--- /dev/null
-upstream_tag = ${upstreamversion}
+ [general]
+ upstream_branch = upstream
++#upstream_tag = ${upstreamversion}
+ packaging_dir = tools/tizen
extlibs/android/sdk/android-sdk-linux
extlibs/android/sdk/android-sdk-macosx
extlibs/android/sdk/android-sdk-windows
- extlibs/boost/boost_1_58_0
+ extlibs/boost/*
-extlibs/tinycbor/tinycbor
+#extlibs/tinycbor/tinycbor
*.tgz
*.zip
extlibs/arduino/arduino-1.5.8
extlibs/tinydtls/dtls-client
extlibs/tinydtls/dtls-server
extlibs/bluez/bluez
-extlibs/mbedtls/mbedtls
++#extlibs/mbedtls/mbedtls
# Ignore editor (e.g. Emacs) backup and autosave files
*~
######################################################################
pc_file = env.get('SRC_DIR') + '/iotivity.pc.in'
- if env.get('ROUTING') == 'GW':
- routing_define = 'ROUTING_GATEWAY'
- elif env.get('ROUTING') == 'EP':
- routing_define = 'ROUTING_EP'
-
user_prefix = env.get('PREFIX')
user_lib = env.get('LIB_INSTALL_DIR')
+
+ if not user_prefix:
+ user_prefix = env.get('BUILD_DIR').encode('string_escape')
+
if not user_lib:
- user_lib = '$${prefix}/lib'
-
- if user_prefix:
- pc_vars = {'\@PREFIX\@': user_prefix,
- '\@EXEC_PREFIX\@':user_prefix,
- '\@VERSION\@': '1.1.1',
- '\@LIB_INSTALL_DIR\@': user_lib,
- '\@ROUTING_DEFINE\@': routing_define
- }
- else:
- pc_vars = {'\@PREFIX\@': env.get('BUILD_DIR'),
- '\@EXEC_PREFIX\@': env.get('BUILD_DIR'),
- '\@VERSION\@': '1.1.1',
- '\@LIB_INSTALL_DIR\@': user_lib,
- '\@ROUTING_DEFINE\@': routing_define
- }
+ user_lib = '$${prefix}/lib'
+
+ defines = []
+ if env.get('LOGGING'):
+ defines.append('-DTB_LOG=1')
+
+ if env.get('ROUTING') == 'GW':
+ defines.append('-DROUTING_GATEWAY=1')
+ elif env.get('ROUTING') == 'EP':
+ defines.append('-DROUTING_EP=1')
+
++if env.get('WITH_TCP'):
++ defines.append('-DTCP_ADAPTER')
++ if env.get('SECURED'):
++ defines.append('-D__WITH_TLS__')
++
++if env.get('SECURED'):
++ defines.append('-D__WITH_DTLS__')
++
++libs = []
++if env.get('SECURED'):
++ libs.append('locpmapi')
++
+ pc_vars = {
+ '\@VERSION\@': project_version,
+ '\@PREFIX\@': user_prefix,
+ '\@EXEC_PREFIX\@': user_prefix,
+ '\@LIB_INSTALL_DIR\@': user_lib,
+ '\@DEFINES\@': " ".join(defines)
+ }
env.Substfile(pc_file, SUBST_DICT = pc_vars)
--- /dev/null
--- /dev/null
++.tag export-subst
++.gitignore export-ignore
++.gitattributes export-ignore
--- /dev/null
--- /dev/null
++# Frequent generated files
++callgrind.out.*
++pcviewer.cfg
++*~
++*.a
++*.la
++*.core
++*.d
++*.dylib
++*.moc
++*.o
++*.obj
++*.orig
++*.swp
++*.rej
++*.so
++*.so.*
++*.pbxuser
++*.mode1
++*.mode1v3
++*_pch.h.cpp
++*_resource.rc
++.#*
++*.*#
++core
++.qmake.cache
++.qmake.stash
++.qmake.vars
++.device.vars
++tags
++.DS_Store
++*.debug
++Makefile*
++*.prl
++*.app
++*.pro.user*
++*.qmlproject.user*
++*.gcov
++*.gcda
++*.gcno
++*.flc
++.*.swp
++tinycbor.pc
++
++# 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
++doc
++lib
++src/cjson
++src/doxygen.log
++!/Makefile
++.config
--- /dev/null
- ddd99e434c45f30c186e320a79bb04856d0b0e5a
++$Format:%H$
--- /dev/null
- sudo apt-add-repository -y ppa:beineri/opt-qt56;
+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-qt561;
+ sudo apt-add-repository -y ppa:ubuntu-toolchain-r/test;
+ sudo apt-get update -qq;
+ sudo apt-get install -y qt56base valgrind g++-5;
+ else
+ brew install qt5;
+ fi
+script:
+ - if [ "${TRAVIS_OS_NAME}" = "linux" ]; then
+ sudo ln -sf g++-5 /usr/bin/g++;
+ fi
+ - make -s -f Makefile.configure configure | tee .config
+ - make
+ CFLAGS="$CFLAGS"
+ all tests/Makefile
+ - cd tests && make check -k
+ TESTRUNNER=`which valgrind 2>/dev/null`
--- /dev/null
--- /dev/null
++# Doxyfile 1.8.8
++
++# This file describes the settings to be used by the documentation system
++# doxygen (www.doxygen.org) for a project.
++#
++# All text after a double hash (##) is considered a comment and is placed in
++# front of the TAG it is preceding.
++#
++# All text after a single hash (#) is considered a comment and will be ignored.
++# The format is:
++# TAG = value [value, ...]
++# For lists, items can also be appended using:
++# TAG += value [value, ...]
++# Values that contain spaces should be placed between quotes (\" \").
++
++#---------------------------------------------------------------------------
++# Project related configuration options
++#---------------------------------------------------------------------------
++
++# This tag specifies the encoding used for all characters in the config file
++# that follow. The default is UTF-8 which is also the encoding used for all text
++# before the first occurrence of this tag. Doxygen uses libiconv (or the iconv
++# built into libc) for the transcoding. See http://www.gnu.org/software/libiconv
++# for the list of possible encodings.
++# The default value is: UTF-8.
++
++DOXYFILE_ENCODING = UTF-8
++
++# The PROJECT_NAME tag is a single word (or a sequence of words surrounded by
++# double-quotes, unless you are using Doxywizard) that should identify the
++# project for which the documentation is generated. This name is used in the
++# title of most generated pages and in a few other places.
++# The default value is: My Project.
++
++PROJECT_NAME = "TinyCBOR $(VERSION) API"
++
++# The PROJECT_NUMBER tag can be used to enter a project or revision number. This
++# could be handy for archiving the generated documentation or if some version
++# control system is used.
++
++PROJECT_NUMBER =
++
++# Using the PROJECT_BRIEF tag one can provide an optional one line description
++# for a project that appears at the top of each page and should give viewer a
++# quick idea about the purpose of the project. Keep the description short.
++
++PROJECT_BRIEF =
++
++# With the PROJECT_LOGO tag one can specify an logo or icon that is included in
++# the documentation. The maximum height of the logo should not exceed 55 pixels
++# and the maximum width should not exceed 200 pixels. Doxygen will copy the logo
++# to the output directory.
++
++PROJECT_LOGO =
++
++# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) path
++# into which the generated documentation will be written. If a relative path is
++# entered, it will be relative to the location where doxygen was started. If
++# left blank the current directory will be used.
++
++OUTPUT_DIRECTORY = ../doc
++
++# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create 4096 sub-
++# directories (in 2 levels) under the output directory of each output format and
++# will distribute the generated files over these directories. Enabling this
++# option can be useful when feeding doxygen a huge amount of source files, where
++# putting all generated files in the same directory would otherwise causes
++# performance problems for the file system.
++# The default value is: NO.
++
++CREATE_SUBDIRS = NO
++
++# If the ALLOW_UNICODE_NAMES tag is set to YES, doxygen will allow non-ASCII
++# characters to appear in the names of generated files. If set to NO, non-ASCII
++# characters will be escaped, for example _xE3_x81_x84 will be used for Unicode
++# U+3044.
++# The default value is: NO.
++
++ALLOW_UNICODE_NAMES = NO
++
++# The OUTPUT_LANGUAGE tag is used to specify the language in which all
++# documentation generated by doxygen is written. Doxygen will use this
++# information to generate all constant output in the proper language.
++# Possible values are: Afrikaans, Arabic, Armenian, Brazilian, Catalan, Chinese,
++# Chinese-Traditional, Croatian, Czech, Danish, Dutch, English (United States),
++# Esperanto, Farsi (Persian), Finnish, French, German, Greek, Hungarian,
++# Indonesian, Italian, Japanese, Japanese-en (Japanese with English messages),
++# Korean, Korean-en (Korean with English messages), Latvian, Lithuanian,
++# Macedonian, Norwegian, Persian (Farsi), Polish, Portuguese, Romanian, Russian,
++# Serbian, Serbian-Cyrillic, Slovak, Slovene, Spanish, Swedish, Turkish,
++# Ukrainian and Vietnamese.
++# The default value is: English.
++
++OUTPUT_LANGUAGE = English
++
++# If the BRIEF_MEMBER_DESC tag is set to YES doxygen will include brief member
++# descriptions after the members that are listed in the file and class
++# documentation (similar to Javadoc). Set to NO to disable this.
++# The default value is: YES.
++
++BRIEF_MEMBER_DESC = YES
++
++# If the REPEAT_BRIEF tag is set to YES doxygen will prepend the brief
++# description of a member or function before the detailed description
++#
++# Note: If both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
++# brief descriptions will be completely suppressed.
++# The default value is: YES.
++
++REPEAT_BRIEF = YES
++
++# This tag implements a quasi-intelligent brief description abbreviator that is
++# used to form the text in various listings. Each string in this list, if found
++# as the leading text of the brief description, will be stripped from the text
++# and the result, after processing the whole list, is used as the annotated
++# text. Otherwise, the brief description is used as-is. If left blank, the
++# following values are used ($name is automatically replaced with the name of
++# the entity):The $name class, The $name widget, The $name file, is, provides,
++# specifies, contains, represents, a, an and the.
++
++ABBREVIATE_BRIEF =
++
++# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
++# doxygen will generate a detailed section even if there is only a brief
++# description.
++# The default value is: NO.
++
++ALWAYS_DETAILED_SEC = NO
++
++# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all
++# inherited members of a class in the documentation of that class as if those
++# members were ordinary class members. Constructors, destructors and assignment
++# operators of the base classes will not be shown.
++# The default value is: NO.
++
++INLINE_INHERITED_MEMB = NO
++
++# If the FULL_PATH_NAMES tag is set to YES doxygen will prepend the full path
++# before files name in the file list and in the header files. If set to NO the
++# shortest path that makes the file name unique will be used
++# The default value is: YES.
++
++FULL_PATH_NAMES = YES
++
++# The STRIP_FROM_PATH tag can be used to strip a user-defined part of the path.
++# Stripping is only done if one of the specified strings matches the left-hand
++# part of the path. The tag can be used to show relative paths in the file list.
++# If left blank the directory from which doxygen is run is used as the path to
++# strip.
++#
++# Note that you can specify absolute paths here, but also relative paths, which
++# will be relative from the directory where doxygen is started.
++# This tag requires that the tag FULL_PATH_NAMES is set to YES.
++
++STRIP_FROM_PATH = $(docroot)
++
++# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of the
++# path mentioned in the documentation of a class, which tells the reader which
++# header file to include in order to use a class. If left blank only the name of
++# the header file containing the class definition is used. Otherwise one should
++# specify the list of include paths that are normally passed to the compiler
++# using the -I flag.
++
++STRIP_FROM_INC_PATH = $(docroot)
++
++# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter (but
++# less readable) file names. This can be useful is your file systems doesn't
++# support long names like on DOS, Mac, or CD-ROM.
++# The default value is: NO.
++
++SHORT_NAMES = YES
++
++# If the JAVADOC_AUTOBRIEF tag is set to YES then doxygen will interpret the
++# first line (until the first dot) of a Javadoc-style comment as the brief
++# description. If set to NO, the Javadoc-style will behave just like regular Qt-
++# style comments (thus requiring an explicit @brief command for a brief
++# description.)
++# The default value is: NO.
++
++JAVADOC_AUTOBRIEF = YES
++
++# If the QT_AUTOBRIEF tag is set to YES then doxygen will interpret the first
++# line (until the first dot) of a Qt-style comment as the brief description. If
++# set to NO, the Qt-style will behave just like regular Qt-style comments (thus
++# requiring an explicit \brief command for a brief description.)
++# The default value is: NO.
++
++QT_AUTOBRIEF = YES
++
++# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make doxygen treat a
++# multi-line C++ special comment block (i.e. a block of //! or /// comments) as
++# a brief description. This used to be the default behavior. The new default is
++# to treat a multi-line C++ comment block as a detailed description. Set this
++# tag to YES if you prefer the old behavior instead.
++#
++# Note that setting this tag to YES also means that rational rose comments are
++# not recognized any more.
++# The default value is: NO.
++
++MULTILINE_CPP_IS_BRIEF = NO
++
++# If the INHERIT_DOCS tag is set to YES then an undocumented member inherits the
++# documentation from any documented member that it re-implements.
++# The default value is: YES.
++
++INHERIT_DOCS = YES
++
++# If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce a
++# new page for each member. If set to NO, the documentation of a member will be
++# part of the file/class/namespace that contains it.
++# The default value is: NO.
++
++SEPARATE_MEMBER_PAGES = NO
++
++# The TAB_SIZE tag can be used to set the number of spaces in a tab. Doxygen
++# uses this value to replace tabs by spaces in code fragments.
++# Minimum value: 1, maximum value: 16, default value: 4.
++
++TAB_SIZE = 8
++
++# This tag can be used to specify a number of aliases that act as commands in
++# the documentation. An alias has the form:
++# name=value
++# For example adding
++# "sideeffect=@par Side Effects:\n"
++# will allow you to put the command \sideeffect (or @sideeffect) in the
++# documentation, which will result in a user-defined paragraph with heading
++# "Side Effects:". You can put \n's in the value part of an alias to insert
++# newlines.
++
++ALIASES = "value=\arg \c"
++
++# This tag can be used to specify a number of word-keyword mappings (TCL only).
++# A mapping has the form "name=value". For example adding "class=itcl::class"
++# will allow you to use the command class in the itcl::class meaning.
++
++TCL_SUBST =
++
++# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources
++# only. Doxygen will then generate output that is more tailored for C. For
++# instance, some of the names that are used will be different. The list of all
++# members will be omitted, etc.
++# The default value is: NO.
++
++OPTIMIZE_OUTPUT_FOR_C = YES
++
++# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java or
++# Python sources only. Doxygen will then generate output that is more tailored
++# for that language. For instance, namespaces will be presented as packages,
++# qualified scopes will look different, etc.
++# The default value is: NO.
++
++OPTIMIZE_OUTPUT_JAVA = NO
++
++# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran
++# sources. Doxygen will then generate output that is tailored for Fortran.
++# The default value is: NO.
++
++OPTIMIZE_FOR_FORTRAN = NO
++
++# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL
++# sources. Doxygen will then generate output that is tailored for VHDL.
++# The default value is: NO.
++
++OPTIMIZE_OUTPUT_VHDL = NO
++
++# Doxygen selects the parser to use depending on the extension of the files it
++# parses. With this tag you can assign which parser to use for a given
++# extension. Doxygen has a built-in mapping, but you can override or extend it
++# using this tag. The format is ext=language, where ext is a file extension, and
++# language is one of the parsers supported by doxygen: IDL, Java, Javascript,
++# C#, C, C++, D, PHP, Objective-C, Python, Fortran (fixed format Fortran:
++# FortranFixed, free formatted Fortran: FortranFree, unknown formatted Fortran:
++# Fortran. In the later case the parser tries to guess whether the code is fixed
++# or free formatted code, this is the default for Fortran type files), VHDL. For
++# instance to make doxygen treat .inc files as Fortran files (default is PHP),
++# and .f files as C (default is Fortran), use: inc=Fortran f=C.
++#
++# Note For files without extension you can use no_extension as a placeholder.
++#
++# Note that for custom extensions you also need to set FILE_PATTERNS otherwise
++# the files are not read by doxygen.
++
++EXTENSION_MAPPING =
++
++# If the MARKDOWN_SUPPORT tag is enabled then doxygen pre-processes all comments
++# according to the Markdown format, which allows for more readable
++# documentation. See http://daringfireball.net/projects/markdown/ for details.
++# The output of markdown processing is further processed by doxygen, so you can
++# mix doxygen, HTML, and XML commands with Markdown formatting. Disable only in
++# case of backward compatibilities issues.
++# The default value is: YES.
++
++MARKDOWN_SUPPORT = YES
++
++# When enabled doxygen tries to link words that correspond to documented
++# classes, or namespaces to their corresponding documentation. Such a link can
++# be prevented in individual cases by by putting a % sign in front of the word
++# or globally by setting AUTOLINK_SUPPORT to NO.
++# The default value is: YES.
++
++AUTOLINK_SUPPORT = YES
++
++# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want
++# to include (a tag file for) the STL sources as input, then you should set this
++# tag to YES in order to let doxygen match functions declarations and
++# definitions whose arguments contain STL classes (e.g. func(std::string);
++# versus func(std::string) {}). This also make the inheritance and collaboration
++# diagrams that involve STL classes more complete and accurate.
++# The default value is: NO.
++
++BUILTIN_STL_SUPPORT = NO
++
++# If you use Microsoft's C++/CLI language, you should set this option to YES to
++# enable parsing support.
++# The default value is: NO.
++
++CPP_CLI_SUPPORT = NO
++
++# Set the SIP_SUPPORT tag to YES if your project consists of sip (see:
++# http://www.riverbankcomputing.co.uk/software/sip/intro) sources only. Doxygen
++# will parse them like normal C++ but will assume all classes use public instead
++# of private inheritance when no explicit protection keyword is present.
++# The default value is: NO.
++
++SIP_SUPPORT = NO
++
++# For Microsoft's IDL there are propget and propput attributes to indicate
++# getter and setter methods for a property. Setting this option to YES will make
++# doxygen to replace the get and set methods by a property in the documentation.
++# This will only work if the methods are indeed getting or setting a simple
++# type. If this is not the case, or you want to show the methods anyway, you
++# should set this option to NO.
++# The default value is: YES.
++
++IDL_PROPERTY_SUPPORT = YES
++
++# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
++# tag is set to YES, then doxygen will reuse the documentation of the first
++# member in the group (if any) for the other members of the group. By default
++# all members of a group must be documented explicitly.
++# The default value is: NO.
++
++DISTRIBUTE_GROUP_DOC = NO
++
++# Set the SUBGROUPING tag to YES to allow class member groups of the same type
++# (for instance a group of public functions) to be put as a subgroup of that
++# type (e.g. under the Public Functions section). Set it to NO to prevent
++# subgrouping. Alternatively, this can be done per class using the
++# \nosubgrouping command.
++# The default value is: YES.
++
++SUBGROUPING = YES
++
++# When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and unions
++# are shown inside the group in which they are included (e.g. using \ingroup)
++# instead of on a separate page (for HTML and Man pages) or section (for LaTeX
++# and RTF).
++#
++# Note that this feature does not work in combination with
++# SEPARATE_MEMBER_PAGES.
++# The default value is: NO.
++
++INLINE_GROUPED_CLASSES = NO
++
++# When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and unions
++# with only public data fields or simple typedef fields will be shown inline in
++# the documentation of the scope in which they are defined (i.e. file,
++# namespace, or group documentation), provided this scope is documented. If set
++# to NO, structs, classes, and unions are shown on a separate page (for HTML and
++# Man pages) or section (for LaTeX and RTF).
++# The default value is: NO.
++
++INLINE_SIMPLE_STRUCTS = NO
++
++# When TYPEDEF_HIDES_STRUCT tag is enabled, a typedef of a struct, union, or
++# enum is documented as struct, union, or enum with the name of the typedef. So
++# typedef struct TypeS {} TypeT, will appear in the documentation as a struct
++# with name TypeT. When disabled the typedef will appear as a member of a file,
++# namespace, or class. And the struct will be named TypeS. This can typically be
++# useful for C code in case the coding convention dictates that all compound
++# types are typedef'ed and only the typedef is referenced, never the tag name.
++# The default value is: NO.
++
++TYPEDEF_HIDES_STRUCT = NO
++
++# The size of the symbol lookup cache can be set using LOOKUP_CACHE_SIZE. This
++# cache is used to resolve symbols given their name and scope. Since this can be
++# an expensive process and often the same symbol appears multiple times in the
++# code, doxygen keeps a cache of pre-resolved symbols. If the cache is too small
++# doxygen will become slower. If the cache is too large, memory is wasted. The
++# cache size is given by this formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range
++# is 0..9, the default is 0, corresponding to a cache size of 2^16=65536
++# symbols. At the end of a run doxygen will report the cache usage and suggest
++# the optimal cache size from a speed point of view.
++# Minimum value: 0, maximum value: 9, default value: 0.
++
++LOOKUP_CACHE_SIZE = 0
++
++#---------------------------------------------------------------------------
++# Build related configuration options
++#---------------------------------------------------------------------------
++
++# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in
++# documentation are documented, even if no documentation was available. Private
++# class members and static file members will be hidden unless the
++# EXTRACT_PRIVATE respectively EXTRACT_STATIC tags are set to YES.
++# Note: This will also disable the warnings about undocumented members that are
++# normally produced when WARNINGS is set to YES.
++# The default value is: NO.
++
++EXTRACT_ALL = NO
++
++# If the EXTRACT_PRIVATE tag is set to YES all private members of a class will
++# be included in the documentation.
++# The default value is: NO.
++
++EXTRACT_PRIVATE = NO
++
++# If the EXTRACT_PACKAGE tag is set to YES all members with package or internal
++# scope will be included in the documentation.
++# The default value is: NO.
++
++EXTRACT_PACKAGE = NO
++
++# If the EXTRACT_STATIC tag is set to YES all static members of a file will be
++# included in the documentation.
++# The default value is: NO.
++
++EXTRACT_STATIC = YES
++
++# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs) defined
++# locally in source files will be included in the documentation. If set to NO
++# only classes defined in header files are included. Does not have any effect
++# for Java sources.
++# The default value is: YES.
++
++EXTRACT_LOCAL_CLASSES = NO
++
++# This flag is only useful for Objective-C code. When set to YES local methods,
++# which are defined in the implementation section but not in the interface are
++# included in the documentation. If set to NO only methods in the interface are
++# included.
++# The default value is: NO.
++
++EXTRACT_LOCAL_METHODS = NO
++
++# If this flag is set to YES, the members of anonymous namespaces will be
++# extracted and appear in the documentation as a namespace called
++# 'anonymous_namespace{file}', where file will be replaced with the base name of
++# the file that contains the anonymous namespace. By default anonymous namespace
++# are hidden.
++# The default value is: NO.
++
++EXTRACT_ANON_NSPACES = NO
++
++# If the HIDE_UNDOC_MEMBERS tag is set to YES, doxygen will hide all
++# undocumented members inside documented classes or files. If set to NO these
++# members will be included in the various overviews, but no documentation
++# section is generated. This option has no effect if EXTRACT_ALL is enabled.
++# The default value is: NO.
++
++HIDE_UNDOC_MEMBERS = YES
++
++# If the HIDE_UNDOC_CLASSES tag is set to YES, doxygen will hide all
++# undocumented classes that are normally visible in the class hierarchy. If set
++# to NO these classes will be included in the various overviews. This option has
++# no effect if EXTRACT_ALL is enabled.
++# The default value is: NO.
++
++HIDE_UNDOC_CLASSES = YES
++
++# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, doxygen will hide all friend
++# (class|struct|union) declarations. If set to NO these declarations will be
++# included in the documentation.
++# The default value is: NO.
++
++HIDE_FRIEND_COMPOUNDS = NO
++
++# If the HIDE_IN_BODY_DOCS tag is set to YES, doxygen will hide any
++# documentation blocks found inside the body of a function. If set to NO these
++# blocks will be appended to the function's detailed documentation block.
++# The default value is: NO.
++
++HIDE_IN_BODY_DOCS = NO
++
++# The INTERNAL_DOCS tag determines if documentation that is typed after a
++# \internal command is included. If the tag is set to NO then the documentation
++# will be excluded. Set it to YES to include the internal documentation.
++# The default value is: NO.
++
++INTERNAL_DOCS = NO
++
++# If the CASE_SENSE_NAMES tag is set to NO then doxygen will only generate file
++# names in lower-case letters. If set to YES upper-case letters are also
++# allowed. This is useful if you have classes or files whose names only differ
++# in case and if your file system supports case sensitive file names. Windows
++# and Mac users are advised to set this option to NO.
++# The default value is: system dependent.
++
++CASE_SENSE_NAMES = YES
++
++# If the HIDE_SCOPE_NAMES tag is set to NO then doxygen will show members with
++# their full class and namespace scopes in the documentation. If set to YES the
++# scope will be hidden.
++# The default value is: NO.
++
++HIDE_SCOPE_NAMES = NO
++
++# If the SHOW_INCLUDE_FILES tag is set to YES then doxygen will put a list of
++# the files that are included by a file in the documentation of that file.
++# The default value is: YES.
++
++SHOW_INCLUDE_FILES = YES
++
++# If the SHOW_GROUPED_MEMB_INC tag is set to YES then Doxygen will add for each
++# grouped member an include statement to the documentation, telling the reader
++# which file to include in order to use the member.
++# The default value is: NO.
++
++SHOW_GROUPED_MEMB_INC = NO
++
++# If the FORCE_LOCAL_INCLUDES tag is set to YES then doxygen will list include
++# files with double quotes in the documentation rather than with sharp brackets.
++# The default value is: NO.
++
++FORCE_LOCAL_INCLUDES = NO
++
++# If the INLINE_INFO tag is set to YES then a tag [inline] is inserted in the
++# documentation for inline members.
++# The default value is: YES.
++
++INLINE_INFO = YES
++
++# If the SORT_MEMBER_DOCS tag is set to YES then doxygen will sort the
++# (detailed) documentation of file and class members alphabetically by member
++# name. If set to NO the members will appear in declaration order.
++# The default value is: YES.
++
++SORT_MEMBER_DOCS = YES
++
++# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the brief
++# descriptions of file, namespace and class members alphabetically by member
++# name. If set to NO the members will appear in declaration order. Note that
++# this will also influence the order of the classes in the class list.
++# The default value is: NO.
++
++SORT_BRIEF_DOCS = NO
++
++# If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen will sort the
++# (brief and detailed) documentation of class members so that constructors and
++# destructors are listed first. If set to NO the constructors will appear in the
++# respective orders defined by SORT_BRIEF_DOCS and SORT_MEMBER_DOCS.
++# Note: If SORT_BRIEF_DOCS is set to NO this option is ignored for sorting brief
++# member documentation.
++# Note: If SORT_MEMBER_DOCS is set to NO this option is ignored for sorting
++# detailed member documentation.
++# The default value is: NO.
++
++SORT_MEMBERS_CTORS_1ST = NO
++
++# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the hierarchy
++# of group names into alphabetical order. If set to NO the group names will
++# appear in their defined order.
++# The default value is: NO.
++
++SORT_GROUP_NAMES = NO
++
++# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be sorted by
++# fully-qualified names, including namespaces. If set to NO, the class list will
++# be sorted only by class name, not including the namespace part.
++# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
++# Note: This option applies only to the class list, not to the alphabetical
++# list.
++# The default value is: NO.
++
++SORT_BY_SCOPE_NAME = NO
++
++# If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to do proper
++# type resolution of all parameters of a function it will reject a match between
++# the prototype and the implementation of a member function even if there is
++# only one candidate or it is obvious which candidate to choose by doing a
++# simple string match. By disabling STRICT_PROTO_MATCHING doxygen will still
++# accept a match between prototype and implementation in such cases.
++# The default value is: NO.
++
++STRICT_PROTO_MATCHING = NO
++
++# The GENERATE_TODOLIST tag can be used to enable ( YES) or disable ( NO) the
++# todo list. This list is created by putting \todo commands in the
++# documentation.
++# The default value is: YES.
++
++GENERATE_TODOLIST = NO
++
++# The GENERATE_TESTLIST tag can be used to enable ( YES) or disable ( NO) the
++# test list. This list is created by putting \test commands in the
++# documentation.
++# The default value is: YES.
++
++GENERATE_TESTLIST = NO
++
++# The GENERATE_BUGLIST tag can be used to enable ( YES) or disable ( NO) the bug
++# list. This list is created by putting \bug commands in the documentation.
++# The default value is: YES.
++
++GENERATE_BUGLIST = NO
++
++# The GENERATE_DEPRECATEDLIST tag can be used to enable ( YES) or disable ( NO)
++# the deprecated list. This list is created by putting \deprecated commands in
++# the documentation.
++# The default value is: YES.
++
++GENERATE_DEPRECATEDLIST= NO
++
++# The ENABLED_SECTIONS tag can be used to enable conditional documentation
++# sections, marked by \if <section_label> ... \endif and \cond <section_label>
++# ... \endcond blocks.
++
++ENABLED_SECTIONS =
++
++# The MAX_INITIALIZER_LINES tag determines the maximum number of lines that the
++# initial value of a variable or macro / define can have for it to appear in the
++# documentation. If the initializer consists of more lines than specified here
++# it will be hidden. Use a value of 0 to hide initializers completely. The
++# appearance of the value of individual variables and macros / defines can be
++# controlled using \showinitializer or \hideinitializer command in the
++# documentation regardless of this setting.
++# Minimum value: 0, maximum value: 10000, default value: 30.
++
++MAX_INITIALIZER_LINES = 30
++
++# Set the SHOW_USED_FILES tag to NO to disable the list of files generated at
++# the bottom of the documentation of classes and structs. If set to YES the list
++# will mention the files that were used to generate the documentation.
++# The default value is: YES.
++
++SHOW_USED_FILES = NO
++
++# Set the SHOW_FILES tag to NO to disable the generation of the Files page. This
++# will remove the Files entry from the Quick Index and from the Folder Tree View
++# (if specified).
++# The default value is: YES.
++
++SHOW_FILES = YES
++
++# Set the SHOW_NAMESPACES tag to NO to disable the generation of the Namespaces
++# page. This will remove the Namespaces entry from the Quick Index and from the
++# Folder Tree View (if specified).
++# The default value is: YES.
++
++SHOW_NAMESPACES = YES
++
++# The FILE_VERSION_FILTER tag can be used to specify a program or script that
++# doxygen should invoke to get the current version for each file (typically from
++# the version control system). Doxygen will invoke the program by executing (via
++# popen()) the command command input-file, where command is the value of the
++# FILE_VERSION_FILTER tag, and input-file is the name of an input file provided
++# by doxygen. Whatever the program writes to standard output is used as the file
++# version. For an example see the documentation.
++
++FILE_VERSION_FILTER =
++
++# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed
++# by doxygen. The layout file controls the global structure of the generated
++# output files in an output format independent way. To create the layout file
++# that represents doxygen's defaults, run doxygen with the -l option. You can
++# optionally specify a file name after the option, if omitted DoxygenLayout.xml
++# will be used as the name of the layout file.
++#
++# Note that if you run doxygen from a directory containing a file called
++# DoxygenLayout.xml, doxygen will parse it automatically even if the LAYOUT_FILE
++# tag is left empty.
++
++LAYOUT_FILE =
++
++# The CITE_BIB_FILES tag can be used to specify one or more bib files containing
++# the reference definitions. This must be a list of .bib files. The .bib
++# extension is automatically appended if omitted. This requires the bibtex tool
++# to be installed. See also http://en.wikipedia.org/wiki/BibTeX for more info.
++# For LaTeX the style of the bibliography can be controlled using
++# LATEX_BIB_STYLE. To use this feature you need bibtex and perl available in the
++# search path. See also \cite for info how to create references.
++
++CITE_BIB_FILES =
++
++#---------------------------------------------------------------------------
++# Configuration options related to warning and progress messages
++#---------------------------------------------------------------------------
++
++# The QUIET tag can be used to turn on/off the messages that are generated to
++# standard output by doxygen. If QUIET is set to YES this implies that the
++# messages are off.
++# The default value is: NO.
++
++QUIET = NO
++
++# The WARNINGS tag can be used to turn on/off the warning messages that are
++# generated to standard error ( stderr) by doxygen. If WARNINGS is set to YES
++# this implies that the warnings are on.
++#
++# Tip: Turn warnings on while writing the documentation.
++# The default value is: YES.
++
++WARNINGS = YES
++
++# If the WARN_IF_UNDOCUMENTED tag is set to YES, then doxygen will generate
++# warnings for undocumented members. If EXTRACT_ALL is set to YES then this flag
++# will automatically be disabled.
++# The default value is: YES.
++
++WARN_IF_UNDOCUMENTED = NO
++
++# If the WARN_IF_DOC_ERROR tag is set to YES, doxygen will generate warnings for
++# potential errors in the documentation, such as not documenting some parameters
++# in a documented function, or documenting parameters that don't exist or using
++# markup commands wrongly.
++# The default value is: YES.
++
++WARN_IF_DOC_ERROR = YES
++
++# This WARN_NO_PARAMDOC option can be enabled to get warnings for functions that
++# are documented, but have no documentation for their parameters or return
++# value. If set to NO doxygen will only warn about wrong or incomplete parameter
++# documentation, but not about the absence of documentation.
++# The default value is: NO.
++
++WARN_NO_PARAMDOC = NO
++
++# The WARN_FORMAT tag determines the format of the warning messages that doxygen
++# can produce. The string should contain the $file, $line, and $text tags, which
++# will be replaced by the file and line number from which the warning originated
++# and the warning text. Optionally the format may contain $version, which will
++# be replaced by the version of the file (if it could be obtained via
++# FILE_VERSION_FILTER)
++# The default value is: $file:$line: $text.
++
++WARN_FORMAT = "$file:$line: $text"
++
++# The WARN_LOGFILE tag can be used to specify a file to which warning and error
++# messages should be written. If left blank the output is written to standard
++# error (stderr).
++
++WARN_LOGFILE = doxygen.log
++
++#---------------------------------------------------------------------------
++# Configuration options related to the input files
++#---------------------------------------------------------------------------
++
++# The INPUT tag is used to specify the files and/or directories that contain
++# documented source files. You may enter file names like myfile.cpp or
++# directories like /usr/src/myproject. Separate the files or directories with
++# spaces.
++# Note: If this tag is empty the current directory is searched.
++
++INPUT = .
++
++# This tag can be used to specify the character encoding of the source files
++# that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses
++# libiconv (or the iconv built into libc) for the transcoding. See the libiconv
++# documentation (see: http://www.gnu.org/software/libiconv) for the list of
++# possible encodings.
++# The default value is: UTF-8.
++
++INPUT_ENCODING = UTF-8
++
++# If the value of the INPUT tag contains directories, you can use the
++# FILE_PATTERNS tag to specify one or more wildcard patterns (like *.cpp and
++# *.h) to filter out the source-files in the directories. If left blank the
++# following patterns are tested:*.c, *.cc, *.cxx, *.cpp, *.c++, *.java, *.ii,
++# *.ixx, *.ipp, *.i++, *.inl, *.idl, *.ddl, *.odl, *.h, *.hh, *.hxx, *.hpp,
++# *.h++, *.cs, *.d, *.php, *.php4, *.php5, *.phtml, *.inc, *.m, *.markdown,
++# *.md, *.mm, *.dox, *.py, *.f90, *.f, *.for, *.tcl, *.vhd, *.vhdl, *.ucf,
++# *.qsf, *.as and *.js.
++
++FILE_PATTERNS = *.h \
++ *.c \
++ *.dox
++
++# The RECURSIVE tag can be used to specify whether or not subdirectories should
++# be searched for input files as well.
++# The default value is: NO.
++
++RECURSIVE = NO
++
++# The EXCLUDE tag can be used to specify files and/or directories that should be
++# excluded from the INPUT source files. This way you can easily exclude a
++# subdirectory from a directory tree whose root is specified with the INPUT tag.
++#
++# Note that relative paths are relative to the directory from which doxygen is
++# run.
++
++EXCLUDE =
++
++# The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
++# directories that are symbolic links (a Unix file system feature) are excluded
++# from the input.
++# The default value is: NO.
++
++EXCLUDE_SYMLINKS = NO
++
++# If the value of the INPUT tag contains directories, you can use the
++# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
++# certain files from those directories.
++#
++# Note that the wildcards are matched against the file with absolute path, so to
++# exclude all test directories for example use the pattern */test/*
++
++EXCLUDE_PATTERNS = *_p.h
++
++# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
++# (namespaces, classes, functions, etc.) that should be excluded from the
++# output. The symbol name can be a fully qualified name, a word, or if the
++# wildcard * is used, a substring. Examples: ANamespace, AClass,
++# AClass::ANamespace, ANamespace::*Test
++#
++# Note that the wildcards are matched against the file with absolute path, so to
++# exclude all test directories use the pattern */test/*
++
++EXCLUDE_SYMBOLS =
++
++# The EXAMPLE_PATH tag can be used to specify one or more files or directories
++# that contain example code fragments that are included (see the \include
++# command).
++
++EXAMPLE_PATH = . \
++ ../examples/rime \
++ ../examples/multi-threading
++
++# If the value of the EXAMPLE_PATH tag contains directories, you can use the
++# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp and
++# *.h) to filter out the source-files in the directories. If left blank all
++# files are included.
++
++EXAMPLE_PATTERNS =
++
++# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be
++# searched for input files to be used with the \include or \dontinclude commands
++# irrespective of the value of the RECURSIVE tag.
++# The default value is: NO.
++
++EXAMPLE_RECURSIVE = NO
++
++# The IMAGE_PATH tag can be used to specify one or more files or directories
++# that contain images that are to be included in the documentation (see the
++# \image command).
++
++IMAGE_PATH = pics
++
++# The INPUT_FILTER tag can be used to specify a program that doxygen should
++# invoke to filter for each input file. Doxygen will invoke the filter program
++# by executing (via popen()) the command:
++#
++# <filter> <input-file>
++#
++# where <filter> is the value of the INPUT_FILTER tag, and <input-file> is the
++# name of an input file. Doxygen will then use the output that the filter
++# program writes to standard output. If FILTER_PATTERNS is specified, this tag
++# will be ignored.
++#
++# Note that the filter must not add or remove lines; it is applied before the
++# code is scanned, but not when the output code is generated. If lines are added
++# or removed, the anchors will not be placed correctly.
++
++INPUT_FILTER =
++
++# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern
++# basis. Doxygen will compare the file name with each pattern and apply the
++# filter if there is a match. The filters are a list of the form: pattern=filter
++# (like *.cpp=my_cpp_filter). See INPUT_FILTER for further information on how
++# filters are used. If the FILTER_PATTERNS tag is empty or if none of the
++# patterns match the file name, INPUT_FILTER is applied.
++
++FILTER_PATTERNS =
++
++# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
++# INPUT_FILTER ) will also be used to filter the input files that are used for
++# producing the source files to browse (i.e. when SOURCE_BROWSER is set to YES).
++# The default value is: NO.
++
++FILTER_SOURCE_FILES = NO
++
++# The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file
++# pattern. A pattern will override the setting for FILTER_PATTERN (if any) and
++# it is also possible to disable source filtering for a specific pattern using
++# *.ext= (so without naming a filter).
++# This tag requires that the tag FILTER_SOURCE_FILES is set to YES.
++
++FILTER_SOURCE_PATTERNS =
++
++# If the USE_MDFILE_AS_MAINPAGE tag refers to the name of a markdown file that
++# is part of the input, its contents will be placed on the main page
++# (index.html). This can be useful if you have a project on for instance GitHub
++# and want to reuse the introduction page also for the doxygen output.
++
++USE_MDFILE_AS_MAINPAGE =
++
++#---------------------------------------------------------------------------
++# Configuration options related to source browsing
++#---------------------------------------------------------------------------
++
++# If the SOURCE_BROWSER tag is set to YES then a list of source files will be
++# generated. Documented entities will be cross-referenced with these sources.
++#
++# Note: To get rid of all source code in the generated output, make sure that
++# also VERBATIM_HEADERS is set to NO.
++# The default value is: NO.
++
++SOURCE_BROWSER = NO
++
++# Setting the INLINE_SOURCES tag to YES will include the body of functions,
++# classes and enums directly into the documentation.
++# The default value is: NO.
++
++INLINE_SOURCES = NO
++
++# Setting the STRIP_CODE_COMMENTS tag to YES will instruct doxygen to hide any
++# special comment blocks from generated source code fragments. Normal C, C++ and
++# Fortran comments will always remain visible.
++# The default value is: YES.
++
++STRIP_CODE_COMMENTS = NO
++
++# If the REFERENCED_BY_RELATION tag is set to YES then for each documented
++# function all documented functions referencing it will be listed.
++# The default value is: NO.
++
++REFERENCED_BY_RELATION = YES
++
++# If the REFERENCES_RELATION tag is set to YES then for each documented function
++# all documented entities called/used by that function will be listed.
++# The default value is: NO.
++
++REFERENCES_RELATION = NO
++
++# If the REFERENCES_LINK_SOURCE tag is set to YES and SOURCE_BROWSER tag is set
++# to YES, then the hyperlinks from functions in REFERENCES_RELATION and
++# REFERENCED_BY_RELATION lists will link to the source code. Otherwise they will
++# link to the documentation.
++# The default value is: YES.
++
++REFERENCES_LINK_SOURCE = YES
++
++# If SOURCE_TOOLTIPS is enabled (the default) then hovering a hyperlink in the
++# source code will show a tooltip with additional information such as prototype,
++# brief description and links to the definition and documentation. Since this
++# will make the HTML file larger and loading of large files a bit slower, you
++# can opt to disable this feature.
++# The default value is: YES.
++# This tag requires that the tag SOURCE_BROWSER is set to YES.
++
++SOURCE_TOOLTIPS = YES
++
++# If the USE_HTAGS tag is set to YES then the references to source code will
++# point to the HTML generated by the htags(1) tool instead of doxygen built-in
++# source browser. The htags tool is part of GNU's global source tagging system
++# (see http://www.gnu.org/software/global/global.html). You will need version
++# 4.8.6 or higher.
++#
++# To use it do the following:
++# - Install the latest version of global
++# - Enable SOURCE_BROWSER and USE_HTAGS in the config file
++# - Make sure the INPUT points to the root of the source tree
++# - Run doxygen as normal
++#
++# Doxygen will invoke htags (and that will in turn invoke gtags), so these
++# tools must be available from the command line (i.e. in the search path).
++#
++# The result: instead of the source browser generated by doxygen, the links to
++# source code will now point to the output of htags.
++# The default value is: NO.
++# This tag requires that the tag SOURCE_BROWSER is set to YES.
++
++USE_HTAGS = NO
++
++# If the VERBATIM_HEADERS tag is set the YES then doxygen will generate a
++# verbatim copy of the header file for each class for which an include is
++# specified. Set to NO to disable this.
++# See also: Section \class.
++# The default value is: YES.
++
++VERBATIM_HEADERS = YES
++
++#---------------------------------------------------------------------------
++# Configuration options related to the alphabetical class index
++#---------------------------------------------------------------------------
++
++# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index of all
++# compounds will be generated. Enable this if the project contains a lot of
++# classes, structs, unions or interfaces.
++# The default value is: YES.
++
++ALPHABETICAL_INDEX = YES
++
++# The COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns in
++# which the alphabetical index list will be split.
++# Minimum value: 1, maximum value: 20, default value: 5.
++# This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
++
++COLS_IN_ALPHA_INDEX = 5
++
++# In case all classes in a project start with a common prefix, all classes will
++# be put under the same header in the alphabetical index. The IGNORE_PREFIX tag
++# can be used to specify a prefix (or a list of prefixes) that should be ignored
++# while generating the index headers.
++# This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
++
++IGNORE_PREFIX = cbor_ Cbor
++
++#---------------------------------------------------------------------------
++# Configuration options related to the HTML output
++#---------------------------------------------------------------------------
++
++# If the GENERATE_HTML tag is set to YES doxygen will generate HTML output
++# The default value is: YES.
++
++GENERATE_HTML = YES
++
++# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. If a
++# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
++# it.
++# The default directory is: html.
++# This tag requires that the tag GENERATE_HTML is set to YES.
++
++HTML_OUTPUT = html
++
++# The HTML_FILE_EXTENSION tag can be used to specify the file extension for each
++# generated HTML page (for example: .htm, .php, .asp).
++# The default value is: .html.
++# This tag requires that the tag GENERATE_HTML is set to YES.
++
++HTML_FILE_EXTENSION = .html
++
++# The HTML_HEADER tag can be used to specify a user-defined HTML header file for
++# each generated HTML page. If the tag is left blank doxygen will generate a
++# standard header.
++#
++# To get valid HTML the header file that includes any scripts and style sheets
++# that doxygen needs, which is dependent on the configuration options used (e.g.
++# the setting GENERATE_TREEVIEW). It is highly recommended to start with a
++# default header using
++# doxygen -w html new_header.html new_footer.html new_stylesheet.css
++# YourConfigFile
++# and then modify the file new_header.html. See also section "Doxygen usage"
++# for information on how to generate the default header that doxygen normally
++# uses.
++# Note: The header is subject to change so you typically have to regenerate the
++# default header when upgrading to a newer version of doxygen. For a description
++# of the possible markers and block names see the documentation.
++# This tag requires that the tag GENERATE_HTML is set to YES.
++
++HTML_HEADER =
++
++# The HTML_FOOTER tag can be used to specify a user-defined HTML footer for each
++# generated HTML page. If the tag is left blank doxygen will generate a standard
++# footer. See HTML_HEADER for more information on how to generate a default
++# footer and what special commands can be used inside the footer. See also
++# section "Doxygen usage" for information on how to generate the default footer
++# that doxygen normally uses.
++# This tag requires that the tag GENERATE_HTML is set to YES.
++
++HTML_FOOTER =
++
++# The HTML_STYLESHEET tag can be used to specify a user-defined cascading style
++# sheet that is used by each HTML page. It can be used to fine-tune the look of
++# the HTML output. If left blank doxygen will generate a default style sheet.
++# See also section "Doxygen usage" for information on how to generate the style
++# sheet that doxygen normally uses.
++# Note: It is recommended to use HTML_EXTRA_STYLESHEET instead of this tag, as
++# it is more robust and this tag (HTML_STYLESHEET) will in the future become
++# obsolete.
++# This tag requires that the tag GENERATE_HTML is set to YES.
++
++HTML_STYLESHEET =
++
++# The HTML_EXTRA_STYLESHEET tag can be used to specify additional user-defined
++# cascading style sheets that are included after the standard style sheets
++# created by doxygen. Using this option one can overrule certain style aspects.
++# This is preferred over using HTML_STYLESHEET since it does not replace the
++# standard style sheet and is therefor more robust against future updates.
++# Doxygen will copy the style sheet files to the output directory.
++# Note: The order of the extra stylesheet files is of importance (e.g. the last
++# stylesheet in the list overrules the setting of the previous ones in the
++# list). For an example see the documentation.
++# This tag requires that the tag GENERATE_HTML is set to YES.
++
++HTML_EXTRA_STYLESHEET =
++
++# The HTML_EXTRA_FILES tag can be used to specify one or more extra images or
++# other source files which should be copied to the HTML output directory. Note
++# that these files will be copied to the base HTML output directory. Use the
++# $relpath^ marker in the HTML_HEADER and/or HTML_FOOTER files to load these
++# files. In the HTML_STYLESHEET file, use the file name only. Also note that the
++# files will be copied as-is; there are no commands or markers available.
++# This tag requires that the tag GENERATE_HTML is set to YES.
++
++HTML_EXTRA_FILES =
++
++# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. Doxygen
++# will adjust the colors in the stylesheet and background images according to
++# this color. Hue is specified as an angle on a colorwheel, see
++# http://en.wikipedia.org/wiki/Hue for more information. For instance the value
++# 0 represents red, 60 is yellow, 120 is green, 180 is cyan, 240 is blue, 300
++# purple, and 360 is red again.
++# Minimum value: 0, maximum value: 359, default value: 220.
++# This tag requires that the tag GENERATE_HTML is set to YES.
++
++HTML_COLORSTYLE_HUE = 220
++
++# The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of the colors
++# in the HTML output. For a value of 0 the output will use grayscales only. A
++# value of 255 will produce the most vivid colors.
++# Minimum value: 0, maximum value: 255, default value: 100.
++# This tag requires that the tag GENERATE_HTML is set to YES.
++
++HTML_COLORSTYLE_SAT = 100
++
++# The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to the
++# luminance component of the colors in the HTML output. Values below 100
++# gradually make the output lighter, whereas values above 100 make the output
++# darker. The value divided by 100 is the actual gamma applied, so 80 represents
++# a gamma of 0.8, The value 220 represents a gamma of 2.2, and 100 does not
++# change the gamma.
++# Minimum value: 40, maximum value: 240, default value: 80.
++# This tag requires that the tag GENERATE_HTML is set to YES.
++
++HTML_COLORSTYLE_GAMMA = 80
++
++# If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML
++# page will contain the date and time when the page was generated. Setting this
++# to NO can help when comparing the output of multiple runs.
++# The default value is: YES.
++# This tag requires that the tag GENERATE_HTML is set to YES.
++
++HTML_TIMESTAMP = YES
++
++# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
++# documentation will contain sections that can be hidden and shown after the
++# page has loaded.
++# The default value is: NO.
++# This tag requires that the tag GENERATE_HTML is set to YES.
++
++HTML_DYNAMIC_SECTIONS = NO
++
++# With HTML_INDEX_NUM_ENTRIES one can control the preferred number of entries
++# shown in the various tree structured indices initially; the user can expand
++# and collapse entries dynamically later on. Doxygen will expand the tree to
++# such a level that at most the specified number of entries are visible (unless
++# a fully collapsed tree already exceeds this amount). So setting the number of
++# entries 1 will produce a full collapsed tree by default. 0 is a special value
++# representing an infinite number of entries and will result in a full expanded
++# tree by default.
++# Minimum value: 0, maximum value: 9999, default value: 100.
++# This tag requires that the tag GENERATE_HTML is set to YES.
++
++HTML_INDEX_NUM_ENTRIES = 100
++
++# If the GENERATE_DOCSET tag is set to YES, additional index files will be
++# generated that can be used as input for Apple's Xcode 3 integrated development
++# environment (see: http://developer.apple.com/tools/xcode/), introduced with
++# OSX 10.5 (Leopard). To create a documentation set, doxygen will generate a
++# Makefile in the HTML output directory. Running make will produce the docset in
++# that directory and running make install will install the docset in
++# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find it at
++# startup. See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html
++# for more information.
++# The default value is: NO.
++# This tag requires that the tag GENERATE_HTML is set to YES.
++
++GENERATE_DOCSET = NO
++
++# This tag determines the name of the docset feed. A documentation feed provides
++# an umbrella under which multiple documentation sets from a single provider
++# (such as a company or product suite) can be grouped.
++# The default value is: Doxygen generated docs.
++# This tag requires that the tag GENERATE_DOCSET is set to YES.
++
++DOCSET_FEEDNAME = "Doxygen generated docs"
++
++# This tag specifies a string that should uniquely identify the documentation
++# set bundle. This should be a reverse domain-name style string, e.g.
++# com.mycompany.MyDocSet. Doxygen will append .docset to the name.
++# The default value is: org.doxygen.Project.
++# This tag requires that the tag GENERATE_DOCSET is set to YES.
++
++DOCSET_BUNDLE_ID = org.doxygen.Project
++
++# The DOCSET_PUBLISHER_ID tag specifies a string that should uniquely identify
++# the documentation publisher. This should be a reverse domain-name style
++# string, e.g. com.mycompany.MyDocSet.documentation.
++# The default value is: org.doxygen.Publisher.
++# This tag requires that the tag GENERATE_DOCSET is set to YES.
++
++DOCSET_PUBLISHER_ID = org.doxygen.Publisher
++
++# The DOCSET_PUBLISHER_NAME tag identifies the documentation publisher.
++# The default value is: Publisher.
++# This tag requires that the tag GENERATE_DOCSET is set to YES.
++
++DOCSET_PUBLISHER_NAME = Publisher
++
++# If the GENERATE_HTMLHELP tag is set to YES then doxygen generates three
++# additional HTML index files: index.hhp, index.hhc, and index.hhk. The
++# index.hhp is a project file that can be read by Microsoft's HTML Help Workshop
++# (see: http://www.microsoft.com/en-us/download/details.aspx?id=21138) on
++# Windows.
++#
++# The HTML Help Workshop contains a compiler that can convert all HTML output
++# generated by doxygen into a single compiled HTML file (.chm). Compiled HTML
++# files are now used as the Windows 98 help format, and will replace the old
++# Windows help format (.hlp) on all Windows platforms in the future. Compressed
++# HTML files also contain an index, a table of contents, and you can search for
++# words in the documentation. The HTML workshop also contains a viewer for
++# compressed HTML files.
++# The default value is: NO.
++# This tag requires that the tag GENERATE_HTML is set to YES.
++
++GENERATE_HTMLHELP = YES
++
++# The CHM_FILE tag can be used to specify the file name of the resulting .chm
++# file. You can add a path in front of the file if the result should not be
++# written to the html output directory.
++# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
++
++CHM_FILE =
++
++# The HHC_LOCATION tag can be used to specify the location (absolute path
++# including file name) of the HTML help compiler ( hhc.exe). If non-empty
++# doxygen will try to run the HTML help compiler on the generated index.hhp.
++# The file has to be specified with full path.
++# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
++
++HHC_LOCATION =
++
++# The GENERATE_CHI flag controls if a separate .chi index file is generated (
++# YES) or that it should be included in the master .chm file ( NO).
++# The default value is: NO.
++# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
++
++GENERATE_CHI = YES
++
++# The CHM_INDEX_ENCODING is used to encode HtmlHelp index ( hhk), content ( hhc)
++# and project file content.
++# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
++
++CHM_INDEX_ENCODING =
++
++# The BINARY_TOC flag controls whether a binary table of contents is generated (
++# YES) or a normal table of contents ( NO) in the .chm file. Furthermore it
++# enables the Previous and Next buttons.
++# The default value is: NO.
++# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
++
++BINARY_TOC = YES
++
++# The TOC_EXPAND flag can be set to YES to add extra items for group members to
++# the table of contents of the HTML help documentation and to the tree view.
++# The default value is: NO.
++# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
++
++TOC_EXPAND = YES
++
++# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and
++# QHP_VIRTUAL_FOLDER are set, an additional index file will be generated that
++# can be used as input for Qt's qhelpgenerator to generate a Qt Compressed Help
++# (.qch) of the generated HTML documentation.
++# The default value is: NO.
++# This tag requires that the tag GENERATE_HTML is set to YES.
++
++GENERATE_QHP = NO
++
++# If the QHG_LOCATION tag is specified, the QCH_FILE tag can be used to specify
++# the file name of the resulting .qch file. The path specified is relative to
++# the HTML output folder.
++# This tag requires that the tag GENERATE_QHP is set to YES.
++
++QCH_FILE =
++
++# The QHP_NAMESPACE tag specifies the namespace to use when generating Qt Help
++# Project output. For more information please see Qt Help Project / Namespace
++# (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#namespace).
++# The default value is: org.doxygen.Project.
++# This tag requires that the tag GENERATE_QHP is set to YES.
++
++QHP_NAMESPACE = org.doxygen.Project
++
++# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating Qt
++# Help Project output. For more information please see Qt Help Project / Virtual
++# Folders (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#virtual-
++# folders).
++# The default value is: doc.
++# This tag requires that the tag GENERATE_QHP is set to YES.
++
++QHP_VIRTUAL_FOLDER = doc
++
++# If the QHP_CUST_FILTER_NAME tag is set, it specifies the name of a custom
++# filter to add. For more information please see Qt Help Project / Custom
++# Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom-
++# filters).
++# This tag requires that the tag GENERATE_QHP is set to YES.
++
++QHP_CUST_FILTER_NAME =
++
++# The QHP_CUST_FILTER_ATTRS tag specifies the list of the attributes of the
++# custom filter to add. For more information please see Qt Help Project / Custom
++# Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom-
++# filters).
++# This tag requires that the tag GENERATE_QHP is set to YES.
++
++QHP_CUST_FILTER_ATTRS =
++
++# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this
++# project's filter section matches. Qt Help Project / Filter Attributes (see:
++# http://qt-project.org/doc/qt-4.8/qthelpproject.html#filter-attributes).
++# This tag requires that the tag GENERATE_QHP is set to YES.
++
++QHP_SECT_FILTER_ATTRS =
++
++# The QHG_LOCATION tag can be used to specify the location of Qt's
++# qhelpgenerator. If non-empty doxygen will try to run qhelpgenerator on the
++# generated .qhp file.
++# This tag requires that the tag GENERATE_QHP is set to YES.
++
++QHG_LOCATION =
++
++# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files will be
++# generated, together with the HTML files, they form an Eclipse help plugin. To
++# install this plugin and make it available under the help contents menu in
++# Eclipse, the contents of the directory containing the HTML and XML files needs
++# to be copied into the plugins directory of eclipse. The name of the directory
++# within the plugins directory should be the same as the ECLIPSE_DOC_ID value.
++# After copying Eclipse needs to be restarted before the help appears.
++# The default value is: NO.
++# This tag requires that the tag GENERATE_HTML is set to YES.
++
++GENERATE_ECLIPSEHELP = NO
++
++# A unique identifier for the Eclipse help plugin. When installing the plugin
++# the directory name containing the HTML and XML files should also have this
++# name. Each documentation set should have its own identifier.
++# The default value is: org.doxygen.Project.
++# This tag requires that the tag GENERATE_ECLIPSEHELP is set to YES.
++
++ECLIPSE_DOC_ID = org.doxygen.Project
++
++# If you want full control over the layout of the generated HTML pages it might
++# be necessary to disable the index and replace it with your own. The
++# DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs) at top
++# of each HTML page. A value of NO enables the index and the value YES disables
++# it. Since the tabs in the index contain the same information as the navigation
++# tree, you can set this option to YES if you also set GENERATE_TREEVIEW to YES.
++# The default value is: NO.
++# This tag requires that the tag GENERATE_HTML is set to YES.
++
++DISABLE_INDEX = NO
++
++# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index
++# structure should be generated to display hierarchical information. If the tag
++# value is set to YES, a side panel will be generated containing a tree-like
++# index structure (just like the one that is generated for HTML Help). For this
++# to work a browser that supports JavaScript, DHTML, CSS and frames is required
++# (i.e. any modern browser). Windows users are probably better off using the
++# HTML help feature. Via custom stylesheets (see HTML_EXTRA_STYLESHEET) one can
++# further fine-tune the look of the index. As an example, the default style
++# sheet generated by doxygen has an example that shows how to put an image at
++# the root of the tree instead of the PROJECT_NAME. Since the tree basically has
++# the same information as the tab index, you could consider setting
++# DISABLE_INDEX to YES when enabling this option.
++# The default value is: NO.
++# This tag requires that the tag GENERATE_HTML is set to YES.
++
++GENERATE_TREEVIEW = NO
++
++# The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values that
++# doxygen will group on one line in the generated HTML documentation.
++#
++# Note that a value of 0 will completely suppress the enum values from appearing
++# in the overview section.
++# Minimum value: 0, maximum value: 20, default value: 4.
++# This tag requires that the tag GENERATE_HTML is set to YES.
++
++ENUM_VALUES_PER_LINE = 4
++
++# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be used
++# to set the initial width (in pixels) of the frame in which the tree is shown.
++# Minimum value: 0, maximum value: 1500, default value: 250.
++# This tag requires that the tag GENERATE_HTML is set to YES.
++
++TREEVIEW_WIDTH = 250
++
++# When the EXT_LINKS_IN_WINDOW option is set to YES doxygen will open links to
++# external symbols imported via tag files in a separate window.
++# The default value is: NO.
++# This tag requires that the tag GENERATE_HTML is set to YES.
++
++EXT_LINKS_IN_WINDOW = NO
++
++# Use this tag to change the font size of LaTeX formulas included as images in
++# the HTML documentation. When you change the font size after a successful
++# doxygen run you need to manually remove any form_*.png images from the HTML
++# output directory to force them to be regenerated.
++# Minimum value: 8, maximum value: 50, default value: 10.
++# This tag requires that the tag GENERATE_HTML is set to YES.
++
++FORMULA_FONTSIZE = 10
++
++# Use the FORMULA_TRANPARENT tag to determine whether or not the images
++# generated for formulas are transparent PNGs. Transparent PNGs are not
++# supported properly for IE 6.0, but are supported on all modern browsers.
++#
++# Note that when changing this option you need to delete any form_*.png files in
++# the HTML output directory before the changes have effect.
++# The default value is: YES.
++# This tag requires that the tag GENERATE_HTML is set to YES.
++
++FORMULA_TRANSPARENT = YES
++
++# Enable the USE_MATHJAX option to render LaTeX formulas using MathJax (see
++# http://www.mathjax.org) which uses client side Javascript for the rendering
++# instead of using prerendered bitmaps. Use this if you do not have LaTeX
++# installed or if you want to formulas look prettier in the HTML output. When
++# enabled you may also need to install MathJax separately and configure the path
++# to it using the MATHJAX_RELPATH option.
++# The default value is: NO.
++# This tag requires that the tag GENERATE_HTML is set to YES.
++
++USE_MATHJAX = NO
++
++# When MathJax is enabled you can set the default output format to be used for
++# the MathJax output. See the MathJax site (see:
++# http://docs.mathjax.org/en/latest/output.html) for more details.
++# Possible values are: HTML-CSS (which is slower, but has the best
++# compatibility), NativeMML (i.e. MathML) and SVG.
++# The default value is: HTML-CSS.
++# This tag requires that the tag USE_MATHJAX is set to YES.
++
++MATHJAX_FORMAT = HTML-CSS
++
++# When MathJax is enabled you need to specify the location relative to the HTML
++# output directory using the MATHJAX_RELPATH option. The destination directory
++# should contain the MathJax.js script. For instance, if the mathjax directory
++# is located at the same level as the HTML output directory, then
++# MATHJAX_RELPATH should be ../mathjax. The default value points to the MathJax
++# Content Delivery Network so you can quickly see the result without installing
++# MathJax. However, it is strongly recommended to install a local copy of
++# MathJax from http://www.mathjax.org before deployment.
++# The default value is: http://cdn.mathjax.org/mathjax/latest.
++# This tag requires that the tag USE_MATHJAX is set to YES.
++
++MATHJAX_RELPATH = http://cdn.mathjax.org/mathjax/latest
++
++# The MATHJAX_EXTENSIONS tag can be used to specify one or more MathJax
++# extension names that should be enabled during MathJax rendering. For example
++# MATHJAX_EXTENSIONS = TeX/AMSmath TeX/AMSsymbols
++# This tag requires that the tag USE_MATHJAX is set to YES.
++
++MATHJAX_EXTENSIONS =
++
++# The MATHJAX_CODEFILE tag can be used to specify a file with javascript pieces
++# of code that will be used on startup of the MathJax code. See the MathJax site
++# (see: http://docs.mathjax.org/en/latest/output.html) for more details. For an
++# example see the documentation.
++# This tag requires that the tag USE_MATHJAX is set to YES.
++
++MATHJAX_CODEFILE =
++
++# When the SEARCHENGINE tag is enabled doxygen will generate a search box for
++# the HTML output. The underlying search engine uses javascript and DHTML and
++# should work on any modern browser. Note that when using HTML help
++# (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets (GENERATE_DOCSET)
++# there is already a search function so this one should typically be disabled.
++# For large projects the javascript based search engine can be slow, then
++# enabling SERVER_BASED_SEARCH may provide a better solution. It is possible to
++# search using the keyboard; to jump to the search box use <access key> + S
++# (what the <access key> is depends on the OS and browser, but it is typically
++# <CTRL>, <ALT>/<option>, or both). Inside the search box use the <cursor down
++# key> to jump into the search results window, the results can be navigated
++# using the <cursor keys>. Press <Enter> to select an item or <escape> to cancel
++# the search. The filter options can be selected when the cursor is inside the
++# search box by pressing <Shift>+<cursor down>. Also here use the <cursor keys>
++# to select a filter and <Enter> or <escape> to activate or cancel the filter
++# option.
++# The default value is: YES.
++# This tag requires that the tag GENERATE_HTML is set to YES.
++
++SEARCHENGINE = NO
++
++# When the SERVER_BASED_SEARCH tag is enabled the search engine will be
++# implemented using a web server instead of a web client using Javascript. There
++# are two flavors of web server based searching depending on the EXTERNAL_SEARCH
++# setting. When disabled, doxygen will generate a PHP script for searching and
++# an index file used by the script. When EXTERNAL_SEARCH is enabled the indexing
++# and searching needs to be provided by external tools. See the section
++# "External Indexing and Searching" for details.
++# The default value is: NO.
++# This tag requires that the tag SEARCHENGINE is set to YES.
++
++SERVER_BASED_SEARCH = NO
++
++# When EXTERNAL_SEARCH tag is enabled doxygen will no longer generate the PHP
++# script for searching. Instead the search results are written to an XML file
++# which needs to be processed by an external indexer. Doxygen will invoke an
++# external search engine pointed to by the SEARCHENGINE_URL option to obtain the
++# search results.
++#
++# Doxygen ships with an example indexer ( doxyindexer) and search engine
++# (doxysearch.cgi) which are based on the open source search engine library
++# Xapian (see: http://xapian.org/).
++#
++# See the section "External Indexing and Searching" for details.
++# The default value is: NO.
++# This tag requires that the tag SEARCHENGINE is set to YES.
++
++EXTERNAL_SEARCH = NO
++
++# The SEARCHENGINE_URL should point to a search engine hosted by a web server
++# which will return the search results when EXTERNAL_SEARCH is enabled.
++#
++# Doxygen ships with an example indexer ( doxyindexer) and search engine
++# (doxysearch.cgi) which are based on the open source search engine library
++# Xapian (see: http://xapian.org/). See the section "External Indexing and
++# Searching" for details.
++# This tag requires that the tag SEARCHENGINE is set to YES.
++
++SEARCHENGINE_URL =
++
++# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the unindexed
++# search data is written to a file for indexing by an external tool. With the
++# SEARCHDATA_FILE tag the name of this file can be specified.
++# The default file is: searchdata.xml.
++# This tag requires that the tag SEARCHENGINE is set to YES.
++
++SEARCHDATA_FILE = searchdata.xml
++
++# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the
++# EXTERNAL_SEARCH_ID tag can be used as an identifier for the project. This is
++# useful in combination with EXTRA_SEARCH_MAPPINGS to search through multiple
++# projects and redirect the results back to the right project.
++# This tag requires that the tag SEARCHENGINE is set to YES.
++
++EXTERNAL_SEARCH_ID =
++
++# The EXTRA_SEARCH_MAPPINGS tag can be used to enable searching through doxygen
++# projects other than the one defined by this configuration file, but that are
++# all added to the same external search index. Each project needs to have a
++# unique id set via EXTERNAL_SEARCH_ID. The search mapping then maps the id of
++# to a relative location where the documentation can be found. The format is:
++# EXTRA_SEARCH_MAPPINGS = tagname1=loc1 tagname2=loc2 ...
++# This tag requires that the tag SEARCHENGINE is set to YES.
++
++EXTRA_SEARCH_MAPPINGS =
++
++#---------------------------------------------------------------------------
++# Configuration options related to the LaTeX output
++#---------------------------------------------------------------------------
++
++# If the GENERATE_LATEX tag is set to YES doxygen will generate LaTeX output.
++# The default value is: YES.
++
++GENERATE_LATEX = NO
++
++# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. If a
++# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
++# it.
++# The default directory is: latex.
++# This tag requires that the tag GENERATE_LATEX is set to YES.
++
++LATEX_OUTPUT = latex
++
++# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
++# invoked.
++#
++# Note that when enabling USE_PDFLATEX this option is only used for generating
++# bitmaps for formulas in the HTML output, but not in the Makefile that is
++# written to the output directory.
++# The default file is: latex.
++# This tag requires that the tag GENERATE_LATEX is set to YES.
++
++LATEX_CMD_NAME = latex
++
++# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to generate
++# index for LaTeX.
++# The default file is: makeindex.
++# This tag requires that the tag GENERATE_LATEX is set to YES.
++
++MAKEINDEX_CMD_NAME = makeindex
++
++# If the COMPACT_LATEX tag is set to YES doxygen generates more compact LaTeX
++# documents. This may be useful for small projects and may help to save some
++# trees in general.
++# The default value is: NO.
++# This tag requires that the tag GENERATE_LATEX is set to YES.
++
++COMPACT_LATEX = YES
++
++# The PAPER_TYPE tag can be used to set the paper type that is used by the
++# printer.
++# Possible values are: a4 (210 x 297 mm), letter (8.5 x 11 inches), legal (8.5 x
++# 14 inches) and executive (7.25 x 10.5 inches).
++# The default value is: a4.
++# This tag requires that the tag GENERATE_LATEX is set to YES.
++
++PAPER_TYPE = a4wide
++
++# The EXTRA_PACKAGES tag can be used to specify one or more LaTeX package names
++# that should be included in the LaTeX output. To get the times font for
++# instance you can specify
++# EXTRA_PACKAGES=times
++# If left blank no extra packages will be included.
++# This tag requires that the tag GENERATE_LATEX is set to YES.
++
++EXTRA_PACKAGES =
++
++# The LATEX_HEADER tag can be used to specify a personal LaTeX header for the
++# generated LaTeX document. The header should contain everything until the first
++# chapter. If it is left blank doxygen will generate a standard header. See
++# section "Doxygen usage" for information on how to let doxygen write the
++# default header to a separate file.
++#
++# Note: Only use a user-defined header if you know what you are doing! The
++# following commands have a special meaning inside the header: $title,
++# $datetime, $date, $doxygenversion, $projectname, $projectnumber,
++# $projectbrief, $projectlogo. Doxygen will replace $title with the empy string,
++# for the replacement values of the other commands the user is refered to
++# HTML_HEADER.
++# This tag requires that the tag GENERATE_LATEX is set to YES.
++
++LATEX_HEADER =
++
++# The LATEX_FOOTER tag can be used to specify a personal LaTeX footer for the
++# generated LaTeX document. The footer should contain everything after the last
++# chapter. If it is left blank doxygen will generate a standard footer. See
++# LATEX_HEADER for more information on how to generate a default footer and what
++# special commands can be used inside the footer.
++#
++# Note: Only use a user-defined footer if you know what you are doing!
++# This tag requires that the tag GENERATE_LATEX is set to YES.
++
++LATEX_FOOTER =
++
++# The LATEX_EXTRA_FILES tag can be used to specify one or more extra images or
++# other source files which should be copied to the LATEX_OUTPUT output
++# directory. Note that the files will be copied as-is; there are no commands or
++# markers available.
++# This tag requires that the tag GENERATE_LATEX is set to YES.
++
++LATEX_EXTRA_FILES =
++
++# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated is
++# prepared for conversion to PDF (using ps2pdf or pdflatex). The PDF file will
++# contain links (just like the HTML output) instead of page references. This
++# makes the output suitable for online browsing using a PDF viewer.
++# The default value is: YES.
++# This tag requires that the tag GENERATE_LATEX is set to YES.
++
++PDF_HYPERLINKS = YES
++
++# If the USE_PDFLATEX tag is set to YES, doxygen will use pdflatex to generate
++# the PDF file directly from the LaTeX files. Set this option to YES to get a
++# higher quality PDF documentation.
++# The default value is: YES.
++# This tag requires that the tag GENERATE_LATEX is set to YES.
++
++USE_PDFLATEX = YES
++
++# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \batchmode
++# command to the generated LaTeX files. This will instruct LaTeX to keep running
++# if errors occur, instead of asking the user for help. This option is also used
++# when generating formulas in HTML.
++# The default value is: NO.
++# This tag requires that the tag GENERATE_LATEX is set to YES.
++
++LATEX_BATCHMODE = NO
++
++# If the LATEX_HIDE_INDICES tag is set to YES then doxygen will not include the
++# index chapters (such as File Index, Compound Index, etc.) in the output.
++# The default value is: NO.
++# This tag requires that the tag GENERATE_LATEX is set to YES.
++
++LATEX_HIDE_INDICES = NO
++
++# If the LATEX_SOURCE_CODE tag is set to YES then doxygen will include source
++# code with syntax highlighting in the LaTeX output.
++#
++# Note that which sources are shown also depends on other settings such as
++# SOURCE_BROWSER.
++# The default value is: NO.
++# This tag requires that the tag GENERATE_LATEX is set to YES.
++
++LATEX_SOURCE_CODE = NO
++
++# The LATEX_BIB_STYLE tag can be used to specify the style to use for the
++# bibliography, e.g. plainnat, or ieeetr. See
++# http://en.wikipedia.org/wiki/BibTeX and \cite for more info.
++# The default value is: plain.
++# This tag requires that the tag GENERATE_LATEX is set to YES.
++
++LATEX_BIB_STYLE = plain
++
++#---------------------------------------------------------------------------
++# Configuration options related to the RTF output
++#---------------------------------------------------------------------------
++
++# If the GENERATE_RTF tag is set to YES doxygen will generate RTF output. The
++# RTF output is optimized for Word 97 and may not look too pretty with other RTF
++# readers/editors.
++# The default value is: NO.
++
++GENERATE_RTF = NO
++
++# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. If a
++# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
++# it.
++# The default directory is: rtf.
++# This tag requires that the tag GENERATE_RTF is set to YES.
++
++RTF_OUTPUT = rtf
++
++# If the COMPACT_RTF tag is set to YES doxygen generates more compact RTF
++# documents. This may be useful for small projects and may help to save some
++# trees in general.
++# The default value is: NO.
++# This tag requires that the tag GENERATE_RTF is set to YES.
++
++COMPACT_RTF = NO
++
++# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated will
++# contain hyperlink fields. The RTF file will contain links (just like the HTML
++# output) instead of page references. This makes the output suitable for online
++# browsing using Word or some other Word compatible readers that support those
++# fields.
++#
++# Note: WordPad (write) and others do not support links.
++# The default value is: NO.
++# This tag requires that the tag GENERATE_RTF is set to YES.
++
++RTF_HYPERLINKS = NO
++
++# Load stylesheet definitions from file. Syntax is similar to doxygen's config
++# file, i.e. a series of assignments. You only have to provide replacements,
++# missing definitions are set to their default value.
++#
++# See also section "Doxygen usage" for information on how to generate the
++# default style sheet that doxygen normally uses.
++# This tag requires that the tag GENERATE_RTF is set to YES.
++
++RTF_STYLESHEET_FILE =
++
++# Set optional variables used in the generation of an RTF document. Syntax is
++# similar to doxygen's config file. A template extensions file can be generated
++# using doxygen -e rtf extensionFile.
++# This tag requires that the tag GENERATE_RTF is set to YES.
++
++RTF_EXTENSIONS_FILE =
++
++#---------------------------------------------------------------------------
++# Configuration options related to the man page output
++#---------------------------------------------------------------------------
++
++# If the GENERATE_MAN tag is set to YES doxygen will generate man pages for
++# classes and files.
++# The default value is: NO.
++
++GENERATE_MAN = NO
++
++# The MAN_OUTPUT tag is used to specify where the man pages will be put. If a
++# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
++# it. A directory man3 will be created inside the directory specified by
++# MAN_OUTPUT.
++# The default directory is: man.
++# This tag requires that the tag GENERATE_MAN is set to YES.
++
++MAN_OUTPUT = man
++
++# The MAN_EXTENSION tag determines the extension that is added to the generated
++# man pages. In case the manual section does not start with a number, the number
++# 3 is prepended. The dot (.) at the beginning of the MAN_EXTENSION tag is
++# optional.
++# The default value is: .3.
++# This tag requires that the tag GENERATE_MAN is set to YES.
++
++MAN_EXTENSION = .3
++
++# The MAN_SUBDIR tag determines the name of the directory created within
++# MAN_OUTPUT in which the man pages are placed. If defaults to man followed by
++# MAN_EXTENSION with the initial . removed.
++# This tag requires that the tag GENERATE_MAN is set to YES.
++
++MAN_SUBDIR =
++
++# If the MAN_LINKS tag is set to YES and doxygen generates man output, then it
++# will generate one additional man file for each entity documented in the real
++# man page(s). These additional files only source the real man page, but without
++# them the man command would be unable to find the correct page.
++# The default value is: NO.
++# This tag requires that the tag GENERATE_MAN is set to YES.
++
++MAN_LINKS = NO
++
++#---------------------------------------------------------------------------
++# Configuration options related to the XML output
++#---------------------------------------------------------------------------
++
++# If the GENERATE_XML tag is set to YES doxygen will generate an XML file that
++# captures the structure of the code including all documentation.
++# The default value is: NO.
++
++GENERATE_XML = NO
++
++# The XML_OUTPUT tag is used to specify where the XML pages will be put. If a
++# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
++# it.
++# The default directory is: xml.
++# This tag requires that the tag GENERATE_XML is set to YES.
++
++XML_OUTPUT = xml
++
++# If the XML_PROGRAMLISTING tag is set to YES doxygen will dump the program
++# listings (including syntax highlighting and cross-referencing information) to
++# the XML output. Note that enabling this will significantly increase the size
++# of the XML output.
++# The default value is: YES.
++# This tag requires that the tag GENERATE_XML is set to YES.
++
++XML_PROGRAMLISTING = YES
++
++#---------------------------------------------------------------------------
++# Configuration options related to the DOCBOOK output
++#---------------------------------------------------------------------------
++
++# If the GENERATE_DOCBOOK tag is set to YES doxygen will generate Docbook files
++# that can be used to generate PDF.
++# The default value is: NO.
++
++GENERATE_DOCBOOK = NO
++
++# The DOCBOOK_OUTPUT tag is used to specify where the Docbook pages will be put.
++# If a relative path is entered the value of OUTPUT_DIRECTORY will be put in
++# front of it.
++# The default directory is: docbook.
++# This tag requires that the tag GENERATE_DOCBOOK is set to YES.
++
++DOCBOOK_OUTPUT = docbook
++
++#---------------------------------------------------------------------------
++# Configuration options for the AutoGen Definitions output
++#---------------------------------------------------------------------------
++
++# If the GENERATE_AUTOGEN_DEF tag is set to YES doxygen will generate an AutoGen
++# Definitions (see http://autogen.sf.net) file that captures the structure of
++# the code including all documentation. Note that this feature is still
++# experimental and incomplete at the moment.
++# The default value is: NO.
++
++GENERATE_AUTOGEN_DEF = NO
++
++#---------------------------------------------------------------------------
++# Configuration options related to the Perl module output
++#---------------------------------------------------------------------------
++
++# If the GENERATE_PERLMOD tag is set to YES doxygen will generate a Perl module
++# file that captures the structure of the code including all documentation.
++#
++# Note that this feature is still experimental and incomplete at the moment.
++# The default value is: NO.
++
++GENERATE_PERLMOD = NO
++
++# If the PERLMOD_LATEX tag is set to YES doxygen will generate the necessary
++# Makefile rules, Perl scripts and LaTeX code to be able to generate PDF and DVI
++# output from the Perl module output.
++# The default value is: NO.
++# This tag requires that the tag GENERATE_PERLMOD is set to YES.
++
++PERLMOD_LATEX = NO
++
++# If the PERLMOD_PRETTY tag is set to YES the Perl module output will be nicely
++# formatted so it can be parsed by a human reader. This is useful if you want to
++# understand what is going on. On the other hand, if this tag is set to NO the
++# size of the Perl module output will be much smaller and Perl will parse it
++# just the same.
++# The default value is: YES.
++# This tag requires that the tag GENERATE_PERLMOD is set to YES.
++
++PERLMOD_PRETTY = YES
++
++# The names of the make variables in the generated doxyrules.make file are
++# prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. This is useful
++# so different doxyrules.make files included by the same Makefile don't
++# overwrite each other's variables.
++# This tag requires that the tag GENERATE_PERLMOD is set to YES.
++
++PERLMOD_MAKEVAR_PREFIX =
++
++#---------------------------------------------------------------------------
++# Configuration options related to the preprocessor
++#---------------------------------------------------------------------------
++
++# If the ENABLE_PREPROCESSING tag is set to YES doxygen will evaluate all
++# C-preprocessor directives found in the sources and include files.
++# The default value is: YES.
++
++ENABLE_PREPROCESSING = YES
++
++# If the MACRO_EXPANSION tag is set to YES doxygen will expand all macro names
++# in the source code. If set to NO only conditional compilation will be
++# performed. Macro expansion can be done in a controlled way by setting
++# EXPAND_ONLY_PREDEF to YES.
++# The default value is: NO.
++# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
++
++MACRO_EXPANSION = YES
++
++# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES then
++# the macro expansion is limited to the macros specified with the PREDEFINED and
++# EXPAND_AS_DEFINED tags.
++# The default value is: NO.
++# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
++
++EXPAND_ONLY_PREDEF = NO
++
++# If the SEARCH_INCLUDES tag is set to YES the includes files in the
++# INCLUDE_PATH will be searched if a #include is found.
++# The default value is: YES.
++# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
++
++SEARCH_INCLUDES = YES
++
++# The INCLUDE_PATH tag can be used to specify one or more directories that
++# contain include files that are not input files but should be processed by the
++# preprocessor.
++# This tag requires that the tag SEARCH_INCLUDES is set to YES.
++
++INCLUDE_PATH =
++
++# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
++# patterns (like *.h and *.hpp) to filter out the header-files in the
++# directories. If left blank, the patterns specified with FILE_PATTERNS will be
++# used.
++# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
++
++INCLUDE_FILE_PATTERNS =
++
++# The PREDEFINED tag can be used to specify one or more macro names that are
++# defined before the preprocessor is started (similar to the -D option of e.g.
++# gcc). The argument of the tag is a list of macros of the form: name or
++# name=definition (no spaces). If the definition and the "=" are omitted, "=1"
++# is assumed. To prevent a macro definition from being undefined via #undef or
++# recursively expanded use the := operator instead of the = operator.
++# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
++
++PREDEFINED = DOXYGEN \
++ CBOR_INLINE_API=
++
++# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then this
++# tag can be used to specify a list of macro names that should be expanded. The
++# macro definition that is found in the sources will be used. Use the PREDEFINED
++# tag if you want to use a different macro definition that overrules the
++# definition found in the source code.
++# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
++
++EXPAND_AS_DEFINED =
++
++# If the SKIP_FUNCTION_MACROS tag is set to YES then doxygen's preprocessor will
++# remove all references to function-like macros that are alone on a line, have
++# an all uppercase name, and do not end with a semicolon. Such function macros
++# are typically used for boiler-plate code, and will confuse the parser if not
++# removed.
++# The default value is: YES.
++# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
++
++SKIP_FUNCTION_MACROS = YES
++
++#---------------------------------------------------------------------------
++# Configuration options related to external references
++#---------------------------------------------------------------------------
++
++# The TAGFILES tag can be used to specify one or more tag files. For each tag
++# file the location of the external documentation should be added. The format of
++# a tag file without this location is as follows:
++# TAGFILES = file1 file2 ...
++# Adding location for the tag files is done as follows:
++# TAGFILES = file1=loc1 "file2 = loc2" ...
++# where loc1 and loc2 can be relative or absolute paths or URLs. See the
++# section "Linking to external documentation" for more information about the use
++# of tag files.
++# Note: Each tag file must have a unique name (where the name does NOT include
++# the path). If a tag file is not located in the directory in which doxygen is
++# run, you must also specify the path to the tagfile here.
++
++TAGFILES =
++
++# When a file name is specified after GENERATE_TAGFILE, doxygen will create a
++# tag file that is based on the input files it reads. See section "Linking to
++# external documentation" for more information about the usage of tag files.
++
++GENERATE_TAGFILE =
++
++# If the ALLEXTERNALS tag is set to YES all external class will be listed in the
++# class index. If set to NO only the inherited external classes will be listed.
++# The default value is: NO.
++
++ALLEXTERNALS = NO
++
++# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed in
++# the modules index. If set to NO, only the current project's groups will be
++# listed.
++# The default value is: YES.
++
++EXTERNAL_GROUPS = YES
++
++# If the EXTERNAL_PAGES tag is set to YES all external pages will be listed in
++# the related pages index. If set to NO, only the current project's pages will
++# be listed.
++# The default value is: YES.
++
++EXTERNAL_PAGES = YES
++
++# The PERL_PATH should be the absolute path and name of the perl script
++# interpreter (i.e. the result of 'which perl').
++# The default file (with absolute path) is: /usr/bin/perl.
++
++PERL_PATH = /usr/bin/perl
++
++#---------------------------------------------------------------------------
++# Configuration options related to the dot tool
++#---------------------------------------------------------------------------
++
++# If the CLASS_DIAGRAMS tag is set to YES doxygen will generate a class diagram
++# (in HTML and LaTeX) for classes with base or super classes. Setting the tag to
++# NO turns the diagrams off. Note that this option also works with HAVE_DOT
++# disabled, but it is recommended to install and use dot, since it yields more
++# powerful graphs.
++# The default value is: YES.
++
++CLASS_DIAGRAMS = NO
++
++# You can define message sequence charts within doxygen comments using the \msc
++# command. Doxygen will then run the mscgen tool (see:
++# http://www.mcternan.me.uk/mscgen/)) to produce the chart and insert it in the
++# documentation. The MSCGEN_PATH tag allows you to specify the directory where
++# the mscgen tool resides. If left empty the tool is assumed to be found in the
++# default search path.
++
++MSCGEN_PATH =
++
++# You can include diagrams made with dia in doxygen documentation. Doxygen will
++# then run dia to produce the diagram and insert it in the documentation. The
++# DIA_PATH tag allows you to specify the directory where the dia binary resides.
++# If left empty dia is assumed to be found in the default search path.
++
++DIA_PATH =
++
++# If set to YES, the inheritance and collaboration graphs will hide inheritance
++# and usage relations if the target is undocumented or is not a class.
++# The default value is: YES.
++
++HIDE_UNDOC_RELATIONS = YES
++
++# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
++# available from the path. This tool is part of Graphviz (see:
++# http://www.graphviz.org/), a graph visualization toolkit from AT&T and Lucent
++# Bell Labs. The other options in this section have no effect if this option is
++# set to NO
++# The default value is: NO.
++
++HAVE_DOT = NO
++
++# The DOT_NUM_THREADS specifies the number of dot invocations doxygen is allowed
++# to run in parallel. When set to 0 doxygen will base this on the number of
++# processors available in the system. You can set it explicitly to a value
++# larger than 0 to get control over the balance between CPU load and processing
++# speed.
++# Minimum value: 0, maximum value: 32, default value: 0.
++# This tag requires that the tag HAVE_DOT is set to YES.
++
++DOT_NUM_THREADS = 0
++
++# When you want a differently looking font in the dot files that doxygen
++# generates you can specify the font name using DOT_FONTNAME. You need to make
++# sure dot is able to find the font, which can be done by putting it in a
++# standard location or by setting the DOTFONTPATH environment variable or by
++# setting DOT_FONTPATH to the directory containing the font.
++# The default value is: Helvetica.
++# This tag requires that the tag HAVE_DOT is set to YES.
++
++DOT_FONTNAME = Helvetica
++
++# The DOT_FONTSIZE tag can be used to set the size (in points) of the font of
++# dot graphs.
++# Minimum value: 4, maximum value: 24, default value: 10.
++# This tag requires that the tag HAVE_DOT is set to YES.
++
++DOT_FONTSIZE = 10
++
++# By default doxygen will tell dot to use the default font as specified with
++# DOT_FONTNAME. If you specify a different font using DOT_FONTNAME you can set
++# the path where dot can find it using this tag.
++# This tag requires that the tag HAVE_DOT is set to YES.
++
++DOT_FONTPATH =
++
++# If the CLASS_GRAPH tag is set to YES then doxygen will generate a graph for
++# each documented class showing the direct and indirect inheritance relations.
++# Setting this tag to YES will force the CLASS_DIAGRAMS tag to NO.
++# The default value is: YES.
++# This tag requires that the tag HAVE_DOT is set to YES.
++
++CLASS_GRAPH = NO
++
++# If the COLLABORATION_GRAPH tag is set to YES then doxygen will generate a
++# graph for each documented class showing the direct and indirect implementation
++# dependencies (inheritance, containment, and class references variables) of the
++# class with other documented classes.
++# The default value is: YES.
++# This tag requires that the tag HAVE_DOT is set to YES.
++
++COLLABORATION_GRAPH = NO
++
++# If the GROUP_GRAPHS tag is set to YES then doxygen will generate a graph for
++# groups, showing the direct groups dependencies.
++# The default value is: YES.
++# This tag requires that the tag HAVE_DOT is set to YES.
++
++GROUP_GRAPHS = NO
++
++# If the UML_LOOK tag is set to YES doxygen will generate inheritance and
++# collaboration diagrams in a style similar to the OMG's Unified Modeling
++# Language.
++# The default value is: NO.
++# This tag requires that the tag HAVE_DOT is set to YES.
++
++UML_LOOK = NO
++
++# If the UML_LOOK tag is enabled, the fields and methods are shown inside the
++# class node. If there are many fields or methods and many nodes the graph may
++# become too big to be useful. The UML_LIMIT_NUM_FIELDS threshold limits the
++# number of items for each type to make the size more manageable. Set this to 0
++# for no limit. Note that the threshold may be exceeded by 50% before the limit
++# is enforced. So when you set the threshold to 10, up to 15 fields may appear,
++# but if the number exceeds 15, the total amount of fields shown is limited to
++# 10.
++# Minimum value: 0, maximum value: 100, default value: 10.
++# This tag requires that the tag HAVE_DOT is set to YES.
++
++UML_LIMIT_NUM_FIELDS = 10
++
++# If the TEMPLATE_RELATIONS tag is set to YES then the inheritance and
++# collaboration graphs will show the relations between templates and their
++# instances.
++# The default value is: NO.
++# This tag requires that the tag HAVE_DOT is set to YES.
++
++TEMPLATE_RELATIONS = NO
++
++# If the INCLUDE_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are set to
++# YES then doxygen will generate a graph for each documented file showing the
++# direct and indirect include dependencies of the file with other documented
++# files.
++# The default value is: YES.
++# This tag requires that the tag HAVE_DOT is set to YES.
++
++INCLUDE_GRAPH = NO
++
++# If the INCLUDED_BY_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are
++# set to YES then doxygen will generate a graph for each documented file showing
++# the direct and indirect include dependencies of the file with other documented
++# files.
++# The default value is: YES.
++# This tag requires that the tag HAVE_DOT is set to YES.
++
++INCLUDED_BY_GRAPH = NO
++
++# If the CALL_GRAPH tag is set to YES then doxygen will generate a call
++# dependency graph for every global function or class method.
++#
++# Note that enabling this option will significantly increase the time of a run.
++# So in most cases it will be better to enable call graphs for selected
++# functions only using the \callgraph command.
++# The default value is: NO.
++# This tag requires that the tag HAVE_DOT is set to YES.
++
++CALL_GRAPH = NO
++
++# If the CALLER_GRAPH tag is set to YES then doxygen will generate a caller
++# dependency graph for every global function or class method.
++#
++# Note that enabling this option will significantly increase the time of a run.
++# So in most cases it will be better to enable caller graphs for selected
++# functions only using the \callergraph command.
++# The default value is: NO.
++# This tag requires that the tag HAVE_DOT is set to YES.
++
++CALLER_GRAPH = NO
++
++# If the GRAPHICAL_HIERARCHY tag is set to YES then doxygen will graphical
++# hierarchy of all classes instead of a textual one.
++# The default value is: YES.
++# This tag requires that the tag HAVE_DOT is set to YES.
++
++GRAPHICAL_HIERARCHY = NO
++
++# If the DIRECTORY_GRAPH tag is set to YES then doxygen will show the
++# dependencies a directory has on other directories in a graphical way. The
++# dependency relations are determined by the #include relations between the
++# files in the directories.
++# The default value is: YES.
++# This tag requires that the tag HAVE_DOT is set to YES.
++
++DIRECTORY_GRAPH = NO
++
++# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
++# generated by dot.
++# Note: If you choose svg you need to set HTML_FILE_EXTENSION to xhtml in order
++# to make the SVG files visible in IE 9+ (other browsers do not have this
++# requirement).
++# Possible values are: png, jpg, gif and svg.
++# The default value is: png.
++# This tag requires that the tag HAVE_DOT is set to YES.
++
++DOT_IMAGE_FORMAT = png
++
++# If DOT_IMAGE_FORMAT is set to svg, then this option can be set to YES to
++# enable generation of interactive SVG images that allow zooming and panning.
++#
++# Note that this requires a modern browser other than Internet Explorer. Tested
++# and working are Firefox, Chrome, Safari, and Opera.
++# Note: For IE 9+ you need to set HTML_FILE_EXTENSION to xhtml in order to make
++# the SVG files visible. Older versions of IE do not have SVG support.
++# The default value is: NO.
++# This tag requires that the tag HAVE_DOT is set to YES.
++
++INTERACTIVE_SVG = NO
++
++# The DOT_PATH tag can be used to specify the path where the dot tool can be
++# found. If left blank, it is assumed the dot tool can be found in the path.
++# This tag requires that the tag HAVE_DOT is set to YES.
++
++DOT_PATH =
++
++# The DOTFILE_DIRS tag can be used to specify one or more directories that
++# contain dot files that are included in the documentation (see the \dotfile
++# command).
++# This tag requires that the tag HAVE_DOT is set to YES.
++
++DOTFILE_DIRS =
++
++# The MSCFILE_DIRS tag can be used to specify one or more directories that
++# contain msc files that are included in the documentation (see the \mscfile
++# command).
++
++MSCFILE_DIRS =
++
++# The DIAFILE_DIRS tag can be used to specify one or more directories that
++# contain dia files that are included in the documentation (see the \diafile
++# command).
++
++DIAFILE_DIRS =
++
++# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of nodes
++# that will be shown in the graph. If the number of nodes in a graph becomes
++# larger than this value, doxygen will truncate the graph, which is visualized
++# by representing a node as a red box. Note that doxygen if the number of direct
++# children of the root node in a graph is already larger than
++# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note that
++# the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.
++# Minimum value: 0, maximum value: 10000, default value: 50.
++# This tag requires that the tag HAVE_DOT is set to YES.
++
++DOT_GRAPH_MAX_NODES = 50
++
++# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the graphs
++# generated by dot. A depth value of 3 means that only nodes reachable from the
++# root by following a path via at most 3 edges will be shown. Nodes that lay
++# further from the root node will be omitted. Note that setting this option to 1
++# or 2 may greatly reduce the computation time needed for large code bases. Also
++# note that the size of a graph can be further restricted by
++# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.
++# Minimum value: 0, maximum value: 1000, default value: 0.
++# This tag requires that the tag HAVE_DOT is set to YES.
++
++MAX_DOT_GRAPH_DEPTH = 0
++
++# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
++# background. This is disabled by default, because dot on Windows does not seem
++# to support this out of the box.
++#
++# Warning: Depending on the platform used, enabling this option may lead to
++# badly anti-aliased labels on the edges of a graph (i.e. they become hard to
++# read).
++# The default value is: NO.
++# This tag requires that the tag HAVE_DOT is set to YES.
++
++DOT_TRANSPARENT = NO
++
++# Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output
++# files in one run (i.e. multiple -o and -T options on the command line). This
++# makes dot run faster, but since only newer versions of dot (>1.8.10) support
++# this, this feature is disabled by default.
++# The default value is: NO.
++# This tag requires that the tag HAVE_DOT is set to YES.
++
++DOT_MULTI_TARGETS = NO
++
++# If the GENERATE_LEGEND tag is set to YES doxygen will generate a legend page
++# explaining the meaning of the various boxes and arrows in the dot generated
++# graphs.
++# The default value is: YES.
++# This tag requires that the tag HAVE_DOT is set to YES.
++
++GENERATE_LEGEND = YES
++
++# If the DOT_CLEANUP tag is set to YES doxygen will remove the intermediate dot
++# files that are used to generate the various graphs.
++# The default value is: YES.
++# This tag requires that the tag HAVE_DOT is set to YES.
++
++DOT_CLEANUP = YES
--- /dev/null
- $(if $(open_memstream-pass),,src/open_memstream.c) \
+# 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/cborparser_dup_string.c \
+ src/cborpretty.c \
+ src/cbortojson.c \
- $(MAKE) -f $(SRCDIR)Makefile.configure OUT='>&10' configure 10> $@
+#
+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
+
++# if open_memstream is unavailable on the system, try to implement our own
++# version using funopen or fopencookie
++ifeq ($(open_memstream-pass),)
++ ifeq ($(funopen-pass)$(fopencookie-pass),)
++ CFLAGS += -DWITHOUT_OPEN_MEMSTREAM
++ $(warning warning: funopen and fopencookie unavailable, open_memstream can not be implemented and conversion to JSON will not work properly!)
++ else
++ TINYCBOR_SOURCES += src/open_memstream.c
++ endif
++endif
++
+# 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
- $(DESTDIR)%/:
- $(INSTALL) -d $@
- $(DESTDIR)$(libdir)/%: lib/% | $(DESTDIR)$(libdir)/
++ $(MAKE) -f $(SRCDIR)Makefile.configure OUT='>&9' configure 9> $@
+
+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)$(bindir)/%: bin/% | $(DESTDIR)$(bindir)/
++$(DESTDIR)$(libdir)/%: lib/%
++ $(INSTALL) -d $(@D)
+ $(INSTALL_DATA) $< $@
- $(DESTDIR)$(pkgconfigdir)/%: % | $(DESTDIR)$(pkgconfigdir)/
++$(DESTDIR)$(bindir)/%: bin/%
++ $(INSTALL) -d $(@D)
+ $(INSTALL_PROGRAM) $< $@
- $(DESTDIR)$(includedir)/tinycbor/%: src/% | $(DESTDIR)$(includedir)/tinycbor/
++$(DESTDIR)$(pkgconfigdir)/%: %
++ $(INSTALL) -d $(@D)
+ $(INSTALL_DATA) $< $@
- -$(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
++$(DESTDIR)$(includedir)/tinycbor/%: src/%
++ $(INSTALL) -d $(@D)
+ $(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 || :
+
++docs:
++ cd $(SRCDIR)src && VERSION=$(VERSION) doxygen $(SRCDIR)/../Doxyfile
++
+dist: $(PACKAGE).tar.gz $(PACKAGE).zip
+distcheck: .git
- .PHONY: dist distcheck release
++ -$(RM) -r $${TMPDIR-/tmp}/tinycbor-distcheck
++ GIT_DIR=$(SRCDIR).git git archive --prefix=tinycbor-distcheck/ --format=tar HEAD | tar -xf - -C $${TMPDIR-/tmp}
++ cd $${TMPDIR-/tmp}/tinycbor-distcheck && $(MAKE) silentcheck
++ $(RM) -r $${TMPDIR-/tmp}/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: docs dist distcheck release
+.SECONDARY:
+
+cflags := $(CPPFLAGS) -I$(SRCDIR)src
+cflags += -DTINYCBOR_VERSION=\"$(VERSION)$(DIRTYSRC)\"
+cflags += -std=c99 $(CFLAGS)
+%.o: %.c
+ @test -d $(@D) || $(MKDIR) $(@D)
+ $(CC) $(cflags) $($(basename $(notdir $@))_CCFLAGS) -c -o $@ $<
+
--- /dev/null
- ALLTESTS = open_memstream funopen gc_sections \
++ALLTESTS = open_memstream funopen fopencookie 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-fopencookie = extern int fopencookie(); int main() { return fopencookie(); }
+PROGRAM-gc_sections = int main() {}
+CCFLAGS-gc_sections = -Wl,--gc-sections
+
+PROGRAM-cjson = \#include <stdlib.h>\n
+PROGRAM-cjson += \#include <cJSON.h>\n
+PROGRAM-cjson += int main() { return cJSON_False; }
+CCFLAGS-cjson = -I$(dir $(MAKEFILE))src/cjson
+PROGRAM-system-cjson = $(PROGRAM-cjson)
- CCLFAGS-system-cjson = -lcJSON
++CCFLAGS-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-,$@))" | \
++ $(if $(V),,@)if printf "$($(subst check-,PROGRAM-,$@))" | \
+ $(CC) -xc $($(subst check-,CCFLAGS-,$@)) -o /dev/null - $(if $(V),,>/dev/null 2>&1); \
+ then \
+ echo $(subst check-,,$@)-pass := 1 $(OUT); \
+ fi
--- /dev/null
- 0.2
++0.3.2
--- /dev/null
--- /dev/null
++/****************************************************************************
++**
++** Copyright (C) 2016 Intel Corporation
++**
++** Permission is hereby granted, free of charge, to any person obtaining a copy
++** of this software and associated documentation files (the "Software"), to deal
++** in the Software without restriction, including without limitation the rights
++** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
++** copies of the Software, and to permit persons to whom the Software is
++** furnished to do so, subject to the following conditions:
++**
++** The above copyright notice and this permission notice shall be included in
++** all copies or substantial portions of the Software.
++**
++** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++** OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
++** THE SOFTWARE.
++**
++****************************************************************************/
++
++/**
++ * \mainpage
++ * The TinyCBOR $(VERSION) library is a small CBOR encoder and decoder library,
++ * optimized for very fast operation with very small footprint. The main encoder
++ * and decoder functions do not allocate memory.
++ *
++ * TinyCBOR is divided into the following groups of functions and structures:
++ * - \ref CborGlobals
++ * - \ref CborEncoding
++ * - \ref CborParsing
++ * - \ref CborPretty
++ * - \ref CborToJson
++ */
++
++/**
++ * \file <cbor.h>
++ * The <cbor.h> is the main header in TinyCBOR and defines the constants used by most functions
++ * as well as the structures for encoding (CborEncoder) and decoding (CborValue).
++ *
++ * \sa <cborjson.h>
++ */
++
++/**
++ * \file <cborjson.h>
++ * The <cborjson.h> file contains the routines that are used to convert a CBOR
++ * data stream into JSON.
++ *
++ * \sa <cbor.h>
++ */
++
++/**
++ * \defgroup CborGlobals Global constants
++ * \brief Constants used by all TinyCBOR function groups.
++ */
++
++/**
++ * \addtogroup CborGlobals
++ * @{
++ */
++
++/**
++ * \var size_t CborIndefiniteLength
++ *
++ * This variable is a constant used to indicate that the length of the map or
++ * array is not yet determined. It is used in functions
++ * cbor_encoder_create_map() and cbor_encoder_create_array()
++ */
++
++/**
++ * \enum CborType
++ * The CborType enum contains the types known to TinyCBOR.
++ *
++ * \value CborIntegerType Type is an integer value, positive, negative or zero
++ * \value CborByteStringType Type is a string of arbitrary raw bytes
++ * \value CborTextStringType Type is a text string encoded in UTF-8
++ * \value CborArrayType Type is a CBOR array
++ * \value CborMapType Type is a CBOR map (an associative container with key and value pairs)
++ * \value CborTagType Type is a CBOR tag (a 64-bit integer describing the item that follows, see CborKnownTags)
++ * \value CborSimpleType Type is one of CBOR Simple Types
++ * \value CborBooleanType Type is a boolean (true or false)
++ * \value CborNullType Type encodes a null
++ * \value CborUndefinedType Type encodes an undefined value
++ * \value CborHalfFloatType Type is an IEEE 754 half precision (16-bit) floating point type
++ * \value CborFloatType Type is an IEEE 754 single precision (32-bit) floating point type
++ * \value CborDoubleType Type is an IEEE 754 double precision (64-bit) floating point type
++ * \value CborInvalidType Type is not valid (this value is used to indicate error conditions)
++ */
++
++/**
++ * \enum CborKnownTags
++ * The CborKnownTags enum contains known tags specified in RFC 7049, for use by the application.
++ * TinyCBOR does not usually interpret the meaning of these tags and does not add them to the
++ * output stream, unless specifically instructed to do so in functions for that effect.
++ *
++ * \value CborDateTimeStringTag Text string contains a date-time encoded in RFC 3339 format, "YYYY-MM-DD hh:mm:ss+zzzz"
++ * \value CborUnixTime_tTag Number is a Unix time_t quantity, the number of seconds since 1970-01-01 midnight UTC
++ * \value CborPositiveBignumTag Item is a CBOR byte string encoding a positive integer of arbitrary precision
++ * \value CborNegativeBignumTag Item is a CBOR byte string encoding a negative integer of arbitrary precision
++ * \value CborDecimalTag Item is a CBOR array of two integers encoding a fixed-point decimal
++ * \value CborBigfloatTag Item is a bigfloat
++ * \value CborExpectedBase64urlTag Item is a CBOR byte string that is expected to be encoded as Base64Url
++ * \value CborExpectedBase64Tag Item is a CBOR byte string that is expected to be encoded as Base64
++ * \value CborExpectedBase16Tag Item is a CBOR byte string that is expected to be encoded as Base16 (also known as "hexdump")
++ * \value CborUriTag Item is a CBOR text string containing an URI (RFC 3986) or IRI (RFC 3987)
++ * \value CborBase64urlTag Item is a CBOR text string that was encoded as Base64Url
++ * \value CborBase64Tag Item is a CBOR text string that was encoded as Base64
++ * \value CborRegularExpressionTag Item is a CBOR text string containing a regular expression
++ * \value CborMimeMessageTag Item is a CBOR text string containing a MIME message (RFC 2045, 2046, 2047, 2822)
++ * \value CborSignatureTag Item contains CBOR-encoded data.
++ * This tag is also used as "file magic," marking a file as containing CBOR
++ */
++
++/**
++ * \typedef CborTag
++ * This typedef is an unsigned 64-bit integer. Known CBOR tags can be used from the CborKnownTags enum
++ * but the user application may use other tag values than the ones specified in RFC 7049.
++ */
++
++/** @} */
--- /dev/null
- # define CBOR_INLINE_API static inline
+/****************************************************************************
+**
+** Copyright (C) 2015 Intel Corporation
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+** copies of the Software, and to permit persons to whom the Software is
+** furnished to do so, subject to the following conditions:
+**
+** The above copyright notice and this permission notice shall be included in
+** all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+** OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+** THE SOFTWARE.
+**
+****************************************************************************/
+
+#ifndef CBOR_H
+#define CBOR_H
+
+#include <assert.h>
+#include <limits.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+#include <stdio.h>
+
+#ifdef __cplusplus
+extern "C" {
+#else
+#include <stdbool.h>
+#endif
+
+#ifndef SIZE_MAX
+/* Some systems fail to define SIZE_MAX in <stdint.h>, even though C99 requires it...
+ * Conversion from signed to unsigned is defined in 6.3.1.3 (Signed and unsigned integers) p2,
+ * which says: "the value is converted by repeatedly adding or subtracting one more than the
+ * maximum value that can be represented in the new type until the value is in the range of the
+ * new type."
+ * So -1 gets converted to size_t by adding SIZE_MAX + 1, which results in SIZE_MAX.
+ */
+# define SIZE_MAX ((size_t)-1)
+#endif
+
+#ifndef CBOR_API
+# define CBOR_API
+#endif
+#ifndef CBOR_PRIVATE_API
+# define CBOR_PRIVATE_API
+#endif
+#ifndef CBOR_INLINE_API
+# if defined(__cplusplus)
++# define CBOR_INLINE inline
+# define CBOR_INLINE_API inline
+# else
- CBOR_INLINE_API bool cbor_type_is_null(const CborValue *value)
++# 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,
++ CborErrorJsonNotImplemented,
+
+ 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);
+
++CBOR_INLINE_API size_t cbor_encoder_get_buffer_size(const CborEncoder *encoder, const uint8_t *buffer)
++{
++ return (size_t)(encoder->ptr - buffer);
++}
++
++CBOR_INLINE_API size_t cbor_encoder_get_extra_bytes_needed(const CborEncoder *encoder)
++{
++ return encoder->end ? 0 : (size_t)encoder->bytes_needed;
++}
++
+/* 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_INLINE_API const uint8_t *cbor_value_get_next_byte(const CborValue *it)
++{ return it->ptr; }
+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_undefined(const CborValue *value)
++CBOR_INLINE_API bool cbor_value_is_null(const CborValue *value)
+{ return value->type == CborNullType; }
- *result = value->extra;
++CBOR_INLINE_API bool cbor_value_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;
++ *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));
- *length = v;
++ *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;
++ *length = (size_t)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;
++ *length = (size_t)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);
- assert(value->type == CborFloatType);
++ *length = (size_t)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_INLINE_API bool cbor_value_is_half_float(const CborValue *value)
++{ return value->type == CborHalfFloatType; }
+CBOR_API CborError cbor_value_get_half_float(const CborValue *value, void *result);
++
++CBOR_INLINE_API bool cbor_value_is_float(const CborValue *value)
++{ return value->type == CborFloatType; }
+CBOR_INLINE_API CborError cbor_value_get_float(const CborValue *value, float *result)
+{
- uint32_t data = _cbor_value_decode_int64_internal(value);
++ assert(cbor_value_is_float(value));
+ assert(value->flags & CborIteratorFlag_IntegerValueTooLarge);
- assert(value->type == CborDoubleType);
++ uint32_t data = (uint32_t)_cbor_value_decode_int64_internal(value);
+ memcpy(result, &data, sizeof(*result));
+ return CborNoError;
+}
+
++CBOR_INLINE_API bool cbor_value_is_double(const CborValue *value)
++{ return value->type == CborDoubleType; }
+CBOR_INLINE_API CborError cbor_value_get_double(const CborValue *value, double *result)
+{
- #endif // CBOR_H
++ assert(cbor_value_is_double(value));
+ assert(value->flags & CborIteratorFlag_IntegerValueTooLarge);
+ uint64_t data = _cbor_value_decode_int64_internal(value);
+ memcpy(result, &data, sizeof(*result));
+ return CborNoError;
+}
+
+/* Human-readable (dump) API */
+CBOR_API CborError cbor_value_to_pretty_advance(FILE *out, CborValue *value);
+CBOR_INLINE_API CborError cbor_value_to_pretty(FILE *out, const CborValue *value)
+{
+ CborValue copy = *value;
+ return cbor_value_to_pretty_advance(out, ©);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
++#endif /* CBOR_H */
+
--- /dev/null
- SmallValueMask = (1U << SmallValueBitLength) - 1, // 31
+#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,
- #endif // CBORCONSTANTS_P_H
-
++ SmallValueMask = (1U << SmallValueBitLength) - 1, /* 31 */
+ Value8Bit = 24U,
+ Value16Bit = 25U,
+ Value32Bit = 26U,
+ Value64Bit = 27U,
+ IndefiniteLength = 31U,
+
+ MajorTypeShift = SmallValueBitLength,
+ MajorTypeMask = ~0U << MajorTypeShift,
+
+ BreakByte = (unsigned)Break | (SimpleTypesType << MajorTypeShift)
+};
+
++#endif /* CBORCONSTANTS_P_H */
--- /dev/null
- ** Copyright (C) 2015 Intel Corporation
+/****************************************************************************
+**
- // 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
++** 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.
+**
+****************************************************************************/
+
+#define _BSD_SOURCE 1
++#define _DEFAULT_SOURCE 1
++#ifndef __STDC_LIMIT_MACROS
++# define __STDC_LIMIT_MACROS 1
++#endif
++
+#include "cbor.h"
+#include "cborconstants_p.h"
+#include "compilersupport_p.h"
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "assert_p.h" /* Always include last */
+
++/**
++ * \defgroup CborEncoding Encoding to CBOR
++ * \brief Group of functions used to encode data to CBOR.
++ *
++ * CborEncoder is used to encode data into a CBOR stream. The outermost
++ * CborEncoder is initialized by calling cbor_encoder_init(), with the buffer
++ * where the CBOR stream will be stored. The outermost CborEncoder is usually
++ * used to encode exactly one item, most often an array or map. It is possible
++ * to encode more than one item, but care must then be taken on the decoder
++ * side to ensure the state is reset after each item was decoded.
++ *
++ * Nested CborEncoder objects are created using cbor_encoder_create_array() and
++ * cbor_encoder_create_map(), later closed with cbor_encoder_close_container()
++ * or cbor_encoder_close_container_checked(). The pairs of creation and closing
++ * must be exactly matched and their parameters are always the same.
++ *
++ * CborEncoder writes directly to the user-supplied buffer, without extra
++ * buffering. CborEncoder does not allocate memory and CborEncoder objects are
++ * usually created on the stack of the encoding functions.
++ *
++ * The example below initializes a CborEncoder object with a buffer and encodes
++ * a single integer.
++ *
++ * \code
++ * uint8_t buf[16];
++ * CborEncoder encoder;
++ * cbor_encoder_init(&encoder, &buf, sizeof(buf), 0);
++ * cbor_encode_int(&encoder, some_value);
++ * \endcode
++ *
++ * As explained before, usually the outermost CborEncoder object is used to add
++ * one array or map, which in turn contains multiple elements. The example
++ * below creates a CBOR map with one element: a key "foo" and a boolean value.
++ *
++ * \code
++ * uint8_t buf[16];
++ * CborEncoder encoder, mapEncoder;
++ * cbor_encoder_init(&encoder, &buf, sizeof(buf), 0);
++ * cbor_encoder_create_map(&encoder, &mapEncoder, 1);
++ * cbor_encode_text_stringz(&mapEncoder, "foo");
++ * cbor_encode_boolean(&mapEncoder, some_value);
++ * cbor_encoder_close_container(&encoder, &mapEncoder);
++ * \endcode
++ *
++ * <h3 class="groupheader">Error checking and buffer size</h2>
++ *
++ * All functions operating on CborEncoder return a condition of type CborError.
++ * If the encoding was successful, they return CborNoError. Some functions do
++ * extra checking on the input provided and may return some other error
++ * conditions (for example, cbor_encode_simple_value() checks that the type is
++ * of the correct type).
++ *
++ * In addition, all functions check whether the buffer has enough bytes to
++ * encode the item being appended. If that is not possible, they return
++ * CborErrorOutOfMemory.
++ *
++ * It is possible to continue with the encoding of data past the first function
++ * that returns CborErrorOutOfMemory. CborEncoder functions will not overrun
++ * the buffer, but will instead count how many more bytes are needed to
++ * complete the encoding. At the end, you can obtain that count by calling
++ * cbor_encoder_get_extra_bytes_needed().
++ *
++ * \section1 Finalizing the encoding
++ *
++ * Once all items have been appended and the containers have all been properly
++ * closed, the user-supplied buffer will contain the CBOR stream and may be
++ * immediately used. To obtain the size of the buffer, call
++ * cbor_encoder_get_buffer_size() with the original buffer pointer.
++ *
++ * The example below illustrates how one can encode an item with error checking
++ * and then pass on the buffer for network sending.
++ *
++ * \code
++ * uint8_t buf[16];
++ * CborError err;
++ * CborEncoder encoder, mapEncoder;
++ * cbor_encoder_init(&encoder, &buf, sizeof(buf), 0);
++ * err = cbor_encoder_create_map(&encoder, &mapEncoder, 1);
++ * if (!err)
++ * return err;
++ * err = cbor_encode_text_stringz(&mapEncoder, "foo");
++ * if (!err)
++ * return err;
++ * err = cbor_encode_boolean(&mapEncoder, some_value);
++ * if (!err)
++ * return err;
++ * err = cbor_encoder_close_container_checked(&encoder, &mapEncoder);
++ * if (!err)
++ * return err;
++ *
++ * size_t len = cbor_encoder_get_buffer_size(&encoder, buf);
++ * send_payload(buf, len);
++ * return CborNoError;
++ * \endcode
++ *
++ * Finally, the example below illustrates expands on the one above and also
++ * deals with dynamically growing the buffer if the initial allocation wasn't
++ * big enough. Note the two places where the error checking was replaced with
++ * an assertion, showing where the author assumes no error can occur.
++ *
++ * \code
++ * uint8_t *encode_string_array(const char **strings, int n, size_t *bufsize)
++ * {
++ * CborError err;
++ * CborEncoder encoder, arrayEncoder;
++ * size_t size = 256;
++ * uint8_t *buf = NULL;
++ *
++ * while (1) {
++ * int i;
++ * size_t more_bytes;
++ * uint8_t *nbuf = realloc(buf, size);
++ * if (nbuf == NULL)
++ * goto error;
++ * buf = nbuf;
++ *
++ * cbor_encoder_init(&encoder, &buf, size, 0);
++ * err = cbor_encoder_create_array(&encoder, &arrayEncoder, n);
++ * assert(err); // can't fail, the buffer is always big enough
++ *
++ * for (i = 0; i < n; ++i) {
++ * err = cbor_encode_text_stringz(&arrayEncoder, strings[i]);
++ * if (err && err != CborErrorOutOfMemory)
++ * goto error;
++ * }
++ *
++ * err = cbor_encoder_close_container_checked(&encoder, &arrayEncoder);
++ * assert(err); // shouldn't fail!
++ *
++ * more_bytes = cbor_encoder_get_extra_bytes_needed(encoder);
++ * if (more_size) {
++ * // buffer wasn't big enough, try again
++ * size += more_bytes;
++ * continue;
++ * }
++ *
++ * *bufsize = cbor_encoder_get_buffer_size(encoder, buf);
++ * return buf;
++ * }
++ * error:
++ * free(buf);
++ * return NULL;
++ * }
++ * \endcode
++ */
++
++/**
++ * \addtogroup CborEncoding
++ * @{
++ */
++
++/**
++ * \struct CborEncoder
++ * Structure used to encode to CBOR.
++ */
++
++/**
++ * Initializes a CborEncoder structure \a encoder by pointing it to buffer \a
++ * buffer of size \a size. The \a flags field is currently unused and must be
++ * zero.
++ */
+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));
+}
+
- put64(buf + 1, ui); // we probably have a bunch of zeros in the beginning
++/* 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;
- unsigned more = 0;
++ put64(buf + 1, ui); /* we probably have a bunch of zeros in the beginning */
+
+ if (ui < Value8Bit) {
+ *bufstart += shiftedMajorType;
+ } else {
- bufstart -= 1 << more;
++ uint8_t 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);
+}
+
- // 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
++/**
++ * Appends the unsigned 64-bit integer \a value to the CBOR stream provided by
++ * \a encoder.
++ *
++ * \sa cbor_encode_negative_int, cbor_encode_int
++ */
+CborError cbor_encode_uint(CborEncoder *encoder, uint64_t value)
+{
+ return encode_number(encoder, value, UnsignedIntegerType << MajorTypeShift);
+}
+
++/**
++ * Appends the negative 64-bit integer whose absolute value is \a
++ * absolute_value to the CBOR stream provided by \a encoder.
++ *
++ * \sa cbor_encode_uint, cbor_encode_int
++ */
+CborError cbor_encode_negative_int(CborEncoder *encoder, uint64_t absolute_value)
+{
+ return encode_number(encoder, absolute_value, NegativeIntegerType << MajorTypeShift);
+}
+
++/**
++ * Appends the signed 64-bit integer \a value to the CBOR stream provided by
++ * \a encoder.
++ *
++ * \sa cbor_encode_negative_int, cbor_encode_uint
++ */
+CborError cbor_encode_int(CborEncoder *encoder, int64_t value)
+{
- // check if this is a valid simple type
++ /* 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);
+}
+
++/**
++ * Appends the CBOR Simple Type of value \a value to the CBOR stream provided by
++ * \a encoder.
++ *
++ * This function may return error CborErrorIllegalSimpleType if the \a value
++ * variable contains a number that is not a valid simple type.
++ */
+CborError cbor_encode_simple_value(CborEncoder *encoder, uint8_t value)
+{
+#ifndef CBOR_ENCODER_NO_CHECK_USER
- // tags don't count towards the number of elements in an array or map
++ /* check if this is a valid simple type */
+ if (value >= HalfPrecisionFloat && value <= Break)
+ return CborErrorIllegalSimpleType;
+#endif
+ return encode_number(encoder, value, SimpleTypesType << MajorTypeShift);
+}
+
++/**
++ * Appends the floating-point value of type \a fpType and pointed to by \a
++ * value to the CBOR stream provided by \a encoder. The value of \a fpType must
++ * be one of CborHalfFloatType, CborFloatType or CborDoubleType, otherwise the
++ * behavior of this function is undefined.
++ *
++ * This function is useful for code that needs to pass through floating point
++ * values but does not wish to have the actual floating-point code.
++ *
++ * \sa cbor_encode_half_float, cbor_encode_float, cbor_encode_double
++ */
+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);
+}
+
++/**
++ * Appends the CBOR tag \a tag to the CBOR stream provided by \a encoder.
++ *
++ * \sa CborTag
++ */
+CborError cbor_encode_tag(CborEncoder *encoder, CborTag tag)
+{
- if (err && !isOomError(err))
- return err;
-
- return CborNoError;
++ /* 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);
+}
+
++/**
++ * \fn CborError cbor_encode_text_stringz(CborEncoder *encoder, const char *string)
++ *
++ * Appends the null-terminated text string \a string to the CBOR stream
++ * provided by \a encoder. CBOR requires that \a string be valid UTF-8, but
++ * TinyCBOR makes no verification of correctness. The terminating null is not
++ * included in the stream.
++ *
++ * \sa cbor_encode_text_string, cbor_encode_byte_string
++ */
++
++/**
++ * Appends the text string \a string of length \a length to the CBOR stream
++ * provided by \a encoder. CBOR requires that \a string be valid UTF-8, but
++ * TinyCBOR makes no verification of correctness.
++ *
++ * \sa CborError cbor_encode_text_stringz, cbor_encode_byte_string
++ */
+CborError cbor_encode_byte_string(CborEncoder *encoder, const uint8_t *string, size_t length)
+{
+ return encode_string(encoder, length, ByteStringType << MajorTypeShift, string);
+}
+
++/**
++ * Appends the byte string \a string of length \a length to the CBOR stream
++ * provided by \a encoder. CBOR byte strings are arbitrary raw data.
++ *
++ * \sa cbor_encode_text_stringz, cbor_encode_text_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);
+ }
++ return err;
+}
+
++/**
++ * Creates a CBOR array in the CBOR stream provided by \a encoder and
++ * initializes \a arrayEncoder so that items can be added to the array using
++ * the CborEncoder functions. The array must be terminated by calling either
++ * cbor_encoder_close_container() or cbor_encoder_close_container_checked()
++ * with the same \a encoder and \a arrayEncoder parameters.
++ *
++ * The number of items inserted into the array must be exactly \a length items,
++ * otherwise the stream is invalid. If the number of items is not known when
++ * creating the array, the constant \ref CborIndefiniteLength may be passed as
++ * length instead.
++ *
++ * \sa cbor_encoder_create_map
++ */
+CborError cbor_encoder_create_array(CborEncoder *encoder, CborEncoder *arrayEncoder, size_t length)
+{
+ return create_container(encoder, arrayEncoder, length, ArrayType << MajorTypeShift);
+}
+
++/**
++ * Creates a CBOR map in the CBOR stream provided by \a encoder and
++ * initializes \a mapEncoder so that items can be added to the map using
++ * the CborEncoder functions. The map must be terminated by calling either
++ * cbor_encoder_close_container() or cbor_encoder_close_container_checked()
++ * with the same \a encoder and \a mapEncoder parameters.
++ *
++ * The number of pair of items inserted into the map must be exactly \a length
++ * items, otherwise the stream is invalid. If the number of items is not known
++ * when creating the map, the constant \ref CborIndefiniteLength may be passed as
++ * length instead.
++ *
++ * \b{Implementation limitation:} TinyCBOR cannot encode more than SIZE_MAX/2
++ * key-value pairs in the stream. If the length \a length is larger than this
++ * value, this function returns error CborErrorDataTooLarge.
++ *
++ * \sa cbor_encoder_create_array
++ */
+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);
+}
+
++/**
++ * Closes the CBOR container (array or map) provided by \a containerEncoder and
++ * updates the CBOR stream provided by \a encoder. Both parameters must be the
++ * same as were passed to cbor_encoder_create_array() or
++ * cbor_encoder_create_map().
++ *
++ * This function does not verify that the number of items (or pair of items, in
++ * the case of a map) was correct. To execute that verification, call
++ * cbor_encoder_close_container_checked() instead.
++ *
++ * \sa cbor_encoder_create_array(), cbor_encoder_create_map()
++ */
+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;
+}
++
++/**
++ * \fn CborError cbor_encode_boolean(CborEncoder *encoder, bool value)
++ *
++ * Appends the boolean value \a value to the CBOR stream provided by \a encoder.
++ */
++
++/**
++ * \fn CborError cbor_encode_null(CborEncoder *encoder)
++ *
++ * Appends the CBOR type representing a null value to the CBOR stream provided
++ * by \a encoder.
++ *
++ * \sa cbor_encode_undefined()
++ */
++
++/**
++ * \fn CborError cbor_encode_undefined(CborEncoder *encoder)
++ *
++ * Appends the CBOR type representing an undefined value to the CBOR stream
++ * provided by \a encoder.
++ *
++ * \sa cbor_encode_null()
++ */
++
++/**
++ * \fn CborError cbor_encode_half_float(CborEncoder *encoder, const void *value)
++ *
++ * Appends the IEEE 754 half-precision (16-bit) floating point value pointed to
++ * by \a value to the CBOR stream provided by \a encoder.
++ *
++ * \sa cbor_encode_floating_point(), cbor_encode_float(), cbor_encode_double()
++ */
++
++/**
++ * \fn CborError cbor_encode_float(CborEncoder *encoder, float value)
++ *
++ * Appends the IEEE 754 single-precision (32-bit) floating point value \a value
++ * to the CBOR stream provided by \a encoder.
++ *
++ * \sa cbor_encode_floating_point(), cbor_encode_half_float(), cbor_encode_double()
++ */
++
++/**
++ * \fn CborError cbor_encode_double(CborEncoder *encoder, double value)
++ *
++ * Appends the IEEE 754 double-precision (64-bit) floating point value \a value
++ * to the CBOR stream provided by \a encoder.
++ *
++ * \sa cbor_encode_floating_point(), cbor_encode_half_float(), cbor_encode_float()
++ */
++
++/**
++ * \fn size_t cbor_encoder_get_buffer_size(const CborEncoder *encoder, const uint8_t *buffer)
++ *
++ * Returns the total size of the buffer starting at \a buffer after the
++ * encoding finished without errors. The \a encoder and \a buffer arguments
++ * must be the same as supplied to cbor_encoder_init().
++ *
++ * If the encoding process had errors, the return value of this function is
++ * meaningless. If the only errors were CborErrorOutOfMemory, instead use
++ * cbor_encoder_get_extra_bytes_needed() to find out by how much to grow the
++ * buffer before encoding again.
++ *
++ * See \ref CborEncoding for an example of using this function.
++ *
++ * \sa cbor_encoder_init(), cbor_encoder_get_extra_bytes_needed(), CborEncoding
++ */
++
++/**
++ * \fn size_t cbor_encoder_get_extra_bytes_needed(const CborEncoder *encoder)
++ *
++ * Returns how many more bytes the original buffer supplied to
++ * cbor_encoder_init() needs to be extended by so that no CborErrorOutOfMemory
++ * condition will happen for the encoding. If the buffer was big enough, this
++ * function returns 0. The \a encoder must be the original argument as passed
++ * to cbor_encoder_init().
++ *
++ * This function is usually called after an encoding sequence ended with one or
++ * more CborErrorOutOfMemory errors, but no other error. If any other error
++ * happened, the return value of this function is meaningless.
++ *
++ * See \ref CborEncoding for an example of using this function.
++ *
++ * \sa cbor_encoder_init(), cbor_encoder_get_buffer_size(), CborEncoding
++ */
++
++/** @} */
--- /dev/null
- // check what the original length was
+/****************************************************************************
+**
+** 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 _DEFAULT_SOURCE 1
++#ifndef __STDC_LIMIT_MACROS
++# define __STDC_LIMIT_MACROS 1
++#endif
++
+#include "cbor.h"
+#include "cborconstants_p.h"
+#include "compilersupport_p.h"
+#include "extract_number_p.h"
+
+#include <assert.h>
+
+#include "assert_p.h" /* Always include last */
+
++/**
++ * \addtogroup CborEncoding
++ * @{
++ */
++
++/**
++ *
++ * Closes the CBOR container (array or map) provided by \a containerEncoder and
++ * updates the CBOR stream provided by \a encoder. Both parameters must be the
++ * same as were passed to cbor_encoder_create_array() or
++ * cbor_encoder_create_map().
++ *
++ * Unlike cbor_encoder_close_container(), this function checks that the number
++ * of items (or pair of items, in the case of a map) was correct. If the number
++ * of items inserted does not match the length originally passed to
++ * cbor_encoder_create_array() or cbor_encoder_create_map(), this function
++ * returns either CborErrorTooFewItems or CborErrorTooManyItems.
++ *
++ * \sa cbor_encoder_create_array(), cbor_encoder_create_map()
++ */
+CborError cbor_encoder_close_container_checked(CborEncoder *encoder, const CborEncoder *containerEncoder)
+{
+ const uint8_t *ptr = encoder->ptr;
+ CborError err = cbor_encoder_close_container(encoder, containerEncoder);
+ if (containerEncoder->flags & CborIteratorFlag_UnknownLength || encoder->end == NULL)
+ return err;
+
++ /* check what the original length was */
+ uint64_t actually_added;
+ err = extract_number(&ptr, encoder->ptr, &actually_added);
+ if (err)
+ return err;
+
+ if (containerEncoder->flags & CborIteratorFlag_ContainerIsMap) {
+ if (actually_added > SIZE_MAX / 2)
+ return CborErrorDataTooLarge;
+ actually_added *= 2;
+ }
+ return actually_added == containerEncoder->added ? CborNoError :
+ actually_added < containerEncoder->added ? CborErrorTooManyItems : CborErrorTooFewItems;
+}
++
++/** @} */
--- /dev/null
- ** Copyright (C) 2015 Intel Corporation
+/****************************************************************************
+**
++** 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.
+**
+****************************************************************************/
+
+#include "cbor.h"
+
+#ifndef _
+# define _(msg) msg
+#endif
+
++/**
++ * \enum CborError
++ * \ingroup CborGlobals
++ * The CborError enum contains the possible error values used by the CBOR encoder and decoder.
++ *
++ * TinyCBOR functions report success by returning CborNoError, or one error
++ * condition by returning one of the values below. One exception is the
++ * out-of-memory condition (CborErrorOutOfMemory), which the functions for \ref
++ * CborEncoding may report in bit-wise OR with other conditions.
++ *
++ * This technique allows code to determine whether the only error condition was
++ * a lack of buffer space, which may not be a fatal condition if the buffer can
++ * be resized. Additionally, the functions for \ref CborEncoding may continue
++ * to be used even after CborErrorOutOfMemory is returned, and instead they
++ * will simply calculate the extra space needed.
++ *
++ * \value CborNoError No error occurred
++ * \omitvalue CborUnknownError
++ * \value CborErrorUnknownLength Request for the length of an array, map or string whose length is not provided in the CBOR stream
++ * \value CborErrorAdvancePastEOF Not enough data in the stream to decode item (decoding would advance past end of stream)
++ * \value CborErrorIO An I/O error occurred, probably due to an out-of-memory situation
++ * \value CborErrorGarbageAtEnd Bytes exist past the end of the CBOR stream
++ * \value CborErrorUnexpectedEOF End of stream reached unexpectedly
++ * \value CborErrorUnexpectedBreak A CBOR break byte was found where not expected
++ * \value CborErrorUnknownType An unknown type (future extension to CBOR) was found in the stream
++ * \value CborErrorIllegalType An invalid type was found while parsing a chunked CBOR string
++ * \value CborErrorIllegalNumber An illegal initial byte (encoding unspecified additional information) was found
++ * \value CborErrorIllegalSimpleType An illegal encoding of a CBOR Simple Type of value less than 32 was found
++ * \omitvalue CborErrorUnknownSimpleType
++ * \omitvalue CborErrorUnknownTag
++ * \omitvalue CborErrorInappropriateTagForType
++ * \omitvalue CborErrorDuplicateObjectKeys
++ * \value CborErrorInvalidUtf8TextString Illegal UTF-8 encoding found while parsing CBOR Text String
++ * \value CborErrorTooManyItems Too many items were added to CBOR map or array of pre-determined length
++ * \value CborErrorTooFewItems Too few items were added to CBOR map or array of pre-determeined length
++ * \value CborErrorDataTooLarge Data item size exceeds TinyCBOR's implementation limits
++ * \value CborErrorNestingTooDeep Data item nesting exceeds TinyCBOR's implementation limits
++ * \omitvalue CborErrorUnsupportedType
++ * \value CborErrorJsonObjectKeyIsAggregate Conversion to JSON failed because the key in a map is a CBOR map or array
++ * \value CborErrorJsonObjectKeyNotString Conversion to JSON failed because the key in a map is not a text string
++ * \value CborErrorOutOfMemory During CBOR encoding, the buffer provided is insufficient for encoding the data item;
++ * in other situations, TinyCBOR failed to allocate memory
++ * \value CborErrorInternalError An internal error occurred in TinyCBOR
++ */
++
++/**
++ * \ingroup CborGlobals
++ * Returns the error string corresponding to the CBOR error condition \a error.
++ */
+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 CborErrorJsonNotImplemented:
++ return _("conversion to JSON failed: open_memstream unavailable");
+
+ case CborErrorInternalError:
+ return _("internal error");
+ }
+ return cbor_error_string(CborUnknownError);
+}
--- /dev/null
- #endif // CBORJSON_H
+/****************************************************************************
+**
+** Copyright (C) 2015 Intel Corporation
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+** copies of the Software, and to permit persons to whom the Software is
+** furnished to do so, subject to the following conditions:
+**
+** The above copyright notice and this permission notice shall be included in
+** all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+** OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+** THE SOFTWARE.
+**
+****************************************************************************/
+
+#ifndef CBORJSON_H
+#define CBORJSON_H
+
+#include "cbor.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Conversion to JSON */
+enum CborToJsonFlags
+{
+ CborConvertAddMetadata = 1,
+ CborConvertTagsToObjects = 2,
+ CborConvertIgnoreTags = 0,
+
+ CborConvertObeyByteStringTags = 0,
+ CborConvertByteStringsToBase64Url = 4,
+
+ CborConvertRequireMapStringKeys = 0,
+ CborConvertStringifyMapKeys = 8,
+
+ CborConvertDefaultFlags = 0
+};
+
+CBOR_API CborError cbor_value_to_json_advance(FILE *out, CborValue *value, int flags);
+CBOR_INLINE_API CborError cbor_value_to_json(FILE *out, const CborValue *value, int flags)
+{
+ CborValue copy = *value;
+ return cbor_value_to_json_advance(out, ©, flags);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
++#endif /* CBORJSON_H */
+
--- /dev/null
- ** Copyright (C) 2015 Intel Corporation
+/****************************************************************************
+**
- #include <stdlib.h>
++** 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.
+**
+****************************************************************************/
+
+#define _BSD_SOURCE 1
++#define _DEFAULT_SOURCE 1
++#ifndef __STDC_LIMIT_MACROS
++# define __STDC_LIMIT_MACROS 1
++#endif
++
+#include "cbor.h"
+#include "cborconstants_p.h"
+#include "compilersupport_p.h"
+#include "extract_number_p.h"
+
+#include <assert.h>
- * \typedef CborValue
- * This type contains one value parsed from the CBOR stream.
+#include <string.h>
+
+#include "assert_p.h" /* Always include last */
+
+#ifndef CBOR_PARSER_MAX_RECURSIONS
+# define CBOR_PARSER_MAX_RECURSIONS 1024
+#endif
+
+/**
- * 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().
++ * \defgroup CborParsing Parsing CBOR streams
++ * \brief Group of functions used to parse CBOR streams.
++ *
++ * TinyCBOR provides functions for pull-based stream parsing of a CBOR-encoded
++ * payload. The main data type for the parsing is a CborValue, which behaves
++ * like an iterator and can be used to extract the encoded data. It is first
++ * initialized with a call to cbor_parser_init() and is usually used to extract
++ * exactly one item, most often an array or map.
++ *
++ * Nested CborValue objects can be parsed using cbor_value_enter_container().
++ * Each call to cbor_value_enter_container() must be matched by a call to
++ * cbor_value_leave_container(), with the exact same parameters.
++ *
++ * The example below initializes a CborParser object, begins the parsing with a
++ * CborValue and decodes a single integer:
++ *
++ * \code
++ * int extract_int(const uint8_t *buffer, size_t len)
++ * {
++ * CborParser parser;
++ * CborValue value;
++ * int result;
++ * cbor_parser_init(buffer, len, 0, &buffer, &value);
++ * cbor_value_get_int(&value, &result);
++ * return result;
++ * }
++ * \endcode
++ *
++ * The code above does no error checking, which means it assumes the data comes
++ * from a source trusted to send one properly-encoded integer. The following
++ * example does the exact same operation, but includes error parsing and
++ * returns 0 on parsing failure:
++ *
++ * \code
++ * int extract_int(const uint8_t *buffer, size_t len)
++ * {
++ * CborParser parser;
++ * CborValue value;
++ * int result;
++ * if (cbor_parser_init(buffer, len, 0, &buffer, &value) != CborNoError)
++ * return 0;
++ * if (!cbor_value_is_integer(&value) ||
++ * cbor_value_get_int(&value, &result) != CborNoError)
++ * return 0;
++ * return result;
++ * }
++ * \endcode
++ *
++ * Note, in the example above, that one can't distinguish a parsing failure
++ * from an encoded value of zero. Reporting a parsing error is left as an
++ * exercise to the reader.
+ *
- * In C++ and C11 modes, you can additionally use the cbor_value_get_integer()
- * and cbor_value_get_floating_point() generic functions.
++ * The code above does not execute a range-check either: it is possible that
++ * the value decoded from the CBOR stream encodes a number larger than what can
++ * be represented in a variable of type \c{int}. If detecting that case is
++ * important, the code should call cbor_value_get_int_checked() instead.
+ *
- * \omit
++ * <h3 class="groupheader">Memory and parsing constraints</h3>
+ *
- * \endomit
++ * TinyCBOR is designed to run with little memory and with minimal overhead.
++ * Except where otherwise noted, the parser functions always run on constant
++ * time (O(1)), do not recurse and never allocate memory (thus, stack usage is
++ * bounded and is O(1)).
++ *
++ * <h3 class="groupheader">Error handling and preconditions</h3>
++ *
++ * All functions operating on a CborValue return a CborError condition, with
++ * CborNoError standing for the normal situation in which no parsing error
++ * occurred. All functions may return parsing errors in case the stream cannot
++ * be decoded properly, be it due to corrupted data or due to reaching the end
++ * of the input buffer.
++ *
++ * Error conditions must not be ignored. All decoder functions have undefined
++ * behavior if called after an error has been reported, and may crash.
++ *
++ * Some functions are also documented to have preconditions, like
++ * cbor_value_get_int() requiring that the input be an integral value.
++ * Violation of preconditions also results in undefined behavior and the
++ * program may crash.
++ */
++
++/**
++ * \addtogroup CborParsing
++ * @{
++ */
++
++/**
++ * \struct CborValue
++ *
++ * This type contains one value parsed from the CBOR stream. Each CborValue
++ * behaves as an iterator in a StAX-style parser.
++ *
++ * \if privatedocs
+ * 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
- *len = v;
++ * \endif
+ */
+
+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;
+ }
+
- // are we at the end?
++ *len = (size_t)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;
+
- // special case
++ /* 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))) {
- // fall through
++ /* 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;
- assert(false); // these conditions can't be reached
++ /* 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:
- // try to decode up to 16 bits
++ assert(false); /* these conditions can't be reached */
+ return CborErrorUnexpectedBreak;
+ }
+ return CborNoError;
+ }
+
- it->flags |= CborIteratorFlag_IntegerValueTooLarge; // Value32Bit or Value64Bit
++ /* 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
- // don't decrement the item count if the current item is tag: they don't count
++ it->flags |= CborIteratorFlag_IntegerValueTooLarge; /* Value32Bit or Value64Bit */
+ return CborNoError;
+}
+
+static CborError preparse_next_value(CborValue *it)
+{
+ if (it->remaining != UINT32_MAX) {
- // end of map or array
++ /* 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) {
- // since the additional information can only be Value32Bit or Value64Bit,
- // we just need to test for the one bit those two options differ
++ /* 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);
+
- *
- * ### Write how to determine the end pointer
- * ### Write how to do limited-buffer windowed decoding
++ /* 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.
- it->remaining = 1; // there's one type altogether, usually an array or map
+ */
+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;
- * \sa cbor_value_at_end(), cbor_value_advance(), cbor_value_begin_recurse(), cbor_value_end_recurse()
++ it->remaining = 1; /* there's one type altogether, usually an array or map */
+ return preparse_value(it);
+}
+
+/**
++ * \fn bool cbor_value_at_end(const CborValue *it)
++ *
++ * Returns true if \a it has reached the end of the iteration, usually when
++ * advancing after the last item in an array or map.
++ *
++ * In the case of the outermost CborValue object, this function returns true
++ * after decoding a single element. A pointer to the first byte of the
++ * remaining data (if any) can be obtained with cbor_value_get_next_byte().
++ *
++ * \sa cbor_value_advance(), cbor_value_is_valid(), cbor_value_get_next_byte()
++ */
++
++/**
++ * \fn const uint8_t *cbor_value_get_next_byte(const CborValue *it)
++ *
++ * Returns a pointer to the next byte that would be decoded if this CborValue
++ * object were advanced.
++ *
++ * This function is useful if cbor_value_at_end() returns true for the
++ * outermost CborValue: the pointer returned is the first byte of the data
++ * remaining in the buffer, if any. Code can decide whether to begin decoding a
++ * new CBOR data stream from this point, or parse some other data appended to
++ * the same buffer.
++ *
++ * This function may be used even after a parsing error. If that occurred,
++ * then this function returns a pointer to where the parsing error occurred.
++ * Note that the error recovery is not precise and the pointer may not indicate
++ * the exact byte containing bad data.
++ *
++ * \sa cbor_value_at_end()
++ */
++
++/**
++ * \fn bool cbor_value_is_valid(const CborValue *it)
++ *
++ * Returns true if the iterator \a it contains a valid value. Invalid iterators
++ * happen when iteration reaches the end of a container (see \ref
++ * cbor_value_at_end()) or when a search function resulted in no matches.
++ *
++ * \sa cbor_value_advance(), cbor_valie_at_end(), cbor_value_get_type()
++ */
++
++/**
+ * 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.
+ *
- // map or array
++ * If the type is not of fixed size, this function has undefined behavior. Code
++ * must be sure that the current type is one of the fixed-size types before
++ * calling this function. This function is provided because it can guarantee
++ * that runs in constant time (O(1)).
++ *
++ * If the caller is not able to determine whether the type is fixed or not, code
++ * can use the cbor_value_advance() function instead.
++ *
++ * \sa cbor_value_at_end(), cbor_value_advance(), cbor_value_enter_container(), cbor_value_leave_container()
+ */
+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);
+ }
+
- * \sa cbor_value_at_end(), cbor_value_advance_fixed(), cbor_value_begin_recurse(), cbor_value_end_recurse()
++ /* 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).
+ *
- // actually, break was expected here
- // it's just an empty container
++ * \sa cbor_value_at_end(), cbor_value_advance_fixed(), cbor_value_enter_container(), cbor_value_leave_container()
+ */
+CborError cbor_value_advance(CborValue *it)
+{
+ assert(it->type != CborInvalidType);
+ if (!it->remaining)
+ return CborErrorAdvancePastEOF;
+ return advance_recursive(it, 0);
+}
+
+/**
++ * \fn bool cbor_value_is_tag(const CborValue *value)
++ *
++ * Returns true if the iterator \a value is valid and points to a CBOR tag.
++ *
++ * \sa cbor_value_get_tag(), cbor_value_skip_tag()
++ */
++
++/**
++ * \fn CborError cbor_value_get_tag(const CborValue *value, CborTag *result)
++ *
++ * Retrieves the CBOR tag value that \a value points to and stores it in \a
++ * result. If the iterator \a value does not point to a CBOR tag value, the
++ * behavior is undefined, so checking with \ref cbor_value_get_type or with
++ * \ref cbor_value_is_tag is recommended.
++ *
++ * \sa cbor_value_get_type(), cbor_value_is_valid(), cbor_value_is_tag()
++ */
++
++/**
+ * 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.
+ *
++ * This function does not run in constant time: it will run on O(n) for n being
++ * the number of tags. It does use constant memory (O(1) memory requirements).
++ *
+ * \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.
+ *
++ * The \a it CborValue iterator must point to a 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;
- recursed->remaining = len;
++ /* 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);
+
- // back track the pointer to indicate where the error occurred
++ recursed->remaining = (uint32_t)len;
+ if (recursed->remaining != len || len == UINT32_MAX) {
- // maps have keys and values, so we need to multiply by 2
++ /* back track the pointer to indicate where the error occurred */
+ recursed->ptr = it->ptr;
+ return CborErrorDataTooLarge;
+ }
+ if (recursed->type == CborMapType) {
- // back track the pointer to indicate where the error occurred
++ /* maps have keys and values, so we need to multiply by 2 */
+ if (recursed->remaining > UINT32_MAX / 2) {
- // the case of the empty container
++ /* 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);
+ }
+
- * 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).
++ /* 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()).
+ *
++ * The \a it and \a recursed parameters must be the exact same as passed to
++ * cbor_value_enter_container().
++ *
+ * \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);
+}
+
++
+/**
- * \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.
++ * \fn CborType cbor_value_get_type(const CborValue *value)
+ *
- * \sa cbor_value_get_string_length(), cbor_value_copy_string(), cbor_value_is_length_known()
++ * Returns the type of the CBOR value that the iterator \a value points to. If
++ * \a value does not point to a valid value, this function returns \ref
++ * CborInvalidType.
+ *
- CborError cbor_value_calculate_string_length(const CborValue *value, size_t *len)
- {
- *len = SIZE_MAX;
- return _cbor_value_copy_string(value, NULL, len, NULL);
- }
++ * TinyCBOR also provides functions to test directly if a given CborValue object
++ * is of a given type, like cbor_value_is_text_string() and cbor_value_is_null().
++ *
++ * \sa cbor_value_is_valid()
+ */
- * \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).
++ * \fn bool cbor_value_is_null(const CborValue *value)
+ *
- * If \c malloc returns a NULL pointer, this function will return error
- * condition \ref CborErrorOutOfMemory.
++ * Returns true if the iterator \a value is valid and points to a CBOR null type.
+ *
- * 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.
++ * \sa cbor_value_is_valid(), cbor_value_is_undefined()
++ */
++
++/**
++ * \fn bool cbor_value_is_undefined(const CborValue *value)
+ *
- * 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.
++ * Returns true if the iterator \a value is valid and points to a CBOR undefined type.
+ *
- * \note This function does not perform UTF-8 validation on the incoming text
- * string.
++ * \sa cbor_value_is_valid(), cbor_value_is_null()
++ */
++
++/**
++ * \fn bool cbor_value_is_boolean(const CborValue *value)
+ *
- * \sa cbor_value_copy_text_string(), cbor_value_dup_byte_string()
++ * Returns true if the iterator \a value is valid and points to a CBOR boolean
++ * type (true or false).
+ *
- * \fn CborError cbor_value_dup_byte_string(const CborValue *value, uint8_t **buffer, size_t *buflen, CborValue *next)
++ * \sa cbor_value_is_valid(), cbor_value_get_boolean()
+ */
+
+/**
- * 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).
++ * \fn CborError cbor_value_get_boolean(const CborValue *value, bool *result)
+ *
- * If \c malloc returns a NULL pointer, this function will return error
- * condition \ref CborErrorOutOfMemory.
++ * Retrieves the boolean value that \a value points to and stores it in \a
++ * result. If the iterator \a value does not point to a boolean value, the
++ * behavior is undefined, so checking with \ref cbor_value_get_type or with
++ * \ref cbor_value_is_boolean is recommended.
+ *
- * 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.
++ * \sa cbor_value_get_type(), cbor_value_is_valid(), cbor_value_is_boolean()
++ */
++
++/**
++ * \fn bool cbor_value_is_simple_type(const CborValue *value)
+ *
- * 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.
++ * Returns true if the iterator \a value is valid and points to a CBOR Simple Type
++ * type (other than true, false, null and undefined).
+ *
- * \sa cbor_value_copy_byte_string(), cbor_value_dup_text_string()
++ * \sa cbor_value_is_valid(), cbor_value_get_simple_type()
++ */
++
++/**
++ * \fn CborError cbor_value_get_simple_type(const CborValue *value, uint8_t *result)
++ *
++ * Retrieves the CBOR Simple Type value that \a value points to and stores it
++ * in \a result. If the iterator \a value does not point to a simple_type
++ * value, the behavior is undefined, so checking with \ref cbor_value_get_type
++ * or with \ref cbor_value_is_simple_type is recommended.
++ *
++ * \sa cbor_value_get_type(), cbor_value_is_valid(), cbor_value_is_simple_type()
++ */
++
++/**
++ * \fn bool cbor_value_is_integer(const CborValue *value)
++ *
++ * Returns true if the iterator \a value is valid and points to a CBOR integer
++ * type.
++ *
++ * \sa cbor_value_is_valid(), cbor_value_get_int, cbor_value_get_int64, cbor_value_get_uint64, cbor_value_get_raw_integer
++ */
++
++/**
++ * \fn bool cbor_value_is_unsigned_integer(const CborValue *value)
+ *
- CborError _cbor_value_dup_string(const CborValue *value, void **buffer, size_t *buflen, CborValue *next)
++ * Returns true if the iterator \a value is valid and points to a CBOR unsigned
++ * integer type (positive values or zero).
++ *
++ * \sa cbor_value_is_valid(), cbor_value_get_uint64()
+ */
- assert(buffer);
- assert(buflen);
- *buflen = SIZE_MAX;
- CborError err = _cbor_value_copy_string(value, NULL, buflen, NULL);
- if (err)
- return err;
++
++/**
++ * \fn bool cbor_value_is_negative_integer(const CborValue *value)
++ *
++ * Returns true if the iterator \a value is valid and points to a CBOR negative
++ * integer type.
++ *
++ * \sa cbor_value_is_valid(), cbor_value_get_int, cbor_value_get_int64, cbor_value_get_raw_integer
++ */
++
++/**
++ * \fn CborError cbor_value_get_int(const CborValue *value, int *result)
++ *
++ * Retrieves the CBOR integer value that \a value points to and stores it in \a
++ * result. If the iterator \a value does not point to an integer value, the
++ * behavior is undefined, so checking with \ref cbor_value_get_type or with
++ * \ref cbor_value_is_integer is recommended.
++ *
++ * Note that this function does not do range-checking: integral values that do
++ * not fit in a variable of type \c{int} are silently truncated to fit. Use
++ * cbor_value_get_int_checked() that is not acceptable.
++ *
++ * \sa cbor_value_get_type(), cbor_value_is_valid(), cbor_value_is_integer()
++ */
++
++/**
++ * \fn CborError cbor_value_get_int64(const CborValue *value, int64_t *result)
++ *
++ * Retrieves the CBOR integer value that \a value points to and stores it in \a
++ * result. If the iterator \a value does not point to an integer value, the
++ * behavior is undefined, so checking with \ref cbor_value_get_type or with
++ * \ref cbor_value_is_integer is recommended.
++ *
++ * Note that this function does not do range-checking: integral values that do
++ * not fit in a variable of type \c{int64_t} are silently truncated to fit. Use
++ * cbor_value_get_int64_checked() that is not acceptable.
++ *
++ * \sa cbor_value_get_type(), cbor_value_is_valid(), cbor_value_is_integer()
++ */
++
++/**
++ * \fn CborError cbor_value_get_uint64(const CborValue *value, uint64_t *result)
++ *
++ * Retrieves the CBOR integer value that \a value points to and stores it in \a
++ * result. If the iterator \a value does not point to an unsigned integer
++ * value, the behavior is undefined, so checking with \ref cbor_value_get_type
++ * or with \ref cbor_value_is_unsigned_integer is recommended.
++ *
++ * \sa cbor_value_get_type(), cbor_value_is_valid(), cbor_value_is_unsigned_integer()
++ */
++
++/**
++ * \fn CborError cbor_value_get_raw_integer(const CborValue *value, uint64_t *result)
++ *
++ * Retrieves the CBOR integer value that \a value points to and stores it in \a
++ * result. If the iterator \a value does not point to an integer value, the
++ * behavior is undefined, so checking with \ref cbor_value_get_type or with
++ * \ref cbor_value_is_integer is recommended.
++ *
++ * This function is provided because CBOR negative integers can assume values
++ * that cannot be represented with normal 64-bit integer variables.
++ *
++ * If the integer is unsigned (that is, if cbor_value_is_unsigned_integer()
++ * returns true), then \a result will contain the actual value. If the integer
++ * is negative, then \a result will contain the absolute value of that integer,
++ * minus one. That is, \c {actual = -result - 1}. On architectures using two's
++ * complement for representation of negative integers, it is equivalent to say
++ * that \a result will contain the bitwise negation of the actual value.
++ *
++ * \sa cbor_value_get_type(), cbor_value_is_valid(), cbor_value_is_integer()
++ */
++
++/**
++ * Retrieves the CBOR integer value that \a value points to and stores it in \a
++ * result. If the iterator \a value does not point to an integer value, the
++ * behavior is undefined, so checking with \ref cbor_value_get_type or with
++ * \ref cbor_value_is_integer is recommended.
++ *
++ * Unlike cbor_value_get_int64(), this function performs a check to see if the
++ * stored integer fits in \a result without data loss. If the number is outside
++ * the valid range for the data type, this function returns the recoverable
++ * error CborErrorDataTooLarge. In that case, use either
++ * cbor_value_get_uint64() (if the number is positive) or
++ * cbor_value_get_raw_integer().
++ *
++ * \sa cbor_value_get_type(), cbor_value_is_valid(), cbor_value_is_integer(), cbor_value_get_int64()
++ */
++CborError cbor_value_get_int64_checked(const CborValue *value, int64_t *result)
+{
- ++*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;
++ assert(cbor_value_is_integer(value));
++ uint64_t v = _cbor_value_extract_int64_helper(value);
++
++ /* Check before converting, as the standard says (C11 6.3.1.3 paragraph 3):
++ * "[if] the new type is signed and the value cannot be represented in it; either the
++ * result is implementation-defined or an implementation-defined signal is raised."
++ *
++ * The range for int64_t is -2^63 to 2^63-1 (int64_t is required to be
++ * two's complement, C11 7.20.1.1 paragraph 3), which in CBOR is
++ * represented the same way, differing only on the "sign bit" (the major
++ * type).
++ */
++
++ if (unlikely(v > (uint64_t)INT64_MAX))
++ return CborErrorDataTooLarge;
+
- // 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.
++ *result = v;
++ if (value->flags & CborIteratorFlag_NegativeInteger)
++ *result = -*result - 1;
++ return CborNoError;
++}
++
++/**
++ * Retrieves the CBOR integer value that \a value points to and stores it in \a
++ * result. If the iterator \a value does not point to an integer value, the
++ * behavior is undefined, so checking with \ref cbor_value_get_type or with
++ * \ref cbor_value_is_integer is recommended.
++ *
++ * Unlike cbor_value_get_int(), this function performs a check to see if the
++ * stored integer fits in \a result without data loss. If the number is outside
++ * the valid range for the data type, this function returns the recoverable
++ * error CborErrorDataTooLarge. In that case, use one of the other integer
++ * functions to obtain the value.
++ *
++ * \sa cbor_value_get_type(), cbor_value_is_valid(), cbor_value_is_integer(), cbor_value_get_int64(),
++ * cbor_value_get_uint64(), cbor_value_get_int64_checked(), cbor_value_get_raw_integer()
++ */
++CborError cbor_value_get_int_checked(const CborValue *value, int *result)
++{
++ assert(cbor_value_is_integer(value));
++ uint64_t v = _cbor_value_extract_int64_helper(value);
++
++ /* Check before converting, as the standard says (C11 6.3.1.3 paragraph 3):
++ * "[if] the new type is signed and the value cannot be represented in it; either the
++ * result is implementation-defined or an implementation-defined signal is raised."
++ *
++ * But we can convert from signed to unsigned without fault (paragraph 2).
++ *
++ * The range for int is implementation-defined and int is not guaranteed use
++ * two's complement representation (int32_t is).
++ */
++
++ if (value->flags & CborIteratorFlag_NegativeInteger) {
++ if (unlikely(v > (unsigned) -(INT_MIN + 1)))
++ return CborErrorDataTooLarge;
++
++ *result = (int)v;
++ *result = -*result - 1;
++ } else {
++ if (unlikely(v > (uint64_t)INT_MAX))
++ return CborErrorDataTooLarge;
++
++ *result = (int)v;
+ }
+ return CborNoError;
++
+}
+
- // easy case: fixed length
++/**
++ * \fn bool cbor_value_is_length_known(const CborValue *value)
++ *
++ * Returns true if the length of this type is known without calculation. That
++ * is, if the length of this CBOR string, map or array is encoded in the data
++ * stream, this function returns true. If the length is not encoded, it returns
++ * false.
++ *
++ * If the length is known, code can call cbor_value_get_string_length(),
++ * cbor_value_get_array_length() or cbor_value_get_map_length() to obtain the
++ * length. If the length is not known but is necessary, code can use the
++ * cbor_value_calculate_string_length() function (no equivalent function is
++ * provided for maps and arrays).
++ */
++
++/**
++ * \fn bool cbor_value_is_text_string(const CborValue *value)
++ *
++ * Returns true if the iterator \a value is valid and points to a CBOR text
++ * string. CBOR text strings are UTF-8 encoded and usually contain
++ * human-readable text.
++ *
++ * \sa cbor_value_is_valid(), cbor_value_get_string_length(), cbor_value_calculate_string_length(),
++ * cbor_value_copy_text_string(), cbor_value_dup_text_string()
++ */
++
++/**
++ * \fn bool cbor_value_is_byte_string(const CborValue *value)
++ *
++ * Returns true if the iterator \a value is valid and points to a CBOR text
++ * string. CBOR byte strings are binary data with no specified encoding or
++ * format.
++ *
++ * \sa cbor_value_is_valid(), cbor_value_get_string_length(), cbor_value_calculate_string_length(),
++ * cbor_value_copy_byte_string(), cbor_value_dup_byte_string()
++ */
++
++/**
++ * \fn CborError cbor_value_get_string_length(const CborValue *value, size_t *length)
++ *
++ * Extracts the length of the byte or text string that \a value points to and
++ * stores it in \a result. If the iterator \a value does not point to a text
++ * string or a byte string, the behaviour is undefined, so checking with \ref
++ * cbor_value_get_type, with \ref cbor_value_is_text_string or \ref
++ * cbor_value_is_byte_string is recommended.
++ *
++ * If the length of this string is not encoded in the CBOR data stream, this
++ * function will return the recoverable error CborErrorUnknownLength. You may
++ * also check whether that is the case by using cbor_value_is_length_known().
++ *
++ * If the length of the string is required but the length was not encoded, use
++ * cbor_value_calculate_string_length(), but note that that function does not
++ * run in constant time.
++ *
++ * \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_is_valid(), cbor_value_is_length_known(), cbor_value_calculate_string_length()
++ */
++
++/**
++ * Calculates the length of the byte or text string that \a value points to and
++ * stores it in \a len. If the iterator \a value does not point to a text
++ * string or a byte string, the behaviour is undefined, so checking with \ref
++ * cbor_value_get_type, with \ref cbor_value_is_text_string or \ref
++ * cbor_value_is_byte_string is recommended.
++ *
++ * 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). It does use constant memory (O(1)).
++ *
++ * \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);
++}
++
++/* 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)) {
- *result = func(buffer, ptr, total);
++ /* 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)
- // chunked
++ *result = !!func(buffer, ptr, total);
+ else
+ *result = false;
+ ptr += total;
+ } else {
- // is this the right type?
++ /* 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;
+ }
+
- *result = func(buffer + total, ptr, chunkLen);
++ /* 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)
- // is there enough room for the ending NUL byte?
++ *result = !!func(buffer + total, ptr, chunkLen);
+ else
+ *result = false;
+
+ ptr += chunkLen;
+ total = newTotal;
+ }
+ }
+
- *result = func(buffer + total, (const uint8_t *)"", 1);
++ /* is there enough room for the ending NUL byte? */
+ if (*result && *buflen > total)
- * 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.
++ *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 iterator \a value does not point to a text string, the behaviour is
++ * undefined, so checking with \ref cbor_value_get_type or \ref
++ * cbor_value_is_text_string is recommended.
++ *
+ * 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.
+ *
++ * This function may not run in constant time (it will run in O(n) time on the
++ * number of chunks). It requires constant memory (O(1)).
++ *
+ * \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 iterator \a value does not point to a byte string, the behaviour is
++ * undefined, so checking with \ref cbor_value_get_type or \ref
++ * cbor_value_is_byte_string is recommended.
++ *
+ * 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.
+ *
++ * This function may not run in constant time (it will run in O(n) time on the
++ * number of chunks). It requires constant memory (O(1)).
++ *
+ * \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
- * 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.
++ * in \a result. If the value is different from \a 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.
++ *
++ * CBOR requires text strings to be encoded in UTF-8, but this function does
++ * not validate either the strings in the stream or the string \a string to be
++ * matched. Moreover, comparison is done on strict codepoint comparison,
++ * without any Unicode normalization.
++ *
++ * This function may not run in constant time (it will run in O(n) time on the
++ * number of chunks). It requires constant memory (O(1)).
++ *
++ * \sa cbor_value_skip_tag(), cbor_value_copy_text_string()
+ */
+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);
+}
+
+/**
++ * \fn bool cbor_value_is_array(const CborValue *value)
++ *
++ * Returns true if the iterator \a value is valid and points to a CBOR array.
++ *
++ * \sa cbor_value_is_valid(), cbor_value_is_map()
++ */
++
++/**
++ * \fn CborError cbor_value_get_array_length(const CborValue *value, size_t *length)
++ *
++ * Extracts the length of the CBOR array that \a value points to and stores it
++ * in \a result. If the iterator \a value does not point to a CBOR array, the
++ * behaviour is undefined, so checking with \ref cbor_value_get_type or \ref
++ * cbor_value_is_array is recommended.
++ *
++ * If the length of this array is not encoded in the CBOR data stream, this
++ * function will return the recoverable error CborErrorUnknownLength. You may
++ * also check whether that is the case by using cbor_value_is_length_known().
++ *
++ * \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_is_valid(), cbor_value_is_length_known()
++ */
++
++/**
++ * \fn bool cbor_value_is_map(const CborValue *value)
++ *
++ * Returns true if the iterator \a value is valid and points to a CBOR map.
++ *
++ * \sa cbor_value_is_valid(), cbor_value_is_array()
++ */
++
++/**
++ * \fn CborError cbor_value_get_map_length(const CborValue *value, size_t *length)
++ *
++ * Extracts the length of the CBOR map that \a value points to and stores it in
++ * \a result. If the iterator \a value does not point to a CBOR map, the
++ * behaviour is undefined, so checking with \ref cbor_value_get_type or \ref
++ * cbor_value_is_map is recommended.
++ *
++ * If the length of this map is not encoded in the CBOR data stream, this
++ * function will return the recoverable error CborErrorUnknownLength. You may
++ * also check whether that is the case by using cbor_value_is_length_known().
++ *
++ * \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_is_valid(), cbor_value_is_length_known()
++ */
++
++/**
+ * Attempts to find the value in map \a map that corresponds to the text string
- * \note This function may be expensive to execute.
++ * entry \a string. If the iterator \a value does not point to a CBOR map, the
++ * behaviour is undefined, so checking with \ref cbor_value_get_type or \ref
++ * cbor_value_is_map is recommended.
++ *
++ * 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. Matching is performed using
++ * cbor_value_text_string_equals(), so tagged strings will also match.
++ *
++ * This function has a time complexity of O(n) where n is the number of
++ * elements in the map to be searched. In addition, this function is has O(n)
++ * memory requirement based on the number of nested containers (maps or arrays)
++ * found as elements of this map.
+ *
- // find the non-tag so we can compare
++ * \sa cbor_value_is_valid(), cbor_value_text_string_equals(), cbor_value_advance()
+ */
+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)) {
- // skip this key
++ /* 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 value
++ /* skip this key */
+ err = cbor_value_advance(element);
+ if (err)
+ goto error;
+ }
+
- // not found
++ /* skip this value */
+ err = cbor_value_skip_tag(element);
+ if (err)
+ goto error;
+ err = cbor_value_advance(element);
+ if (err)
+ goto error;
+ }
+
- * Extracts a half-precision floating point from \a value and stores it in \a
- * result.
++ /* not found */
+ element->type = CborInvalidType;
+ return CborNoError;
+
+error:
+ element->type = CborInvalidType;
+ return err;
+}
+
+/**
- assert(value->type == CborHalfFloatType);
++ * \fn bool cbor_value_is_float(const CborValue *value)
++ *
++ * Returns true if the iterator \a value is valid and points to a CBOR
++ * single-precision floating point (32-bit).
++ *
++ * \sa cbor_value_is_valid(), cbor_value_is_double(), cbor_value_is_half_float()
++ */
++
++/**
++ * \fn CborError cbor_value_get_float(const CborValue *value, float *result)
++ *
++ * Retrieves the CBOR single-precision floating point (32-bit) value that \a
++ * value points to and stores it in \a result. If the iterator \a value does
++ * not point to a single-precision floating point value, the behavior is
++ * undefined, so checking with \ref cbor_value_get_type or with \ref
++ * cbor_value_is_float is recommended.
++ *
++ * \sa cbor_value_get_type(), cbor_value_is_valid(), cbor_value_is_float(), cbor_value_get_double()
++ */
++
++/**
++ * \fn bool cbor_value_is_double(const CborValue *value)
++ *
++ * Returns true if the iterator \a value is valid and points to a CBOR
++ * double-precision floating point (64-bit).
++ *
++ * \sa cbor_value_is_valid(), cbor_value_is_float(), cbor_value_is_half_float()
++ */
++
++/**
++ * \fn CborError cbor_value_get_double(const CborValue *value, float *result)
++ *
++ * Retrieves the CBOR double-precision floating point (64-bit) value that \a
++ * value points to and stores it in \a result. If the iterator \a value does
++ * not point to a double-precision floating point value, the behavior is
++ * undefined, so checking with \ref cbor_value_get_type or with \ref
++ * cbor_value_is_double is recommended.
++ *
++ * \sa cbor_value_get_type(), cbor_value_is_valid(), cbor_value_is_double(), cbor_value_get_float()
++ */
++
++/**
++ * \fn bool cbor_value_is_half_float(const CborValue *value)
++ *
++ * Returns true if the iterator \a value is valid and points to a CBOR
++ * single-precision floating point (16-bit).
++ *
++ * \sa cbor_value_is_valid(), cbor_value_is_double(), cbor_value_is_float()
++ */
++
++/**
++ * Retrieves the CBOR half-precision floating point (16-bit) value that \a
++ * value points to and stores it in \a result. If the iterator \a value does
++ * not point to a half-precision floating point value, the behavior is
++ * undefined, so checking with \ref cbor_value_get_type or with \ref
++ * cbor_value_is_half_float is recommended.
++ *
++ * Note: since the C language does not have a standard type for half-precision
++ * floating point, this function takes a \c{void *} as a parameter for the
++ * storage area, which must be at least 16 bits wide.
++ *
++ * \sa cbor_value_get_type(), cbor_value_is_valid(), cbor_value_is_half_float(), cbor_value_get_float()
+ */
+CborError cbor_value_get_half_float(const CborValue *value, void *result)
+{
- // size has been computed already
++ assert(cbor_value_is_half_float(value));
+
++ /* size has been computed already */
+ uint16_t v = get16(value->ptr + 1);
+ memcpy(result, &v, sizeof(v));
+ return CborNoError;
+}
++
++/** @} */
--- /dev/null
--- /dev/null
++/****************************************************************************
++**
++** Copyright (C) 2016 Intel Corporation
++**
++** Permission is hereby granted, free of charge, to any person obtaining a copy
++** of this software and associated documentation files (the "Software"), to deal
++** in the Software without restriction, including without limitation the rights
++** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
++** copies of the Software, and to permit persons to whom the Software is
++** furnished to do so, subject to the following conditions:
++**
++** The above copyright notice and this permission notice shall be included in
++** all copies or substantial portions of the Software.
++**
++** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++** OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
++** THE SOFTWARE.
++**
++****************************************************************************/
++
++#define _BSD_SOURCE 1
++#define _DEFAULT_SOURCE 1
++#ifndef __STDC_LIMIT_MACROS
++# define __STDC_LIMIT_MACROS 1
++#endif
++
++#include "cbor.h"
++#include <stdlib.h>
++
++/**
++ * \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 the iterator \a value does not point to a text string, the behaviour is
++ * undefined, so checking with \ref cbor_value_get_type or \ref
++ * cbor_value_is_text_string is recommended.
++ *
++ * 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.
++ *
++ * This function may not run in constant time (it will run in O(n) time on the
++ * number of chunks). It requires constant memory (O(1)) in addition to the
++ * malloc'ed block.
++ *
++ * \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 the iterator \a value does not point to a byte string, the behaviour is
++ * undefined, so checking with \ref cbor_value_get_type or \ref
++ * cbor_value_is_byte_string is recommended.
++ *
++ * 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.
++ *
++ * This function may not run in constant time (it will run in O(n) time on the
++ * number of chunks). It requires constant memory (O(1)) in addition to the
++ * malloc'ed block.
++ *
++ * \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;
++}
--- /dev/null
- ** Copyright (C) 2015 Intel Corporation
+/****************************************************************************
+**
- return 0; // should be n * 2, but we don't have the original n anymore
++** 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.
+**
+****************************************************************************/
+
+#define _BSD_SOURCE 1
++#define _DEFAULT_SOURCE 1
++#ifndef __STDC_LIMIT_MACROS
++# define __STDC_LIMIT_MACROS 1
++#endif
++
+#include "cbor.h"
+#include "compilersupport_p.h"
++#include "math_support_p.h"
+
+#include <float.h>
+#include <inttypes.h>
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
++/**
++ * \defgroup CborPretty Converting CBOR to text
++ * \brief Group of functions used to convert CBOR to text form.
++ *
++ * This group contains two functions that are can be used to convert one
++ * CborValue object to a text representation. This module attempts to follow
++ * the recommendations from RFC 7049 section 6 "Diagnostic Notation", though it
++ * has a few differences. They are noted below.
++ *
++ * TinyCBOR does not provide a way to convert from the text representation back
++ * to encoded form. To produce a text form meant to be parsed, CborToJson is
++ * recommended instead.
++ *
++ * Either of the functions in this section will attempt to convert exactly one
++ * CborValue object to text. Those functions may return any error documented
++ * for the functions for CborParsing. In addition, if the C standard library
++ * stream functions return with error, the text conversion will return with
++ * error CborErrorIO.
++ *
++ * These functions also perform UTF-8 validation in CBOR text strings. If they
++ * encounter a sequence of bytes that not permitted in UTF-8, they will return
++ * CborErrorInvalidUtf8TextString. That includes encoding of surrogate points
++ * in UTF-8.
++ *
++ * \warning The output type produced by these functions is not guaranteed to
++ * remain stable. A future update of TinyCBOR may produce different output for
++ * the same input and parsers may be unable to handle them.
++ *
++ * \sa CborParsing, CborToJson, cbor_parser_init()
++ */
++
++/**
++ * \addtogroup CborPretty
++ * @{
++ * <h2 class="groupheader">Text format</h2>
++ *
++ * As described in RFC 7049 section 6 "Diagnostic Notation", the format is
++ * largely borrowed from JSON, but modified to suit CBOR's different data
++ * types. TinyCBOR makes further modifications to distinguish different, but
++ * similar values.
++ *
++ * CBOR values are currently encoded as follows:
++ * \par Integrals (unsigned and negative)
++ * Base-10 (decimal) text representation of the value
++ * \par Byte strings:
++ * <tt>"h'"</tt> followed by the Base16 (hex) representation of the binary data, followed by an ending quote (')
++ * \par Text strings:
++ * C-style escaped string in quotes, with C11/C++11 escaping of Unicode codepoints above U+007F.
++ * \par Tags:
++ * Tag value, with the tagged value in parentheses. No special encoding of the tagged value is performed.
++ * \par Simple types:
++ * <tt>"simple(nn)"</tt> where \c nn is the simple value
++ * \par Null:
++ * \c null
++ * \par Undefined:
++ * \c undefined
++ * \par Booleans:
++ * \c true or \c false
++ * \par Floating point:
++ * If NaN or infinite, the actual words \c NaN or \c infinite.
++ * Otherwise, the decimal representation with as many digits as necessary to ensure no loss of information,
++ * with float values suffixed by "f" and half-float values suffixed by "f16" (doubles have no suffix). A dot is always present.
++ * \par Arrays:
++ * Comma-separated list of elements, enclosed in square brackets ("[" and "]").
++ * If the array length is indeterminate, an underscore ("_") appears immediately after the opening bracket.
++ * \par Maps:
++ * Comma-separated list of key-value pairs, with the key and value separated
++ * by a colon (":"), enclosed in curly braces ("{" and "}").
++ * If the map length is indeterminate, an underscore ("_") appears immediately after the opening brace.
++ */
++
+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;
+ }
- // single-byte UTF-8
++ 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) {
- // print as an escape sequence
++ /* single-byte UTF-8 */
+ if (uc < 0x7f && uc >= 0x20 && uc != '\\' && uc != '"') {
+ if (fprintf(out, "%c", (char)uc) < 0)
+ return CborErrorIO;
+ continue;
+ }
+
- // multi-byte UTF-8, decode it
++ /* 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;
+ }
+
- // first continuation character
++ /* 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;
+
- // second continuation character
++ /* first continuation character */
+ uint8_t b = (uint8_t)*buffer++;
+ if ((b & 0xc0) != 0x80)
+ return CborErrorInvalidUtf8TextString;
+ uc <<= 6;
+ uc |= b & 0x3f;
+
+ if (charsNeeded > 2) {
- // third continuation character
++ /* second continuation character */
+ b = (uint8_t)*buffer++;
+ if ((b & 0xc0) != 0x80)
+ return CborErrorInvalidUtf8TextString;
+ uc <<= 6;
+ uc |= b & 0x3f;
+
+ if (charsNeeded > 3) {
- // overlong sequence? surrogate pair? out or range?
++ /* third continuation character */
+ b = (uint8_t)*buffer++;
+ if ((b & 0xc0) != 0x80)
+ return CborErrorInvalidUtf8TextString;
+ uc <<= 6;
+ uc |= b & 0x3f;
+ }
+ }
+
- // now print the sequence
++ /* overlong sequence? surrogate pair? out or range? */
+ if (uc < min_uc || uc - 0xd800U < 2048U || uc > 0x10ffff)
+ return CborErrorInvalidUtf8TextString;
+
- // needs surrogate pairs
++ /* now print the sequence */
+ if (charsNeeded > 3) {
- (uc >> 10) + 0xd7c0, // high surrogate
++ /* needs surrogate pairs */
+ if (fprintf(out, "\\u%04" PRIX32 "\\u%04" PRIX32,
- // no surrogate pair needed
++ (uc >> 10) + 0xd7c0, /* high surrogate */
+ (uc % 0x0400) + 0xdc00) < 0)
+ return CborErrorIO;
+ } else {
+print_utf16:
- // map: that was the key, so get the value
++ /* 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;
+
- // recursive type
++ /* 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: {
- return err; // parse error
++ /* 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
++ return err; /* parse error */
+ }
+ err = container_to_pretty(out, &recursed, type);
+ if (err) {
+ it->ptr = recursed.ptr;
- return err; // parse error
++ return err; /* parse error */
+ }
+ err = cbor_value_leave_container(it, &recursed);
+ if (err)
- cbor_value_get_raw_integer(it, &val); // can't fail
++ return err; /* parse error */
+
+ if (fprintf(out, type == CborArrayType ? "]" : "}") < 0)
+ return CborErrorIO;
+ return CborNoError;
+ }
+
+ case CborIntegerType: {
+ uint64_t val;
- // 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
++ 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 {
- // overflown
- // 0xffff`ffff`ffff`ffff + 1 =
- // 0x1`0000`0000`0000`0000 = 18446744073709551616 (2^64)
++ /* 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 {
- cbor_value_get_tag(it, &tag); // can't fail
++ /* 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_simple_type(it, &simple_type); // can't fail
++ 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_boolean(it, &val); // can't fail
++ 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;
- // this double value fits in a 64-bit integer, so show it as such
- // (followed by a floating point suffix, to disambiguate)
++ 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 number is definitely not a 64-bit integer
++ /* 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;
+}
+
++/**
++ * \fn CborError cbor_value_to_pretty(FILE *out, const CborValue *value)
++ *
++ * Converts the current CBOR type pointed by \a value to its textual
++ * representation and writes it to the \a out stream. If an error occurs, this
++ * function returns an error code similar to CborParsing.
++ *
++ * \sa cbor_value_to_pretty_advance(), cbor_value_to_json_advance()
++ */
++
++/**
++ * Converts the current CBOR type pointed by \a value to its textual
++ * representation and writes it to the \a out stream. If an error occurs, this
++ * function returns an error code similar to CborParsing.
++ *
++ * If no error ocurred, this function advances \a value to the next element.
++ * Often, concatenating the text representation of multiple elements can be
++ * done by appending a comma to the output stream.
++ *
++ * \sa cbor_value_to_pretty(), cbor_value_to_json_advance()
++ */
+CborError cbor_value_to_pretty_advance(FILE *out, CborValue *value)
+{
+ return value_to_pretty(out, value);
+}
++
++/** @} */
--- /dev/null
- ** Copyright (C) 2015 Intel Corporation
+/****************************************************************************
+**
- TypeWasNotNative = 0x100, // anything but strings, boolean, null, arrays and maps
++** 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.
+**
+****************************************************************************/
+
+#define _BSD_SOURCE 1
++#define _DEFAULT_SOURCE 1
+#define _GNU_SOURCE 1
+#define _POSIX_C_SOURCE 200809L
++#ifndef __STDC_LIMIT_MACROS
++# define __STDC_LIMIT_MACROS 1
++#endif
++
+#include "cbor.h"
+#include "cborjson.h"
+#include "compilersupport_p.h"
++#include "math_support_p.h"
+
+#include <float.h>
+#include <inttypes.h>
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
++/**
++ * \defgroup CborToJson Converting CBOR to JSON
++ * \brief Group of functions used to convert CBOR to JSON.
++ *
++ * This group contains two functions that are can be used to convert one
++ * CborValue object to an equivalent JSON representation. This module attempts
++ * to follow the recommendations from RFC 7049 section 4.1 "Converting from
++ * CBOR to JSON", though it has a few differences. They are noted below.
++ *
++ * These functions produce a "minified" JSON output, with no spacing,
++ * indentation or line breaks. If those are necessary, they need to be applied
++ * in a post-processing phase.
++ *
++ * Note that JSON cannot support all CBOR types with fidelity, so the
++ * conversion is usually lossy. For that reason, TinyCBOR supports adding a set
++ * of metadata JSON values that can be used by a JSON-to-CBOR converter to
++ * restore the original data types.
++ *
++ * The TinyCBOR library does not provide a way to convert from JSON
++ * representation back to encoded form. However, it provides a tool called
++ * \c json2cbor which can be used for that purpose. That tool supports the
++ * metadata format that these functions may produce.
++ *
++ * Either of the functions in this section will attempt to convert exactly one
++ * CborValue object to JSON. Those functions may return any error documented
++ * for the functions for CborParsing. In addition, if the C standard library
++ * stream functions return with error, the text conversion will return with
++ * error CborErrorIO.
++ *
++ * These functions also perform UTF-8 validation in CBOR text strings. If they
++ * encounter a sequence of bytes that not permitted in UTF-8, they will return
++ * CborErrorInvalidUtf8TextString. That includes encoding of surrogate points
++ * in UTF-8.
++ *
++ * \warning The metadata produced by these functions is not guaranteed to
++ * remain stable. A future update of TinyCBOR may produce different output for
++ * the same input and parsers may be unable to handle them.
++ *
++ * \sa CborParsing, CborPretty, cbor_parser_init()
++ */
++
++/**
++ * \addtogroup CborToJson
++ * @{
++ * <h2 class="groupheader">Conversion limitations</h2>
++ *
++ * When converting from CBOR to JSON, there may be information loss. This
++ * section lists the possible scenarios.
++ *
++ * \par Number precision:
++ * ALL JSON numbers, due to its JavaScript heritage, are IEEE 754
++ * double-precision floating point. This means JSON is not capable of
++ * representing integers numbers outside the range [-(2<sup>53</sup>)+1,
++ * 2<sup>53</sup>-1] and is not capable of representing NaN or infinite. If the
++ * CBOR data contains a number outside the valid range, the conversion will
++ * lose precision. If the input was NaN or infinite, the result of the
++ * conversion will be "null". In addition, the distinction between half-,
++ * single- and double-precision is lost.
++ *
++ * \par
++ * If enabled, the original value and original type are stored in the metadata.
++ *
++ * \par Non-native types:
++ * CBOR's type system is richer than JSON's, which means some data values
++ * cannot be represented when converted to JSON. The conversion silently turns
++ * them into strings: CBOR simple types become "simple(nn)" where \c nn is the
++ * simple type's value, with the exception of CBOR undefined, which becomes
++ * "undefined", while CBOR byte strings are converted to an Base16, Base64, or
++ * Base64url encoding
++ *
++ * \par
++ * If enabled, the original type is stored in the metadata.
++ *
++ * \par Presence of tags:
++ * JSON has no support for tagged values, so by default tags are dropped when
++ * converting to JSON. However, if the CborConvertObeyByteStringTags option is
++ * active (default), then certain known tags are honored and are used to format
++ * the conversion of the tagged byte string to JSON.
++ *
++ * \par
++ * If the CborConvertTagsToObjects option is active, then the tag and the
++ * tagged value are converted to to a JSON object. Otherwise, if enabled, the
++ * last (innermost) tag is stored in the metadata.
++ *
++ * \par Non-string keys in maps:
++ * JSON requires all Object keys to be strings, while CBOR does not. By
++ * default, if a non-string key is found, the conversion fails with error
++ * CborErrorJsonObjectKeyNotString. If the CborConvertStringifyMapKeys option
++ * is active, then the conversion attempts to create a string representation
++ * using CborPretty. Note that the \c json2cbor tool is not able to parse this
++ * back to the original form.
++ *
++ * \par Duplicate keys in maps:
++ * Neither JSON nor CBOR allow duplicated keys, but current TinyCBOR does not
++ * validate that this is the case. If there are duplicated keys in the input,
++ * they will be repeated in the output, which may JSON tools may flag as
++ * invalid. In addition to that, if the CborConvertStringifyMapKeys option is
++ * active, it is possible that a non-string key in a CBOR map will be converted
++ * to a string form that is identical to another key.
++ *
++ * \par
++ * When metadata support is active, the conversion will add extra key-value
++ * pairs to the JSON output so it can store the metadata. It is possible that
++ * the keys for the metadata clash with existing keys in the JSON map.
++ */
++
+extern FILE *open_memstream(char **bufptr, size_t *sizeptr);
+
+enum ConversionStatusFlags {
- NumberWasNegative = 0x2000, // always used with NumberWasInifite or NumberWasTooBig
++ TypeWasNotNative = 0x100, /* anything but strings, boolean, null, arrays and maps */
+ TypeWasTagged = 0x200,
+ NumberPrecisionWasLost = 0x400,
+ NumberWasNaN = 0x800,
+ NumberWasInfinite = 0x1000,
- // a Base16 (hex) output is twice as big as our buffer
++ 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;
+
- // let cbor_value_copy_byte_string know we have an extra byte for the terminating NUL
++ /* a Base16 (hex) output is twice as big as our buffer */
+ buffer = (uint8_t *)malloc(n * 2 + 1);
+ *result = (char *)buffer;
+
- for (size_t i = 0; i < n; ++i) {
++ /* 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);
+
- // a Base64 output (untruncated) has 4 bytes for every 3 in the input
++ 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;
+
- // we read our byte string at the tail end of the buffer
- // so we can do an in-place conversion while iterating forwards
++ /* 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;
+
- // let cbor_value_copy_byte_string know we have an extra byte for the terminating NUL
++ /* 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;
+
- // read 3 bytes x 8 bits = 24 bits
++ /* 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) {
- // write 4 chars x 6 bits = 24 bits
++ /* 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];
+ }
+
- // maybe 1 or 2 bytes left
++ /* 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];
+ }
+
- // 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
++ /* maybe 1 or 2 bytes left */
+ if (n - i) {
- // the 65th character in the alphabet is our filler: either '=' or '\0'
++ /* 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;
+
- // write the third char in 3 chars x 6 bits = 18 bits
++ /* the 65th character in the alphabet is our filler: either '=' or '\0' */
+ out[4] = '\0';
+ out[3] = alphabet[64];
+ if (n - i == 2) {
- out[2] = alphabet[64]; // filler
++ /* write the third char in 3 chars x 6 bits = 18 bits */
+ out[2] = alphabet[(val >> 6) & 0x3f];
+ } else {
- // extract the tagged type, which may be JSON native
++ 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) {
- // print at least the type
++ /* 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;
+
- cbor_value_get_tag(it, tag); // can't fail
++ /* 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
++ 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) {
- // special handling of byte strings?
++ 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;
+
- } else { // tag == CborExpectedBase16Tag
++ /* 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);
- // no special handling
++ } 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;
+ }
+
- (void)flags; // unused
- (void)type; // unused
++ /* 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)
+{
- return CborErrorOutOfMemory; // could also be EMFILE, but it's unlikely
++ (void)flags; /* unused */
++ (void)type; /* unused */
++#ifdef WITHOUT_OPEN_MEMSTREAM
++ (void)key; /* unused */
++ (void)it; /* unused */
++ return CborErrorJsonNotImplemented;
++#else
+ size_t size;
+
+ FILE *memstream = open_memstream(key, &size);
+ if (memstream == NULL)
- // first, print the key
++ 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;
++#endif
+}
+
+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;
+
- // then, print the value
++ /* first, print the key */
+ if (fprintf(out, "\"%s\":", key) < 0)
+ return CborErrorIO;
+
- // finally, print any metadata we may have
++ /* then, print the value */
+ CborType valueType = cbor_value_get_type(it);
+ err = value_to_json(out, it, flags, valueType, status);
+
- // recursive type
++ /* 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: {
- return err; // parse error
++ /* recursive type */
+ CborValue recursed;
+ err = cbor_value_enter_container(it, &recursed);
+ if (err) {
+ it->ptr = recursed.ptr;
- return err; // parse error
++ 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
++ return err; /* parse error */
+ }
+
+ if (fputc(type == CborArrayType ? ']' : '}', out) < 0)
+ return CborErrorIO;
+ err = cbor_value_leave_container(it, &recursed);
+ if (err)
- status->flags = 0; // reset, there are never conversion errors for us
++ return err; /* parse error */
+
- double num; // JS numbers are IEEE double precision
++ status->flags = 0; /* reset, there are never conversion errors for us */
+ return CborNoError;
+ }
+
+ case CborIntegerType: {
- cbor_value_get_raw_integer(it, &val); // can't fail
- num = val;
++ double num; /* JS numbers are IEEE double precision */
+ uint64_t val;
- num = -num - 1; // convert to negative
++ cbor_value_get_raw_integer(it, &val); /* can't fail */
++ num = (double)val;
+
+ if (cbor_value_is_negative_integer(it)) {
- if (fprintf(out, "%.0f", num) < 0) // this number has no fraction, so no decimal points please
++ 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;
+ }
+ }
- cbor_value_get_simple_type(it, &simple_type); // can't fail
++ 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_boolean(it, &val); // can't fail
++ 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;
- // print as integer so we get the full precision
++ 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)) {
- status->flags |= TypeWasNotNative; // mark this integer number as a double
++ /* print as integer so we get the full precision */
+ r = fprintf(out, "%s%" PRIu64, val < 0 ? "-" : "", ival);
- // this number is definitely not a 64-bit integer
++ 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);
+}
+
++/**
++ * \enum CborToJsonFlags
++ * The CborToJsonFlags enum contains flags that control the conversion of CBOR to JSON.
++ *
++ * \value CborConvertAddMetadata Adds metadata to facilitate restoration of the original CBOR data.
++ * \value CborConvertTagsToObjects Converts CBOR tags to JSON objects
++ * \value CborConvertIgnoreTags (default) Ignore CBOR tags, except for byte strings
++ * \value CborConvertObeyByteStringTags (default) Honor formatting of CBOR byte strings if so tagged
++ * \value CborConvertByteStringsToBase64Url Force the conversion of all CBOR byte strings to Base64url encoding, despite any tags
++ * \value CborConvertRequireMapStringKeys (default) Require CBOR map keys to be strings, failing the conversion if they are not
++ * \value CborConvertStringifyMapKeys Convert non-string keys in CBOR maps to a string form
++ * \value CborConvertDefaultFlags Default conversion flags.
++ */
++
++/**
++ * \fn CborError cbor_value_to_json(FILE *out, const CborValue *value, int flags)
++ *
++ * Converts the current CBOR type pointed by \a value to JSON and writes that
++ * to the \a out stream. If an error occurs, this function returns an error
++ * code similar to CborParsing. The \a flags parameter indicates one of the
++ * flags from CborToJsonFlags that control the conversion.
++ *
++ * \sa cbor_value_to_json_advance(), cbor_value_to_pretty()
++ */
++
++/**
++ * Converts the current CBOR type pointed by \a value to JSON and writes that
++ * to the \a out stream. If an error occurs, this function returns an error
++ * code similar to CborParsing. The \a flags parameter indicates one of the
++ * flags from CborToJsonFlags that control the conversion.
++ *
++ * If no error ocurred, this function advances \a value to the next element.
++ *
++ * \sa cbor_value_to_json(), cbor_value_to_pretty_advance()
++ */
+CborError cbor_value_to_json_advance(FILE *out, CborValue *value, int flags)
+{
+ ConversionStatus status;
+ return value_to_json(out, value, flags, cbor_value_get_type(value), &status);
+}
++
++/** @} */
--- /dev/null
- #include <math.h>
+/****************************************************************************
+**
+** 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
++#ifndef _DEFAULT_SOURCE
++# define _DEFAULT_SOURCE
++#endif
+#include <assert.h>
+#include <float.h>
- #ifndef UINT32_MAX
- /* C99 requires it in stdint.h, but some systems lack it */
- # define UINT32_MAX (0xffffffffU)
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
+#ifndef __cplusplus
+# include <stdbool.h>
+#endif
+
+#ifdef __F16C__
+# include <immintrin.h>
+#endif
+
+#if __STDC_VERSION__ >= 201112L || __cplusplus >= 201103L || __cpp_static_assert >= 200410
+# define cbor_static_assert(x) static_assert(x, #x)
+#elif !defined(__cplusplus) && defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 406)
+# define cbor_static_assert(x) _Static_assert(x, #x)
+#else
+# define cbor_static_assert(x) ((void)sizeof(char[2*!!(x) - 1]))
+#endif
++#if __STDC_VERSION__ >= 199901L || defined(__cplusplus)
++/* inline is a keyword */
++#else
++/* use the definition from cbor.h */
++# define inline CBOR_INLINE
++#endif
+
+#define STRINGIFY(x) STRINGIFY2(x)
+#define STRINGIFY2(x) #x
+
- // DBL_DECIMAL_DIG is C11
++#if !defined(UINT32_MAX) || !defined(INT64_MAX)
++/* C89? We can define UINT32_MAX portably, but not INT64_MAX */
++# error "Your system has stdint.h but that doesn't define UINT32_MAX or INT64_MAX"
+#endif
++
+#ifndef DBL_DECIMAL_DIG
- // C-style const_cast without triggering a warning with -Wcast-qual
++/* DBL_DECIMAL_DIG is C11 */
+# define DBL_DECIMAL_DIG 17
+#endif
+#define DBL_DECIMAL_DIG_STR STRINGIFY(DBL_DECIMAL_DIG)
+
+#ifndef __has_builtin
+# define __has_builtin(x) 0
+#endif
+
+#if (defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 403)) || \
+ (__has_builtin(__builtin_bswap64) && __has_builtin(__builtin_bswap32))
+# if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+# define cbor_ntohll __builtin_bswap64
+# define cbor_htonll __builtin_bswap64
+# define cbor_ntohl __builtin_bswap32
+# define cbor_htonl __builtin_bswap32
+# ifdef __INTEL_COMPILER
+# define cbor_ntohs _bswap16
+# define cbor_htons _bswap16
+# elif (__GNUC__ * 100 + __GNUC_MINOR__ >= 608) || __has_builtin(__builtin_bswap16)
+# define cbor_ntohs __builtin_bswap16
+# define cbor_htons __builtin_bswap16
+# else
+# define cbor_ntohs(x) (((uint16_t)x >> 8) | ((uint16_t)x << 8))
+# define cbor_htons cbor_ntohs
+# endif
+# else
+# define cbor_ntohll
+# define cbor_htonll
+# define cbor_ntohl
+# define cbor_htonl
+# define cbor_ntohs
+# define cbor_htons
+# endif
+#elif defined(__sun)
+# include <sys/byteorder.h>
+#elif defined(_MSC_VER)
+/* MSVC, which implies Windows, which implies little-endian and sizeof(long) == 4 */
+# define cbor_ntohll _byteswap_uint64
+# define cbor_htonll _byteswap_uint64
+# define cbor_ntohl _byteswap_ulong
+# define cbor_htonl _byteswap_ulong
+# define cbor_ntohs _byteswap_ushort
+# define cbor_htons _byteswap_ushort
+#endif
+#ifndef cbor_ntohs
+# include <arpa/inet.h>
+# define cbor_ntohs ntohs
+# define cbor_htons htons
+#endif
+#ifndef cbor_ntohl
+# include <arpa/inet.h>
+# define cbor_ntohl ntohl
+# define cbor_htonl htonl
+#endif
+#ifndef cbor_ntohll
+# define cbor_ntohll ntohll
+# define cbor_htonll htonll
+/* ntohll isn't usually defined */
+# ifndef ntohll
+# if defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+# define ntohll
+# define htonll
+# elif defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+# define ntohll(x) ((ntohl((uint32_t)(x)) * UINT64_C(0x100000000)) + (ntohl((x) >> 32)))
+# define htonll ntohll
+# else
+# error "Unable to determine byte order!"
+# endif
+# endif
+#endif
+
+
+#ifdef __cplusplus
+# define CONST_CAST(t, v) const_cast<t>(v)
+#else
- // unsigned additions are well-defined
++/* 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
- int mant = v << 12 >> 12 >> (53-11); // keep only the 11 most significant bits of the mantissa
++ /* 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;
- // infinity or NaN
++ int mant = v << 12 >> 12 >> (53-11); /* keep only the 11 most significant bits of the mantissa */
+ exp -= 1023;
+ if (exp == 1024) {
- // overflow, as largest number
++ /* infinity or NaN */
+ exp = 16;
+ mant >>= 1;
+ } else if (exp >= 16) {
- // regular normal
++ /* overflow, as largest number */
+ exp = 15;
+ mant = 1023;
+ } else if (exp >= -14) {
- // subnormal
++ /* regular normal */
+ } else if (exp >= -24) {
- // underflow, make zero
++ /* subnormal */
+ mant |= 1024;
+ mant >>= -(exp + 14);
+ exp = -15;
+ } else {
- return sign | ((exp + 15) << 10) | mant;
- #endif
- }
++ /* underflow, make zero */
+ return 0;
+ }
- // 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 // COMPILERSUPPORT_H
++ /* safe cast here as bit operations above guarantee not to overflow */
++ return (unsigned short)(sign | ((exp + 15) << 10) | mant);
+#endif
+}
+
++#endif /* COMPILERSUPPORT_H */
+
--- /dev/null
- size_t bytesNeeded = 1 << (additional_information - Value8Bit);
+/****************************************************************************
+**
+** 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 _DEFAULT_SOURCE 1
+#include "cbor.h"
+#include "cborconstants_p.h"
+#include "compilersupport_p.h"
+#include <stdlib.h>
+
+static inline uint16_t get16(const uint8_t *ptr)
+{
+ uint16_t result;
+ memcpy(&result, ptr, sizeof(result));
+ return cbor_ntohs(result);
+}
+
+static inline uint32_t get32(const uint8_t *ptr)
+{
+ uint32_t result;
+ memcpy(&result, ptr, sizeof(result));
+ return cbor_ntohl(result);
+}
+
+static inline uint64_t get64(const uint8_t *ptr)
+{
+ uint64_t result;
+ memcpy(&result, ptr, sizeof(result));
+ return cbor_ntohll(result);
+}
+
+static CborError extract_number(const uint8_t **ptr, const uint8_t *end, uint64_t *len)
+{
+ uint8_t additional_information = **ptr & SmallValueMask;
+ ++*ptr;
+ if (additional_information < Value8Bit) {
+ *len = additional_information;
+ return CborNoError;
+ }
+ if (unlikely(additional_information > Value64Bit))
+ return CborErrorIllegalNumber;
+
++ size_t bytesNeeded = (size_t)(1 << (additional_information - Value8Bit));
+ if (unlikely(bytesNeeded > (size_t)(end - *ptr))) {
+ return CborErrorUnexpectedEOF;
+ } else if (bytesNeeded == 1) {
+ *len = (uint8_t)(*ptr)[0];
+ } else if (bytesNeeded == 2) {
+ *len = get16(*ptr);
+ } else if (bytesNeeded == 4) {
+ *len = get32(*ptr);
+ } else {
+ *len = get64(*ptr);
+ }
+ *ptr += bytesNeeded;
+ return CborNoError;
+}
--- /dev/null
--- /dev/null
++/****************************************************************************
++**
++** Copyright (C) 2016 Intel Corporation
++**
++** Permission is hereby granted, free of charge, to any person obtaining a copy
++** of this software and associated documentation files (the "Software"), to deal
++** in the Software without restriction, including without limitation the rights
++** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
++** copies of the Software, and to permit persons to whom the Software is
++** furnished to do so, subject to the following conditions:
++**
++** The above copyright notice and this permission notice shall be included in
++** all copies or substantial portions of the Software.
++**
++** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++** OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
++** THE SOFTWARE.
++**
++****************************************************************************/
++
++#ifndef MATH_SUPPORT_H
++#define MATH_SUPPORT_H
++
++#include <math.h>
++
++/* this function was copied & adapted from RFC 7049 Appendix D */
++static inline double decode_half(unsigned short half)
++{
++#ifdef __F16C__
++ return _cvtsh_ss(half);
++#else
++ int exp = (half >> 10) & 0x1f;
++ int mant = half & 0x3ff;
++ double val;
++ if (exp == 0) val = ldexp(mant, -24);
++ else if (exp != 31) val = ldexp(mant + 1024, exp - 25);
++ else val = mant == 0 ? INFINITY : NAN;
++ return half & 0x8000 ? -val : val;
++#endif
++}
++
++#endif // MATH_SUPPORT_H
++
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2015 Intel Corporation
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+** copies of the Software, and to permit persons to whom the Software is
+** furnished to do so, subject to the following conditions:
+**
+** The above copyright notice and this permission notice shall be included in
+** all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+** OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+** THE SOFTWARE.
+**
+****************************************************************************/
+
+#define _BSD_SOURCE 1
++#define _DEFAULT_SOURCE 1
+#define _GNU_SOURCE 1
+
+#include <sys/types.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#if defined(__unix__) || defined(__APPLE__)
+# include <unistd.h>
+#endif
+#ifdef __APPLE__
+typedef int RetType;
+typedef int LenType;
+#elif __GLIBC__
+typedef ssize_t RetType;
+typedef size_t LenType;
+#else
+# error "Cannot implement open_memstream!"
+#endif
+
+#include "compilersupport_p.h"
+
+struct Buffer
+{
+ char **ptr;
+ size_t *len;
+ size_t alloc;
+};
+
+static RetType write_to_buffer(void *cookie, const char *data, LenType len)
+{
+ struct Buffer *b = (struct Buffer *)cookie;
+ char *ptr = *b->ptr;
+ size_t newsize;
+
+ errno = EFBIG;
+ if (unlikely(add_check_overflow(*b->len, len, &newsize)))
+ return -1;
+
+ if (newsize > b->alloc) {
+ // make room
+ size_t newalloc = newsize + newsize / 2 + 1; // give 50% more room
+ ptr = realloc(ptr, newalloc);
+ if (ptr == NULL)
+ return -1;
+ b->alloc = newalloc;
+ *b->ptr = ptr;
+ }
+
+ memcpy(ptr + *b->len, data, len);
+ *b->len = newsize;
+ return len;
+}
+
+static int close_buffer(void *cookie)
+{
+ struct Buffer *b = (struct Buffer *)cookie;
+ if (*b->ptr)
+ (*b->ptr)[*b->len] = '\0';
+ free(b);
+ return 0;
+}
+
+FILE *open_memstream(char **bufptr, size_t *lenptr)
+{
+ struct Buffer *b = (struct Buffer *)malloc(sizeof(struct Buffer));
+ if (b == NULL)
+ return NULL;
+ b->alloc = 0;
+ b->len = lenptr;
+ b->ptr = bufptr;
+ *bufptr = NULL;
+ *lenptr = 0;
+
+#ifdef __APPLE__
+ return funopen(b, NULL, write_to_buffer, NULL, close_buffer);
+#elif __GLIBC__
+ static const cookie_io_functions_t vtable = {
+ NULL,
+ write_to_buffer,
+ NULL,
+ close_buffer
+ };
+ return fopencookie(b, "w", vtable);
+#endif
+}
+
--- /dev/null
+SOURCES += \
+ $$PWD/cborencoder.c \
+ $$PWD/cborencoder_close_container_checked.c \
+ $$PWD/cborerrorstrings.c \
+ $$PWD/cborparser.c \
++ $$PWD/cborparser_dup_string.c \
+ $$PWD/cborpretty.c \
+ $$PWD/cbortojson.c \
+
+QMAKE_CFLAGS *= $$QMAKE_CFLAGS_SPLIT_SECTIONS
+QMAKE_LFLAGS *= $$QMAKE_LFLAGS_GCSECTIONS
+INCLUDEPATH += $$PWD
++CONFIG(release, debug|release): DEFINES += NDEBUG
--- /dev/null
+TEMPLATE = lib
+CONFIG += static
++CONFIG -= qt
+DESTDIR = ../lib
+
+include(src.pri)
--- /dev/null
--- /dev/null
++Makefile
++debug
++moc_predefs.h
++release
++target_wrapper.*
++
++# The executables
++cpp/cpp
++cpp/cpp.exe
++encoder/encoder
++encoder/encoder.exe
++parser/parser
++parser/parser.exe
++tojson/tojson
++tojson/tojson.exe
--- /dev/null
- // All it does is verify that the three source files above
+/****************************************************************************
+**
+** 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/cborparser_dup_string.c"
+#include "../../src/cborerrorstrings.c"
+
+#include <QtTest>
+
+// This is a compilation-only test.
++// All it does is verify that the four source files above
+// compile as C++ without errors.
+class tst_Cpp : public QObject
+{
+ Q_OBJECT
+};
+
+QTEST_MAIN(tst_Cpp)
+#include "tst_cpp.moc"
--- /dev/null
- POST_TARGETDEPS += ../../lib/libtinycbor.a
+SOURCES += tst_encoder.cpp
+
+CONFIG += testcase parallel_test c++11
+QT = core testlib
+
+INCLUDEPATH += ../../src
++msvc: POST_TARGETDEPS = ../../lib/tinycbor.lib
++else: POST_TARGETDEPS += ../../lib/libtinycbor.a
+LIBS += $$POST_TARGETDEPS
--- /dev/null
- ** Copyright (C) 2015 Intel Corporation
+/****************************************************************************
+**
- cbor_encoder_init(&encoder, reinterpret_cast<quint8 *>(buffer.data()), buffer.length(), 0);
++** 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.
+**
+****************************************************************************/
+
+#include <QtTest>
+#include "cbor.h"
+
+Q_DECLARE_METATYPE(CborError)
+
+class tst_Encoder : public QObject
+{
+ Q_OBJECT
+private slots:
+ void fixed_data();
+ void fixed();
+ void strings_data();
+ void strings() { fixed(); }
+ void arraysAndMaps_data();
+ void arraysAndMaps() { fixed(); }
+ void tags_data();
+ void tags();
+ void arrays_data() { tags_data(); }
+ void arrays();
+ void maps_data() { tags_data(); }
+ void maps();
+
+ void shortBuffer_data() { tags_data(); }
+ void shortBuffer();
+ void tooShortArrays_data() { tags_data(); }
+ void tooShortArrays();
+ void tooShortMaps_data() { tags_data(); }
+ void tooShortMaps();
+ void tooBigArrays_data() { tags_data(); }
+ void tooBigArrays();
+ void tooBigMaps_data() { tags_data(); }
+ void tooBigMaps();
+ void illegalSimpleType_data();
+ void illegalSimpleType();
+};
+
+#include "tst_encoder.moc"
+
++static float myNaNf()
++{
++ uint32_t v = 0x7fc00000;
++ float f;
++ memcpy(&f, &v, sizeof(f));
++ Q_ASSERT(qIsNaN(f));
++ return f;
++}
++
++static float myInff()
++{
++ uint32_t v = 0x7f800000;
++ float f;
++ memcpy(&f, &v, sizeof(f));
++ Q_ASSERT(qIsInf(f));
++ return f;
++}
++
++static float myNInff()
++{
++ uint32_t v = 0xff800000;
++ float f;
++ memcpy(&f, &v, sizeof(f));
++ Q_ASSERT(qIsInf(f));
++ return f;
++}
++
++static double myNaN()
++{
++ uint64_t v = UINT64_C(0x7ff8000000000000);
++ double f;
++ memcpy(&f, &v, sizeof(f));
++ Q_ASSERT(qIsNaN(f));
++ return f;
++}
++
++static double myInf()
++{
++ uint64_t v = UINT64_C(0x7ff0000000000000);
++ double f;
++ memcpy(&f, &v, sizeof(f));
++ Q_ASSERT(qIsInf(f));
++ return f;
++}
++
++static double myNInf()
++{
++ uint64_t v = UINT64_C(0xfff0000000000000);
++ double f;
++ memcpy(&f, &v, sizeof(f));
++ Q_ASSERT(qIsInf(f));
++ return f;
++}
++
+template <size_t N> QByteArray raw(const char (&data)[N])
+{
+ return QByteArray::fromRawData(data, N - 1);
+}
+
+struct SimpleType { uint8_t type; };
+Q_DECLARE_METATYPE(SimpleType)
+
+struct Float16Standin { uint16_t val; };
+Q_DECLARE_METATYPE(Float16Standin)
+
+struct Tag { CborTag tag; QVariant tagged; };
+Q_DECLARE_METATYPE(Tag)
+
++template <typename... Args>
++QVariant make_list(const Args &... args)
++{
++ return QVariantList{args...};
++}
++
+typedef QVector<QPair<QVariant, QVariant>> Map;
+Q_DECLARE_METATYPE(Map)
+QVariant make_map(const std::initializer_list<QPair<QVariant, QVariant>> &list)
+{
+ return QVariant::fromValue(Map(list));
+}
+
+struct IndeterminateLengthArray : QVariantList { using QVariantList::QVariantList; };
+struct IndeterminateLengthMap : Map { using Map::Map; };
+Q_DECLARE_METATYPE(IndeterminateLengthArray)
+Q_DECLARE_METATYPE(IndeterminateLengthMap)
+
+QVariant make_ilarray(const std::initializer_list<QVariant> &list)
+{
+ return QVariant::fromValue(IndeterminateLengthArray(list));
+}
+
+QVariant make_ilmap(const std::initializer_list<QPair<QVariant, QVariant>> &list)
+{
+ return QVariant::fromValue(IndeterminateLengthMap(list));
+}
+
+static inline bool isOomError(CborError err)
+{
+ return err == CborErrorOutOfMemory;
+}
+
+CborError encodeVariant(CborEncoder *encoder, const QVariant &v)
+{
+ int type = v.userType();
+ switch (type) {
+ case QVariant::Int:
+ case QVariant::LongLong:
+ return cbor_encode_int(encoder, v.toLongLong());
+
+ case QVariant::UInt:
+ case QVariant::ULongLong:
+ return cbor_encode_uint(encoder, v.toULongLong());
+
+ case QVariant::Bool:
+ return cbor_encode_boolean(encoder, v.toBool());
+
+ case QVariant::Invalid:
+ return cbor_encode_undefined(encoder);
+
+ case QMetaType::VoidStar:
+ return cbor_encode_null(encoder);
+
+ case QVariant::Double:
+ return cbor_encode_double(encoder, v.toDouble());
+
+ case QMetaType::Float:
+ return cbor_encode_float(encoder, v.toFloat());
+
+ case QVariant::String: {
+ QByteArray string = v.toString().toUtf8();
+ return cbor_encode_text_string(encoder, string.constData(), string.length());
+ }
+
+ case QVariant::ByteArray: {
+ QByteArray string = v.toByteArray();
+ return cbor_encode_byte_string(encoder, reinterpret_cast<const quint8 *>(string.constData()), string.length());
+ }
+
+ default:
+ if (type == qMetaTypeId<SimpleType>())
+ return cbor_encode_simple_value(encoder, v.value<SimpleType>().type);
+ if (type == qMetaTypeId<Float16Standin>())
+ return cbor_encode_half_float(encoder, v.constData());
+ if (type == qMetaTypeId<Tag>()) {
+ CborError err = cbor_encode_tag(encoder, v.value<Tag>().tag);
+ if (err && !isOomError(err))
+ return err;
+ return static_cast<CborError>(err | encodeVariant(encoder, v.value<Tag>().tagged));
+ }
+ if (type == QVariant::List || type == qMetaTypeId<IndeterminateLengthArray>()) {
+ CborEncoder sub;
+ QVariantList list = v.toList();
+ size_t len = list.length();
+ if (type == qMetaTypeId<IndeterminateLengthArray>()) {
+ len = CborIndefiniteLength;
+ list = v.value<IndeterminateLengthArray>();
+ }
+ CborError err = cbor_encoder_create_array(encoder, &sub, len);
+ if (err && !isOomError(err))
+ return err;
+ foreach (const QVariant &v2, list) {
+ err = static_cast<CborError>(err | encodeVariant(&sub, v2));
+ if (err && !isOomError(err))
+ return err;
+ }
+ return static_cast<CborError>(err | cbor_encoder_close_container_checked(encoder, &sub));
+ }
+ if (type == qMetaTypeId<Map>() || type == qMetaTypeId<IndeterminateLengthMap>()) {
+ CborEncoder sub;
+ Map map = v.value<Map>();
+ size_t len = map.length();
+ if (type == qMetaTypeId<IndeterminateLengthMap>()) {
+ len = CborIndefiniteLength;
+ map = v.value<IndeterminateLengthMap>();
+ }
+ CborError err = cbor_encoder_create_map(encoder, &sub, len);
+ if (err && !isOomError(err))
+ return err;
+ for (auto pair : map) {
+ err = static_cast<CborError>(err | encodeVariant(&sub, pair.first));
+ if (err && !isOomError(err))
+ return err;
+ err = static_cast<CborError>(err | encodeVariant(&sub, pair.second));
+ if (err && !isOomError(err))
+ return err;
+ }
+ return (CborError)(err | cbor_encoder_close_container_checked(encoder, &sub));
+ }
+ }
+ return CborErrorUnknownType;
+}
+
+bool compareFailed;
+void compare(const QVariant &input, const QByteArray &output)
+{
+ QByteArray buffer(output.length(), Qt::Uninitialized);
++ uint8_t *bufptr = reinterpret_cast<quint8 *>(buffer.data());
+ CborEncoder encoder;
- buffer.resize(encoder.ptr - reinterpret_cast<const quint8 *>(buffer.constData()));
- QCOMPARE(buffer, output);
++ cbor_encoder_init(&encoder, bufptr, buffer.length(), 0);
++
+ QCOMPARE(int(encodeVariant(&encoder, input)), int(CborNoError));
- QTest::newRow("qnan_f") << raw("\xfa\xff\xc0\0\0") << QVariant::fromValue<float>(qQNaN());
- QTest::newRow("qnan") << raw("\xfb\xff\xf8\0\0\0\0\0\0") << QVariant(qQNaN());
- QTest::newRow("snan_f") << raw("\xfa\x7f\xc0\0\0") << QVariant::fromValue<float>(qSNaN());
- QTest::newRow("snan") << raw("\xfb\x7f\xf8\0\0\0\0\0\0") << QVariant(qSNaN());
- QTest::newRow("-inf_f") << raw("\xfa\xff\x80\0\0") << QVariant::fromValue<float>(-qInf());
- QTest::newRow("-inf") << raw("\xfb\xff\xf0\0\0\0\0\0\0") << QVariant(-qInf());
- QTest::newRow("+inf_f") << raw("\xfa\x7f\x80\0\0") << QVariant::fromValue<float>(qInf());
- QTest::newRow("+inf") << raw("\xfb\x7f\xf0\0\0\0\0\0\0") << QVariant(qInf());
+ QCOMPARE(encoder.added, size_t(1));
++ QCOMPARE(cbor_encoder_get_extra_bytes_needed(&encoder), size_t(0));
++
++ buffer.resize(int(cbor_encoder_get_buffer_size(&encoder, bufptr)));
++ QCOMPARE(buffer, output);
+}
+
+void addColumns()
+{
+ QTest::addColumn<QByteArray>("output");
+ QTest::addColumn<QVariant>("input");
+}
+
+void addFixedData()
+{
+ // unsigned integers
+ QTest::newRow("0U") << raw("\x00") << QVariant(0U);
+ QTest::newRow("1U") << raw("\x01") << QVariant(1U);
+ QTest::newRow("10U") << raw("\x0a") << QVariant(10U);
+ QTest::newRow("23U") << raw("\x17") << QVariant(23U);
+ QTest::newRow("24U") << raw("\x18\x18") << QVariant(24U);
+ QTest::newRow("255U") << raw("\x18\xff") << QVariant(255U);
+ QTest::newRow("256U") << raw("\x19\x01\x00") << QVariant(256U);
+ QTest::newRow("65535U") << raw("\x19\xff\xff") << QVariant(65535U);
+ QTest::newRow("65536U") << raw("\x1a\0\1\x00\x00") << QVariant(65536U);
+ QTest::newRow("4294967295U") << raw("\x1a\xff\xff\xff\xff") << QVariant(4294967295U);
+ QTest::newRow("4294967296U") << raw("\x1b\0\0\0\1\0\0\0\0") << QVariant(Q_UINT64_C(4294967296));
+ QTest::newRow("UINT64_MAX") << raw("\x1b" "\xff\xff\xff\xff" "\xff\xff\xff\xff")
+ << QVariant(std::numeric_limits<quint64>::max());
+
+ // signed integers containing positive numbers
+ QTest::newRow("0") << raw("\x00") << QVariant(0);
+ QTest::newRow("1") << raw("\x01") << QVariant(1);
+ QTest::newRow("10") << raw("\x0a") << QVariant(10);
+ QTest::newRow("23") << raw("\x17") << QVariant(23);
+ QTest::newRow("24") << raw("\x18\x18") << QVariant(24);
+ QTest::newRow("255") << raw("\x18\xff") << QVariant(255);
+ QTest::newRow("256") << raw("\x19\x01\x00") << QVariant(256);
+ QTest::newRow("65535") << raw("\x19\xff\xff") << QVariant(65535);
+ QTest::newRow("65536") << raw("\x1a\0\1\x00\x00") << QVariant(65536);
+ QTest::newRow("4294967295") << raw("\x1a\xff\xff\xff\xff") << QVariant(Q_INT64_C(4294967295));
+ QTest::newRow("4294967296") << raw("\x1b\0\0\0\1\0\0\0\0") << QVariant(Q_INT64_C(4294967296));
+
+ // negative integers
+ QTest::newRow("-1") << raw("\x20") << QVariant(-1);
+ QTest::newRow("-2") << raw("\x21") << QVariant(-2);
+ QTest::newRow("-24") << raw("\x37") << QVariant(-24);
+ QTest::newRow("-25") << raw("\x38\x18") << QVariant(-25);
+ QTest::newRow("-UINT8_MAX") << raw("\x38\xff") << QVariant(-256);
+ QTest::newRow("-UINT8_MAX-1") << raw("\x39\x01\x00") << QVariant(-257);
+ QTest::newRow("-UINT16_MAX") << raw("\x39\xff\xff") << QVariant(-65536);
+ QTest::newRow("-UINT16_MAX-1") << raw("\x3a\0\1\x00\x00") << QVariant(-65537);
+ QTest::newRow("-UINT32_MAX") << raw("\x3a\xff\xff\xff\xff") << QVariant(Q_INT64_C(-4294967296));
+ QTest::newRow("-UINT32_MAX-1") << raw("\x3b\0\0\0\1\0\0\0\0") << QVariant(Q_INT64_C(-4294967297));
+// QTest::newRow("-UINT64_MAX") << raw("\x3b" "\xff\xff\xff\xff" "\xff\xff\xff\xff")
+// << QVariant::fromValue(BigNegative{std::numeric_limits<quint64>::max()});
+
+ QTest::newRow("simple0") << raw("\xe0") << QVariant::fromValue(SimpleType{0});
+ QTest::newRow("simple19") << raw("\xf3") << QVariant::fromValue(SimpleType{19});
+ QTest::newRow("false") << raw("\xf4") << QVariant(false);
+ QTest::newRow("true") << raw("\xf5") << QVariant(true);
+ QTest::newRow("null") << raw("\xf6") << QVariant::fromValue<void *>(nullptr);
+ QTest::newRow("undefined") << raw("\xf7") << QVariant();
+ QTest::newRow("simple32") << raw("\xf8\x20") << QVariant::fromValue(SimpleType{32});
+ QTest::newRow("simple255") << raw("\xf8\xff") << QVariant::fromValue(SimpleType{255});
+
+ // floating point
+ QTest::newRow("0f16") << raw("\xf9\0\0") << QVariant::fromValue(Float16Standin{0x0000});
+
+ QTest::newRow("0.f") << raw("\xfa\0\0\0\0") << QVariant::fromValue(0.f);
+ QTest::newRow("0.") << raw("\xfb\0\0\0\0\0\0\0\0") << QVariant(0.);
+ QTest::newRow("-1.f") << raw("\xfa\xbf\x80\0\0") << QVariant::fromValue(-1.f);
+ QTest::newRow("-1.") << raw("\xfb\xbf\xf0\0\0\0\0\0\0") << QVariant(-1.);
+ QTest::newRow("16777215.f") << raw("\xfa\x4b\x7f\xff\xff") << QVariant::fromValue(16777215.f);
+ QTest::newRow("16777215.") << raw("\xfb\x41\x6f\xff\xff\xe0\0\0\0") << QVariant::fromValue(16777215.);
+ QTest::newRow("-16777215.f") << raw("\xfa\xcb\x7f\xff\xff") << QVariant(-16777215.f);
+ QTest::newRow("-16777215.") << raw("\xfb\xc1\x6f\xff\xff\xe0\0\0\0") << QVariant::fromValue(-16777215.);
+
- QTest::newRow("emptyarray") << raw("\x80") << QVariant(QVariantList{});
++ QTest::newRow("nan_f") << raw("\xfa\x7f\xc0\0\0") << QVariant::fromValue<float>(myNaNf());
++ QTest::newRow("nan") << raw("\xfb\x7f\xf8\0\0\0\0\0\0") << QVariant(myNaN());
++ QTest::newRow("-inf_f") << raw("\xfa\xff\x80\0\0") << QVariant::fromValue<float>(myNInff());
++ QTest::newRow("-inf") << raw("\xfb\xff\xf0\0\0\0\0\0\0") << QVariant(myNInf());
++ QTest::newRow("+inf_f") << raw("\xfa\x7f\x80\0\0") << QVariant::fromValue<float>(myInff());
++ QTest::newRow("+inf") << raw("\xfb\x7f\xf0\0\0\0\0\0\0") << QVariant(myInf());
+}
+
+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("array-0") << raw("\x81\0") << QVariant(QVariantList{0});
- QTest::newRow("array-{0-0}") << raw("\x82\0\0") << QVariant(QVariantList{0, 0});
- QTest::newRow("array-Hello") << raw("\x81\x65Hello") << QVariant(QVariantList{"Hello"});
- QTest::newRow("array-array-0") << raw("\x81\x81\0") << QVariant(QVariantList{QVariantList{0}});
- QTest::newRow("array-array-{0-0}") << raw("\x81\x82\0\0") << QVariant(QVariantList{QVariantList{0, 0}});
- QTest::newRow("array-array-0-0") << raw("\x82\x81\0\0") << QVariant(QVariantList{QVariantList{0},0});
- QTest::newRow("array-array-Hello") << raw("\x81\x81\x65Hello") << QVariant(QVariantList{QVariantList{"Hello"}});
++ QTest::newRow("emptyarray") << raw("\x80") << make_list();
+ QTest::newRow("emptymap") << raw("\xa0") << make_map({});
+
- QTest::newRow("array-map1") << raw("\x81\xa1\0\0") << QVariant(QVariantList{make_map({{0,0}})});
- QTest::newRow("array-map2") << raw("\x82\xa1\0\0\xa1\1\1") << QVariant(QVariantList{make_map({{0,0}}), make_map({{1,1}})});
++ 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("map-array1") << raw("\xa1\x62oc\x81\0") << make_map({{"oc", QVariantList{0}}});
- QTest::newRow("map-array2") << raw("\xa1\x62oc\x84\0\1\2\3") << make_map({{"oc", QVariantList{0, 1, 2, 3}}});
- QTest::newRow("map-array3") << raw("\xa2\x62oc\x82\0\1\2\3") << make_map({{"oc", QVariantList{0, 1}}, {2, 3}});
++ 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("_array-array-0") << raw("\x9f\x81\0\xff") << make_ilarray({QVariantList{0}});
++ 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("_map-array1") << raw("\xbf\x62oc\x81\0\xff") << make_ilmap({{"oc", QVariantList{0}}});
++ 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-array2") << raw("\xbf\x62oc\x84\0\1\2\3\xff") << make_ilmap({{"oc", QVariantList{0, 1, 2, 3}}});
++ 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-array3") << raw("\xbf\x62oc\x82\0\1\2\3\xff") << make_ilmap({{"oc", QVariantList{0, 1}}, {2, 3}});
++ 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("array-1(0)") << raw("\x81\xc1\0") << QVariant(QVariantList{QVariant::fromValue(Tag{1, 0})});
- QTest::newRow("array-1(map)") << raw("\x81\xc1\xa0") << QVariant(QVariantList{QVariant::fromValue(Tag{1, make_map({})})});
++ 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
- compare(QVariantList{input}, "\x81" + output);
++ 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(QVariantList{input, input}, "\x82" + output + output);
++ compare(make_list(input), "\x81" + output);
+ if (compareFailed) return;
+
- compare(QVariantList{QVariantList{input}}, "\x81\x81" + output);
++ 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(QVariantList{QVariantList{input, input}}, "\x81\x82" + output + output);
++ compare(make_list(make_list(input)), "\x81\x81" + output);
+ if (compareFailed) return;
+
- compare(QVariantList{QVariantList{input}, input}, "\x82\x81" + output + output);
++ compare(make_list(make_list(input, input)), "\x81\x82" + output + output);
+ if (compareFailed) return;
+
- compare(QVariantList{QVariantList{input}, QVariantList{input}}, "\x82\x81" + output + "\x81" + output);
++ compare(make_list(make_list(input), input), "\x82\x81" + output + output);
+ if (compareFailed) return;
+
- for (int len = 0; len < output.length() - 1; ++len) {
++ 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);
+
- QCOMPARE(len + int(encoder.ptr - encoder.end), output.length());
++ for (int len = 0; len < output.length(); ++len) {
+ CborEncoder encoder;
+ cbor_encoder_init(&encoder, reinterpret_cast<quint8 *>(buffer.data()), len, 0);
+ QCOMPARE(int(encodeVariant(&encoder, input)), int(CborErrorOutOfMemory));
++ QVERIFY(cbor_encoder_get_extra_bytes_needed(&encoder) != 0);
++ QCOMPARE(len + cbor_encoder_get_extra_bytes_needed(&encoder), size_t(output.length()));
+ }
+}
+
+void tst_Encoder::tooShortArrays()
+{
+ QFETCH(QVariant, input);
+ QFETCH(QByteArray, output);
+ QByteArray buffer(output.length() + 1, Qt::Uninitialized);
+
+ CborEncoder encoder, container;
+ cbor_encoder_init(&encoder, reinterpret_cast<quint8 *>(buffer.data()), buffer.length(), 0);
+ QCOMPARE(cbor_encoder_create_array(&encoder, &container, 2), CborNoError);
+ QCOMPARE(int(encodeVariant(&container, input)), int(CborNoError));
+ QCOMPARE(container.added, size_t(1));
+ QCOMPARE(int(cbor_encoder_close_container_checked(&encoder, &container)), int(CborErrorTooFewItems));
+}
+
+void tst_Encoder::tooShortMaps()
+{
+ QFETCH(QVariant, input);
+ QFETCH(QByteArray, output);
+ QByteArray buffer(output.length() + 1, Qt::Uninitialized);
+
+ CborEncoder encoder, container;
+ cbor_encoder_init(&encoder, reinterpret_cast<quint8 *>(buffer.data()), buffer.length(), 0);
+ QCOMPARE(cbor_encoder_create_map(&encoder, &container, 2), CborNoError);
+ QCOMPARE(int(encodeVariant(&container, input)), int(CborNoError));
+ QCOMPARE(container.added, size_t(1));
+ QCOMPARE(int(cbor_encoder_close_container_checked(&encoder, &container)), int(CborErrorTooFewItems));
+}
+
+void tst_Encoder::tooBigArrays()
+{
+ QFETCH(QVariant, input);
+ QFETCH(QByteArray, output);
+ QByteArray buffer(output.length() * 2 + 1, Qt::Uninitialized);
+
+ CborEncoder encoder, container;
+ cbor_encoder_init(&encoder, reinterpret_cast<quint8 *>(buffer.data()), buffer.length(), 0);
+ QCOMPARE(cbor_encoder_create_array(&encoder, &container, 1), CborNoError);
+ QCOMPARE(int(encodeVariant(&container, input)), int(CborNoError));
+ QCOMPARE(int(encodeVariant(&container, input)), int(CborNoError));
+ QCOMPARE(container.added, size_t(2));
+ QCOMPARE(int(cbor_encoder_close_container_checked(&encoder, &container)), int(CborErrorTooManyItems));
+}
+
+void tst_Encoder::tooBigMaps()
+{
+ QFETCH(QVariant, input);
+ QFETCH(QByteArray, output);
+ QByteArray buffer(output.length() * 3 + 1, Qt::Uninitialized);
+
+ CborEncoder encoder, container;
+ cbor_encoder_init(&encoder, reinterpret_cast<quint8 *>(buffer.data()), buffer.length(), 0);
+ QCOMPARE(cbor_encoder_create_map(&encoder, &container, 1), CborNoError);
+ QCOMPARE(int(encodeVariant(&container, input)), int(CborNoError));
+ QCOMPARE(int(encodeVariant(&container, input)), int(CborNoError));
+ QCOMPARE(int(encodeVariant(&container, input)), int(CborNoError));
+ QCOMPARE(container.added, size_t(3));
+ QCOMPARE(int(cbor_encoder_close_container_checked(&encoder, &container)), int(CborErrorTooManyItems));
+}
+
+void tst_Encoder::illegalSimpleType_data()
+{
+ QTest::addColumn<int>("type");
+ QTest::newRow("half-float") << 25;
+ QTest::newRow("float") << 26;
+ QTest::newRow("double") << 27;
+ QTest::newRow("28") << 28;
+ QTest::newRow("29") << 29;
+ QTest::newRow("30") << 30;
+ QTest::newRow("31") << 31;
+}
+
+void tst_Encoder::illegalSimpleType()
+{
+ QFETCH(int, type);
+
+ quint8 buf[2];
+ CborEncoder encoder;
+ cbor_encoder_init(&encoder, buf, sizeof(buf), 0);
+ QCOMPARE(int(cbor_encode_simple_value(&encoder, type)), int(CborErrorIllegalSimpleType));
+}
+
+QTEST_MAIN(tst_Encoder)
--- /dev/null
- POST_TARGETDEPS += ../../lib/libtinycbor.a
+SOURCES += tst_parser.cpp ../../src/cborparser.c
+
+CONFIG += testcase parallel_test c++11
+QT = core testlib
+DEFINES += CBOR_PARSER_MAX_RECURSIONS=16
+
+INCLUDEPATH += ../../src
++msvc: POST_TARGETDEPS = ../../lib/tinycbor.lib
++else: POST_TARGETDEPS += ../../lib/libtinycbor.a
+LIBS += $$POST_TARGETDEPS
--- /dev/null
- ** Copyright (C) 2015 Intel Corporation
+/****************************************************************************
+**
- *parsed = QString::fromLatin1(buffer, size);
++** 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.
+**
+****************************************************************************/
+
+#define _XOPEN_SOURCE 700
+#include <QtTest>
+#include "cbor.h"
+#include <locale.h>
+#include <stdio.h>
+
++#ifndef Q_CC_MSVC
+extern "C" FILE *open_memstream(char **bufptr, size_t *sizeptr);
++#endif
+
+Q_DECLARE_METATYPE(CborError)
+
+class tst_Parser : public QObject
+{
+ Q_OBJECT
+private slots:
+ void initParserEmpty();
+
+ // parsing API
+ void fixed_data();
+ void fixed();
+ void strings_data();
+ void strings() { fixed(); }
+ void tags_data();
+ void tags() { fixed(); }
+ void tagTags_data() { tags_data(); }
+ void tagTags();
+ void emptyContainers_data();
+ void emptyContainers();
+ void arrays_data();
+ void arrays();
+ void undefLengthArrays_data() { arrays_data(); }
+ void undefLengthArrays();
+ void nestedArrays_data() { arrays_data(); }
+ void nestedArrays();
+ void maps_data();
+ void maps();
+ void undefLengthMaps_data() { maps_data(); }
+ void undefLengthMaps();
+ void nestedMaps_data() { maps_data(); }
+ void nestedMaps();
+ void mapMixed_data();
+ void mapMixed() { arrays(); }
+ void mapsAndArrays_data() { arrays_data(); }
+ void mapsAndArrays();
+
+ // convenience API
+ void stringLength_data();
+ void stringLength();
+ void stringCompare_data();
+ void stringCompare();
+ void mapFind_data();
+ void mapFind();
+
+ // validation & errors
++ void checkedIntegers_data();
++ void checkedIntegers();
+ void validation_data();
+ void validation();
+ void resumeParsing_data();
+ void resumeParsing();
+ void endPointer_data();
+ void endPointer();
+ void recursionLimit_data();
+ void recursionLimit();
+};
+
+CborError parseOne(CborValue *it, QString *parsed)
+{
+ CborError err;
+ char *buffer;
+ size_t size;
+
+ setlocale(LC_ALL, "C");
++#ifdef Q_CC_MSVC
++ // no open_memstream, so use a temporary file
++ QTemporaryFile tmp("./output.XXXXXX.txt");
++ tmp.open();
++
++ FILE *f = fopen(QFile::encodeName(tmp.fileName()), "w+");
++ if (!f)
++ return CborErrorIO;
++ err = cbor_value_to_pretty_advance(f, it);
++ size = ftell(f);
++ rewind(f);
++
++ buffer = static_cast<char *>(malloc(size));
++ size = fread(buffer, 1, size, f);
++ fclose(f);
++#else
+ FILE *f = open_memstream(&buffer, &size);
+ err = cbor_value_to_pretty_advance(f, it);
+ fclose(f);
++#endif
+
- QCOMPARE((void*)first.ptr, (void*)data.constEnd());
++ *parsed = QString::fromLatin1(buffer, int(size));
+ free(buffer);
+ return err;
+}
+
+template <size_t N> QByteArray raw(const char (&data)[N])
+{
+ return QByteArray::fromRawData(data, N - 1);
+}
+
+void tst_Parser::initParserEmpty()
+{
+ CborParser parser;
+ CborValue first;
+ CborError err = cbor_parser_init((const quint8 *)"", 0, 0, &parser, &first);
+ QCOMPARE(err, CborErrorUnexpectedEOF);
+}
+
+void addColumns()
+{
+ QTest::addColumn<QByteArray>("data");
+ QTest::addColumn<QString>("expected");
+ QTest::addColumn<int>("n"); // some aux integer, not added in all columns
+}
+
+bool compareFailed = true;
+void compareOne_real(const QByteArray &data, const QString &expected, int line, int n = -1)
+{
+ compareFailed = true;
+ CborParser parser;
+ CborValue first;
+ CborError err = cbor_parser_init(reinterpret_cast<const quint8 *>(data.constData()), data.length(), 0, &parser, &first);
+ QVERIFY2(!err, QByteArray::number(line) + ": Got error \"" + cbor_error_string(err) + "\"");
+
+ if (cbor_value_get_type(&first) == CborArrayType) {
+ size_t len;
+ if (n >= 0) {
++ QVERIFY(cbor_value_is_length_known(&first));
+ QCOMPARE(cbor_value_get_array_length(&first, &len), CborNoError);
+ QCOMPARE(len, size_t(len));
+ } else {
++ QVERIFY(!cbor_value_is_length_known(&first));
+ QCOMPARE(cbor_value_get_array_length(&first, &len), CborErrorUnknownLength);
+ }
+ } else if (cbor_value_get_type(&first) == CborMapType) {
+ size_t len;
+ if (n >= 0) {
++ QVERIFY(cbor_value_is_length_known(&first));
+ QCOMPARE(cbor_value_get_map_length(&first, &len), CborNoError);
+ QCOMPARE(len, size_t(len));
+ } else {
++ QVERIFY(!cbor_value_is_length_known(&first));
+ QCOMPARE(cbor_value_get_map_length(&first, &len), CborErrorUnknownLength);
+ }
++ } else if (cbor_value_is_text_string(&first) || cbor_value_is_byte_string(&first)) {
++ size_t len;
++ QCOMPARE(cbor_value_calculate_string_length(&first, &len), CborNoError);
++ if (cbor_value_is_length_known(&first)) {
++ size_t len2;
++ QCOMPARE(cbor_value_get_string_length(&first, &len2), CborNoError);
++ QCOMPARE(len2, len);
++ } else {
++ QCOMPARE(cbor_value_get_string_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
- QTest::newRow("nan_f16") << raw("\xf9\x7e\x00") << "nan";
++ QCOMPARE((void*)cbor_value_get_next_byte(&first), (void*)data.constEnd());
+
+ compareFailed = false;
+}
+#define compareOne(data, expected) compareOne_real(data, expected, __LINE__)
+#define compareOneSize(n, data, expected) compareOne_real(data, expected, __LINE__, n)
+
+void addFixedData()
+{
+ // unsigned integers
+ QTest::newRow("0") << raw("\x00") << "0";
+ QTest::newRow("1") << raw("\x01") << "1";
+ QTest::newRow("10") << raw("\x0a") << "10";
+ QTest::newRow("23") << raw("\x17") << "23";
+ QTest::newRow("24") << raw("\x18\x18") << "24";
+ QTest::newRow("UINT8_MAX") << raw("\x18\xff") << "255";
+ QTest::newRow("UINT8_MAX+1") << raw("\x19\x01\x00") << "256";
+ QTest::newRow("UINT16_MAX") << raw("\x19\xff\xff") << "65535";
+ QTest::newRow("UINT16_MAX+1") << raw("\x1a\0\1\x00\x00") << "65536";
+ QTest::newRow("UINT32_MAX") << raw("\x1a\xff\xff\xff\xff") << "4294967295";
+ QTest::newRow("UINT32_MAX+1") << raw("\x1b\0\0\0\1\0\0\0\0") << "4294967296";
+ QTest::newRow("UINT64_MAX") << raw("\x1b" "\xff\xff\xff\xff" "\xff\xff\xff\xff")
+ << QString::number(std::numeric_limits<uint64_t>::max());
+
+ // negative integers
+ QTest::newRow("-1") << raw("\x20") << "-1";
+ QTest::newRow("-2") << raw("\x21") << "-2";
+ QTest::newRow("-24") << raw("\x37") << "-24";
+ QTest::newRow("-25") << raw("\x38\x18") << "-25";
+ QTest::newRow("-UINT8_MAX") << raw("\x38\xff") << "-256";
+ QTest::newRow("-UINT8_MAX-1") << raw("\x39\x01\x00") << "-257";
+ QTest::newRow("-UINT16_MAX") << raw("\x39\xff\xff") << "-65536";
+ QTest::newRow("-UINT16_MAX-1") << raw("\x3a\0\1\x00\x00") << "-65537";
+ QTest::newRow("-UINT32_MAX") << raw("\x3a\xff\xff\xff\xff") << "-4294967296";
+ QTest::newRow("-UINT32_MAX-1") << raw("\x3b\0\0\0\1\0\0\0\0") << "-4294967297";
+ QTest::newRow("INT64_MIN+1") << raw("\x3b\x7f\xff\xff\xff""\xff\xff\xff\xfe")
+ << QString::number(std::numeric_limits<int64_t>::min() + 1);
+ QTest::newRow("INT64_MIN") << raw("\x3b\x7f\xff\xff\xff""\xff\xff\xff\xff")
+ << QString::number(std::numeric_limits<int64_t>::min());
+ QTest::newRow("INT64_MIN-1") << raw("\x3b\x80\0\0\0""\0\0\0\0") << "-9223372036854775809";
+ QTest::newRow("-UINT64_MAX") << raw("\x3b" "\xff\xff\xff\xff" "\xff\xff\xff\xfe")
+ << '-' + QString::number(std::numeric_limits<uint64_t>::max());
+ QTest::newRow("-UINT64_MAX+1") << raw("\x3b" "\xff\xff\xff\xff" "\xff\xff\xff\xff")
+ << "-18446744073709551616";
+
+ // overlongs
+ QTest::newRow("0*1") << raw("\x18\x00") << "0";
+ QTest::newRow("0*2") << raw("\x19\x00\x00") << "0";
+ QTest::newRow("0*4") << raw("\x1a\0\0\0\0") << "0";
+ QTest::newRow("0*8") << raw("\x1b\0\0\0\0\0\0\0\0") << "0";
+ QTest::newRow("-1*1") << raw("\x38\x00") << "-1";
+ QTest::newRow("-1*2") << raw("\x39\x00\x00") << "-1";
+ QTest::newRow("-1*4") << raw("\x3a\0\0\0\0") << "-1";
+ QTest::newRow("-1*8") << raw("\x3b\0\0\0\0\0\0\0\0") << "-1";
+
+ QTest::newRow("simple0") << raw("\xe0") << "simple(0)";
+ QTest::newRow("simple19") << raw("\xf3") << "simple(19)";
+ QTest::newRow("false") << raw("\xf4") << "false";
+ QTest::newRow("true") << raw("\xf5") << "true";
+ QTest::newRow("null") << raw("\xf6") << "null";
+ QTest::newRow("undefined") << raw("\xf7") << "undefined";
+ QTest::newRow("simple32") << raw("\xf8\x20") << "simple(32)";
+ QTest::newRow("simple255") << raw("\xf8\xff") << "simple(255)";
+
+ // floating point
+
+ QTest::newRow("0.f16") << raw("\xf9\0\0") << "0.f16";
+ QTest::newRow("0.f") << raw("\xfa\0\0\0\0") << "0.f";
+ QTest::newRow("0.") << raw("\xfb\0\0\0\0\0\0\0\0") << "0.";
+ QTest::newRow("-1.f16") << raw("\xf9\xbc\x00") << "-1.f16";
+ QTest::newRow("-1.f") << raw("\xfa\xbf\x80\0\0") << "-1.f";
+ QTest::newRow("-1.") << raw("\xfb\xbf\xf0\0\0\0\0\0\0") << "-1.";
+ QTest::newRow("65504.f16") << raw("\xf9\x7b\xff") << "65504.f16";
+ QTest::newRow("16777215.f") << raw("\xfa\x4b\x7f\xff\xff") << "16777215.f";
+ QTest::newRow("16777215.") << raw("\xfb\x41\x6f\xff\xff\xe0\0\0\0") << "16777215.";
+ QTest::newRow("-16777215.f") << raw("\xfa\xcb\x7f\xff\xff") << "-16777215.f";
+ QTest::newRow("-16777215.") << raw("\xfb\xc1\x6f\xff\xff\xe0\0\0\0") << "-16777215.";
+
+ QTest::newRow("0.5f16") << raw("\xf9\x38\0") << "0.5f16";
+ QTest::newRow("0.5f") << raw("\xfa\x3f\0\0\0") << "0.5f";
+ QTest::newRow("0.5") << raw("\xfb\x3f\xe0\0\0\0\0\0\0") << "0.5";
+ QTest::newRow("2.f16^11-1") << raw("\xf9\x67\xff") << "2047.f16";
+ QTest::newRow("2.f^24-1") << raw("\xfa\x4b\x7f\xff\xff") << "16777215.f";
+ QTest::newRow("2.^53-1") << raw("\xfb\x43\x3f\xff\xff""\xff\xff\xff\xff") << "9007199254740991.";
+ QTest::newRow("2.f^64-epsilon") << raw("\xfa\x5f\x7f\xff\xff") << "18446742974197923840.f";
+ QTest::newRow("2.^64-epsilon") << raw("\xfb\x43\xef\xff\xff""\xff\xff\xff\xff") << "18446744073709549568.";
+ QTest::newRow("2.f^64") << raw("\xfa\x5f\x80\0\0") << "1.8446744073709552e+19f";
+ QTest::newRow("2.^64") << raw("\xfb\x43\xf0\0\0\0\0\0\0") << "1.8446744073709552e+19";
+
- err = cbor_value_text_string_equals(&value, string.toUtf8().constData(), &result);
++ QTest::newRow("nan_f16") << raw("\xf9\x7e\x00")
++#ifdef Q_CC_MSVC
++ << "-nan(ind)"
++#else
++ << "nan"
++#endif
++ ;
+ QTest::newRow("nan_f") << raw("\xfa\x7f\xc0\0\0") << "nan";
+ QTest::newRow("nan") << raw("\xfb\x7f\xf8\0\0\0\0\0\0") << "nan";
+ QTest::newRow("-inf_f16") << raw("\xf9\xfc\x00") << "-inf";
+ QTest::newRow("-inf_f") << raw("\xfa\xff\x80\0\0") << "-inf";
+ QTest::newRow("-inf") << raw("\xfb\xff\xf0\0\0\0\0\0\0") << "-inf";
+ QTest::newRow("+inf_f16") << raw("\xf9\x7c\x00") << "inf";
+ QTest::newRow("+inf_f") << raw("\xfa\x7f\x80\0\0") << "inf";
+ QTest::newRow("+inf") << raw("\xfb\x7f\xf0\0\0\0\0\0\0") << "inf";
+
+}
+
+void tst_Parser::fixed_data()
+{
+ addColumns();
+ addFixedData();
+}
+
+void tst_Parser::fixed()
+{
+ QFETCH(QByteArray, data);
+ QFETCH(QString, expected);
+
+ compareOne(data, expected);
+}
+
+void addStringsData()
+{
+ // byte strings
+ QTest::newRow("emptybytestring") << raw("\x40") << "h''";
+ QTest::newRow("bytestring1") << raw("\x41 ") << "h'20'";
+ QTest::newRow("bytestring1-nul") << raw("\x41\0") << "h'00'";
+ QTest::newRow("bytestring5") << raw("\x45Hello") << "h'48656c6c6f'";
+ QTest::newRow("bytestring24") << raw("\x58\x18""123456789012345678901234")
+ << "h'313233343536373839303132333435363738393031323334'";
+ QTest::newRow("bytestring256") << raw("\x59\1\0") + QByteArray(256, '3')
+ << "h'" + QString(256 * 2, '3') + '\'';
+
+ // text strings
+ QTest::newRow("emptytextstring") << raw("\x60") << "\"\"";
+ QTest::newRow("textstring1") << raw("\x61 ") << "\" \"";
+ QTest::newRow("textstring1-nul") << raw("\x61\0") << "\"\\u0000\"";
+ QTest::newRow("textstring5") << raw("\x65Hello") << "\"Hello\"";
+ QTest::newRow("textstring24") << raw("\x78\x18""123456789012345678901234")
+ << "\"123456789012345678901234\"";
+ QTest::newRow("textstring256") << raw("\x79\1\0") + QByteArray(256, '3')
+ << '"' + QString(256, '3') + '"';
+
+ // strings with overlong length
+ QTest::newRow("emptybytestring*1") << raw("\x58\x00") << "h''";
+ QTest::newRow("emptytextstring*1") << raw("\x78\x00") << "\"\"";
+ QTest::newRow("emptybytestring*2") << raw("\x59\x00\x00") << "h''";
+ QTest::newRow("emptytextstring*2") << raw("\x79\x00\x00") << "\"\"";
+ QTest::newRow("emptybytestring*4") << raw("\x5a\0\0\0\0") << "h''";
+ QTest::newRow("emptytextstring*4") << raw("\x7a\0\0\0\0") << "\"\"";
+ QTest::newRow("emptybytestring*8") << raw("\x5b\0\0\0\0\0\0\0\0") << "h''";
+ QTest::newRow("emptytextstring*8") << raw("\x7b\0\0\0\0\0\0\0\0") << "\"\"";
+ QTest::newRow("bytestring5*1") << raw("\x58\x05Hello") << "h'48656c6c6f'";
+ QTest::newRow("textstring5*1") << raw("\x78\x05Hello") << "\"Hello\"";
+ QTest::newRow("bytestring5*2") << raw("\x59\0\5Hello") << "h'48656c6c6f'";
+ QTest::newRow("textstring5*2") << raw("\x79\0\x05Hello") << "\"Hello\"";
+ QTest::newRow("bytestring5*4") << raw("\x5a\0\0\0\5Hello") << "h'48656c6c6f'";
+ QTest::newRow("textstring5*4") << raw("\x7a\0\0\0\x05Hello") << "\"Hello\"";
+ QTest::newRow("bytestring5*8") << raw("\x5b\0\0\0\0\0\0\0\5Hello") << "h'48656c6c6f'";
+ QTest::newRow("textstring5*8") << raw("\x7b\0\0\0\0\0\0\0\x05Hello") << "\"Hello\"";
+
+ // strings with undefined length
+ QTest::newRow("_emptybytestring") << raw("\x5f\xff") << "h''";
+ QTest::newRow("_emptytextstring") << raw("\x7f\xff") << "\"\"";
+ QTest::newRow("_emptybytestring2") << raw("\x5f\x40\xff") << "h''";
+ QTest::newRow("_emptytextstring2") << raw("\x7f\x60\xff") << "\"\"";
+ QTest::newRow("_emptybytestring3") << raw("\x5f\x40\x40\xff") << "h''";
+ QTest::newRow("_emptytextstring3") << raw("\x7f\x60\x60\xff") << "\"\"";
+ QTest::newRow("_bytestring5*2") << raw("\x5f\x43Hel\x42lo\xff") << "h'48656c6c6f'";
+ QTest::newRow("_textstring5*2") << raw("\x7f\x63Hel\x62lo\xff") << "\"Hello\"";
+ QTest::newRow("_bytestring5*5") << raw("\x5f\x41H\x41""e\x41l\x41l\x41o\xff") << "h'48656c6c6f'";
+ QTest::newRow("_textstring5*5") << raw("\x7f\x61H\x61""e\x61l\x61l\x61o\xff") << "\"Hello\"";
+ QTest::newRow("_bytestring5*6") << raw("\x5f\x41H\x41""e\x40\x41l\x41l\x41o\xff") << "h'48656c6c6f'";
+ QTest::newRow("_textstring5*6") << raw("\x7f\x61H\x61""e\x61l\x60\x61l\x61o\xff") << "\"Hello\"";
+}
+
+void tst_Parser::strings_data()
+{
+ addColumns();
+ addStringsData();
+}
+
+void addTagsData()
+{
+ // since parseOne() works recursively for tags, we can't test lone tags
+ QTest::newRow("tag0") << raw("\xc0\x00") << "0(0)";
+ QTest::newRow("tag1") << raw("\xc1\x00") << "1(0)";
+ QTest::newRow("tag24") << raw("\xd8\x18\x00") << "24(0)";
+ QTest::newRow("tag255") << raw("\xd8\xff\x00") << "255(0)";
+ QTest::newRow("tag256") << raw("\xd9\1\0\x00") << "256(0)";
+ QTest::newRow("tag65535") << raw("\xd9\xff\xff\x00") << "65535(0)";
+ QTest::newRow("tag65536") << raw("\xda\0\1\0\0\x00") << "65536(0)";
+ QTest::newRow("tagUINT32_MAX-1") << raw("\xda\xff\xff\xff\xff\x00") << "4294967295(0)";
+ QTest::newRow("tagUINT32_MAX") << raw("\xdb\0\0\0\1\0\0\0\0\x00") << "4294967296(0)";
+ QTest::newRow("tagUINT64_MAX") << raw("\xdb" "\xff\xff\xff\xff" "\xff\xff\xff\xff" "\x00")
+ << QString::number(std::numeric_limits<uint64_t>::max()) + "(0)";
+
+ // overlong tags
+ QTest::newRow("tag0*1") << raw("\xd8\0\x00") << "0(0)";
+ QTest::newRow("tag0*2") << raw("\xd9\0\0\x00") << "0(0)";
+ QTest::newRow("tag0*4") << raw("\xda\0\0\0\0\x00") << "0(0)";
+ QTest::newRow("tag0*8") << raw("\xdb\0\0\0\0\0\0\0\0\x00") << "0(0)";
+
+ // tag other things
+ QTest::newRow("unixtime") << raw("\xc1\x1a\x55\x4b\xbf\xd3") << "1(1431027667)";
+ QTest::newRow("rfc3339date") << raw("\xc0\x78\x19" "2015-05-07 12:41:07-07:00")
+ << "0(\"2015-05-07 12:41:07-07:00\")";
+ QTest::newRow("tag6+false") << raw("\xc6\xf4") << "6(false)";
+ QTest::newRow("tag25+true") << raw("\xd8\x19\xf5") << "25(true)";
+ QTest::newRow("tag256+null") << raw("\xd9\1\0\xf6") << "256(null)";
+ QTest::newRow("tag65536+simple32") << raw("\xda\0\1\0\0\xf8\x20") << "65536(simple(32))";
+ QTest::newRow("float+unixtime") << raw("\xc1\xfa\x4e\xaa\x97\x80") << "1(1431027712.f)";
+ QTest::newRow("double+unixtime") << raw("\xc1\xfb" "\x41\xd5\x52\xef" "\xf4\xc7\xce\xfe")
+ << "1(1431027667.1220088)";
+}
+
+void tst_Parser::tags_data()
+{
+ addColumns();
+ addTagsData();
+}
+
+void tst_Parser::tagTags()
+{
+ QFETCH(QByteArray, data);
+ QFETCH(QString, expected);
+
+ compareOne("\xd9\xd9\xf7" + data, "55799(" + expected + ')');
+ if (!compareFailed)
+ compareOne("\xd9\xd9\xf7" "\xd9\xd9\xf7" + data, "55799(55799(" + expected + "))");
+}
+
+void addEmptyContainersData()
+{
+ QTest::newRow("emptyarray") << raw("\x80") << "[]" << 0;
+ QTest::newRow("emptymap") << raw("\xa0") << "{}" << 0;
+ QTest::newRow("_emptyarray") << raw("\x9f\xff") << "[_ ]" << -1;
+ QTest::newRow("_emptymap") << raw("\xbf\xff") << "{_ }" << -1;
+}
+
+void tst_Parser::emptyContainers_data()
+{
+ addColumns();
+ addEmptyContainersData();
+}
+
+void tst_Parser::emptyContainers()
+{
+ QFETCH(QByteArray, data);
+ QFETCH(QString, expected);
+ QFETCH(int, n);
+
+ compareOneSize(n, data, expected);
+}
+
+void tst_Parser::arrays_data()
+{
+ addColumns();
+ addFixedData();
+ addStringsData();
+ addTagsData();
+}
+
+void tst_Parser::arrays()
+{
+ QFETCH(QByteArray, data);
+ QFETCH(QString, expected);
+
+ compareOneSize(1, "\x81" + data, '[' + expected + ']');
+ if (compareFailed) return;
+
+ compareOneSize(2, "\x82" + data + data, '[' + expected + ", " + expected + ']');
+ if (compareFailed) return;
+
+ // overlong length
+ compareOneSize(1, "\x98\1" + data, '[' + expected + ']');
+ if (compareFailed) return;
+ compareOneSize(1, raw("\x99\0\1") + data, '[' + expected + ']');
+ if (compareFailed) return;
+ compareOneSize(1, raw("\x9a\0\0\0\1") + data, '[' + expected + ']');
+ if (compareFailed) return;
+ compareOneSize(1, raw("\x9b\0\0\0\0\0\0\0\1") + data, '[' + expected + ']');
+ if (compareFailed) return;
+
+ // medium-sized array: 32 elements (1 << 5)
+ expected += ", ";
+ for (int i = 0; i < 5; ++i) {
+ data += data;
+ expected += expected;
+ }
+ expected.chop(2); // remove the last ", "
+ compareOneSize(32, "\x98\x20" + data, '[' + expected + ']');
+ if (compareFailed) return;
+
+ // large array: 256 elements (32 << 3)
+ expected += ", ";
+ for (int i = 0; i < 3; ++i) {
+ data += data;
+ expected += expected;
+ }
+ expected.chop(2); // remove the last ", "
+ compareOneSize(256, raw("\x99\1\0") + data, '[' + expected + ']');
+ if (compareFailed) return;
+}
+
+void tst_Parser::undefLengthArrays()
+{
+ QFETCH(QByteArray, data);
+ QFETCH(QString, expected);
+
+ compareOne("\x9f" + data + "\xff", "[_ " + expected + ']');
+ if (compareFailed) return;
+
+ compareOne("\x9f" + data + data + "\xff", "[_ " + expected + ", " + expected + ']');
+}
+
+void tst_Parser::nestedArrays()
+{
+ QFETCH(QByteArray, data);
+ QFETCH(QString, expected);
+
+ compareOneSize(1, "\x81\x81" + data, "[[" + expected + "]]");
+ if (compareFailed) return;
+
+ compareOneSize(1, "\x81\x81\x81" + data, "[[[" + expected + "]]]");
+ if (compareFailed) return;
+
+ compareOneSize(1, "\x81\x82" + data + data, "[[" + expected + ", " + expected + "]]");
+ if (compareFailed) return;
+
+ compareOneSize(2, "\x82\x81" + data + data, "[[" + expected + "], " + expected + "]");
+ if (compareFailed) return;
+
+ compareOneSize(2, "\x82\x81" + data + '\x81' + data, "[[" + expected + "], [" + expected + "]]");
+ if (compareFailed) return;
+
+ // undefined length
+ compareOneSize(-1, "\x9f\x9f" + data + data + "\xff\xff", "[_ [_ " + expected + ", " + expected + "]]");
+ if (compareFailed) return;
+
+ compareOneSize(-1, "\x9f\x9f" + data + "\xff\x9f" + data + "\xff\xff", "[_ [_ " + expected + "], [_ " + expected + "]]");
+ if (compareFailed) return;
+
+ compareOneSize(-1, "\x9f\x9f" + data + data + "\xff\x9f" + data + "\xff\xff",
+ "[_ [_ " + expected + ", " + expected + "], [_ " + expected + "]]");
+ if (compareFailed) return;
+
+ // mix them
+ compareOneSize(1, "\x81\x9f" + data + "\xff", "[[_ " + expected + "]]");
+ if (compareFailed) return;
+
+ compareOneSize(-1, "\x9f\x81" + data + "\xff", "[_ [" + expected + "]]");
+}
+
+void tst_Parser::maps_data()
+{
+ arrays_data();
+}
+
+void tst_Parser::maps()
+{
+ QFETCH(QByteArray, data);
+ QFETCH(QString, expected);
+
+ // integer key
+ compareOneSize(1, "\xa1\1" + data, "{1: " + expected + '}');
+ if (compareFailed) return;
+
+ // string key
+ compareOneSize(1, "\xa1\x65" "Hello" + data, "{\"Hello\": " + expected + '}');
+ if (compareFailed) return;
+
+ // map to self
+ compareOneSize(1, "\xa1" + data + data, '{' + expected + ": " + expected + '}');
+ if (compareFailed) return;
+
+ // two integer keys
+ compareOneSize(2, "\xa2\1" + data + "\2" + data, "{1: " + expected + ", 2: " + expected + '}');
+ if (compareFailed) return;
+
+ // OneSize integer and OneSize string key
+ compareOneSize(2, "\xa2\1" + data + "\x65" "Hello" + data, "{1: " + expected + ", \"Hello\": " + expected + '}');
+ if (compareFailed) return;
+}
+
+void tst_Parser::undefLengthMaps()
+{
+ QFETCH(QByteArray, data);
+ QFETCH(QString, expected);
+
+ // integer key
+ compareOne("\xbf\1" + data + '\xff', "{_ 1: " + expected + '}');
+ if (compareFailed) return;
+
+ compareOne("\xbf\1" + data + '\2' + data + '\xff', "{_ 1: " + expected + ", 2: " + expected + '}');
+ if (compareFailed) return;
+
+ compareOne("\xbf\1" + data + "\x65Hello" + data + '\xff', "{_ 1: " + expected + ", \"Hello\": " + expected + '}');
+ if (compareFailed) return;
+
+ compareOne("\xbf\x65Hello" + data + '\1' + data + '\xff', "{_ \"Hello\": " + expected + ", 1: " + expected + '}');
+}
+
+void tst_Parser::nestedMaps()
+{
+ QFETCH(QByteArray, data);
+ QFETCH(QString, expected);
+
+ // nested maps as values
+ compareOneSize(1, "\xa1\1\xa1\2" + data, "{1: {2: " + expected + "}}");
+ if (compareFailed) return;
+
+ compareOneSize(1, "\xa1\x65Hello\xa1\2" + data, "{\"Hello\": {2: " + expected + "}}");
+ if (compareFailed) return;
+
+ compareOneSize(1, "\xa1\1\xa2\2" + data + '\x20' + data, "{1: {2: " + expected + ", -1: " + expected + "}}");
+ if (compareFailed) return;
+
+ compareOneSize(2, "\xa2\1\xa1\2" + data + "\2\xa1\x20" + data, "{1: {2: " + expected + "}, 2: {-1: " + expected + "}}");
+ if (compareFailed) return;
+
+ // nested maps as keys
+ compareOneSize(1, "\xa1\xa1\xf4" + data + "\xf5", "{{false: " + expected + "}: true}");
+ if (compareFailed) return;
+
+ compareOneSize(1, "\xa1\xa1" + data + data + "\xa1" + data + data,
+ "{{" + expected + ": " + expected + "}: {" + expected + ": " + expected + "}}");
+ if (compareFailed) return;
+
+ // undefined length
+ compareOneSize(-1, "\xbf\1\xbf\2" + data + "\xff\xff", "{_ 1: {_ 2: " + expected + "}}");
+ if (compareFailed) return;
+
+ compareOneSize(-1, "\xbf\1\xbf\2" + data + '\x20' + data + "\xff\xff", "{_ 1: {_ 2: " + expected + ", -1: " + expected + "}}");
+ if (compareFailed) return;
+
+ compareOneSize(-1, "\xbf\1\xbf\2" + data + "\xff\2\xbf\x20" + data + "\xff\xff",
+ "{_ 1: {_ 2: " + expected + "}, 2: {_ -1: " + expected + "}}");
+ if (compareFailed) return;
+
+ compareOneSize(-1, "\xbf\xbf" + data + data + "\xff\xbf" + data + data + "\xff\xff",
+ "{_ {_ " + expected + ": " + expected + "}: {_ " + expected + ": " + expected + "}}");
+ if (compareFailed) return;
+
+ // mix them
+ compareOneSize(1, "\xa1\1\xbf\2" + data + "\xff", "{1: {_ 2: " + expected + "}}");
+ if (compareFailed) return;
+
+ compareOneSize(-1, "\xbf\1\xa1\2" + data + "\xff", "{_ 1: {2: " + expected + "}}");
+ if (compareFailed) return;
+}
+
+void addMapMixedData()
+{
+ QTest::newRow("map-0-24") << raw("\xa1\0\x18\x18") << "{0: 24}" << 1;
+ QTest::newRow("map-0*1-24") << raw("\xa1\x18\0\x18\x18") << "{0: 24}" << 1;
+ QTest::newRow("map-0*1-24*2") << raw("\xa1\x18\0\x19\0\x18") << "{0: 24}" << 1;
+ QTest::newRow("map-0*4-24*2") << raw("\xa1\x1a\0\0\0\0\x19\0\x18") << "{0: 24}" << 1;
+ QTest::newRow("map-24-0") << raw("\xa1\x18\x18\0") << "{24: 0}" << 1;
+ QTest::newRow("map-24-0*1") << raw("\xa1\x18\x18\0") << "{24: 0}" << 1;
+ QTest::newRow("map-255-65535") << raw("\xa1\x18\xff\x19\xff\xff") << "{255: 65535}" << 1;
+
+ QTest::newRow("_map-0-24") << raw("\xbf\0\x18\x18\xff") << "{_ 0: 24}" << 1;
+ QTest::newRow("_map-0*1-24") << raw("\xbf\x18\0\x18\x18\xff") << "{_ 0: 24}" << 1;
+ QTest::newRow("_map-0*1-24*2") << raw("\xbf\x18\0\x19\0\x18\xff") << "{_ 0: 24}" << 1;
+ QTest::newRow("_map-0*4-24*2") << raw("\xbf\x1a\0\0\0\0\x19\0\x18\xff") << "{_ 0: 24}" << 1;
+ QTest::newRow("_map-24-0") << raw("\xbf\x18\x18\0\xff") << "{_ 24: 0}" << 1;
+ QTest::newRow("_map-24-0*1") << raw("\xbf\x18\x18\0\xff") << "{_ 24: 0}" << 1;
+ QTest::newRow("_map-255-65535") << raw("\xbf\x18\xff\x19\xff\xff\xff") << "{_ 255: 65535}" << 1;
+}
+
+void tst_Parser::mapMixed_data()
+{
+ addColumns();
+ addMapMixedData();
+}
+
+void tst_Parser::mapsAndArrays()
+{
+ QFETCH(QByteArray, data);
+ QFETCH(QString, expected);
+
+ // arrays of maps
+ compareOneSize(1, "\x81\xa1\1" + data, "[{1: " + expected + "}]");
+ if (compareFailed) return;
+
+ compareOneSize(2, "\x82\xa1\1" + data + "\xa1\2" + data, "[{1: " + expected + "}, {2: " + expected + "}]");
+ if (compareFailed) return;
+
+ compareOneSize(1, "\x81\xa2\1" + data + "\2" + data, "[{1: " + expected + ", 2: " + expected + "}]");
+ if (compareFailed) return;
+
+ compareOneSize(-1, "\x9f\xa1\1" + data + "\xff", "[_ {1: " + expected + "}]");
+ if (compareFailed) return;
+
+ compareOneSize(1, "\x81\xbf\1" + data + "\xff", "[{_ 1: " + expected + "}]");
+ if (compareFailed) return;
+
+ compareOneSize(-1, "\x9f\xbf\1" + data + "\xff\xff", "[_ {_ 1: " + expected + "}]");
+ if (compareFailed) return;
+
+ // maps of arrays
+ compareOneSize(1, "\xa1\1\x81" + data, "{1: [" + expected + "]}");
+ if (compareFailed) return;
+
+ compareOneSize(1, "\xa1\1\x82" + data + data, "{1: [" + expected + ", " + expected + "]}");
+ if (compareFailed) return;
+
+ compareOneSize(2, "\xa2\1\x81" + data + "\x65Hello\x81" + data, "{1: [" + expected + "], \"Hello\": [" + expected + "]}");
+ if (compareFailed) return;
+
+ compareOneSize(1, "\xa1\1\x9f" + data + "\xff", "{1: [_ " + expected + "]}");
+ if (compareFailed) return;
+
+ compareOneSize(1, "\xa1\1\x9f" + data + data + "\xff", "{1: [_ " + expected + ", " + expected + "]}");
+ if (compareFailed) return;
+
+ compareOneSize(-1, "\xbf\1\x81" + data + "\xff", "{_ 1: [" + expected + "]}");
+ if (compareFailed) return;
+
+ compareOneSize(-1, "\xbf\1\x9f" + data + "\xff\xff", "{_ 1: [_ " + expected + "]}");
+ if (compareFailed) return;
+
+ compareOneSize(-1, "\xbf\1\x9f" + data + data + "\xff\xff", "{_ 1: [_ " + expected + ", " + expected + "]}");
+ if (compareFailed) return;
+
+ // mixed with indeterminate length strings
+ compareOneSize(-1, "\xbf\1\x9f" + data + "\xff\x65Hello\xbf" + data + "\x7f\xff\xff\xff",
+ "{_ 1: [_ " + expected + "], \"Hello\": {_ " + expected + ": \"\"}}");
+}
+
+void tst_Parser::stringLength_data()
+{
+ QTest::addColumn<QByteArray>("data");
+ QTest::addColumn<int>("expected");
+
+ QTest::newRow("emptybytestring") << raw("\x40") << 0;
+ QTest::newRow("bytestring1") << raw("\x41 ") << 1;
+ QTest::newRow("bytestring1-nul") << raw("\x41\0") << 1;
+ QTest::newRow("bytestring5") << raw("\x45Hello") << 5;
+ QTest::newRow("bytestring24") << raw("\x58\x18""123456789012345678901234") << 24;
+ QTest::newRow("bytestring256") << raw("\x59\1\0") + QByteArray(256, '3') << 256;
+
+ // text strings
+ QTest::newRow("emptytextstring") << raw("\x60") << 0;
+ QTest::newRow("textstring1") << raw("\x61 ") << 1;
+ QTest::newRow("textstring1-nul") << raw("\x61\0") << 1;
+ QTest::newRow("textstring5") << raw("\x65Hello") << 5;
+ QTest::newRow("textstring24") << raw("\x78\x18""123456789012345678901234") << 24;
+ QTest::newRow("textstring256") << raw("\x79\1\0") + QByteArray(256, '3') << 256;
+
+ // strings with overlong length
+ QTest::newRow("emptybytestring*1") << raw("\x58\x00") << 0;
+ QTest::newRow("emptytextstring*1") << raw("\x78\x00") << 0;
+ QTest::newRow("emptybytestring*2") << raw("\x59\x00\x00") << 0;
+ QTest::newRow("emptytextstring*2") << raw("\x79\x00\x00") << 0;
+ QTest::newRow("emptybytestring*4") << raw("\x5a\0\0\0\0") << 0;
+ QTest::newRow("emptytextstring*4") << raw("\x7a\0\0\0\0") << 0;
+ QTest::newRow("emptybytestring*8") << raw("\x5b\0\0\0\0\0\0\0\0") << 0;
+ QTest::newRow("emptytextstring*8") << raw("\x7b\0\0\0\0\0\0\0\0") << 0;
+ QTest::newRow("bytestring5*1") << raw("\x58\x05Hello") << 5;
+ QTest::newRow("textstring5*1") << raw("\x78\x05Hello") << 5;
+ QTest::newRow("bytestring5*2") << raw("\x59\0\5Hello") << 5;
+ QTest::newRow("textstring5*2") << raw("\x79\0\x05Hello") << 5;
+ QTest::newRow("bytestring5*4") << raw("\x5a\0\0\0\5Hello") << 5;
+ QTest::newRow("textstring5*4") << raw("\x7a\0\0\0\x05Hello") << 5;
+ QTest::newRow("bytestring5*8") << raw("\x5b\0\0\0\0\0\0\0\5Hello") << 5;
+ QTest::newRow("textstring5*8") << raw("\x7b\0\0\0\0\0\0\0\x05Hello") << 5;
+
+ // strings with undefined length
+ QTest::newRow("_emptybytestring") << raw("\x5f\xff") << 0;
+ QTest::newRow("_emptytextstring") << raw("\x7f\xff") << 0;
+ QTest::newRow("_emptybytestring2") << raw("\x5f\x40\xff") << 0;
+ QTest::newRow("_emptytextstring2") << raw("\x7f\x60\xff") << 0;
+ QTest::newRow("_emptybytestring3") << raw("\x5f\x40\x40\xff") << 0;
+ QTest::newRow("_emptytextstring3") << raw("\x7f\x60\x60\xff") << 0;
+ QTest::newRow("_bytestring5*2") << raw("\x5f\x43Hel\x42lo\xff") << 5;
+ QTest::newRow("_textstring5*2") << raw("\x7f\x63Hel\x62lo\xff") << 5;
+ QTest::newRow("_bytestring5*5") << raw("\x5f\x41H\x41""e\x41l\x41l\x41o\xff") << 5;
+ QTest::newRow("_textstring5*5") << raw("\x7f\x61H\x61""e\x61l\x61l\x61o\xff") << 5;
+ QTest::newRow("_bytestring5*6") << raw("\x5f\x41H\x41""e\x40\x41l\x41l\x41o\xff") << 5;
+ QTest::newRow("_textstring5*6") << raw("\x7f\x61H\x61""e\x61l\x60\x61l\x61o\xff") << 5;
+}
+
+void tst_Parser::stringLength()
+{
+ QFETCH(QByteArray, data);
+ QFETCH(int, expected);
+
+ CborParser parser;
+ CborValue value;
+ CborError err = cbor_parser_init(reinterpret_cast<const quint8 *>(data.constData()), data.length(), 0, &parser, &value);
+ QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\"");
+
+ size_t result;
+ err = cbor_value_calculate_string_length(&value, &result);
+ QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\"");
+ QCOMPARE(result, size_t(expected));
++
++ if (cbor_value_is_length_known(&value)) {
++ QCOMPARE(cbor_value_get_string_length(&value, &result), CborNoError);
++ QCOMPARE(result, size_t(expected));
++ }
++
+}
+
+void tst_Parser::stringCompare_data()
+{
+ QTest::addColumn<QByteArray>("data");
+ QTest::addColumn<QString>("string");
+ QTest::addColumn<bool>("expected");
+
+ // compare empty to empty
+ QTest::newRow("empty-empty") << raw("\x60") << QString() << true;
+ QTest::newRow("_empty-empty") << raw("\x7f\xff") << QString() << true;
+ QTest::newRow("_empty*1-empty") << raw("\x7f\x60\xff") << QString() << true;
+ QTest::newRow("_empty*2-empty") << raw("\x7f\x60\x60\xff") << QString() << true;
+
+ // compare empty to non-empty
+ QTest::newRow("empty-nonempty") << raw("\x60") << "Hello" << false;
+ QTest::newRow("_empty-nonempty") << raw("\x7f\xff") << "Hello" << false;
+ QTest::newRow("_empty*1-nonempty") << raw("\x7f\x60\xff") << "Hello" << false;
+ QTest::newRow("_empty*2-nonempty") << raw("\x7f\x60\x60\xff") << "Hello" << false;
+
+ // compare same strings
+ QTest::newRow("same-short-short") << raw("\x65Hello") << "Hello" << true;
+ QTest::newRow("same-_short*1-short") << raw("\x7f\x65Hello\xff") << "Hello" << true;
+ QTest::newRow("same-_short*2-short") << raw("\x7f\x63Hel\x62lo\xff") << "Hello" << true;
+ QTest::newRow("same-_short*5-short") << raw("\x7f\x61H\x61""e\x61l\x61l\x61o\xff") << "Hello" << true;
+ QTest::newRow("same-_short*8-short") << raw("\x7f\x61H\x60\x61""e\x60\x61l\x61l\x60\x61o\xff") << "Hello" << true;
+ QTest::newRow("same-long-long") << raw("\x78\x2aGood morning, good afternoon and goodnight")
+ << "Good morning, good afternoon and goodnight" << true;
+ QTest::newRow("same-_long*1-long") << raw("\x7f\x78\x2aGood morning, good afternoon and goodnight\xff")
+ << "Good morning, good afternoon and goodnight" << true;
+ QTest::newRow("same-_long*2-long") << raw("\x7f\x78\x1cGood morning, good afternoon\x6e and goodnight\xff")
+ << "Good morning, good afternoon and goodnight" << true;
+
+ // compare different strings (same length)
+ QTest::newRow("diff-same-length-short-short") << raw("\x65Hello") << "World" << false;
+ QTest::newRow("diff-same-length-_short*1-short") << raw("\x7f\x65Hello\xff") << "World" << false;
+ QTest::newRow("diff-same-length-_short*2-short") << raw("\x7f\x63Hel\x62lo\xff") << "World" << false;
+ QTest::newRow("diff-same-length-_short*5-short") << raw("\x7f\x61H\x61""e\x61l\x61l\x61o\xff") << "World" << false;
+ QTest::newRow("diff-same-length-_short*8-short") << raw("\x7f\x61H\x60\x61""e\x60\x61l\x61l\x60\x61o\xff") << "World" << false;
+ QTest::newRow("diff-same-length-long-long") << raw("\x78\x2aGood morning, good afternoon and goodnight")
+ << "Good morning, good afternoon and goodnight, world" << false;
+ QTest::newRow("diff-same-length-_long*1-long") << raw("\x7f\x78\x2aGood morning, good afternoon and goodnight\xff")
+ << "Good morning, good afternoon and goodnight, world" << false;
+ QTest::newRow("diff-same-length-_long*2-long") << raw("\x7f\x78\x1cGood morning, good afternoon\x6e and goodnight\xff")
+ << "Good morning, good afternoon and goodnight, world" << false;
+
+ // compare different strings (different length)
+ QTest::newRow("diff-diff-length-short-short") << raw("\x65Hello") << "Hello World" << false;
+ QTest::newRow("diff-diff-length-_short*1-short") << raw("\x7f\x65Hello\xff") << "Hello World" << false;
+ QTest::newRow("diff-diff-length-_short*2-short") << raw("\x7f\x63Hel\x62lo\xff") << "Hello World" << false;
+ QTest::newRow("diff-diff-length-_short*5-short") << raw("\x7f\x61H\x61""e\x61l\x61l\x61o\xff") << "Hello World" << false;
+ QTest::newRow("diff-diff-length-_short*8-short") << raw("\x7f\x61H\x60\x61""e\x60\x61l\x61l\x60\x61o\xff") << "Hello World" << false;
+ QTest::newRow("diff-diff-length-long-long") << raw("\x78\x2aGood morning, good afternoon and goodnight")
+ << "Good morning, good afternoon and goodnight World" << false;
+ QTest::newRow("diff-diff-length-_long*1-long") << raw("\x7f\x78\x2aGood morning, good afternoon and goodnight\xff")
+ << "Good morning, good afternoon and goodnight World" << false;
+ QTest::newRow("diff-diff-length-_long*2-long") << raw("\x7f\x78\x1cGood morning, good afternoon\x6e and goodnight\xff")
+ << "Good morning, good afternoon and goodnight World" << false;
+
+ // compare against non-strings
+ QTest::newRow("unsigned") << raw("\0") << "0" << false;
+ QTest::newRow("negative") << raw("\x20") << "-1" << false;
+ QTest::newRow("emptybytestring") << raw("\x40") << "" << false;
+ QTest::newRow("_emptybytestring") << raw("\x5f\xff") << "" << false;
+ QTest::newRow("shortbytestring") << raw("\x45Hello") << "Hello" << false;
+ QTest::newRow("longbytestring") << raw("\x58\x2aGood morning, good afternoon and goodnight")
+ << "Good morning, good afternoon and goodnight" << false;
+ QTest::newRow("emptyarray") << raw("\x80") << "" << false;
+ QTest::newRow("emptymap") << raw("\xa0") << "" << false;
+ QTest::newRow("array") << raw("\x81\x65Hello") << "Hello" << false;
+ QTest::newRow("map") << raw("\xa1\x65Hello\x65World") << "Hello World" << false;
+ QTest::newRow("false") << raw("\xf4") << "false" << false;
+ QTest::newRow("true") << raw("\xf5") << "true" << false;
+ QTest::newRow("null") << raw("\xf6") << "null" << false;
+}
+
+void compareOneString(const QByteArray &data, const QString &string, bool expected, int line)
+{
+ compareFailed = true;
+
+ CborParser parser;
+ CborValue value;
+ CborError err = cbor_parser_init(reinterpret_cast<const quint8 *>(data.constData()), data.length(), 0, &parser, &value);
+ QVERIFY2(!err, QByteArray::number(line) + ": Got error \"" + cbor_error_string(err) + "\"");
+
+ bool result;
- QCOMPARE(int(first.ptr - reinterpret_cast<const quint8 *>(data.constBegin())), offset);
++ QByteArray bastring = string.toUtf8();
++ err = cbor_value_text_string_equals(&value, bastring.constData(), &result);
+ QVERIFY2(!err, QByteArray::number(line) + ": Got error \"" + cbor_error_string(err) + "\"");
+ QCOMPARE(result, expected);
+
++ if (expected) {
++ size_t len;
++ cbor_value_skip_tag(&value);
++ if (cbor_value_is_length_known(&value)) {
++ QCOMPARE(cbor_value_get_string_length(&value, &len), CborNoError);
++ QCOMPARE(int(len), bastring.size());
++ }
++ QCOMPARE(cbor_value_calculate_string_length(&value, &len), CborNoError);
++ QCOMPARE(int(len), bastring.size());
++ }
++
+ compareFailed = false;
+}
+#define compareOneString(data, string, expected) compareOneString(data, string, expected, __LINE__)
+
+void tst_Parser::stringCompare()
+{
+ QFETCH(QByteArray, data);
+ QFETCH(QString, string);
+ QFETCH(bool, expected);
+
+ compareOneString(data, string, expected);
+ if (compareFailed) return;
+
+ // tag it
+ compareOneString("\xc1" + data, string, expected);
+ if (compareFailed) return;
+
+ compareOneString("\xc1\xc2" + data, string, expected);
+}
+
+void tst_Parser::mapFind_data()
+{
+ // Rules:
+ // we are searching for string "needle"
+ // if present, the value should be the string "haystack" (with tag 42)
+
+ QTest::addColumn<QByteArray>("data");
+ QTest::addColumn<bool>("expected");
+
+ QTest::newRow("emptymap") << raw("\xa0") << false;
+ QTest::newRow("_emptymap") << raw("\xbf\xff") << false;
+
+ // maps not containing our items
+ QTest::newRow("absent-unsigned-unsigned") << raw("\xa1\0\0") << false;
+ QTest::newRow("absent-taggedunsigned-unsigned") << raw("\xa1\xc0\0\0") << false;
+ QTest::newRow("absent-unsigned-taggedunsigned") << raw("\xa1\0\xc0\0") << false;
+ QTest::newRow("absent-taggedunsigned-taggedunsigned") << raw("\xa1\xc0\0\xc0\0") << false;
+ QTest::newRow("absent-string-unsigned") << raw("\xa1\x68haystack\0") << false;
+ QTest::newRow("absent-taggedstring-unsigned") << raw("\xa1\xc0\x68haystack\0") << false;
+ QTest::newRow("absent-string-taggedunsigned") << raw("\xa1\x68haystack\xc0\0") << false;
+ QTest::newRow("absent-taggedstring-taggedunsigned") << raw("\xa1\xc0\x68haystack\xc0\0") << false;
+ QTest::newRow("absent-string-string") << raw("\xa1\x68haystack\x66needle") << false;
+ QTest::newRow("absent-string-taggedstring") << raw("\xa1\x68haystack\xc0\x66needle") << false;
+ QTest::newRow("absent-taggedstring-string") << raw("\xa1\xc0\x68haystack\x66needle") << false;
+ QTest::newRow("absent-string-taggedstring") << raw("\xa1\xc0\x68haystack\xc0\x66needle") << false;
+
+ QTest::newRow("absent-string-emptyarray") << raw("\xa1\x68haystack\x80") << false;
+ QTest::newRow("absent-string-_emptyarray") << raw("\xa1\x68haystack\x9f\xff") << false;
+ QTest::newRow("absent-string-array1") << raw("\xa1\x68haystack\x81\0") << false;
+ QTest::newRow("absent-string-array2") << raw("\xa1\x68haystack\x85\0\1\2\3\4") << false;
+ QTest::newRow("absent-string-array3") << raw("\xa1\x68haystack\x85\x63one\x63two\x65three\x64""four\x64""five") << false;
+
+ QTest::newRow("absent-string-emptymap") << raw("\xa1\x68haystack\xa0") << false;
+ QTest::newRow("absent-string-_emptymap") << raw("\xa1\x68haystack\xbf\xff") << false;
+ QTest::newRow("absent-string-map") << raw("\xa1\x68haystack\xa1\x68haystack\x66needle") << false;
+ QTest::newRow("absent-string-map2") << raw("\xa1\x68haystack\xa1\x68haystack\x66needle\61z\62yx") << false;
+
+ // maps containing our items
+ QTest::newRow("alone") << raw("\xa1\x66needle\xd8\x2a\x68haystack") << true;
+ QTest::newRow("tagged") << raw("\xa1\xc1\x66needle\xd8\x2a\x68haystack") << true;
+ QTest::newRow("doubletagged") << raw("\xa1\xc1\xc2\x66needle\xd8\x2a\x68haystack") << true;
+ QTest::newRow("chunked") << raw("\xa1\x7f\x66needle\xff\xd8\x2a\x68haystack") << true;
+ QTest::newRow("chunked*2") << raw("\xa1\x7f\x60\x66needle\xff\xd8\x2a\x68haystack") << true;
+ QTest::newRow("chunked*2bis") << raw("\xa1\x7f\x66needle\x60\xff\xd8\x2a\x68haystack") << true;
+ QTest::newRow("chunked*3") << raw("\xa1\x7f\x62ne\x62""ed\x62le\xff\xd8\x2a\x68haystack") << true;
+ QTest::newRow("chunked*8") << raw("\xa1\x7f\x61n\x61""e\x60\x61""e\x61""d\x60\x62le\x60\xff\xd8\x2a\x68haystack") << true;
+
+ QTest::newRow("1before") << raw("\xa2\x68haystack\x66needle\x66needle\xd8\x2a\x68haystack") << true;
+ QTest::newRow("tagged-1before") << raw("\xa2\xc1\x68haystack\x66needle\xc1\x66needle\xd8\x2a\x68haystack") << true;
+ QTest::newRow("doubletagged-1before2") << raw("\xa2\xc1\xc2\x68haystack\x66needle\xc1\xc2\x66needle\xd8\x2a\x68haystack") << true;
+
+ QTest::newRow("arraybefore") << raw("\xa2\x61z\x80\x66needle\xd8\x2a\x68haystack") << true;
+ QTest::newRow("nestedarraybefore") << raw("\xa2\x61z\x81\x81\0\x66needle\xd8\x2a\x68haystack") << true;
+ QTest::newRow("arrayarraybefore") << raw("\xa2\x82\1\2\x80\x66needle\xd8\x2a\x68haystack") << true;
+
+ QTest::newRow("mapbefore") << raw("\xa2\x61z\xa0\x66needle\xd8\x2a\x68haystack") << true;
+ QTest::newRow("nestedmapbefore") << raw("\xa2\x61z\xa1\0\x81\0\x66needle\xd8\x2a\x68haystack") << true;
+ QTest::newRow("mapmapbefore") << raw("\xa2\xa1\1\2\xa0\x66needle\xd8\x2a\x68haystack") << true;
+}
+
+void tst_Parser::mapFind()
+{
+ QFETCH(QByteArray, data);
+ QFETCH(bool, expected);
+
+ CborParser parser;
+ CborValue value;
+ CborError err = cbor_parser_init(reinterpret_cast<const quint8 *>(data.constData()), data.length(), 0, &parser, &value);
+ QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\"");
+
+ CborValue element;
+ err = cbor_value_map_find_value(&value, "needle", &element);
+ QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\"");
+
+ if (expected) {
+ QCOMPARE(int(element.type), int(CborTagType));
+
+ CborTag tag;
+ err = cbor_value_get_tag(&element, &tag);
+ QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\"");
+ QCOMPARE(int(tag), 42);
+
+ bool equals;
+ err = cbor_value_text_string_equals(&element, "haystack", &equals);
+ QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\"");
+ QVERIFY(equals);
+ } else {
+ QCOMPARE(int(element.type), int(CborInvalidType));
+ }
+}
+
++void tst_Parser::checkedIntegers_data()
++{
++ QTest::addColumn<QByteArray>("data");
++ QTest::addColumn<QVariant>("result"); // QVariant so we can note numbers out of int64_t range
++
++ QTest::newRow("0") << raw("\x00") << QVariant(Q_INT64_C(0));
++ QTest::newRow("1") << raw("\x01") << QVariant(Q_INT64_C(1));
++ QTest::newRow("10") << raw("\x0a") << QVariant(Q_INT64_C(10));
++ QTest::newRow("23") << raw("\x17") << QVariant(Q_INT64_C(23));
++ QTest::newRow("24") << raw("\x18\x18") << QVariant(Q_INT64_C(24));
++ QTest::newRow("UINT8_MAX") << raw("\x18\xff") << QVariant(Q_INT64_C(255));
++ QTest::newRow("UINT8_MAX+1") << raw("\x19\x01\x00") << QVariant(Q_INT64_C(256));
++ QTest::newRow("UINT16_MAX") << raw("\x19\xff\xff") << QVariant(Q_INT64_C(65535));
++ QTest::newRow("UINT16_MAX+1") << raw("\x1a\0\1\x00\x00") << QVariant(Q_INT64_C(65536));
++ QTest::newRow("INT32_MAX") << raw("\x1a\x7f\xff\xff\xff") << QVariant(Q_INT64_C(2147483647));
++ QTest::newRow("INT32_MAX+1") << raw("\x1a\x80\x00\x00\x00") << QVariant(Q_INT64_C(2147483648));
++ QTest::newRow("UINT32_MAX") << raw("\x1a\xff\xff\xff\xff") << QVariant(Q_INT64_C(4294967295));
++ QTest::newRow("UINT32_MAX+1") << raw("\x1b\0\0\0\1\0\0\0\0") << QVariant(Q_INT64_C(4294967296));
++ QTest::newRow("UINT64_MAX") << raw("\x1b" "\xff\xff\xff\xff" "\xff\xff\xff\xff")
++ << QVariant(); // out of range
++
++ // negative integers
++ QTest::newRow("-1") << raw("\x20") << QVariant(Q_INT64_C(-1));
++ QTest::newRow("-2") << raw("\x21") << QVariant(Q_INT64_C(-2));
++ QTest::newRow("-24") << raw("\x37") << QVariant(Q_INT64_C(-24));
++ QTest::newRow("-25") << raw("\x38\x18") << QVariant(Q_INT64_C(-25));
++ QTest::newRow("-UINT8_MAX") << raw("\x38\xff") << QVariant(Q_INT64_C(-256));
++ QTest::newRow("-UINT8_MAX-1") << raw("\x39\x01\x00") << QVariant(Q_INT64_C(-257));
++ QTest::newRow("-UINT16_MAX") << raw("\x39\xff\xff") << QVariant(Q_INT64_C(-65536));
++ QTest::newRow("-UINT16_MAX-1") << raw("\x3a\0\1\x00\x00") << QVariant(Q_INT64_C(-65537));
++ QTest::newRow("INT32_MIN") << raw("\x3a\x7f\xff\xff\xff") << QVariant(Q_INT64_C(-2147483648));
++ QTest::newRow("INT32_MIN-1") << raw("\x3a\x80\x00\x00\x00") << QVariant(Q_INT64_C(-2147483649));
++ 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("INT64_MIN+1") << raw("\x3b\x7f\xff\xff\xff""\xff\xff\xff\xfe")
++ << QVariant(std::numeric_limits<qint64>::min() + 1);
++ QTest::newRow("INT64_MIN") << raw("\x3b\x7f\xff\xff\xff""\xff\xff\xff\xff")
++ << QVariant(std::numeric_limits<qint64>::min());
++ QTest::newRow("INT64_MIN-1") << raw("\x3b\x80\0\0\0""\0\0\0\0") << QVariant(); // out of range
++ QTest::newRow("-UINT64_MAX") << raw("\x3b" "\xff\xff\xff\xff" "\xff\xff\xff\xfe")
++ << QVariant(); // out of range
++ QTest::newRow("-UINT64_MAX+1") << raw("\x3b" "\xff\xff\xff\xff" "\xff\xff\xff\xff")
++ << QVariant(); // out of range
++}
++
++void tst_Parser::checkedIntegers()
++{
++ QFETCH(QByteArray, data);
++ QFETCH(QVariant, result);
++ int64_t expected = result.toLongLong();
++
++ CborParser parser;
++ CborValue value;
++ CborError err = cbor_parser_init(reinterpret_cast<const quint8 *>(data.constData()), data.length(), 0, &parser, &value);
++ QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\"");
++
++ int64_t v;
++ err = cbor_value_get_int64_checked(&value, &v);
++ if (result.isNull()) {
++ QCOMPARE(int(err), int(CborErrorDataTooLarge));
++ } else {
++ QCOMPARE(v, expected);
++ }
++
++ int v2;
++ err = cbor_value_get_int_checked(&value, &v2);
++ if (result.isNull() || expected < std::numeric_limits<int>::min() || expected > std::numeric_limits<int>::max()) {
++ QCOMPARE(int(err), int(CborErrorDataTooLarge));
++ } else {
++ QCOMPARE(int64_t(v2), expected);
++ }
++}
++
+void tst_Parser::validation_data()
+{
+ QTest::addColumn<QByteArray>("data");
+ QTest::addColumn<int>("flags"); // future
+ QTest::addColumn<CborError>("expectedError");
+ QTest::addColumn<int>("offset");
+
+ // illegal numbers are future extension points
+ QTest::newRow("illegal-number-in-unsigned-1") << raw("\x81\x1c") << 0 << CborErrorIllegalNumber << 1;
+ QTest::newRow("illegal-number-in-unsigned-2") << raw("\x81\x1d") << 0 << CborErrorIllegalNumber << 1;
+ QTest::newRow("illegal-number-in-unsigned-3") << raw("\x81\x1e") << 0 << CborErrorIllegalNumber << 1;
+ QTest::newRow("illegal-number-in-unsigned-4") << raw("\x81\x1f") << 0 << CborErrorIllegalNumber << 1;
+ QTest::newRow("illegal-number-in-negative-1") << raw("\x81\x3c") << 0 << CborErrorIllegalNumber << 1;
+ QTest::newRow("illegal-number-in-negative-2") << raw("\x81\x3d") << 0 << CborErrorIllegalNumber << 1;
+ QTest::newRow("illegal-number-in-negative-3") << raw("\x81\x3e") << 0 << CborErrorIllegalNumber << 1;
+ QTest::newRow("illegal-number-in-negative-4") << raw("\x81\x3f") << 0 << CborErrorIllegalNumber << 1;
+ QTest::newRow("illegal-number-in-bytearray-length-1") << raw("\x81\x5c") << 0 << CborErrorIllegalNumber << 1;
+ QTest::newRow("illegal-number-in-bytearray-length-2") << raw("\x81\x5d") << 0 << CborErrorIllegalNumber << 1;
+ QTest::newRow("illegal-number-in-bytearray-length-3") << raw("\x81\x5e") << 0 << CborErrorIllegalNumber << 1;
+ QTest::newRow("illegal-number-in-string-length-1") << raw("\x81\x7c") << 0 << CborErrorIllegalNumber << 1;
+ QTest::newRow("illegal-number-in-string-length-2") << raw("\x81\x7d") << 0 << CborErrorIllegalNumber << 1;
+ QTest::newRow("illegal-number-in-string-length-3") << raw("\x81\x7e") << 0 << CborErrorIllegalNumber << 1;
+ QTest::newRow("illegal-number-in-array-length-1") << raw("\x81\x9c") << 0 << CborErrorIllegalNumber << 1;
+ QTest::newRow("illegal-number-in-array-length-2") << raw("\x81\x9d") << 0 << CborErrorIllegalNumber << 1;
+ QTest::newRow("illegal-number-in-array-length-3") << raw("\x81\x9e") << 0 << CborErrorIllegalNumber << 1;
+ QTest::newRow("illegal-number-in-map-length-1") << raw("\x81\xbc") << 0 << CborErrorIllegalNumber << 1;
+ QTest::newRow("illegal-number-in-map-length-2") << raw("\x81\xbd") << 0 << CborErrorIllegalNumber << 1;
+ QTest::newRow("illegal-number-in-map-length-3") << raw("\x81\xbe") << 0 << CborErrorIllegalNumber << 1;
+
+ QTest::newRow("number-too-short-1-0") << raw("\x81\x18") << 0 << CborErrorUnexpectedEOF << 1; // requires 1 byte, 0 given
+ QTest::newRow("number-too-short-2-0") << raw("\x81\x19") << 0 << CborErrorUnexpectedEOF << 1; // requires 2 bytes, 0 given
+ QTest::newRow("number-too-short-2-1") << raw("\x81\x19\x01") << 0 << CborErrorUnexpectedEOF << 1; // etc
+ QTest::newRow("number-too-short-4-0") << raw("\x81\x1a") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("number-too-short-4-3") << raw("\x81\x1a\x01\x02\x03") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("number-too-short-8-0") << raw("\x81\x1b") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("number-too-short-8-7") << raw("\x81\x1b\1\2\3\4\5\6\7") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("bytearray-length-too-short-1-0") << raw("\x81\x38") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("bytearray-length-too-short-2-0") << raw("\x81\x39") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("bytearray-length-too-short-2-1") << raw("\x81\x39\x01") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("bytearray-length-too-short-4-0") << raw("\x81\x3a") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("bytearray-length-too-short-4-3") << raw("\x81\x3a\x01\x02\x03") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("bytearray-length-too-short-8-0") << raw("\x81\x3b") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("bytearray-length-too-short-8-7") << raw("\x81\x3b\1\2\3\4\5\6\7") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("string-length-too-short-1-0") << raw("\x81\x58") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("string-length-too-short-2-0") << raw("\x81\x59") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("string-length-too-short-2-1") << raw("\x81\x59\x01") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("string-length-too-short-4-0") << raw("\x81\x5a") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("string-length-too-short-4-3") << raw("\x81\x5a\x01\x02\x03") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("string-length-too-short-8-0") << raw("\x81\x5b") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("string-length-too-short-8-7") << raw("\x81\x5b\1\2\3\4\5\6\7") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("array-length-too-short-1-0") << raw("\x81\x98") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("array-length-too-short-2-0") << raw("\x81\x99") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("array-length-too-short-2-1") << raw("\x81\x99\x01") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("array-length-too-short-4-0") << raw("\x81\x9a") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("array-length-too-short-4-3") << raw("\x81\x9a\x01\x02\x03") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("array-length-too-short-8-0") << raw("\x81\x9b") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("array-length-too-short-8-7") << raw("\x81\x9b\1\2\3\4\5\6\7") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("map-length-too-short-1-0") << raw("\x81\xb8") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("map-length-too-short-2-0") << raw("\x81\xb9") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("map-length-too-short-2-1") << raw("\x81\xb9\x01") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("map-length-too-short-4-0") << raw("\x81\xba") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("map-length-too-short-4-3") << raw("\x81\xba\x01\x02\x03") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("map-length-too-short-8-0") << raw("\x81\xbb") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("map-length-too-short-8-7") << raw("\x81\xbb\1\2\3\4\5\6\7") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("tag-too-short-1-0") << raw("\x81\xd8") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("tag-too-short-2-0") << raw("\x81\xd9") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("tag-too-short-2-1") << raw("\x81\xd9\x01") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("tag-too-short-4-0") << raw("\x81\xda") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("tag-too-short-4-3") << raw("\x81\xda\x01\x02\x03") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("tag-too-short-8-0") << raw("\x81\xdb") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("tag-too-short-8-7") << raw("\x81\xdb\1\2\3\4\5\6\7") << 0 << CborErrorUnexpectedEOF << 1;
+
+ QTest::newRow("bytearray-too-short1") << raw("\x81\x41") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("bytearray-too-short2") << raw("\x81\x58") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("bytearray-too-short3") << raw("\x81\x58\x01") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("bytearray-too-short4") << raw("\x81\x59") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("bytearray-too-short5") << raw("\x81\x5a\0\0\0\1") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("bytearray-too-short6") << raw("\x81\x5b\0\0\0\0\0\0\0\1") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("string-too-short1") << raw("\x81\x61") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("string-too-short2") << raw("\x81\x78") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("string-too-short3") << raw("\x81\x78\x01") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("string-too-short4") << raw("\x81\x79") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("string-too-short5") << raw("\x81\x7a\0\0\0\1") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("string-too-short6") << raw("\x81\x7b\0\0\0\0\0\0\0\1") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("fp16-too-short1") << raw("\x81\xf9") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("fp16-too-short2") << raw("\x81\xf9\x00") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("float-too-short1") << raw("\x81\xfa") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("float-too-short2") << raw("\x81\xfa\0\0\0") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("double-too-short1") << raw("\x81\xfb") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("double-too-short2") << raw("\x81\xfb\0\0\0\0\0\0\0") << 0 << CborErrorUnexpectedEOF << 1;
+
+ // check for pointer additions wrapping over the limit of the address space
+ CborError tooLargeOn32bit = (sizeof(void *) == 4) ? CborErrorDataTooLarge : CborErrorUnexpectedEOF;
+ // on 32-bit systems, this is a -1
+ QTest::newRow("bytearray-wraparound1") << raw("\x81\x5a\xff\xff\xff\xff") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("string-wraparound1") << raw("\x81\x7a\xff\xff\xff\xff") << 0 << CborErrorUnexpectedEOF << 1;
+ // on 32-bit systems, a 4GB addition could be dropped
+ QTest::newRow("bytearray-wraparound2") << raw("\x81\x5b\0\0\0\1\0\0\0\0") << 0 << tooLargeOn32bit << 1;
+ QTest::newRow("string-wraparound2") << raw("\x81\x7b\0\0\0\1\0\0\0\0") << 0 << tooLargeOn32bit << 1;
+ // on 64-bit systems, this could be a -1
+ QTest::newRow("bytearray-wraparound3") << raw("\x81\x5b\xff\xff\xff\xff\xff\xff\xff\xff") << 0 << tooLargeOn32bit << 1;
+ QTest::newRow("string-wraparound3") << raw("\x81\x7b\xff\xff\xff\xff\xff\xff\xff\xff") << 0 << tooLargeOn32bit << 1;
+
+ // ditto on chunks
+ QTest::newRow("bytearray-chunk-wraparound1") << raw("\x81\x5f\x5a\xff\xff\xff\xff") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("string-chunk-wraparound1") << raw("\x81\x7f\x7a\xff\xff\xff\xff") << 0 << CborErrorUnexpectedEOF << 1;
+ // on 32-bit systems, a 4GB addition could be dropped
+ QTest::newRow("bytearray-chunk-wraparound2") << raw("\x81\x5f\x5b\0\0\0\1\0\0\0\0") << 0 << tooLargeOn32bit << 1;
+ QTest::newRow("string-chunk-wraparound2") << raw("\x81\x7f\x7b\0\0\0\1\0\0\0\0") << 0 << tooLargeOn32bit << 1;
+ // on 64-bit systems, this could be a -1
+ QTest::newRow("bytearray-chunk-wraparound3") << raw("\x81\x5f\x5b\xff\xff\xff\xff\xff\xff\xff\xff") << 0 << tooLargeOn32bit << 1;
+ QTest::newRow("string-chunk-wraparound3") << raw("\x81\x7f\x7b\xff\xff\xff\xff\xff\xff\xff\xff") << 0 << tooLargeOn32bit << 1;
+
+ QTest::newRow("eof-after-array") << raw("\x81") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("eof-after-array2") << raw("\x81\x78\x20") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("eof-after-array-element") << raw("\x81\x82\x01") << 0 << CborErrorUnexpectedEOF << 3;
+ QTest::newRow("eof-after-object") << raw("\x81\xa1") << 0 << CborErrorUnexpectedEOF << 2;
+ QTest::newRow("eof-after-object2") << raw("\x81\xb8\x20") << 0 << CborErrorUnexpectedEOF << 3;
+ QTest::newRow("eof-after-object-key") << raw("\x81\xa1\x01") << 0 << CborErrorUnexpectedEOF << 3;
+ QTest::newRow("eof-after-object-value") << raw("\x81\xa2\x01\x01") << 0 << CborErrorUnexpectedEOF << 4;
+ QTest::newRow("eof-after-tag") << raw("\x81\xc0") << 0 << CborErrorUnexpectedEOF << 2;
+ QTest::newRow("eof-after-tag2") << raw("\x81\xd8\x20") << 0 << CborErrorUnexpectedEOF << 3;
+
+ // major type 7 has future types
+ QTest::newRow("future-type-28") << raw("\x81\xfc") << 0 << CborErrorUnknownType << 1;
+ QTest::newRow("future-type-29") << raw("\x81\xfd") << 0 << CborErrorUnknownType << 1;
+ QTest::newRow("future-type-30") << raw("\x81\xfe") << 0 << CborErrorUnknownType << 1;
+ QTest::newRow("unexpected-break") << raw("\x81\xff") << 0 << CborErrorUnexpectedBreak << 1;
+ QTest::newRow("illegal-simple-0") << raw("\x81\xf8\0") << 0 << CborErrorIllegalSimpleType << 1;
+ QTest::newRow("illegal-simple-31") << raw("\x81\xf8\x1f") << 0 << CborErrorIllegalSimpleType << 1;
+
+ // not only too big (UINT_MAX or UINT_MAX+1 in size), but also incomplete
+ if (sizeof(size_t) < sizeof(uint64_t)) {
+ QTest::newRow("bytearray-too-big1") << raw("\x81\x5b\0\0\0\1\0\0\0\0") << 0 << CborErrorDataTooLarge << 1;
+ QTest::newRow("string-too-big1") << raw("\x81\x7b\0\0\0\1\0\0\0\0") << 0 << CborErrorDataTooLarge << 1;
+ }
+ QTest::newRow("array-too-big1") << raw("\x81\x9a\xff\xff\xff\xff\0\0\0\0") << 0 << CborErrorDataTooLarge << 1;
+ QTest::newRow("array-too-big2") << raw("\x81\x9b\0\0\0\1\0\0\0\0") << 0 << CborErrorDataTooLarge << 1;
+ QTest::newRow("object-too-big1") << raw("\x81\xba\xff\xff\xff\xff\0\0\0\0") << 0 << CborErrorDataTooLarge << 1;
+ QTest::newRow("object-too-big2") << raw("\x81\xbb\0\0\0\1\0\0\0\0") << 0 << CborErrorDataTooLarge << 1;
+
+ QTest::newRow("no-break-for-array0") << raw("\x81\x9f") << 0 << CborErrorUnexpectedEOF << 2;
+ QTest::newRow("no-break-for-array1") << raw("\x81\x9f\x01") << 0 << CborErrorUnexpectedEOF << 3;
+ QTest::newRow("no-break-string0") << raw("\x81\x7f") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("no-break-string1") << raw("\x81\x7f\x61Z") << 0 << CborErrorUnexpectedEOF << 1;
+
+ QTest::newRow("nested-indefinite-length-bytearrays") << raw("\x81\x5f\x5f\xff\xff") << 0 << CborErrorIllegalNumber << 1;
+ QTest::newRow("nested-indefinite-length-strings") << raw("\x81\x5f\x5f\xff\xff") << 0 << CborErrorIllegalNumber << 1;
+
+ QTest::newRow("string-chunk-unsigned") << raw("\x81\x7f\0\xff") << 0 << CborErrorIllegalType << 1;
+ QTest::newRow("string-chunk-bytearray") << raw("\x81\x7f\x40\xff") << 0 << CborErrorIllegalType << 1;
+ QTest::newRow("string-chunk-array") << raw("\x81\x7f\x80\xff") << 0 << CborErrorIllegalType << 1;
+ QTest::newRow("bytearray-chunk-unsigned") << raw("\x81\x5f\0\xff") << 0 << CborErrorIllegalType << 1;
+ QTest::newRow("bytearray-chunk-string") << raw("\x81\x5f\x60\xff") << 0 << CborErrorIllegalType << 1;
+ QTest::newRow("bytearray-chunk-array") << raw("\x81\x5f\x80\xff") << 0 << CborErrorIllegalType << 1;
+}
+
+void tst_Parser::validation()
+{
+ QFETCH(QByteArray, data);
+ QFETCH(int, flags);
+ QFETCH(CborError, expectedError);
+ QFETCH(int, offset);
+
+ QString decoded;
+ CborParser parser;
+ CborValue first;
+ CborError err = cbor_parser_init(reinterpret_cast<const quint8 *>(data.constData()), data.length(), flags, &parser, &first);
+ QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\"");
+
+ err = parseOne(&first, &decoded);
+ QCOMPARE(int(err), int(expectedError));
++ QCOMPARE(int(cbor_value_get_next_byte(&first) - reinterpret_cast<const quint8 *>(data.constBegin())), offset);
+}
+
+void tst_Parser::resumeParsing_data()
+{
+ addColumns();
+ addFixedData();
+ addStringsData();
+ addTagsData();
+ addMapMixedData();
+}
+
+void tst_Parser::resumeParsing()
+{
+ QFETCH(QByteArray, data);
+ QFETCH(QString, expected);
+
+ for (int len = 0; len < data.length() - 1; ++len) {
+ CborParser parser;
+ CborValue first;
+ CborError err = cbor_parser_init(reinterpret_cast<const quint8 *>(data.constData()), len, 0, &parser, &first);
+ if (!err) {
+ QString decoded;
+ err = parseOne(&first, &decoded);
+ }
+ if (err != CborErrorUnexpectedEOF)
+ qDebug() << "Length is" << len;
+ QCOMPARE(int(err), int(CborErrorUnexpectedEOF));
+ }
+}
+
+void tst_Parser::endPointer_data()
+{
+ QTest::addColumn<QByteArray>("data");
+ QTest::addColumn<int>("offset");
+
+ QTest::newRow("number1") << raw("\x81\x01\x01") << 2;
+ QTest::newRow("number24") << raw("\x81\x18\x18\x01") << 3;
+ QTest::newRow("string") << raw("\x81\x61Z\x01") << 3;
+ QTest::newRow("indefinite-string") << raw("\x81\x7f\x61Z\xff\x01") << 5;
+ QTest::newRow("array") << raw("\x81\x02\x01") << 2;
+ QTest::newRow("indefinite-array") << raw("\x81\x9f\x02\xff\x01") << 4;
+ QTest::newRow("object") << raw("\x81\xa1\x03\x02\x01") << 4;
+ QTest::newRow("indefinite-object") << raw("\x81\xbf\x03\x02\xff\x01") << 5;
+}
+
+void tst_Parser::endPointer()
+{
+ QFETCH(QByteArray, data);
+ QFETCH(int, offset);
+
+ QString decoded;
+ CborParser parser;
+ CborValue first;
+ CborError err = cbor_parser_init(reinterpret_cast<const quint8 *>(data.constData()), data.length(), 0, &parser, &first);
+ QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\"");
+
+ err = parseOne(&first, &decoded);
+ QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\"");
+ QCOMPARE(int(first.ptr - reinterpret_cast<const quint8 *>(data.constBegin())), offset);
+}
+
+void tst_Parser::recursionLimit_data()
+{
+ static const int recursions = CBOR_PARSER_MAX_RECURSIONS + 2;
+ QTest::addColumn<QByteArray>("data");
+
+ QTest::newRow("array") << QByteArray(recursions, '\x81') + '\x20';
+ QTest::newRow("_array") << QByteArray(recursions, '\x9f') + '\x20' + QByteArray(recursions, '\xff');
+
+ QByteArray data;
+ for (int i = 0; i < recursions; ++i)
+ data += "\xa1\x65Hello";
+ data += '\2';
+ QTest::newRow("map-recursive-values") << data;
+
+ data.clear();
+ for (int i = 0; i < recursions; ++i)
+ data += "\xbf\x65World";
+ data += '\2';
+ for (int i = 0; i < recursions; ++i)
+ data += "\xff";
+ QTest::newRow("_map-recursive-values") << data;
+
+ data = QByteArray(recursions, '\xa1');
+ data += '\2';
+ for (int i = 0; i < recursions; ++i)
+ data += "\x7f\x64quux\xff";
+ QTest::newRow("map-recursive-keys") << data;
+
+ data = QByteArray(recursions, '\xbf');
+ data += '\2';
+ for (int i = 0; i < recursions; ++i)
+ data += "\1\xff";
+ QTest::newRow("_map-recursive-keys") << data;
+
+ data.clear();
+ for (int i = 0; i < recursions / 2; ++i)
+ data += "\x81\xa1\1";
+ data += '\2';
+ QTest::newRow("mixed") << data;
+}
+
+void tst_Parser::recursionLimit()
+{
+ QFETCH(QByteArray, data);
+
+ CborParser parser;
+ CborValue first;
+ CborError err = cbor_parser_init(reinterpret_cast<const quint8 *>(data.constData()), data.length(), 0, &parser, &first);
+ QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\"");
+
+ // check that it is valid:
+ CborValue it = first;
+ {
+ QString dummy;
+ err = parseOne(&it, &dummy);
+ QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\"");
+ }
+
+ it = first;
+ err = cbor_value_advance(&it);
+ QCOMPARE(int(err), int(CborErrorNestingTooDeep));
+
+ it = first;
+ if (cbor_value_is_map(&it)) {
+ CborValue dummy;
+ err = cbor_value_map_find_value(&it, "foo", &dummy);
+ QCOMPARE(int(err), int(CborErrorNestingTooDeep));
+ }
+}
+
+QTEST_MAIN(tst_Parser)
+#include "tst_parser.moc"
--- /dev/null
+TEMPLATE = subdirs
+SUBDIRS = parser encoder cpp tojson
++msvc: SUBDIRS -= tojson
--- /dev/null
- POST_TARGETDEPS += ../../lib/libtinycbor.a
+CONFIG += testcase parallel_test c++11
+QT = core testlib
+
+SOURCES += tst_tojson.cpp
+INCLUDEPATH += ../../src
++msvc: POST_TARGETDEPS = ../../lib/tinycbor.lib
++else: POST_TARGETDEPS += ../../lib/libtinycbor.a
+LIBS += $$POST_TARGETDEPS
--- /dev/null
- ../bin/cbordump: cbordump.o cborparser.o cborerrorstrings.o cborpretty.o
+CFLAGS = -O2 -g
+CPPFLAGS = -I../src
+VPATH = cbordump:../src
+
+all: ../bin ../bin/cbordump
+../bin:
+ @-mkdir ../bin
+
++../bin/cbordump: cbordump.o cborparser.o cborparser_dup_string.o cbortojson.o cborerrorstrings.o cborpretty.o
+ $(CC) -o $@ $^
+ $(RM) $^
+
--- /dev/null
- // fall through
+/****************************************************************************
+**
+** Copyright (C) 2015 Intel Corporation
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+** copies of the Software, and to permit persons to whom the Software is
+** furnished to do so, subject to the following conditions:
+**
+** The above copyright notice and this permission notice shall be included in
+** all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+** OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+** THE SOFTWARE.
+**
+****************************************************************************/
+
+#define _POSIX_C_SOURCE 200809L
+#include "cbor.h"
+#include "cborjson.h"
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+enum Mode {
+ PrintCborDump = 0,
+ PrintJson = 0x80000000
+};
+
+void *xrealloc(void *old, size_t size, const char *fname)
+{
+ old = realloc(old, size);
+ if (old == NULL) {
+ fprintf(stderr, "%s: %s\n", fname, strerror(errno));
+ exit(EXIT_FAILURE);
+ }
+ return old;
+}
+
+void printerror(CborError err, const char *fname)
+{
+ fprintf(stderr, "%s: %s\n", fname, cbor_error_string(err));
+ exit(EXIT_FAILURE);
+}
+
+void dumpFile(FILE *in, const char *fname, int mode)
+{
+ static const size_t chunklen = 16 * 1024;
+ static size_t bufsize = 0;
+ static uint8_t *buffer = NULL;
+
+ size_t buflen = 0;
+ do {
+ if (bufsize == buflen)
+ buffer = xrealloc(buffer, bufsize += chunklen, fname);
+
+ size_t n = fread(buffer + buflen, 1, bufsize - buflen, in);
+ buflen += n;
+ if (n == 0) {
+ if (!ferror(in))
+ continue;
+ fprintf(stderr, "%s: %s\n", fname, strerror(errno));
+ exit(EXIT_FAILURE);
+ }
+ } while (!feof(in));
+
+ CborParser parser;
+ CborValue value;
+ CborError err = cbor_parser_init(buffer, buflen, 0, &parser, &value);
+ if (!err) {
+ if (mode)
+ err = cbor_value_to_json_advance(stdout, &value, mode & ~PrintJson);
+ else
+ err = cbor_value_to_pretty_advance(stdout, &value);
+ if (!err)
+ puts("");
+ }
+ if (!err && value.ptr != buffer + buflen)
+ err = CborErrorGarbageAtEnd;
+ if (err)
+ printerror(err, fname);
+}
+
+int main(int argc, char **argv)
+{
+ int mode = PrintCborDump;
+ int c;
+ while ((c = getopt(argc, argv, "MOSUcjh")) != -1) {
+ switch (c) {
+ case 'c':
+ mode = PrintCborDump;
+ break;
+ case 'j':
+ mode &= ~PrintCborDump;
+ mode |= PrintJson;
+ break;
+
+ case 'M':
+ mode |= CborConvertAddMetadata;
+ break;
+ case 'O':
+ mode |= CborConvertTagsToObjects;
+ break;
+ case 'S':
+ mode |= CborConvertStringifyMapKeys;
+ break;
+ case 'U':
+ mode |= CborConvertByteStringsToBase64Url;
+ break;
+
+ case '?':
+ fprintf(stderr, "Unknown option -%c.\n", optopt);
++ /* fall through */
+ case 'h':
+ puts("Usage: cbordump [OPTION]... [FILE]...\n"
+ "Interprets FILEs as CBOR binary data and dumps the content to stdout.\n"
+ "\n"
+ "Options:\n"
+ " -c Print a CBOR dump (see RFC 7049) (default)\n"
+ " -j Print a JSON equivalent version\n"
+ " -h Print this help output and exit\n"
+ "When JSON output is active, the following options are recognized:\n"
+ " -M Add metadata so converting back to CBOR is possible\n"
+ " -O Convert CBOR tags to JSON objects\n"
+ " -S Stringify non-text string map keys\n"
+ " -U Convert all CBOR byte strings to Base64url regardless of tags"
+ "");
+ return c == '?' ? EXIT_FAILURE : EXIT_SUCCESS;
+ }
+ }
+
+ char **fname = argv + optind;
+ if (!*fname) {
+ dumpFile(stdin, "-", mode);
+ } else {
+ for ( ; *fname; ++fname) {
+ FILE *in = fopen(*fname, "rb");
+ if (!in) {
+ perror("open");
+ return EXIT_FAILURE;
+ }
+
+ dumpFile(in, *fname, mode);
+ fclose(in);
+ }
+ }
+
+ return EXIT_SUCCESS;
+}
Name: iotivity
- Version: 1.1.1
+ Version: 1.2.0
Release: 0
- Summary: IoT Connectivity sponsored by the OIC
+ Summary: IoT Connectivity sponsored by the OCF
Group: Network & Connectivity/Other
-License: Apache-2.0
+License: Apache-2.0 and BSD-2-Clause and MIT
URL: https://www.iotivity.org/
Source0: %{name}-%{version}.tar.bz2
Source1001: %{name}.manifest
%en_speedpython
%endif
-## If tizen 2.x, RELEASE follows tizen_build_binary_release_type_eng. ##
-## and if tizen 3.0, RELEASE follows tizen_build_devel_mode. ##
-%if 0%{?tizen_build_devel_mode} == 1 || 0%{?tizen_build_binary_release_type_eng} == 1
-%define RELEASE False
-%else
-%define RELEASE True
-%endif
-# For Example
-%if %{RELEASE} == "True"
-%define build_mode release
-%else
-%define build_mode debug
-%endif
-
-%ifarch armv7l armv7hl armv7nhl armv7tnhl armv7thl
-%define TARGET_ARCH "armeabi-v7a"
-%endif
-%ifarch aarch64
-%define TARGET_ARCH "arm64"
-%endif
-%ifarch x86_64
-%define TARGET_ARCH "x86_64"
-%endif
-%ifarch %{ix86}
-%define TARGET_ARCH "x86"
-%endif
-
-%define ex_install_dir %{buildroot}%{_bindir}
-
+ %if ! %{?license:0}
+ %define license %doc
+ %endif
+
+# default is RELEASE mode.
+# If DEBUG mode is needed, please use tizen_build_devel_mode
+%define RELEASE True
+
- %{!?TARGET_TRANSPORT: %define TARGET_TRANSPORT IP}
- %{!?LOGGING: %define LOGGING True}
- %{!?ROUTING: %define ROUTING GW}
- %{!?SECURED: %define SECURED 1}
+ # Default values to be eventually overiden BEFORE or as gbs params:
%{!?ES_TARGET_ENROLLEE: %define ES_TARGET_ENROLLEE tizen}
- %{!?ES_ROLE: %define ES_ROLE enrollee}
- %{!?ES_SOFTAP_MODE: %define ES_SOFTAP_MODE MEDIATOR_SOFTAP}
- %{!?VERBOSE: %define VERBOSE 0}
+ %{!?LOGGING: %define LOGGING 1}
+ %{!?ROUTING: %define ROUTING EP}
-%{!?SECURED: %define SECURED 0}
-%{!?TARGET_ARCH: %define TARGET_ARCH %{_arch}}
++%{!?SECURED: %define SECURED 1}
+ %{!?TARGET_OS: %define TARGET_OS tizen}
-%{!?TARGET_TRANSPORT: %define TARGET_TRANSPORT IP,BT}
++%{!?TARGET_TRANSPORT: %define TARGET_TRANSPORT IP}
+ %{!?VERBOSE: %define VERBOSE 1}
+ %{!?WITH_CLOUD: %define WITH_CLOUD 0}
+ %{!?WITH_MQ: %define WITH_MQ OFF}
+ %{!?WITH_PROXY: %define WITH_PROXY 0}
-%{!?WITH_TCP: %define WITH_TCP 0}
-
-BuildRequires: gettext-tools, expat-devel
-BuildRequires: python, libcurl-devel
-BuildRequires: scons
-BuildRequires: openssl-devel
-BuildRequires: boost-devel
-BuildRequires: boost-thread
-BuildRequires: boost-system
-BuildRequires: boost-filesystem
-BuildRequires: pkgconfig(dlog)
-BuildRequires: pkgconfig(uuid)
-BuildRequires: pkgconfig(glib-2.0)
-BuildRequires: pkgconfig(sqlite3)
-%if "%{TARGET_OS}" == "tizen"
-BuildRequires: pkgconfig(dlog)
-BuildRequires: pkgconfig(capi-network-wifi)
-BuildRequires: pkgconfig(capi-network-bluetooth) >= 0.1.52
-%endif
-Requires(postun): /sbin/ldconfig
-Requires(post): /sbin/ldconfig
++%{!?WITH_TCP: %define WITH_TCP 1}
%description
An open source reference implementation of the OIC standard specifications
%endif
%build
+%define RPM_ARCH %{_arch}
+
+%ifarch armv7l armv7hl armv7nhl armv7tnhl armv7thl
+%define RPM_ARCH "armeabi-v7a"
+%endif
+
+%ifarch aarch64
+%define RPM_ARCH "arm64"
+%endif
+
+%ifarch x86_64
+%define RPM_ARCH "x86_64"
+%endif
+
+%ifarch %{ix86}
+%define RPM_ARCH "x86"
+%endif
+
+%define JOB "-j4"
+
+%if 0%{?speedpython}
+%define JOB %{?_smp_mflags}
+%endif
+
scons %{JOB} --prefix=%{_prefix} \
- VERBOSE=%{VERBOSE} \
- TARGET_OS=tizen TARGET_ARCH=%{RPM_ARCH} TARGET_TRANSPORT=%{TARGET_TRANSPORT} \
- RELEASE=%{RELEASE} SECURED=%{SECURED} LOGGING=%{LOGGING} ROUTING=%{ROUTING} \
- ES_TARGET_ENROLLEE=%{ES_TARGET_ENROLLEE} ES_ROLE=%{ES_ROLE} ES_SOFTAP_MODE=%{ES_SOFTAP_MODE} \
- LIB_INSTALL_DIR=%{_libdir} WITH_TCP=true
+ ES_TARGET_ENROLLEE=%{ES_TARGET_ENROLLEE} \
+ LIB_INSTALL_DIR=%{_libdir} \
+ LOGGING=%{LOGGING} \
+ RELEASE=%{RELEASE} \
+ ROUTING=%{ROUTING} \
+ SECURED=%{SECURED} \
- TARGET_ARCH=%{TARGET_ARCH} \
++ TARGET_ARCH=%{RPM_ARCH} \
+ TARGET_OS=%{TARGET_OS} \
+ TARGET_TRANSPORT=%{TARGET_TRANSPORT} \
+ VERBOSE=%{VERBOSE} \
+ WITH_CLOUD=%{WITH_CLOUD} \
+ WITH_MQ=%{WITH_MQ} \
+ WITH_PROXY=%{WITH_PROXY} \
+ WITH_TCP=%{WITH_TCP} \
+ #eol
-
%install
rm -rf %{buildroot}
CFLAGS="${CFLAGS:-%optflags}" ; export CFLAGS ;
scons install --install-sandbox=%{buildroot} --prefix=%{_prefix} \
- TARGET_OS=tizen TARGET_ARCH=%{RPM_ARCH} TARGET_TRANSPORT=%{TARGET_TRANSPORT} \
- RELEASE=%{RELEASE} SECURED=%{SECURED} LOGGING=%{LOGGING} ROUTING=%{ROUTING} \
- ES_TARGET_ENROLLEE=%{ES_TARGET_ENROLLEE} ES_ROLE=%{ES_ROLE} ES_SOFTAP_MODE=%{ES_SOFTAP_MODE} \
- LIB_INSTALL_DIR=%{_libdir} WITH_TCP=true
+ ES_TARGET_ENROLLEE=%{ES_TARGET_ENROLLEE} \
+ LIB_INSTALL_DIR=%{_libdir} \
+ LOGGING=%{LOGGING} \
+ RELEASE=%{RELEASE} \
+ ROUTING=%{ROUTING} \
+ SECURED=%{SECURED} \
- TARGET_ARCH=%{TARGET_ARCH} \
++ TARGET_ARCH=%{RPM_ARCH} \
+ TARGET_OS=%{TARGET_OS} \
+ TARGET_TRANSPORT=%{TARGET_TRANSPORT} \
+ VERBOSE=%{VERBOSE} \
+ WITH_CLOUD=%{WITH_CLOUD} \
+ WITH_MQ=%{WITH_MQ} \
+ WITH_PROXY=%{WITH_PROXY} \
+ WITH_TCP=%{WITH_TCP} \
+ #eol
+
+# For Example
+%if %{RELEASE} == "True"
+%define build_mode release
+%else
+%define build_mode debug
+%endif
+%define ex_install_dir %{buildroot}%{_bindir}
mkdir -p %{ex_install_dir}
-cp out/%{TARGET_OS}/%{TARGET_ARCH}/%{build_mode}/examples/OICMiddle/OICMiddle %{ex_install_dir}
-cp out/%{TARGET_OS}/%{TARGET_ARCH}/%{build_mode}/resource/examples/devicediscoveryclient %{ex_install_dir}
-cp out/%{TARGET_OS}/%{TARGET_ARCH}/%{build_mode}/resource/examples/devicediscoveryserver %{ex_install_dir}
-cp out/%{TARGET_OS}/%{TARGET_ARCH}/%{build_mode}/resource/examples/fridgeclient %{ex_install_dir}
-cp out/%{TARGET_OS}/%{TARGET_ARCH}/%{build_mode}/resource/examples/fridgeserver %{ex_install_dir}
-cp out/%{TARGET_OS}/%{TARGET_ARCH}/%{build_mode}/resource/examples/garageclient %{ex_install_dir}
-cp out/%{TARGET_OS}/%{TARGET_ARCH}/%{build_mode}/resource/examples/garageserver %{ex_install_dir}
-cp out/%{TARGET_OS}/%{TARGET_ARCH}/%{build_mode}/resource/examples/groupclient %{ex_install_dir}
-cp out/%{TARGET_OS}/%{TARGET_ARCH}/%{build_mode}/resource/examples/groupserver %{ex_install_dir}
-cp out/%{TARGET_OS}/%{TARGET_ARCH}/%{build_mode}/resource/examples/lightserver %{ex_install_dir}
-cp out/%{TARGET_OS}/%{TARGET_ARCH}/%{build_mode}/resource/examples/presenceclient %{ex_install_dir}
-cp out/%{TARGET_OS}/%{TARGET_ARCH}/%{build_mode}/resource/examples/presenceserver %{ex_install_dir}
-cp out/%{TARGET_OS}/%{TARGET_ARCH}/%{build_mode}/resource/examples/roomclient %{ex_install_dir}
-cp out/%{TARGET_OS}/%{TARGET_ARCH}/%{build_mode}/resource/examples/roomserver %{ex_install_dir}
-cp out/%{TARGET_OS}/%{TARGET_ARCH}/%{build_mode}/resource/examples/simpleclient %{ex_install_dir}
-cp out/%{TARGET_OS}/%{TARGET_ARCH}/%{build_mode}/resource/examples/simpleclientHQ %{ex_install_dir}
-cp out/%{TARGET_OS}/%{TARGET_ARCH}/%{build_mode}/resource/examples/simpleclientserver %{ex_install_dir}
-cp out/%{TARGET_OS}/%{TARGET_ARCH}/%{build_mode}/resource/examples/simpleserver %{ex_install_dir}
-cp out/%{TARGET_OS}/%{TARGET_ARCH}/%{build_mode}/resource/examples/simpleserverHQ %{ex_install_dir}
-cp out/%{TARGET_OS}/%{TARGET_ARCH}/%{build_mode}/resource/examples/threadingsample %{ex_install_dir}
-cp out/%{TARGET_OS}/%{TARGET_ARCH}/%{build_mode}/resource/examples/oic_svr_db_server.dat %{ex_install_dir}
-cp out/%{TARGET_OS}/%{TARGET_ARCH}/%{build_mode}/resource/examples/oic_svr_db_client.dat %{ex_install_dir}
-cp out/%{TARGET_OS}/%{TARGET_ARCH}/%{build_mode}/libcoap.a %{buildroot}%{_libdir}
+cp out/tizen/*/%{build_mode}/examples/OICMiddle/OICMiddle %{ex_install_dir}
+cp out/tizen/*/%{build_mode}/resource/examples/devicediscoveryclient %{ex_install_dir}
+cp out/tizen/*/%{build_mode}/resource/examples/devicediscoveryserver %{ex_install_dir}
+cp out/tizen/*/%{build_mode}/resource/examples/fridgeclient %{ex_install_dir}
+cp out/tizen/*/%{build_mode}/resource/examples/fridgeserver %{ex_install_dir}
+cp out/tizen/*/%{build_mode}/resource/examples/garageclient %{ex_install_dir}
+cp out/tizen/*/%{build_mode}/resource/examples/garageserver %{ex_install_dir}
+cp out/tizen/*/%{build_mode}/resource/examples/groupclient %{ex_install_dir}
+cp out/tizen/*/%{build_mode}/resource/examples/groupserver %{ex_install_dir}
+cp out/tizen/*/%{build_mode}/resource/examples/lightserver %{ex_install_dir}
+cp out/tizen/*/%{build_mode}/resource/examples/presenceclient %{ex_install_dir}
+cp out/tizen/*/%{build_mode}/resource/examples/presenceserver %{ex_install_dir}
+cp out/tizen/*/%{build_mode}/resource/examples/roomclient %{ex_install_dir}
+cp out/tizen/*/%{build_mode}/resource/examples/roomserver %{ex_install_dir}
+cp out/tizen/*/%{build_mode}/resource/examples/simpleclient %{ex_install_dir}
+cp out/tizen/*/%{build_mode}/resource/examples/simpleclientHQ %{ex_install_dir}
+cp out/tizen/*/%{build_mode}/resource/examples/simpleclientserver %{ex_install_dir}
+cp out/tizen/*/%{build_mode}/resource/examples/simpleserver %{ex_install_dir}
+cp out/tizen/*/%{build_mode}/resource/examples/simpleserverHQ %{ex_install_dir}
+cp out/tizen/*/%{build_mode}/resource/examples/threadingsample %{ex_install_dir}
+cp out/tizen/*/%{build_mode}/resource/examples/oic_svr_db_server.dat %{ex_install_dir}
+cp out/tizen/*/%{build_mode}/resource/examples/oic_svr_db_client.dat %{ex_install_dir}
- %if 0%{SECURED} == 1
- mkdir -p %{ex_install_dir}/provisioning
- cp out/tizen/*/%{build_mode}/resource/csdk/security/provisioning/sample/provisioningclient %{ex_install_dir}/provisioning/
- cp out/tizen/*/%{build_mode}/resource/csdk/security/provisioning/sample/oic_svr_db_client.dat %{ex_install_dir}/provisioning/
- cp out/tizen/*/%{build_mode}/resource/csdk/security/provisioning/sample/sampleserver_justworks %{ex_install_dir}/provisioning/
- cp out/tizen/*/%{build_mode}/resource/csdk/security/provisioning/sample/oic_svr_db_server_justworks.dat %{ex_install_dir}/provisioning/
- cp out/tizen/*/%{build_mode}/resource/csdk/security/provisioning/sample/sampleserver_randompin %{ex_install_dir}/provisioning/
- cp out/tizen/*/%{build_mode}/resource/csdk/security/provisioning/sample/oic_svr_db_server_randompin.dat %{ex_install_dir}/provisioning/
+
+ %if 0%{?WITH_PROXY} == 1
+ mkdir -p %{ex_install_dir}/proxy-sample
+ cp out/%{TARGET_OS}/%{TARGET_ARCH}/%{build_mode}/service/coap-http-proxy/samples/proxy_main %{ex_install_dir}/proxy-sample/
+ cp out/%{TARGET_OS}/%{TARGET_ARCH}/%{build_mode}/service/coap-http-proxy/samples/proxy_client %{ex_install_dir}/proxy-sample/
%endif
-mkdir -p %{ex_install_dir}/provisioning
-mkdir -p %{ex_install_dir}/provision-sample
+ %if 0%{?SECURED} == 1
++%define ex_provision_install_dir %{ex_install_dir}/provision-sample
++mkdir -p %{ex_provision_install_dir}
++
++cp out/tizen/*/%{build_mode}/resource/csdk/security/provisioning/sample/provisioningclient %{ex_provision_install_dir}
++cp out/tizen/*/%{build_mode}/resource/csdk/security/provisioning/sample/oic_svr_db_client.dat %{ex_provision_install_dir}
++cp out/tizen/*/%{build_mode}/resource/csdk/security/provisioning/sample/sampleserver_justworks %{ex_provision_install_dir}
++cp out/tizen/*/%{build_mode}/resource/csdk/security/provisioning/sample/oic_svr_db_server_justworks.dat %{ex_provision_install_dir}
++cp out/tizen/*/%{build_mode}/resource/csdk/security/provisioning/sample/sampleserver_randompin %{ex_provision_install_dir}
++cp out/tizen/*/%{build_mode}/resource/csdk/security/provisioning/sample/oic_svr_db_server_randompin.dat %{ex_provision_install_dir}
cp ./resource/csdk/security/include/pinoxmcommon.h %{buildroot}%{_includedir}
+cp ./resource/csdk/security/include/securevirtualresourcetypes.h %{buildroot}%{_includedir}
cp ./resource/csdk/security/provisioning/include/oxm/*.h %{buildroot}%{_includedir}
cp ./resource/csdk/security/provisioning/include/internal/*.h %{buildroot}%{_includedir}
cp ./resource/csdk/security/provisioning/include/*.h %{buildroot}%{_includedir}
-cp ./resource/csdk/security/provisioning/sample/oic_svr_db_server_justworks.dat %{buildroot}%{_libdir}/oic_svr_db_server.dat
-cp out/%{TARGET_OS}/%{TARGET_ARCH}/%{build_mode}/resource/csdk/security/provisioning/sample/sampleserver_justworks %{ex_install_dir}/provision-sample/
-cp ./resource/csdk/security/provisioning/sample/oic_svr_db_server_justworks.dat %{ex_install_dir}/provision-sample/
-cp out/%{TARGET_OS}/%{TARGET_ARCH}/%{build_mode}/resource/csdk/security/provisioning/sample/sampleserver_randompin %{ex_install_dir}/provision-sample/
-cp ./resource/csdk/security/provisioning/sample/oic_svr_db_server_randompin.dat %{ex_install_dir}/provision-sample/
++cp ./resource/c_common/byte_array.h %{buildroot}%{_includedir}
+cp ./resource/csdk/connectivity/api/casecurityinterface.h %{buildroot}%{_includedir}
+cp ./resource/csdk/connectivity/api/cacommon.h %{buildroot}%{_includedir}
-%endif
+# For IoTCon
+cp ./resource/csdk/security/include/internal/doxmresource.h %{buildroot}%{_includedir}
+cp ./resource/csdk/security/include/internal/verresource.h %{buildroot}%{_includedir}
- %if 0%{?tizen_version_major} < 3
- mkdir -p %{buildroot}/%{_datadir}/license
- cp LICENSE %{buildroot}/%{_datadir}/license/%{name}
- cp LICENSE %{buildroot}/%{_datadir}/license/%{name}-service
- cp LICENSE %{buildroot}/%{_datadir}/license/%{name}-test
-cp resource/c_common/*.h %{buildroot}%{_includedir}
-cp resource/csdk/stack/include/*.h %{buildroot}%{_includedir}
-cp resource/csdk/logger/include/*.h %{buildroot}%{_includedir}
+%endif
cp service/things-manager/sdk/inc/*.h %{buildroot}%{_includedir}
cp service/easy-setup/inc/*.h %{buildroot}%{_includedir}
%{_libdir}/liboc_logger_core.so
%{_libdir}/liboctbstack.so
%{_libdir}/libconnectivity_abstraction.so
- %if 0%{SECURED} == 1
++%if 0%{?SECURED} == 1
+%{_libdir}/libocpmapi.so
+%{_libdir}/libocprovision.so
+%endif
- %if 0%{?tizen_version_major} < 3
- %{_datadir}/license/%{name}
- %else
+%license LICENSE
- %license LICENSE.MIT
- %license LICENSE.BSD-2-clause
- %license LICENSE.MIT.tinydtls
- %license LICENSE.BSD-2-clause.ecc
- %endif
%files service
%manifest %{name}.manifest
%{_libdir}/librcs_container.so
%{_libdir}/librcs_server.so
%{_libdir}/libESEnrolleeSDK.so
- %if 0%{?tizen_version_major} < 3
- %{_datadir}/license/%{name}-service
-%if 0%{?WITH_PROXY} == 1
-%{_libdir}/libcoap_http_proxy.so
-%endif
-%if 0%{?SECURED} == 1
-%{_libdir}/libocpmapi.so
-%{_libdir}/libocprovision.so
-%{_libdir}/oic_svr_db_server.dat
-%endif
-%if "%{TARGET_OS}" == "linux"
-%{_libdir}/libnotification*.so
--%else
-%{_libdir}/libresource_hosting.so
-%endif
+%license LICENSE
- %license LICENSE.MIT
- %license LICENSE.BSD-2-clause
- %license LICENSE.MIT.tinydtls
- %license LICENSE.BSD-2-clause.ecc
- %endif
%files test
%manifest %{name}-test.manifest
%defattr(-,root,root,-)
-%license LICENSE
%{_bindir}/*
- %if 0%{?tizen_version_major} < 3
- %{_datadir}/license/%{name}-test
- %else
+%license LICENSE
- %license LICENSE.MIT
- %license LICENSE.BSD-2-clause
- %license LICENSE.MIT.tinydtls
- %license LICENSE.BSD-2-clause.ecc
- %endif
%files devel
%defattr(-,root,root,-)
projects / platform / upstream / iotivity.git / commitdiff