From 8de8ec1c5fa26f9e051ddd57f398d688e972c192 Mon Sep 17 00:00:00 2001 From: wangmenglan Date: Fri, 28 Apr 2023 16:18:32 +0800 Subject: [PATCH] =?UTF-8?q?TSG-14938=20TFE=E6=94=AF=E6=8C=81=E6=96=B0?= =?UTF-8?q?=E6=8E=A7=E5=88=B6=E6=8A=A5=E6=96=87=E6=A0=BC=E5=BC=8F;=20?= =?UTF-8?q?=E8=B0=83=E6=95=B4=E4=BB=A3=E7=A0=81=E7=BB=93=E6=9E=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- common/CMakeLists.txt | 9 +- common/include/mpack.h | 8207 +++++++++++++++++++ common/include/tap.h | 2 + common/include/tfe_acceptor_kni.h | 147 - common/include/tfe_packet_io.h | 95 +- common/include/tfe_tap_rss.h | 35 - common/include/tfe_timestamp.h | 24 - common/src/mpack.cpp | 7304 +++++++++++++++++ common/src/tap.cpp | 19 + common/src/tfe_acceptor_kni.cpp | 91 - common/src/tfe_ctrl_packet.cpp | 1 - common/src/tfe_mpack.cpp | 377 +- common/src/tfe_packet_io.cpp | 481 +- common/src/tfe_tap_rss.cpp | 389 - common/src/tfe_timestamp.cpp | 65 - conf/tfe/tfe.conf | 26 +- platform/CMakeLists.txt | 1 - platform/include/internal/acceptor_kni_v4.h | 7 - platform/src/acceptor_kni_v4.cpp | 144 +- platform/src/proxy.cpp | 1 - vendor/CMakeLists.txt | 16 - vendor/msgpack-c-6.0.0.tar.gz | Bin 69341 -> 0 bytes 22 files changed, 16372 insertions(+), 1069 deletions(-) create mode 100644 common/include/mpack.h delete mode 100644 common/include/tfe_acceptor_kni.h delete mode 100644 common/include/tfe_tap_rss.h delete mode 100644 common/include/tfe_timestamp.h create mode 100644 common/src/mpack.cpp delete mode 100644 common/src/tfe_acceptor_kni.cpp delete mode 100644 common/src/tfe_tap_rss.cpp delete mode 100644 common/src/tfe_timestamp.cpp delete mode 100644 vendor/msgpack-c-6.0.0.tar.gz diff --git a/common/CMakeLists.txt b/common/CMakeLists.txt index cebf8a3..b5d3a14 100644 --- a/common/CMakeLists.txt +++ b/common/CMakeLists.txt @@ -3,13 +3,14 @@ src/tfe_rpc.cpp src/tfe_cmsg.cpp src/tfe_kafka_logger.cpp src/tfe_resource.cpp src/tfe_scan.cpp src/tfe_pkt_util.cpp src/tfe_tcp_restore.cpp src/raw_socket.cpp src/packet_construct.cpp src/tap.cpp src/io_uring.cpp src/intercept_policy.cpp src/tfe_fieldstat.cpp - src/tfe_addr_tuple4.cpp src/tfe_packet_io.cpp src/tfe_session_table.cpp src/tfe_timestamp.cpp - src/tfe_acceptor_kni.cpp src/tfe_ctrl_packet.cpp src/tfe_raw_packet.cpp - src/tfe_mpack.cpp src/mpack.cpp src/tfe_tap_rss.cpp src/tfe_metrics.cpp) + src/tfe_addr_tuple4.cpp src/tfe_packet_io.cpp src/tfe_session_table.cpp + src/tfe_ctrl_packet.cpp src/tfe_raw_packet.cpp + src/tfe_mpack.cpp src/tfe_metrics.cpp src/mpack.cpp) target_include_directories(common PUBLIC ${CMAKE_CURRENT_LIST_DIR}/include) +target_include_directories(common PUBLIC ${CMAKE_CURRENT_LIST_DIR}/../bpf/) target_include_directories(common PRIVATE ${CMAKE_CURRENT_LIST_DIR}/../platform/include/internal) target_link_libraries(common PUBLIC libevent-static libevent-static-openssl libevent-static-pthreads rdkafka) -target_link_libraries(common PUBLIC MESA_handle_logger cjson msgpack) +target_link_libraries(common PUBLIC MESA_handle_logger cjson bpf_obj) target_link_libraries(common PUBLIC pthread) if (SUPPORT_LIBURING) diff --git a/common/include/mpack.h b/common/include/mpack.h new file mode 100644 index 0000000..1f2386a --- /dev/null +++ b/common/include/mpack.h @@ -0,0 +1,8207 @@ +/** + * The MIT License (MIT) + * + * Copyright (c) 2015-2021 Nicholas Fraser and the MPack authors + * + * 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. + * + */ + +/* + * This is the MPack 1.1.1 amalgamation package. + * + * http://github.com/ludocode/mpack + */ + +#ifndef MPACK_H +#define MPACK_H 1 + +#define MPACK_AMALGAMATED 1 +#define MPACK_RELEASE_VERSION 1 + +#if defined(MPACK_HAS_CONFIG) && MPACK_HAS_CONFIG +#include "mpack-config.h" +#endif + + +/* mpack/mpack-platform.h.h */ + +/** + * @file + * + * Abstracts all platform-specific code from MPack and handles configuration + * options. + * + * This verifies the configuration and sets defaults based on the platform, + * contains implementations of standard C functions when libc is not available, + * and provides wrappers to all library functions. + * + * Documentation for configuration options is available here: + * + * https://ludocode.github.io/mpack/group__config.html + */ + +#ifndef MPACK_PLATFORM_H +#define MPACK_PLATFORM_H 1 + + + +/** + * @defgroup config Configuration Options + * + * Defines the MPack configuration options. + * + * Custom configuration of MPack is not usually necessary. In almost all + * cases you can ignore this and use the defaults. + * + * If you do want to configure MPack, you can define the below options as part + * of your build system or project settings. This will override the below + * defaults. + * + * If you'd like to use a file for configuration instead, define + * @ref MPACK_HAS_CONFIG to 1 in your build system or project settings. + * This will cause MPack to include a file you create called @c mpack-config.h + * in which you can define your configuration. This is useful if you need to + * include specific headers (such as a custom allocator) in order to configure + * MPack to use it. + * + * @warning The value of all configuration options must be the same in + * all translation units of your project, as well as in the mpack source + * itself. These configuration options affect the layout of structs, among + * other things, which cannot be different in source files that are linked + * together. + * + * @note MPack does not contain defaults for building inside the Linux kernel. + * There is a + * configuration file for the Linux kernel that can be used instead. + * + * @{ + */ + + + +/* + * Pre-include checks + * + * These need to come before the user's mpack-config.h because they might be + * including headers in it. + */ + +/** @cond */ +#if defined(_MSC_VER) && _MSC_VER < 1800 && !defined(__cplusplus) + #error "In Visual Studio 2012 and earlier, MPack must be compiled as C++. Enable the /Tp compiler flag." +#endif + +#if defined(_WIN32) && MPACK_INTERNAL + #define _CRT_SECURE_NO_WARNINGS 1 +#endif + +#ifndef __STDC_LIMIT_MACROS + #define __STDC_LIMIT_MACROS 1 +#endif +#ifndef __STDC_FORMAT_MACROS + #define __STDC_FORMAT_MACROS 1 +#endif +#ifndef __STDC_CONSTANT_MACROS + #define __STDC_CONSTANT_MACROS 1 +#endif +/** @endcond */ + + + +/** + * @name File Configuration + * @{ + */ + +/** + * @def MPACK_HAS_CONFIG + * + * Causes MPack to include a file you create called @c mpack-config.h . + * + * The file is included before MPack sets any defaults for undefined + * configuration options. You can use it to configure MPack. + * + * This is off by default. + */ +#if defined(MPACK_HAS_CONFIG) + #if MPACK_HAS_CONFIG + #include "mpack-config.h" + #endif +#else + #define MPACK_HAS_CONFIG 0 +#endif + +/** + * @} + */ + +// this needs to come first since some stuff depends on it +/** @cond */ +#ifndef MPACK_NO_BUILTINS + #define MPACK_NO_BUILTINS 0 +#endif +/** @endcond */ + + + +/** + * @name Features + * @{ + */ + +/** + * @def MPACK_READER + * + * Enables compilation of the base Tag Reader. + */ +#ifndef MPACK_READER +#define MPACK_READER 1 +#endif + +/** + * @def MPACK_EXPECT + * + * Enables compilation of the static Expect API. + */ +#ifndef MPACK_EXPECT +#define MPACK_EXPECT 1 +#endif + +/** + * @def MPACK_NODE + * + * Enables compilation of the dynamic Node API. + */ +#ifndef MPACK_NODE +#define MPACK_NODE 1 +#endif + +/** + * @def MPACK_WRITER + * + * Enables compilation of the Writer. + */ +#ifndef MPACK_WRITER +#define MPACK_WRITER 1 +#endif + +/** + * @def MPACK_BUILDER + * + * Enables compilation of the Builder. + * + * The Builder API provides additional functions to the Writer for + * automatically determining the element count of compound elements so you do + * not have to specify them up-front. + * + * This requires a @c malloc(). It is enabled by default if MPACK_WRITER is + * enabled and MPACK_MALLOC is defined. + * + * @see mpack_build_map() + * @see mpack_build_array() + * @see mpack_complete_map() + * @see mpack_complete_array() + */ +// This is defined furthur below after we've resolved whether we have malloc(). + +/** + * @def MPACK_COMPATIBILITY + * + * Enables compatibility features for reading and writing older + * versions of MessagePack. + * + * This is disabled by default. When disabled, the behaviour is equivalent to + * using the default version, @ref mpack_version_current. + * + * Enable this if you need to interoperate with applications or data that do + * not support the new (v5) MessagePack spec. See the section on v4 + * compatibility in @ref docs/protocol.md for more information. + */ +#ifndef MPACK_COMPATIBILITY +#define MPACK_COMPATIBILITY 0 +#endif + +/** + * @def MPACK_EXTENSIONS + * + * Enables the use of extension types. + * + * This is disabled by default. Define it to 1 to enable it. If disabled, + * functions to read and write extensions will not exist, and any occurrence of + * extension types in parsed messages will flag @ref mpack_error_invalid. + * + * MPack discourages the use of extension types. See the section on extension + * types in @ref docs/protocol.md for more information. + */ +#ifndef MPACK_EXTENSIONS +#define MPACK_EXTENSIONS 0 +#endif + +/** + * @} + */ + + + +// workarounds for Doxygen +#if defined(MPACK_DOXYGEN) +#if MPACK_DOXYGEN +// We give these their default values of 0 here even though they are defined to +// 1 in the doxyfile. Doxygen will show this as the value in the docs, even +// though it ignores it when parsing the rest of the source. This is what we +// want, since we want the documentation to show these defaults but still +// generate documentation for the functions they add when they're on. +#define MPACK_COMPATIBILITY 0 +#define MPACK_EXTENSIONS 0 +#endif +#endif + + + +/** + * @name Dependencies + * @{ + */ + +/** + * @def MPACK_CONFORMING + * + * Enables the inclusion of basic C headers to define standard types and + * macros. + * + * This causes MPack to include headers required for conforming implementations + * of C99 even in freestanding, in particular , , + * and . It also includes ; this is + * technically not required for freestanding but MPack needs it to detect + * integer limits. + * + * You can disable this if these headers are unavailable or if they do not + * define the standard types and macros (for example inside the Linux kernel.) + * If this is disabled, MPack will include no headers and will assume a 32-bit + * int. You will probably also want to define @ref MPACK_HAS_CONFIG to 1 and + * include your own headers in the config file. You must provide definitions + * for standard types such as @c size_t, @c bool, @c int32_t and so on. + * + * @see + * cppreference.com documentation on Conformance + */ +#ifndef MPACK_CONFORMING + #define MPACK_CONFORMING 1 +#endif + +/** + * @def MPACK_STDLIB + * + * Enables the use of the C stdlib. + * + * This allows the library to use basic functions like @c memcmp() and @c + * strlen(), as well as @c malloc() for debugging and in allocation helpers. + * + * If this is disabled, allocation helper functions will not be defined, and + * MPack will attempt to detect compiler intrinsics for functions like @c + * memcmp() (assuming @ref MPACK_NO_BUILTINS is not set.) It will fallback to + * its own (slow) implementations if it cannot use builtins. You may want to + * define @ref MPACK_MEMCMP and friends if you disable this. + * + * @see MPACK_MEMCMP + * @see MPACK_MEMCPY + * @see MPACK_MEMMOVE + * @see MPACK_MEMSET + * @see MPACK_STRLEN + * @see MPACK_MALLOC + * @see MPACK_REALLOC + * @see MPACK_FREE + */ +#ifndef MPACK_STDLIB + #if !MPACK_CONFORMING + // If we don't even have a proper we assume we won't have + // malloc() either. + #define MPACK_STDLIB 0 + #else + #define MPACK_STDLIB 1 + #endif +#endif + +/** + * @def MPACK_STDIO + * + * Enables the use of C stdio. This adds helpers for easily + * reading/writing C files and makes debugging easier. + */ +#ifndef MPACK_STDIO + #if !MPACK_STDLIB || defined(__AVR__) + #define MPACK_STDIO 0 + #else + #define MPACK_STDIO 1 + #endif +#endif + +/** + * Whether the 'float' type and floating point operations are supported. + * + * If @ref MPACK_FLOAT is disabled, floats are read and written as @c uint32_t + * instead. This way messages with floats do not result in errors and you can + * still perform manual float parsing yourself. + */ +#ifndef MPACK_FLOAT + #define MPACK_FLOAT 1 +#endif + +/** + * Whether the 'double' type is supported. This requires support for 'float'. + * + * If @ref MPACK_DOUBLE is disabled, doubles are read and written as @c + * uint32_t instead. This way messages with doubles do not result in errors and + * you can still perform manual doubles parsing yourself. + * + * If @ref MPACK_FLOAT is enabled but @ref MPACK_DOUBLE is not, doubles can be + * read as floats using the shortening conversion functions, e.g. @ref + * mpack_expect_float() or @ref mpack_node_float(). + */ +#ifndef MPACK_DOUBLE + #if !MPACK_FLOAT || defined(__AVR__) + // AVR supports only float, not double. + #define MPACK_DOUBLE 0 + #else + #define MPACK_DOUBLE 1 + #endif +#endif + +/** + * @} + */ + + + +/** + * @name Allocation Functions + * @{ + */ + +/** + * @def MPACK_MALLOC + * + * Defines the memory allocation function used by MPack. This is used by + * helpers for automatically allocating data the correct size, and for + * debugging functions. If this macro is undefined, the allocation helpers + * will not be compiled. + * + * Set this to use a custom @c malloc() function. Your function must have the + * signature: + * + * @code + * void* malloc(size_t size); + * @endcode + * + * The default is @c malloc() if @ref MPACK_STDLIB is enabled. + */ +/** + * @def MPACK_FREE + * + * Defines the memory free function used by MPack. This is used by helpers + * for automatically allocating data the correct size. If this macro is + * undefined, the allocation helpers will not be compiled. + * + * Set this to use a custom @c free() function. Your function must have the + * signature: + * + * @code + * void free(void* p); + * @endcode + * + * The default is @c free() if @ref MPACK_MALLOC has not been customized and + * @ref MPACK_STDLIB is enabled. + */ +/** + * @def MPACK_REALLOC + * + * Defines the realloc function used by MPack. It is used by growable + * buffers to resize more efficiently. + * + * The default is @c realloc() if @ref MPACK_MALLOC has not been customized and + * @ref MPACK_STDLIB is enabled. + * + * Set this to use a custom @c realloc() function. Your function must have the + * signature: + * + * @code + * void* realloc(void* p, size_t new_size); + * @endcode + * + * This is optional, even when @ref MPACK_MALLOC is used. If @ref MPACK_MALLOC is + * set and @ref MPACK_REALLOC is not, @ref MPACK_MALLOC is used with a simple copy + * to grow buffers. + */ + +#if defined(MPACK_MALLOC) && !defined(MPACK_FREE) + #error "MPACK_MALLOC requires MPACK_FREE." +#endif +#if !defined(MPACK_MALLOC) && defined(MPACK_FREE) + #error "MPACK_FREE requires MPACK_MALLOC." +#endif + +// These were never configurable in lowercase but we check anyway. +#ifdef mpack_malloc + #error "Define MPACK_MALLOC, not mpack_malloc." +#endif +#ifdef mpack_realloc + #error "Define MPACK_REALLOC, not mpack_realloc." +#endif +#ifdef mpack_free + #error "Define MPACK_FREE, not mpack_free." +#endif + +// We don't use calloc() at all. +#ifdef MPACK_CALLOC + #error "Don't define MPACK_CALLOC. MPack does not use calloc()." +#endif +#ifdef mpack_calloc + #error "Don't define mpack_calloc. MPack does not use calloc()." +#endif + +// Use defaults in stdlib if we have them. Without it we don't use malloc. +#if defined(MPACK_STDLIB) + #if MPACK_STDLIB && !defined(MPACK_MALLOC) + #define MPACK_MALLOC malloc + #define MPACK_REALLOC realloc + #define MPACK_FREE free + #endif +#endif + +/** + * @} + */ + + + +// This needs to be defined after we've decided whether we have malloc(). +#ifndef MPACK_BUILDER + #if defined(MPACK_MALLOC) && MPACK_WRITER + #define MPACK_BUILDER 1 + #else + #define MPACK_BUILDER 0 + #endif +#endif + + + +/** + * @name System Functions + * @{ + */ + +/** + * @def MPACK_MEMCMP + * + * The function MPack will use to provide @c memcmp(). + * + * Set this to use a custom @c memcmp() function. Your function must have the + * signature: + * + * @code + * int memcmp(const void* left, const void* right, size_t count); + * @endcode + */ +/** + * @def MPACK_MEMCPY + * + * The function MPack will use to provide @c memcpy(). + * + * Set this to use a custom @c memcpy() function. Your function must have the + * signature: + * + * @code + * void* memcpy(void* restrict dest, const void* restrict src, size_t count); + * @endcode + */ +/** + * @def MPACK_MEMMOVE + * + * The function MPack will use to provide @c memmove(). + * + * Set this to use a custom @c memmove() function. Your function must have the + * signature: + * + * @code + * void* memmove(void* dest, const void* src, size_t count); + * @endcode + */ +/** + * @def MPACK_MEMSET + * + * The function MPack will use to provide @c memset(). + * + * Set this to use a custom @c memset() function. Your function must have the + * signature: + * + * @code + * void* memset(void* p, int c, size_t count); + * @endcode + */ +/** + * @def MPACK_STRLEN + * + * The function MPack will use to provide @c strlen(). + * + * Set this to use a custom @c strlen() function. Your function must have the + * signature: + * + * @code + * size_t strlen(const char* str); + * @endcode + */ + +// These were briefly configurable in lowercase in an unreleased version. Just +// to make sure no one is doing this, we make sure these aren't already defined. +#ifdef mpack_memcmp + #error "Define MPACK_MEMCMP, not mpack_memcmp." +#endif +#ifdef mpack_memcpy + #error "Define MPACK_MEMCPY, not mpack_memcpy." +#endif +#ifdef mpack_memmove + #error "Define MPACK_MEMMOVE, not mpack_memmove." +#endif +#ifdef mpack_memset + #error "Define MPACK_MEMSET, not mpack_memset." +#endif +#ifdef mpack_strlen + #error "Define MPACK_STRLEN, not mpack_strlen." +#endif + +// If the standard library is available, we prefer to use its functions. +#if MPACK_STDLIB + #ifndef MPACK_MEMCMP + #define MPACK_MEMCMP memcmp + #endif + #ifndef MPACK_MEMCPY + #define MPACK_MEMCPY memcpy + #endif + #ifndef MPACK_MEMMOVE + #define MPACK_MEMMOVE memmove + #endif + #ifndef MPACK_MEMSET + #define MPACK_MEMSET memset + #endif + #ifndef MPACK_STRLEN + #define MPACK_STRLEN strlen + #endif +#endif + +#if !MPACK_NO_BUILTINS + #ifdef __has_builtin + #if !defined(MPACK_MEMCMP) && __has_builtin(__builtin_memcmp) + #define MPACK_MEMCMP __builtin_memcmp + #endif + #if !defined(MPACK_MEMCPY) && __has_builtin(__builtin_memcpy) + #define MPACK_MEMCPY __builtin_memcpy + #endif + #if !defined(MPACK_MEMMOVE) && __has_builtin(__builtin_memmove) + #define MPACK_MEMMOVE __builtin_memmove + #endif + #if !defined(MPACK_MEMSET) && __has_builtin(__builtin_memset) + #define MPACK_MEMSET __builtin_memset + #endif + #if !defined(MPACK_STRLEN) && __has_builtin(__builtin_strlen) + #define MPACK_STRLEN __builtin_strlen + #endif + #elif defined(__GNUC__) + #ifndef MPACK_MEMCMP + #define MPACK_MEMCMP __builtin_memcmp + #endif + #ifndef MPACK_MEMCPY + #define MPACK_MEMCPY __builtin_memcpy + #endif + // There's not always a builtin memmove for GCC. If we can't test for + // it with __has_builtin above, we don't use it. It's been around for + // much longer under clang, but then so has __has_builtin, so we let + // the block above handle it. + #ifndef MPACK_MEMSET + #define MPACK_MEMSET __builtin_memset + #endif + #ifndef MPACK_STRLEN + #define MPACK_STRLEN __builtin_strlen + #endif + #endif +#endif + +/** + * @} + */ + + + +/** + * @name Debugging Options + * @{ + */ + +/** + * @def MPACK_DEBUG + * + * Enables debug features. You may want to wrap this around your + * own debug preprocs. By default, this is enabled if @c DEBUG or @c _DEBUG + * are defined. (@c NDEBUG is not used since it is allowed to have + * different values in different translation units.) + */ +#if !defined(MPACK_DEBUG) + #if defined(DEBUG) || defined(_DEBUG) + #define MPACK_DEBUG 1 + #else + #define MPACK_DEBUG 0 + #endif +#endif + +/** + * @def MPACK_STRINGS + * + * Enables descriptive error and type strings. + * + * This can be turned off (by defining it to 0) to maximize space savings + * on embedded devices. If this is disabled, string functions such as + * mpack_error_to_string() and mpack_type_to_string() return an empty string. + */ +#ifndef MPACK_STRINGS + #ifdef __AVR__ + #define MPACK_STRINGS 0 + #else + #define MPACK_STRINGS 1 + #endif +#endif + +/** + * Set this to 1 to implement a custom @ref mpack_assert_fail() function. + * See the documentation on @ref mpack_assert_fail() for details. + * + * Asserts are only used when @ref MPACK_DEBUG is enabled, and can be + * triggered by bugs in MPack or bugs due to incorrect usage of MPack. + */ +#ifndef MPACK_CUSTOM_ASSERT +#define MPACK_CUSTOM_ASSERT 0 +#endif + +/** + * @def MPACK_READ_TRACKING + * + * Enables compound type size tracking for readers. This ensures that the + * correct number of elements or bytes are read from a compound type. + * + * This is enabled by default in debug builds (provided a @c malloc() is + * available.) + */ +#if !defined(MPACK_READ_TRACKING) + #if MPACK_DEBUG && MPACK_READER && defined(MPACK_MALLOC) + #define MPACK_READ_TRACKING 1 + #else + #define MPACK_READ_TRACKING 0 + #endif +#endif +#if MPACK_READ_TRACKING && !MPACK_READER + #error "MPACK_READ_TRACKING requires MPACK_READER." +#endif + +/** + * @def MPACK_WRITE_TRACKING + * + * Enables compound type size tracking for writers. This ensures that the + * correct number of elements or bytes are written in a compound type. + * + * Note that without write tracking enabled, it is possible for buggy code + * to emit invalid MessagePack without flagging an error by writing the wrong + * number of elements or bytes in a compound type. With tracking enabled, + * MPack will catch such errors and break on the offending line of code. + * + * This is enabled by default in debug builds (provided a @c malloc() is + * available.) + */ +#if !defined(MPACK_WRITE_TRACKING) + #if MPACK_DEBUG && MPACK_WRITER && defined(MPACK_MALLOC) + #define MPACK_WRITE_TRACKING 1 + #else + #define MPACK_WRITE_TRACKING 0 + #endif +#endif +#if MPACK_WRITE_TRACKING && !MPACK_WRITER + #error "MPACK_WRITE_TRACKING requires MPACK_WRITER." +#endif + +/** + * @} + */ + + + + +/** + * @name Miscellaneous Options + * @{ + */ + +/** + * Whether to optimize for size or speed. + * + * Optimizing for size simplifies some parsing and encoding algorithms + * at the expense of speed and saves a few kilobytes of space in the + * resulting executable. + * + * This automatically detects -Os with GCC/Clang. Unfortunately there + * doesn't seem to be a macro defined for /Os under MSVC. + */ +#ifndef MPACK_OPTIMIZE_FOR_SIZE + #ifdef __OPTIMIZE_SIZE__ + #define MPACK_OPTIMIZE_FOR_SIZE 1 + #else + #define MPACK_OPTIMIZE_FOR_SIZE 0 + #endif +#endif + +/** + * Stack space in bytes to use when initializing a reader or writer + * with a stack-allocated buffer. + * + * @warning Make sure you have sufficient stack space. Some libc use relatively + * small stacks even on desktop platforms, e.g. musl. + */ +#ifndef MPACK_STACK_SIZE +#define MPACK_STACK_SIZE 4096 +#endif + +/** + * Buffer size to use for allocated buffers (such as for a file writer.) + * + * Starting with a single page and growing as needed seems to + * provide the best performance with minimal memory waste. + * Increasing this does not improve performance even when writing + * huge messages. + */ +#ifndef MPACK_BUFFER_SIZE +#define MPACK_BUFFER_SIZE 4096 +#endif + +/** + * Minimum size for paged allocations in bytes. + * + * This is the value used by default for MPACK_NODE_PAGE_SIZE and + * MPACK_BUILDER_PAGE_SIZE. + */ +#ifndef MPACK_PAGE_SIZE +#define MPACK_PAGE_SIZE 4096 +#endif + +/** + * Minimum size of an allocated node page in bytes. + * + * The children for a given compound element must be contiguous, so + * larger pages than this may be allocated as needed. (Safety checks + * exist to prevent malicious data from causing too large allocations.) + * + * See @ref mpack_node_data_t for the size of nodes. + * + * Using as many nodes fit in one memory page seems to provide the + * best performance, and has very little waste when parsing small + * messages. + */ +#ifndef MPACK_NODE_PAGE_SIZE +#define MPACK_NODE_PAGE_SIZE MPACK_PAGE_SIZE +#endif + +/** + * Minimum size of an allocated builder page in bytes. + * + * Builder writes are deferred to the allocated builder buffer which is + * composed of a list of buffer pages. This defines the size of those pages. + */ +#ifndef MPACK_BUILDER_PAGE_SIZE +#define MPACK_BUILDER_PAGE_SIZE MPACK_PAGE_SIZE +#endif + +/** + * @def MPACK_BUILDER_INTERNAL_STORAGE + * + * Enables a small amount of internal storage within the writer to avoid some + * allocations when using builders. + * + * This is disabled by default. Enable it to potentially improve performance at + * the expense of a larger writer. + * + * @see MPACK_BUILDER_INTERNAL_STORAGE_SIZE to configure its size. + */ +#ifndef MPACK_BUILDER_INTERNAL_STORAGE +#define MPACK_BUILDER_INTERNAL_STORAGE 0 +#endif + +/** + * Amount of space reserved inside @ref mpack_writer_t for the Builders. This + * can allow small messages to be built with the Builder API without incurring + * an allocation. + * + * Builder metadata is placed in this space in addition to the literal + * MessagePack data. It needs to be big enough to be useful, but not so big as + * to overflow the stack. If more space is needed, pages are allocated. + * + * This is only used if MPACK_BUILDER_INTERNAL_STORAGE is enabled. + * + * @see MPACK_BUILDER_PAGE_SIZE + * @see MPACK_BUILDER_INTERNAL_STORAGE + * + * @warning Writers are typically placed on the stack so make sure you have + * sufficient stack space. Some libc use relatively small stacks even on + * desktop platforms, e.g. musl. + */ +#ifndef MPACK_BUILDER_INTERNAL_STORAGE_SIZE +#define MPACK_BUILDER_INTERNAL_STORAGE_SIZE 256 +#endif + +/** + * The initial depth for the node parser. When MPACK_MALLOC is available, + * the node parser has no practical depth limit, and it is not recursive + * so there is no risk of overflowing the call stack. + */ +#ifndef MPACK_NODE_INITIAL_DEPTH +#define MPACK_NODE_INITIAL_DEPTH 8 +#endif + +/** + * The maximum depth for the node parser if @ref MPACK_MALLOC is not available. + */ +#ifndef MPACK_NODE_MAX_DEPTH_WITHOUT_MALLOC +#define MPACK_NODE_MAX_DEPTH_WITHOUT_MALLOC 32 +#endif + +/** + * @def MPACK_NO_BUILTINS + * + * Whether to disable compiler intrinsics and other built-in functions. + * + * If this is enabled, MPack won't use `__attribute__`, `__declspec`, any + * function starting with `__builtin`, or pretty much anything else that isn't + * standard C. + */ +#if defined(MPACK_DOXYGEN) +#if MPACK_DOXYGEN + #define MPACK_NO_BUILTINS 0 +#endif +#endif + +/** + * @} + */ + + + +#if MPACK_DEBUG +/** + * @name Debug Functions + * @{ + */ +/** + * Implement this and define @ref MPACK_CUSTOM_ASSERT to use a custom + * assertion function. + * + * This function should not return. If it does, MPack will @c abort(). + * + * If you use C++, make sure you include @c mpack.h where you define + * this to get the correct linkage (or define it extern "C".) + * + * Asserts are only used when @ref MPACK_DEBUG is enabled, and can be + * triggered by bugs in MPack or bugs due to incorrect usage of MPack. + */ +void mpack_assert_fail(const char* message); +/** + * @} + */ +#endif + + + +// The rest of this file shouldn't show up in Doxygen docs. +/** @cond */ + + + +/* + * All remaining pseudo-configuration options that have not yet been set must + * be defined here in order to support -Wundef. + * + * These aren't real configuration options; they are implementation details of + * MPack. + */ +#ifndef MPACK_CUSTOM_BREAK +#define MPACK_CUSTOM_BREAK 0 +#endif +#ifndef MPACK_EMIT_INLINE_DEFS +#define MPACK_EMIT_INLINE_DEFS 0 +#endif +#ifndef MPACK_AMALGAMATED +#define MPACK_AMALGAMATED 0 +#endif +#ifndef MPACK_RELEASE_VERSION +#define MPACK_RELEASE_VERSION 0 +#endif +#ifndef MPACK_INTERNAL +#define MPACK_INTERNAL 0 +#endif + + + +/* System headers (based on configuration) */ + +#if MPACK_CONFORMING + #include + #include + #include + #include + #include +#endif + +#if MPACK_STDLIB + #include + #include +#endif + +#if MPACK_STDIO + #include + #include + #if MPACK_DEBUG + #include + #endif +#endif + + + +/* + * Integer Constants and Limits + */ + +#if MPACK_CONFORMING + #define MPACK_INT64_C INT64_C + #define MPACK_UINT64_C UINT64_C + + #define MPACK_INT8_MIN INT8_MIN + #define MPACK_INT16_MIN INT16_MIN + #define MPACK_INT32_MIN INT32_MIN + #define MPACK_INT64_MIN INT64_MIN + #define MPACK_INT_MIN INT_MIN + + #define MPACK_INT8_MAX INT8_MAX + #define MPACK_INT16_MAX INT16_MAX + #define MPACK_INT32_MAX INT32_MAX + #define MPACK_INT64_MAX INT64_MAX + #define MPACK_INT_MAX INT_MAX + + #define MPACK_UINT8_MAX UINT8_MAX + #define MPACK_UINT16_MAX UINT16_MAX + #define MPACK_UINT32_MAX UINT32_MAX + #define MPACK_UINT64_MAX UINT64_MAX + #define MPACK_UINT_MAX UINT_MAX +#else + // For a non-conforming implementation we assume int is 32 bits. + + #define MPACK_INT64_C(x) ((int64_t)(x##LL)) + #define MPACK_UINT64_C(x) ((uint64_t)(x##LLU)) + + #define MPACK_INT8_MIN ((int8_t)(0x80)) + #define MPACK_INT16_MIN ((int16_t)(0x8000)) + #define MPACK_INT32_MIN ((int32_t)(0x80000000)) + #define MPACK_INT64_MIN MPACK_INT64_C(0x8000000000000000) + #define MPACK_INT_MIN MPACK_INT32_MIN + + #define MPACK_INT8_MAX ((int8_t)(0x7f)) + #define MPACK_INT16_MAX ((int16_t)(0x7fff)) + #define MPACK_INT32_MAX ((int32_t)(0x7fffffff)) + #define MPACK_INT64_MAX MPACK_INT64_C(0x7fffffffffffffff) + #define MPACK_INT_MAX MPACK_INT32_MAX + + #define MPACK_UINT8_MAX ((uint8_t)(0xffu)) + #define MPACK_UINT16_MAX ((uint16_t)(0xffffu)) + #define MPACK_UINT32_MAX ((uint32_t)(0xffffffffu)) + #define MPACK_UINT64_MAX MPACK_UINT64_C(0xffffffffffffffff) + #define MPACK_UINT_MAX MPACK_UINT32_MAX +#endif + + + +/* + * Floating point support + */ + +#if MPACK_DOUBLE && !MPACK_FLOAT + #error "MPACK_DOUBLE requires MPACK_FLOAT." +#endif + +// If we don't have support for float or double, we poison the identifiers to +// make sure we don't define anything related to them. +#if MPACK_INTERNAL + #ifdef __GNUC__ + #if !MPACK_FLOAT + #pragma GCC poison float + #endif + #if !MPACK_DOUBLE + #pragma GCC poison double + #endif + #endif +#endif + + + +/* + * extern C + */ + +#ifdef __cplusplus + #define MPACK_EXTERN_C_BEGIN extern "C" { + #define MPACK_EXTERN_C_END } +#else + #define MPACK_EXTERN_C_BEGIN /*nothing*/ + #define MPACK_EXTERN_C_END /*nothing*/ +#endif + + + +/* + * Warnings + */ + +#if defined(__GNUC__) + // Diagnostic push is not supported before GCC 4.6. + #if defined(__clang__) || __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6) + #define MPACK_SILENCE_WARNINGS_PUSH _Pragma ("GCC diagnostic push") + #define MPACK_SILENCE_WARNINGS_POP _Pragma ("GCC diagnostic pop") + #endif +#elif defined(_MSC_VER) + // To support VS2017 and earlier we need to use __pragma and not _Pragma + #define MPACK_SILENCE_WARNINGS_PUSH __pragma(warning(push)) + #define MPACK_SILENCE_WARNINGS_POP __pragma(warning(pop)) +#endif + +#if defined(_MSC_VER) + // These are a bunch of mostly useless warnings emitted under MSVC /W4, + // some as a result of the expansion of macros. + #define MPACK_SILENCE_WARNINGS_MSVC_W4 \ + __pragma(warning(disable:4996)) /* _CRT_SECURE_NO_WARNINGS */ \ + __pragma(warning(disable:4127)) /* comparison is constant */ \ + __pragma(warning(disable:4702)) /* unreachable code */ \ + __pragma(warning(disable:4310)) /* cast truncates constant value */ +#else + #define MPACK_SILENCE_WARNINGS_MSVC_W4 /*nothing*/ +#endif + +/* GCC versions before 5.1 warn about defining a C99 non-static inline function + * before declaring it (see issue #20). */ +#if defined(__GNUC__) && !defined(__clang__) + #if __GNUC__ < 5 || (__GNUC__ == 5 && __GNUC_MINOR__ < 1) + #ifdef __cplusplus + #define MPACK_SILENCE_WARNINGS_MISSING_PROTOTYPES \ + _Pragma ("GCC diagnostic ignored \"-Wmissing-declarations\"") + #else + #define MPACK_SILENCE_WARNINGS_MISSING_PROTOTYPES \ + _Pragma ("GCC diagnostic ignored \"-Wmissing-prototypes\"") + #endif + #endif +#endif +#ifndef MPACK_SILENCE_WARNINGS_MISSING_PROTOTYPES + #define MPACK_SILENCE_WARNINGS_MISSING_PROTOTYPES /*nothing*/ +#endif + +/* GCC versions before 4.8 warn about shadowing a function with a variable that + * isn't a function or function pointer (like "index"). */ +#if defined(__GNUC__) && !defined(__clang__) + #if __GNUC__ == 4 && __GNUC_MINOR__ < 8 + #define MPACK_SILENCE_WARNINGS_SHADOW \ + _Pragma ("GCC diagnostic ignored \"-Wshadow\"") + #endif +#endif +#ifndef MPACK_SILENCE_WARNINGS_SHADOW + #define MPACK_SILENCE_WARNINGS_SHADOW /*nothing*/ +#endif + +// On platforms with small size_t (e.g. AVR) we get type limits warnings where +// we compare a size_t to e.g. MPACK_UINT32_MAX. +#ifdef __AVR__ + #define MPACK_SILENCE_WARNINGS_TYPE_LIMITS \ + _Pragma ("GCC diagnostic ignored \"-Wtype-limits\"") +#else + #define MPACK_SILENCE_WARNINGS_TYPE_LIMITS /*nothing*/ +#endif + +// MPack uses declarations after statements. This silences warnings about it +// (e.g. when using MPack in a Linux kernel module.) +#if defined(__GNUC__) && !defined(__cplusplus) + #define MPACK_SILENCE_WARNINGS_DECLARATION_AFTER_STATEMENT \ + _Pragma ("GCC diagnostic ignored \"-Wdeclaration-after-statement\"") +#else + #define MPACK_SILENCE_WARNINGS_DECLARATION_AFTER_STATEMENT /*nothing*/ +#endif + +#ifdef MPACK_SILENCE_WARNINGS_PUSH + // We only silence warnings if push/pop is supported, that way we aren't + // silencing warnings in code that uses MPack. If your compiler doesn't + // support push/pop silencing of warnings, you'll have to turn off + // conflicting warnings manually. + + #define MPACK_SILENCE_WARNINGS_BEGIN \ + MPACK_SILENCE_WARNINGS_PUSH \ + MPACK_SILENCE_WARNINGS_MSVC_W4 \ + MPACK_SILENCE_WARNINGS_MISSING_PROTOTYPES \ + MPACK_SILENCE_WARNINGS_SHADOW \ + MPACK_SILENCE_WARNINGS_TYPE_LIMITS \ + MPACK_SILENCE_WARNINGS_DECLARATION_AFTER_STATEMENT + + #define MPACK_SILENCE_WARNINGS_END \ + MPACK_SILENCE_WARNINGS_POP +#else + #define MPACK_SILENCE_WARNINGS_BEGIN /*nothing*/ + #define MPACK_SILENCE_WARNINGS_END /*nothing*/ +#endif + +MPACK_SILENCE_WARNINGS_BEGIN +MPACK_EXTERN_C_BEGIN + + + +/* Miscellaneous helper macros */ + +#define MPACK_UNUSED(var) ((void)(var)) + +#define MPACK_STRINGIFY_IMPL(arg) #arg +#define MPACK_STRINGIFY(arg) MPACK_STRINGIFY_IMPL(arg) + +// This is a workaround for MSVC's incorrect expansion of __VA_ARGS__. It +// treats __VA_ARGS__ as a single preprocessor token when passed in the +// argument list of another macro unless we use an outer wrapper to expand it +// lexically first. (For safety/consistency we use this in all variadic macros +// that don't ignore the variadic arguments regardless of whether __VA_ARGS__ +// is passed to another macro.) +// https://stackoverflow.com/a/32400131 +#define MPACK_EXPAND(x) x + +// Extracts the first argument of a variadic macro list, where there might only +// be one argument. +#define MPACK_EXTRACT_ARG0_IMPL(first, ...) first +#define MPACK_EXTRACT_ARG0(...) MPACK_EXPAND(MPACK_EXTRACT_ARG0_IMPL( __VA_ARGS__ , ignored)) + +// Stringifies the first argument of a variadic macro list, where there might +// only be one argument. +#define MPACK_STRINGIFY_ARG0_impl(first, ...) #first +#define MPACK_STRINGIFY_ARG0(...) MPACK_EXPAND(MPACK_STRINGIFY_ARG0_impl( __VA_ARGS__ , ignored)) + + + +/* + * Definition of inline macros. + * + * MPack does not use static inline in header files; only one non-inline definition + * of each function should exist in the final build. This can reduce the binary size + * in cases where the compiler cannot or chooses not to inline a function. + * The addresses of functions should also compare equal across translation units + * regardless of whether they are declared inline. + * + * The above requirements mean that the declaration and definition of non-trivial + * inline functions must be separated so that the definitions will only + * appear when necessary. In addition, three different linkage models need + * to be supported: + * + * - The C99 model, where a standalone function is emitted only if there is any + * `extern inline` or non-`inline` declaration (including the definition itself) + * + * - The GNU model, where an `inline` definition emits a standalone function and an + * `extern inline` definition does not, regardless of other declarations + * + * - The C++ model, where `inline` emits a standalone function with special + * (COMDAT) linkage + * + * The macros below wrap up everything above. All inline functions defined in header + * files have a single non-inline definition emitted in the compilation of + * mpack-platform.c. All inline declarations and definitions use the same MPACK_INLINE + * specification to simplify the rules on when standalone functions are emitted. + * Inline functions in source files are defined MPACK_STATIC_INLINE. + * + * Additional reading: + * http://www.greenend.org.uk/rjk/tech/inline.html + */ + +#if defined(__cplusplus) + // C++ rules + // The linker will need COMDAT support to link C++ object files, + // so we don't need to worry about emitting definitions from C++ + // translation units. If mpack-platform.c (or the amalgamation) + // is compiled as C, its definition will be used, otherwise a + // C++ definition will be used, and no other C files will emit + // a definition. + #define MPACK_INLINE inline + +#elif defined(_MSC_VER) + // MSVC 2013 always uses COMDAT linkage, but it doesn't treat 'inline' as a + // keyword in C99 mode. (This appears to be fixed in a later version of + // MSVC but we don't bother detecting it.) + #define MPACK_INLINE __inline + #define MPACK_STATIC_INLINE static __inline + +#elif defined(__GNUC__) && (defined(__GNUC_GNU_INLINE__) || \ + (!defined(__GNUC_STDC_INLINE__) && !defined(__GNUC_GNU_INLINE__))) + // GNU rules + #if MPACK_EMIT_INLINE_DEFS + #define MPACK_INLINE inline + #else + #define MPACK_INLINE extern inline + #endif + +#elif defined(__TINYC__) + // tcc ignores the inline keyword, so we have to use static inline. We + // issue a warning to make sure you are aware. You can define the below + // macro to disable the warning. Hopefully this will be fixed soon: + // https://lists.nongnu.org/archive/html/tinycc-devel/2019-06/msg00000.html + #ifndef MPACK_DISABLE_TINYC_INLINE_WARNING + #warning "Single-definition inline is not supported by tcc. All inlines will be static. Define MPACK_DISABLE_TINYC_INLINE_WARNING to disable this warning." + #endif + #define MPACK_INLINE static inline + +#else + // C99 rules + #if MPACK_EMIT_INLINE_DEFS + #define MPACK_INLINE extern inline + #else + #define MPACK_INLINE inline + #endif +#endif + +#ifndef MPACK_STATIC_INLINE +#define MPACK_STATIC_INLINE static inline +#endif + +#ifdef MPACK_OPTIMIZE_FOR_SPEED + #error "You should define MPACK_OPTIMIZE_FOR_SIZE, not MPACK_OPTIMIZE_FOR_SPEED." +#endif + + + +/* + * Prevent inlining + * + * When a function is only used once, it is almost always inlined + * automatically. This can cause poor instruction cache usage because a + * function that should rarely be called (such as buffer exhaustion handling) + * will get inlined into the middle of a hot code path. + */ + +#if !MPACK_NO_BUILTINS + #if defined(_MSC_VER) + #define MPACK_NOINLINE __declspec(noinline) + #elif defined(__GNUC__) || defined(__clang__) + #define MPACK_NOINLINE __attribute__((__noinline__)) + #endif +#endif +#ifndef MPACK_NOINLINE + #define MPACK_NOINLINE /* nothing */ +#endif + + + +/* restrict */ + +// We prefer the builtins even though e.g. MSVC's __restrict may not have +// exactly the same behaviour as the proper C99 restrict keyword because the +// builtins work in C++, so using the same keyword in both C and C++ prevents +// any incompatibilities when using MPack compiled as C in C++ code. +#if !MPACK_NO_BUILTINS + #if defined(__GNUC__) + #define MPACK_RESTRICT __restrict__ + #elif defined(_MSC_VER) + #define MPACK_RESTRICT __restrict + #endif +#endif + +#ifndef MPACK_RESTRICT + #ifdef __cplusplus + #define MPACK_RESTRICT /* nothing, unavailable in C++ */ + #endif +#endif + +#ifndef MPACK_RESTRICT + #ifdef _MSC_VER + // MSVC 2015 apparently doesn't properly support the restrict keyword + // in C. We're using builtins above which do work on 2015, but when + // MPACK_NO_BUILTINS is enabled we can't use it. + #if _MSC_VER < 1910 + #define MPACK_RESTRICT /*nothing*/ + #endif + #endif +#endif + +#ifndef MPACK_RESTRICT + #define MPACK_RESTRICT restrict /* required in C99 */ +#endif + + + +/* Some compiler-specific keywords and builtins */ + +#if !MPACK_NO_BUILTINS + #if defined(__GNUC__) || defined(__clang__) + #define MPACK_UNREACHABLE __builtin_unreachable() + #define MPACK_NORETURN(fn) fn __attribute__((__noreturn__)) + #elif defined(_MSC_VER) + #define MPACK_UNREACHABLE __assume(0) + #define MPACK_NORETURN(fn) __declspec(noreturn) fn + #endif +#endif + +#ifndef MPACK_UNREACHABLE +#define MPACK_UNREACHABLE ((void)0) +#endif +#ifndef MPACK_NORETURN +#define MPACK_NORETURN(fn) fn +#endif + + + +/* + * Likely/unlikely + * + * These should only really be used when a branch is taken (or not taken) less + * than 1/1000th of the time. Buffer flush checks when writing very small + * elements are a good example. + */ + +#if !MPACK_NO_BUILTINS + #if defined(__GNUC__) || defined(__clang__) + #ifndef MPACK_LIKELY + #define MPACK_LIKELY(x) __builtin_expect((x),1) + #endif + #ifndef MPACK_UNLIKELY + #define MPACK_UNLIKELY(x) __builtin_expect((x),0) + #endif + #endif +#endif + +#ifndef MPACK_LIKELY + #define MPACK_LIKELY(x) (x) +#endif +#ifndef MPACK_UNLIKELY + #define MPACK_UNLIKELY(x) (x) +#endif + + + +/* alignof */ + +#ifndef MPACK_ALIGNOF + #if defined(__STDC_VERSION__) + #if __STDC_VERSION__ >= 201112L + #define MPACK_ALIGNOF(T) (_Alignof(T)) + #endif + #endif +#endif + +#ifndef MPACK_ALIGNOF + #if defined(__cplusplus) + #if __cplusplus >= 201103L + #define MPACK_ALIGNOF(T) (alignof(T)) + #endif + #endif +#endif + +#ifndef MPACK_ALIGNOF + #if defined(__GNUC__) && !defined(MPACK_NO_BUILTINS) + #if defined(__clang__) || __GNUC__ >= 4 + #define MPACK_ALIGNOF(T) (__alignof__(T)) + #endif + #endif +#endif + +#ifndef MPACK_ALIGNOF + #ifdef _MSC_VER + #define MPACK_ALIGNOF(T) __alignof(T) + #endif +#endif + +// MPACK_ALIGNOF may not exist, in which case a workaround is used. + + + +/* Static assert */ + +#ifndef MPACK_STATIC_ASSERT + #if defined(__cplusplus) + #if __cplusplus >= 201103L + #define MPACK_STATIC_ASSERT static_assert + #endif + #elif defined(__STDC_VERSION__) + #if __STDC_VERSION__ >= 201112L + #define MPACK_STATIC_ASSERT _Static_assert + #endif + #endif +#endif + +#if !MPACK_NO_BUILTINS + #ifndef MPACK_STATIC_ASSERT + #if defined(__has_feature) + #if __has_feature(cxx_static_assert) + #define MPACK_STATIC_ASSERT static_assert + #elif __has_feature(c_static_assert) + #define MPACK_STATIC_ASSERT _Static_assert + #endif + #endif + #endif + + #ifndef MPACK_STATIC_ASSERT + #if defined(__GNUC__) + /* Diagnostic push is not supported before GCC 4.6. */ + #if defined(__clang__) || __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6) + #ifndef __cplusplus + #if defined(__clang__) || __GNUC__ >= 5 + #define MPACK_IGNORE_PEDANTIC "GCC diagnostic ignored \"-Wpedantic\"" + #else + #define MPACK_IGNORE_PEDANTIC "GCC diagnostic ignored \"-pedantic\"" + #endif + #define MPACK_STATIC_ASSERT(expr, str) do { \ + _Pragma ("GCC diagnostic push") \ + _Pragma (MPACK_IGNORE_PEDANTIC) \ + _Pragma ("GCC diagnostic ignored \"-Wc++-compat\"") \ + _Static_assert(expr, str); \ + _Pragma ("GCC diagnostic pop") \ + } while (0) + #endif + #endif + #endif + #endif + + #ifndef MPACK_STATIC_ASSERT + #ifdef _MSC_VER + #if _MSC_VER >= 1600 + #define MPACK_STATIC_ASSERT static_assert + #endif + #endif + #endif +#endif + +#ifndef MPACK_STATIC_ASSERT + #define MPACK_STATIC_ASSERT(expr, str) (MPACK_UNUSED(sizeof(char[1 - 2*!(expr)]))) +#endif + + + +/* _Generic */ + +#ifndef MPACK_HAS_GENERIC + #if defined(__clang__) && defined(__has_feature) + // With Clang we can test for _Generic support directly + // and ignore C/C++ version + #if __has_feature(c_generic_selections) + #define MPACK_HAS_GENERIC 1 + #else + #define MPACK_HAS_GENERIC 0 + #endif + #endif +#endif + +#ifndef MPACK_HAS_GENERIC + #if defined(__STDC_VERSION__) + #if __STDC_VERSION__ >= 201112L + #if defined(__GNUC__) && !defined(__clang__) + // GCC does not have full C11 support in GCC 4.7 and 4.8 + #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 9) + #define MPACK_HAS_GENERIC 1 + #endif + #else + // We hope other compilers aren't lying about C11/_Generic support + #define MPACK_HAS_GENERIC 1 + #endif + #endif + #endif +#endif + +#ifndef MPACK_HAS_GENERIC + #define MPACK_HAS_GENERIC 0 +#endif + + + +/* + * Finite Math + * + * -ffinite-math-only, included in -ffast-math, breaks functions that + * that check for non-finite real values such as isnan() and isinf(). + * + * We should use this to trap errors when reading data that contains + * non-finite reals. This isn't currently implemented. + */ + +#ifndef MPACK_FINITE_MATH +#if defined(__FINITE_MATH_ONLY__) && __FINITE_MATH_ONLY__ +#define MPACK_FINITE_MATH 1 +#endif +#endif + +#ifndef MPACK_FINITE_MATH +#define MPACK_FINITE_MATH 0 +#endif + + + +/* + * Endianness checks + * + * These define MPACK_NHSWAP*() which swap network<->host byte + * order when needed. + * + * We leave them undefined if we can't determine the endianness + * at compile-time, in which case we fall back to bit-shifts. + * + * See the notes in mpack-common.h. + */ + +#if defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && defined(__ORDER_BIG_ENDIAN__) + #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ + #define MPACK_NHSWAP16(x) (x) + #define MPACK_NHSWAP32(x) (x) + #define MPACK_NHSWAP64(x) (x) + #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ + + #if !MPACK_NO_BUILTINS + #if defined(__clang__) + #ifdef __has_builtin + // Unlike the GCC builtins, the bswap builtins in Clang + // significantly improve ARM performance. + #if __has_builtin(__builtin_bswap16) + #define MPACK_NHSWAP16(x) __builtin_bswap16(x) + #endif + #if __has_builtin(__builtin_bswap32) + #define MPACK_NHSWAP32(x) __builtin_bswap32(x) + #endif + #if __has_builtin(__builtin_bswap64) + #define MPACK_NHSWAP64(x) __builtin_bswap64(x) + #endif + #endif + + #elif defined(__GNUC__) + + // The GCC bswap builtins are apparently poorly optimized on older + // versions of GCC, so we set a minimum version here just in case. + // http://hardwarebug.org/2010/01/14/beware-the-builtins/ + + #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5) + #define MPACK_NHSWAP64(x) __builtin_bswap64(x) + #endif + + // __builtin_bswap16() was not implemented on all platforms + // until GCC 4.8.0: + // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=52624 + // + // The 16- and 32-bit versions in GCC significantly reduce performance + // on ARM with little effect on code size so we don't use them. + + #endif + #endif + #endif + +#elif defined(_MSC_VER) && defined(_WIN32) && MPACK_STDLIB && !MPACK_NO_BUILTINS + + // On Windows, we assume x86 and x86_64 are always little-endian. + // We make no assumptions about ARM even though all current + // Windows Phone devices are little-endian in case Microsoft's + // compiler is ever used with a big-endian ARM device. + + // These are functions in so we depend on MPACK_STDLIB. + // It's not clear if these are actually faster than just doing the + // swap manually; maybe we shouldn't bother with this. + + #if defined(_M_IX86) || defined(_M_X64) || defined(_M_AMD64) + #define MPACK_NHSWAP16(x) _byteswap_ushort(x) + #define MPACK_NHSWAP32(x) _byteswap_ulong(x) + #define MPACK_NHSWAP64(x) _byteswap_uint64(x) + #endif + +#endif + +#if defined(__FLOAT_WORD_ORDER__) && defined(__BYTE_ORDER__) + + // We check where possible that the float byte order matches the + // integer byte order. This is extremely unlikely to fail, but + // we check anyway just in case. + // + // (The static assert is placed in float/double encoders instead + // of here because our static assert fallback doesn't work at + // file scope) + + #define MPACK_CHECK_FLOAT_ORDER() \ + MPACK_STATIC_ASSERT(__FLOAT_WORD_ORDER__ == __BYTE_ORDER__, \ + "float byte order does not match int byte order! float/double " \ + "encoding is not properly implemented on this platform.") + +#endif + +#ifndef MPACK_CHECK_FLOAT_ORDER + #define MPACK_CHECK_FLOAT_ORDER() /* nothing */ +#endif + + +/* + * Here we define mpack_assert() and mpack_break(). They both work like a normal + * assertion function in debug mode, causing a trap or abort. However, on some platforms + * you can safely resume execution from mpack_break(), whereas mpack_assert() is + * always fatal. + * + * In release mode, mpack_assert() is converted to an assurance to the compiler + * that the expression cannot be false (via e.g. __assume() or __builtin_unreachable()) + * to improve optimization where supported. There is thus no point in "safely" handling + * the case of this being false. Writing mpack_assert(0) rarely makes sense (except + * possibly as a default handler in a switch) since the compiler will throw away any + * code after it. If at any time an mpack_assert() is not true, the behaviour is + * undefined. This also means the expression is evaluated even in release. + * + * mpack_break() on the other hand is compiled to nothing in release. It is + * used in situations where we want to highlight a programming error as early as + * possible (in the debugger), but we still handle the situation safely if it + * happens in release to avoid producing incorrect results (such as in + * MPACK_WRITE_TRACKING.) It does not take an expression to test because it + * belongs in a safe-handling block after its failing condition has been tested. + * + * If stdio is available, we can add a format string describing the error, and + * on some compilers we can declare it noreturn to get correct results from static + * analysis tools. Note that the format string and arguments are not evaluated unless + * the assertion is hit. + * + * Note that any arguments to mpack_assert() beyond the first are only evaluated + * if the expression is false (and are never evaluated in release.) + * + * mpack_assert_fail() and mpack_break_hit() are defined separately + * because assert is noreturn and break isn't. This distinction is very + * important for static analysis tools to give correct results. + */ + +#if MPACK_DEBUG + MPACK_NORETURN(void mpack_assert_fail_wrapper(const char* message)); + #if MPACK_STDIO + MPACK_NORETURN(void mpack_assert_fail_format(const char* format, ...)); + #define mpack_assert_fail_at(line, file, exprstr, format, ...) \ + MPACK_EXPAND(mpack_assert_fail_format("mpack assertion failed at " file ":" #line "\n%s\n" format, exprstr, __VA_ARGS__)) + #else + #define mpack_assert_fail_at(line, file, exprstr, format, ...) \ + mpack_assert_fail_wrapper("mpack assertion failed at " file ":" #line "\n" exprstr "\n") + #endif + + #define mpack_assert_fail_pos(line, file, exprstr, expr, ...) \ + MPACK_EXPAND(mpack_assert_fail_at(line, file, exprstr, __VA_ARGS__)) + + // This contains a workaround to the pedantic C99 requirement of having at + // least one argument to a variadic macro. The first argument is the + // boolean expression, the optional second argument (if provided) must be a + // literal format string, and any additional arguments are the format + // argument list. + // + // Unfortunately this means macros are expanded in the expression before it + // gets stringified. I haven't found a workaround to this. + // + // This adds two unused arguments to the format argument list when a + // format string is provided, so this would complicate the use of + // -Wformat and __attribute__((__format__)) on mpack_assert_fail_format() + // if we ever bothered to implement it. + #define mpack_assert(...) \ + MPACK_EXPAND(((!(MPACK_EXTRACT_ARG0(__VA_ARGS__))) ? \ + mpack_assert_fail_pos(__LINE__, __FILE__, MPACK_STRINGIFY_ARG0(__VA_ARGS__) , __VA_ARGS__ , "", NULL) : \ + (void)0)) + + void mpack_break_hit(const char* message); + #if MPACK_STDIO + void mpack_break_hit_format(const char* format, ...); + #define mpack_break_hit_at(line, file, ...) \ + MPACK_EXPAND(mpack_break_hit_format("mpack breakpoint hit at " file ":" #line "\n" __VA_ARGS__)) + #else + #define mpack_break_hit_at(line, file, ...) \ + mpack_break_hit("mpack breakpoint hit at " file ":" #line ) + #endif + #define mpack_break_hit_pos(line, file, ...) MPACK_EXPAND(mpack_break_hit_at(line, file, __VA_ARGS__)) + #define mpack_break(...) MPACK_EXPAND(mpack_break_hit_pos(__LINE__, __FILE__, __VA_ARGS__)) +#else + #define mpack_assert(...) \ + (MPACK_EXPAND((!(MPACK_EXTRACT_ARG0(__VA_ARGS__))) ? \ + (MPACK_UNREACHABLE, (void)0) : \ + (void)0)) + #define mpack_break(...) ((void)0) +#endif + + + +// make sure we don't use the stdlib directly during development +#if MPACK_STDLIB && defined(MPACK_UNIT_TESTS) && MPACK_INTERNAL && defined(__GNUC__) + #undef memcmp + #undef memcpy + #undef memmove + #undef memset + #undef strlen + #undef malloc + #undef calloc + #undef realloc + #undef free + #pragma GCC poison memcmp + #pragma GCC poison memcpy + #pragma GCC poison memmove + #pragma GCC poison memset + #pragma GCC poison strlen + #pragma GCC poison malloc + #pragma GCC poison calloc + #pragma GCC poison realloc + #pragma GCC poison free +#endif + + + +// If we don't have these stdlib functions, we need to define them ourselves. +// Either way we give them a lowercase name to make the code a bit nicer. + +#ifdef MPACK_MEMCMP + #define mpack_memcmp MPACK_MEMCMP +#else + int mpack_memcmp(const void* s1, const void* s2, size_t n); +#endif + +#ifdef MPACK_MEMCPY + #define mpack_memcpy MPACK_MEMCPY +#else + void* mpack_memcpy(void* MPACK_RESTRICT s1, const void* MPACK_RESTRICT s2, size_t n); +#endif + +#ifdef MPACK_MEMMOVE + #define mpack_memmove MPACK_MEMMOVE +#else + void* mpack_memmove(void* s1, const void* s2, size_t n); +#endif + +#ifdef MPACK_MEMSET + #define mpack_memset MPACK_MEMSET +#else + void* mpack_memset(void* s, int c, size_t n); +#endif + +#ifdef MPACK_STRLEN + #define mpack_strlen MPACK_STRLEN +#else + size_t mpack_strlen(const char* s); +#endif + + + +#if MPACK_STDIO + #if defined(WIN32) + #define mpack_snprintf _snprintf + #else + #define mpack_snprintf snprintf + #endif +#endif + + + +/* Debug logging */ +#if 0 + #include + #define mpack_log(...) (MPACK_EXPAND(printf(__VA_ARGS__)), fflush(stdout)) +#else + #define mpack_log(...) ((void)0) +#endif + + + +/* Make sure our configuration makes sense */ +#ifndef MPACK_MALLOC + #if MPACK_STDIO + #error "MPACK_STDIO requires preprocessor definitions for MPACK_MALLOC and MPACK_FREE." + #endif + #if MPACK_READ_TRACKING + #error "MPACK_READ_TRACKING requires preprocessor definitions for MPACK_MALLOC and MPACK_FREE." + #endif + #if MPACK_WRITE_TRACKING + #error "MPACK_WRITE_TRACKING requires preprocessor definitions for MPACK_MALLOC and MPACK_FREE." + #endif +#endif + + + +/* Implement realloc if unavailable */ +#ifdef MPACK_MALLOC + #ifdef MPACK_REALLOC + MPACK_INLINE void* mpack_realloc(void* old_ptr, size_t used_size, size_t new_size) { + MPACK_UNUSED(used_size); + return MPACK_REALLOC(old_ptr, new_size); + } + #else + void* mpack_realloc(void* old_ptr, size_t used_size, size_t new_size); + #endif +#endif + + + +/** @endcond */ +/** + * @} + */ + +MPACK_EXTERN_C_END +MPACK_SILENCE_WARNINGS_END + +#endif + +/* mpack/mpack-common.h.h */ + +/** + * @file + * + * Defines types and functions shared by the MPack reader and writer. + */ + +#ifndef MPACK_COMMON_H +#define MPACK_COMMON_H 1 + +/* #include "mpack-platform.h" */ + +#ifndef MPACK_PRINT_BYTE_COUNT +#define MPACK_PRINT_BYTE_COUNT 12 +#endif + +MPACK_SILENCE_WARNINGS_BEGIN +MPACK_EXTERN_C_BEGIN + + + +/** + * @defgroup common Tags and Common Elements + * + * Contains types, constants and functions shared by both the encoding + * and decoding portions of MPack. + * + * @{ + */ + +/* Version information */ + +#define MPACK_VERSION_MAJOR 1 /**< The major version number of MPack. */ +#define MPACK_VERSION_MINOR 1 /**< The minor version number of MPack. */ +#define MPACK_VERSION_PATCH 1 /**< The patch version number of MPack. */ + +/** A number containing the version number of MPack for comparison purposes. */ +#define MPACK_VERSION ((MPACK_VERSION_MAJOR * 10000) + \ + (MPACK_VERSION_MINOR * 100) + MPACK_VERSION_PATCH) + +/** A macro to test for a minimum version of MPack. */ +#define MPACK_VERSION_AT_LEAST(major, minor, patch) \ + (MPACK_VERSION >= (((major) * 10000) + ((minor) * 100) + (patch))) + +/** @cond */ +#if (MPACK_VERSION_PATCH > 0) +#define MPACK_VERSION_STRING_BASE \ + MPACK_STRINGIFY(MPACK_VERSION_MAJOR) "." \ + MPACK_STRINGIFY(MPACK_VERSION_MINOR) "." \ + MPACK_STRINGIFY(MPACK_VERSION_PATCH) +#else +#define MPACK_VERSION_STRING_BASE \ + MPACK_STRINGIFY(MPACK_VERSION_MAJOR) "." \ + MPACK_STRINGIFY(MPACK_VERSION_MINOR) +#endif +/** @endcond */ + +/** + * @def MPACK_VERSION_STRING + * @hideinitializer + * + * A string containing the MPack version. + */ +#if MPACK_RELEASE_VERSION +#define MPACK_VERSION_STRING MPACK_VERSION_STRING_BASE +#else +#define MPACK_VERSION_STRING MPACK_VERSION_STRING_BASE "dev" +#endif + +/** + * @def MPACK_LIBRARY_STRING + * @hideinitializer + * + * A string describing MPack, containing the library name, version and debug mode. + */ +#if MPACK_DEBUG +#define MPACK_LIBRARY_STRING "MPack " MPACK_VERSION_STRING "-debug" +#else +#define MPACK_LIBRARY_STRING "MPack " MPACK_VERSION_STRING +#endif + +/** @cond */ +/** + * @def MPACK_MAXIMUM_TAG_SIZE + * + * The maximum encoded size of a tag in bytes. + */ +#define MPACK_MAXIMUM_TAG_SIZE 9 +/** @endcond */ + +#if MPACK_EXTENSIONS +/** + * @def MPACK_TIMESTAMP_NANOSECONDS_MAX + * + * The maximum value of nanoseconds for a timestamp. + * + * @note This requires @ref MPACK_EXTENSIONS. + */ +#define MPACK_TIMESTAMP_NANOSECONDS_MAX 999999999 +#endif + + + +#if MPACK_COMPATIBILITY +/** + * Versions of the MessagePack format. + * + * A reader, writer, or tree can be configured to serialize in an older + * version of the MessagePack spec. This is necessary to interface with + * older MessagePack libraries that do not support new MessagePack features. + * + * @note This requires @ref MPACK_COMPATIBILITY. + */ +typedef enum mpack_version_t { + + /** + * Version 1.0/v4, supporting only the @c raw type without @c str8. + */ + mpack_version_v4 = 4, + + /** + * Version 2.0/v5, supporting the @c str8, @c bin and @c ext types. + */ + mpack_version_v5 = 5, + + /** + * The most recent supported version of MessagePack. This is the default. + */ + mpack_version_current = mpack_version_v5, + +} mpack_version_t; +#endif + +/** + * Error states for MPack objects. + * + * When a reader, writer, or tree is in an error state, all subsequent calls + * are ignored and their return values are nil/zero. You should check whether + * the source is in an error state before using such values. + */ +typedef enum mpack_error_t { + mpack_ok = 0, /**< No error. */ + mpack_error_io = 2, /**< The reader or writer failed to fill or flush, or some other file or socket error occurred. */ + mpack_error_invalid, /**< The data read is not valid MessagePack. */ + mpack_error_unsupported, /**< The data read is not supported by this configuration of MPack. (See @ref MPACK_EXTENSIONS.) */ + mpack_error_type, /**< The type or value range did not match what was expected by the caller. */ + mpack_error_too_big, /**< A read or write was bigger than the maximum size allowed for that operation. */ + mpack_error_memory, /**< An allocation failure occurred. */ + mpack_error_bug, /**< The MPack API was used incorrectly. (This will always assert in debug mode.) */ + mpack_error_data, /**< The contained data is not valid. */ + mpack_error_eof, /**< The reader failed to read because of file or socket EOF */ +} mpack_error_t; + +/** + * Converts an MPack error to a string. This function returns an empty + * string when MPACK_DEBUG is not set. + */ +const char* mpack_error_to_string(mpack_error_t error); + +/** + * Defines the type of a MessagePack tag. + * + * Note that extension types, both user defined and built-in, are represented + * in tags as @ref mpack_type_ext. The value for an extension type is stored + * separately. + */ +typedef enum mpack_type_t { + mpack_type_missing = 0, /**< Special type indicating a missing optional value. */ + mpack_type_nil, /**< A null value. */ + mpack_type_bool, /**< A boolean (true or false.) */ + mpack_type_int, /**< A 64-bit signed integer. */ + mpack_type_uint, /**< A 64-bit unsigned integer. */ + mpack_type_float, /**< A 32-bit IEEE 754 floating point number. */ + mpack_type_double, /**< A 64-bit IEEE 754 floating point number. */ + mpack_type_str, /**< A string. */ + mpack_type_bin, /**< A chunk of binary data. */ + mpack_type_array, /**< An array of MessagePack objects. */ + mpack_type_map, /**< An ordered map of key/value pairs of MessagePack objects. */ + + #if MPACK_EXTENSIONS + /** + * A typed MessagePack extension object containing a chunk of binary data. + * + * @note This requires @ref MPACK_EXTENSIONS. + */ + mpack_type_ext, + #endif +} mpack_type_t; + +/** + * Converts an MPack type to a string. This function returns an empty + * string when MPACK_DEBUG is not set. + */ +const char* mpack_type_to_string(mpack_type_t type); + +#if MPACK_EXTENSIONS +/** + * A timestamp. + * + * @note This requires @ref MPACK_EXTENSIONS. + */ +typedef struct mpack_timestamp_t { + int64_t seconds; /*< The number of seconds (signed) since 1970-01-01T00:00:00Z. */ + uint32_t nanoseconds; /*< The number of additional nanoseconds, between 0 and 999,999,999. */ +} mpack_timestamp_t; +#endif + +/** + * An MPack tag is a MessagePack object header. It is a variant type + * representing any kind of object, and includes the length of compound types + * (e.g. map, array, string) or the value of non-compound types (e.g. boolean, + * integer, float.) + * + * If the type is compound (str, bin, ext, array or map), the contained + * elements or bytes are stored separately. + * + * This structure is opaque; its fields should not be accessed outside + * of MPack. + */ +typedef struct mpack_tag_t mpack_tag_t; + +/* Hide internals from documentation */ +/** @cond */ +struct mpack_tag_t { + mpack_type_t type; /*< The type of value. */ + + #if MPACK_EXTENSIONS + int8_t exttype; /*< The extension type if the type is @ref mpack_type_ext. */ + #endif + + /* The value for non-compound types. */ + union { + uint64_t u; /*< The value if the type is unsigned int. */ + int64_t i; /*< The value if the type is signed int. */ + bool b; /*< The value if the type is bool. */ + + #if MPACK_FLOAT + float f; /*< The value if the type is float. */ + #else + uint32_t f; /*< The raw value if the type is float. */ + #endif + + #if MPACK_DOUBLE + double d; /*< The value if the type is double. */ + #else + uint64_t d; /*< The raw value if the type is double. */ + #endif + + /* The number of bytes if the type is str, bin or ext. */ + uint32_t l; + + /* The element count if the type is an array, or the number of + key/value pairs if the type is map. */ + uint32_t n; + } v; +}; +/** @endcond */ + +/** + * @name Tag Generators + * @{ + */ + +/** + * @def MPACK_TAG_ZERO + * + * An @ref mpack_tag_t initializer that zeroes the given tag. + * + * @warning This does not make the tag nil! The tag's type is invalid when + * initialized this way. Use @ref mpack_tag_make_nil() to generate a nil tag. + */ +#if MPACK_EXTENSIONS +#define MPACK_TAG_ZERO {(mpack_type_t)0, 0, {0}} +#else +#define MPACK_TAG_ZERO {(mpack_type_t)0, {0}} +#endif + +/** Generates a nil tag. */ +MPACK_INLINE mpack_tag_t mpack_tag_make_nil(void) { + mpack_tag_t ret = MPACK_TAG_ZERO; + ret.type = mpack_type_nil; + return ret; +} + +/** Generates a bool tag. */ +MPACK_INLINE mpack_tag_t mpack_tag_make_bool(bool value) { + mpack_tag_t ret = MPACK_TAG_ZERO; + ret.type = mpack_type_bool; + ret.v.b = value; + return ret; +} + +/** Generates a bool tag with value true. */ +MPACK_INLINE mpack_tag_t mpack_tag_make_true(void) { + mpack_tag_t ret = MPACK_TAG_ZERO; + ret.type = mpack_type_bool; + ret.v.b = true; + return ret; +} + +/** Generates a bool tag with value false. */ +MPACK_INLINE mpack_tag_t mpack_tag_make_false(void) { + mpack_tag_t ret = MPACK_TAG_ZERO; + ret.type = mpack_type_bool; + ret.v.b = false; + return ret; +} + +/** Generates a signed int tag. */ +MPACK_INLINE mpack_tag_t mpack_tag_make_int(int64_t value) { + mpack_tag_t ret = MPACK_TAG_ZERO; + ret.type = mpack_type_int; + ret.v.i = value; + return ret; +} + +/** Generates an unsigned int tag. */ +MPACK_INLINE mpack_tag_t mpack_tag_make_uint(uint64_t value) { + mpack_tag_t ret = MPACK_TAG_ZERO; + ret.type = mpack_type_uint; + ret.v.u = value; + return ret; +} + +#if MPACK_FLOAT +/** Generates a float tag. */ +MPACK_INLINE mpack_tag_t mpack_tag_make_float(float value) +#else +/** Generates a float tag from a raw uint32_t. */ +MPACK_INLINE mpack_tag_t mpack_tag_make_raw_float(uint32_t value) +#endif +{ + mpack_tag_t ret = MPACK_TAG_ZERO; + ret.type = mpack_type_float; + ret.v.f = value; + return ret; +} + +#if MPACK_DOUBLE +/** Generates a double tag. */ +MPACK_INLINE mpack_tag_t mpack_tag_make_double(double value) +#else +/** Generates a double tag from a raw uint64_t. */ +MPACK_INLINE mpack_tag_t mpack_tag_make_raw_double(uint64_t value) +#endif +{ + mpack_tag_t ret = MPACK_TAG_ZERO; + ret.type = mpack_type_double; + ret.v.d = value; + return ret; +} + +/** Generates an array tag. */ +MPACK_INLINE mpack_tag_t mpack_tag_make_array(uint32_t count) { + mpack_tag_t ret = MPACK_TAG_ZERO; + ret.type = mpack_type_array; + ret.v.n = count; + return ret; +} + +/** Generates a map tag. */ +MPACK_INLINE mpack_tag_t mpack_tag_make_map(uint32_t count) { + mpack_tag_t ret = MPACK_TAG_ZERO; + ret.type = mpack_type_map; + ret.v.n = count; + return ret; +} + +/** Generates a str tag. */ +MPACK_INLINE mpack_tag_t mpack_tag_make_str(uint32_t length) { + mpack_tag_t ret = MPACK_TAG_ZERO; + ret.type = mpack_type_str; + ret.v.l = length; + return ret; +} + +/** Generates a bin tag. */ +MPACK_INLINE mpack_tag_t mpack_tag_make_bin(uint32_t length) { + mpack_tag_t ret = MPACK_TAG_ZERO; + ret.type = mpack_type_bin; + ret.v.l = length; + return ret; +} + +#if MPACK_EXTENSIONS +/** + * Generates an ext tag. + * + * @note This requires @ref MPACK_EXTENSIONS. + */ +MPACK_INLINE mpack_tag_t mpack_tag_make_ext(int8_t exttype, uint32_t length) { + mpack_tag_t ret = MPACK_TAG_ZERO; + ret.type = mpack_type_ext; + ret.exttype = exttype; + ret.v.l = length; + return ret; +} +#endif + +/** + * @} + */ + +/** + * @name Tag Querying Functions + * @{ + */ + +/** + * Gets the type of a tag. + */ +MPACK_INLINE mpack_type_t mpack_tag_type(mpack_tag_t* tag) { + return tag->type; +} + +/** + * Gets the boolean value of a bool-type tag. The tag must be of type @ref + * mpack_type_bool. + * + * This asserts that the type in the tag is @ref mpack_type_bool. (No check is + * performed if MPACK_DEBUG is not set.) + */ +MPACK_INLINE bool mpack_tag_bool_value(mpack_tag_t* tag) { + mpack_assert(tag->type == mpack_type_bool, "tag is not a bool!"); + return tag->v.b; +} + +/** + * Gets the signed integer value of an int-type tag. + * + * This asserts that the type in the tag is @ref mpack_type_int. (No check is + * performed if MPACK_DEBUG is not set.) + * + * @warning This does not convert between signed and unsigned tags! A positive + * integer may be stored in a tag as either @ref mpack_type_int or @ref + * mpack_type_uint. You must check the type first; this can only be used if the + * type is @ref mpack_type_int. + * + * @see mpack_type_int + */ +MPACK_INLINE int64_t mpack_tag_int_value(mpack_tag_t* tag) { + mpack_assert(tag->type == mpack_type_int, "tag is not an int!"); + return tag->v.i; +} + +/** + * Gets the unsigned integer value of a uint-type tag. + * + * This asserts that the type in the tag is @ref mpack_type_uint. (No check is + * performed if MPACK_DEBUG is not set.) + * + * @warning This does not convert between signed and unsigned tags! A positive + * integer may be stored in a tag as either @ref mpack_type_int or @ref + * mpack_type_uint. You must check the type first; this can only be used if the + * type is @ref mpack_type_uint. + * + * @see mpack_type_uint + */ +MPACK_INLINE uint64_t mpack_tag_uint_value(mpack_tag_t* tag) { + mpack_assert(tag->type == mpack_type_uint, "tag is not a uint!"); + return tag->v.u; +} + +/** + * Gets the float value of a float-type tag. + * + * This asserts that the type in the tag is @ref mpack_type_float. (No check is + * performed if MPACK_DEBUG is not set.) + * + * @warning This does not convert between float and double tags! This can only + * be used if the type is @ref mpack_type_float. + * + * @see mpack_type_float + */ +MPACK_INLINE +#if MPACK_FLOAT +float mpack_tag_float_value(mpack_tag_t* tag) +#else +uint32_t mpack_tag_raw_float_value(mpack_tag_t* tag) +#endif +{ + mpack_assert(tag->type == mpack_type_float, "tag is not a float!"); + return tag->v.f; +} + +/** + * Gets the double value of a double-type tag. + * + * This asserts that the type in the tag is @ref mpack_type_double. (No check + * is performed if MPACK_DEBUG is not set.) + * + * @warning This does not convert between float and double tags! This can only + * be used if the type is @ref mpack_type_double. + * + * @see mpack_type_double + */ +MPACK_INLINE +#if MPACK_DOUBLE +double mpack_tag_double_value(mpack_tag_t* tag) +#else +uint64_t mpack_tag_raw_double_value(mpack_tag_t* tag) +#endif +{ + mpack_assert(tag->type == mpack_type_double, "tag is not a double!"); + return tag->v.d; +} + +/** + * Gets the number of elements in an array tag. + * + * This asserts that the type in the tag is @ref mpack_type_array. (No check is + * performed if MPACK_DEBUG is not set.) + * + * @see mpack_type_array + */ +MPACK_INLINE uint32_t mpack_tag_array_count(mpack_tag_t* tag) { + mpack_assert(tag->type == mpack_type_array, "tag is not an array!"); + return tag->v.n; +} + +/** + * Gets the number of key-value pairs in a map tag. + * + * This asserts that the type in the tag is @ref mpack_type_map. (No check is + * performed if MPACK_DEBUG is not set.) + * + * @see mpack_type_map + */ +MPACK_INLINE uint32_t mpack_tag_map_count(mpack_tag_t* tag) { + mpack_assert(tag->type == mpack_type_map, "tag is not a map!"); + return tag->v.n; +} + +/** + * Gets the length in bytes of a str-type tag. + * + * This asserts that the type in the tag is @ref mpack_type_str. (No check is + * performed if MPACK_DEBUG is not set.) + * + * @see mpack_type_str + */ +MPACK_INLINE uint32_t mpack_tag_str_length(mpack_tag_t* tag) { + mpack_assert(tag->type == mpack_type_str, "tag is not a str!"); + return tag->v.l; +} + +/** + * Gets the length in bytes of a bin-type tag. + * + * This asserts that the type in the tag is @ref mpack_type_bin. (No check is + * performed if MPACK_DEBUG is not set.) + * + * @see mpack_type_bin + */ +MPACK_INLINE uint32_t mpack_tag_bin_length(mpack_tag_t* tag) { + mpack_assert(tag->type == mpack_type_bin, "tag is not a bin!"); + return tag->v.l; +} + +#if MPACK_EXTENSIONS +/** + * Gets the length in bytes of an ext-type tag. + * + * This asserts that the type in the tag is @ref mpack_type_ext. (No check is + * performed if MPACK_DEBUG is not set.) + * + * @note This requires @ref MPACK_EXTENSIONS. + * + * @see mpack_type_ext + */ +MPACK_INLINE uint32_t mpack_tag_ext_length(mpack_tag_t* tag) { + mpack_assert(tag->type == mpack_type_ext, "tag is not an ext!"); + return tag->v.l; +} + +/** + * Gets the extension type (exttype) of an ext-type tag. + * + * This asserts that the type in the tag is @ref mpack_type_ext. (No check is + * performed if MPACK_DEBUG is not set.) + * + * @note This requires @ref MPACK_EXTENSIONS. + * + * @see mpack_type_ext + */ +MPACK_INLINE int8_t mpack_tag_ext_exttype(mpack_tag_t* tag) { + mpack_assert(tag->type == mpack_type_ext, "tag is not an ext!"); + return tag->exttype; +} +#endif + +/** + * Gets the length in bytes of a str-, bin- or ext-type tag. + * + * This asserts that the type in the tag is @ref mpack_type_str, @ref + * mpack_type_bin or @ref mpack_type_ext. (No check is performed if MPACK_DEBUG + * is not set.) + * + * @see mpack_type_str + * @see mpack_type_bin + * @see mpack_type_ext + */ +MPACK_INLINE uint32_t mpack_tag_bytes(mpack_tag_t* tag) { + #if MPACK_EXTENSIONS + mpack_assert(tag->type == mpack_type_str || tag->type == mpack_type_bin + || tag->type == mpack_type_ext, "tag is not a str, bin or ext!"); + #else + mpack_assert(tag->type == mpack_type_str || tag->type == mpack_type_bin, + "tag is not a str or bin!"); + #endif + return tag->v.l; +} + +/** + * @} + */ + +/** + * @name Other tag functions + * @{ + */ + +#if MPACK_EXTENSIONS +/** + * The extension type for a timestamp. + * + * @note This requires @ref MPACK_EXTENSIONS. + */ +#define MPACK_EXTTYPE_TIMESTAMP ((int8_t)(-1)) +#endif + +/** + * Compares two tags with an arbitrary fixed ordering. Returns 0 if the tags are + * equal, a negative integer if left comes before right, or a positive integer + * otherwise. + * + * \warning The ordering is not guaranteed to be preserved across MPack versions; do + * not rely on it in persistent data. + * + * \warning Floating point numbers are compared bit-for-bit, not using the language's + * operator==. This means that NaNs with matching representation will compare equal. + * This behaviour is up for debate; see comments in the definition of mpack_tag_cmp(). + * + * See mpack_tag_equal() for more information on when tags are considered equal. + */ +int mpack_tag_cmp(mpack_tag_t left, mpack_tag_t right); + +/** + * Compares two tags for equality. Tags are considered equal if the types are compatible + * and the values (for non-compound types) are equal. + * + * The field width of variable-width fields is ignored (and in fact is not stored + * in a tag), and positive numbers in signed integers are considered equal to their + * unsigned counterparts. So for example the value 1 stored as a positive fixint + * is equal to the value 1 stored in a 64-bit unsigned integer field. + * + * The "extension type" of an extension object is considered part of the value + * and must match exactly. + * + * \warning Floating point numbers are compared bit-for-bit, not using the language's + * operator==. This means that NaNs with matching representation will compare equal. + * This behaviour is up for debate; see comments in the definition of mpack_tag_cmp(). + */ +MPACK_INLINE bool mpack_tag_equal(mpack_tag_t left, mpack_tag_t right) { + return mpack_tag_cmp(left, right) == 0; +} + +#if MPACK_DEBUG && MPACK_STDIO +/** + * Generates a json-like debug description of the given tag into the given buffer. + * + * This is only available in debug mode, and only if stdio is available (since + * it uses snprintf().) It's strictly for debugging purposes. + * + * The prefix is used to print the first few hexadecimal bytes of a bin or ext + * type. Pass NULL if not a bin or ext. + */ +void mpack_tag_debug_pseudo_json(mpack_tag_t tag, char* buffer, size_t buffer_size, + const char* prefix, size_t prefix_size); + +/** + * Generates a debug string description of the given tag into the given buffer. + * + * This is only available in debug mode, and only if stdio is available (since + * it uses snprintf().) It's strictly for debugging purposes. + */ +void mpack_tag_debug_describe(mpack_tag_t tag, char* buffer, size_t buffer_size); + +/** @cond */ + +/* + * A callback function for printing pseudo-JSON for debugging purposes. + * + * @see mpack_node_print_callback + */ +typedef void (*mpack_print_callback_t)(void* context, const char* data, size_t count); + +// helpers for printing debug output +// i feel a bit like i'm re-implementing a buffered writer again... +typedef struct mpack_print_t { + char* buffer; + size_t size; + size_t count; + mpack_print_callback_t callback; + void* context; +} mpack_print_t; + +void mpack_print_append(mpack_print_t* print, const char* data, size_t count); + +MPACK_INLINE void mpack_print_append_cstr(mpack_print_t* print, const char* cstr) { + mpack_print_append(print, cstr, mpack_strlen(cstr)); +} + +void mpack_print_flush(mpack_print_t* print); + +void mpack_print_file_callback(void* context, const char* data, size_t count); + +/** @endcond */ + +#endif + +/** + * @} + */ + +/** + * @name Deprecated Tag Generators + * @{ + */ + +/* + * "make" has been added to their names to disambiguate them from the + * value-fetching functions (e.g. mpack_tag_make_bool() vs + * mpack_tag_bool_value().) + * + * The length and count for all compound types was the wrong sign (int32_t + * instead of uint32_t.) These preserve the old behaviour; the new "make" + * functions have the correct sign. + */ + +/** \deprecated Renamed to mpack_tag_make_nil(). */ +MPACK_INLINE mpack_tag_t mpack_tag_nil(void) { + return mpack_tag_make_nil(); +} + +/** \deprecated Renamed to mpack_tag_make_bool(). */ +MPACK_INLINE mpack_tag_t mpack_tag_bool(bool value) { + return mpack_tag_make_bool(value); +} + +/** \deprecated Renamed to mpack_tag_make_true(). */ +MPACK_INLINE mpack_tag_t mpack_tag_true(void) { + return mpack_tag_make_true(); +} + +/** \deprecated Renamed to mpack_tag_make_false(). */ +MPACK_INLINE mpack_tag_t mpack_tag_false(void) { + return mpack_tag_make_false(); +} + +/** \deprecated Renamed to mpack_tag_make_int(). */ +MPACK_INLINE mpack_tag_t mpack_tag_int(int64_t value) { + return mpack_tag_make_int(value); +} + +/** \deprecated Renamed to mpack_tag_make_uint(). */ +MPACK_INLINE mpack_tag_t mpack_tag_uint(uint64_t value) { + return mpack_tag_make_uint(value); +} + +#if MPACK_FLOAT +/** \deprecated Renamed to mpack_tag_make_float(). */ +MPACK_INLINE mpack_tag_t mpack_tag_float(float value) { + return mpack_tag_make_float(value); +} +#endif + +#if MPACK_DOUBLE +/** \deprecated Renamed to mpack_tag_make_double(). */ +MPACK_INLINE mpack_tag_t mpack_tag_double(double value) { + return mpack_tag_make_double(value); +} +#endif + +/** \deprecated Renamed to mpack_tag_make_array(). */ +MPACK_INLINE mpack_tag_t mpack_tag_array(int32_t count) { + return mpack_tag_make_array((uint32_t)count); +} + +/** \deprecated Renamed to mpack_tag_make_map(). */ +MPACK_INLINE mpack_tag_t mpack_tag_map(int32_t count) { + return mpack_tag_make_map((uint32_t)count); +} + +/** \deprecated Renamed to mpack_tag_make_str(). */ +MPACK_INLINE mpack_tag_t mpack_tag_str(int32_t length) { + return mpack_tag_make_str((uint32_t)length); +} + +/** \deprecated Renamed to mpack_tag_make_bin(). */ +MPACK_INLINE mpack_tag_t mpack_tag_bin(int32_t length) { + return mpack_tag_make_bin((uint32_t)length); +} + +#if MPACK_EXTENSIONS +/** \deprecated Renamed to mpack_tag_make_ext(). */ +MPACK_INLINE mpack_tag_t mpack_tag_ext(int8_t exttype, int32_t length) { + return mpack_tag_make_ext(exttype, (uint32_t)length); +} +#endif + +/** + * @} + */ + +/** @cond */ + +/* + * Helpers to perform unaligned network-endian loads and stores + * at arbitrary addresses. Byte-swapping builtins are used if they + * are available and if they improve performance. + * + * These will remain available in the public API so feel free to + * use them for other purposes, but they are undocumented. + */ + +MPACK_INLINE uint8_t mpack_load_u8(const char* p) { + return (uint8_t)p[0]; +} + +MPACK_INLINE uint16_t mpack_load_u16(const char* p) { + #ifdef MPACK_NHSWAP16 + uint16_t val; + mpack_memcpy(&val, p, sizeof(val)); + return MPACK_NHSWAP16(val); + #else + return (uint16_t)((((uint16_t)(uint8_t)p[0]) << 8) | + ((uint16_t)(uint8_t)p[1])); + #endif +} + +MPACK_INLINE uint32_t mpack_load_u32(const char* p) { + #ifdef MPACK_NHSWAP32 + uint32_t val; + mpack_memcpy(&val, p, sizeof(val)); + return MPACK_NHSWAP32(val); + #else + return (((uint32_t)(uint8_t)p[0]) << 24) | + (((uint32_t)(uint8_t)p[1]) << 16) | + (((uint32_t)(uint8_t)p[2]) << 8) | + ((uint32_t)(uint8_t)p[3]); + #endif +} + +MPACK_INLINE uint64_t mpack_load_u64(const char* p) { + #ifdef MPACK_NHSWAP64 + uint64_t val; + mpack_memcpy(&val, p, sizeof(val)); + return MPACK_NHSWAP64(val); + #else + return (((uint64_t)(uint8_t)p[0]) << 56) | + (((uint64_t)(uint8_t)p[1]) << 48) | + (((uint64_t)(uint8_t)p[2]) << 40) | + (((uint64_t)(uint8_t)p[3]) << 32) | + (((uint64_t)(uint8_t)p[4]) << 24) | + (((uint64_t)(uint8_t)p[5]) << 16) | + (((uint64_t)(uint8_t)p[6]) << 8) | + ((uint64_t)(uint8_t)p[7]); + #endif +} + +MPACK_INLINE void mpack_store_u8(char* p, uint8_t val) { + uint8_t* u = (uint8_t*)p; + u[0] = val; +} + +MPACK_INLINE void mpack_store_u16(char* p, uint16_t val) { + #ifdef MPACK_NHSWAP16 + val = MPACK_NHSWAP16(val); + mpack_memcpy(p, &val, sizeof(val)); + #else + uint8_t* u = (uint8_t*)p; + u[0] = (uint8_t)((val >> 8) & 0xFF); + u[1] = (uint8_t)( val & 0xFF); + #endif +} + +MPACK_INLINE void mpack_store_u32(char* p, uint32_t val) { + #ifdef MPACK_NHSWAP32 + val = MPACK_NHSWAP32(val); + mpack_memcpy(p, &val, sizeof(val)); + #else + uint8_t* u = (uint8_t*)p; + u[0] = (uint8_t)((val >> 24) & 0xFF); + u[1] = (uint8_t)((val >> 16) & 0xFF); + u[2] = (uint8_t)((val >> 8) & 0xFF); + u[3] = (uint8_t)( val & 0xFF); + #endif +} + +MPACK_INLINE void mpack_store_u64(char* p, uint64_t val) { + #ifdef MPACK_NHSWAP64 + val = MPACK_NHSWAP64(val); + mpack_memcpy(p, &val, sizeof(val)); + #else + uint8_t* u = (uint8_t*)p; + u[0] = (uint8_t)((val >> 56) & 0xFF); + u[1] = (uint8_t)((val >> 48) & 0xFF); + u[2] = (uint8_t)((val >> 40) & 0xFF); + u[3] = (uint8_t)((val >> 32) & 0xFF); + u[4] = (uint8_t)((val >> 24) & 0xFF); + u[5] = (uint8_t)((val >> 16) & 0xFF); + u[6] = (uint8_t)((val >> 8) & 0xFF); + u[7] = (uint8_t)( val & 0xFF); + #endif +} + +MPACK_INLINE int8_t mpack_load_i8 (const char* p) {return (int8_t) mpack_load_u8 (p);} +MPACK_INLINE int16_t mpack_load_i16(const char* p) {return (int16_t)mpack_load_u16(p);} +MPACK_INLINE int32_t mpack_load_i32(const char* p) {return (int32_t)mpack_load_u32(p);} +MPACK_INLINE int64_t mpack_load_i64(const char* p) {return (int64_t)mpack_load_u64(p);} +MPACK_INLINE void mpack_store_i8 (char* p, int8_t val) {mpack_store_u8 (p, (uint8_t) val);} +MPACK_INLINE void mpack_store_i16(char* p, int16_t val) {mpack_store_u16(p, (uint16_t)val);} +MPACK_INLINE void mpack_store_i32(char* p, int32_t val) {mpack_store_u32(p, (uint32_t)val);} +MPACK_INLINE void mpack_store_i64(char* p, int64_t val) {mpack_store_u64(p, (uint64_t)val);} + +#if MPACK_FLOAT +MPACK_INLINE float mpack_load_float(const char* p) { + MPACK_CHECK_FLOAT_ORDER(); + MPACK_STATIC_ASSERT(sizeof(float) == sizeof(uint32_t), "float is wrong size??"); + union { + float f; + uint32_t u; + } v; + v.u = mpack_load_u32(p); + return v.f; +} +#endif + +#if MPACK_DOUBLE +MPACK_INLINE double mpack_load_double(const char* p) { + MPACK_CHECK_FLOAT_ORDER(); + MPACK_STATIC_ASSERT(sizeof(double) == sizeof(uint64_t), "double is wrong size??"); + union { + double d; + uint64_t u; + } v; + v.u = mpack_load_u64(p); + return v.d; +} +#endif + +#if MPACK_FLOAT +MPACK_INLINE void mpack_store_float(char* p, float value) { + MPACK_CHECK_FLOAT_ORDER(); + union { + float f; + uint32_t u; + } v; + v.f = value; + mpack_store_u32(p, v.u); +} +#endif + +#if MPACK_DOUBLE +MPACK_INLINE void mpack_store_double(char* p, double value) { + MPACK_CHECK_FLOAT_ORDER(); + union { + double d; + uint64_t u; + } v; + v.d = value; + mpack_store_u64(p, v.u); +} +#endif + +#if MPACK_FLOAT && !MPACK_DOUBLE +/** + * Performs a manual shortening conversion on the raw 64-bit representation of + * a double. This is useful for parsing doubles on platforms that only support + * floats (such as AVR.) + * + * The significand is truncated rather than rounded and subnormal numbers are + * set to 0 so this may not be quite as accurate as a real double-to-float + * conversion. + */ +MPACK_INLINE float mpack_shorten_raw_double_to_float(uint64_t d) { + MPACK_CHECK_FLOAT_ORDER(); + union { + float f; + uint32_t u; + } v; + + // float has 1 bit sign, 8 bits exponent, 23 bits significand + // double has 1 bit sign, 11 bits exponent, 52 bits significand + + uint64_t d_sign = (uint64_t)(d >> 63); + uint64_t d_exponent = (uint32_t)(d >> 52) & ((1 << 11) - 1); + uint64_t d_significand = d & (((uint64_t)1 << 52) - 1); + + uint32_t f_sign = (uint32_t)d_sign; + uint32_t f_exponent; + uint32_t f_significand; + + if (MPACK_UNLIKELY(d_exponent == ((1 << 11) - 1))) { + // infinity or NAN. shift down to preserve the top bit since it + // indicates signaling NAN, but also set the low bit if any bits were + // set (that way we can't shift NAN to infinity.) + f_exponent = ((1 << 8) - 1); + f_significand = (uint32_t)(d_significand >> 29) | (d_significand ? 1 : 0); + + } else { + int fix_bias = (int)d_exponent - ((1 << 10) - 1) + ((1 << 7) - 1); + if (MPACK_UNLIKELY(fix_bias <= 0)) { + // we don't currently handle subnormal numbers. just set it to zero. + f_exponent = 0; + f_significand = 0; + } else if (MPACK_UNLIKELY(fix_bias > 0xff)) { + // exponent is too large; saturate to infinity + f_exponent = 0xff; + f_significand = 0; + } else { + // a normal number that fits in a float. this is the usual case. + f_exponent = (uint32_t)fix_bias; + f_significand = (uint32_t)(d_significand >> 29); + } + } + + #if 0 + printf("\n===============\n"); + for (size_t i = 0; i < 64; ++i) + printf("%i%s",(int)((d>>(63-i))&1),((i%8)==7)?" ":""); + printf("\n%lu %lu %lu\n", d_sign, d_exponent, d_significand); + printf("%u %u %u\n", f_sign, f_exponent, f_significand); + #endif + + v.u = (f_sign << 31) | (f_exponent << 23) | f_significand; + return v.f; +} +#endif + +/** @endcond */ + + + +/** @cond */ + +// Sizes in bytes for the various possible tags +#define MPACK_TAG_SIZE_FIXUINT 1 +#define MPACK_TAG_SIZE_U8 2 +#define MPACK_TAG_SIZE_U16 3 +#define MPACK_TAG_SIZE_U32 5 +#define MPACK_TAG_SIZE_U64 9 +#define MPACK_TAG_SIZE_FIXINT 1 +#define MPACK_TAG_SIZE_I8 2 +#define MPACK_TAG_SIZE_I16 3 +#define MPACK_TAG_SIZE_I32 5 +#define MPACK_TAG_SIZE_I64 9 +#define MPACK_TAG_SIZE_FLOAT 5 +#define MPACK_TAG_SIZE_DOUBLE 9 +#define MPACK_TAG_SIZE_FIXARRAY 1 +#define MPACK_TAG_SIZE_ARRAY16 3 +#define MPACK_TAG_SIZE_ARRAY32 5 +#define MPACK_TAG_SIZE_FIXMAP 1 +#define MPACK_TAG_SIZE_MAP16 3 +#define MPACK_TAG_SIZE_MAP32 5 +#define MPACK_TAG_SIZE_FIXSTR 1 +#define MPACK_TAG_SIZE_STR8 2 +#define MPACK_TAG_SIZE_STR16 3 +#define MPACK_TAG_SIZE_STR32 5 +#define MPACK_TAG_SIZE_BIN8 2 +#define MPACK_TAG_SIZE_BIN16 3 +#define MPACK_TAG_SIZE_BIN32 5 +#define MPACK_TAG_SIZE_FIXEXT1 2 +#define MPACK_TAG_SIZE_FIXEXT2 2 +#define MPACK_TAG_SIZE_FIXEXT4 2 +#define MPACK_TAG_SIZE_FIXEXT8 2 +#define MPACK_TAG_SIZE_FIXEXT16 2 +#define MPACK_TAG_SIZE_EXT8 3 +#define MPACK_TAG_SIZE_EXT16 4 +#define MPACK_TAG_SIZE_EXT32 6 + +// size in bytes for complete ext types +#define MPACK_EXT_SIZE_TIMESTAMP4 (MPACK_TAG_SIZE_FIXEXT4 + 4) +#define MPACK_EXT_SIZE_TIMESTAMP8 (MPACK_TAG_SIZE_FIXEXT8 + 8) +#define MPACK_EXT_SIZE_TIMESTAMP12 (MPACK_TAG_SIZE_EXT8 + 12) + +/** @endcond */ + + + +#if MPACK_READ_TRACKING || MPACK_WRITE_TRACKING +/* Tracks the write state of compound elements (maps, arrays, */ +/* strings, binary blobs and extension types) */ +/** @cond */ + +typedef struct mpack_track_element_t { + mpack_type_t type; + uint32_t left; + + // indicates that a value still needs to be read/written for an already + // read/written key. left is not decremented until both key and value are + // read/written. + bool key_needs_value; + + // tracks whether the map/array being written is using a builder. if true, + // the number of elements is automatic, and left is 0. + bool builder; +} mpack_track_element_t; + +typedef struct mpack_track_t { + size_t count; + size_t capacity; + mpack_track_element_t* elements; +} mpack_track_t; + +#if MPACK_INTERNAL +mpack_error_t mpack_track_init(mpack_track_t* track); +mpack_error_t mpack_track_grow(mpack_track_t* track); +mpack_error_t mpack_track_push(mpack_track_t* track, mpack_type_t type, uint32_t count); +mpack_error_t mpack_track_push_builder(mpack_track_t* track, mpack_type_t type); +mpack_error_t mpack_track_pop(mpack_track_t* track, mpack_type_t type); +mpack_error_t mpack_track_pop_builder(mpack_track_t* track, mpack_type_t type); +mpack_error_t mpack_track_element(mpack_track_t* track, bool read); +mpack_error_t mpack_track_peek_element(mpack_track_t* track, bool read); +mpack_error_t mpack_track_bytes(mpack_track_t* track, bool read, size_t count); +mpack_error_t mpack_track_str_bytes_all(mpack_track_t* track, bool read, size_t count); +mpack_error_t mpack_track_check_empty(mpack_track_t* track); +mpack_error_t mpack_track_destroy(mpack_track_t* track, bool cancel); +#endif + +/** @endcond */ +#endif + + + +#if MPACK_INTERNAL +/** @cond */ + + + +/* Miscellaneous string functions */ + +/** + * Returns true if the given UTF-8 string is valid. + */ +bool mpack_utf8_check(const char* str, size_t bytes); + +/** + * Returns true if the given UTF-8 string is valid and contains no null characters. + */ +bool mpack_utf8_check_no_null(const char* str, size_t bytes); + +/** + * Returns true if the given string has no null bytes. + */ +bool mpack_str_check_no_null(const char* str, size_t bytes); + + + +/** @endcond */ +#endif + + + +/** + * @} + */ + +MPACK_EXTERN_C_END +MPACK_SILENCE_WARNINGS_END + +#endif + + +/* mpack/mpack-writer.h.h */ + +/** + * @file + * + * Declares the MPack Writer. + */ + +#ifndef MPACK_WRITER_H +#define MPACK_WRITER_H 1 + +/* #include "mpack-common.h" */ + +#if MPACK_WRITER + +MPACK_SILENCE_WARNINGS_BEGIN +MPACK_EXTERN_C_BEGIN + +#if MPACK_WRITE_TRACKING +struct mpack_track_t; +#endif + +/** + * @defgroup writer Write API + * + * The MPack Write API encodes structured data of a fixed (hardcoded) schema to MessagePack. + * + * @{ + */ + +/** + * @def MPACK_WRITER_MINIMUM_BUFFER_SIZE + * + * The minimum buffer size for a writer with a flush function. + */ +#define MPACK_WRITER_MINIMUM_BUFFER_SIZE 32 + +/** + * A buffered MessagePack encoder. + * + * The encoder wraps an existing buffer and, optionally, a flush function. + * This allows efficiently encoding to an in-memory buffer or to a stream. + * + * All write operations are synchronous; they will block until the + * data is fully written, or an error occurs. + */ +typedef struct mpack_writer_t mpack_writer_t; + +/** + * The MPack writer's flush function to flush the buffer to the output stream. + * It should flag an appropriate error on the writer if flushing fails (usually + * mpack_error_io or mpack_error_memory.) + * + * The specified context for callbacks is at writer->context. + */ +typedef void (*mpack_writer_flush_t)(mpack_writer_t* writer, const char* buffer, size_t count); + +/** + * An error handler function to be called when an error is flagged on + * the writer. + * + * The error handler will only be called once on the first error flagged; + * any subsequent writes and errors are ignored, and the writer is + * permanently in that error state. + * + * MPack is safe against non-local jumps out of error handler callbacks. + * This means you are allowed to longjmp or throw an exception (in C++, + * Objective-C, or with SEH) out of this callback. + * + * Bear in mind when using longjmp that local non-volatile variables that + * have changed are undefined when setjmp() returns, so you can't put the + * writer on the stack in the same activation frame as the setjmp without + * declaring it volatile. + * + * You must still eventually destroy the writer. It is not destroyed + * automatically when an error is flagged. It is safe to destroy the + * writer within this error callback, but you will either need to perform + * a non-local jump, or store something in your context to identify + * that the writer is destroyed since any future accesses to it cause + * undefined behavior. + */ +typedef void (*mpack_writer_error_t)(mpack_writer_t* writer, mpack_error_t error); + +/** + * A teardown function to be called when the writer is destroyed. + */ +typedef void (*mpack_writer_teardown_t)(mpack_writer_t* writer); + +/* Hide internals from documentation */ +/** @cond */ + +#if MPACK_BUILDER +/** + * Build buffer pages form a linked list. + * + * They don't always fill up. If there is not enough space within them to write + * a tag or place an mpack_build_t, a new page is allocated. For this reason + * they store the number of used bytes. + */ +typedef struct mpack_builder_page_t { + struct mpack_builder_page_t* next; + size_t bytes_used; +} mpack_builder_page_t; + +/** + * Builds form a linked list of mpack_build_t, interleaved with their encoded + * contents directly in the paged builder buffer. + */ +typedef struct mpack_build_t { + //mpack_builder_page_t* page; + struct mpack_build_t* parent; + //struct mpack_build_t* next; + + size_t bytes; // number of bytes between this build and the next one + uint32_t count; // number of elements (or key/value pairs) in this map/array + mpack_type_t type; + + // depth of nested non-build compound elements within this + // build. + uint32_t nested_compound_elements; + + // indicates that a value still needs to be written for an already + // written key. count is not incremented until both key and value are + // written. + bool key_needs_value; +} mpack_build_t; + +/** + * The builder state. This is stored within mpack_writer_t. + */ +typedef struct mpack_builder_t { + mpack_build_t* current_build; // build which is accumulating elements + mpack_build_t* latest_build; // build which is accumulating bytes + mpack_builder_page_t* current_page; + mpack_builder_page_t* pages; + char* stash_buffer; + char* stash_position; + char* stash_end; + #if MPACK_BUILDER_INTERNAL_STORAGE + char internal[MPACK_BUILDER_INTERNAL_STORAGE_SIZE]; + #endif +} mpack_builder_t; +#endif + +struct mpack_writer_t { + #if MPACK_COMPATIBILITY + mpack_version_t version; /* Version of the MessagePack spec to write */ + #endif + mpack_writer_flush_t flush; /* Function to write bytes to the output stream */ + mpack_writer_error_t error_fn; /* Function to call on error */ + mpack_writer_teardown_t teardown; /* Function to teardown the context on destroy */ + void* context; /* Context for writer callbacks */ + + char* buffer; /* Byte buffer */ + char* position; /* Current position within the buffer */ + char* end; /* The end of the buffer */ + mpack_error_t error; /* Error state */ + + #if MPACK_WRITE_TRACKING + mpack_track_t track; /* Stack of map/array/str/bin/ext writes */ + #endif + + #ifdef MPACK_MALLOC + /* Reserved. You can use this space to allocate a custom + * context in order to reduce heap allocations. */ + void* reserved[2]; + #endif + + #if MPACK_BUILDER + mpack_builder_t builder; + #endif +}; + + +#if MPACK_WRITE_TRACKING +void mpack_writer_track_push(mpack_writer_t* writer, mpack_type_t type, uint32_t count); +void mpack_writer_track_push_builder(mpack_writer_t* writer, mpack_type_t type); +void mpack_writer_track_pop(mpack_writer_t* writer, mpack_type_t type); +void mpack_writer_track_pop_builder(mpack_writer_t* writer, mpack_type_t type); +void mpack_writer_track_bytes(mpack_writer_t* writer, size_t count); +#else +MPACK_INLINE void mpack_writer_track_push(mpack_writer_t* writer, mpack_type_t type, uint32_t count) { + MPACK_UNUSED(writer); + MPACK_UNUSED(type); + MPACK_UNUSED(count); +} +MPACK_INLINE void mpack_writer_track_push_builder(mpack_writer_t* writer, mpack_type_t type) { + MPACK_UNUSED(writer); + MPACK_UNUSED(type); +} +MPACK_INLINE void mpack_writer_track_pop(mpack_writer_t* writer, mpack_type_t type) { + MPACK_UNUSED(writer); + MPACK_UNUSED(type); +} +MPACK_INLINE void mpack_writer_track_pop_builder(mpack_writer_t* writer, mpack_type_t type) { + MPACK_UNUSED(writer); + MPACK_UNUSED(type); +} +MPACK_INLINE void mpack_writer_track_bytes(mpack_writer_t* writer, size_t count) { + MPACK_UNUSED(writer); + MPACK_UNUSED(count); +} +#endif + +/** @endcond */ + +/** + * @name Lifecycle Functions + * @{ + */ + +/** + * Initializes an MPack writer with the given buffer. The writer + * does not assume ownership of the buffer. + * + * Trying to write past the end of the buffer will result in mpack_error_too_big + * unless a flush function is set with mpack_writer_set_flush(). To use the data + * without flushing, call mpack_writer_buffer_used() to determine the number of + * bytes written. + * + * @param writer The MPack writer. + * @param buffer The buffer into which to write MessagePack data. + * @param size The size of the buffer. + */ +void mpack_writer_init(mpack_writer_t* writer, char* buffer, size_t size); + +#ifdef MPACK_MALLOC +/** + * Initializes an MPack writer using a growable buffer. + * + * The data is placed in the given data pointer if and when the writer + * is destroyed without error. The data pointer is NULL during writing, + * and will remain NULL if an error occurs. + * + * The allocated data must be freed with MPACK_FREE() (or simply free() + * if MPack's allocator hasn't been customized.) + * + * @throws mpack_error_memory if the buffer fails to grow when + * flushing. + * + * @param writer The MPack writer. + * @param data Where to place the allocated data. + * @param size Where to write the size of the data. + */ +void mpack_writer_init_growable(mpack_writer_t* writer, char** data, size_t* size); +#endif + +/** + * Initializes an MPack writer directly into an error state. Use this if you + * are writing a wrapper to mpack_writer_init() which can fail its setup. + */ +void mpack_writer_init_error(mpack_writer_t* writer, mpack_error_t error); + +#if MPACK_STDIO +/** + * Initializes an MPack writer that writes to a file. + * + * @throws mpack_error_memory if allocation fails + * @throws mpack_error_io if the file cannot be opened + */ +void mpack_writer_init_filename(mpack_writer_t* writer, const char* filename); + +/** + * Deprecated. + * + * \deprecated Renamed to mpack_writer_init_filename(). + */ +MPACK_INLINE void mpack_writer_init_file(mpack_writer_t* writer, const char* filename) { + mpack_writer_init_filename(writer, filename); +} + +/** + * Initializes an MPack writer that writes to a libc FILE. This can be used to + * write to stdout or stderr, or to a file opened separately. + * + * @param writer The MPack writer. + * @param stdfile The FILE. + * @param close_when_done If true, fclose() will be called on the FILE when it + * is no longer needed. If false, the file will not be flushed or + * closed when writing is done. + * + * @note The writer is buffered. If you want to write other data to the FILE in + * between messages, you must flush it first. + * + * @see mpack_writer_flush_message + */ +void mpack_writer_init_stdfile(mpack_writer_t* writer, FILE* stdfile, bool close_when_done); +#endif + +/** @cond */ + +#define mpack_writer_init_stack_line_ex(line, writer) \ + char mpack_buf_##line[MPACK_STACK_SIZE]; \ + mpack_writer_init(writer, mpack_buf_##line, sizeof(mpack_buf_##line)) + +#define mpack_writer_init_stack_line(line, writer) \ + mpack_writer_init_stack_line_ex(line, writer) + +/* + * Initializes an MPack writer using stack space as a buffer. A flush function + * should be added to the writer to flush the buffer. + * + * This is currently undocumented since it's not entirely useful on its own. + */ + +#define mpack_writer_init_stack(writer) \ + mpack_writer_init_stack_line(__LINE__, (writer)) + +/** @endcond */ + +/** + * Cleans up the MPack writer, flushing and closing the underlying stream, + * if any. Returns the final error state of the writer. + * + * No flushing is performed if the writer is in an error state. The attached + * teardown function is called whether or not the writer is in an error state. + * + * This will assert in tracking mode if the writer is not in an error + * state and has any unclosed compound types. If you want to cancel + * writing in the middle of a document, you need to flag an error on + * the writer before destroying it (such as mpack_error_data). + * + * Note that a writer may raise an error and call your error handler during + * the final flush. It is safe to longjmp or throw out of this error handler, + * but if you do, the writer will not be destroyed, and the teardown function + * will not be called. You can still get the writer's error state, and you + * must call @ref mpack_writer_destroy() again. (The second call is guaranteed + * not to call your error handler again since the writer is already in an error + * state.) + * + * @see mpack_writer_set_error_handler + * @see mpack_writer_set_flush + * @see mpack_writer_set_teardown + * @see mpack_writer_flag_error + * @see mpack_error_data + */ +mpack_error_t mpack_writer_destroy(mpack_writer_t* writer); + +/** + * @} + */ + +/** + * @name Configuration + * @{ + */ + +#if MPACK_COMPATIBILITY +/** + * Sets the version of the MessagePack spec that will be generated. + * + * This can be used to interface with older libraries that do not support + * the newest MessagePack features (such as the @c str8 type.) + * + * @note This requires @ref MPACK_COMPATIBILITY. + */ +MPACK_INLINE void mpack_writer_set_version(mpack_writer_t* writer, mpack_version_t version) { + writer->version = version; +} +#endif + +/** + * Sets the custom pointer to pass to the writer callbacks, such as flush + * or teardown. + * + * @param writer The MPack writer. + * @param context User data to pass to the writer callbacks. + * + * @see mpack_writer_context() + */ +MPACK_INLINE void mpack_writer_set_context(mpack_writer_t* writer, void* context) { + writer->context = context; +} + +/** + * Returns the custom context for writer callbacks. + * + * @see mpack_writer_set_context + * @see mpack_writer_set_flush + */ +MPACK_INLINE void* mpack_writer_context(mpack_writer_t* writer) { + return writer->context; +} + +/** + * Sets the flush function to write out the data when the buffer is full. + * + * If no flush function is used, trying to write past the end of the + * buffer will result in mpack_error_too_big. + * + * This should normally be used with mpack_writer_set_context() to register + * a custom pointer to pass to the flush function. + * + * @param writer The MPack writer. + * @param flush The function to write out data from the buffer. + * + * @see mpack_writer_context() + */ +void mpack_writer_set_flush(mpack_writer_t* writer, mpack_writer_flush_t flush); + +/** + * Sets the error function to call when an error is flagged on the writer. + * + * This should normally be used with mpack_writer_set_context() to register + * a custom pointer to pass to the error function. + * + * See the definition of mpack_writer_error_t for more information about + * what you can do from an error callback. + * + * @see mpack_writer_error_t + * @param writer The MPack writer. + * @param error_fn The function to call when an error is flagged on the writer. + */ +MPACK_INLINE void mpack_writer_set_error_handler(mpack_writer_t* writer, mpack_writer_error_t error_fn) { + writer->error_fn = error_fn; +} + +/** + * Sets the teardown function to call when the writer is destroyed. + * + * This should normally be used with mpack_writer_set_context() to register + * a custom pointer to pass to the teardown function. + * + * @param writer The MPack writer. + * @param teardown The function to call when the writer is destroyed. + */ +MPACK_INLINE void mpack_writer_set_teardown(mpack_writer_t* writer, mpack_writer_teardown_t teardown) { + writer->teardown = teardown; +} + +/** + * @} + */ + +/** + * @name Core Writer Functions + * @{ + */ + +/** + * Flushes any buffered data to the underlying stream. + * + * If the writer is connected to a socket and you are keeping it open, + * you will want to call this after writing a message (or set of + * messages) so that the data is actually sent. + * + * It is not necessary to call this if you are not keeping the writer + * open afterwards. You can just call `mpack_writer_destroy()` and it + * will flush before cleaning up. + * + * This will assert if no flush function is assigned to the writer. + * + * If write tracking is enabled, this will break and flag @ref + * mpack_error_bug if the writer has any open compound types, ensuring + * that no compound types are still open. This prevents a "missing + * finish" bug from causing a never-ending message. + */ +void mpack_writer_flush_message(mpack_writer_t* writer); + +/** + * Returns the number of bytes currently stored in the buffer. This + * may be less than the total number of bytes written if bytes have + * been flushed to an underlying stream. + */ +MPACK_INLINE size_t mpack_writer_buffer_used(mpack_writer_t* writer) { + return (size_t)(writer->position - writer->buffer); +} + +/** + * Returns the amount of space left in the buffer. This may be reset + * after a write if bytes are flushed to an underlying stream. + */ +MPACK_INLINE size_t mpack_writer_buffer_left(mpack_writer_t* writer) { + return (size_t)(writer->end - writer->position); +} + +/** + * Returns the (current) size of the buffer. This may change after a write if + * the flush callback changes the buffer. + */ +MPACK_INLINE size_t mpack_writer_buffer_size(mpack_writer_t* writer) { + return (size_t)(writer->end - writer->buffer); +} + +/** + * Places the writer in the given error state, calling the error callback if one + * is set. + * + * This allows you to externally flag errors, for example if you are validating + * data as you write it, or if you want to cancel writing in the middle of a + * document. (The writer will assert if you try to destroy it without error and + * with unclosed compound types. In this case you should flag mpack_error_data + * before destroying it.) + * + * If the writer is already in an error state, this call is ignored and no + * error callback is called. + * + * @see mpack_writer_destroy + * @see mpack_error_data + */ +void mpack_writer_flag_error(mpack_writer_t* writer, mpack_error_t error); + +/** + * Queries the error state of the MPack writer. + * + * If a writer is in an error state, you should discard all data since the + * last time the error flag was checked. The error flag cannot be cleared. + */ +MPACK_INLINE mpack_error_t mpack_writer_error(mpack_writer_t* writer) { + return writer->error; +} + +/** + * Writes a MessagePack object header (an MPack Tag.) + * + * If the value is a map, array, string, binary or extension type, the + * containing elements or bytes must be written separately and the + * appropriate finish function must be called (as though one of the + * mpack_start_*() functions was called.) + * + * @see mpack_write_bytes() + * @see mpack_finish_map() + * @see mpack_finish_array() + * @see mpack_finish_str() + * @see mpack_finish_bin() + * @see mpack_finish_ext() + * @see mpack_finish_type() + */ +void mpack_write_tag(mpack_writer_t* writer, mpack_tag_t tag); + +/** + * @} + */ + +/** + * @name Integers + * @{ + */ + +/** Writes an 8-bit integer in the most efficient packing available. */ +void mpack_write_i8(mpack_writer_t* writer, int8_t value); + +/** Writes a 16-bit integer in the most efficient packing available. */ +void mpack_write_i16(mpack_writer_t* writer, int16_t value); + +/** Writes a 32-bit integer in the most efficient packing available. */ +void mpack_write_i32(mpack_writer_t* writer, int32_t value); + +/** Writes a 64-bit integer in the most efficient packing available. */ +void mpack_write_i64(mpack_writer_t* writer, int64_t value); + +/** Writes an integer in the most efficient packing available. */ +MPACK_INLINE void mpack_write_int(mpack_writer_t* writer, int64_t value) { + mpack_write_i64(writer, value); +} + +/** Writes an 8-bit unsigned integer in the most efficient packing available. */ +void mpack_write_u8(mpack_writer_t* writer, uint8_t value); + +/** Writes an 16-bit unsigned integer in the most efficient packing available. */ +void mpack_write_u16(mpack_writer_t* writer, uint16_t value); + +/** Writes an 32-bit unsigned integer in the most efficient packing available. */ +void mpack_write_u32(mpack_writer_t* writer, uint32_t value); + +/** Writes an 64-bit unsigned integer in the most efficient packing available. */ +void mpack_write_u64(mpack_writer_t* writer, uint64_t value); + +/** Writes an unsigned integer in the most efficient packing available. */ +MPACK_INLINE void mpack_write_uint(mpack_writer_t* writer, uint64_t value) { + mpack_write_u64(writer, value); +} + +/** + * @} + */ + +/** + * @name Other Basic Types + * @{ + */ + +#if MPACK_FLOAT +/** Writes a float. */ +void mpack_write_float(mpack_writer_t* writer, float value); +#else +/** Writes a float from a raw uint32_t. */ +void mpack_write_raw_float(mpack_writer_t* writer, uint32_t raw_value); +#endif + +#if MPACK_DOUBLE +/** Writes a double. */ +void mpack_write_double(mpack_writer_t* writer, double value); +#else +/** Writes a double from a raw uint64_t. */ +void mpack_write_raw_double(mpack_writer_t* writer, uint64_t raw_value); +#endif + +/** Writes a boolean. */ +void mpack_write_bool(mpack_writer_t* writer, bool value); + +/** Writes a boolean with value true. */ +void mpack_write_true(mpack_writer_t* writer); + +/** Writes a boolean with value false. */ +void mpack_write_false(mpack_writer_t* writer); + +/** Writes a nil. */ +void mpack_write_nil(mpack_writer_t* writer); + +/** Write a pre-encoded messagepack object */ +void mpack_write_object_bytes(mpack_writer_t* writer, const char* data, size_t bytes); + +#if MPACK_EXTENSIONS +/** + * Writes a timestamp. + * + * @note This requires @ref MPACK_EXTENSIONS. + * + * @param writer The writer + * @param seconds The (signed) number of seconds since 1970-01-01T00:00:00Z. + * @param nanoseconds The additional number of nanoseconds from 0 to 999,999,999 inclusive. + */ +void mpack_write_timestamp(mpack_writer_t* writer, int64_t seconds, uint32_t nanoseconds); + +/** + * Writes a timestamp with the given number of seconds (and zero nanoseconds). + * + * @note This requires @ref MPACK_EXTENSIONS. + * + * @param writer The writer + * @param seconds The (signed) number of seconds since 1970-01-01T00:00:00Z. + */ +MPACK_INLINE void mpack_write_timestamp_seconds(mpack_writer_t* writer, int64_t seconds) { + mpack_write_timestamp(writer, seconds, 0); +} + +/** + * Writes a timestamp. + * + * @note This requires @ref MPACK_EXTENSIONS. + */ +MPACK_INLINE void mpack_write_timestamp_struct(mpack_writer_t* writer, mpack_timestamp_t timestamp) { + mpack_write_timestamp(writer, timestamp.seconds, timestamp.nanoseconds); +} +#endif + +/** + * @} + */ + +/** + * @name Map and Array Functions + * @{ + */ + +/** + * Opens an array. + * + * `count` elements must follow, and mpack_finish_array() must be called + * when done. + * + * If you do not know the number of elements to be written ahead of time, call + * mpack_build_array() instead. + * + * @see mpack_finish_array() + * @see mpack_build_array() to count the number of elements automatically + */ +void mpack_start_array(mpack_writer_t* writer, uint32_t count); + +/** + * Opens a map. + * + * `count * 2` elements must follow, and mpack_finish_map() must be called + * when done. + * + * If you do not know the number of elements to be written ahead of time, call + * mpack_build_map() instead. + * + * Remember that while map elements in MessagePack are implicitly ordered, + * they are not ordered in JSON. If you need elements to be read back + * in the order they are written, consider use an array instead. + * + * @see mpack_finish_map() + * @see mpack_build_map() to count the number of key/value pairs automatically + */ +void mpack_start_map(mpack_writer_t* writer, uint32_t count); + +MPACK_INLINE void mpack_builder_compound_push(mpack_writer_t* writer) { + MPACK_UNUSED(writer); + + #if MPACK_BUILDER + mpack_build_t* build = writer->builder.current_build; + if (build != NULL) { + ++build->nested_compound_elements; + } + #endif +} + +MPACK_INLINE void mpack_builder_compound_pop(mpack_writer_t* writer) { + MPACK_UNUSED(writer); + + #if MPACK_BUILDER + mpack_build_t* build = writer->builder.current_build; + if (build != NULL) { + mpack_assert(build->nested_compound_elements > 0); + --build->nested_compound_elements; + } + #endif +} + +/** + * Finishes writing an array. + * + * This should be called only after a corresponding call to mpack_start_array() + * and after the array contents are written. + * + * In debug mode (or if MPACK_WRITE_TRACKING is not 0), this will track writes + * to ensure that the correct number of elements are written. + * + * @see mpack_start_array() + */ +MPACK_INLINE void mpack_finish_array(mpack_writer_t* writer) { + mpack_writer_track_pop(writer, mpack_type_array); + mpack_builder_compound_pop(writer); +} + +/** + * Finishes writing a map. + * + * This should be called only after a corresponding call to mpack_start_map() + * and after the map contents are written. + * + * In debug mode (or if MPACK_WRITE_TRACKING is not 0), this will track writes + * to ensure that the correct number of elements are written. + * + * @see mpack_start_map() + */ +MPACK_INLINE void mpack_finish_map(mpack_writer_t* writer) { + mpack_writer_track_pop(writer, mpack_type_map); + mpack_builder_compound_pop(writer); +} + +/** + * Starts building an array. + * + * Elements must follow, and mpack_complete_array() must be called when done. The + * number of elements is determined automatically. + * + * If you know ahead of time the number of elements in the array, it is more + * efficient to call mpack_start_array() instead, even if you are already + * within another open build. + * + * Builder containers can be nested within normal (known size) containers and + * vice versa. You can call mpack_build_array(), then mpack_start_array() + * inside it, then mpack_build_array() inside that, and so forth. + * + * @see mpack_complete_array() to complete this array + * @see mpack_start_array() if you already know the size of the array + * @see mpack_build_map() for implementation details + */ +void mpack_build_array(struct mpack_writer_t* writer); + +/** + * Starts building a map. + * + * An even number of elements must follow, and mpack_complete_map() must be + * called when done. The number of elements is determined automatically. + * + * If you know ahead of time the number of elements in the map, it is more + * efficient to call mpack_start_map() instead, even if you are already within + * another open build. + * + * Builder containers can be nested within normal (known size) containers and + * vice versa. You can call mpack_build_map(), then mpack_start_map() inside + * it, then mpack_build_map() inside that, and so forth. + * + * A writer in build mode diverts writes to a builder buffer that allocates as + * needed. Once the last map or array being built is completed, the deferred + * message is composed with computed array and map sizes into the writer. + * Builder maps and arrays are encoded exactly the same as ordinary maps and + * arrays in the final message. + * + * This indirect encoding is costly, as it incurs at least an extra copy of all + * data written within a builder (but not additional copies for nested + * builders.) Expect a speed penalty of half or more. + * + * A good strategy is to use this during early development when your messages + * are constantly changing, and then closer to release when your message + * formats have stabilized, replace all your build calls with start calls with + * pre-computed sizes. Or don't, if you find the builder has little impact on + * performance, because even with builders MPack is extremely fast. + * + * @note When an array or map starts being built, nothing will be flushed + * until it is completed. If you are building a large message that + * does not fit in the output stream, you won't get an error about it + * until everything is written. + * + * @see mpack_complete_map() to complete this map + * @see mpack_start_map() if you already know the size of the map + */ +void mpack_build_map(struct mpack_writer_t* writer); + +/** + * Completes an array being built. + * + * @see mpack_build_array() + */ +void mpack_complete_array(struct mpack_writer_t* writer); + +/** + * Completes a map being built. + * + * @see mpack_build_map() + */ +void mpack_complete_map(struct mpack_writer_t* writer); + +/** + * @} + */ + +/** + * @name Data Helpers + * @{ + */ + +/** + * Writes a string. + * + * To stream a string in chunks, use mpack_start_str() instead. + * + * MPack does not care about the underlying encoding, but UTF-8 is highly + * recommended, especially for compatibility with JSON. You should consider + * calling mpack_write_utf8() instead, especially if you will be reading + * it back as UTF-8. + * + * You should not call mpack_finish_str() after calling this; this + * performs both start and finish. + */ +void mpack_write_str(mpack_writer_t* writer, const char* str, uint32_t length); + +/** + * Writes a string, ensuring that it is valid UTF-8. + * + * This does not accept any UTF-8 variant such as Modified UTF-8, CESU-8 or + * WTF-8. Only pure UTF-8 is allowed. + * + * You should not call mpack_finish_str() after calling this; this + * performs both start and finish. + * + * @throws mpack_error_invalid if the string is not valid UTF-8 + */ +void mpack_write_utf8(mpack_writer_t* writer, const char* str, uint32_t length); + +/** + * Writes a null-terminated string. (The null-terminator is not written.) + * + * MPack does not care about the underlying encoding, but UTF-8 is highly + * recommended, especially for compatibility with JSON. You should consider + * calling mpack_write_utf8_cstr() instead, especially if you will be reading + * it back as UTF-8. + * + * You should not call mpack_finish_str() after calling this; this + * performs both start and finish. + */ +void mpack_write_cstr(mpack_writer_t* writer, const char* cstr); + +/** + * Writes a null-terminated string, or a nil node if the given cstr pointer + * is NULL. (The null-terminator is not written.) + * + * MPack does not care about the underlying encoding, but UTF-8 is highly + * recommended, especially for compatibility with JSON. You should consider + * calling mpack_write_utf8_cstr_or_nil() instead, especially if you will + * be reading it back as UTF-8. + * + * You should not call mpack_finish_str() after calling this; this + * performs both start and finish. + */ +void mpack_write_cstr_or_nil(mpack_writer_t* writer, const char* cstr); + +/** + * Writes a null-terminated string, ensuring that it is valid UTF-8. (The + * null-terminator is not written.) + * + * This does not accept any UTF-8 variant such as Modified UTF-8, CESU-8 or + * WTF-8. Only pure UTF-8 is allowed. + * + * You should not call mpack_finish_str() after calling this; this + * performs both start and finish. + * + * @throws mpack_error_invalid if the string is not valid UTF-8 + */ +void mpack_write_utf8_cstr(mpack_writer_t* writer, const char* cstr); + +/** + * Writes a null-terminated string ensuring that it is valid UTF-8, or + * writes nil if the given cstr pointer is NULL. (The null-terminator + * is not written.) + * + * This does not accept any UTF-8 variant such as Modified UTF-8, CESU-8 or + * WTF-8. Only pure UTF-8 is allowed. + * + * You should not call mpack_finish_str() after calling this; this + * performs both start and finish. + * + * @throws mpack_error_invalid if the string is not valid UTF-8 + */ +void mpack_write_utf8_cstr_or_nil(mpack_writer_t* writer, const char* cstr); + +/** + * Writes a binary blob. + * + * To stream a binary blob in chunks, use mpack_start_bin() instead. + * + * You should not call mpack_finish_bin() after calling this; this + * performs both start and finish. + */ +void mpack_write_bin(mpack_writer_t* writer, const char* data, uint32_t count); + +#if MPACK_EXTENSIONS +/** + * Writes an extension type. + * + * To stream an extension blob in chunks, use mpack_start_ext() instead. + * + * Extension types [0, 127] are available for application-specific types. Extension + * types [-128, -1] are reserved for future extensions of MessagePack. + * + * You should not call mpack_finish_ext() after calling this; this + * performs both start and finish. + * + * @note This requires @ref MPACK_EXTENSIONS. + */ +void mpack_write_ext(mpack_writer_t* writer, int8_t exttype, const char* data, uint32_t count); +#endif + +/** + * @} + */ + +/** + * @name Chunked Data Functions + * @{ + */ + +/** + * Opens a string. `count` bytes should be written with calls to + * mpack_write_bytes(), and mpack_finish_str() should be called + * when done. + * + * To write an entire string at once, use mpack_write_str() or + * mpack_write_cstr() instead. + * + * MPack does not care about the underlying encoding, but UTF-8 is highly + * recommended, especially for compatibility with JSON. + */ +void mpack_start_str(mpack_writer_t* writer, uint32_t count); + +/** + * Opens a binary blob. `count` bytes should be written with calls to + * mpack_write_bytes(), and mpack_finish_bin() should be called + * when done. + */ +void mpack_start_bin(mpack_writer_t* writer, uint32_t count); + +#if MPACK_EXTENSIONS +/** + * Opens an extension type. `count` bytes should be written with calls + * to mpack_write_bytes(), and mpack_finish_ext() should be called + * when done. + * + * Extension types [0, 127] are available for application-specific types. Extension + * types [-128, -1] are reserved for future extensions of MessagePack. + * + * @note This requires @ref MPACK_EXTENSIONS. + */ +void mpack_start_ext(mpack_writer_t* writer, int8_t exttype, uint32_t count); +#endif + +/** + * Writes a portion of bytes for a string, binary blob or extension type which + * was opened by mpack_write_tag() or one of the mpack_start_*() functions. + * + * This can be called multiple times to write the data in chunks, as long as + * the total amount of bytes written matches the count given when the compound + * type was started. + * + * The corresponding mpack_finish_*() function must be called when done. + * + * To write an entire string, binary blob or extension type at + * once, use one of the mpack_write_*() functions instead. + * + * @see mpack_write_tag() + * @see mpack_start_str() + * @see mpack_start_bin() + * @see mpack_start_ext() + * @see mpack_finish_str() + * @see mpack_finish_bin() + * @see mpack_finish_ext() + * @see mpack_finish_type() + */ +void mpack_write_bytes(mpack_writer_t* writer, const char* data, size_t count); + +/** + * Finishes writing a string. + * + * This should be called only after a corresponding call to mpack_start_str() + * and after the string bytes are written with mpack_write_bytes(). + * + * This will track writes to ensure that the correct number of elements are written. + * + * @see mpack_start_str() + * @see mpack_write_bytes() + */ +MPACK_INLINE void mpack_finish_str(mpack_writer_t* writer) { + mpack_writer_track_pop(writer, mpack_type_str); +} + +/** + * Finishes writing a binary blob. + * + * This should be called only after a corresponding call to mpack_start_bin() + * and after the binary bytes are written with mpack_write_bytes(). + * + * This will track writes to ensure that the correct number of bytes are written. + * + * @see mpack_start_bin() + * @see mpack_write_bytes() + */ +MPACK_INLINE void mpack_finish_bin(mpack_writer_t* writer) { + mpack_writer_track_pop(writer, mpack_type_bin); +} + +#if MPACK_EXTENSIONS +/** + * Finishes writing an extended type binary data blob. + * + * This should be called only after a corresponding call to mpack_start_bin() + * and after the binary bytes are written with mpack_write_bytes(). + * + * This will track writes to ensure that the correct number of bytes are written. + * + * @note This requires @ref MPACK_EXTENSIONS. + * + * @see mpack_start_ext() + * @see mpack_write_bytes() + */ +MPACK_INLINE void mpack_finish_ext(mpack_writer_t* writer) { + mpack_writer_track_pop(writer, mpack_type_ext); +} +#endif + +/** + * Finishes writing the given compound type. + * + * This will track writes to ensure that the correct number of elements + * or bytes are written. + * + * This can be called with the appropriate type instead the corresponding + * mpack_finish_*() function if you want to finish a dynamic type. + */ +MPACK_INLINE void mpack_finish_type(mpack_writer_t* writer, mpack_type_t type) { + mpack_writer_track_pop(writer, type); +} + +/** + * @} + */ + +#if MPACK_HAS_GENERIC && !defined(__cplusplus) + +/** + * @name Type-Generic Writers + * @{ + */ + +/** + * @def mpack_write(writer, value) + * + * Type-generic writer for primitive types. + * + * The compiler will dispatch to an appropriate write function based + * on the type of the @a value parameter. + * + * @note This requires C11 `_Generic` support. (A set of inline overloads + * are used in C++ to provide the same functionality.) + * + * @warning In C11, the indentifiers `true`, `false` and `NULL` are + * all of type `int`, not `bool` or `void*`! They will emit unexpected + * types when passed uncast, so be careful when using them. + */ +#if MPACK_FLOAT + #define MPACK_WRITE_GENERIC_FLOAT float: mpack_write_float, +#else + #define MPACK_WRITE_GENERIC_FLOAT /*nothing*/ +#endif +#if MPACK_DOUBLE + #define MPACK_WRITE_GENERIC_DOUBLE double: mpack_write_double, +#else + #define MPACK_WRITE_GENERIC_DOUBLE /*nothing*/ +#endif +#define mpack_write(writer, value) \ + _Generic(((void)0, value), \ + int8_t: mpack_write_i8, \ + int16_t: mpack_write_i16, \ + int32_t: mpack_write_i32, \ + int64_t: mpack_write_i64, \ + uint8_t: mpack_write_u8, \ + uint16_t: mpack_write_u16, \ + uint32_t: mpack_write_u32, \ + uint64_t: mpack_write_u64, \ + bool: mpack_write_bool, \ + MPACK_WRITE_GENERIC_FLOAT \ + MPACK_WRITE_GENERIC_DOUBLE \ + char *: mpack_write_cstr_or_nil, \ + const char *: mpack_write_cstr_or_nil \ + )(writer, value) + +/** + * @def mpack_write_kv(writer, key, value) + * + * Type-generic writer for key-value pairs of null-terminated string + * keys and primitive values. + * + * @warning @a writer may be evaluated multiple times. + * + * @warning In C11, the indentifiers `true`, `false` and `NULL` are + * all of type `int`, not `bool` or `void*`! They will emit unexpected + * types when passed uncast, so be careful when using them. + * + * @param writer The writer. + * @param key A null-terminated C string. + * @param value A primitive type supported by mpack_write(). + */ +#define mpack_write_kv(writer, key, value) do { \ + mpack_write_cstr(writer, key); \ + mpack_write(writer, value); \ +} while (0) + +/** + * @} + */ + +#endif // MPACK_HAS_GENERIC && !defined(__cplusplus) + +// The rest of this file contains C++ overloads, so we end extern "C" here. +MPACK_EXTERN_C_END + +#if defined(__cplusplus) || defined(MPACK_DOXYGEN) + +/** + * @name C++ write overloads + * @{ + */ + +/* + * C++ generic writers for primitive values + */ + +#ifdef MPACK_DOXYGEN +#undef mpack_write +#undef mpack_write_kv +#endif + +MPACK_INLINE void mpack_write(mpack_writer_t* writer, int8_t value) { + mpack_write_i8(writer, value); +} + +MPACK_INLINE void mpack_write(mpack_writer_t* writer, int16_t value) { + mpack_write_i16(writer, value); +} + +MPACK_INLINE void mpack_write(mpack_writer_t* writer, int32_t value) { + mpack_write_i32(writer, value); +} + +MPACK_INLINE void mpack_write(mpack_writer_t* writer, int64_t value) { + mpack_write_i64(writer, value); +} + +MPACK_INLINE void mpack_write(mpack_writer_t* writer, uint8_t value) { + mpack_write_u8(writer, value); +} + +MPACK_INLINE void mpack_write(mpack_writer_t* writer, uint16_t value) { + mpack_write_u16(writer, value); +} + +MPACK_INLINE void mpack_write(mpack_writer_t* writer, uint32_t value) { + mpack_write_u32(writer, value); +} + +MPACK_INLINE void mpack_write(mpack_writer_t* writer, uint64_t value) { + mpack_write_u64(writer, value); +} + +MPACK_INLINE void mpack_write(mpack_writer_t* writer, bool value) { + mpack_write_bool(writer, value); +} + +MPACK_INLINE void mpack_write(mpack_writer_t* writer, float value) { + mpack_write_float(writer, value); +} + +MPACK_INLINE void mpack_write(mpack_writer_t* writer, double value) { + mpack_write_double(writer, value); +} + +MPACK_INLINE void mpack_write(mpack_writer_t* writer, char *value) { + mpack_write_cstr_or_nil(writer, value); +} + +MPACK_INLINE void mpack_write(mpack_writer_t* writer, const char *value) { + mpack_write_cstr_or_nil(writer, value); +} + +/* C++ generic write for key-value pairs */ + +MPACK_INLINE void mpack_write_kv(mpack_writer_t* writer, const char *key, int8_t value) { + mpack_write_cstr(writer, key); + mpack_write_i8(writer, value); +} + +MPACK_INLINE void mpack_write_kv(mpack_writer_t* writer, const char *key, int16_t value) { + mpack_write_cstr(writer, key); + mpack_write_i16(writer, value); +} + +MPACK_INLINE void mpack_write_kv(mpack_writer_t* writer, const char *key, int32_t value) { + mpack_write_cstr(writer, key); + mpack_write_i32(writer, value); +} + +MPACK_INLINE void mpack_write_kv(mpack_writer_t* writer, const char *key, int64_t value) { + mpack_write_cstr(writer, key); + mpack_write_i64(writer, value); +} + +MPACK_INLINE void mpack_write_kv(mpack_writer_t* writer, const char *key, uint8_t value) { + mpack_write_cstr(writer, key); + mpack_write_u8(writer, value); +} + +MPACK_INLINE void mpack_write_kv(mpack_writer_t* writer, const char *key, uint16_t value) { + mpack_write_cstr(writer, key); + mpack_write_u16(writer, value); +} + +MPACK_INLINE void mpack_write_kv(mpack_writer_t* writer, const char *key, uint32_t value) { + mpack_write_cstr(writer, key); + mpack_write_u32(writer, value); +} + +MPACK_INLINE void mpack_write_kv(mpack_writer_t* writer, const char *key, uint64_t value) { + mpack_write_cstr(writer, key); + mpack_write_u64(writer, value); +} + +MPACK_INLINE void mpack_write_kv(mpack_writer_t* writer, const char *key, bool value) { + mpack_write_cstr(writer, key); + mpack_write_bool(writer, value); +} + +MPACK_INLINE void mpack_write_kv(mpack_writer_t* writer, const char *key, float value) { + mpack_write_cstr(writer, key); + mpack_write_float(writer, value); +} + +MPACK_INLINE void mpack_write_kv(mpack_writer_t* writer, const char *key, double value) { + mpack_write_cstr(writer, key); + mpack_write_double(writer, value); +} + +MPACK_INLINE void mpack_write_kv(mpack_writer_t* writer, const char *key, char *value) { + mpack_write_cstr(writer, key); + mpack_write_cstr_or_nil(writer, value); +} + +MPACK_INLINE void mpack_write_kv(mpack_writer_t* writer, const char *key, const char *value) { + mpack_write_cstr(writer, key); + mpack_write_cstr_or_nil(writer, value); +} + +/** + * @} + */ + +#endif /* __cplusplus */ + +/** + * @} + */ + +MPACK_SILENCE_WARNINGS_END + +#endif // MPACK_WRITER + +#endif + +/* mpack/mpack-reader.h.h */ + +/** + * @file + * + * Declares the core MPack Tag Reader. + */ + +#ifndef MPACK_READER_H +#define MPACK_READER_H 1 + +/* #include "mpack-common.h" */ + +MPACK_SILENCE_WARNINGS_BEGIN +MPACK_EXTERN_C_BEGIN + +#if MPACK_READER + +#if MPACK_READ_TRACKING +struct mpack_track_t; +#endif + +// The denominator to determine whether a read is a small +// fraction of the buffer size. +#define MPACK_READER_SMALL_FRACTION_DENOMINATOR 32 + +/** + * @defgroup reader Reader API + * + * The MPack Reader API contains functions for imperatively reading dynamically + * typed data from a MessagePack stream. + * + * See @ref docs/reader.md for examples. + * + * @note If you are not writing code for an embedded device (or otherwise do + * not need maximum performance with minimal memory usage), you should not use + * this. You probably want to use the @link node Node API@endlink instead. + * + * This forms the basis of the @link expect Expect API@endlink, which can be + * used to interpret the stream of elements in expected types and value ranges. + * + * @{ + */ + +/** + * @def MPACK_READER_MINIMUM_BUFFER_SIZE + * + * The minimum buffer size for a reader with a fill function. + */ +#define MPACK_READER_MINIMUM_BUFFER_SIZE 32 + +/** + * A buffered MessagePack decoder. + * + * The decoder wraps an existing buffer and, optionally, a fill function. + * This allows efficiently decoding data from existing memory buffers, files, + * streams, etc. + * + * All read operations are synchronous; they will block until the + * requested data is fully read, or an error occurs. + * + * This structure is opaque; its fields should not be accessed outside + * of MPack. + */ +typedef struct mpack_reader_t mpack_reader_t; + +/** + * The MPack reader's fill function. It should fill the buffer with at + * least one byte and at most the given @c count, returning the number + * of bytes written to the buffer. + * + * In case of error, it should flag an appropriate error on the reader + * (usually @ref mpack_error_io), or simply return zero. If zero is + * returned, mpack_error_io is raised. + * + * @note When reading from a stream, you should only copy and return + * the bytes that are immediately available. It is always safe to return + * less than the requested count as long as some non-zero number of bytes + * are read; if more bytes are needed, the read function will simply be + * called again. + * + * @see mpack_reader_context() + */ +typedef size_t (*mpack_reader_fill_t)(mpack_reader_t* reader, char* buffer, size_t count); + +/** + * The MPack reader's skip function. It should discard the given number + * of bytes from the source (for example by seeking forward.) + * + * In case of error, it should flag an appropriate error on the reader. + * + * @see mpack_reader_context() + */ +typedef void (*mpack_reader_skip_t)(mpack_reader_t* reader, size_t count); + +/** + * An error handler function to be called when an error is flagged on + * the reader. + * + * The error handler will only be called once on the first error flagged; + * any subsequent reads and errors are ignored, and the reader is + * permanently in that error state. + * + * MPack is safe against non-local jumps out of error handler callbacks. + * This means you are allowed to longjmp or throw an exception (in C++, + * Objective-C, or with SEH) out of this callback. + * + * Bear in mind when using longjmp that local non-volatile variables that + * have changed are undefined when setjmp() returns, so you can't put the + * reader on the stack in the same activation frame as the setjmp without + * declaring it volatile. + * + * You must still eventually destroy the reader. It is not destroyed + * automatically when an error is flagged. It is safe to destroy the + * reader within this error callback, but you will either need to perform + * a non-local jump, or store something in your context to identify + * that the reader is destroyed since any future accesses to it cause + * undefined behavior. + */ +typedef void (*mpack_reader_error_t)(mpack_reader_t* reader, mpack_error_t error); + +/** + * A teardown function to be called when the reader is destroyed. + */ +typedef void (*mpack_reader_teardown_t)(mpack_reader_t* reader); + +/* Hide internals from documentation */ +/** @cond */ + +struct mpack_reader_t { + void* context; /* Context for reader callbacks */ + mpack_reader_fill_t fill; /* Function to read bytes into the buffer */ + mpack_reader_error_t error_fn; /* Function to call on error */ + mpack_reader_teardown_t teardown; /* Function to teardown the context on destroy */ + mpack_reader_skip_t skip; /* Function to skip bytes from the source */ + + char* buffer; /* Writeable byte buffer */ + size_t size; /* Size of the buffer */ + + const char* data; /* Current data pointer (in the buffer, if it is used) */ + const char* end; /* The end of available data (in the buffer, if it is used) */ + + mpack_error_t error; /* Error state */ + + #if MPACK_READ_TRACKING + mpack_track_t track; /* Stack of map/array/str/bin/ext reads */ + #endif +}; + +/** @endcond */ + +/** + * @name Lifecycle Functions + * @{ + */ + +/** + * Initializes an MPack reader with the given buffer. The reader does + * not assume ownership of the buffer, but the buffer must be writeable + * if a fill function will be used to refill it. + * + * @param reader The MPack reader. + * @param buffer The buffer with which to read MessagePack data. + * @param size The size of the buffer. + * @param count The number of bytes already in the buffer. + */ +void mpack_reader_init(mpack_reader_t* reader, char* buffer, size_t size, size_t count); + +/** + * Initializes an MPack reader directly into an error state. Use this if you + * are writing a wrapper to mpack_reader_init() which can fail its setup. + */ +void mpack_reader_init_error(mpack_reader_t* reader, mpack_error_t error); + +/** + * Initializes an MPack reader to parse a pre-loaded contiguous chunk of data. The + * reader does not assume ownership of the data. + * + * @param reader The MPack reader. + * @param data The data to parse. + * @param count The number of bytes pointed to by data. + */ +void mpack_reader_init_data(mpack_reader_t* reader, const char* data, size_t count); + +#if MPACK_STDIO +/** + * Initializes an MPack reader that reads from a file. + * + * The file will be automatically opened and closed by the reader. + */ +void mpack_reader_init_filename(mpack_reader_t* reader, const char* filename); + +/** + * Deprecated. + * + * \deprecated Renamed to mpack_reader_init_filename(). + */ +MPACK_INLINE void mpack_reader_init_file(mpack_reader_t* reader, const char* filename) { + mpack_reader_init_filename(reader, filename); +} + +/** + * Initializes an MPack reader that reads from a libc FILE. This can be used to + * read from stdin, or from a file opened separately. + * + * @param reader The MPack reader. + * @param stdfile The FILE. + * @param close_when_done If true, fclose() will be called on the FILE when it + * is no longer needed. If false, the file will not be closed when + * reading is done. + * + * @warning The reader is buffered. It will read data in advance of parsing it, + * and it may read more data than it parsed. See mpack_reader_remaining() to + * access the extra data. + */ +void mpack_reader_init_stdfile(mpack_reader_t* reader, FILE* stdfile, bool close_when_done); +#endif + +/** + * @def mpack_reader_init_stack(reader) + * @hideinitializer + * + * Initializes an MPack reader using stack space as a buffer. A fill function + * should be added to the reader to fill the buffer. + * + * @see mpack_reader_set_fill + */ + +/** @cond */ +#define mpack_reader_init_stack_line_ex(line, reader) \ + char mpack_buf_##line[MPACK_STACK_SIZE]; \ + mpack_reader_init((reader), mpack_buf_##line, sizeof(mpack_buf_##line), 0) + +#define mpack_reader_init_stack_line(line, reader) \ + mpack_reader_init_stack_line_ex(line, reader) +/** @endcond */ + +#define mpack_reader_init_stack(reader) \ + mpack_reader_init_stack_line(__LINE__, (reader)) + +/** + * Cleans up the MPack reader, ensuring that all compound elements + * have been completely read. Returns the final error state of the + * reader. + * + * This will assert in tracking mode if the reader is not in an error + * state and has any incomplete reads. If you want to cancel reading + * in the middle of a document, you need to flag an error on the reader + * before destroying it (such as mpack_error_data). + * + * @see mpack_read_tag() + * @see mpack_reader_flag_error() + * @see mpack_error_data + */ +mpack_error_t mpack_reader_destroy(mpack_reader_t* reader); + +/** + * @} + */ + +/** + * @name Callbacks + * @{ + */ + +/** + * Sets the custom pointer to pass to the reader callbacks, such as fill + * or teardown. + * + * @param reader The MPack reader. + * @param context User data to pass to the reader callbacks. + * + * @see mpack_reader_context() + */ +MPACK_INLINE void mpack_reader_set_context(mpack_reader_t* reader, void* context) { + reader->context = context; +} + +/** + * Returns the custom context for reader callbacks. + * + * @see mpack_reader_set_context + * @see mpack_reader_set_fill + * @see mpack_reader_set_skip + */ +MPACK_INLINE void* mpack_reader_context(mpack_reader_t* reader) { + return reader->context; +} + +/** + * Sets the fill function to refill the data buffer when it runs out of data. + * + * If no fill function is used, truncated MessagePack data results in + * mpack_error_invalid (since the buffer is assumed to contain a + * complete MessagePack object.) + * + * If a fill function is used, truncated MessagePack data usually + * results in mpack_error_io (since the fill function fails to get + * the missing data.) + * + * This should normally be used with mpack_reader_set_context() to register + * a custom pointer to pass to the fill function. + * + * @param reader The MPack reader. + * @param fill The function to fetch additional data into the buffer. + */ +void mpack_reader_set_fill(mpack_reader_t* reader, mpack_reader_fill_t fill); + +/** + * Sets the skip function to discard bytes from the source stream. + * + * It's not necessary to implement this function. If the stream is not + * seekable, don't set a skip callback. The reader will fall back to + * using the fill function instead. + * + * This should normally be used with mpack_reader_set_context() to register + * a custom pointer to pass to the skip function. + * + * The skip function is ignored in size-optimized builds to reduce code + * size. Data will be skipped with the fill function when necessary. + * + * @param reader The MPack reader. + * @param skip The function to discard bytes from the source stream. + */ +void mpack_reader_set_skip(mpack_reader_t* reader, mpack_reader_skip_t skip); + +/** + * Sets the error function to call when an error is flagged on the reader. + * + * This should normally be used with mpack_reader_set_context() to register + * a custom pointer to pass to the error function. + * + * See the definition of mpack_reader_error_t for more information about + * what you can do from an error callback. + * + * @see mpack_reader_error_t + * @param reader The MPack reader. + * @param error_fn The function to call when an error is flagged on the reader. + */ +MPACK_INLINE void mpack_reader_set_error_handler(mpack_reader_t* reader, mpack_reader_error_t error_fn) { + reader->error_fn = error_fn; +} + +/** + * Sets the teardown function to call when the reader is destroyed. + * + * This should normally be used with mpack_reader_set_context() to register + * a custom pointer to pass to the teardown function. + * + * @param reader The MPack reader. + * @param teardown The function to call when the reader is destroyed. + */ +MPACK_INLINE void mpack_reader_set_teardown(mpack_reader_t* reader, mpack_reader_teardown_t teardown) { + reader->teardown = teardown; +} + +/** + * @} + */ + +/** + * @name Core Reader Functions + * @{ + */ + +/** + * Queries the error state of the MPack reader. + * + * If a reader is in an error state, you should discard all data since the + * last time the error flag was checked. The error flag cannot be cleared. + */ +MPACK_INLINE mpack_error_t mpack_reader_error(mpack_reader_t* reader) { + return reader->error; +} + +/** + * Places the reader in the given error state, calling the error callback if one + * is set. + * + * This allows you to externally flag errors, for example if you are validating + * data as you read it. + * + * If the reader is already in an error state, this call is ignored and no + * error callback is called. + */ +void mpack_reader_flag_error(mpack_reader_t* reader, mpack_error_t error); + +/** + * Places the reader in the given error state if the given error is not mpack_ok, + * returning the resulting error state of the reader. + * + * This allows you to externally flag errors, for example if you are validating + * data as you read it. + * + * If the given error is mpack_ok or if the reader is already in an error state, + * this call is ignored and the actual error state of the reader is returned. + */ +MPACK_INLINE mpack_error_t mpack_reader_flag_if_error(mpack_reader_t* reader, mpack_error_t error) { + if (error != mpack_ok) + mpack_reader_flag_error(reader, error); + return mpack_reader_error(reader); +} + +/** + * Returns bytes left in the reader's buffer. + * + * If you are done reading MessagePack data but there is other interesting data + * following it, the reader may have buffered too much data. The number of bytes + * remaining in the buffer and a pointer to the position of those bytes can be + * queried here. + * + * If you know the length of the MPack chunk beforehand, it's better to instead + * have your fill function limit the data it reads so that the reader does not + * have extra data. In this case you can simply check that this returns zero. + * + * Returns 0 if the reader is in an error state. + * + * @param reader The MPack reader from which to query remaining data. + * @param data [out] A pointer to the remaining data, or NULL. + * @return The number of bytes remaining in the buffer. + */ +size_t mpack_reader_remaining(mpack_reader_t* reader, const char** data); + +/** + * Reads a MessagePack object header (an MPack tag.) + * + * If an error occurs, the reader is placed in an error state and a + * nil tag is returned. If the reader is already in an error state, + * a nil tag is returned. + * + * If the type is compound (i.e. is a map, array, string, binary or + * extension type), additional reads are required to get the contained + * data, and the corresponding done function must be called when done. + * + * @note Maps in JSON are unordered, so it is recommended not to expect + * a specific ordering for your map values in case your data is converted + * to/from JSON. + * + * @see mpack_read_bytes() + * @see mpack_done_array() + * @see mpack_done_map() + * @see mpack_done_str() + * @see mpack_done_bin() + * @see mpack_done_ext() + */ +mpack_tag_t mpack_read_tag(mpack_reader_t* reader); + +/** + * Parses the next MessagePack object header (an MPack tag) without + * advancing the reader. + * + * If an error occurs, the reader is placed in an error state and a + * nil tag is returned. If the reader is already in an error state, + * a nil tag is returned. + * + * @note Maps in JSON are unordered, so it is recommended not to expect + * a specific ordering for your map values in case your data is converted + * to/from JSON. + * + * @see mpack_read_tag() + * @see mpack_discard() + */ +mpack_tag_t mpack_peek_tag(mpack_reader_t* reader); + +/** + * @} + */ + +/** + * @name String and Data Functions + * @{ + */ + +/** + * Skips bytes from the underlying stream. This is used only to + * skip the contents of a string, binary blob or extension object. + */ +void mpack_skip_bytes(mpack_reader_t* reader, size_t count); + +/** + * Reads bytes from a string, binary blob or extension object, copying + * them into the given buffer. + * + * A str, bin or ext must have been opened by a call to mpack_read_tag() + * which yielded one of these types, or by a call to an expect function + * such as mpack_expect_str() or mpack_expect_bin(). + * + * If an error occurs, the buffer contents are undefined. + * + * This can be called multiple times for a single str, bin or ext + * to read the data in chunks. The total data read must add up + * to the size of the object. + * + * @param reader The MPack reader + * @param p The buffer in which to copy the bytes + * @param count The number of bytes to read + */ +void mpack_read_bytes(mpack_reader_t* reader, char* p, size_t count); + +/** + * Reads bytes from a string, ensures that the string is valid UTF-8, + * and copies the bytes into the given buffer. + * + * A string must have been opened by a call to mpack_read_tag() which + * yielded a string, or by a call to an expect function such as + * mpack_expect_str(). + * + * The given byte count must match the complete size of the string as + * returned by the tag or expect function. You must ensure that the + * buffer fits the data. + * + * This does not accept any UTF-8 variant such as Modified UTF-8, CESU-8 or + * WTF-8. Only pure UTF-8 is allowed. + * + * If an error occurs, the buffer contents are undefined. + * + * Unlike mpack_read_bytes(), this cannot be used to read the data in + * chunks (since this might split a character's UTF-8 bytes, and the + * reader does not keep track of the UTF-8 decoding state between reads.) + * + * @throws mpack_error_type if the string contains invalid UTF-8. + */ +void mpack_read_utf8(mpack_reader_t* reader, char* p, size_t byte_count); + +/** + * Reads bytes from a string, ensures that the string contains no NUL + * bytes, copies the bytes into the given buffer and adds a null-terminator. + * + * A string must have been opened by a call to mpack_read_tag() which + * yielded a string, or by a call to an expect function such as + * mpack_expect_str(). + * + * The given byte count must match the size of the string as returned + * by the tag or expect function. The string will only be copied if + * the buffer is large enough to store it. + * + * If an error occurs, the buffer will contain an empty string. + * + * @note If you know the object will be a string before reading it, + * it is highly recommended to use mpack_expect_cstr() instead. + * Alternatively you could use mpack_peek_tag() and call + * mpack_expect_cstr() if it's a string. + * + * @throws mpack_error_too_big if the string plus null-terminator is larger than the given buffer size + * @throws mpack_error_type if the string contains a null byte. + * + * @see mpack_peek_tag() + * @see mpack_expect_cstr() + * @see mpack_expect_utf8_cstr() + */ +void mpack_read_cstr(mpack_reader_t* reader, char* buf, size_t buffer_size, size_t byte_count); + +/** + * Reads bytes from a string, ensures that the string is valid UTF-8 + * with no NUL bytes, copies the bytes into the given buffer and adds a + * null-terminator. + * + * A string must have been opened by a call to mpack_read_tag() which + * yielded a string, or by a call to an expect function such as + * mpack_expect_str(). + * + * The given byte count must match the size of the string as returned + * by the tag or expect function. The string will only be copied if + * the buffer is large enough to store it. + * + * This does not accept any UTF-8 variant such as Modified UTF-8, CESU-8 or + * WTF-8. Only pure UTF-8 is allowed, but without the NUL character, since + * it cannot be represented in a null-terminated string. + * + * If an error occurs, the buffer will contain an empty string. + * + * @note If you know the object will be a string before reading it, + * it is highly recommended to use mpack_expect_utf8_cstr() instead. + * Alternatively you could use mpack_peek_tag() and call + * mpack_expect_utf8_cstr() if it's a string. + * + * @throws mpack_error_too_big if the string plus null-terminator is larger than the given buffer size + * @throws mpack_error_type if the string contains invalid UTF-8 or a null byte. + * + * @see mpack_peek_tag() + * @see mpack_expect_utf8_cstr() + */ +void mpack_read_utf8_cstr(mpack_reader_t* reader, char* buf, size_t buffer_size, size_t byte_count); + +#ifdef MPACK_MALLOC +/** @cond */ +// This can optionally add a null-terminator, but it does not check +// whether the data contains null bytes. This must be done separately +// in a cstring read function (possibly as part of a UTF-8 check.) +char* mpack_read_bytes_alloc_impl(mpack_reader_t* reader, size_t count, bool null_terminated); +/** @endcond */ + +/** + * Reads bytes from a string, binary blob or extension object, allocating + * storage for them and returning the allocated pointer. + * + * The allocated string must be freed with MPACK_FREE() (or simply free() + * if MPack's allocator hasn't been customized.) + * + * Returns NULL if any error occurs, or if count is zero. + */ +MPACK_INLINE char* mpack_read_bytes_alloc(mpack_reader_t* reader, size_t count) { + return mpack_read_bytes_alloc_impl(reader, count, false); +} +#endif + +/** + * Reads bytes from a string, binary blob or extension object in-place in + * the buffer. This can be used to avoid copying the data. + * + * A str, bin or ext must have been opened by a call to mpack_read_tag() + * which yielded one of these types, or by a call to an expect function + * such as mpack_expect_str() or mpack_expect_bin(). + * + * If the bytes are from a string, the string is not null-terminated! Use + * mpack_read_cstr() to copy the string into a buffer and add a null-terminator. + * + * The returned pointer is invalidated on the next read, or when the buffer + * is destroyed. + * + * The reader will move data around in the buffer if needed to ensure that + * the pointer can always be returned, so this should only be used if + * count is very small compared to the buffer size. If you need to check + * whether a small size is reasonable (for example you intend to handle small and + * large sizes differently), you can call mpack_should_read_bytes_inplace(). + * + * This can be called multiple times for a single str, bin or ext + * to read the data in chunks. The total data read must add up + * to the size of the object. + * + * NULL is returned if the reader is in an error state. + * + * @throws mpack_error_too_big if the requested size is larger than the buffer size + * + * @see mpack_should_read_bytes_inplace() + */ +const char* mpack_read_bytes_inplace(mpack_reader_t* reader, size_t count); + +/** + * Reads bytes from a string in-place in the buffer and ensures they are + * valid UTF-8. This can be used to avoid copying the data. + * + * A string must have been opened by a call to mpack_read_tag() which + * yielded a string, or by a call to an expect function such as + * mpack_expect_str(). + * + * The string is not null-terminated! Use mpack_read_utf8_cstr() to + * copy the string into a buffer and add a null-terminator. + * + * The returned pointer is invalidated on the next read, or when the buffer + * is destroyed. + * + * The reader will move data around in the buffer if needed to ensure that + * the pointer can always be returned, so this should only be used if + * count is very small compared to the buffer size. If you need to check + * whether a small size is reasonable (for example you intend to handle small and + * large sizes differently), you can call mpack_should_read_bytes_inplace(). + * + * This does not accept any UTF-8 variant such as Modified UTF-8, CESU-8 or + * WTF-8. Only pure UTF-8 is allowed. + * + * Unlike mpack_read_bytes_inplace(), this cannot be used to read the data in + * chunks (since this might split a character's UTF-8 bytes, and the + * reader does not keep track of the UTF-8 decoding state between reads.) + * + * NULL is returned if the reader is in an error state. + * + * @throws mpack_error_type if the string contains invalid UTF-8 + * @throws mpack_error_too_big if the requested size is larger than the buffer size + * + * @see mpack_should_read_bytes_inplace() + */ +const char* mpack_read_utf8_inplace(mpack_reader_t* reader, size_t count); + +/** + * Returns true if it's a good idea to read the given number of bytes + * in-place. + * + * If the read will be larger than some small fraction of the buffer size, + * this will return false to avoid shuffling too much data back and forth + * in the buffer. + * + * Use this if you're expecting arbitrary size data, and you want to read + * in-place for the best performance when possible but will fall back to + * a normal read if the data is too large. + * + * @see mpack_read_bytes_inplace() + */ +MPACK_INLINE bool mpack_should_read_bytes_inplace(mpack_reader_t* reader, size_t count) { + return (reader->size == 0 || count <= reader->size / MPACK_READER_SMALL_FRACTION_DENOMINATOR); +} + +#if MPACK_EXTENSIONS +/** + * Reads a timestamp contained in an ext object of the given size, closing the + * ext type. + * + * An ext object of exttype @ref MPACK_EXTTYPE_TIMESTAMP must have been opened + * by a call to e.g. mpack_read_tag() or mpack_expect_ext(). + * + * You must NOT call mpack_done_ext() after calling this. A timestamp ext + * object can only contain a single timestamp value, so this calls + * mpack_done_ext() automatically. + * + * @note This requires @ref MPACK_EXTENSIONS. + * + * @throws mpack_error_invalid if the size is not one of the supported + * timestamp sizes, or if the nanoseconds are out of range. + */ +mpack_timestamp_t mpack_read_timestamp(mpack_reader_t* reader, size_t size); +#endif + +/** + * @} + */ + +/** + * @name Core Reader Functions + * @{ + */ + +#if MPACK_READ_TRACKING +/** + * Finishes reading the given type. + * + * This will track reads to ensure that the correct number of elements + * or bytes are read. + */ +void mpack_done_type(mpack_reader_t* reader, mpack_type_t type); +#else +MPACK_INLINE void mpack_done_type(mpack_reader_t* reader, mpack_type_t type) { + MPACK_UNUSED(reader); + MPACK_UNUSED(type); +} +#endif + +/** + * Finishes reading an array. + * + * This will track reads to ensure that the correct number of elements are read. + */ +MPACK_INLINE void mpack_done_array(mpack_reader_t* reader) { + mpack_done_type(reader, mpack_type_array); +} + +/** + * @fn mpack_done_map(mpack_reader_t* reader) + * + * Finishes reading a map. + * + * This will track reads to ensure that the correct number of elements are read. + */ +MPACK_INLINE void mpack_done_map(mpack_reader_t* reader) { + mpack_done_type(reader, mpack_type_map); +} + +/** + * @fn mpack_done_str(mpack_reader_t* reader) + * + * Finishes reading a string. + * + * This will track reads to ensure that the correct number of bytes are read. + */ +MPACK_INLINE void mpack_done_str(mpack_reader_t* reader) { + mpack_done_type(reader, mpack_type_str); +} + +/** + * @fn mpack_done_bin(mpack_reader_t* reader) + * + * Finishes reading a binary data blob. + * + * This will track reads to ensure that the correct number of bytes are read. + */ +MPACK_INLINE void mpack_done_bin(mpack_reader_t* reader) { + mpack_done_type(reader, mpack_type_bin); +} + +#if MPACK_EXTENSIONS +/** + * @fn mpack_done_ext(mpack_reader_t* reader) + * + * Finishes reading an extended type binary data blob. + * + * This will track reads to ensure that the correct number of bytes are read. + * + * @note This requires @ref MPACK_EXTENSIONS. + */ +MPACK_INLINE void mpack_done_ext(mpack_reader_t* reader) { + mpack_done_type(reader, mpack_type_ext); +} +#endif + +/** + * Reads and discards the next object. This will read and discard all + * contained data as well if it is a compound type. + */ +void mpack_discard(mpack_reader_t* reader); + +/** + * @} + */ + +/** @cond */ + +#if MPACK_DEBUG && MPACK_STDIO +/** + * @name Debugging Functions + * @{ + */ +/* + * Converts a blob of MessagePack to a pseudo-JSON string for debugging + * purposes, placing the result in the given buffer with a null-terminator. + * + * If the buffer does not have enough space, the result will be truncated (but + * it is guaranteed to be null-terminated.) + * + * This is only available in debug mode, and only if stdio is available (since + * it uses snprintf().) It's strictly for debugging purposes. + */ +void mpack_print_data_to_buffer(const char* data, size_t data_size, char* buffer, size_t buffer_size); + +/* + * Converts a node to pseudo-JSON for debugging purposes, calling the given + * callback as many times as is necessary to output the character data. + * + * No null-terminator or trailing newline will be written. + * + * This is only available in debug mode, and only if stdio is available (since + * it uses snprintf().) It's strictly for debugging purposes. + */ +void mpack_print_data_to_callback(const char* data, size_t size, mpack_print_callback_t callback, void* context); + +/* + * Converts a blob of MessagePack to pseudo-JSON for debugging purposes + * and pretty-prints it to the given file. + */ +void mpack_print_data_to_file(const char* data, size_t len, FILE* file); + +/* + * Converts a blob of MessagePack to pseudo-JSON for debugging purposes + * and pretty-prints it to stdout. + */ +MPACK_INLINE void mpack_print_data_to_stdout(const char* data, size_t len) { + mpack_print_data_to_file(data, len, stdout); +} + +/* + * Converts the MessagePack contained in the given `FILE*` to pseudo-JSON for + * debugging purposes, calling the given callback as many times as is necessary + * to output the character data. + */ +void mpack_print_stdfile_to_callback(FILE* file, mpack_print_callback_t callback, void* context); + +/* + * Deprecated. + * + * \deprecated Renamed to mpack_print_data_to_stdout(). + */ +MPACK_INLINE void mpack_print(const char* data, size_t len) { + mpack_print_data_to_stdout(data, len); +} + +/** + * @} + */ +#endif + +/** @endcond */ + +/** + * @} + */ + + + +#if MPACK_INTERNAL + +bool mpack_reader_ensure_straddle(mpack_reader_t* reader, size_t count); + +/* + * Ensures there are at least @c count bytes left in the + * data, raising an error and returning false if more + * data cannot be made available. + */ +MPACK_INLINE bool mpack_reader_ensure(mpack_reader_t* reader, size_t count) { + mpack_assert(count != 0, "cannot ensure zero bytes!"); + mpack_assert(reader->error == mpack_ok, "reader cannot be in an error state!"); + + if (count <= (size_t)(reader->end - reader->data)) + return true; + return mpack_reader_ensure_straddle(reader, count); +} + +void mpack_read_native_straddle(mpack_reader_t* reader, char* p, size_t count); + +// Reads count bytes into p, deferring to mpack_read_native_straddle() if more +// bytes are needed than are available in the buffer. +MPACK_INLINE void mpack_read_native(mpack_reader_t* reader, char* p, size_t count) { + mpack_assert(count == 0 || p != NULL, "data pointer for %i bytes is NULL", (int)count); + + if (count > (size_t)(reader->end - reader->data)) { + mpack_read_native_straddle(reader, p, count); + } else { + mpack_memcpy(p, reader->data, count); + reader->data += count; + } +} + +#if MPACK_READ_TRACKING +#define MPACK_READER_TRACK(reader, error_expr) \ + (((reader)->error == mpack_ok) ? mpack_reader_flag_if_error((reader), (error_expr)) : (reader)->error) +#else +#define MPACK_READER_TRACK(reader, error_expr) (MPACK_UNUSED(reader), mpack_ok) +#endif + +MPACK_INLINE mpack_error_t mpack_reader_track_element(mpack_reader_t* reader) { + return MPACK_READER_TRACK(reader, mpack_track_element(&reader->track, true)); +} + +MPACK_INLINE mpack_error_t mpack_reader_track_peek_element(mpack_reader_t* reader) { + return MPACK_READER_TRACK(reader, mpack_track_peek_element(&reader->track, true)); +} + +MPACK_INLINE mpack_error_t mpack_reader_track_bytes(mpack_reader_t* reader, size_t count) { + MPACK_UNUSED(count); + return MPACK_READER_TRACK(reader, mpack_track_bytes(&reader->track, true, count)); +} + +MPACK_INLINE mpack_error_t mpack_reader_track_str_bytes_all(mpack_reader_t* reader, size_t count) { + MPACK_UNUSED(count); + return MPACK_READER_TRACK(reader, mpack_track_str_bytes_all(&reader->track, true, count)); +} + +#endif + + + +#endif + +MPACK_EXTERN_C_END +MPACK_SILENCE_WARNINGS_END + +#endif + + +/* mpack/mpack-expect.h.h */ + +/** + * @file + * + * Declares the MPack static Expect API. + */ + +#ifndef MPACK_EXPECT_H +#define MPACK_EXPECT_H 1 + +/* #include "mpack-reader.h" */ + +MPACK_SILENCE_WARNINGS_BEGIN +MPACK_EXTERN_C_BEGIN + +#if MPACK_EXPECT + +#if !MPACK_READER +#error "MPACK_EXPECT requires MPACK_READER." +#endif + +/** + * @defgroup expect Expect API + * + * The MPack Expect API allows you to easily read MessagePack data when you + * expect it to follow a predefined schema. + * + * @note If you are not writing code for an embedded device (or otherwise do + * not need maximum performance with minimal memory usage), you should not use + * this. You probably want to use the @link node Node API@endlink instead. + * + * See @ref docs/expect.md for examples. + * + * The main purpose of the Expect API is convenience, so the API is lax. It + * automatically converts between similar types where there is no loss of + * precision. + * + * When using any of the expect functions, if the type or value of what was + * read does not match what is expected, @ref mpack_error_type is raised. + * + * @{ + */ + +/** + * @name Basic Number Functions + * @{ + */ + +/** + * Reads an 8-bit unsigned integer. + * + * The underlying type may be an integer type of any size and signedness, + * as long as the value can be represented in an 8-bit unsigned int. + * + * Returns zero if an error occurs. + */ +uint8_t mpack_expect_u8(mpack_reader_t* reader); + +/** + * Reads a 16-bit unsigned integer. + * + * The underlying type may be an integer type of any size and signedness, + * as long as the value can be represented in a 16-bit unsigned int. + * + * Returns zero if an error occurs. + */ +uint16_t mpack_expect_u16(mpack_reader_t* reader); + +/** + * Reads a 32-bit unsigned integer. + * + * The underlying type may be an integer type of any size and signedness, + * as long as the value can be represented in a 32-bit unsigned int. + * + * Returns zero if an error occurs. + */ +uint32_t mpack_expect_u32(mpack_reader_t* reader); + +/** + * Reads a 64-bit unsigned integer. + * + * The underlying type may be an integer type of any size and signedness, + * as long as the value can be represented in a 64-bit unsigned int. + * + * Returns zero if an error occurs. + */ +uint64_t mpack_expect_u64(mpack_reader_t* reader); + +/** + * Reads an 8-bit signed integer. + * + * The underlying type may be an integer type of any size and signedness, + * as long as the value can be represented in an 8-bit signed int. + * + * Returns zero if an error occurs. + */ +int8_t mpack_expect_i8(mpack_reader_t* reader); + +/** + * Reads a 16-bit signed integer. + * + * The underlying type may be an integer type of any size and signedness, + * as long as the value can be represented in a 16-bit signed int. + * + * Returns zero if an error occurs. + */ +int16_t mpack_expect_i16(mpack_reader_t* reader); + +/** + * Reads a 32-bit signed integer. + * + * The underlying type may be an integer type of any size and signedness, + * as long as the value can be represented in a 32-bit signed int. + * + * Returns zero if an error occurs. + */ +int32_t mpack_expect_i32(mpack_reader_t* reader); + +/** + * Reads a 64-bit signed integer. + * + * The underlying type may be an integer type of any size and signedness, + * as long as the value can be represented in a 64-bit signed int. + * + * Returns zero if an error occurs. + */ +int64_t mpack_expect_i64(mpack_reader_t* reader); + +#if MPACK_FLOAT +/** + * Reads a number, returning the value as a float. The underlying value can be an + * integer, float or double; the value is converted to a float. + * + * @note Reading a double or a large integer with this function can incur a + * loss of precision. + * + * @throws mpack_error_type if the underlying value is not a float, double or integer. + */ +float mpack_expect_float(mpack_reader_t* reader); +#endif + +#if MPACK_DOUBLE +/** + * Reads a number, returning the value as a double. The underlying value can be an + * integer, float or double; the value is converted to a double. + * + * @note Reading a very large integer with this function can incur a + * loss of precision. + * + * @throws mpack_error_type if the underlying value is not a float, double or integer. + */ +double mpack_expect_double(mpack_reader_t* reader); +#endif + +#if MPACK_FLOAT +/** + * Reads a float. The underlying value must be a float, not a double or an integer. + * This ensures no loss of precision can occur. + * + * @throws mpack_error_type if the underlying value is not a float. + */ +float mpack_expect_float_strict(mpack_reader_t* reader); +#endif + +#if MPACK_DOUBLE +/** + * Reads a double. The underlying value must be a float or double, not an integer. + * This ensures no loss of precision can occur. + * + * @throws mpack_error_type if the underlying value is not a float or double. + */ +double mpack_expect_double_strict(mpack_reader_t* reader); +#endif + +#if !MPACK_FLOAT +/** + * Reads a float as a raw uint32_t. The underlying value must be a float, not a + * double or an integer. + * + * @throws mpack_error_type if the underlying value is not a float. + */ +uint32_t mpack_expect_raw_float(mpack_reader_t* reader); +#endif + +#if !MPACK_DOUBLE +/** + * Reads a double as a raw uint64_t. The underlying value must be a double, not a + * float or an integer. + * + * @throws mpack_error_type if the underlying value is not a double. + */ +uint64_t mpack_expect_raw_double(mpack_reader_t* reader); +#endif + +/** + * @} + */ + +/** + * @name Ranged Number Functions + * @{ + */ + +/** + * Reads an 8-bit unsigned integer, ensuring that it falls within the given range. + * + * The underlying type may be an integer type of any size and signedness, + * as long as the value can be represented in an 8-bit unsigned int. + * + * Returns min_value if an error occurs. + */ +uint8_t mpack_expect_u8_range(mpack_reader_t* reader, uint8_t min_value, uint8_t max_value); + +/** + * Reads a 16-bit unsigned integer, ensuring that it falls within the given range. + * + * The underlying type may be an integer type of any size and signedness, + * as long as the value can be represented in a 16-bit unsigned int. + * + * Returns min_value if an error occurs. + */ +uint16_t mpack_expect_u16_range(mpack_reader_t* reader, uint16_t min_value, uint16_t max_value); + +/** + * Reads a 32-bit unsigned integer, ensuring that it falls within the given range. + * + * The underlying type may be an integer type of any size and signedness, + * as long as the value can be represented in a 32-bit unsigned int. + * + * Returns min_value if an error occurs. + */ +uint32_t mpack_expect_u32_range(mpack_reader_t* reader, uint32_t min_value, uint32_t max_value); + +/** + * Reads a 64-bit unsigned integer, ensuring that it falls within the given range. + * + * The underlying type may be an integer type of any size and signedness, + * as long as the value can be represented in a 64-bit unsigned int. + * + * Returns min_value if an error occurs. + */ +uint64_t mpack_expect_u64_range(mpack_reader_t* reader, uint64_t min_value, uint64_t max_value); + +/** + * Reads an unsigned integer, ensuring that it falls within the given range. + * + * The underlying type may be an integer type of any size and signedness, + * as long as the value can be represented in an unsigned int. + * + * Returns min_value if an error occurs. + */ +MPACK_INLINE unsigned int mpack_expect_uint_range(mpack_reader_t* reader, unsigned int min_value, unsigned int max_value) { + // This should be true at compile-time, so this just wraps the 32-bit + // function. We fallback to 64-bit if for some reason sizeof(int) isn't 4. + if (sizeof(unsigned int) == 4) + return (unsigned int)mpack_expect_u32_range(reader, (uint32_t)min_value, (uint32_t)max_value); + return (unsigned int)mpack_expect_u64_range(reader, min_value, max_value); +} + +/** + * Reads an 8-bit unsigned integer, ensuring that it is at most @a max_value. + * + * The underlying type may be an integer type of any size and signedness, + * as long as the value can be represented in an 8-bit unsigned int. + * + * Returns 0 if an error occurs. + */ +MPACK_INLINE uint8_t mpack_expect_u8_max(mpack_reader_t* reader, uint8_t max_value) { + return mpack_expect_u8_range(reader, 0, max_value); +} + +/** + * Reads a 16-bit unsigned integer, ensuring that it is at most @a max_value. + * + * The underlying type may be an integer type of any size and signedness, + * as long as the value can be represented in a 16-bit unsigned int. + * + * Returns 0 if an error occurs. + */ +MPACK_INLINE uint16_t mpack_expect_u16_max(mpack_reader_t* reader, uint16_t max_value) { + return mpack_expect_u16_range(reader, 0, max_value); +} + +/** + * Reads a 32-bit unsigned integer, ensuring that it is at most @a max_value. + * + * The underlying type may be an integer type of any size and signedness, + * as long as the value can be represented in a 32-bit unsigned int. + * + * Returns 0 if an error occurs. + */ +MPACK_INLINE uint32_t mpack_expect_u32_max(mpack_reader_t* reader, uint32_t max_value) { + return mpack_expect_u32_range(reader, 0, max_value); +} + +/** + * Reads a 64-bit unsigned integer, ensuring that it is at most @a max_value. + * + * The underlying type may be an integer type of any size and signedness, + * as long as the value can be represented in a 64-bit unsigned int. + * + * Returns 0 if an error occurs. + */ +MPACK_INLINE uint64_t mpack_expect_u64_max(mpack_reader_t* reader, uint64_t max_value) { + return mpack_expect_u64_range(reader, 0, max_value); +} + +/** + * Reads an unsigned integer, ensuring that it is at most @a max_value. + * + * The underlying type may be an integer type of any size and signedness, + * as long as the value can be represented in an unsigned int. + * + * Returns 0 if an error occurs. + */ +MPACK_INLINE unsigned int mpack_expect_uint_max(mpack_reader_t* reader, unsigned int max_value) { + return mpack_expect_uint_range(reader, 0, max_value); +} + +/** + * Reads an 8-bit signed integer, ensuring that it falls within the given range. + * + * The underlying type may be an integer type of any size and signedness, + * as long as the value can be represented in an 8-bit signed int. + * + * Returns min_value if an error occurs. + */ +int8_t mpack_expect_i8_range(mpack_reader_t* reader, int8_t min_value, int8_t max_value); + +/** + * Reads a 16-bit signed integer, ensuring that it falls within the given range. + * + * The underlying type may be an integer type of any size and signedness, + * as long as the value can be represented in a 16-bit signed int. + * + * Returns min_value if an error occurs. + */ +int16_t mpack_expect_i16_range(mpack_reader_t* reader, int16_t min_value, int16_t max_value); + +/** + * Reads a 32-bit signed integer, ensuring that it falls within the given range. + * + * The underlying type may be an integer type of any size and signedness, + * as long as the value can be represented in a 32-bit signed int. + * + * Returns min_value if an error occurs. + */ +int32_t mpack_expect_i32_range(mpack_reader_t* reader, int32_t min_value, int32_t max_value); + +/** + * Reads a 64-bit signed integer, ensuring that it falls within the given range. + * + * The underlying type may be an integer type of any size and signedness, + * as long as the value can be represented in a 64-bit signed int. + * + * Returns min_value if an error occurs. + */ +int64_t mpack_expect_i64_range(mpack_reader_t* reader, int64_t min_value, int64_t max_value); + +/** + * Reads a signed integer, ensuring that it falls within the given range. + * + * The underlying type may be an integer type of any size and signedness, + * as long as the value can be represented in a signed int. + * + * Returns min_value if an error occurs. + */ +MPACK_INLINE int mpack_expect_int_range(mpack_reader_t* reader, int min_value, int max_value) { + // This should be true at compile-time, so this just wraps the 32-bit + // function. We fallback to 64-bit if for some reason sizeof(int) isn't 4. + if (sizeof(int) == 4) + return (int)mpack_expect_i32_range(reader, (int32_t)min_value, (int32_t)max_value); + return (int)mpack_expect_i64_range(reader, min_value, max_value); +} + +/** + * Reads an 8-bit signed integer, ensuring that it is at least zero and at + * most @a max_value. + * + * The underlying type may be an integer type of any size and signedness, + * as long as the value can be represented in an 8-bit signed int. + * + * Returns 0 if an error occurs. + */ +MPACK_INLINE int8_t mpack_expect_i8_max(mpack_reader_t* reader, int8_t max_value) { + return mpack_expect_i8_range(reader, 0, max_value); +} + +/** + * Reads a 16-bit signed integer, ensuring that it is at least zero and at + * most @a max_value. + * + * The underlying type may be an integer type of any size and signedness, + * as long as the value can be represented in a 16-bit signed int. + * + * Returns 0 if an error occurs. + */ +MPACK_INLINE int16_t mpack_expect_i16_max(mpack_reader_t* reader, int16_t max_value) { + return mpack_expect_i16_range(reader, 0, max_value); +} + +/** + * Reads a 32-bit signed integer, ensuring that it is at least zero and at + * most @a max_value. + * + * The underlying type may be an integer type of any size and signedness, + * as long as the value can be represented in a 32-bit signed int. + * + * Returns 0 if an error occurs. + */ +MPACK_INLINE int32_t mpack_expect_i32_max(mpack_reader_t* reader, int32_t max_value) { + return mpack_expect_i32_range(reader, 0, max_value); +} + +/** + * Reads a 64-bit signed integer, ensuring that it is at least zero and at + * most @a max_value. + * + * The underlying type may be an integer type of any size and signedness, + * as long as the value can be represented in a 64-bit signed int. + * + * Returns 0 if an error occurs. + */ +MPACK_INLINE int64_t mpack_expect_i64_max(mpack_reader_t* reader, int64_t max_value) { + return mpack_expect_i64_range(reader, 0, max_value); +} + +/** + * Reads an int, ensuring that it is at least zero and at most @a max_value. + * + * The underlying type may be an integer type of any size and signedness, + * as long as the value can be represented in a signed int. + * + * Returns 0 if an error occurs. + */ +MPACK_INLINE int mpack_expect_int_max(mpack_reader_t* reader, int max_value) { + return mpack_expect_int_range(reader, 0, max_value); +} + +#if MPACK_FLOAT +/** + * Reads a number, ensuring that it falls within the given range and returning + * the value as a float. The underlying value can be an integer, float or + * double; the value is converted to a float. + * + * @note Reading a double or a large integer with this function can incur a + * loss of precision. + * + * @throws mpack_error_type if the underlying value is not a float, double or integer. + */ +float mpack_expect_float_range(mpack_reader_t* reader, float min_value, float max_value); +#endif + +#if MPACK_DOUBLE +/** + * Reads a number, ensuring that it falls within the given range and returning + * the value as a double. The underlying value can be an integer, float or + * double; the value is converted to a double. + * + * @note Reading a very large integer with this function can incur a + * loss of precision. + * + * @throws mpack_error_type if the underlying value is not a float, double or integer. + */ +double mpack_expect_double_range(mpack_reader_t* reader, double min_value, double max_value); +#endif + +/** + * @} + */ + + + +// These are additional Basic Number functions that wrap inline range functions. + +/** + * @name Basic Number Functions + * @{ + */ + +/** + * Reads an unsigned int. + * + * The underlying type may be an integer type of any size and signedness, + * as long as the value can be represented in an unsigned int. + * + * Returns zero if an error occurs. + */ +MPACK_INLINE unsigned int mpack_expect_uint(mpack_reader_t* reader) { + + // This should be true at compile-time, so this just wraps the 32-bit function. + if (sizeof(unsigned int) == 4) + return (unsigned int)mpack_expect_u32(reader); + + // Otherwise we wrap the max function to ensure it fits. + return (unsigned int)mpack_expect_u64_max(reader, MPACK_UINT_MAX); + +} + +/** + * Reads a signed int. + * + * The underlying type may be an integer type of any size and signedness, + * as long as the value can be represented in a signed int. + * + * Returns zero if an error occurs. + */ +MPACK_INLINE int mpack_expect_int(mpack_reader_t* reader) { + + // This should be true at compile-time, so this just wraps the 32-bit function. + if (sizeof(int) == 4) + return (int)mpack_expect_i32(reader); + + // Otherwise we wrap the range function to ensure it fits. + return (int)mpack_expect_i64_range(reader, MPACK_INT_MIN, MPACK_INT_MAX); + +} + +/** + * @} + */ + + + +/** + * @name Matching Number Functions + * @{ + */ + +/** + * Reads an unsigned integer, ensuring that it exactly matches the given value. + * + * mpack_error_type is raised if the value is not representable as an unsigned + * integer or if it does not exactly match the given value. + */ +void mpack_expect_uint_match(mpack_reader_t* reader, uint64_t value); + +/** + * Reads a signed integer, ensuring that it exactly matches the given value. + * + * mpack_error_type is raised if the value is not representable as a signed + * integer or if it does not exactly match the given value. + */ +void mpack_expect_int_match(mpack_reader_t* reader, int64_t value); + +/** + * @} + */ + +/** + * @name Other Basic Types + * @{ + */ + +/** + * Reads a nil, raising @ref mpack_error_type if the value is not nil. + */ +void mpack_expect_nil(mpack_reader_t* reader); + +/** + * Reads a boolean. + * + * @note Integers will raise mpack_error_type; the value must be strictly a boolean. + */ +bool mpack_expect_bool(mpack_reader_t* reader); + +/** + * Reads a boolean, raising @ref mpack_error_type if its value is not @c true. + */ +void mpack_expect_true(mpack_reader_t* reader); + +/** + * Reads a boolean, raising @ref mpack_error_type if its value is not @c false. + */ +void mpack_expect_false(mpack_reader_t* reader); + +/** + * @} + */ + +/** + * @name Extension Functions + * @{ + */ + +#if MPACK_EXTENSIONS +/** + * Reads a timestamp. + * + * @note This requires @ref MPACK_EXTENSIONS. + */ +mpack_timestamp_t mpack_expect_timestamp(mpack_reader_t* reader); + +/** + * Reads a timestamp in seconds, truncating the nanoseconds (if any). + * + * @note This requires @ref MPACK_EXTENSIONS. + */ +int64_t mpack_expect_timestamp_truncate(mpack_reader_t* reader); +#endif + +/** + * @} + */ + +/** + * @name Compound Types + * @{ + */ + +/** + * Reads the start of a map, returning its element count. + * + * A number of values follow equal to twice the element count of the map, + * alternating between keys and values. @ref mpack_done_map() must be called + * once all elements have been read. + * + * @note Maps in JSON are unordered, so it is recommended not to expect + * a specific ordering for your map values in case your data is converted + * to/from JSON. + * + * @warning This call is dangerous! It does not have a size limit, and it + * does not have any way of checking whether there is enough data in the + * message (since the data could be coming from a stream.) When looping + * through the map's contents, you must check for errors on each iteration + * of the loop. Otherwise an attacker could craft a message declaring a map + * of a billion elements which would throw your parsing code into an + * infinite loop! You should strongly consider using mpack_expect_map_max() + * with a safe maximum size instead. + * + * @throws mpack_error_type if the value is not a map. + */ +uint32_t mpack_expect_map(mpack_reader_t* reader); + +/** + * Reads the start of a map with a number of elements in the given range, returning + * its element count. + * + * A number of values follow equal to twice the element count of the map, + * alternating between keys and values. @ref mpack_done_map() must be called + * once all elements have been read. + * + * @note Maps in JSON are unordered, so it is recommended not to expect + * a specific ordering for your map values in case your data is converted + * to/from JSON. + * + * min_count is returned if an error occurs. + * + * @throws mpack_error_type if the value is not a map or if its size does + * not fall within the given range. + */ +uint32_t mpack_expect_map_range(mpack_reader_t* reader, uint32_t min_count, uint32_t max_count); + +/** + * Reads the start of a map with a number of elements at most @a max_count, + * returning its element count. + * + * A number of values follow equal to twice the element count of the map, + * alternating between keys and values. @ref mpack_done_map() must be called + * once all elements have been read. + * + * @note Maps in JSON are unordered, so it is recommended not to expect + * a specific ordering for your map values in case your data is converted + * to/from JSON. + * + * Zero is returned if an error occurs. + * + * @throws mpack_error_type if the value is not a map or if its size is + * greater than max_count. + */ +MPACK_INLINE uint32_t mpack_expect_map_max(mpack_reader_t* reader, uint32_t max_count) { + return mpack_expect_map_range(reader, 0, max_count); +} + +/** + * Reads the start of a map of the exact size given. + * + * A number of values follow equal to twice the element count of the map, + * alternating between keys and values. @ref mpack_done_map() must be called + * once all elements have been read. + * + * @note Maps in JSON are unordered, so it is recommended not to expect + * a specific ordering for your map values in case your data is converted + * to/from JSON. + * + * @throws mpack_error_type if the value is not a map or if its size + * does not match the given count. + */ +void mpack_expect_map_match(mpack_reader_t* reader, uint32_t count); + +/** + * Reads a nil node or the start of a map, returning whether a map was + * read and placing its number of key/value pairs in count. + * + * If a map was read, a number of values follow equal to twice the element count + * of the map, alternating between keys and values. @ref mpack_done_map() should + * also be called once all elements have been read (only if a map was read.) + * + * @note Maps in JSON are unordered, so it is recommended not to expect + * a specific ordering for your map values in case your data is converted + * to/from JSON. + * + * @warning This call is dangerous! It does not have a size limit, and it + * does not have any way of checking whether there is enough data in the + * message (since the data could be coming from a stream.) When looping + * through the map's contents, you must check for errors on each iteration + * of the loop. Otherwise an attacker could craft a message declaring a map + * of a billion elements which would throw your parsing code into an + * infinite loop! You should strongly consider using mpack_expect_map_max_or_nil() + * with a safe maximum size instead. + * + * @returns @c true if a map was read successfully; @c false if nil was read + * or an error occurred. + * @throws mpack_error_type if the value is not a nil or map. + */ +bool mpack_expect_map_or_nil(mpack_reader_t* reader, uint32_t* count); + +/** + * Reads a nil node or the start of a map with a number of elements at most + * max_count, returning whether a map was read and placing its number of + * key/value pairs in count. + * + * If a map was read, a number of values follow equal to twice the element count + * of the map, alternating between keys and values. @ref mpack_done_map() should + * anlso be called once all elements have been read (only if a map was read.) + * + * @note Maps in JSON are unordered, so it is recommended not to expect + * a specific ordering for your map values in case your data is converted + * to/from JSON. Consider using mpack_expect_key_cstr() or mpack_expect_key_uint() + * to switch on the key; see @ref docs/expect.md for examples. + * + * @returns @c true if a map was read successfully; @c false if nil was read + * or an error occurred. + * @throws mpack_error_type if the value is not a nil or map. + */ +bool mpack_expect_map_max_or_nil(mpack_reader_t* reader, uint32_t max_count, uint32_t* count); + +/** + * Reads the start of an array, returning its element count. + * + * A number of values follow equal to the element count of the array. + * @ref mpack_done_array() must be called once all elements have been read. + * + * @warning This call is dangerous! It does not have a size limit, and it + * does not have any way of checking whether there is enough data in the + * message (since the data could be coming from a stream.) When looping + * through the array's contents, you must check for errors on each iteration + * of the loop. Otherwise an attacker could craft a message declaring an array + * of a billion elements which would throw your parsing code into an + * infinite loop! You should strongly consider using mpack_expect_array_max() + * with a safe maximum size instead. + */ +uint32_t mpack_expect_array(mpack_reader_t* reader); + +/** + * Reads the start of an array with a number of elements in the given range, + * returning its element count. + * + * A number of values follow equal to the element count of the array. + * @ref mpack_done_array() must be called once all elements have been read. + * + * min_count is returned if an error occurs. + * + * @throws mpack_error_type if the value is not an array or if its size does + * not fall within the given range. + */ +uint32_t mpack_expect_array_range(mpack_reader_t* reader, uint32_t min_count, uint32_t max_count); + +/** + * Reads the start of an array with a number of elements at most @a max_count, + * returning its element count. + * + * A number of values follow equal to the element count of the array. + * @ref mpack_done_array() must be called once all elements have been read. + * + * Zero is returned if an error occurs. + * + * @throws mpack_error_type if the value is not an array or if its size is + * greater than max_count. + */ +MPACK_INLINE uint32_t mpack_expect_array_max(mpack_reader_t* reader, uint32_t max_count) { + return mpack_expect_array_range(reader, 0, max_count); +} + +/** + * Reads the start of an array of the exact size given. + * + * A number of values follow equal to the element count of the array. + * @ref mpack_done_array() must be called once all elements have been read. + * + * @throws mpack_error_type if the value is not an array or if its size does + * not match the given count. + */ +void mpack_expect_array_match(mpack_reader_t* reader, uint32_t count); + +/** + * Reads a nil node or the start of an array, returning whether an array was + * read and placing its number of elements in count. + * + * If an array was read, a number of values follow equal to the element count + * of the array. @ref mpack_done_array() should also be called once all elements + * have been read (only if an array was read.) + * + * @warning This call is dangerous! It does not have a size limit, and it + * does not have any way of checking whether there is enough data in the + * message (since the data could be coming from a stream.) When looping + * through the array's contents, you must check for errors on each iteration + * of the loop. Otherwise an attacker could craft a message declaring an array + * of a billion elements which would throw your parsing code into an + * infinite loop! You should strongly consider using mpack_expect_array_max_or_nil() + * with a safe maximum size instead. + * + * @returns @c true if an array was read successfully; @c false if nil was read + * or an error occurred. + * @throws mpack_error_type if the value is not a nil or array. + */ +bool mpack_expect_array_or_nil(mpack_reader_t* reader, uint32_t* count); + +/** + * Reads a nil node or the start of an array with a number of elements at most + * max_count, returning whether an array was read and placing its number of + * key/value pairs in count. + * + * If an array was read, a number of values follow equal to the element count + * of the array. @ref mpack_done_array() should also be called once all elements + * have been read (only if an array was read.) + * + * @returns @c true if an array was read successfully; @c false if nil was read + * or an error occurred. + * @throws mpack_error_type if the value is not a nil or array. + */ +bool mpack_expect_array_max_or_nil(mpack_reader_t* reader, uint32_t max_count, uint32_t* count); + +#ifdef MPACK_MALLOC +/** + * @hideinitializer + * + * Reads the start of an array and allocates storage for it, placing its + * size in out_count. A number of objects follow equal to the element count + * of the array. You must call @ref mpack_done_array() when done (even + * if the element count is zero.) + * + * If an error occurs, NULL is returned and the reader is placed in an + * error state. + * + * If the count is zero, NULL is returned. This does not indicate error. + * You should not check the return value for NULL to check for errors; only + * check the reader's error state. + * + * The allocated array must be freed with MPACK_FREE() (or simply free() + * if MPack's allocator hasn't been customized.) + * + * @throws mpack_error_type if the value is not an array or if its size is + * greater than max_count. + */ +#define mpack_expect_array_alloc(reader, Type, max_count, out_count) \ + ((Type*)mpack_expect_array_alloc_impl(reader, sizeof(Type), max_count, out_count, false)) + +/** + * @hideinitializer + * + * Reads a nil node or the start of an array and allocates storage for it, + * placing its size in out_count. A number of objects follow equal to the element + * count of the array if a non-empty array was read. + * + * If an error occurs, NULL is returned and the reader is placed in an + * error state. + * + * If a nil node was read, NULL is returned. If an empty array was read, + * mpack_done_array() is called automatically and NULL is returned. These + * do not indicate error. You should not check the return value for NULL + * to check for errors; only check the reader's error state. + * + * The allocated array must be freed with MPACK_FREE() (or simply free() + * if MPack's allocator hasn't been customized.) + * + * @warning You must call @ref mpack_done_array() if and only if a non-zero + * element count is read. This function does not differentiate between nil + * and an empty array. + * + * @throws mpack_error_type if the value is not an array or if its size is + * greater than max_count. + */ +#define mpack_expect_array_or_nil_alloc(reader, Type, max_count, out_count) \ + ((Type*)mpack_expect_array_alloc_impl(reader, sizeof(Type), max_count, out_count, true)) +#endif + +/** + * @} + */ + +/** @cond */ +#ifdef MPACK_MALLOC +void* mpack_expect_array_alloc_impl(mpack_reader_t* reader, + size_t element_size, uint32_t max_count, uint32_t* out_count, bool allow_nil); +#endif +/** @endcond */ + + +/** + * @name String Functions + * @{ + */ + +/** + * Reads the start of a string, returning its size in bytes. + * + * The bytes follow and must be read separately with mpack_read_bytes() + * or mpack_read_bytes_inplace(). mpack_done_str() must be called + * once all bytes have been read. + * + * NUL bytes are allowed in the string, and no encoding checks are done. + * + * mpack_error_type is raised if the value is not a string. + */ +uint32_t mpack_expect_str(mpack_reader_t* reader); + +/** + * Reads a string of at most the given size, writing it into the + * given buffer and returning its size in bytes. + * + * This does not add a null-terminator! Use mpack_expect_cstr() to + * add a null-terminator. + * + * NUL bytes are allowed in the string, and no encoding checks are done. + */ +size_t mpack_expect_str_buf(mpack_reader_t* reader, char* buf, size_t bufsize); + +/** + * Reads a string into the given buffer, ensuring it is a valid UTF-8 string + * and returning its size in bytes. + * + * This does not add a null-terminator! Use mpack_expect_utf8_cstr() to + * add a null-terminator. + * + * This does not accept any UTF-8 variant such as Modified UTF-8, CESU-8 or + * WTF-8. Only pure UTF-8 is allowed. + * + * NUL bytes are allowed in the string (as they are in UTF-8.) + * + * Raises mpack_error_too_big if there is not enough room for the string. + * Raises mpack_error_type if the value is not a string or is not a valid UTF-8 string. + */ +size_t mpack_expect_utf8(mpack_reader_t* reader, char* buf, size_t bufsize); + +/** + * Reads the start of a string, raising an error if its length is not + * at most the given number of bytes (not including any null-terminator.) + * + * The bytes follow and must be read separately with mpack_read_bytes() + * or mpack_read_bytes_inplace(). @ref mpack_done_str() must be called + * once all bytes have been read. + * + * @throws mpack_error_type If the value is not a string. + * @throws mpack_error_too_big If the string's length in bytes is larger than the given maximum size. + */ +MPACK_INLINE uint32_t mpack_expect_str_max(mpack_reader_t* reader, uint32_t maxsize) { + uint32_t length = mpack_expect_str(reader); + if (length > maxsize) { + mpack_reader_flag_error(reader, mpack_error_too_big); + return 0; + } + return length; +} + +/** + * Reads the start of a string, raising an error if its length is not + * exactly the given number of bytes (not including any null-terminator.) + * + * The bytes follow and must be read separately with mpack_read_bytes() + * or mpack_read_bytes_inplace(). @ref mpack_done_str() must be called + * once all bytes have been read. + * + * mpack_error_type is raised if the value is not a string or if its + * length does not match. + */ +MPACK_INLINE void mpack_expect_str_length(mpack_reader_t* reader, uint32_t count) { + if (mpack_expect_str(reader) != count) + mpack_reader_flag_error(reader, mpack_error_type); +} + +/** + * Reads a string, ensuring it exactly matches the given string. + * + * Remember that maps are unordered in JSON. Don't use this for map keys + * unless the map has only a single key! + */ +void mpack_expect_str_match(mpack_reader_t* reader, const char* str, size_t length); + +/** + * Reads a string into the given buffer, ensures it has no null bytes, + * and adds a null-terminator at the end. + * + * Raises mpack_error_too_big if there is not enough room for the string and null-terminator. + * Raises mpack_error_type if the value is not a string or contains a null byte. + */ +void mpack_expect_cstr(mpack_reader_t* reader, char* buf, size_t size); + +/** + * Reads a string into the given buffer, ensures it is a valid UTF-8 string + * without NUL characters, and adds a null-terminator at the end. + * + * This does not accept any UTF-8 variant such as Modified UTF-8, CESU-8 or + * WTF-8. Only pure UTF-8 is allowed, but without the NUL character, since + * it cannot be represented in a null-terminated string. + * + * Raises mpack_error_too_big if there is not enough room for the string and null-terminator. + * Raises mpack_error_type if the value is not a string or is not a valid UTF-8 string. + */ +void mpack_expect_utf8_cstr(mpack_reader_t* reader, char* buf, size_t size); + +#ifdef MPACK_MALLOC +/** + * Reads a string with the given total maximum size (including space for a + * null-terminator), allocates storage for it, ensures it has no null-bytes, + * and adds a null-terminator at the end. You assume ownership of the + * returned pointer if reading succeeds. + * + * The allocated string must be freed with MPACK_FREE() (or simply free() + * if MPack's allocator hasn't been customized.) + * + * @throws mpack_error_too_big If the string plus null-terminator is larger than the given maxsize. + * @throws mpack_error_type If the value is not a string or contains a null byte. + */ +char* mpack_expect_cstr_alloc(mpack_reader_t* reader, size_t maxsize); + +/** + * Reads a string with the given total maximum size (including space for a + * null-terminator), allocates storage for it, ensures it is valid UTF-8 + * with no null-bytes, and adds a null-terminator at the end. You assume + * ownership of the returned pointer if reading succeeds. + * + * The length in bytes of the string, not including the null-terminator, + * will be written to size. + * + * This does not accept any UTF-8 variant such as Modified UTF-8, CESU-8 or + * WTF-8. Only pure UTF-8 is allowed, but without the NUL character, since + * it cannot be represented in a null-terminated string. + * + * The allocated string must be freed with MPACK_FREE() (or simply free() + * if MPack's allocator hasn't been customized.) + * if you want a null-terminator. + * + * @throws mpack_error_too_big If the string plus null-terminator is larger + * than the given maxsize. + * @throws mpack_error_type If the value is not a string or contains + * invalid UTF-8 or a null byte. + */ +char* mpack_expect_utf8_cstr_alloc(mpack_reader_t* reader, size_t maxsize); +#endif + +/** + * Reads a string, ensuring it exactly matches the given null-terminated + * string. + * + * Remember that maps are unordered in JSON. Don't use this for map keys + * unless the map has only a single key! + */ +MPACK_INLINE void mpack_expect_cstr_match(mpack_reader_t* reader, const char* cstr) { + mpack_assert(cstr != NULL, "cstr pointer is NULL"); + mpack_expect_str_match(reader, cstr, mpack_strlen(cstr)); +} + +/** + * @} + */ + +/** + * @name Binary Data + * @{ + */ + +/** + * Reads the start of a binary blob, returning its size in bytes. + * + * The bytes follow and must be read separately with mpack_read_bytes() + * or mpack_read_bytes_inplace(). @ref mpack_done_bin() must be called + * once all bytes have been read. + * + * mpack_error_type is raised if the value is not a binary blob. + */ +uint32_t mpack_expect_bin(mpack_reader_t* reader); + +/** + * Reads the start of a binary blob, raising an error if its length is not + * at most the given number of bytes. + * + * The bytes follow and must be read separately with mpack_read_bytes() + * or mpack_read_bytes_inplace(). @ref mpack_done_bin() must be called + * once all bytes have been read. + * + * mpack_error_type is raised if the value is not a binary blob or if its + * length does not match. + */ +MPACK_INLINE uint32_t mpack_expect_bin_max(mpack_reader_t* reader, uint32_t maxsize) { + uint32_t length = mpack_expect_bin(reader); + if (length > maxsize) { + mpack_reader_flag_error(reader, mpack_error_type); + return 0; + } + return length; +} + +/** + * Reads the start of a binary blob, raising an error if its length is not + * exactly the given number of bytes. + * + * The bytes follow and must be read separately with mpack_read_bytes() + * or mpack_read_bytes_inplace(). @ref mpack_done_bin() must be called + * once all bytes have been read. + * + * @throws mpack_error_type if the value is not a binary blob or if its size + * does not match. + */ +MPACK_INLINE void mpack_expect_bin_size(mpack_reader_t* reader, uint32_t count) { + if (mpack_expect_bin(reader) != count) + mpack_reader_flag_error(reader, mpack_error_type); +} + +/** + * Reads a binary blob into the given buffer, returning its size in bytes. + * + * For compatibility, this will accept if the underlying type is string or + * binary (since in MessagePack 1.0, strings and binary data were combined + * under the "raw" type which became string in 1.1.) + */ +size_t mpack_expect_bin_buf(mpack_reader_t* reader, char* buf, size_t size); + +/** + * Reads a binary blob with the exact given size into the given buffer. + * + * For compatibility, this will accept if the underlying type is string or + * binary (since in MessagePack 1.0, strings and binary data were combined + * under the "raw" type which became string in 1.1.) + * + * @throws mpack_error_type if the value is not a binary blob or if its size + * does not match. + */ +void mpack_expect_bin_size_buf(mpack_reader_t* reader, char* buf, uint32_t size); + +/** + * Reads a binary blob with the given total maximum size, allocating storage for it. + */ +char* mpack_expect_bin_alloc(mpack_reader_t* reader, size_t maxsize, size_t* size); + +/** + * @} + */ + +/** + * @name Extension Functions + * @{ + */ + +#if MPACK_EXTENSIONS +/** + * Reads the start of an extension blob, returning its size in bytes and + * placing the type into @p type. + * + * The bytes follow and must be read separately with mpack_read_bytes() + * or mpack_read_bytes_inplace(). @ref mpack_done_ext() must be called + * once all bytes have been read. + * + * @p type will be a user-defined type in the range [0,127] or a reserved type + * in the range [-128,-2]. + * + * mpack_error_type is raised if the value is not an extension blob. The @p + * type value is zero if an error occurs. + * + * @note This cannot be used to match a timestamp. @ref mpack_error_type will + * be flagged if the value is a timestamp. Use mpack_expect_timestamp() or + * mpack_expect_timestamp_truncate() instead. + * + * @note This requires @ref MPACK_EXTENSIONS. + * + * @warning Be careful when using reserved types. They may no longer be ext + * types in the future, and previously valid data containing reserved types may + * become invalid in the future. + */ +uint32_t mpack_expect_ext(mpack_reader_t* reader, int8_t* type); + +/** + * Reads the start of an extension blob, raising an error if its length is not + * at most the given number of bytes and placing the type into @p type. + * + * The bytes follow and must be read separately with mpack_read_bytes() + * or mpack_read_bytes_inplace(). @ref mpack_done_ext() must be called + * once all bytes have been read. + * + * mpack_error_type is raised if the value is not an extension blob or if its + * length does not match. The @p type value is zero if an error is raised. + * + * @p type will be a user-defined type in the range [0,127] or a reserved type + * in the range [-128,-2]. + * + * @note This cannot be used to match a timestamp. @ref mpack_error_type will + * be flagged if the value is a timestamp. Use mpack_expect_timestamp() or + * mpack_expect_timestamp_truncate() instead. + * + * @note This requires @ref MPACK_EXTENSIONS. + * + * @warning Be careful when using reserved types. They may no longer be ext + * types in the future, and previously valid data containing reserved types may + * become invalid in the future. + * + * @see mpack_expect_ext() + */ +MPACK_INLINE uint32_t mpack_expect_ext_max(mpack_reader_t* reader, int8_t* type, uint32_t maxsize) { + uint32_t length = mpack_expect_ext(reader, type); + if (length > maxsize) { + mpack_reader_flag_error(reader, mpack_error_type); + return 0; + } + return length; +} + +/** + * Reads the start of an extension blob, raising an error if its length is not + * exactly the given number of bytes and placing the type into @p type. + * + * The bytes follow and must be read separately with mpack_read_bytes() + * or mpack_read_bytes_inplace(). @ref mpack_done_ext() must be called + * once all bytes have been read. + * + * mpack_error_type is raised if the value is not an extension blob or if its + * length does not match. The @p type value is zero if an error is raised. + * + * @p type will be a user-defined type in the range [0,127] or a reserved type + * in the range [-128,-2]. + * + * @note This cannot be used to match a timestamp. @ref mpack_error_type will + * be flagged if the value is a timestamp. Use mpack_expect_timestamp() or + * mpack_expect_timestamp_truncate() instead. + * + * @note This requires @ref MPACK_EXTENSIONS. + * + * @warning Be careful when using reserved types. They may no longer be ext + * types in the future, and previously valid data containing reserved types may + * become invalid in the future. + * + * @see mpack_expect_ext() + */ +MPACK_INLINE void mpack_expect_ext_size(mpack_reader_t* reader, int8_t* type, uint32_t count) { + if (mpack_expect_ext(reader, type) != count) { + *type = 0; + mpack_reader_flag_error(reader, mpack_error_type); + } +} + +/** + * Reads an extension blob into the given buffer, returning its size in bytes + * and placing the type into @p type. + * + * mpack_error_type is raised if the value is not an extension blob or if its + * length does not match. The @p type value is zero if an error is raised. + * + * @p type will be a user-defined type in the range [0,127] or a reserved type + * in the range [-128,-2]. + * + * @note This cannot be used to match a timestamp. @ref mpack_error_type will + * be flagged if the value is a timestamp. Use mpack_expect_timestamp() or + * mpack_expect_timestamp_truncate() instead. + * + * @warning Be careful when using reserved types. They may no longer be ext + * types in the future, and previously valid data containing reserved types may + * become invalid in the future. + * + * @note This requires @ref MPACK_EXTENSIONS. + * + * @see mpack_expect_ext() + */ +size_t mpack_expect_ext_buf(mpack_reader_t* reader, int8_t* type, char* buf, size_t size); +#endif + +#if MPACK_EXTENSIONS && defined(MPACK_MALLOC) +/** + * Reads an extension blob with the given total maximum size, allocating + * storage for it, and placing the type into @p type. + * + * mpack_error_type is raised if the value is not an extension blob or if its + * length does not match. The @p type value is zero if an error is raised. + * + * @p type will be a user-defined type in the range [0,127] or a reserved type + * in the range [-128,-2]. + * + * @note This cannot be used to match a timestamp. @ref mpack_error_type will + * be flagged if the value is a timestamp. Use mpack_expect_timestamp() or + * mpack_expect_timestamp_truncate() instead. + * + * @warning Be careful when using reserved types. They may no longer be ext + * types in the future, and previously valid data containing reserved types may + * become invalid in the future. + * + * @note This requires @ref MPACK_EXTENSIONS and @ref MPACK_MALLOC. + * + * @see mpack_expect_ext() + */ +char* mpack_expect_ext_alloc(mpack_reader_t* reader, int8_t* type, size_t maxsize, size_t* size); +#endif + +/** + * @} + */ + +/** + * @name Special Functions + * @{ + */ + +/** + * Reads a MessagePack object header (an MPack tag), expecting it to exactly + * match the given tag. + * + * If the type is compound (i.e. is a map, array, string, binary or + * extension type), additional reads are required to get the contained + * data, and the corresponding done function must be called when done. + * + * @throws mpack_error_type if the tag does not match + * + * @see mpack_read_bytes() + * @see mpack_done_array() + * @see mpack_done_map() + * @see mpack_done_str() + * @see mpack_done_bin() + * @see mpack_done_ext() + */ +void mpack_expect_tag(mpack_reader_t* reader, mpack_tag_t tag); + +/** + * Expects a string matching one of the strings in the given array, + * returning its array index. + * + * If the value does not match any of the given strings, + * @ref mpack_error_type is flagged. Use mpack_expect_enum_optional() + * if you want to allow other values than the given strings. + * + * If any error occurs or the reader is in an error state, @a count + * is returned. + * + * This can be used to quickly parse a string into an enum when the + * enum values range from 0 to @a count-1. If the last value in the + * enum is a special "count" value, it can be passed as the count, + * and the return value can be cast directly to the enum type. + * + * @code{.c} + * typedef enum { APPLE , BANANA , ORANGE , COUNT} fruit_t; + * const char* fruits[] = {"apple", "banana", "orange"}; + * + * fruit_t fruit = (fruit_t)mpack_expect_enum(reader, fruits, COUNT); + * @endcode + * + * See @ref docs/expect.md for more examples. + * + * The maximum string length is the size of the buffer (strings are read in-place.) + * + * @param reader The reader + * @param strings An array of expected strings of length count + * @param count The number of strings + * @return The index of the matched string, or @a count in case of error + */ +size_t mpack_expect_enum(mpack_reader_t* reader, const char* strings[], size_t count); + +/** + * Expects a string matching one of the strings in the given array + * returning its array index, or @a count if no strings match. + * + * If the value is not a string, or it does not match any of the + * given strings, @a count is returned and no error is flagged. + * + * If any error occurs or the reader is in an error state, @a count + * is returned. + * + * This can be used to quickly parse a string into an enum when the + * enum values range from 0 to @a count-1. If the last value in the + * enum is a special "count" value, it can be passed as the count, + * and the return value can be cast directly to the enum type. + * + * @code{.c} + * typedef enum { APPLE , BANANA , ORANGE , COUNT} fruit_t; + * const char* fruits[] = {"apple", "banana", "orange"}; + * + * fruit_t fruit = (fruit_t)mpack_expect_enum_optional(reader, fruits, COUNT); + * @endcode + * + * See @ref docs/expect.md for more examples. + * + * The maximum string length is the size of the buffer (strings are read in-place.) + * + * @param reader The reader + * @param strings An array of expected strings of length count + * @param count The number of strings + * + * @return The index of the matched string, or @a count if it does not + * match or an error occurs + */ +size_t mpack_expect_enum_optional(mpack_reader_t* reader, const char* strings[], size_t count); + +/** + * Expects an unsigned integer map key between 0 and count-1, marking it + * as found in the given bool array and returning it. + * + * This is a helper for switching among int keys in a map. It is + * typically used with an enum to define the key values. It should + * be called in the expression of a switch() statement. See @ref + * docs/expect.md for an example. + * + * The found array must be cleared before expecting the first key. If the + * flag for a given key is already set when found (i.e. the map contains a + * duplicate key), mpack_error_invalid is flagged. + * + * If the key is not a non-negative integer, or if the key is @a count or + * larger, @a count is returned and no error is flagged. If you want an error + * on unrecognized keys, flag an error in the default case in your switch; + * otherwise you must call mpack_discard() to discard its content. + * + * @param reader The reader + * @param found An array of bool flags of length count + * @param count The number of values in the found array, and one more than the + * maximum allowed key + * + * @see @ref docs/expect.md + */ +size_t mpack_expect_key_uint(mpack_reader_t* reader, bool found[], size_t count); + +/** + * Expects a string map key matching one of the strings in the given key list, + * marking it as found in the given bool array and returning its index. + * + * This is a helper for switching among string keys in a map. It is + * typically used with an enum with names matching the strings in the + * array to define the key indices. It should be called in the expression + * of a switch() statement. See @ref docs/expect.md for an example. + * + * The found array must be cleared before expecting the first key. If the + * flag for a given key is already set when found (i.e. the map contains a + * duplicate key), mpack_error_invalid is flagged. + * + * If the key is unrecognized, count is returned and no error is flagged. If + * you want an error on unrecognized keys, flag an error in the default case + * in your switch; otherwise you must call mpack_discard() to discard its content. + * + * The maximum key length is the size of the buffer (keys are read in-place.) + * + * @param reader The reader + * @param keys An array of expected string keys of length count + * @param found An array of bool flags of length count + * @param count The number of values in the keys and found arrays + * + * @see @ref docs/expect.md + */ +size_t mpack_expect_key_cstr(mpack_reader_t* reader, const char* keys[], + bool found[], size_t count); + +/** + * @} + */ + +/** + * @} + */ + +#endif + +MPACK_EXTERN_C_END +MPACK_SILENCE_WARNINGS_END + +#endif + + + +/* mpack/mpack-node.h.h */ + +/** + * @file + * + * Declares the MPack dynamic Node API. + */ + +#ifndef MPACK_NODE_H +#define MPACK_NODE_H 1 + +/* #include "mpack-reader.h" */ + +MPACK_SILENCE_WARNINGS_BEGIN +MPACK_EXTERN_C_BEGIN + +#if MPACK_NODE + +/** + * @defgroup node Node API + * + * The MPack Node API allows you to parse a chunk of MessagePack into a + * dynamically typed data structure, providing random access to the parsed + * data. + * + * See @ref docs/node.md for examples. + * + * @{ + */ + +/** + * A handle to node data in a parsed MPack tree. + * + * Nodes represent either primitive values or compound types. If a + * node is a compound type, it contains a pointer to its child nodes, + * or a pointer to its underlying data. + * + * Nodes are immutable. + * + * @note @ref mpack_node_t is an opaque reference to the node data, not the + * node data itself. (It contains pointers to both the node data and the tree.) + * It is passed by value in the Node API. + */ +typedef struct mpack_node_t mpack_node_t; + +/** + * The storage for nodes in an MPack tree. + * + * You only need to use this if you intend to provide your own storage + * for nodes instead of letting the tree allocate it. + * + * @ref mpack_node_data_t is 16 bytes on most common architectures (32-bit + * and 64-bit.) + */ +typedef struct mpack_node_data_t mpack_node_data_t; + +/** + * An MPack tree parser to parse a blob or stream of MessagePack. + * + * When a message is parsed, the tree contains a single root node which + * contains all parsed data. The tree and its nodes are immutable. + */ +typedef struct mpack_tree_t mpack_tree_t; + +/** + * An error handler function to be called when an error is flagged on + * the tree. + * + * The error handler will only be called once on the first error flagged; + * any subsequent node reads and errors are ignored, and the tree is + * permanently in that error state. + * + * MPack is safe against non-local jumps out of error handler callbacks. + * This means you are allowed to longjmp or throw an exception (in C++, + * Objective-C, or with SEH) out of this callback. + * + * Bear in mind when using longjmp that local non-volatile variables that + * have changed are undefined when setjmp() returns, so you can't put the + * tree on the stack in the same activation frame as the setjmp without + * declaring it volatile. + * + * You must still eventually destroy the tree. It is not destroyed + * automatically when an error is flagged. It is safe to destroy the + * tree within this error callback, but you will either need to perform + * a non-local jump, or store something in your context to identify + * that the tree is destroyed since any future accesses to it cause + * undefined behavior. + */ +typedef void (*mpack_tree_error_t)(mpack_tree_t* tree, mpack_error_t error); + +/** + * The MPack tree's read function. It should fill the buffer with as many bytes + * as are immediately available up to the given @c count, returning the number + * of bytes written to the buffer. + * + * In case of error, it should flag an appropriate error on the reader + * (usually @ref mpack_error_io.) + * + * The blocking or non-blocking behaviour of the read should match whether you + * are using mpack_tree_parse() or mpack_tree_try_parse(). + * + * If you are using mpack_tree_parse(), the read should block until at least + * one byte is read. If you return 0, mpack_tree_parse() will raise @ref + * mpack_error_io. + * + * If you are using mpack_tree_try_parse(), the read function can always + * return 0, and must never block waiting for data (otherwise + * mpack_tree_try_parse() would be equivalent to mpack_tree_parse().) + * When you return 0, mpack_tree_try_parse() will return false without flagging + * an error. + */ +typedef size_t (*mpack_tree_read_t)(mpack_tree_t* tree, char* buffer, size_t count); + +/** + * A teardown function to be called when the tree is destroyed. + */ +typedef void (*mpack_tree_teardown_t)(mpack_tree_t* tree); + + + +/* Hide internals from documentation */ +/** @cond */ + +struct mpack_node_t { + mpack_node_data_t* data; + mpack_tree_t* tree; +}; + +struct mpack_node_data_t { + mpack_type_t type; + + /* + * The element count if the type is an array; + * the number of key/value pairs if the type is map; + * or the number of bytes if the type is str, bin or ext. + */ + uint32_t len; + + union { + bool b; /* The value if the type is bool. */ + + #if MPACK_FLOAT + float f; /* The value if the type is float. */ + #else + uint32_t f; /*< The raw value if the type is float. */ + #endif + + #if MPACK_DOUBLE + double d; /* The value if the type is double. */ + #else + uint64_t d; /*< The raw value if the type is double. */ + #endif + + int64_t i; /* The value if the type is signed int. */ + uint64_t u; /* The value if the type is unsigned int. */ + size_t offset; /* The byte offset for str, bin and ext */ + + mpack_node_data_t* children; /* The children for map or array */ + } value; +}; + +typedef struct mpack_tree_page_t { + struct mpack_tree_page_t* next; + mpack_node_data_t nodes[1]; // variable size +} mpack_tree_page_t; + +typedef enum mpack_tree_parse_state_t { + mpack_tree_parse_state_not_started, + mpack_tree_parse_state_in_progress, + mpack_tree_parse_state_parsed, +} mpack_tree_parse_state_t; + +typedef struct mpack_level_t { + mpack_node_data_t* child; + size_t left; // children left in level +} mpack_level_t; + +typedef struct mpack_tree_parser_t { + mpack_tree_parse_state_t state; + + // We keep track of the number of "possible nodes" left in the data rather + // than the number of bytes. + // + // When a map or array is parsed, we ensure at least one byte for each child + // exists and subtract them right away. This ensures that if ever a map or + // array declares more elements than could possibly be contained in the data, + // we will error out immediately rather than allocating storage for them. + // + // For example malicious data that repeats 0xDE 0xFF 0xFF (start of a map + // with 65536 key-value pairs) would otherwise cause us to run out of + // memory. With this, the parser can allocate at most as many nodes as + // there are bytes in the data (plus the paging overhead, 12%.) An error + // will be flagged immediately if and when there isn't enough data left to + // fully read all children of all open compound types on the parsing stack. + // + // Once an entire message has been parsed (and there are no nodes left to + // parse whose bytes have been subtracted), this matches the number of left + // over bytes in the data. + size_t possible_nodes_left; + + mpack_node_data_t* nodes; // next node in current page/pool + size_t nodes_left; // nodes left in current page/pool + + size_t current_node_reserved; + size_t level; + + #ifdef MPACK_MALLOC + // It's much faster to allocate the initial parsing stack inline within the + // parser. We replace it with a heap allocation if we need to grow it. + mpack_level_t* stack; + size_t stack_capacity; + bool stack_owned; + mpack_level_t stack_local[MPACK_NODE_INITIAL_DEPTH]; + #else + // Without malloc(), we have to reserve a parsing stack the maximum allowed + // parsing depth. + mpack_level_t stack[MPACK_NODE_MAX_DEPTH_WITHOUT_MALLOC]; + #endif +} mpack_tree_parser_t; + +struct mpack_tree_t { + mpack_tree_error_t error_fn; /* Function to call on error */ + mpack_tree_read_t read_fn; /* Function to call to read more data */ + mpack_tree_teardown_t teardown; /* Function to teardown the context on destroy */ + void* context; /* Context for tree callbacks */ + + mpack_node_data_t nil_node; /* a nil node to be returned in case of error */ + mpack_node_data_t missing_node; /* a missing node to be returned in optional lookups */ + mpack_error_t error; + + #ifdef MPACK_MALLOC + char* buffer; + size_t buffer_capacity; + #endif + + const char* data; + size_t data_length; // length of data (and content of buffer, if used) + + size_t size; // size in bytes of tree (usually matches data_length, but not if tree has trailing data) + size_t node_count; // total number of nodes in tree (across all pages) + + size_t max_size; // maximum message size + size_t max_nodes; // maximum nodes in a message + + mpack_tree_parser_t parser; + mpack_node_data_t* root; + + mpack_node_data_t* pool; // pool, or NULL if no pool provided + size_t pool_count; + + #ifdef MPACK_MALLOC + mpack_tree_page_t* next; + #endif +}; + +// internal functions + +MPACK_INLINE mpack_node_t mpack_node(mpack_tree_t* tree, mpack_node_data_t* data) { + mpack_node_t node; + node.data = data; + node.tree = tree; + return node; +} + +MPACK_INLINE mpack_node_data_t* mpack_node_child(mpack_node_t node, size_t child) { + return node.data->value.children + child; +} + +MPACK_INLINE mpack_node_t mpack_tree_nil_node(mpack_tree_t* tree) { + return mpack_node(tree, &tree->nil_node); +} + +MPACK_INLINE mpack_node_t mpack_tree_missing_node(mpack_tree_t* tree) { + return mpack_node(tree, &tree->missing_node); +} + +/** @endcond */ + + + +/** + * @name Tree Initialization + * @{ + */ + +#ifdef MPACK_MALLOC +/** + * Initializes a tree parser with the given data. + * + * Configure the tree if desired, then call mpack_tree_parse() to parse it. The + * tree will allocate pages of nodes as needed and will free them when + * destroyed. + * + * The tree must be destroyed with mpack_tree_destroy(). + * + * Any string or blob data types reference the original data, so the given data + * pointer must remain valid until after the tree is destroyed. + */ +void mpack_tree_init_data(mpack_tree_t* tree, const char* data, size_t length); + +/** + * Deprecated. + * + * \deprecated Renamed to mpack_tree_init_data(). + */ +MPACK_INLINE void mpack_tree_init(mpack_tree_t* tree, const char* data, size_t length) { + mpack_tree_init_data(tree, data, length); +} + +/** + * Initializes a tree parser from an unbounded stream, or a stream of + * unknown length. + * + * The parser can be used to read a single message from a stream of unknown + * length, or multiple messages from an unbounded stream, allowing it to + * be used for RPC communication. Call @ref mpack_tree_parse() to parse + * a message from a blocking stream, or @ref mpack_tree_try_parse() for a + * non-blocking stream. + * + * The stream will use a growable internal buffer to store the most recent + * message, as well as allocated pages of nodes for the parse tree. + * + * Maximum allowances for message size and node count must be specified in this + * function (since the stream is unbounded.) They can be changed later with + * @ref mpack_tree_set_limits(). + * + * @param tree The tree parser + * @param read_fn The read function + * @param context The context for the read function + * @param max_message_size The maximum size of a message in bytes + * @param max_message_nodes The maximum number of nodes per message. See + * @ref mpack_node_data_t for the size of nodes. + * + * @see mpack_tree_read_t + * @see mpack_reader_context() + */ +void mpack_tree_init_stream(mpack_tree_t* tree, mpack_tree_read_t read_fn, void* context, + size_t max_message_size, size_t max_message_nodes); +#endif + +/** + * Initializes a tree parser with the given data, using the given node data + * pool to store the results. + * + * Configure the tree if desired, then call mpack_tree_parse() to parse it. + * + * If the data does not fit in the pool, @ref mpack_error_too_big will be flagged + * on the tree. + * + * The tree must be destroyed with mpack_tree_destroy(), even if parsing fails. + */ +void mpack_tree_init_pool(mpack_tree_t* tree, const char* data, size_t length, + mpack_node_data_t* node_pool, size_t node_pool_count); + +/** + * Initializes an MPack tree directly into an error state. Use this if you + * are writing a wrapper to another mpack_tree_init*() function which + * can fail its setup. + */ +void mpack_tree_init_error(mpack_tree_t* tree, mpack_error_t error); + +#if MPACK_STDIO +/** + * Initializes a tree to parse the given file. The tree must be destroyed with + * mpack_tree_destroy(), even if parsing fails. + * + * The file is opened, loaded fully into memory, and closed before this call + * returns. + * + * @param tree The tree to initialize + * @param filename The filename passed to fopen() to read the file + * @param max_bytes The maximum size of file to load, or 0 for unlimited size. + */ +void mpack_tree_init_filename(mpack_tree_t* tree, const char* filename, size_t max_bytes); + +/** + * Deprecated. + * + * \deprecated Renamed to mpack_tree_init_filename(). + */ +MPACK_INLINE void mpack_tree_init_file(mpack_tree_t* tree, const char* filename, size_t max_bytes) { + mpack_tree_init_filename(tree, filename, max_bytes); +} + +/** + * Initializes a tree to parse the given libc FILE. This can be used to + * read from stdin, or from a file opened separately. + * + * The tree must be destroyed with mpack_tree_destroy(), even if parsing fails. + * + * The FILE is fully loaded fully into memory (and closed if requested) before + * this call returns. + * + * @param tree The tree to initialize. + * @param stdfile The FILE. + * @param max_bytes The maximum size of file to load, or 0 for unlimited size. + * @param close_when_done If true, fclose() will be called on the FILE when it + * is no longer needed. If false, the file will not be closed when + * reading is done. + * + * @warning The tree will read all data in the FILE before parsing it. If this + * is used on stdin, the parser will block until it is closed, even if + * a complete message has been written to it! + */ +void mpack_tree_init_stdfile(mpack_tree_t* tree, FILE* stdfile, size_t max_bytes, bool close_when_done); +#endif + +/** + * @} + */ + +/** + * @name Tree Functions + * @{ + */ + +/** + * Sets the maximum byte size and maximum number of nodes allowed per message. + * + * The default is SIZE_MAX (no limit) unless @ref mpack_tree_init_stream() is + * called (where maximums are required.) + * + * If a pool of nodes is used, the node limit is the lesser of this limit and + * the pool size. + * + * @param tree The tree parser + * @param max_message_size The maximum size of a message in bytes + * @param max_message_nodes The maximum number of nodes per message. See + * @ref mpack_node_data_t for the size of nodes. + */ +void mpack_tree_set_limits(mpack_tree_t* tree, size_t max_message_size, + size_t max_message_nodes); + +/** + * Parses a MessagePack message into a tree of immutable nodes. + * + * If successful, the root node will be available under @ref mpack_tree_root(). + * If not, an appropriate error will be flagged. + * + * This can be called repeatedly to parse a series of messages from a data + * source. When this is called, all previous nodes from this tree and their + * contents (including the root node) are invalidated. + * + * If this is called with a stream (see @ref mpack_tree_init_stream()), the + * stream must block until data is available. (Otherwise, if this is called on + * a non-blocking stream, parsing will fail with @ref mpack_error_io when the + * fill function returns 0.) + * + * There is no way to recover a tree in an error state. It must be destroyed. + */ +void mpack_tree_parse(mpack_tree_t* tree); + +/** + * Attempts to parse a MessagePack message from a non-blocking stream into a + * tree of immutable nodes. + * + * A non-blocking read function must have been passed to the tree in + * mpack_tree_init_stream(). + * + * If this returns true, a message is available under + * @ref mpack_tree_root(). The tree nodes and data will be valid until + * the next time a parse is started. + * + * If this returns false, no message is available, because either not enough + * data is available yet or an error has occurred. You must check the tree for + * errors whenever this returns false. If there is no error, you should try + * again later when more data is available. (You will want to select()/poll() + * on the underlying socket or use some other asynchronous mechanism to + * determine when it has data.) + * + * There is no way to recover a tree in an error state. It must be destroyed. + * + * @see mpack_tree_init_stream() + */ +bool mpack_tree_try_parse(mpack_tree_t* tree); + +/** + * Returns the root node of the tree, if the tree is not in an error state. + * Returns a nil node otherwise. + * + * @warning You must call mpack_tree_parse() before calling this. If + * @ref mpack_tree_parse() was never called, the tree will assert. + */ +mpack_node_t mpack_tree_root(mpack_tree_t* tree); + +/** + * Returns the error state of the tree. + */ +MPACK_INLINE mpack_error_t mpack_tree_error(mpack_tree_t* tree) { + return tree->error; +} + +/** + * Returns the size in bytes of the current parsed message. + * + * If there is something in the buffer after the MessagePack object, this can + * be used to find it. + * + * This is zero if an error occurred during tree parsing (since the + * portion of the data that the first complete object occupies cannot + * be determined if the data is invalid or corrupted.) + */ +MPACK_INLINE size_t mpack_tree_size(mpack_tree_t* tree) { + return tree->size; +} + +/** + * Destroys the tree. + */ +mpack_error_t mpack_tree_destroy(mpack_tree_t* tree); + +/** + * Sets the custom pointer to pass to the tree callbacks, such as teardown. + * + * @param tree The MPack tree. + * @param context User data to pass to the tree callbacks. + * + * @see mpack_reader_context() + */ +MPACK_INLINE void mpack_tree_set_context(mpack_tree_t* tree, void* context) { + tree->context = context; +} + +/** + * Returns the custom context for tree callbacks. + * + * @see mpack_tree_set_context + * @see mpack_tree_init_stream + */ +MPACK_INLINE void* mpack_tree_context(mpack_tree_t* tree) { + return tree->context; +} + +/** + * Sets the error function to call when an error is flagged on the tree. + * + * This should normally be used with mpack_tree_set_context() to register + * a custom pointer to pass to the error function. + * + * See the definition of mpack_tree_error_t for more information about + * what you can do from an error callback. + * + * @see mpack_tree_error_t + * @param tree The MPack tree. + * @param error_fn The function to call when an error is flagged on the tree. + */ +MPACK_INLINE void mpack_tree_set_error_handler(mpack_tree_t* tree, mpack_tree_error_t error_fn) { + tree->error_fn = error_fn; +} + +/** + * Sets the teardown function to call when the tree is destroyed. + * + * This should normally be used with mpack_tree_set_context() to register + * a custom pointer to pass to the teardown function. + * + * @param tree The MPack tree. + * @param teardown The function to call when the tree is destroyed. + */ +MPACK_INLINE void mpack_tree_set_teardown(mpack_tree_t* tree, mpack_tree_teardown_t teardown) { + tree->teardown = teardown; +} + +/** + * Places the tree in the given error state, calling the error callback if one + * is set. + * + * This allows you to externally flag errors, for example if you are validating + * data as you read it. + * + * If the tree is already in an error state, this call is ignored and no + * error callback is called. + */ +void mpack_tree_flag_error(mpack_tree_t* tree, mpack_error_t error); + +/** + * @} + */ + +/** + * @name Node Core Functions + * @{ + */ + +/** + * Places the node's tree in the given error state, calling the error callback + * if one is set. + * + * This allows you to externally flag errors, for example if you are validating + * data as you read it. + * + * If the tree is already in an error state, this call is ignored and no + * error callback is called. + */ +void mpack_node_flag_error(mpack_node_t node, mpack_error_t error); + +/** + * Returns the error state of the node's tree. + */ +MPACK_INLINE mpack_error_t mpack_node_error(mpack_node_t node) { + return mpack_tree_error(node.tree); +} + +/** + * Returns a tag describing the given node, or a nil tag if the + * tree is in an error state. + */ +mpack_tag_t mpack_node_tag(mpack_node_t node); + +/** @cond */ + +#if MPACK_DEBUG && MPACK_STDIO +/* + * Converts a node to a pseudo-JSON string for debugging purposes, placing the + * result in the given buffer with a null-terminator. + * + * If the buffer does not have enough space, the result will be truncated (but + * it is guaranteed to be null-terminated.) + * + * This is only available in debug mode, and only if stdio is available (since + * it uses snprintf().) It's strictly for debugging purposes. + */ +void mpack_node_print_to_buffer(mpack_node_t node, char* buffer, size_t buffer_size); + +/* + * Converts a node to pseudo-JSON for debugging purposes, calling the given + * callback as many times as is necessary to output the character data. + * + * No null-terminator or trailing newline will be written. + * + * This is only available in debug mode, and only if stdio is available (since + * it uses snprintf().) It's strictly for debugging purposes. + */ +void mpack_node_print_to_callback(mpack_node_t node, mpack_print_callback_t callback, void* context); + +/* + * Converts a node to pseudo-JSON for debugging purposes + * and pretty-prints it to the given file. + * + * This is only available in debug mode, and only if stdio is available (since + * it uses snprintf().) It's strictly for debugging purposes. + */ +void mpack_node_print_to_file(mpack_node_t node, FILE* file); + +/* + * Converts a node to pseudo-JSON for debugging purposes + * and pretty-prints it to stdout. + * + * This is only available in debug mode, and only if stdio is available (since + * it uses snprintf().) It's strictly for debugging purposes. + */ +MPACK_INLINE void mpack_node_print_to_stdout(mpack_node_t node) { + mpack_node_print_to_file(node, stdout); +} + +/* + * Deprecated. + * + * \deprecated Renamed to mpack_node_print_to_stdout(). + */ +MPACK_INLINE void mpack_node_print(mpack_node_t node) { + mpack_node_print_to_stdout(node); +} +#endif + +/** @endcond */ + +/** + * @} + */ + +/** + * @name Node Primitive Value Functions + * @{ + */ + +/** + * Returns the type of the node. + */ +mpack_type_t mpack_node_type(mpack_node_t node); + +/** + * Returns true if the given node is a nil node; false otherwise. + * + * To ensure that a node is nil and flag an error otherwise, use + * mpack_node_nil(). + */ +bool mpack_node_is_nil(mpack_node_t node); + +/** + * Returns true if the given node handle indicates a missing node; false otherwise. + * + * To ensure that a node is missing and flag an error otherwise, use + * mpack_node_missing(). + */ +bool mpack_node_is_missing(mpack_node_t node); + +/** + * Checks that the given node is of nil type, raising @ref mpack_error_type + * otherwise. + * + * Use mpack_node_is_nil() to return whether the node is nil. + */ +void mpack_node_nil(mpack_node_t node); + +/** + * Checks that the given node indicates a missing node, raising @ref + * mpack_error_type otherwise. + * + * Use mpack_node_is_missing() to return whether the node is missing. + */ +void mpack_node_missing(mpack_node_t node); + +/** + * Returns the bool value of the node. If this node is not of the correct + * type, false is returned and mpack_error_type is raised. + */ +bool mpack_node_bool(mpack_node_t node); + +/** + * Checks if the given node is of bool type with value true, raising + * mpack_error_type otherwise. + */ +void mpack_node_true(mpack_node_t node); + +/** + * Checks if the given node is of bool type with value false, raising + * mpack_error_type otherwise. + */ +void mpack_node_false(mpack_node_t node); + +/** + * Returns the 8-bit unsigned value of the node. If this node is not + * of a compatible type, @ref mpack_error_type is raised and zero is returned. + */ +uint8_t mpack_node_u8(mpack_node_t node); + +/** + * Returns the 8-bit signed value of the node. If this node is not + * of a compatible type, @ref mpack_error_type is raised and zero is returned. + */ +int8_t mpack_node_i8(mpack_node_t node); + +/** + * Returns the 16-bit unsigned value of the node. If this node is not + * of a compatible type, @ref mpack_error_type is raised and zero is returned. + */ +uint16_t mpack_node_u16(mpack_node_t node); + +/** + * Returns the 16-bit signed value of the node. If this node is not + * of a compatible type, @ref mpack_error_type is raised and zero is returned. + */ +int16_t mpack_node_i16(mpack_node_t node); + +/** + * Returns the 32-bit unsigned value of the node. If this node is not + * of a compatible type, @ref mpack_error_type is raised and zero is returned. + */ +uint32_t mpack_node_u32(mpack_node_t node); + +/** + * Returns the 32-bit signed value of the node. If this node is not + * of a compatible type, @ref mpack_error_type is raised and zero is returned. + */ +int32_t mpack_node_i32(mpack_node_t node); + +/** + * Returns the 64-bit unsigned value of the node. If this node is not + * of a compatible type, @ref mpack_error_type is raised, and zero is returned. + */ +uint64_t mpack_node_u64(mpack_node_t node); + +/** + * Returns the 64-bit signed value of the node. If this node is not + * of a compatible type, @ref mpack_error_type is raised and zero is returned. + */ +int64_t mpack_node_i64(mpack_node_t node); + +/** + * Returns the unsigned int value of the node. + * + * Returns zero if an error occurs. + * + * @throws mpack_error_type If the node is not an integer type or does not fit in the range of an unsigned int + */ +unsigned int mpack_node_uint(mpack_node_t node); + +/** + * Returns the int value of the node. + * + * Returns zero if an error occurs. + * + * @throws mpack_error_type If the node is not an integer type or does not fit in the range of an int + */ +int mpack_node_int(mpack_node_t node); + +#if MPACK_FLOAT +/** + * Returns the float value of the node. The underlying value can be an + * integer, float or double; the value is converted to a float. + * + * @note Reading a double or a large integer with this function can incur a + * loss of precision. + * + * @throws mpack_error_type if the underlying value is not a float, double or integer. + */ +float mpack_node_float(mpack_node_t node); +#endif + +#if MPACK_DOUBLE +/** + * Returns the double value of the node. The underlying value can be an + * integer, float or double; the value is converted to a double. + * + * @note Reading a very large integer with this function can incur a + * loss of precision. + * + * @throws mpack_error_type if the underlying value is not a float, double or integer. + */ +double mpack_node_double(mpack_node_t node); +#endif + +#if MPACK_FLOAT +/** + * Returns the float value of the node. The underlying value must be a float, + * not a double or an integer. This ensures no loss of precision can occur. + * + * @throws mpack_error_type if the underlying value is not a float. + */ +float mpack_node_float_strict(mpack_node_t node); +#endif + +#if MPACK_DOUBLE +/** + * Returns the double value of the node. The underlying value must be a float + * or double, not an integer. This ensures no loss of precision can occur. + * + * @throws mpack_error_type if the underlying value is not a float or double. + */ +double mpack_node_double_strict(mpack_node_t node); +#endif + +#if !MPACK_FLOAT +/** + * Returns the float value of the node as a raw uint32_t. The underlying value + * must be a float, not a double or an integer. + * + * @throws mpack_error_type if the underlying value is not a float. + */ +uint32_t mpack_node_raw_float(mpack_node_t node); +#endif + +#if !MPACK_DOUBLE +/** + * Returns the double value of the node as a raw uint64_t. The underlying value + * must be a double, not a float or an integer. + * + * @throws mpack_error_type if the underlying value is not a float or double. + */ +uint64_t mpack_node_raw_double(mpack_node_t node); +#endif + + +#if MPACK_EXTENSIONS +/** + * Returns a timestamp. + * + * @note This requires @ref MPACK_EXTENSIONS. + * + * @throws mpack_error_type if the underlying value is not a timestamp. + */ +mpack_timestamp_t mpack_node_timestamp(mpack_node_t node); + +/** + * Returns a timestamp's (signed) seconds since 1970-01-01T00:00:00Z. + * + * @note This requires @ref MPACK_EXTENSIONS. + * + * @throws mpack_error_type if the underlying value is not a timestamp. + */ +int64_t mpack_node_timestamp_seconds(mpack_node_t node); + +/** + * Returns a timestamp's additional nanoseconds. + * + * @note This requires @ref MPACK_EXTENSIONS. + * + * @return A nanosecond count between 0 and 999,999,999 inclusive. + * @throws mpack_error_type if the underlying value is not a timestamp. + */ +uint32_t mpack_node_timestamp_nanoseconds(mpack_node_t node); +#endif + +/** + * @} + */ + +/** + * @name Node String and Data Functions + * @{ + */ + +/** + * Checks that the given node contains a valid UTF-8 string. + * + * If the string is invalid, this flags an error, which would cause subsequent calls + * to mpack_node_str() to return NULL and mpack_node_strlen() to return zero. So you + * can check the node for error immediately after calling this, or you can call those + * functions to use the data anyway and check for errors later. + * + * @throws mpack_error_type If this node is not a string or does not contain valid UTF-8. + * + * @param node The string node to test + * + * @see mpack_node_str() + * @see mpack_node_strlen() + */ +void mpack_node_check_utf8(mpack_node_t node); + +/** + * Checks that the given node contains a valid UTF-8 string with no NUL bytes. + * + * This does not check that the string has a null-terminator! It only checks whether + * the string could safely be represented as a C-string by appending a null-terminator. + * (If the string does already contain a null-terminator, this will flag an error.) + * + * This is performed automatically by other UTF-8 cstr helper functions. Only + * call this if you will do something else with the data directly, but you still + * want to ensure it will be valid as a UTF-8 C-string. + * + * @throws mpack_error_type If this node is not a string, does not contain valid UTF-8, + * or contains a NUL byte. + * + * @param node The string node to test + * + * @see mpack_node_str() + * @see mpack_node_strlen() + * @see mpack_node_copy_utf8_cstr() + * @see mpack_node_utf8_cstr_alloc() + */ +void mpack_node_check_utf8_cstr(mpack_node_t node); + +#if MPACK_EXTENSIONS +/** + * Returns the extension type of the given ext node. + * + * This returns zero if the tree is in an error state. + * + * @note This requires @ref MPACK_EXTENSIONS. + */ +int8_t mpack_node_exttype(mpack_node_t node); +#endif + +/** + * Returns the number of bytes in the given bin node. + * + * This returns zero if the tree is in an error state. + * + * If this node is not a bin, @ref mpack_error_type is raised and zero is returned. + */ +size_t mpack_node_bin_size(mpack_node_t node); + +/** + * Returns the length of the given str, bin or ext node. + * + * This returns zero if the tree is in an error state. + * + * If this node is not a str, bin or ext, @ref mpack_error_type is raised and zero + * is returned. + */ +uint32_t mpack_node_data_len(mpack_node_t node); + +/** + * Returns the length in bytes of the given string node. This does not + * include any null-terminator. + * + * This returns zero if the tree is in an error state. + * + * If this node is not a str, @ref mpack_error_type is raised and zero is returned. + */ +size_t mpack_node_strlen(mpack_node_t node); + +/** + * Returns a pointer to the data contained by this node, ensuring the node is a + * string. + * + * @warning Strings are not null-terminated! Use one of the cstr functions + * to get a null-terminated string. + * + * The pointer is valid as long as the data backing the tree is valid. + * + * If this node is not a string, @ref mpack_error_type is raised and @c NULL is returned. + * + * @see mpack_node_copy_cstr() + * @see mpack_node_cstr_alloc() + * @see mpack_node_utf8_cstr_alloc() + */ +const char* mpack_node_str(mpack_node_t node); + +/** + * Returns a pointer to the data contained by this node. + * + * @note Strings are not null-terminated! Use one of the cstr functions + * to get a null-terminated string. + * + * The pointer is valid as long as the data backing the tree is valid. + * + * If this node is not of a str, bin or ext, @ref mpack_error_type is raised, and + * @c NULL is returned. + * + * @see mpack_node_copy_cstr() + * @see mpack_node_cstr_alloc() + * @see mpack_node_utf8_cstr_alloc() + */ +const char* mpack_node_data(mpack_node_t node); + +/** + * Returns a pointer to the data contained by this bin node. + * + * The pointer is valid as long as the data backing the tree is valid. + * + * If this node is not a bin, @ref mpack_error_type is raised and @c NULL is + * returned. + */ +const char* mpack_node_bin_data(mpack_node_t node); + +/** + * Copies the bytes contained by this node into the given buffer, returning the + * number of bytes in the node. + * + * @throws mpack_error_type If this node is not a str, bin or ext type + * @throws mpack_error_too_big If the string does not fit in the given buffer + * + * @param node The string node from which to copy data + * @param buffer A buffer in which to copy the node's bytes + * @param bufsize The size of the given buffer + * + * @return The number of bytes in the node, or zero if an error occurs. + */ +size_t mpack_node_copy_data(mpack_node_t node, char* buffer, size_t bufsize); + +/** + * Checks that the given node contains a valid UTF-8 string and copies the + * string into the given buffer, returning the number of bytes in the string. + * + * @throws mpack_error_type If this node is not a string + * @throws mpack_error_too_big If the string does not fit in the given buffer + * + * @param node The string node from which to copy data + * @param buffer A buffer in which to copy the node's bytes + * @param bufsize The size of the given buffer + * + * @return The number of bytes in the node, or zero if an error occurs. + */ +size_t mpack_node_copy_utf8(mpack_node_t node, char* buffer, size_t bufsize); + +/** + * Checks that the given node contains a string with no NUL bytes, copies the string + * into the given buffer, and adds a null terminator. + * + * If this node is not of a string type, @ref mpack_error_type is raised. If the string + * does not fit, @ref mpack_error_data is raised. + * + * If any error occurs, the buffer will contain an empty null-terminated string. + * + * @param node The string node from which to copy data + * @param buffer A buffer in which to copy the node's string + * @param size The size of the given buffer + */ +void mpack_node_copy_cstr(mpack_node_t node, char* buffer, size_t size); + +/** + * Checks that the given node contains a valid UTF-8 string with no NUL bytes, + * copies the string into the given buffer, and adds a null terminator. + * + * If this node is not of a string type, @ref mpack_error_type is raised. If the string + * does not fit, @ref mpack_error_data is raised. + * + * If any error occurs, the buffer will contain an empty null-terminated string. + * + * @param node The string node from which to copy data + * @param buffer A buffer in which to copy the node's string + * @param size The size of the given buffer + */ +void mpack_node_copy_utf8_cstr(mpack_node_t node, char* buffer, size_t size); + +#ifdef MPACK_MALLOC +/** + * Allocates a new chunk of data using MPACK_MALLOC() with the bytes + * contained by this node. + * + * The allocated data must be freed with MPACK_FREE() (or simply free() + * if MPack's allocator hasn't been customized.) + * + * @throws mpack_error_type If this node is not a str, bin or ext type + * @throws mpack_error_too_big If the size of the data is larger than the + * given maximum size + * @throws mpack_error_memory If an allocation failure occurs + * + * @param node The node from which to allocate and copy data + * @param maxsize The maximum size to allocate + * + * @return The allocated data, or NULL if any error occurs. + */ +char* mpack_node_data_alloc(mpack_node_t node, size_t maxsize); + +/** + * Allocates a new null-terminated string using MPACK_MALLOC() with the string + * contained by this node. + * + * The allocated string must be freed with MPACK_FREE() (or simply free() + * if MPack's allocator hasn't been customized.) + * + * @throws mpack_error_type If this node is not a string or contains NUL bytes + * @throws mpack_error_too_big If the size of the string plus null-terminator + * is larger than the given maximum size + * @throws mpack_error_memory If an allocation failure occurs + * + * @param node The node from which to allocate and copy string data + * @param maxsize The maximum size to allocate, including the null-terminator + * + * @return The allocated string, or NULL if any error occurs. + */ +char* mpack_node_cstr_alloc(mpack_node_t node, size_t maxsize); + +/** + * Allocates a new null-terminated string using MPACK_MALLOC() with the UTF-8 + * string contained by this node. + * + * The allocated string must be freed with MPACK_FREE() (or simply free() + * if MPack's allocator hasn't been customized.) + * + * @throws mpack_error_type If this node is not a string, is not valid UTF-8, + * or contains NUL bytes + * @throws mpack_error_too_big If the size of the string plus null-terminator + * is larger than the given maximum size + * @throws mpack_error_memory If an allocation failure occurs + * + * @param node The node from which to allocate and copy string data + * @param maxsize The maximum size to allocate, including the null-terminator + * + * @return The allocated string, or NULL if any error occurs. + */ +char* mpack_node_utf8_cstr_alloc(mpack_node_t node, size_t maxsize); +#endif + +/** + * Searches the given string array for a string matching the given + * node and returns its index. + * + * If the node does not match any of the given strings, + * @ref mpack_error_type is flagged. Use mpack_node_enum_optional() + * if you want to allow values other than the given strings. + * + * If any error occurs or if the tree is in an error state, @a count + * is returned. + * + * This can be used to quickly parse a string into an enum when the + * enum values range from 0 to @a count-1. If the last value in the + * enum is a special "count" value, it can be passed as the count, + * and the return value can be cast directly to the enum type. + * + * @code{.c} + * typedef enum { APPLE , BANANA , ORANGE , COUNT} fruit_t; + * const char* fruits[] = {"apple", "banana", "orange"}; + * + * fruit_t fruit = (fruit_t)mpack_node_enum(node, fruits, COUNT); + * @endcode + * + * @param node The node + * @param strings An array of expected strings of length count + * @param count The number of strings + * @return The index of the matched string, or @a count in case of error + */ +size_t mpack_node_enum(mpack_node_t node, const char* strings[], size_t count); + +/** + * Searches the given string array for a string matching the given node, + * returning its index or @a count if no strings match. + * + * If the value is not a string, or it does not match any of the + * given strings, @a count is returned and no error is flagged. + * + * If any error occurs or if the tree is in an error state, @a count + * is returned. + * + * This can be used to quickly parse a string into an enum when the + * enum values range from 0 to @a count-1. If the last value in the + * enum is a special "count" value, it can be passed as the count, + * and the return value can be cast directly to the enum type. + * + * @code{.c} + * typedef enum { APPLE , BANANA , ORANGE , COUNT} fruit_t; + * const char* fruits[] = {"apple", "banana", "orange"}; + * + * fruit_t fruit = (fruit_t)mpack_node_enum_optional(node, fruits, COUNT); + * @endcode + * + * @param node The node + * @param strings An array of expected strings of length count + * @param count The number of strings + * @return The index of the matched string, or @a count in case of error + */ +size_t mpack_node_enum_optional(mpack_node_t node, const char* strings[], size_t count); + +/** + * @} + */ + +/** + * @name Compound Node Functions + * @{ + */ + +/** + * Returns the length of the given array node. Raises mpack_error_type + * and returns 0 if the given node is not an array. + */ +size_t mpack_node_array_length(mpack_node_t node); + +/** + * Returns the node in the given array at the given index. If the node + * is not an array, @ref mpack_error_type is raised and a nil node is returned. + * If the given index is out of bounds, @ref mpack_error_data is raised and + * a nil node is returned. + */ +mpack_node_t mpack_node_array_at(mpack_node_t node, size_t index); + +/** + * Returns the number of key/value pairs in the given map node. Raises + * mpack_error_type and returns 0 if the given node is not a map. + */ +size_t mpack_node_map_count(mpack_node_t node); + +/** + * Returns the key node in the given map at the given index. + * + * A nil node is returned in case of error. + * + * @throws mpack_error_type if the node is not a map + * @throws mpack_error_data if the given index is out of bounds + */ +mpack_node_t mpack_node_map_key_at(mpack_node_t node, size_t index); + +/** + * Returns the value node in the given map at the given index. + * + * A nil node is returned in case of error. + * + * @throws mpack_error_type if the node is not a map + * @throws mpack_error_data if the given index is out of bounds + */ +mpack_node_t mpack_node_map_value_at(mpack_node_t node, size_t index); + +/** + * Returns the value node in the given map for the given integer key. + * + * The key must exist within the map. Use mpack_node_map_int_optional() to + * check for optional keys. + * + * The key must be unique. An error is flagged if the node has multiple + * entries with the given key. + * + * @throws mpack_error_type If the node is not a map + * @throws mpack_error_data If the node does not contain exactly one entry with the given key + * + * @return The value node for the given key, or a nil node in case of error + */ +mpack_node_t mpack_node_map_int(mpack_node_t node, int64_t num); + +/** + * Returns the value node in the given map for the given integer key, or a + * missing node if the map does not contain the given key. + * + * The key must be unique. An error is flagged if the node has multiple + * entries with the given key. + * + * @throws mpack_error_type If the node is not a map + * @throws mpack_error_data If the node contains more than one entry with the given key + * + * @return The value node for the given key, or a missing node if the key does + * not exist, or a nil node in case of error + * + * @see mpack_node_is_missing() + */ +mpack_node_t mpack_node_map_int_optional(mpack_node_t node, int64_t num); + +/** + * Returns the value node in the given map for the given unsigned integer key. + * + * The key must exist within the map. Use mpack_node_map_uint_optional() to + * check for optional keys. + * + * The key must be unique. An error is flagged if the node has multiple + * entries with the given key. + * + * @throws mpack_error_type If the node is not a map + * @throws mpack_error_data If the node does not contain exactly one entry with the given key + * + * @return The value node for the given key, or a nil node in case of error + */ +mpack_node_t mpack_node_map_uint(mpack_node_t node, uint64_t num); + +/** + * Returns the value node in the given map for the given unsigned integer + * key, or a missing node if the map does not contain the given key. + * + * The key must be unique. An error is flagged if the node has multiple + * entries with the given key. + * + * @throws mpack_error_type If the node is not a map + * @throws mpack_error_data If the node contains more than one entry with the given key + * + * @return The value node for the given key, or a missing node if the key does + * not exist, or a nil node in case of error + * + * @see mpack_node_is_missing() + */ +mpack_node_t mpack_node_map_uint_optional(mpack_node_t node, uint64_t num); + +/** + * Returns the value node in the given map for the given string key. + * + * The key must exist within the map. Use mpack_node_map_str_optional() to + * check for optional keys. + * + * The key must be unique. An error is flagged if the node has multiple + * entries with the given key. + * + * @throws mpack_error_type If the node is not a map + * @throws mpack_error_data If the node does not contain exactly one entry with the given key + * + * @return The value node for the given key, or a nil node in case of error + */ +mpack_node_t mpack_node_map_str(mpack_node_t node, const char* str, size_t length); + +/** + * Returns the value node in the given map for the given string key, or a missing + * node if the map does not contain the given key. + * + * The key must be unique. An error is flagged if the node has multiple + * entries with the given key. + * + * @throws mpack_error_type If the node is not a map + * @throws mpack_error_data If the node contains more than one entry with the given key + * + * @return The value node for the given key, or a missing node if the key does + * not exist, or a nil node in case of error + * + * @see mpack_node_is_missing() + */ +mpack_node_t mpack_node_map_str_optional(mpack_node_t node, const char* str, size_t length); + +/** + * Returns the value node in the given map for the given null-terminated + * string key. + * + * The key must exist within the map. Use mpack_node_map_cstr_optional() to + * check for optional keys. + * + * The key must be unique. An error is flagged if the node has multiple + * entries with the given key. + * + * @throws mpack_error_type If the node is not a map + * @throws mpack_error_data If the node does not contain exactly one entry with the given key + * + * @return The value node for the given key, or a nil node in case of error + */ +mpack_node_t mpack_node_map_cstr(mpack_node_t node, const char* cstr); + +/** + * Returns the value node in the given map for the given null-terminated + * string key, or a missing node if the map does not contain the given key. + * + * The key must be unique. An error is flagged if the node has multiple + * entries with the given key. + * + * @throws mpack_error_type If the node is not a map + * @throws mpack_error_data If the node contains more than one entry with the given key + * + * @return The value node for the given key, or a missing node if the key does + * not exist, or a nil node in case of error + * + * @see mpack_node_is_missing() + */ +mpack_node_t mpack_node_map_cstr_optional(mpack_node_t node, const char* cstr); + +/** + * Returns true if the given node map contains exactly one entry with the + * given integer key. + * + * The key must be unique. An error is flagged if the node has multiple + * entries with the given key. + * + * @throws mpack_error_type If the node is not a map + * @throws mpack_error_data If the node contains more than one entry with the given key + */ +bool mpack_node_map_contains_int(mpack_node_t node, int64_t num); + +/** + * Returns true if the given node map contains exactly one entry with the + * given unsigned integer key. + * + * The key must be unique. An error is flagged if the node has multiple + * entries with the given key. + * + * @throws mpack_error_type If the node is not a map + * @throws mpack_error_data If the node contains more than one entry with the given key + */ +bool mpack_node_map_contains_uint(mpack_node_t node, uint64_t num); + +/** + * Returns true if the given node map contains exactly one entry with the + * given string key. + * + * The key must be unique. An error is flagged if the node has multiple + * entries with the given key. + * + * @throws mpack_error_type If the node is not a map + * @throws mpack_error_data If the node contains more than one entry with the given key + */ +bool mpack_node_map_contains_str(mpack_node_t node, const char* str, size_t length); + +/** + * Returns true if the given node map contains exactly one entry with the + * given null-terminated string key. + * + * The key must be unique. An error is flagged if the node has multiple + * entries with the given key. + * + * @throws mpack_error_type If the node is not a map + * @throws mpack_error_data If the node contains more than one entry with the given key + */ +bool mpack_node_map_contains_cstr(mpack_node_t node, const char* cstr); + +/** + * @} + */ + +/** + * @} + */ + +#endif + +MPACK_EXTERN_C_END +MPACK_SILENCE_WARNINGS_END + +#endif + + +#endif + diff --git a/common/include/tap.h b/common/include/tap.h index 47286f5..14ca309 100644 --- a/common/include/tap.h +++ b/common/include/tap.h @@ -12,6 +12,8 @@ void tap_close(int sockfd); int tap_up_link(const char *eth); int tap_get_mtu(const char *eth); +int tap_set_rps(const char *eth, int thread_index, const char *rps_mask); + #ifdef __cpluscplus } #endif diff --git a/common/include/tfe_acceptor_kni.h b/common/include/tfe_acceptor_kni.h deleted file mode 100644 index 3871dbc..0000000 --- a/common/include/tfe_acceptor_kni.h +++ /dev/null @@ -1,147 +0,0 @@ -#ifndef _TFE_ACCEPTOR_KNI_H -#define _TFE_ACCEPTOR_KNI_H - -#ifdef __cpluscplus -extern "C" -{ -#endif - -#include -#include - -// #include "proxy.h" -#include "tfe_utils.h" -#include "tfe_timestamp.h" -#include "tfe_packet_io.h" -#include "tfe_session_table.h" - - /****************************************************************************** - * Struct For tap - ******************************************************************************/ - - struct tap_config - { - int enable_iouring; - int enable_debuglog; - - int ring_size; - int buff_size; - - int flags; - int sq_thread_idle; - - char src_mac[6]; - char tap_mac[6]; - char tap_c_mac[6]; - char tap_s_mac[6]; - char tap_device[16]; - char tap_c_device[16]; - char tap_s_device[16]; - int tap_rps_enable; - char tap_rps_mask[TFE_SYMBOL_MAX]; - - struct bpf_ctx *tap_bpf_ctx; - }; - - struct tap_ctx - { - int tap_s; - int tap_c; - int tap_fd; - - struct io_uring_instance *io_uring_fd; - struct io_uring_instance *io_uring_c; - struct io_uring_instance *io_uring_s; - - int buff_size; - char *buff; - }; - - /****************************************************************************** - * Struct For Thread - ******************************************************************************/ - struct acceptor_thread_ctx - { - pthread_t tid; - int thread_index; - - struct tap_ctx *tap_ctx; - struct session_table *session_table; - struct sf_metrics *sf_metrics; - - struct tap_config *ref_tap_config; - struct packet_io *ref_io; - struct global_metrics *ref_metrics; - struct policy_enforcer *ref_enforcer; - struct acceptor_ctx *ref_acceptor_ctx; - struct tfe_proxy *ref_proxy; - - int session_table_need_reset; - }; - - /****************************************************************************** - * Struct For Session - ******************************************************************************/ - - struct packet_info - { - int is_e2i_dir; - struct addr_tuple4 tuple4; - - char *header_data; - int header_len; - }; - - struct session_ctx - { - int policy_ids; - uint64_t session_id; - char *session_addr; - - char client_mac[6]; - char server_mac[6]; - - struct packet_info c2s_info; - struct packet_info s2c_info; - - struct metadata *raw_meta_i2e; - struct metadata *raw_meta_e2i; - struct metadata *ctrl_meta; - - struct tfe_cmsg *cmsg; - - struct acceptor_thread_ctx *ref_thread_ctx; - }; - - struct session_ctx *session_ctx_new(); - void session_ctx_free(struct session_ctx *ctx); - - /****************************************************************************** - * Struct For KNI - ******************************************************************************/ - - struct acceptor_ctx - { - int firewall_sids; - int sce_sids; - int nr_worker_threads; - - int cpu_affinity_mask[TFE_THREAD_MAX]; - - cpu_set_t coremask; - struct tap_config *config; - struct packet_io *io; - struct global_metrics *metrics; - struct acceptor_thread_ctx work_threads[TFE_THREAD_MAX]; - - struct tfe_proxy *ref_proxy; - }; - - struct acceptor_ctx *acceptor_ctx_create(const char *profile); - void acceptor_ctx_destory(struct acceptor_ctx *ctx); - -#ifdef __cpluscplus -} -#endif - -#endif diff --git a/common/include/tfe_packet_io.h b/common/include/tfe_packet_io.h index 5f1a6d8..1795cc9 100644 --- a/common/include/tfe_packet_io.h +++ b/common/include/tfe_packet_io.h @@ -6,15 +6,104 @@ extern "C" { #endif -struct packet_io *packet_io_create(const char *profile, int thread_num, cpu_set_t *coremask); -void packet_io_destory(struct packet_io *handle); +#include "tfe_addr_tuple4.h" + +struct tap_ctx +{ + int tap_s; + int tap_c; + int tap_fd; + + int eventfd; + int eventfd_c; + int eventfd_s; + + struct io_uring_instance *io_uring_fd; + struct io_uring_instance *io_uring_c; + struct io_uring_instance *io_uring_s; + + int buff_size; + char *buff; +}; + +struct acceptor_thread_ctx +{ + pthread_t tid; + int thread_index; + + struct tap_ctx *tap_ctx; + struct session_table *session_table; + struct sf_metrics *sf_metrics; + + struct packet_io *ref_io; + struct global_metrics *ref_metrics; + struct policy_enforcer *ref_enforcer; + struct tfe_proxy *ref_proxy; + struct acceptor_kni_v4 *ref_acceptor_ctx; + + int session_table_need_reset; +}; + +struct packet_info +{ + int is_e2i_dir; + struct addr_tuple4 tuple4; + + char *header_data; + int header_len; +}; + +struct session_ctx +{ + int policy_ids; + uint64_t session_id; + char *session_addr; + + char client_mac[6]; + char server_mac[6]; + + struct packet_info c2s_info; + struct packet_info s2c_info; + + struct metadata *raw_meta_i2e; + struct metadata *raw_meta_e2i; + struct metadata *ctrl_meta; + + struct tfe_cmsg *cmsg; + + struct acceptor_thread_ctx *ref_thread_ctx; +}; + +struct acceptor_kni_v4 +{ + int firewall_sids; + int proxy_sids; + int sce_sids; + int nr_worker_threads; + + int cpu_affinity_mask[TFE_THREAD_MAX]; + + cpu_set_t coremask; + struct packet_io *io; + struct global_metrics *metrics; + struct acceptor_thread_ctx work_threads[TFE_THREAD_MAX]; + + struct tfe_proxy *ref_proxy; +}; + +int is_enable_iouring(struct packet_io *handle); + +void tfe_tap_ctx_destory(struct tap_ctx *handler); +struct tap_ctx *tfe_tap_ctx_create(void *ctx); int packet_io_thread_init(struct packet_io *handle, struct acceptor_thread_ctx *thread_ctx); void packet_io_thread_wait(struct packet_io *handle, struct acceptor_thread_ctx *thread_ctx, int timeout_ms); +void packet_io_destory(struct packet_io *handle); +struct packet_io *packet_io_create(const char *profile, int thread_num, cpu_set_t *coremask); int packet_io_polling_nf_interface(struct packet_io *handle, int thread_seq, void *ctx); -void handle_raw_packet_from_tap(const char *data, int len, void *args); void handle_decryption_packet_from_tap(const char *data, int len, void *args); +void handle_raw_packet_from_tap(const char *data, int len, void *args); #ifdef __cpluscplus } diff --git a/common/include/tfe_tap_rss.h b/common/include/tfe_tap_rss.h deleted file mode 100644 index 3ae0872..0000000 --- a/common/include/tfe_tap_rss.h +++ /dev/null @@ -1,35 +0,0 @@ -#ifndef _TFE_TAP_RSS_H_ -#define _TFE_TAP_RSS_H_ - -#ifdef __cplusplus -extern "C" -{ -#endif - -#define TAP_RSS_LOG_TAG "TAP_RSS: " - -struct bpf_ctx; - -int tfe_tap_get_bpf_prog_fd(struct bpf_ctx *ctx); - -struct bpf_ctx *tfe_tap_global_load_rss_bpf(const char *bpf_obj_file, uint32_t bpf_queue_num, uint32_t bpf_hash_mode, uint32_t bpf_debug_log, void *logger); -void tfe_tap_global_unload_rss_bpf(struct bpf_ctx *ctx); - -struct tap_ctx *tfe_tap_ctx_create(void *ctx); - -struct tap_config *tfe_tap_config_create(const char *profile, int thread_num); -void tfe_tap_destory(struct tap_config *tap); - -int tfe_tap_set_rps(void *local_logger, const char *tap_name, int thread_num, const char *rps_mask); - -int tfe_tap_open_per_thread(const char *tap_dev, int tap_flags, int bpf_prog_fd, void *logger); -void tfe_tap_close_per_thread(int tap_fd); - -int tfe_tap_read_per_thread(int tap_fd, char *buff, int buff_size, void *logger); -int tfe_tap_write_per_thread(int tap_fd, const char *data, int data_len, void *logger); - -#ifdef __cplusplus -} -#endif - -#endif \ No newline at end of file diff --git a/common/include/tfe_timestamp.h b/common/include/tfe_timestamp.h deleted file mode 100644 index 4266c87..0000000 --- a/common/include/tfe_timestamp.h +++ /dev/null @@ -1,24 +0,0 @@ -#ifndef _TFE_TIMESTAMP_H -#define _TFE_TIMESTAMP_H - -#ifdef __cpluscplus -extern "C" -{ -#endif - -#include - -struct timestamp *timestamp_new(uint64_t update_interval_ms); -void timestamp_free(struct timestamp *ts); - -void timestamp_update(struct timestamp *ts); -uint64_t timestamp_update_interval_ms(struct timestamp *ts); - -uint64_t timestamp_get_sec(struct timestamp *ts); -uint64_t timestamp_get_msec(struct timestamp *ts); - -#ifdef __cpluscplus -} -#endif - -#endif diff --git a/common/src/mpack.cpp b/common/src/mpack.cpp new file mode 100644 index 0000000..4f0dab4 --- /dev/null +++ b/common/src/mpack.cpp @@ -0,0 +1,7304 @@ +/** + * The MIT License (MIT) + * + * Copyright (c) 2015-2021 Nicholas Fraser and the MPack authors + * + * 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. + * + */ + +/* + * This is the MPack 1.1.1 amalgamation package. + * + * http://github.com/ludocode/mpack + */ + +#define MPACK_INTERNAL 1 +#define MPACK_EMIT_INLINE_DEFS 1 + +#include "mpack.h" + + +/* mpack/mpack-platform.c.c */ + + +// We define MPACK_EMIT_INLINE_DEFS and include mpack.h to emit +// standalone definitions of all (non-static) inline functions in MPack. + +#define MPACK_INTERNAL 1 +#define MPACK_EMIT_INLINE_DEFS 1 + +/* #include "mpack-platform.h" */ +/* #include "mpack.h" */ + +MPACK_SILENCE_WARNINGS_BEGIN + +#if MPACK_DEBUG + +#if MPACK_STDIO +void mpack_assert_fail_format(const char* format, ...) { + char buffer[512]; + va_list args; + va_start(args, format); + vsnprintf(buffer, sizeof(buffer), format, args); + va_end(args); + buffer[sizeof(buffer) - 1] = 0; + mpack_assert_fail_wrapper(buffer); +} + +void mpack_break_hit_format(const char* format, ...) { + char buffer[512]; + va_list args; + va_start(args, format); + vsnprintf(buffer, sizeof(buffer), format, args); + va_end(args); + buffer[sizeof(buffer) - 1] = 0; + mpack_break_hit(buffer); +} +#endif + +#if !MPACK_CUSTOM_ASSERT +void mpack_assert_fail(const char* message) { + MPACK_UNUSED(message); + + #if MPACK_STDIO + fprintf(stderr, "%s\n", message); + #endif +} +#endif + +// We split the assert failure from the wrapper so that a +// custom assert function can return. +void mpack_assert_fail_wrapper(const char* message) { + + #ifdef MPACK_GCOV + // gcov marks even __builtin_unreachable() as an uncovered line. this + // silences it. + (mpack_assert_fail(message), __builtin_unreachable()); + + #else + mpack_assert_fail(message); + + // mpack_assert_fail() is not supposed to return. in case it does, we + // abort. + + #if !MPACK_NO_BUILTINS + #if defined(__GNUC__) || defined(__clang__) + __builtin_trap(); + #elif defined(WIN32) + __debugbreak(); + #endif + #endif + + #if (defined(__GNUC__) || defined(__clang__)) && !MPACK_NO_BUILTINS + __builtin_abort(); + #elif MPACK_STDLIB + abort(); + #endif + + MPACK_UNREACHABLE; + #endif +} + +#if !MPACK_CUSTOM_BREAK + +// If we have a custom assert handler, break wraps it by default. +// This allows users of MPack to only implement mpack_assert_fail() without +// having to worry about the difference between assert and break. +// +// MPACK_CUSTOM_BREAK is available to define a separate break handler +// (which is needed by the unit test suite), but this is not offered in +// mpack-config.h for simplicity. + +#if MPACK_CUSTOM_ASSERT +void mpack_break_hit(const char* message) { + mpack_assert_fail_wrapper(message); +} +#else +void mpack_break_hit(const char* message) { + MPACK_UNUSED(message); + + #if MPACK_STDIO + fprintf(stderr, "%s\n", message); + #endif + + #if defined(__GNUC__) || defined(__clang__) && !MPACK_NO_BUILTINS + __builtin_trap(); + #elif defined(WIN32) && !MPACK_NO_BUILTINS + __debugbreak(); + #elif MPACK_STDLIB + abort(); + #endif +} +#endif + +#endif + +#endif + + + +// The below are adapted from the C wikibook: +// https://en.wikibooks.org/wiki/C_Programming/Strings + +#ifndef mpack_memcmp +int mpack_memcmp(const void* s1, const void* s2, size_t n) { + const unsigned char *us1 = (const unsigned char *) s1; + const unsigned char *us2 = (const unsigned char *) s2; + while (n-- != 0) { + if (*us1 != *us2) + return (*us1 < *us2) ? -1 : +1; + us1++; + us2++; + } + return 0; +} +#endif + +#ifndef mpack_memcpy +void* mpack_memcpy(void* MPACK_RESTRICT s1, const void* MPACK_RESTRICT s2, size_t n) { + char* MPACK_RESTRICT dst = (char *)s1; + const char* MPACK_RESTRICT src = (const char *)s2; + while (n-- != 0) + *dst++ = *src++; + return s1; +} +#endif + +#ifndef mpack_memmove +void* mpack_memmove(void* s1, const void* s2, size_t n) { + char *p1 = (char *)s1; + const char *p2 = (const char *)s2; + if (p2 < p1 && p1 < p2 + n) { + p2 += n; + p1 += n; + while (n-- != 0) + *--p1 = *--p2; + } else + while (n-- != 0) + *p1++ = *p2++; + return s1; +} +#endif + +#ifndef mpack_memset +void* mpack_memset(void* s, int c, size_t n) { + unsigned char *us = (unsigned char *)s; + unsigned char uc = (unsigned char)c; + while (n-- != 0) + *us++ = uc; + return s; +} +#endif + +#ifndef mpack_strlen +size_t mpack_strlen(const char* s) { + const char* p = s; + while (*p != '\0') + p++; + return (size_t)(p - s); +} +#endif + + + +#if defined(MPACK_MALLOC) && !defined(MPACK_REALLOC) +void* mpack_realloc(void* old_ptr, size_t used_size, size_t new_size) { + if (new_size == 0) { + if (old_ptr) + MPACK_FREE(old_ptr); + return NULL; + } + + void* new_ptr = MPACK_MALLOC(new_size); + if (new_ptr == NULL) + return NULL; + + mpack_memcpy(new_ptr, old_ptr, used_size); + MPACK_FREE(old_ptr); + return new_ptr; +} +#endif + +MPACK_SILENCE_WARNINGS_END + +/* mpack/mpack-common.c.c */ + +#define MPACK_INTERNAL 1 + +/* #include "mpack-common.h" */ + +MPACK_SILENCE_WARNINGS_BEGIN + +const char* mpack_error_to_string(mpack_error_t error) { + #if MPACK_STRINGS + switch (error) { + #define MPACK_ERROR_STRING_CASE(e) case e: return #e + MPACK_ERROR_STRING_CASE(mpack_ok); + MPACK_ERROR_STRING_CASE(mpack_error_io); + MPACK_ERROR_STRING_CASE(mpack_error_invalid); + MPACK_ERROR_STRING_CASE(mpack_error_unsupported); + MPACK_ERROR_STRING_CASE(mpack_error_type); + MPACK_ERROR_STRING_CASE(mpack_error_too_big); + MPACK_ERROR_STRING_CASE(mpack_error_memory); + MPACK_ERROR_STRING_CASE(mpack_error_bug); + MPACK_ERROR_STRING_CASE(mpack_error_data); + MPACK_ERROR_STRING_CASE(mpack_error_eof); + #undef MPACK_ERROR_STRING_CASE + } + mpack_assert(0, "unrecognized error %i", (int)error); + return "(unknown mpack_error_t)"; + #else + MPACK_UNUSED(error); + return ""; + #endif +} + +const char* mpack_type_to_string(mpack_type_t type) { + #if MPACK_STRINGS + switch (type) { + #define MPACK_TYPE_STRING_CASE(e) case e: return #e + MPACK_TYPE_STRING_CASE(mpack_type_missing); + MPACK_TYPE_STRING_CASE(mpack_type_nil); + MPACK_TYPE_STRING_CASE(mpack_type_bool); + MPACK_TYPE_STRING_CASE(mpack_type_float); + MPACK_TYPE_STRING_CASE(mpack_type_double); + MPACK_TYPE_STRING_CASE(mpack_type_int); + MPACK_TYPE_STRING_CASE(mpack_type_uint); + MPACK_TYPE_STRING_CASE(mpack_type_str); + MPACK_TYPE_STRING_CASE(mpack_type_bin); + MPACK_TYPE_STRING_CASE(mpack_type_array); + MPACK_TYPE_STRING_CASE(mpack_type_map); + #if MPACK_EXTENSIONS + MPACK_TYPE_STRING_CASE(mpack_type_ext); + #endif + #undef MPACK_TYPE_STRING_CASE + } + mpack_assert(0, "unrecognized type %i", (int)type); + return "(unknown mpack_type_t)"; + #else + MPACK_UNUSED(type); + return ""; + #endif +} + +int mpack_tag_cmp(mpack_tag_t left, mpack_tag_t right) { + + // positive numbers may be stored as int; convert to uint + if (left.type == mpack_type_int && left.v.i >= 0) { + left.type = mpack_type_uint; + left.v.u = (uint64_t)left.v.i; + } + if (right.type == mpack_type_int && right.v.i >= 0) { + right.type = mpack_type_uint; + right.v.u = (uint64_t)right.v.i; + } + + if (left.type != right.type) + return ((int)left.type < (int)right.type) ? -1 : 1; + + switch (left.type) { + case mpack_type_missing: // fallthrough + case mpack_type_nil: + return 0; + + case mpack_type_bool: + return (int)left.v.b - (int)right.v.b; + + case mpack_type_int: + if (left.v.i == right.v.i) + return 0; + return (left.v.i < right.v.i) ? -1 : 1; + + case mpack_type_uint: + if (left.v.u == right.v.u) + return 0; + return (left.v.u < right.v.u) ? -1 : 1; + + case mpack_type_array: + case mpack_type_map: + if (left.v.n == right.v.n) + return 0; + return (left.v.n < right.v.n) ? -1 : 1; + + case mpack_type_str: + case mpack_type_bin: + if (left.v.l == right.v.l) + return 0; + return (left.v.l < right.v.l) ? -1 : 1; + + #if MPACK_EXTENSIONS + case mpack_type_ext: + if (left.exttype == right.exttype) { + if (left.v.l == right.v.l) + return 0; + return (left.v.l < right.v.l) ? -1 : 1; + } + return (int)left.exttype - (int)right.exttype; + #endif + + // floats should not normally be compared for equality. we compare + // with memcmp() to silence compiler warnings, but this will return + // equal if both are NaNs with the same representation (though we may + // want this, for instance if you are for some bizarre reason using + // floats as map keys.) i'm not sure what the right thing to + // do is here. check for NaN first? always return false if the type + // is float? use operator== and pragmas to silence compiler warning? + // please send me your suggestions. + // note also that we don't convert floats to doubles, so when this is + // used for ordering purposes, all floats are ordered before all + // doubles. + case mpack_type_float: + return mpack_memcmp(&left.v.f, &right.v.f, sizeof(left.v.f)); + case mpack_type_double: + return mpack_memcmp(&left.v.d, &right.v.d, sizeof(left.v.d)); + } + + mpack_assert(0, "unrecognized type %i", (int)left.type); + return false; +} + +#if MPACK_DEBUG && MPACK_STDIO +static char mpack_hex_char(uint8_t hex_value) { + // Older compilers (e.g. GCC 4.4.7) promote the result of this ternary to + // int and warn under -Wconversion, so we have to cast it back to char. + return (char)((hex_value < 10) ? (char)('0' + hex_value) : (char)('a' + (hex_value - 10))); +} + +static void mpack_tag_debug_complete_bin_ext(mpack_tag_t tag, size_t string_length, char* buffer, size_t buffer_size, + const char* prefix, size_t prefix_size) +{ + // If at any point in this function we run out of space in the buffer, we + // bail out. The outer tag print wrapper will make sure we have a + // null-terminator. + + if (string_length == 0 || string_length >= buffer_size) + return; + buffer += string_length; + buffer_size -= string_length; + + size_t total = mpack_tag_bytes(&tag); + if (total == 0) { + strncpy(buffer, ">", buffer_size); + return; + } + + strncpy(buffer, ": ", buffer_size); + if (buffer_size < 2) + return; + buffer += 2; + buffer_size -= 2; + + size_t hex_bytes = 0; + size_t i; + for (i = 0; i < MPACK_PRINT_BYTE_COUNT && i < prefix_size && buffer_size > 2; ++i) { + uint8_t byte = (uint8_t)prefix[i]; + buffer[0] = mpack_hex_char((uint8_t)(byte >> 4)); + buffer[1] = mpack_hex_char((uint8_t)(byte & 0xfu)); + buffer += 2; + buffer_size -= 2; + ++hex_bytes; + } + + if (buffer_size != 0) + mpack_snprintf(buffer, buffer_size, "%s>", (total > hex_bytes) ? "..." : ""); +} + +static void mpack_tag_debug_pseudo_json_bin(mpack_tag_t tag, char* buffer, size_t buffer_size, + const char* prefix, size_t prefix_size) +{ + mpack_assert(mpack_tag_type(&tag) == mpack_type_bin); + size_t length = (size_t)mpack_snprintf(buffer, buffer_size, ""); + return; + case mpack_type_nil: + mpack_snprintf(buffer, buffer_size, "null"); + return; + case mpack_type_bool: + mpack_snprintf(buffer, buffer_size, tag.v.b ? "true" : "false"); + return; + case mpack_type_int: + mpack_snprintf(buffer, buffer_size, "%" PRIi64, tag.v.i); + return; + case mpack_type_uint: + mpack_snprintf(buffer, buffer_size, "%" PRIu64, tag.v.u); + return; + case mpack_type_float: + #if MPACK_FLOAT + mpack_snprintf(buffer, buffer_size, "%f", tag.v.f); + #else + mpack_snprintf(buffer, buffer_size, ""); + #endif + return; + case mpack_type_double: + #if MPACK_DOUBLE + mpack_snprintf(buffer, buffer_size, "%f", tag.v.d); + #else + mpack_snprintf(buffer, buffer_size, ""); + #endif + return; + + case mpack_type_str: + mpack_snprintf(buffer, buffer_size, "", tag.v.l); + return; + case mpack_type_bin: + mpack_tag_debug_pseudo_json_bin(tag, buffer, buffer_size, prefix, prefix_size); + return; + #if MPACK_EXTENSIONS + case mpack_type_ext: + mpack_tag_debug_pseudo_json_ext(tag, buffer, buffer_size, prefix, prefix_size); + return; + #endif + + case mpack_type_array: + mpack_snprintf(buffer, buffer_size, "", tag.v.n); + return; + case mpack_type_map: + mpack_snprintf(buffer, buffer_size, "", tag.v.n); + return; + } + + mpack_snprintf(buffer, buffer_size, ""); +} + +void mpack_tag_debug_pseudo_json(mpack_tag_t tag, char* buffer, size_t buffer_size, + const char* prefix, size_t prefix_size) +{ + mpack_assert(buffer_size > 0, "buffer size cannot be zero!"); + buffer[0] = 0; + + mpack_tag_debug_pseudo_json_impl(tag, buffer, buffer_size, prefix, prefix_size); + + // We always null-terminate the buffer manually just in case the snprintf() + // function doesn't null-terminate when the string doesn't fit. + buffer[buffer_size - 1] = 0; +} + +static void mpack_tag_debug_describe_impl(mpack_tag_t tag, char* buffer, size_t buffer_size) { + switch (tag.type) { + case mpack_type_missing: + mpack_snprintf(buffer, buffer_size, "missing"); + return; + case mpack_type_nil: + mpack_snprintf(buffer, buffer_size, "nil"); + return; + case mpack_type_bool: + mpack_snprintf(buffer, buffer_size, tag.v.b ? "true" : "false"); + return; + case mpack_type_int: + mpack_snprintf(buffer, buffer_size, "int %" PRIi64, tag.v.i); + return; + case mpack_type_uint: + mpack_snprintf(buffer, buffer_size, "uint %" PRIu64, tag.v.u); + return; + case mpack_type_float: + #if MPACK_FLOAT + mpack_snprintf(buffer, buffer_size, "float %f", tag.v.f); + #else + mpack_snprintf(buffer, buffer_size, "float"); + #endif + return; + case mpack_type_double: + #if MPACK_DOUBLE + mpack_snprintf(buffer, buffer_size, "double %f", tag.v.d); + #else + mpack_snprintf(buffer, buffer_size, "double"); + #endif + return; + case mpack_type_str: + mpack_snprintf(buffer, buffer_size, "str of %" PRIu32 " bytes", tag.v.l); + return; + case mpack_type_bin: + mpack_snprintf(buffer, buffer_size, "bin of %" PRIu32 " bytes", tag.v.l); + return; + #if MPACK_EXTENSIONS + case mpack_type_ext: + mpack_snprintf(buffer, buffer_size, "ext of type %i, %" PRIu32 " bytes", + mpack_tag_ext_exttype(&tag), mpack_tag_ext_length(&tag)); + return; + #endif + case mpack_type_array: + mpack_snprintf(buffer, buffer_size, "array of %" PRIu32 " elements", tag.v.n); + return; + case mpack_type_map: + mpack_snprintf(buffer, buffer_size, "map of %" PRIu32 " key-value pairs", tag.v.n); + return; + } + + mpack_snprintf(buffer, buffer_size, "unknown!"); +} + +void mpack_tag_debug_describe(mpack_tag_t tag, char* buffer, size_t buffer_size) { + mpack_assert(buffer_size > 0, "buffer size cannot be zero!"); + buffer[0] = 0; + + mpack_tag_debug_describe_impl(tag, buffer, buffer_size); + + // We always null-terminate the buffer manually just in case the snprintf() + // function doesn't null-terminate when the string doesn't fit. + buffer[buffer_size - 1] = 0; +} +#endif + + + +#if MPACK_READ_TRACKING || MPACK_WRITE_TRACKING + +#ifndef MPACK_TRACKING_INITIAL_CAPACITY +// seems like a reasonable number. we grow by doubling, and it only +// needs to be as long as the maximum depth of the message. +#define MPACK_TRACKING_INITIAL_CAPACITY 8 +#endif + +mpack_error_t mpack_track_init(mpack_track_t* track) { + track->count = 0; + track->capacity = MPACK_TRACKING_INITIAL_CAPACITY; + track->elements = (mpack_track_element_t*)MPACK_MALLOC(sizeof(mpack_track_element_t) * track->capacity); + if (track->elements == NULL) + return mpack_error_memory; + return mpack_ok; +} + +mpack_error_t mpack_track_grow(mpack_track_t* track) { + mpack_assert(track->elements, "null track elements!"); + mpack_assert(track->count == track->capacity, "incorrect growing?"); + + size_t new_capacity = track->capacity * 2; + + mpack_track_element_t* new_elements = (mpack_track_element_t*)mpack_realloc(track->elements, + sizeof(mpack_track_element_t) * track->count, sizeof(mpack_track_element_t) * new_capacity); + if (new_elements == NULL) + return mpack_error_memory; + + track->elements = new_elements; + track->capacity = new_capacity; + return mpack_ok; +} + +mpack_error_t mpack_track_push(mpack_track_t* track, mpack_type_t type, uint32_t count) { + mpack_assert(track->elements, "null track elements!"); + mpack_log("track pushing %s count %i\n", mpack_type_to_string(type), (int)count); + + // grow if needed + if (track->count == track->capacity) { + mpack_error_t error = mpack_track_grow(track); + if (error != mpack_ok) + return error; + } + + // insert new track + track->elements[track->count].type = type; + track->elements[track->count].left = count; + track->elements[track->count].builder = false; + track->elements[track->count].key_needs_value = false; + ++track->count; + return mpack_ok; +} + +// TODO dedupe this +mpack_error_t mpack_track_push_builder(mpack_track_t* track, mpack_type_t type) { + mpack_assert(track->elements, "null track elements!"); + mpack_log("track pushing %s builder\n", mpack_type_to_string(type)); + + // grow if needed + if (track->count == track->capacity) { + mpack_error_t error = mpack_track_grow(track); + if (error != mpack_ok) + return error; + } + + // insert new track + track->elements[track->count].type = type; + track->elements[track->count].left = 0; + track->elements[track->count].builder = true; + track->elements[track->count].key_needs_value = false; + ++track->count; + return mpack_ok; +} + +static mpack_error_t mpack_track_pop_impl(mpack_track_t* track, mpack_type_t type, bool builder) { + mpack_assert(track->elements, "null track elements!"); + mpack_log("track popping %s\n", mpack_type_to_string(type)); + + if (track->count == 0) { + mpack_break("attempting to close a %s but nothing was opened!", mpack_type_to_string(type)); + return mpack_error_bug; + } + + mpack_track_element_t* element = &track->elements[track->count - 1]; + + if (element->type != type) { + mpack_break("attempting to close a %s but the open element is a %s!", + mpack_type_to_string(type), mpack_type_to_string(element->type)); + return mpack_error_bug; + } + + if (element->key_needs_value) { + mpack_assert(type == mpack_type_map, "key_needs_value can only be true for maps!"); + mpack_break("attempting to close a %s but an odd number of elements were written", + mpack_type_to_string(type)); + return mpack_error_bug; + } + + if (element->left != 0) { + mpack_break("attempting to close a %s but there are %i %s left", + mpack_type_to_string(type), element->left, + (type == mpack_type_map || type == mpack_type_array) ? "elements" : "bytes"); + return mpack_error_bug; + } + + if (element->builder != builder) { + mpack_break("attempting to pop a %sbuilder but the open element is %sa builder", + builder ? "" : "non-", + element->builder ? "" : "not "); + return mpack_error_bug; + } + + --track->count; + return mpack_ok; +} + +mpack_error_t mpack_track_pop(mpack_track_t* track, mpack_type_t type) { + return mpack_track_pop_impl(track, type, false); +} + +mpack_error_t mpack_track_pop_builder(mpack_track_t* track, mpack_type_t type) { + return mpack_track_pop_impl(track, type, true); +} + +mpack_error_t mpack_track_peek_element(mpack_track_t* track, bool read) { + MPACK_UNUSED(read); + mpack_assert(track->elements, "null track elements!"); + + // if there are no open elements, that's fine, we can read/write elements at will + if (track->count == 0) + return mpack_ok; + + mpack_track_element_t* element = &track->elements[track->count - 1]; + + if (element->type != mpack_type_map && element->type != mpack_type_array) { + mpack_break("elements cannot be %s within an %s", read ? "read" : "written", + mpack_type_to_string(element->type)); + return mpack_error_bug; + } + + if (!element->builder && element->left == 0 && !element->key_needs_value) { + mpack_break("too many elements %s for %s", read ? "read" : "written", + mpack_type_to_string(element->type)); + return mpack_error_bug; + } + + return mpack_ok; +} + +mpack_error_t mpack_track_element(mpack_track_t* track, bool read) { + mpack_error_t error = mpack_track_peek_element(track, read); + if (track->count == 0 || error != mpack_ok) + return error; + + mpack_track_element_t* element = &track->elements[track->count - 1]; + + if (element->type == mpack_type_map) { + if (!element->key_needs_value) { + element->key_needs_value = true; + return mpack_ok; // don't decrement + } + element->key_needs_value = false; + } + + if (!element->builder) + --element->left; + return mpack_ok; +} + +mpack_error_t mpack_track_bytes(mpack_track_t* track, bool read, size_t count) { + MPACK_UNUSED(read); + mpack_assert(track->elements, "null track elements!"); + + if (count > MPACK_UINT32_MAX) { + mpack_break("%s more bytes than could possibly fit in a str/bin/ext!", + read ? "reading" : "writing"); + return mpack_error_bug; + } + + if (track->count == 0) { + mpack_break("bytes cannot be %s with no open bin, str or ext", read ? "read" : "written"); + return mpack_error_bug; + } + + mpack_track_element_t* element = &track->elements[track->count - 1]; + + if (element->type == mpack_type_map || element->type == mpack_type_array) { + mpack_break("bytes cannot be %s within an %s", read ? "read" : "written", + mpack_type_to_string(element->type)); + return mpack_error_bug; + } + + if (element->left < count) { + mpack_break("too many bytes %s for %s", read ? "read" : "written", + mpack_type_to_string(element->type)); + return mpack_error_bug; + } + + element->left -= (uint32_t)count; + return mpack_ok; +} + +mpack_error_t mpack_track_str_bytes_all(mpack_track_t* track, bool read, size_t count) { + mpack_error_t error = mpack_track_bytes(track, read, count); + if (error != mpack_ok) + return error; + + mpack_track_element_t* element = &track->elements[track->count - 1]; + + if (element->type != mpack_type_str) { + mpack_break("the open type must be a string, not a %s", mpack_type_to_string(element->type)); + return mpack_error_bug; + } + + if (element->left != 0) { + mpack_break("not all bytes were read; the wrong byte count was requested for a string read."); + return mpack_error_bug; + } + + return mpack_ok; +} + +mpack_error_t mpack_track_check_empty(mpack_track_t* track) { + if (track->count != 0) { + mpack_break("unclosed %s", mpack_type_to_string(track->elements[0].type)); + return mpack_error_bug; + } + return mpack_ok; +} + +mpack_error_t mpack_track_destroy(mpack_track_t* track, bool cancel) { + mpack_error_t error = cancel ? mpack_ok : mpack_track_check_empty(track); + if (track->elements) { + MPACK_FREE(track->elements); + track->elements = NULL; + } + return error; +} +#endif + + + +static bool mpack_utf8_check_impl(const uint8_t* str, size_t count, bool allow_null) { + while (count > 0) { + uint8_t lead = str[0]; + + // NUL + if (!allow_null && lead == '\0') // we don't allow NUL bytes in MPack C-strings + return false; + + // ASCII + if (lead <= 0x7F) { + ++str; + --count; + + // 2-byte sequence + } else if ((lead & 0xE0) == 0xC0) { + if (count < 2) // truncated sequence + return false; + + uint8_t cont = str[1]; + if ((cont & 0xC0) != 0x80) // not a continuation byte + return false; + + str += 2; + count -= 2; + + uint32_t z = ((uint32_t)(lead & ~0xE0) << 6) | + (uint32_t)(cont & ~0xC0); + + if (z < 0x80) // overlong sequence + return false; + + // 3-byte sequence + } else if ((lead & 0xF0) == 0xE0) { + if (count < 3) // truncated sequence + return false; + + uint8_t cont1 = str[1]; + if ((cont1 & 0xC0) != 0x80) // not a continuation byte + return false; + uint8_t cont2 = str[2]; + if ((cont2 & 0xC0) != 0x80) // not a continuation byte + return false; + + str += 3; + count -= 3; + + uint32_t z = ((uint32_t)(lead & ~0xF0) << 12) | + ((uint32_t)(cont1 & ~0xC0) << 6) | + (uint32_t)(cont2 & ~0xC0); + + if (z < 0x800) // overlong sequence + return false; + if (z >= 0xD800 && z <= 0xDFFF) // surrogate + return false; + + // 4-byte sequence + } else if ((lead & 0xF8) == 0xF0) { + if (count < 4) // truncated sequence + return false; + + uint8_t cont1 = str[1]; + if ((cont1 & 0xC0) != 0x80) // not a continuation byte + return false; + uint8_t cont2 = str[2]; + if ((cont2 & 0xC0) != 0x80) // not a continuation byte + return false; + uint8_t cont3 = str[3]; + if ((cont3 & 0xC0) != 0x80) // not a continuation byte + return false; + + str += 4; + count -= 4; + + uint32_t z = ((uint32_t)(lead & ~0xF8) << 18) | + ((uint32_t)(cont1 & ~0xC0) << 12) | + ((uint32_t)(cont2 & ~0xC0) << 6) | + (uint32_t)(cont3 & ~0xC0); + + if (z < 0x10000) // overlong sequence + return false; + if (z > 0x10FFFF) // codepoint limit + return false; + + } else { + return false; // continuation byte without a lead, or lead for a 5-byte sequence or longer + } + } + return true; +} + +bool mpack_utf8_check(const char* str, size_t bytes) { + return mpack_utf8_check_impl((const uint8_t*)str, bytes, true); +} + +bool mpack_utf8_check_no_null(const char* str, size_t bytes) { + return mpack_utf8_check_impl((const uint8_t*)str, bytes, false); +} + +bool mpack_str_check_no_null(const char* str, size_t bytes) { + size_t i; + for (i = 0; i < bytes; ++i) + if (str[i] == '\0') + return false; + return true; +} + +#if MPACK_DEBUG && MPACK_STDIO +void mpack_print_append(mpack_print_t* print, const char* data, size_t count) { + + // copy whatever fits into the buffer + size_t copy = print->size - print->count; + if (copy > count) + copy = count; + mpack_memcpy(print->buffer + print->count, data, copy); + print->count += copy; + data += copy; + count -= copy; + + // if we don't need to flush or can't flush there's nothing else to do + if (count == 0 || print->callback == NULL) + return; + + // flush the buffer + print->callback(print->context, print->buffer, print->count); + + if (count > print->size / 2) { + // flush the rest of the data + print->count = 0; + print->callback(print->context, data, count); + } else { + // copy the rest of the data into the buffer + mpack_memcpy(print->buffer, data, count); + print->count = count; + } + +} + +void mpack_print_flush(mpack_print_t* print) { + if (print->count > 0 && print->callback != NULL) { + print->callback(print->context, print->buffer, print->count); + print->count = 0; + } +} + +void mpack_print_file_callback(void* context, const char* data, size_t count) { + FILE* file = (FILE*)context; + fwrite(data, 1, count, file); +} +#endif + +MPACK_SILENCE_WARNINGS_END + +/* mpack/mpack-writer.c.c */ + +#define MPACK_INTERNAL 1 + +/* #include "mpack-writer.h" */ + +MPACK_SILENCE_WARNINGS_BEGIN + +#if MPACK_WRITER + +#if MPACK_BUILDER +static void mpack_builder_flush(mpack_writer_t* writer); +#endif + +#if MPACK_WRITE_TRACKING +static void mpack_writer_flag_if_error(mpack_writer_t* writer, mpack_error_t error) { + if (error != mpack_ok) + mpack_writer_flag_error(writer, error); +} + +void mpack_writer_track_push(mpack_writer_t* writer, mpack_type_t type, uint32_t count) { + if (writer->error == mpack_ok) + mpack_writer_flag_if_error(writer, mpack_track_push(&writer->track, type, count)); +} + +void mpack_writer_track_push_builder(mpack_writer_t* writer, mpack_type_t type) { + if (writer->error == mpack_ok) + mpack_writer_flag_if_error(writer, mpack_track_push_builder(&writer->track, type)); +} + +void mpack_writer_track_pop(mpack_writer_t* writer, mpack_type_t type) { + if (writer->error == mpack_ok) + mpack_writer_flag_if_error(writer, mpack_track_pop(&writer->track, type)); +} + +void mpack_writer_track_pop_builder(mpack_writer_t* writer, mpack_type_t type) { + if (writer->error == mpack_ok) + mpack_writer_flag_if_error(writer, mpack_track_pop_builder(&writer->track, type)); +} + +void mpack_writer_track_bytes(mpack_writer_t* writer, size_t count) { + if (writer->error == mpack_ok) + mpack_writer_flag_if_error(writer, mpack_track_bytes(&writer->track, false, count)); +} +#endif + +// This should probably be renamed. It's not solely used for tracking. +static inline void mpack_writer_track_element(mpack_writer_t* writer) { + (void)writer; + + #if MPACK_WRITE_TRACKING + if (writer->error == mpack_ok) + mpack_writer_flag_if_error(writer, mpack_track_element(&writer->track, false)); + #endif + + #if MPACK_BUILDER + if (writer->builder.current_build != NULL) { + mpack_build_t* build = writer->builder.current_build; + // We only track this write if it's not nested within another non-build + // map or array. + if (build->nested_compound_elements == 0) { + if (build->type != mpack_type_map) { + ++build->count; + mpack_log("adding element to build %p, now %" PRIu32 " elements\n", (void*)build, build->count); + } else if (build->key_needs_value) { + build->key_needs_value = false; + ++build->count; + } else { + build->key_needs_value = true; + } + } + } + #endif +} + +static void mpack_writer_clear(mpack_writer_t* writer) { + #if MPACK_COMPATIBILITY + writer->version = mpack_version_current; + #endif + writer->flush = NULL; + writer->error_fn = NULL; + writer->teardown = NULL; + writer->context = NULL; + + writer->buffer = NULL; + writer->position = NULL; + writer->end = NULL; + writer->error = mpack_ok; + + #if MPACK_WRITE_TRACKING + mpack_memset(&writer->track, 0, sizeof(writer->track)); + #endif + + #if MPACK_BUILDER + writer->builder.current_build = NULL; + writer->builder.latest_build = NULL; + writer->builder.current_page = NULL; + writer->builder.pages = NULL; + writer->builder.stash_buffer = NULL; + writer->builder.stash_position = NULL; + writer->builder.stash_end = NULL; + #endif +} + +void mpack_writer_init(mpack_writer_t* writer, char* buffer, size_t size) { + mpack_assert(buffer != NULL, "cannot initialize writer with empty buffer"); + mpack_writer_clear(writer); + writer->buffer = buffer; + writer->position = buffer; + writer->end = writer->buffer + size; + + #if MPACK_WRITE_TRACKING + mpack_writer_flag_if_error(writer, mpack_track_init(&writer->track)); + #endif + + mpack_log("===========================\n"); + mpack_log("initializing writer with buffer size %i\n", (int)size); +} + +void mpack_writer_init_error(mpack_writer_t* writer, mpack_error_t error) { + mpack_writer_clear(writer); + writer->error = error; + + mpack_log("===========================\n"); + mpack_log("initializing writer in error state %i\n", (int)error); +} + +void mpack_writer_set_flush(mpack_writer_t* writer, mpack_writer_flush_t flush) { + MPACK_STATIC_ASSERT(MPACK_WRITER_MINIMUM_BUFFER_SIZE >= MPACK_MAXIMUM_TAG_SIZE, + "minimum buffer size must fit any tag!"); + MPACK_STATIC_ASSERT(31 + MPACK_TAG_SIZE_FIXSTR >= MPACK_WRITER_MINIMUM_BUFFER_SIZE, + "minimum buffer size must fit the largest possible fixstr!"); + + if (mpack_writer_buffer_size(writer) < MPACK_WRITER_MINIMUM_BUFFER_SIZE) { + mpack_break("buffer size is %i, but minimum buffer size for flush is %i", + (int)mpack_writer_buffer_size(writer), MPACK_WRITER_MINIMUM_BUFFER_SIZE); + mpack_writer_flag_error(writer, mpack_error_bug); + return; + } + + writer->flush = flush; +} + +#ifdef MPACK_MALLOC +typedef struct mpack_growable_writer_t { + char** target_data; + size_t* target_size; +} mpack_growable_writer_t; + +static char* mpack_writer_get_reserved(mpack_writer_t* writer) { + // This is in a separate function in order to avoid false strict aliasing + // warnings. We aren't actually violating strict aliasing (the reserved + // space is only ever dereferenced as an mpack_growable_writer_t.) + return (char*)writer->reserved; +} + +static void mpack_growable_writer_flush(mpack_writer_t* writer, const char* data, size_t count) { + + // This is an intrusive flush function which modifies the writer's buffer + // in response to a flush instead of emptying it in order to add more + // capacity for data. This removes the need to copy data from a fixed buffer + // into a growable one, improving performance. + // + // There are three ways flush can be called: + // - flushing the buffer during writing (used is zero, count is all data, data is buffer) + // - flushing extra data during writing (used is all flushed data, count is extra data, data is not buffer) + // - flushing during teardown (used and count are both all flushed data, data is buffer) + // + // In the first two cases, we grow the buffer by at least double, enough + // to ensure that new data will fit. We ignore the teardown flush. + + if (data == writer->buffer) { + + // teardown, do nothing + if (mpack_writer_buffer_used(writer) == count) + return; + + // otherwise leave the data in the buffer and just grow + writer->position = writer->buffer + count; + count = 0; + } + + size_t used = mpack_writer_buffer_used(writer); + size_t size = mpack_writer_buffer_size(writer); + + mpack_log("flush size %i used %i data %p buffer %p\n", + (int)count, (int)used, data, writer->buffer); + + mpack_assert(data == writer->buffer || used + count > size, + "extra flush for %i but there is %i space left in the buffer! (%i/%i)", + (int)count, (int)mpack_writer_buffer_left(writer), (int)used, (int)size); + + // grow to fit the data + // TODO: this really needs to correctly test for overflow + size_t new_size = size * 2; + while (new_size < used + count) + new_size *= 2; + + mpack_log("flush growing buffer size from %i to %i\n", (int)size, (int)new_size); + + // grow the buffer + char* new_buffer = (char*)mpack_realloc(writer->buffer, used, new_size); + if (new_buffer == NULL) { + mpack_writer_flag_error(writer, mpack_error_memory); + return; + } + writer->position = new_buffer + used; + writer->buffer = new_buffer; + writer->end = writer->buffer + new_size; + + // append the extra data + if (count > 0) { + mpack_memcpy(writer->position, data, count); + writer->position += count; + } + + mpack_log("new buffer %p, used %i\n", new_buffer, (int)mpack_writer_buffer_used(writer)); +} + +static void mpack_growable_writer_teardown(mpack_writer_t* writer) { + mpack_growable_writer_t* growable_writer = (mpack_growable_writer_t*)mpack_writer_get_reserved(writer); + + if (mpack_writer_error(writer) == mpack_ok) { + + // shrink the buffer to an appropriate size if the data is + // much smaller than the buffer + if (mpack_writer_buffer_used(writer) < mpack_writer_buffer_size(writer) / 2) { + size_t used = mpack_writer_buffer_used(writer); + + // We always return a non-null pointer that must be freed, even if + // nothing was written. malloc() and realloc() do not necessarily + // do this so we enforce it ourselves. + size_t size = (used != 0) ? used : 1; + + char* buffer = (char*)mpack_realloc(writer->buffer, used, size); + if (!buffer) { + MPACK_FREE(writer->buffer); + mpack_writer_flag_error(writer, mpack_error_memory); + return; + } + writer->buffer = buffer; + writer->end = (writer->position = writer->buffer + used); + } + + *growable_writer->target_data = writer->buffer; + *growable_writer->target_size = mpack_writer_buffer_used(writer); + writer->buffer = NULL; + + } else if (writer->buffer) { + MPACK_FREE(writer->buffer); + writer->buffer = NULL; + } + + writer->context = NULL; +} + +void mpack_writer_init_growable(mpack_writer_t* writer, char** target_data, size_t* target_size) { + mpack_assert(target_data != NULL, "cannot initialize writer without a destination for the data"); + mpack_assert(target_size != NULL, "cannot initialize writer without a destination for the size"); + + *target_data = NULL; + *target_size = 0; + + MPACK_STATIC_ASSERT(sizeof(mpack_growable_writer_t) <= sizeof(writer->reserved), + "not enough reserved space for growable writer!"); + mpack_growable_writer_t* growable_writer = (mpack_growable_writer_t*)mpack_writer_get_reserved(writer); + + growable_writer->target_data = target_data; + growable_writer->target_size = target_size; + + size_t capacity = MPACK_BUFFER_SIZE; + char* buffer = (char*)MPACK_MALLOC(capacity); + if (buffer == NULL) { + mpack_writer_init_error(writer, mpack_error_memory); + return; + } + + mpack_writer_init(writer, buffer, capacity); + mpack_writer_set_flush(writer, mpack_growable_writer_flush); + mpack_writer_set_teardown(writer, mpack_growable_writer_teardown); +} +#endif + +#if MPACK_STDIO +static void mpack_file_writer_flush(mpack_writer_t* writer, const char* buffer, size_t count) { + FILE* file = (FILE*)writer->context; + size_t written = fwrite((const void*)buffer, 1, count, file); + if (written != count) + mpack_writer_flag_error(writer, mpack_error_io); +} + +static void mpack_file_writer_teardown(mpack_writer_t* writer) { + MPACK_FREE(writer->buffer); + writer->buffer = NULL; + writer->context = NULL; +} + +static void mpack_file_writer_teardown_close(mpack_writer_t* writer) { + FILE* file = (FILE*)writer->context; + + if (file) { + int ret = fclose(file); + if (ret != 0) + mpack_writer_flag_error(writer, mpack_error_io); + } + + mpack_file_writer_teardown(writer); +} + +void mpack_writer_init_stdfile(mpack_writer_t* writer, FILE* file, bool close_when_done) { + mpack_assert(file != NULL, "file is NULL"); + + size_t capacity = MPACK_BUFFER_SIZE; + char* buffer = (char*)MPACK_MALLOC(capacity); + if (buffer == NULL) { + mpack_writer_init_error(writer, mpack_error_memory); + if (close_when_done) { + fclose(file); + } + return; + } + + mpack_writer_init(writer, buffer, capacity); + mpack_writer_set_context(writer, file); + mpack_writer_set_flush(writer, mpack_file_writer_flush); + mpack_writer_set_teardown(writer, close_when_done ? + mpack_file_writer_teardown_close : + mpack_file_writer_teardown); +} + +void mpack_writer_init_filename(mpack_writer_t* writer, const char* filename) { + mpack_assert(filename != NULL, "filename is NULL"); + + FILE* file = fopen(filename, "wb"); + if (file == NULL) { + mpack_writer_init_error(writer, mpack_error_io); + return; + } + + mpack_writer_init_stdfile(writer, file, true); +} +#endif + +void mpack_writer_flag_error(mpack_writer_t* writer, mpack_error_t error) { + mpack_log("writer %p setting error %i: %s\n", (void*)writer, (int)error, mpack_error_to_string(error)); + + if (writer->error == mpack_ok) { + writer->error = error; + if (writer->error_fn) + writer->error_fn(writer, writer->error); + } +} + +MPACK_STATIC_INLINE void mpack_writer_flush_unchecked(mpack_writer_t* writer) { + // This is a bit ugly; we reset used before calling flush so that + // a flush function can distinguish between flushing the buffer + // versus flushing external data. see mpack_growable_writer_flush() + size_t used = mpack_writer_buffer_used(writer); + writer->position = writer->buffer; + writer->flush(writer, writer->buffer, used); +} + +void mpack_writer_flush_message(mpack_writer_t* writer) { + if (writer->error != mpack_ok) + return; + + #if MPACK_WRITE_TRACKING + // You cannot flush while there are elements open. + mpack_writer_flag_if_error(writer, mpack_track_check_empty(&writer->track)); + if (writer->error != mpack_ok) + return; + #endif + + #if MPACK_BUILDER + if (writer->builder.current_build != NULL) { + mpack_break("cannot call mpack_writer_flush_message() while there are elements open!"); + mpack_writer_flag_error(writer, mpack_error_bug); + return; + } + #endif + + if (writer->flush == NULL) { + mpack_break("cannot call mpack_writer_flush_message() without a flush function!"); + mpack_writer_flag_error(writer, mpack_error_bug); + return; + } + + if (mpack_writer_buffer_used(writer) > 0) + mpack_writer_flush_unchecked(writer); +} + +// Ensures there are at least count bytes free in the buffer. This +// will flag an error if the flush function fails to make enough +// room in the buffer. +MPACK_NOINLINE static bool mpack_writer_ensure(mpack_writer_t* writer, size_t count) { + mpack_assert(count != 0, "cannot ensure zero bytes!"); + mpack_assert(count <= MPACK_WRITER_MINIMUM_BUFFER_SIZE, + "cannot ensure %i bytes, this is more than the minimum buffer size %i!", + (int)count, (int)MPACK_WRITER_MINIMUM_BUFFER_SIZE); + mpack_assert(count > mpack_writer_buffer_left(writer), + "request to ensure %i bytes but there are already %i left in the buffer!", + (int)count, (int)mpack_writer_buffer_left(writer)); + + mpack_log("ensuring %i bytes, %i left\n", (int)count, (int)mpack_writer_buffer_left(writer)); + + if (mpack_writer_error(writer) != mpack_ok) + return false; + + #if MPACK_BUILDER + // if we have a build in progress, we just ask the builder for a page. + // either it will have space for a tag, or it will flag a memory error. + if (writer->builder.current_build != NULL) { + mpack_builder_flush(writer); + return mpack_writer_error(writer) == mpack_ok; + } + #endif + + if (writer->flush == NULL) { + mpack_writer_flag_error(writer, mpack_error_too_big); + return false; + } + + mpack_writer_flush_unchecked(writer); + if (mpack_writer_error(writer) != mpack_ok) + return false; + + if (mpack_writer_buffer_left(writer) >= count) + return true; + + mpack_writer_flag_error(writer, mpack_error_io); + return false; +} + +// Writes encoded bytes to the buffer when we already know the data +// does not fit in the buffer (i.e. it straddles the edge of the +// buffer.) If there is a flush function, it is guaranteed to be +// called; otherwise mpack_error_too_big is raised. +MPACK_NOINLINE static void mpack_write_native_straddle(mpack_writer_t* writer, const char* p, size_t count) { + mpack_assert(count == 0 || p != NULL, "data pointer for %i bytes is NULL", (int)count); + + if (mpack_writer_error(writer) != mpack_ok) + return; + mpack_log("big write for %i bytes from %p, %i space left in buffer\n", + (int)count, p, (int)mpack_writer_buffer_left(writer)); + mpack_assert(count > mpack_writer_buffer_left(writer), + "big write requested for %i bytes, but there is %i available " + "space in buffer. should have called mpack_write_native() instead", + (int)count, (int)(mpack_writer_buffer_left(writer))); + + #if MPACK_BUILDER + // if we have a build in progress, we can't flush. we need to copy all + // bytes into as many build buffer pages as it takes. + if (writer->builder.current_build != NULL) { + while (true) { + size_t step = (size_t)(writer->end - writer->position); + if (step > count) + step = count; + mpack_memcpy(writer->position, p, step); + writer->position += step; + p += step; + count -= step; + + if (count == 0) + return; + + mpack_builder_flush(writer); + if (mpack_writer_error(writer) != mpack_ok) + return; + mpack_assert(writer->position != writer->end); + } + } + #endif + + // we'll need a flush function + if (!writer->flush) { + mpack_writer_flag_error(writer, mpack_error_too_big); + return; + } + + // flush the buffer + mpack_writer_flush_unchecked(writer); + if (mpack_writer_error(writer) != mpack_ok) + return; + + // note that an intrusive flush function (such as mpack_growable_writer_flush()) + // may have changed size and/or reset used to a non-zero value. we treat both as + // though they may have changed, and there may still be data in the buffer. + + // flush the extra data directly if it doesn't fit in the buffer + if (count > mpack_writer_buffer_left(writer)) { + writer->flush(writer, p, count); + if (mpack_writer_error(writer) != mpack_ok) + return; + } else { + mpack_memcpy(writer->position, p, count); + writer->position += count; + } +} + +// Writes encoded bytes to the buffer, flushing if necessary. +MPACK_STATIC_INLINE void mpack_write_native(mpack_writer_t* writer, const char* p, size_t count) { + mpack_assert(count == 0 || p != NULL, "data pointer for %i bytes is NULL", (int)count); + + if (mpack_writer_buffer_left(writer) < count) { + mpack_write_native_straddle(writer, p, count); + } else { + mpack_memcpy(writer->position, p, count); + writer->position += count; + } +} + +mpack_error_t mpack_writer_destroy(mpack_writer_t* writer) { + + // clean up tracking, asserting if we're not already in an error state + #if MPACK_WRITE_TRACKING + mpack_track_destroy(&writer->track, writer->error != mpack_ok); + #endif + + #if MPACK_BUILDER + mpack_builder_t* builder = &writer->builder; + if (builder->current_build != NULL) { + // A builder is open! + + // Flag an error, if there's not already an error. You can only skip + // closing any open compound types if a write error occurred. If there + // wasn't already an error, it's a bug, which will assert in debug. + if (mpack_writer_error(writer) == mpack_ok) { + mpack_break("writer cannot be destroyed with an incomplete builder unless " + "an error was flagged!"); + mpack_writer_flag_error(writer, mpack_error_bug); + } + + // Free any remaining builder pages + mpack_builder_page_t* page = builder->pages; + #if MPACK_BUILDER_INTERNAL_STORAGE + mpack_assert(page == (mpack_builder_page_t*)builder->internal); + page = page->next; + #endif + while (page != NULL) { + mpack_builder_page_t* next = page->next; + MPACK_FREE(page); + page = next; + } + + // Restore the stashed pointers. The teardown function may need to free + // them (e.g. mpack_growable_writer_teardown().) + writer->buffer = builder->stash_buffer; + writer->position = builder->stash_position; + writer->end = builder->stash_end; + + // Note: It's not necessary to clean up the current_build or other + // pointers at this point because we're guaranteed to be in an error + // state already so a user error callback can't longjmp out. This + // destroy function will complete no matter what so it doesn't matter + // what junk is left in the writer. + } + #endif + + // flush any outstanding data + if (mpack_writer_error(writer) == mpack_ok && mpack_writer_buffer_used(writer) != 0 && writer->flush != NULL) { + writer->flush(writer, writer->buffer, mpack_writer_buffer_used(writer)); + writer->flush = NULL; + } + + if (writer->teardown) { + writer->teardown(writer); + writer->teardown = NULL; + } + + return writer->error; +} + +void mpack_write_tag(mpack_writer_t* writer, mpack_tag_t value) { + switch (value.type) { + case mpack_type_missing: + mpack_break("cannot write a missing value!"); + mpack_writer_flag_error(writer, mpack_error_bug); + return; + + case mpack_type_nil: mpack_write_nil (writer); return; + case mpack_type_bool: mpack_write_bool (writer, value.v.b); return; + case mpack_type_int: mpack_write_int (writer, value.v.i); return; + case mpack_type_uint: mpack_write_uint (writer, value.v.u); return; + + case mpack_type_float: + #if MPACK_FLOAT + mpack_write_float + #else + mpack_write_raw_float + #endif + (writer, value.v.f); + return; + case mpack_type_double: + #if MPACK_DOUBLE + mpack_write_double + #else + mpack_write_raw_double + #endif + (writer, value.v.d); + return; + + case mpack_type_str: mpack_start_str(writer, value.v.l); return; + case mpack_type_bin: mpack_start_bin(writer, value.v.l); return; + + #if MPACK_EXTENSIONS + case mpack_type_ext: + mpack_start_ext(writer, mpack_tag_ext_exttype(&value), mpack_tag_ext_length(&value)); + return; + #endif + + case mpack_type_array: mpack_start_array(writer, value.v.n); return; + case mpack_type_map: mpack_start_map(writer, value.v.n); return; + } + + mpack_break("unrecognized type %i", (int)value.type); + mpack_writer_flag_error(writer, mpack_error_bug); +} + +MPACK_STATIC_INLINE void mpack_write_byte_element(mpack_writer_t* writer, char value) { + mpack_writer_track_element(writer); + if (MPACK_LIKELY(mpack_writer_buffer_left(writer) >= 1) || mpack_writer_ensure(writer, 1)) + *(writer->position++) = value; +} + +void mpack_write_nil(mpack_writer_t* writer) { + mpack_write_byte_element(writer, (char)0xc0); +} + +void mpack_write_bool(mpack_writer_t* writer, bool value) { + mpack_write_byte_element(writer, (char)(0xc2 | (value ? 1 : 0))); +} + +void mpack_write_true(mpack_writer_t* writer) { + mpack_write_byte_element(writer, (char)0xc3); +} + +void mpack_write_false(mpack_writer_t* writer) { + mpack_write_byte_element(writer, (char)0xc2); +} + +void mpack_write_object_bytes(mpack_writer_t* writer, const char* data, size_t bytes) { + mpack_writer_track_element(writer); + mpack_write_native(writer, data, bytes); +} + +/* + * Encode functions + */ + +MPACK_STATIC_INLINE void mpack_encode_fixuint(char* p, uint8_t value) { + mpack_assert(value <= 127); + mpack_store_u8(p, value); +} + +MPACK_STATIC_INLINE void mpack_encode_u8(char* p, uint8_t value) { + mpack_assert(value > 127); + mpack_store_u8(p, 0xcc); + mpack_store_u8(p + 1, value); +} + +MPACK_STATIC_INLINE void mpack_encode_u16(char* p, uint16_t value) { + mpack_assert(value > MPACK_UINT8_MAX); + mpack_store_u8(p, 0xcd); + mpack_store_u16(p + 1, value); +} + +MPACK_STATIC_INLINE void mpack_encode_u32(char* p, uint32_t value) { + mpack_assert(value > MPACK_UINT16_MAX); + mpack_store_u8(p, 0xce); + mpack_store_u32(p + 1, value); +} + +MPACK_STATIC_INLINE void mpack_encode_u64(char* p, uint64_t value) { + mpack_assert(value > MPACK_UINT32_MAX); + mpack_store_u8(p, 0xcf); + mpack_store_u64(p + 1, value); +} + +MPACK_STATIC_INLINE void mpack_encode_fixint(char* p, int8_t value) { + // this can encode positive or negative fixints + mpack_assert(value >= -32); + mpack_store_i8(p, value); +} + +MPACK_STATIC_INLINE void mpack_encode_i8(char* p, int8_t value) { + mpack_assert(value < -32); + mpack_store_u8(p, 0xd0); + mpack_store_i8(p + 1, value); +} + +MPACK_STATIC_INLINE void mpack_encode_i16(char* p, int16_t value) { + mpack_assert(value < MPACK_INT8_MIN); + mpack_store_u8(p, 0xd1); + mpack_store_i16(p + 1, value); +} + +MPACK_STATIC_INLINE void mpack_encode_i32(char* p, int32_t value) { + mpack_assert(value < MPACK_INT16_MIN); + mpack_store_u8(p, 0xd2); + mpack_store_i32(p + 1, value); +} + +MPACK_STATIC_INLINE void mpack_encode_i64(char* p, int64_t value) { + mpack_assert(value < MPACK_INT32_MIN); + mpack_store_u8(p, 0xd3); + mpack_store_i64(p + 1, value); +} + +#if MPACK_FLOAT +MPACK_STATIC_INLINE void mpack_encode_float(char* p, float value) { + mpack_store_u8(p, 0xca); + mpack_store_float(p + 1, value); +} +#else +MPACK_STATIC_INLINE void mpack_encode_raw_float(char* p, uint32_t value) { + mpack_store_u8(p, 0xca); + mpack_store_u32(p + 1, value); +} +#endif + +#if MPACK_DOUBLE +MPACK_STATIC_INLINE void mpack_encode_double(char* p, double value) { + mpack_store_u8(p, 0xcb); + mpack_store_double(p + 1, value); +} +#else +MPACK_STATIC_INLINE void mpack_encode_raw_double(char* p, uint64_t value) { + mpack_store_u8(p, 0xcb); + mpack_store_u64(p + 1, value); +} +#endif + +MPACK_STATIC_INLINE void mpack_encode_fixarray(char* p, uint8_t count) { + mpack_assert(count <= 15); + mpack_store_u8(p, (uint8_t)(0x90 | count)); +} + +MPACK_STATIC_INLINE void mpack_encode_array16(char* p, uint16_t count) { + mpack_assert(count > 15); + mpack_store_u8(p, 0xdc); + mpack_store_u16(p + 1, count); +} + +MPACK_STATIC_INLINE void mpack_encode_array32(char* p, uint32_t count) { + mpack_assert(count > MPACK_UINT16_MAX); + mpack_store_u8(p, 0xdd); + mpack_store_u32(p + 1, count); +} + +MPACK_STATIC_INLINE void mpack_encode_fixmap(char* p, uint8_t count) { + mpack_assert(count <= 15); + mpack_store_u8(p, (uint8_t)(0x80 | count)); +} + +MPACK_STATIC_INLINE void mpack_encode_map16(char* p, uint16_t count) { + mpack_assert(count > 15); + mpack_store_u8(p, 0xde); + mpack_store_u16(p + 1, count); +} + +MPACK_STATIC_INLINE void mpack_encode_map32(char* p, uint32_t count) { + mpack_assert(count > MPACK_UINT16_MAX); + mpack_store_u8(p, 0xdf); + mpack_store_u32(p + 1, count); +} + +MPACK_STATIC_INLINE void mpack_encode_fixstr(char* p, uint8_t count) { + mpack_assert(count <= 31); + mpack_store_u8(p, (uint8_t)(0xa0 | count)); +} + +MPACK_STATIC_INLINE void mpack_encode_str8(char* p, uint8_t count) { + mpack_assert(count > 31); + mpack_store_u8(p, 0xd9); + mpack_store_u8(p + 1, count); +} + +MPACK_STATIC_INLINE void mpack_encode_str16(char* p, uint16_t count) { + // we might be encoding a raw in compatibility mode, so we + // allow count to be in the range [32, MPACK_UINT8_MAX]. + mpack_assert(count > 31); + mpack_store_u8(p, 0xda); + mpack_store_u16(p + 1, count); +} + +MPACK_STATIC_INLINE void mpack_encode_str32(char* p, uint32_t count) { + mpack_assert(count > MPACK_UINT16_MAX); + mpack_store_u8(p, 0xdb); + mpack_store_u32(p + 1, count); +} + +MPACK_STATIC_INLINE void mpack_encode_bin8(char* p, uint8_t count) { + mpack_store_u8(p, 0xc4); + mpack_store_u8(p + 1, count); +} + +MPACK_STATIC_INLINE void mpack_encode_bin16(char* p, uint16_t count) { + mpack_assert(count > MPACK_UINT8_MAX); + mpack_store_u8(p, 0xc5); + mpack_store_u16(p + 1, count); +} + +MPACK_STATIC_INLINE void mpack_encode_bin32(char* p, uint32_t count) { + mpack_assert(count > MPACK_UINT16_MAX); + mpack_store_u8(p, 0xc6); + mpack_store_u32(p + 1, count); +} + +#if MPACK_EXTENSIONS +MPACK_STATIC_INLINE void mpack_encode_fixext1(char* p, int8_t exttype) { + mpack_store_u8(p, 0xd4); + mpack_store_i8(p + 1, exttype); +} + +MPACK_STATIC_INLINE void mpack_encode_fixext2(char* p, int8_t exttype) { + mpack_store_u8(p, 0xd5); + mpack_store_i8(p + 1, exttype); +} + +MPACK_STATIC_INLINE void mpack_encode_fixext4(char* p, int8_t exttype) { + mpack_store_u8(p, 0xd6); + mpack_store_i8(p + 1, exttype); +} + +MPACK_STATIC_INLINE void mpack_encode_fixext8(char* p, int8_t exttype) { + mpack_store_u8(p, 0xd7); + mpack_store_i8(p + 1, exttype); +} + +MPACK_STATIC_INLINE void mpack_encode_fixext16(char* p, int8_t exttype) { + mpack_store_u8(p, 0xd8); + mpack_store_i8(p + 1, exttype); +} + +MPACK_STATIC_INLINE void mpack_encode_ext8(char* p, int8_t exttype, uint8_t count) { + mpack_assert(count != 1 && count != 2 && count != 4 && count != 8 && count != 16); + mpack_store_u8(p, 0xc7); + mpack_store_u8(p + 1, count); + mpack_store_i8(p + 2, exttype); +} + +MPACK_STATIC_INLINE void mpack_encode_ext16(char* p, int8_t exttype, uint16_t count) { + mpack_assert(count > MPACK_UINT8_MAX); + mpack_store_u8(p, 0xc8); + mpack_store_u16(p + 1, count); + mpack_store_i8(p + 3, exttype); +} + +MPACK_STATIC_INLINE void mpack_encode_ext32(char* p, int8_t exttype, uint32_t count) { + mpack_assert(count > MPACK_UINT16_MAX); + mpack_store_u8(p, 0xc9); + mpack_store_u32(p + 1, count); + mpack_store_i8(p + 5, exttype); +} + +MPACK_STATIC_INLINE void mpack_encode_timestamp_4(char* p, uint32_t seconds) { + mpack_encode_fixext4(p, MPACK_EXTTYPE_TIMESTAMP); + mpack_store_u32(p + MPACK_TAG_SIZE_FIXEXT4, seconds); +} + +MPACK_STATIC_INLINE void mpack_encode_timestamp_8(char* p, int64_t seconds, uint32_t nanoseconds) { + mpack_assert(nanoseconds <= MPACK_TIMESTAMP_NANOSECONDS_MAX); + mpack_encode_fixext8(p, MPACK_EXTTYPE_TIMESTAMP); + uint64_t encoded = ((uint64_t)nanoseconds << 34) | (uint64_t)seconds; + mpack_store_u64(p + MPACK_TAG_SIZE_FIXEXT8, encoded); +} + +MPACK_STATIC_INLINE void mpack_encode_timestamp_12(char* p, int64_t seconds, uint32_t nanoseconds) { + mpack_assert(nanoseconds <= MPACK_TIMESTAMP_NANOSECONDS_MAX); + mpack_encode_ext8(p, MPACK_EXTTYPE_TIMESTAMP, 12); + mpack_store_u32(p + MPACK_TAG_SIZE_EXT8, nanoseconds); + mpack_store_i64(p + MPACK_TAG_SIZE_EXT8 + 4, seconds); +} +#endif + + + +/* + * Write functions + */ + +// This is a macro wrapper to the encode functions to encode +// directly into the buffer. If mpack_writer_ensure() fails +// it will flag an error so we don't have to do anything. +#define MPACK_WRITE_ENCODED(encode_fn, size, ...) do { \ + if (MPACK_LIKELY(mpack_writer_buffer_left(writer) >= size) || mpack_writer_ensure(writer, size)) { \ + MPACK_EXPAND(encode_fn(writer->position, __VA_ARGS__)); \ + writer->position += size; \ + } \ +} while (0) + +void mpack_write_u8(mpack_writer_t* writer, uint8_t value) { + #if MPACK_OPTIMIZE_FOR_SIZE + mpack_write_u64(writer, value); + #else + mpack_writer_track_element(writer); + if (value <= 127) { + MPACK_WRITE_ENCODED(mpack_encode_fixuint, MPACK_TAG_SIZE_FIXUINT, value); + } else { + MPACK_WRITE_ENCODED(mpack_encode_u8, MPACK_TAG_SIZE_U8, value); + } + #endif +} + +void mpack_write_u16(mpack_writer_t* writer, uint16_t value) { + #if MPACK_OPTIMIZE_FOR_SIZE + mpack_write_u64(writer, value); + #else + mpack_writer_track_element(writer); + if (value <= 127) { + MPACK_WRITE_ENCODED(mpack_encode_fixuint, MPACK_TAG_SIZE_FIXUINT, (uint8_t)value); + } else if (value <= MPACK_UINT8_MAX) { + MPACK_WRITE_ENCODED(mpack_encode_u8, MPACK_TAG_SIZE_U8, (uint8_t)value); + } else { + MPACK_WRITE_ENCODED(mpack_encode_u16, MPACK_TAG_SIZE_U16, value); + } + #endif +} + +void mpack_write_u32(mpack_writer_t* writer, uint32_t value) { + #if MPACK_OPTIMIZE_FOR_SIZE + mpack_write_u64(writer, value); + #else + mpack_writer_track_element(writer); + if (value <= 127) { + MPACK_WRITE_ENCODED(mpack_encode_fixuint, MPACK_TAG_SIZE_FIXUINT, (uint8_t)value); + } else if (value <= MPACK_UINT8_MAX) { + MPACK_WRITE_ENCODED(mpack_encode_u8, MPACK_TAG_SIZE_U8, (uint8_t)value); + } else if (value <= MPACK_UINT16_MAX) { + MPACK_WRITE_ENCODED(mpack_encode_u16, MPACK_TAG_SIZE_U16, (uint16_t)value); + } else { + MPACK_WRITE_ENCODED(mpack_encode_u32, MPACK_TAG_SIZE_U32, value); + } + #endif +} + +void mpack_write_u64(mpack_writer_t* writer, uint64_t value) { + mpack_writer_track_element(writer); + + if (value <= 127) { + MPACK_WRITE_ENCODED(mpack_encode_fixuint, MPACK_TAG_SIZE_FIXUINT, (uint8_t)value); + } else if (value <= MPACK_UINT8_MAX) { + MPACK_WRITE_ENCODED(mpack_encode_u8, MPACK_TAG_SIZE_U8, (uint8_t)value); + } else if (value <= MPACK_UINT16_MAX) { + MPACK_WRITE_ENCODED(mpack_encode_u16, MPACK_TAG_SIZE_U16, (uint16_t)value); + } else if (value <= MPACK_UINT32_MAX) { + MPACK_WRITE_ENCODED(mpack_encode_u32, MPACK_TAG_SIZE_U32, (uint32_t)value); + } else { + MPACK_WRITE_ENCODED(mpack_encode_u64, MPACK_TAG_SIZE_U64, value); + } +} + +void mpack_write_i8(mpack_writer_t* writer, int8_t value) { + #if MPACK_OPTIMIZE_FOR_SIZE + mpack_write_i64(writer, value); + #else + mpack_writer_track_element(writer); + if (value >= -32) { + // we encode positive and negative fixints together + MPACK_WRITE_ENCODED(mpack_encode_fixint, MPACK_TAG_SIZE_FIXINT, (int8_t)value); + } else { + MPACK_WRITE_ENCODED(mpack_encode_i8, MPACK_TAG_SIZE_I8, (int8_t)value); + } + #endif +} + +void mpack_write_i16(mpack_writer_t* writer, int16_t value) { + #if MPACK_OPTIMIZE_FOR_SIZE + mpack_write_i64(writer, value); + #else + mpack_writer_track_element(writer); + if (value >= -32) { + if (value <= 127) { + // we encode positive and negative fixints together + MPACK_WRITE_ENCODED(mpack_encode_fixint, MPACK_TAG_SIZE_FIXINT, (int8_t)value); + } else if (value <= MPACK_UINT8_MAX) { + MPACK_WRITE_ENCODED(mpack_encode_u8, MPACK_TAG_SIZE_U8, (uint8_t)value); + } else { + MPACK_WRITE_ENCODED(mpack_encode_u16, MPACK_TAG_SIZE_U16, (uint16_t)value); + } + } else if (value >= MPACK_INT8_MIN) { + MPACK_WRITE_ENCODED(mpack_encode_i8, MPACK_TAG_SIZE_I8, (int8_t)value); + } else { + MPACK_WRITE_ENCODED(mpack_encode_i16, MPACK_TAG_SIZE_I16, (int16_t)value); + } + #endif +} + +void mpack_write_i32(mpack_writer_t* writer, int32_t value) { + #if MPACK_OPTIMIZE_FOR_SIZE + mpack_write_i64(writer, value); + #else + mpack_writer_track_element(writer); + if (value >= -32) { + if (value <= 127) { + // we encode positive and negative fixints together + MPACK_WRITE_ENCODED(mpack_encode_fixint, MPACK_TAG_SIZE_FIXINT, (int8_t)value); + } else if (value <= MPACK_UINT8_MAX) { + MPACK_WRITE_ENCODED(mpack_encode_u8, MPACK_TAG_SIZE_U8, (uint8_t)value); + } else if (value <= MPACK_UINT16_MAX) { + MPACK_WRITE_ENCODED(mpack_encode_u16, MPACK_TAG_SIZE_U16, (uint16_t)value); + } else { + MPACK_WRITE_ENCODED(mpack_encode_u32, MPACK_TAG_SIZE_U32, (uint32_t)value); + } + } else if (value >= MPACK_INT8_MIN) { + MPACK_WRITE_ENCODED(mpack_encode_i8, MPACK_TAG_SIZE_I8, (int8_t)value); + } else if (value >= MPACK_INT16_MIN) { + MPACK_WRITE_ENCODED(mpack_encode_i16, MPACK_TAG_SIZE_I16, (int16_t)value); + } else { + MPACK_WRITE_ENCODED(mpack_encode_i32, MPACK_TAG_SIZE_I32, value); + } + #endif +} + +void mpack_write_i64(mpack_writer_t* writer, int64_t value) { + #if MPACK_OPTIMIZE_FOR_SIZE + if (value > 127) { + // for non-fix positive ints we call the u64 writer to save space + mpack_write_u64(writer, (uint64_t)value); + return; + } + #endif + + mpack_writer_track_element(writer); + if (value >= -32) { + #if MPACK_OPTIMIZE_FOR_SIZE + MPACK_WRITE_ENCODED(mpack_encode_fixint, MPACK_TAG_SIZE_FIXINT, (int8_t)value); + #else + if (value <= 127) { + MPACK_WRITE_ENCODED(mpack_encode_fixint, MPACK_TAG_SIZE_FIXINT, (int8_t)value); + } else if (value <= MPACK_UINT8_MAX) { + MPACK_WRITE_ENCODED(mpack_encode_u8, MPACK_TAG_SIZE_U8, (uint8_t)value); + } else if (value <= MPACK_UINT16_MAX) { + MPACK_WRITE_ENCODED(mpack_encode_u16, MPACK_TAG_SIZE_U16, (uint16_t)value); + } else if (value <= MPACK_UINT32_MAX) { + MPACK_WRITE_ENCODED(mpack_encode_u32, MPACK_TAG_SIZE_U32, (uint32_t)value); + } else { + MPACK_WRITE_ENCODED(mpack_encode_u64, MPACK_TAG_SIZE_U64, (uint64_t)value); + } + #endif + } else if (value >= MPACK_INT8_MIN) { + MPACK_WRITE_ENCODED(mpack_encode_i8, MPACK_TAG_SIZE_I8, (int8_t)value); + } else if (value >= MPACK_INT16_MIN) { + MPACK_WRITE_ENCODED(mpack_encode_i16, MPACK_TAG_SIZE_I16, (int16_t)value); + } else if (value >= MPACK_INT32_MIN) { + MPACK_WRITE_ENCODED(mpack_encode_i32, MPACK_TAG_SIZE_I32, (int32_t)value); + } else { + MPACK_WRITE_ENCODED(mpack_encode_i64, MPACK_TAG_SIZE_I64, value); + } +} + +#if MPACK_FLOAT +void mpack_write_float(mpack_writer_t* writer, float value) { + mpack_writer_track_element(writer); + MPACK_WRITE_ENCODED(mpack_encode_float, MPACK_TAG_SIZE_FLOAT, value); +} +#else +void mpack_write_raw_float(mpack_writer_t* writer, uint32_t value) { + mpack_writer_track_element(writer); + MPACK_WRITE_ENCODED(mpack_encode_raw_float, MPACK_TAG_SIZE_FLOAT, value); +} +#endif + +#if MPACK_DOUBLE +void mpack_write_double(mpack_writer_t* writer, double value) { + mpack_writer_track_element(writer); + MPACK_WRITE_ENCODED(mpack_encode_double, MPACK_TAG_SIZE_DOUBLE, value); +} +#else +void mpack_write_raw_double(mpack_writer_t* writer, uint64_t value) { + mpack_writer_track_element(writer); + MPACK_WRITE_ENCODED(mpack_encode_raw_double, MPACK_TAG_SIZE_DOUBLE, value); +} +#endif + +#if MPACK_EXTENSIONS +void mpack_write_timestamp(mpack_writer_t* writer, int64_t seconds, uint32_t nanoseconds) { + #if MPACK_COMPATIBILITY + if (writer->version <= mpack_version_v4) { + mpack_break("Timestamps require spec version v5 or later. This writer is in v%i mode.", (int)writer->version); + mpack_writer_flag_error(writer, mpack_error_bug); + return; + } + #endif + + if (nanoseconds > MPACK_TIMESTAMP_NANOSECONDS_MAX) { + mpack_break("timestamp nanoseconds out of bounds: %" PRIu32 , nanoseconds); + mpack_writer_flag_error(writer, mpack_error_bug); + return; + } + + mpack_writer_track_element(writer); + + if (seconds < 0 || seconds >= (MPACK_INT64_C(1) << 34)) { + MPACK_WRITE_ENCODED(mpack_encode_timestamp_12, MPACK_EXT_SIZE_TIMESTAMP12, seconds, nanoseconds); + } else if (seconds > MPACK_UINT32_MAX || nanoseconds > 0) { + MPACK_WRITE_ENCODED(mpack_encode_timestamp_8, MPACK_EXT_SIZE_TIMESTAMP8, seconds, nanoseconds); + } else { + MPACK_WRITE_ENCODED(mpack_encode_timestamp_4, MPACK_EXT_SIZE_TIMESTAMP4, (uint32_t)seconds); + } +} +#endif + +static void mpack_write_array_notrack(mpack_writer_t* writer, uint32_t count) { + if (count <= 15) { + MPACK_WRITE_ENCODED(mpack_encode_fixarray, MPACK_TAG_SIZE_FIXARRAY, (uint8_t)count); + } else if (count <= MPACK_UINT16_MAX) { + MPACK_WRITE_ENCODED(mpack_encode_array16, MPACK_TAG_SIZE_ARRAY16, (uint16_t)count); + } else { + MPACK_WRITE_ENCODED(mpack_encode_array32, MPACK_TAG_SIZE_ARRAY32, (uint32_t)count); + } +} + +static void mpack_write_map_notrack(mpack_writer_t* writer, uint32_t count) { + if (count <= 15) { + MPACK_WRITE_ENCODED(mpack_encode_fixmap, MPACK_TAG_SIZE_FIXMAP, (uint8_t)count); + } else if (count <= MPACK_UINT16_MAX) { + MPACK_WRITE_ENCODED(mpack_encode_map16, MPACK_TAG_SIZE_MAP16, (uint16_t)count); + } else { + MPACK_WRITE_ENCODED(mpack_encode_map32, MPACK_TAG_SIZE_MAP32, (uint32_t)count); + } +} + +void mpack_start_array(mpack_writer_t* writer, uint32_t count) { + mpack_writer_track_element(writer); + mpack_write_array_notrack(writer, count); + mpack_writer_track_push(writer, mpack_type_array, count); + mpack_builder_compound_push(writer); +} + +void mpack_start_map(mpack_writer_t* writer, uint32_t count) { + mpack_writer_track_element(writer); + mpack_write_map_notrack(writer, count); + mpack_writer_track_push(writer, mpack_type_map, count); + mpack_builder_compound_push(writer); +} + +static void mpack_start_str_notrack(mpack_writer_t* writer, uint32_t count) { + if (count <= 31) { + MPACK_WRITE_ENCODED(mpack_encode_fixstr, MPACK_TAG_SIZE_FIXSTR, (uint8_t)count); + + // str8 is only supported in v5 or later. + } else if (count <= MPACK_UINT8_MAX + #if MPACK_COMPATIBILITY + && writer->version >= mpack_version_v5 + #endif + ) { + MPACK_WRITE_ENCODED(mpack_encode_str8, MPACK_TAG_SIZE_STR8, (uint8_t)count); + + } else if (count <= MPACK_UINT16_MAX) { + MPACK_WRITE_ENCODED(mpack_encode_str16, MPACK_TAG_SIZE_STR16, (uint16_t)count); + } else { + MPACK_WRITE_ENCODED(mpack_encode_str32, MPACK_TAG_SIZE_STR32, (uint32_t)count); + } +} + +static void mpack_start_bin_notrack(mpack_writer_t* writer, uint32_t count) { + #if MPACK_COMPATIBILITY + // In the v4 spec, there was only the raw type for any kind of + // variable-length data. In v4 mode, we support the bin functions, + // but we produce an old-style raw. + if (writer->version <= mpack_version_v4) { + mpack_start_str_notrack(writer, count); + return; + } + #endif + + if (count <= MPACK_UINT8_MAX) { + MPACK_WRITE_ENCODED(mpack_encode_bin8, MPACK_TAG_SIZE_BIN8, (uint8_t)count); + } else if (count <= MPACK_UINT16_MAX) { + MPACK_WRITE_ENCODED(mpack_encode_bin16, MPACK_TAG_SIZE_BIN16, (uint16_t)count); + } else { + MPACK_WRITE_ENCODED(mpack_encode_bin32, MPACK_TAG_SIZE_BIN32, (uint32_t)count); + } +} + +void mpack_start_str(mpack_writer_t* writer, uint32_t count) { + mpack_writer_track_element(writer); + mpack_start_str_notrack(writer, count); + mpack_writer_track_push(writer, mpack_type_str, count); +} + +void mpack_start_bin(mpack_writer_t* writer, uint32_t count) { + mpack_writer_track_element(writer); + mpack_start_bin_notrack(writer, count); + mpack_writer_track_push(writer, mpack_type_bin, count); +} + +#if MPACK_EXTENSIONS +void mpack_start_ext(mpack_writer_t* writer, int8_t exttype, uint32_t count) { + #if MPACK_COMPATIBILITY + if (writer->version <= mpack_version_v4) { + mpack_break("Ext types require spec version v5 or later. This writer is in v%i mode.", (int)writer->version); + mpack_writer_flag_error(writer, mpack_error_bug); + return; + } + #endif + + mpack_writer_track_element(writer); + + if (count == 1) { + MPACK_WRITE_ENCODED(mpack_encode_fixext1, MPACK_TAG_SIZE_FIXEXT1, exttype); + } else if (count == 2) { + MPACK_WRITE_ENCODED(mpack_encode_fixext2, MPACK_TAG_SIZE_FIXEXT2, exttype); + } else if (count == 4) { + MPACK_WRITE_ENCODED(mpack_encode_fixext4, MPACK_TAG_SIZE_FIXEXT4, exttype); + } else if (count == 8) { + MPACK_WRITE_ENCODED(mpack_encode_fixext8, MPACK_TAG_SIZE_FIXEXT8, exttype); + } else if (count == 16) { + MPACK_WRITE_ENCODED(mpack_encode_fixext16, MPACK_TAG_SIZE_FIXEXT16, exttype); + } else if (count <= MPACK_UINT8_MAX) { + MPACK_WRITE_ENCODED(mpack_encode_ext8, MPACK_TAG_SIZE_EXT8, exttype, (uint8_t)count); + } else if (count <= MPACK_UINT16_MAX) { + MPACK_WRITE_ENCODED(mpack_encode_ext16, MPACK_TAG_SIZE_EXT16, exttype, (uint16_t)count); + } else { + MPACK_WRITE_ENCODED(mpack_encode_ext32, MPACK_TAG_SIZE_EXT32, exttype, (uint32_t)count); + } + + mpack_writer_track_push(writer, mpack_type_ext, count); +} +#endif + + + +/* + * Compound helpers and other functions + */ + +void mpack_write_str(mpack_writer_t* writer, const char* data, uint32_t count) { + mpack_assert(count == 0 || data != NULL, "data for string of length %i is NULL", (int)count); + + #if MPACK_OPTIMIZE_FOR_SIZE + mpack_writer_track_element(writer); + mpack_start_str_notrack(writer, count); + mpack_write_native(writer, data, count); + #else + + mpack_writer_track_element(writer); + + if (count <= 31) { + // The minimum buffer size when using a flush function is guaranteed to + // fit the largest possible fixstr. + size_t size = count + MPACK_TAG_SIZE_FIXSTR; + if (MPACK_LIKELY(mpack_writer_buffer_left(writer) >= size) || mpack_writer_ensure(writer, size)) { + char* MPACK_RESTRICT p = writer->position; + mpack_encode_fixstr(p, (uint8_t)count); + mpack_memcpy(p + MPACK_TAG_SIZE_FIXSTR, data, count); + writer->position += count + MPACK_TAG_SIZE_FIXSTR; + } + return; + } + + if (count <= MPACK_UINT8_MAX + #if MPACK_COMPATIBILITY + && writer->version >= mpack_version_v5 + #endif + ) { + if (count + MPACK_TAG_SIZE_STR8 <= mpack_writer_buffer_left(writer)) { + char* MPACK_RESTRICT p = writer->position; + mpack_encode_str8(p, (uint8_t)count); + mpack_memcpy(p + MPACK_TAG_SIZE_STR8, data, count); + writer->position += count + MPACK_TAG_SIZE_STR8; + } else { + MPACK_WRITE_ENCODED(mpack_encode_str8, MPACK_TAG_SIZE_STR8, (uint8_t)count); + mpack_write_native(writer, data, count); + } + return; + } + + // str16 and str32 are likely to be a significant fraction of the buffer + // size, so we don't bother with a combined space check in order to + // minimize code size. + if (count <= MPACK_UINT16_MAX) { + MPACK_WRITE_ENCODED(mpack_encode_str16, MPACK_TAG_SIZE_STR16, (uint16_t)count); + mpack_write_native(writer, data, count); + } else { + MPACK_WRITE_ENCODED(mpack_encode_str32, MPACK_TAG_SIZE_STR32, (uint32_t)count); + mpack_write_native(writer, data, count); + } + + #endif +} + +void mpack_write_bin(mpack_writer_t* writer, const char* data, uint32_t count) { + mpack_assert(count == 0 || data != NULL, "data pointer for bin of %i bytes is NULL", (int)count); + mpack_start_bin(writer, count); + mpack_write_bytes(writer, data, count); + mpack_finish_bin(writer); +} + +#if MPACK_EXTENSIONS +void mpack_write_ext(mpack_writer_t* writer, int8_t exttype, const char* data, uint32_t count) { + mpack_assert(count == 0 || data != NULL, "data pointer for ext of type %i and %i bytes is NULL", exttype, (int)count); + mpack_start_ext(writer, exttype, count); + mpack_write_bytes(writer, data, count); + mpack_finish_ext(writer); +} +#endif + +void mpack_write_bytes(mpack_writer_t* writer, const char* data, size_t count) { + mpack_assert(count == 0 || data != NULL, "data pointer for %i bytes is NULL", (int)count); + mpack_writer_track_bytes(writer, count); + mpack_write_native(writer, data, count); +} + +void mpack_write_cstr(mpack_writer_t* writer, const char* cstr) { + mpack_assert(cstr != NULL, "cstr pointer is NULL"); + size_t length = mpack_strlen(cstr); + if (length > MPACK_UINT32_MAX) + mpack_writer_flag_error(writer, mpack_error_invalid); + mpack_write_str(writer, cstr, (uint32_t)length); +} + +void mpack_write_cstr_or_nil(mpack_writer_t* writer, const char* cstr) { + if (cstr) + mpack_write_cstr(writer, cstr); + else + mpack_write_nil(writer); +} + +void mpack_write_utf8(mpack_writer_t* writer, const char* str, uint32_t length) { + mpack_assert(length == 0 || str != NULL, "data for string of length %i is NULL", (int)length); + if (!mpack_utf8_check(str, length)) { + mpack_writer_flag_error(writer, mpack_error_invalid); + return; + } + mpack_write_str(writer, str, length); +} + +void mpack_write_utf8_cstr(mpack_writer_t* writer, const char* cstr) { + mpack_assert(cstr != NULL, "cstr pointer is NULL"); + size_t length = mpack_strlen(cstr); + if (length > MPACK_UINT32_MAX) { + mpack_writer_flag_error(writer, mpack_error_invalid); + return; + } + mpack_write_utf8(writer, cstr, (uint32_t)length); +} + +void mpack_write_utf8_cstr_or_nil(mpack_writer_t* writer, const char* cstr) { + if (cstr) + mpack_write_utf8_cstr(writer, cstr); + else + mpack_write_nil(writer); +} + +/* + * Builder implementation + * + * When a writer is in build mode, it diverts writes to an internal growable + * buffer. All elements other than builder start tags are encoded as normal + * into the builder buffer (even nested maps and arrays of known size, e.g. + * `mpack_start_array()`.) But for compound elements of unknown size, an + * mpack_build_t is written to the buffer instead. + * + * The mpack_build_t tracks everything needed to re-constitute the final + * message once all sizes are known. When the last build element is completed, + * the builder resolves the build by walking through the builds, outputting the + * final encoded tag, and copying everything in between to the writer's true + * buffer. + * + * To make things extra complicated, the builder buffer is not contiguous. It's + * allocated in pages, where the first page may be an internal page in the + * writer. But, each mpack_build_t must itself be contiguous and aligned + * properly within the buffer. This means bytes can be skipped (and wasted) + * before the builds or at the end of pages. + * + * To keep track of this, builds store both their element count and the number + * of encoded bytes that follow, and pages store the number of bytes used. As + * elements are written, each element adds to the count in the current open + * build, and the number of bytes written adds to the current page and the byte + * count in the last started build (whether or not it is completed.) + */ + +#if MPACK_BUILDER + +#ifdef MPACK_ALIGNOF + #define MPACK_BUILD_ALIGNMENT MPACK_ALIGNOF(mpack_build_t) +#else + // without alignof, we just align to the greater of size_t, void* and uint64_t. + // (we do this even though we don't have uint64_t in it in case we add it later.) + #define MPACK_BUILD_ALIGNMENT_MAX(x, y) ((x) > (y) ? (x) : (y)) + #define MPACK_BUILD_ALIGNMENT (MPACK_BUILD_ALIGNMENT_MAX(sizeof(void*), \ + MPACK_BUILD_ALIGNMENT_MAX(sizeof(size_t), sizeof(uint64_t)))) +#endif + +static inline void mpack_builder_check_sizes(mpack_writer_t* writer) { + + // We check internal and page sizes here so that we don't have to check + // them again. A new page with a build in it will have a page header, + // build, and minimum space for a tag. This will perform horribly and waste + // tons of memory if the page size is small, so you're best off just + // sticking with the defaults. + // + // These are all known at compile time, so if they are large + // enough this function should trivially optimize to a no-op. + + #if MPACK_BUILDER_INTERNAL_STORAGE + // make sure the internal storage is big enough to be useful + MPACK_STATIC_ASSERT(MPACK_BUILDER_INTERNAL_STORAGE_SIZE >= (sizeof(mpack_builder_page_t) + + sizeof(mpack_build_t) + MPACK_WRITER_MINIMUM_BUFFER_SIZE), + "MPACK_BUILDER_INTERNAL_STORAGE_SIZE is too small to be useful!"); + if (MPACK_BUILDER_INTERNAL_STORAGE_SIZE < (sizeof(mpack_builder_page_t) + + sizeof(mpack_build_t) + MPACK_WRITER_MINIMUM_BUFFER_SIZE)) + { + mpack_break("MPACK_BUILDER_INTERNAL_STORAGE_SIZE is too small to be useful!"); + mpack_writer_flag_error(writer, mpack_error_bug); + } + #endif + + // make sure the builder page size is big enough to be useful + MPACK_STATIC_ASSERT(MPACK_BUILDER_PAGE_SIZE >= (sizeof(mpack_builder_page_t) + + sizeof(mpack_build_t) + MPACK_WRITER_MINIMUM_BUFFER_SIZE), + "MPACK_BUILDER_PAGE_SIZE is too small to be useful!"); + if (MPACK_BUILDER_PAGE_SIZE < (sizeof(mpack_builder_page_t) + + sizeof(mpack_build_t) + MPACK_WRITER_MINIMUM_BUFFER_SIZE)) + { + mpack_break("MPACK_BUILDER_PAGE_SIZE is too small to be useful!"); + mpack_writer_flag_error(writer, mpack_error_bug); + } +} + +static inline size_t mpack_builder_page_size(mpack_writer_t* writer, mpack_builder_page_t* page) { + #if MPACK_BUILDER_INTERNAL_STORAGE + if ((char*)page == writer->builder.internal) + return sizeof(writer->builder.internal); + #else + (void)writer; + (void)page; + #endif + return MPACK_BUILDER_PAGE_SIZE; +} + +static inline size_t mpack_builder_align_build(size_t bytes_used) { + size_t offset = bytes_used; + offset += MPACK_BUILD_ALIGNMENT - 1; + offset -= offset % MPACK_BUILD_ALIGNMENT; + mpack_log("aligned %zi to %zi\n", bytes_used, offset); + return offset; +} + +static inline void mpack_builder_free_page(mpack_writer_t* writer, mpack_builder_page_t* page) { + mpack_log("freeing page %p\n", (void*)page); + #if MPACK_BUILDER_INTERNAL_STORAGE + if ((char*)page == writer->builder.internal) + return; + #else + (void)writer; + #endif + MPACK_FREE(page); +} + +static inline size_t mpack_builder_page_remaining(mpack_writer_t* writer, mpack_builder_page_t* page) { + return mpack_builder_page_size(writer, page) - page->bytes_used; +} + +static void mpack_builder_configure_buffer(mpack_writer_t* writer) { + if (mpack_writer_error(writer) != mpack_ok) + return; + mpack_builder_t* builder = &writer->builder; + + mpack_builder_page_t* page = builder->current_page; + mpack_assert(page != NULL, "page is null??"); + + // This diverts the writer into the remainder of the current page of our + // build buffer. + writer->buffer = (char*)page + page->bytes_used; + writer->position = (char*)page + page->bytes_used; + writer->end = (char*)page + mpack_builder_page_size(writer, page); + mpack_log("configuring buffer from %p to %p\n", (void*)writer->position, (void*)writer->end); +} + +static void mpack_builder_add_page(mpack_writer_t* writer) { + mpack_builder_t* builder = &writer->builder; + mpack_assert(writer->error == mpack_ok); + + mpack_log("adding a page.\n"); + mpack_builder_page_t* page = (mpack_builder_page_t*)MPACK_MALLOC(MPACK_BUILDER_PAGE_SIZE); + if (page == NULL) { + mpack_writer_flag_error(writer, mpack_error_memory); + return; + } + + page->next = NULL; + page->bytes_used = sizeof(mpack_builder_page_t); + builder->current_page->next = page; + builder->current_page = page; +} + +// Checks how many bytes the writer wrote to the page, adding it to the page's +// bytes_used. This must be followed up with mpack_builder_configure_buffer() +// (after adding a new page, build, etc) to reset the writer's buffer pointers. +static void mpack_builder_apply_writes(mpack_writer_t* writer) { + mpack_assert(writer->error == mpack_ok); + mpack_builder_t* builder = &writer->builder; + mpack_log("latest build is %p\n", (void*)builder->latest_build); + + // The difference between buffer and current is the number of bytes that + // were written to the page. + size_t bytes_written = (size_t)(writer->position - writer->buffer); + mpack_log("applying write of %zi bytes to build %p\n", bytes_written, (void*)builder->latest_build); + + mpack_assert(builder->current_page != NULL); + mpack_assert(builder->latest_build != NULL); + builder->current_page->bytes_used += bytes_written; + builder->latest_build->bytes += bytes_written; + mpack_log("latest build %p now has %zi bytes\n", (void*)builder->latest_build, builder->latest_build->bytes); +} + +static void mpack_builder_flush(mpack_writer_t* writer) { + mpack_assert(writer->error == mpack_ok); + mpack_builder_apply_writes(writer); + mpack_builder_add_page(writer); + mpack_builder_configure_buffer(writer); +} + +MPACK_NOINLINE static void mpack_builder_begin(mpack_writer_t* writer) { + mpack_builder_t* builder = &writer->builder; + mpack_assert(writer->error == mpack_ok); + mpack_assert(builder->current_build == NULL); + mpack_assert(builder->latest_build == NULL); + mpack_assert(builder->pages == NULL); + + // If this is the first build, we need to stash the real buffer backing our + // writer. We'll be diverting the writer to our build buffer. + builder->stash_buffer = writer->buffer; + builder->stash_position = writer->position; + builder->stash_end = writer->end; + + mpack_builder_page_t* page; + + // we've checked that both these sizes are large enough above. + #if MPACK_BUILDER_INTERNAL_STORAGE + page = (mpack_builder_page_t*)builder->internal; + mpack_log("beginning builder with internal storage %p\n", (void*)page); + #else + page = (mpack_builder_page_t*)MPACK_MALLOC(MPACK_BUILDER_PAGE_SIZE); + if (page == NULL) { + mpack_writer_flag_error(writer, mpack_error_memory); + return; + } + mpack_log("beginning builder with allocated page %p\n", (void*)page); + #endif + + page->next = NULL; + page->bytes_used = sizeof(mpack_builder_page_t); + builder->pages = page; + builder->current_page = page; +} + +static void mpack_builder_build(mpack_writer_t* writer, mpack_type_t type) { + mpack_builder_check_sizes(writer); + if (mpack_writer_error(writer) != mpack_ok) + return; + + mpack_writer_track_element(writer); + mpack_writer_track_push_builder(writer, type); + + mpack_builder_t* builder = &writer->builder; + + if (builder->current_build == NULL) { + mpack_builder_begin(writer); + } else { + mpack_builder_apply_writes(writer); + } + if (mpack_writer_error(writer) != mpack_ok) + return; + + // find aligned space for a new build. if there isn't enough space in the + // current page, we discard the remaining space in it and allocate a new + // page. + size_t offset = mpack_builder_align_build(builder->current_page->bytes_used); + if (offset + sizeof(mpack_build_t) > mpack_builder_page_size(writer, builder->current_page)) { + mpack_log("not enough space for a build. %zi bytes used of %zi in this page\n", + builder->current_page->bytes_used, mpack_builder_page_size(writer, builder->current_page)); + mpack_builder_add_page(writer); + // there is always enough space in a fresh page. + offset = mpack_builder_align_build(builder->current_page->bytes_used); + } + + // allocate the build within the page. note that we don't keep track of the + // space wasted due to the offset. instead the previous build has stored + // how many bytes follow it, and we'll redo this offset calculation to find + // this build after it. + mpack_builder_page_t* page = builder->current_page; + page->bytes_used = offset + sizeof(mpack_build_t); + mpack_assert(page->bytes_used <= mpack_builder_page_size(writer, page)); + mpack_build_t* build = (mpack_build_t*)((char*)page + offset); + mpack_log("created new build %p within page %p, which now has %zi bytes used\n", + (void*)build, (void*)page, page->bytes_used); + + // configure the new build + build->parent = builder->current_build; + build->bytes = 0; + build->count = 0; + build->type = type; + build->key_needs_value = false; + build->nested_compound_elements = 0; + + mpack_log("setting current and latest build to new build %p\n", (void*)build); + builder->current_build = build; + builder->latest_build = build; + + // we always need to provide a buffer that meets the minimum buffer size. + // if there isn't enough space, we discard the remaining space in the + // current page and allocate a new one. + if (mpack_builder_page_remaining(writer, page) < MPACK_WRITER_MINIMUM_BUFFER_SIZE) { + mpack_log("less than minimum buffer size in current page. %zi bytes used of %zi in this page\n", + builder->current_page->bytes_used, mpack_builder_page_size(writer, builder->current_page)); + mpack_builder_add_page(writer); + if (mpack_writer_error(writer) != mpack_ok) + return; + } + mpack_assert(mpack_builder_page_remaining(writer, builder->current_page) >= MPACK_WRITER_MINIMUM_BUFFER_SIZE); + mpack_builder_configure_buffer(writer); +} + +MPACK_NOINLINE +static void mpack_builder_resolve(mpack_writer_t* writer) { + mpack_builder_t* builder = &writer->builder; + + // We should not have gotten here if we are in an error state. If an error + // occurs with an open builder, the writer will free the open builder pages + // when destroyed. + mpack_assert(mpack_writer_error(writer) == mpack_ok, "can't resolve in error state!"); + + // We don't want the user to longjmp out of any I/O errors while we are + // walking the page list, so defer error callbacks to after we're done. + mpack_writer_error_t error_fn = writer->error_fn; + writer->error_fn = NULL; + + // The starting page is the internal storage (if we have it), otherwise + // it's the first page in the array + mpack_builder_page_t* page = + #if MPACK_BUILDER_INTERNAL_STORAGE + (mpack_builder_page_t*)builder->internal + #else + builder->pages + #endif + ; + + // We start by restoring the writer's original buffer so we can write the + // data for real. + writer->buffer = builder->stash_buffer; + writer->position = builder->stash_position; + writer->end = builder->stash_end; + + // We can also close out the build now. + builder->current_build = NULL; + builder->latest_build = NULL; + builder->current_page = NULL; + builder->pages = NULL; + + // the starting page always starts with the first build + size_t offset = mpack_builder_align_build(sizeof(mpack_builder_page_t)); + mpack_build_t* build = (mpack_build_t*)((char*)page + offset); + mpack_log("starting resolve with build %p in page %p\n", (void*)build, (void*)page); + + // encoded data immediately follows the build + offset += sizeof(mpack_build_t); + + // Walk the list of builds, writing everything out in the buffer. Note that + // we don't check for errors anywhere. The lower-level write functions will + // all check for errors and do nothing after an error occurs. We need to + // walk all pages anyway to free them, so there's not much point in + // optimizing an error path at the expense of the normal path. + while (true) { + + // write out the container tag + mpack_log("writing out an %s with count %" PRIu32 " followed by %zi bytes\n", + mpack_type_to_string(build->type), build->count, build->bytes); + switch (build->type) { + case mpack_type_map: + mpack_write_map_notrack(writer, build->count); + break; + case mpack_type_array: + mpack_write_array_notrack(writer, build->count); + break; + default: + mpack_break("invalid type in builder?"); + mpack_writer_flag_error(writer, mpack_error_bug); + return; + } + + // figure out how many bytes follow this container. we're going to be + // freeing pages as we write, so we need to be done with this build. + size_t left = build->bytes; + build = NULL; + + // write out all bytes following this container + while (left > 0) { + size_t bytes_used = page->bytes_used; + if (offset < bytes_used) { + size_t step = bytes_used - offset; + if (step > left) + step = left; + mpack_log("writing out %zi bytes starting at %p in page %p\n", + step, (void*)((char*)page + offset), (void*)page); + mpack_write_native(writer, (char*)page + offset, step); + offset += step; + left -= step; + } + + if (left == 0) { + mpack_log("done writing bytes for this build\n"); + break; + } + + // still need to write more bytes. free this page and jump to the + // next one. + mpack_builder_page_t* next_page = page->next; + mpack_builder_free_page(writer, page); + page = next_page; + // bytes on the next page immediately follow the header. + offset = sizeof(mpack_builder_page_t); + } + + // now see if we can find another build. + offset = mpack_builder_align_build(offset); + if (offset + sizeof(mpack_build_t) > mpack_builder_page_size(writer, page)) { + mpack_log("not enough room in this page for another build\n"); + mpack_builder_page_t* next_page = page->next; + mpack_builder_free_page(writer, page); + page = next_page; + if (page == NULL) { + mpack_log("no more pages\n"); + // there are no more pages. we're done. + break; + } + offset = mpack_builder_align_build(sizeof(mpack_builder_page_t)); + } + if (offset + sizeof(mpack_build_t) > page->bytes_used) { + // there is no more data. we're done. + mpack_log("no more data\n"); + mpack_builder_free_page(writer, page); + break; + } + + // we've found another build. loop around! + build = (mpack_build_t*)((char*)page + offset); + offset += sizeof(mpack_build_t); + mpack_log("found build %p\n", (void*)build); + } + + mpack_log("done resolve.\n"); + + // We can now restore the error handler and call it if an error occurred. + writer->error_fn = error_fn; + if (writer->error_fn && mpack_writer_error(writer) != mpack_ok) + writer->error_fn(writer, writer->error); +} + +static void mpack_builder_complete(mpack_writer_t* writer, mpack_type_t type) { + mpack_writer_track_pop_builder(writer, type); + if (mpack_writer_error(writer) != mpack_ok) + return; + + mpack_builder_t* builder = &writer->builder; + mpack_assert(builder->current_build != NULL, "no build in progress!"); + mpack_assert(builder->latest_build != NULL, "missing latest build!"); + mpack_assert(builder->current_build->type == type, "completing wrong type!"); + mpack_log("completing build %p\n", (void*)builder->current_build); + + if (builder->current_build->key_needs_value) { + mpack_break("an odd number of elements were written in a map!"); + mpack_writer_flag_error(writer, mpack_error_bug); + return; + } + + if (builder->current_build->nested_compound_elements != 0) { + mpack_break("there is a nested unfinished non-build map or array in this build."); + mpack_writer_flag_error(writer, mpack_error_bug); + return; + } + + // We need to apply whatever writes have been made to the current build + // before popping it. + mpack_builder_apply_writes(writer); + + // For a nested build, we just switch the current build back to its parent. + if (builder->current_build->parent != NULL) { + mpack_log("setting current build to parent build %p. latest is still %p.\n", + (void*)builder->current_build->parent, (void*)builder->latest_build); + builder->current_build = builder->current_build->parent; + mpack_builder_configure_buffer(writer); + } else { + // We're completing the final build. + mpack_builder_resolve(writer); + } +} + +void mpack_build_map(mpack_writer_t* writer) { + mpack_builder_build(writer, mpack_type_map); +} + +void mpack_build_array(mpack_writer_t* writer) { + mpack_builder_build(writer, mpack_type_array); +} + +void mpack_complete_map(mpack_writer_t* writer) { + mpack_builder_complete(writer, mpack_type_map); +} + +void mpack_complete_array(mpack_writer_t* writer) { + mpack_builder_complete(writer, mpack_type_array); +} + +#endif // MPACK_BUILDER +#endif // MPACK_WRITER + +MPACK_SILENCE_WARNINGS_END + +/* mpack/mpack-reader.c.c */ + +#define MPACK_INTERNAL 1 + +/* #include "mpack-reader.h" */ + +MPACK_SILENCE_WARNINGS_BEGIN + +#if MPACK_READER + +static void mpack_reader_skip_using_fill(mpack_reader_t* reader, size_t count); + +void mpack_reader_init(mpack_reader_t* reader, char* buffer, size_t size, size_t count) { + mpack_assert(buffer != NULL, "buffer is NULL"); + + mpack_memset(reader, 0, sizeof(*reader)); + reader->buffer = buffer; + reader->size = size; + reader->data = buffer; + reader->end = buffer + count; + + #if MPACK_READ_TRACKING + mpack_reader_flag_if_error(reader, mpack_track_init(&reader->track)); + #endif + + mpack_log("===========================\n"); + mpack_log("initializing reader with buffer size %i\n", (int)size); +} + +void mpack_reader_init_error(mpack_reader_t* reader, mpack_error_t error) { + mpack_memset(reader, 0, sizeof(*reader)); + reader->error = error; + + mpack_log("===========================\n"); + mpack_log("initializing reader error state %i\n", (int)error); +} + +void mpack_reader_init_data(mpack_reader_t* reader, const char* data, size_t count) { + mpack_assert(data != NULL, "data is NULL"); + + mpack_memset(reader, 0, sizeof(*reader)); + reader->data = data; + reader->end = data + count; + + #if MPACK_READ_TRACKING + mpack_reader_flag_if_error(reader, mpack_track_init(&reader->track)); + #endif + + mpack_log("===========================\n"); + mpack_log("initializing reader with data size %i\n", (int)count); +} + +void mpack_reader_set_fill(mpack_reader_t* reader, mpack_reader_fill_t fill) { + MPACK_STATIC_ASSERT(MPACK_READER_MINIMUM_BUFFER_SIZE >= MPACK_MAXIMUM_TAG_SIZE, + "minimum buffer size must fit any tag!"); + + if (reader->size == 0) { + mpack_break("cannot use fill function without a writeable buffer!"); + mpack_reader_flag_error(reader, mpack_error_bug); + return; + } + + if (reader->size < MPACK_READER_MINIMUM_BUFFER_SIZE) { + mpack_break("buffer size is %i, but minimum buffer size for fill is %i", + (int)reader->size, MPACK_READER_MINIMUM_BUFFER_SIZE); + mpack_reader_flag_error(reader, mpack_error_bug); + return; + } + + reader->fill = fill; +} + +void mpack_reader_set_skip(mpack_reader_t* reader, mpack_reader_skip_t skip) { + mpack_assert(reader->size != 0, "cannot use skip function without a writeable buffer!"); + reader->skip = skip; +} + +#if MPACK_STDIO +static size_t mpack_file_reader_fill(mpack_reader_t* reader, char* buffer, size_t count) { + if (feof((FILE *)reader->context)) { + mpack_reader_flag_error(reader, mpack_error_eof); + return 0; + } + return fread((void*)buffer, 1, count, (FILE*)reader->context); +} + +static void mpack_file_reader_skip(mpack_reader_t* reader, size_t count) { + if (mpack_reader_error(reader) != mpack_ok) + return; + FILE* file = (FILE*)reader->context; + + // We call ftell() to test whether the stream is seekable + // without causing a file error. + if (ftell(file) >= 0) { + mpack_log("seeking forward %i bytes\n", (int)count); + if (fseek(file, (long int)count, SEEK_CUR) == 0) + return; + mpack_log("fseek() didn't return zero!\n"); + if (ferror(file)) { + mpack_reader_flag_error(reader, mpack_error_io); + return; + } + } + + // If the stream is not seekable, fall back to the fill function. + mpack_reader_skip_using_fill(reader, count); +} + +static void mpack_file_reader_teardown(mpack_reader_t* reader) { + MPACK_FREE(reader->buffer); + reader->buffer = NULL; + reader->context = NULL; + reader->size = 0; + reader->fill = NULL; + reader->skip = NULL; + reader->teardown = NULL; +} + +static void mpack_file_reader_teardown_close(mpack_reader_t* reader) { + FILE* file = (FILE*)reader->context; + + if (file) { + int ret = fclose(file); + if (ret != 0) + mpack_reader_flag_error(reader, mpack_error_io); + } + + mpack_file_reader_teardown(reader); +} + +void mpack_reader_init_stdfile(mpack_reader_t* reader, FILE* file, bool close_when_done) { + mpack_assert(file != NULL, "file is NULL"); + + size_t capacity = MPACK_BUFFER_SIZE; + char* buffer = (char*)MPACK_MALLOC(capacity); + if (buffer == NULL) { + mpack_reader_init_error(reader, mpack_error_memory); + if (close_when_done) { + fclose(file); + } + return; + } + + mpack_reader_init(reader, buffer, capacity, 0); + mpack_reader_set_context(reader, file); + mpack_reader_set_fill(reader, mpack_file_reader_fill); + mpack_reader_set_skip(reader, mpack_file_reader_skip); + mpack_reader_set_teardown(reader, close_when_done ? + mpack_file_reader_teardown_close : + mpack_file_reader_teardown); +} + +void mpack_reader_init_filename(mpack_reader_t* reader, const char* filename) { + mpack_assert(filename != NULL, "filename is NULL"); + + FILE* file = fopen(filename, "rb"); + if (file == NULL) { + mpack_reader_init_error(reader, mpack_error_io); + return; + } + + mpack_reader_init_stdfile(reader, file, true); +} +#endif + +mpack_error_t mpack_reader_destroy(mpack_reader_t* reader) { + + // clean up tracking, asserting if we're not already in an error state + #if MPACK_READ_TRACKING + mpack_reader_flag_if_error(reader, mpack_track_destroy(&reader->track, mpack_reader_error(reader) != mpack_ok)); + #endif + + if (reader->teardown) + reader->teardown(reader); + reader->teardown = NULL; + + return reader->error; +} + +size_t mpack_reader_remaining(mpack_reader_t* reader, const char** data) { + if (mpack_reader_error(reader) != mpack_ok) + return 0; + + #if MPACK_READ_TRACKING + if (mpack_reader_flag_if_error(reader, mpack_track_check_empty(&reader->track)) != mpack_ok) + return 0; + #endif + + if (data) + *data = reader->data; + return (size_t)(reader->end - reader->data); +} + +void mpack_reader_flag_error(mpack_reader_t* reader, mpack_error_t error) { + mpack_log("reader %p setting error %i: %s\n", (void*)reader, (int)error, mpack_error_to_string(error)); + + if (reader->error == mpack_ok) { + reader->error = error; + reader->end = reader->data; + if (reader->error_fn) + reader->error_fn(reader, error); + } +} + +// Loops on the fill function, reading between the minimum and +// maximum number of bytes and flagging an error if it fails. +MPACK_NOINLINE static size_t mpack_fill_range(mpack_reader_t* reader, char* p, size_t min_bytes, size_t max_bytes) { + mpack_assert(reader->fill != NULL, "mpack_fill_range() called with no fill function?"); + mpack_assert(min_bytes > 0, "cannot fill zero bytes!"); + mpack_assert(max_bytes >= min_bytes, "min_bytes %i cannot be larger than max_bytes %i!", + (int)min_bytes, (int)max_bytes); + + size_t count = 0; + while (count < min_bytes) { + size_t read = reader->fill(reader, p + count, max_bytes - count); + + // Reader fill functions can flag an error or return 0 on failure. We + // also guard against functions that return -1 just in case. + if (mpack_reader_error(reader) != mpack_ok) + return 0; + if (read == 0 || read == ((size_t)(-1))) { + mpack_reader_flag_error(reader, mpack_error_io); + return 0; + } + + count += read; + } + return count; +} + +MPACK_NOINLINE bool mpack_reader_ensure_straddle(mpack_reader_t* reader, size_t count) { + mpack_assert(count != 0, "cannot ensure zero bytes!"); + mpack_assert(reader->error == mpack_ok, "reader cannot be in an error state!"); + + mpack_assert(count > (size_t)(reader->end - reader->data), + "straddling ensure requested for %i bytes, but there are %i bytes " + "left in buffer. call mpack_reader_ensure() instead", + (int)count, (int)(reader->end - reader->data)); + + // we'll need a fill function to get more data. if there's no + // fill function, the buffer should contain an entire MessagePack + // object, so we raise mpack_error_invalid instead of mpack_error_io + // on truncated data. + if (reader->fill == NULL) { + mpack_reader_flag_error(reader, mpack_error_invalid); + return false; + } + + // we need enough space in the buffer. if the buffer is not + // big enough, we return mpack_error_too_big (since this is + // for an in-place read larger than the buffer size.) + if (count > reader->size) { + mpack_reader_flag_error(reader, mpack_error_too_big); + return false; + } + + // move the existing data to the start of the buffer + size_t left = (size_t)(reader->end - reader->data); + mpack_memmove(reader->buffer, reader->data, left); + reader->end -= reader->data - reader->buffer; + reader->data = reader->buffer; + + // read at least the necessary number of bytes, accepting up to the + // buffer size + size_t read = mpack_fill_range(reader, reader->buffer + left, + count - left, reader->size - left); + if (mpack_reader_error(reader) != mpack_ok) + return false; + reader->end += read; + return true; +} + +// Reads count bytes into p. Used when there are not enough bytes +// left in the buffer to satisfy a read. +MPACK_NOINLINE void mpack_read_native_straddle(mpack_reader_t* reader, char* p, size_t count) { + mpack_assert(count == 0 || p != NULL, "data pointer for %i bytes is NULL", (int)count); + + if (mpack_reader_error(reader) != mpack_ok) { + mpack_memset(p, 0, count); + return; + } + + size_t left = (size_t)(reader->end - reader->data); + mpack_log("big read for %i bytes into %p, %i left in buffer, buffer size %i\n", + (int)count, p, (int)left, (int)reader->size); + + if (count <= left) { + mpack_assert(0, + "big read requested for %i bytes, but there are %i bytes " + "left in buffer. call mpack_read_native() instead", + (int)count, (int)left); + mpack_reader_flag_error(reader, mpack_error_bug); + mpack_memset(p, 0, count); + return; + } + + // we'll need a fill function to get more data. if there's no + // fill function, the buffer should contain an entire MessagePack + // object, so we raise mpack_error_invalid instead of mpack_error_io + // on truncated data. + if (reader->fill == NULL) { + mpack_reader_flag_error(reader, mpack_error_invalid); + mpack_memset(p, 0, count); + return; + } + + if (reader->size == 0) { + // somewhat debatable what error should be returned here. when + // initializing a reader with an in-memory buffer it's not + // necessarily a bug if the data is blank; it might just have + // been truncated to zero. for this reason we return the same + // error as if the data was truncated. + mpack_reader_flag_error(reader, mpack_error_io); + mpack_memset(p, 0, count); + return; + } + + // flush what's left of the buffer + if (left > 0) { + mpack_log("flushing %i bytes remaining in buffer\n", (int)left); + mpack_memcpy(p, reader->data, left); + count -= left; + p += left; + reader->data += left; + } + + // if the remaining data needed is some small fraction of the + // buffer size, we'll try to fill the buffer as much as possible + // and copy the needed data out. + if (count <= reader->size / MPACK_READER_SMALL_FRACTION_DENOMINATOR) { + size_t read = mpack_fill_range(reader, reader->buffer, count, reader->size); + if (mpack_reader_error(reader) != mpack_ok) + return; + mpack_memcpy(p, reader->buffer, count); + reader->data = reader->buffer + count; + reader->end = reader->buffer + read; + + // otherwise we read the remaining data directly into the target. + } else { + mpack_log("reading %i additional bytes\n", (int)count); + mpack_fill_range(reader, p, count, count); + } +} + +MPACK_NOINLINE static void mpack_skip_bytes_straddle(mpack_reader_t* reader, size_t count) { + + // we'll need at least a fill function to skip more data. if there's + // no fill function, the buffer should contain an entire MessagePack + // object, so we raise mpack_error_invalid instead of mpack_error_io + // on truncated data. (see mpack_read_native_straddle()) + if (reader->fill == NULL) { + mpack_log("reader has no fill function!\n"); + mpack_reader_flag_error(reader, mpack_error_invalid); + return; + } + + // discard whatever's left in the buffer + size_t left = (size_t)(reader->end - reader->data); + mpack_log("discarding %i bytes still in buffer\n", (int)left); + count -= left; + reader->data = reader->end; + + // use the skip function if we've got one, and if we're trying + // to skip a lot of data. if we only need to skip some tiny + // fraction of the buffer size, it's probably better to just + // fill the buffer and skip from it instead of trying to seek. + if (reader->skip && count > reader->size / 16) { + mpack_log("calling skip function for %i bytes\n", (int)count); + reader->skip(reader, count); + return; + } + + mpack_reader_skip_using_fill(reader, count); +} + +void mpack_skip_bytes(mpack_reader_t* reader, size_t count) { + if (mpack_reader_error(reader) != mpack_ok) + return; + mpack_log("skip requested for %i bytes\n", (int)count); + + mpack_reader_track_bytes(reader, count); + + // check if we have enough in the buffer already + size_t left = (size_t)(reader->end - reader->data); + if (left >= count) { + mpack_log("skipping %" PRIu32 " bytes still in buffer\n", (uint32_t)count); + reader->data += count; + return; + } + + mpack_skip_bytes_straddle(reader, count); +} + +MPACK_NOINLINE static void mpack_reader_skip_using_fill(mpack_reader_t* reader, size_t count) { + mpack_assert(reader->fill != NULL, "missing fill function!"); + mpack_assert(reader->data == reader->end, "there are bytes left in the buffer!"); + mpack_assert(reader->error == mpack_ok, "should not have called this in an error state (%i)", reader->error); + mpack_log("skip using fill for %i bytes\n", (int)count); + + // fill and discard multiples of the buffer size + while (count > reader->size) { + mpack_log("filling and discarding buffer of %i bytes\n", (int)reader->size); + if (mpack_fill_range(reader, reader->buffer, reader->size, reader->size) < reader->size) { + mpack_reader_flag_error(reader, mpack_error_io); + return; + } + count -= reader->size; + } + + // fill the buffer as much as possible + reader->data = reader->buffer; + size_t read = mpack_fill_range(reader, reader->buffer, count, reader->size); + if (read < count) { + mpack_reader_flag_error(reader, mpack_error_io); + return; + } + reader->end = reader->data + read; + mpack_log("filled %i bytes into buffer; discarding %i bytes\n", (int)read, (int)count); + reader->data += count; +} + +void mpack_read_bytes(mpack_reader_t* reader, char* p, size_t count) { + mpack_assert(p != NULL, "destination for read of %i bytes is NULL", (int)count); + mpack_reader_track_bytes(reader, count); + mpack_read_native(reader, p, count); +} + +void mpack_read_utf8(mpack_reader_t* reader, char* p, size_t byte_count) { + mpack_assert(p != NULL, "destination for read of %i bytes is NULL", (int)byte_count); + mpack_reader_track_str_bytes_all(reader, byte_count); + mpack_read_native(reader, p, byte_count); + + if (mpack_reader_error(reader) == mpack_ok && !mpack_utf8_check(p, byte_count)) + mpack_reader_flag_error(reader, mpack_error_type); +} + +static void mpack_read_cstr_unchecked(mpack_reader_t* reader, char* buf, size_t buffer_size, size_t byte_count) { + mpack_assert(buf != NULL, "destination for read of %i bytes is NULL", (int)byte_count); + mpack_assert(buffer_size >= 1, "buffer size is zero; you must have room for at least a null-terminator"); + + if (mpack_reader_error(reader)) { + buf[0] = 0; + return; + } + + if (byte_count > buffer_size - 1) { + mpack_reader_flag_error(reader, mpack_error_too_big); + buf[0] = 0; + return; + } + + mpack_reader_track_str_bytes_all(reader, byte_count); + mpack_read_native(reader, buf, byte_count); + buf[byte_count] = 0; +} + +void mpack_read_cstr(mpack_reader_t* reader, char* buf, size_t buffer_size, size_t byte_count) { + mpack_read_cstr_unchecked(reader, buf, buffer_size, byte_count); + + // check for null bytes + if (mpack_reader_error(reader) == mpack_ok && !mpack_str_check_no_null(buf, byte_count)) { + buf[0] = 0; + mpack_reader_flag_error(reader, mpack_error_type); + } +} + +void mpack_read_utf8_cstr(mpack_reader_t* reader, char* buf, size_t buffer_size, size_t byte_count) { + mpack_read_cstr_unchecked(reader, buf, buffer_size, byte_count); + + // check encoding + if (mpack_reader_error(reader) == mpack_ok && !mpack_utf8_check_no_null(buf, byte_count)) { + buf[0] = 0; + mpack_reader_flag_error(reader, mpack_error_type); + } +} + +#ifdef MPACK_MALLOC +// Reads native bytes with error callback disabled. This allows MPack reader functions +// to hold an allocated buffer and read native data into it without leaking it in +// case of a non-local jump (longjmp, throw) out of an error handler. +static void mpack_read_native_noerrorfn(mpack_reader_t* reader, char* p, size_t count) { + mpack_assert(reader->error == mpack_ok, "cannot call if an error is already flagged!"); + mpack_reader_error_t error_fn = reader->error_fn; + reader->error_fn = NULL; + mpack_read_native(reader, p, count); + reader->error_fn = error_fn; +} + +char* mpack_read_bytes_alloc_impl(mpack_reader_t* reader, size_t count, bool null_terminated) { + + // track the bytes first in case it jumps + mpack_reader_track_bytes(reader, count); + if (mpack_reader_error(reader) != mpack_ok) + return NULL; + + // cannot allocate zero bytes. this is not an error. + if (count == 0 && null_terminated == false) + return NULL; + + // allocate data + char* data = (char*)MPACK_MALLOC(count + (null_terminated ? 1 : 0)); // TODO: can this overflow? + if (data == NULL) { + mpack_reader_flag_error(reader, mpack_error_memory); + return NULL; + } + + // read with error callback disabled so we don't leak our buffer + mpack_read_native_noerrorfn(reader, data, count); + + // report flagged errors + if (mpack_reader_error(reader) != mpack_ok) { + MPACK_FREE(data); + if (reader->error_fn) + reader->error_fn(reader, mpack_reader_error(reader)); + return NULL; + } + + if (null_terminated) + data[count] = '\0'; + return data; +} +#endif + +// read inplace without tracking (since there are different +// tracking modes for different inplace readers) +static const char* mpack_read_bytes_inplace_notrack(mpack_reader_t* reader, size_t count) { + if (mpack_reader_error(reader) != mpack_ok) + return NULL; + + // if we have enough bytes already in the buffer, we can return it directly. + if ((size_t)(reader->end - reader->data) >= count) { + const char* bytes = reader->data; + reader->data += count; + return bytes; + } + + if (!mpack_reader_ensure(reader, count)) + return NULL; + + const char* bytes = reader->data; + reader->data += count; + return bytes; +} + +const char* mpack_read_bytes_inplace(mpack_reader_t* reader, size_t count) { + mpack_reader_track_bytes(reader, count); + return mpack_read_bytes_inplace_notrack(reader, count); +} + +const char* mpack_read_utf8_inplace(mpack_reader_t* reader, size_t count) { + mpack_reader_track_str_bytes_all(reader, count); + const char* str = mpack_read_bytes_inplace_notrack(reader, count); + + if (mpack_reader_error(reader) == mpack_ok && !mpack_utf8_check(str, count)) { + mpack_reader_flag_error(reader, mpack_error_type); + return NULL; + } + + return str; +} + +static size_t mpack_parse_tag(mpack_reader_t* reader, mpack_tag_t* tag) { + mpack_assert(reader->error == mpack_ok, "reader cannot be in an error state!"); + + if (!mpack_reader_ensure(reader, 1)) + return 0; + uint8_t type = mpack_load_u8(reader->data); + + // unfortunately, by far the fastest way to parse a tag is to switch + // on the first byte, and to explicitly list every possible byte. so for + // infix types, the list of cases is quite large. + // + // in size-optimized builds, we switch on the top four bits first to + // handle most infix types with a smaller jump table to save space. + + #if MPACK_OPTIMIZE_FOR_SIZE + switch (type >> 4) { + + // positive fixnum + case 0x0: case 0x1: case 0x2: case 0x3: + case 0x4: case 0x5: case 0x6: case 0x7: + *tag = mpack_tag_make_uint(type); + return 1; + + // negative fixnum + case 0xe: case 0xf: + *tag = mpack_tag_make_int((int8_t)type); + return 1; + + // fixmap + case 0x8: + *tag = mpack_tag_make_map(type & ~0xf0u); + return 1; + + // fixarray + case 0x9: + *tag = mpack_tag_make_array(type & ~0xf0u); + return 1; + + // fixstr + case 0xa: case 0xb: + *tag = mpack_tag_make_str(type & ~0xe0u); + return 1; + + // not one of the common infix types + default: + break; + + } + #endif + + // handle individual type tags + switch (type) { + + #if !MPACK_OPTIMIZE_FOR_SIZE + // positive fixnum + case 0x00: case 0x01: case 0x02: case 0x03: case 0x04: case 0x05: case 0x06: case 0x07: + case 0x08: case 0x09: case 0x0a: case 0x0b: case 0x0c: case 0x0d: case 0x0e: case 0x0f: + case 0x10: case 0x11: case 0x12: case 0x13: case 0x14: case 0x15: case 0x16: case 0x17: + case 0x18: case 0x19: case 0x1a: case 0x1b: case 0x1c: case 0x1d: case 0x1e: case 0x1f: + case 0x20: case 0x21: case 0x22: case 0x23: case 0x24: case 0x25: case 0x26: case 0x27: + case 0x28: case 0x29: case 0x2a: case 0x2b: case 0x2c: case 0x2d: case 0x2e: case 0x2f: + case 0x30: case 0x31: case 0x32: case 0x33: case 0x34: case 0x35: case 0x36: case 0x37: + case 0x38: case 0x39: case 0x3a: case 0x3b: case 0x3c: case 0x3d: case 0x3e: case 0x3f: + case 0x40: case 0x41: case 0x42: case 0x43: case 0x44: case 0x45: case 0x46: case 0x47: + case 0x48: case 0x49: case 0x4a: case 0x4b: case 0x4c: case 0x4d: case 0x4e: case 0x4f: + case 0x50: case 0x51: case 0x52: case 0x53: case 0x54: case 0x55: case 0x56: case 0x57: + case 0x58: case 0x59: case 0x5a: case 0x5b: case 0x5c: case 0x5d: case 0x5e: case 0x5f: + case 0x60: case 0x61: case 0x62: case 0x63: case 0x64: case 0x65: case 0x66: case 0x67: + case 0x68: case 0x69: case 0x6a: case 0x6b: case 0x6c: case 0x6d: case 0x6e: case 0x6f: + case 0x70: case 0x71: case 0x72: case 0x73: case 0x74: case 0x75: case 0x76: case 0x77: + case 0x78: case 0x79: case 0x7a: case 0x7b: case 0x7c: case 0x7d: case 0x7e: case 0x7f: + *tag = mpack_tag_make_uint(type); + return 1; + + // negative fixnum + case 0xe0: case 0xe1: case 0xe2: case 0xe3: case 0xe4: case 0xe5: case 0xe6: case 0xe7: + case 0xe8: case 0xe9: case 0xea: case 0xeb: case 0xec: case 0xed: case 0xee: case 0xef: + case 0xf0: case 0xf1: case 0xf2: case 0xf3: case 0xf4: case 0xf5: case 0xf6: case 0xf7: + case 0xf8: case 0xf9: case 0xfa: case 0xfb: case 0xfc: case 0xfd: case 0xfe: case 0xff: + *tag = mpack_tag_make_int((int8_t)type); + return 1; + + // fixmap + case 0x80: case 0x81: case 0x82: case 0x83: case 0x84: case 0x85: case 0x86: case 0x87: + case 0x88: case 0x89: case 0x8a: case 0x8b: case 0x8c: case 0x8d: case 0x8e: case 0x8f: + *tag = mpack_tag_make_map(type & ~0xf0u); + return 1; + + // fixarray + case 0x90: case 0x91: case 0x92: case 0x93: case 0x94: case 0x95: case 0x96: case 0x97: + case 0x98: case 0x99: case 0x9a: case 0x9b: case 0x9c: case 0x9d: case 0x9e: case 0x9f: + *tag = mpack_tag_make_array(type & ~0xf0u); + return 1; + + // fixstr + case 0xa0: case 0xa1: case 0xa2: case 0xa3: case 0xa4: case 0xa5: case 0xa6: case 0xa7: + case 0xa8: case 0xa9: case 0xaa: case 0xab: case 0xac: case 0xad: case 0xae: case 0xaf: + case 0xb0: case 0xb1: case 0xb2: case 0xb3: case 0xb4: case 0xb5: case 0xb6: case 0xb7: + case 0xb8: case 0xb9: case 0xba: case 0xbb: case 0xbc: case 0xbd: case 0xbe: case 0xbf: + *tag = mpack_tag_make_str(type & ~0xe0u); + return 1; + #endif + + // nil + case 0xc0: + *tag = mpack_tag_make_nil(); + return 1; + + // bool + case 0xc2: case 0xc3: + *tag = mpack_tag_make_bool((bool)(type & 1)); + return 1; + + // bin8 + case 0xc4: + if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_BIN8)) + return 0; + *tag = mpack_tag_make_bin(mpack_load_u8(reader->data + 1)); + return MPACK_TAG_SIZE_BIN8; + + // bin16 + case 0xc5: + if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_BIN16)) + return 0; + *tag = mpack_tag_make_bin(mpack_load_u16(reader->data + 1)); + return MPACK_TAG_SIZE_BIN16; + + // bin32 + case 0xc6: + if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_BIN32)) + return 0; + *tag = mpack_tag_make_bin(mpack_load_u32(reader->data + 1)); + return MPACK_TAG_SIZE_BIN32; + + #if MPACK_EXTENSIONS + // ext8 + case 0xc7: + if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_EXT8)) + return 0; + *tag = mpack_tag_make_ext(mpack_load_i8(reader->data + 2), mpack_load_u8(reader->data + 1)); + return MPACK_TAG_SIZE_EXT8; + + // ext16 + case 0xc8: + if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_EXT16)) + return 0; + *tag = mpack_tag_make_ext(mpack_load_i8(reader->data + 3), mpack_load_u16(reader->data + 1)); + return MPACK_TAG_SIZE_EXT16; + + // ext32 + case 0xc9: + if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_EXT32)) + return 0; + *tag = mpack_tag_make_ext(mpack_load_i8(reader->data + 5), mpack_load_u32(reader->data + 1)); + return MPACK_TAG_SIZE_EXT32; + #endif + + // float + case 0xca: + if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_FLOAT)) + return 0; + #if MPACK_FLOAT + *tag = mpack_tag_make_float(mpack_load_float(reader->data + 1)); + #else + *tag = mpack_tag_make_raw_float(mpack_load_u32(reader->data + 1)); + #endif + return MPACK_TAG_SIZE_FLOAT; + + // double + case 0xcb: + if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_DOUBLE)) + return 0; + #if MPACK_DOUBLE + *tag = mpack_tag_make_double(mpack_load_double(reader->data + 1)); + #else + *tag = mpack_tag_make_raw_double(mpack_load_u64(reader->data + 1)); + #endif + return MPACK_TAG_SIZE_DOUBLE; + + // uint8 + case 0xcc: + if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_U8)) + return 0; + *tag = mpack_tag_make_uint(mpack_load_u8(reader->data + 1)); + return MPACK_TAG_SIZE_U8; + + // uint16 + case 0xcd: + if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_U16)) + return 0; + *tag = mpack_tag_make_uint(mpack_load_u16(reader->data + 1)); + return MPACK_TAG_SIZE_U16; + + // uint32 + case 0xce: + if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_U32)) + return 0; + *tag = mpack_tag_make_uint(mpack_load_u32(reader->data + 1)); + return MPACK_TAG_SIZE_U32; + + // uint64 + case 0xcf: + if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_U64)) + return 0; + *tag = mpack_tag_make_uint(mpack_load_u64(reader->data + 1)); + return MPACK_TAG_SIZE_U64; + + // int8 + case 0xd0: + if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_I8)) + return 0; + *tag = mpack_tag_make_int(mpack_load_i8(reader->data + 1)); + return MPACK_TAG_SIZE_I8; + + // int16 + case 0xd1: + if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_I16)) + return 0; + *tag = mpack_tag_make_int(mpack_load_i16(reader->data + 1)); + return MPACK_TAG_SIZE_I16; + + // int32 + case 0xd2: + if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_I32)) + return 0; + *tag = mpack_tag_make_int(mpack_load_i32(reader->data + 1)); + return MPACK_TAG_SIZE_I32; + + // int64 + case 0xd3: + if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_I64)) + return 0; + *tag = mpack_tag_make_int(mpack_load_i64(reader->data + 1)); + return MPACK_TAG_SIZE_I64; + + #if MPACK_EXTENSIONS + // fixext1 + case 0xd4: + if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_FIXEXT1)) + return 0; + *tag = mpack_tag_make_ext(mpack_load_i8(reader->data + 1), 1); + return MPACK_TAG_SIZE_FIXEXT1; + + // fixext2 + case 0xd5: + if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_FIXEXT2)) + return 0; + *tag = mpack_tag_make_ext(mpack_load_i8(reader->data + 1), 2); + return MPACK_TAG_SIZE_FIXEXT2; + + // fixext4 + case 0xd6: + if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_FIXEXT4)) + return 0; + *tag = mpack_tag_make_ext(mpack_load_i8(reader->data + 1), 4); + return 2; + + // fixext8 + case 0xd7: + if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_FIXEXT8)) + return 0; + *tag = mpack_tag_make_ext(mpack_load_i8(reader->data + 1), 8); + return MPACK_TAG_SIZE_FIXEXT8; + + // fixext16 + case 0xd8: + if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_FIXEXT16)) + return 0; + *tag = mpack_tag_make_ext(mpack_load_i8(reader->data + 1), 16); + return MPACK_TAG_SIZE_FIXEXT16; + #endif + + // str8 + case 0xd9: + if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_STR8)) + return 0; + *tag = mpack_tag_make_str(mpack_load_u8(reader->data + 1)); + return MPACK_TAG_SIZE_STR8; + + // str16 + case 0xda: + if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_STR16)) + return 0; + *tag = mpack_tag_make_str(mpack_load_u16(reader->data + 1)); + return MPACK_TAG_SIZE_STR16; + + // str32 + case 0xdb: + if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_STR32)) + return 0; + *tag = mpack_tag_make_str(mpack_load_u32(reader->data + 1)); + return MPACK_TAG_SIZE_STR32; + + // array16 + case 0xdc: + if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_ARRAY16)) + return 0; + *tag = mpack_tag_make_array(mpack_load_u16(reader->data + 1)); + return MPACK_TAG_SIZE_ARRAY16; + + // array32 + case 0xdd: + if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_ARRAY32)) + return 0; + *tag = mpack_tag_make_array(mpack_load_u32(reader->data + 1)); + return MPACK_TAG_SIZE_ARRAY32; + + // map16 + case 0xde: + if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_MAP16)) + return 0; + *tag = mpack_tag_make_map(mpack_load_u16(reader->data + 1)); + return MPACK_TAG_SIZE_MAP16; + + // map32 + case 0xdf: + if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_MAP32)) + return 0; + *tag = mpack_tag_make_map(mpack_load_u32(reader->data + 1)); + return MPACK_TAG_SIZE_MAP32; + + // reserved + case 0xc1: + mpack_reader_flag_error(reader, mpack_error_invalid); + return 0; + + #if !MPACK_EXTENSIONS + // ext + case 0xc7: // fallthrough + case 0xc8: // fallthrough + case 0xc9: // fallthrough + // fixext + case 0xd4: // fallthrough + case 0xd5: // fallthrough + case 0xd6: // fallthrough + case 0xd7: // fallthrough + case 0xd8: + mpack_reader_flag_error(reader, mpack_error_unsupported); + return 0; + #endif + + #if MPACK_OPTIMIZE_FOR_SIZE + // any other bytes should have been handled by the infix switch + default: + break; + #endif + } + + mpack_assert(0, "unreachable"); + return 0; +} + +mpack_tag_t mpack_read_tag(mpack_reader_t* reader) { + mpack_log("reading tag\n"); + + // make sure we can read a tag + if (mpack_reader_error(reader) != mpack_ok) + return mpack_tag_nil(); + if (mpack_reader_track_element(reader) != mpack_ok) + return mpack_tag_nil(); + + mpack_tag_t tag = MPACK_TAG_ZERO; + size_t count = mpack_parse_tag(reader, &tag); + if (count == 0) + return mpack_tag_nil(); + + #if MPACK_READ_TRACKING + mpack_error_t track_error = mpack_ok; + + switch (tag.type) { + case mpack_type_map: + case mpack_type_array: + track_error = mpack_track_push(&reader->track, tag.type, tag.v.n); + break; + #if MPACK_EXTENSIONS + case mpack_type_ext: + #endif + case mpack_type_str: + case mpack_type_bin: + track_error = mpack_track_push(&reader->track, tag.type, tag.v.l); + break; + default: + break; + } + + if (track_error != mpack_ok) { + mpack_reader_flag_error(reader, track_error); + return mpack_tag_nil(); + } + #endif + + reader->data += count; + return tag; +} + +mpack_tag_t mpack_peek_tag(mpack_reader_t* reader) { + mpack_log("peeking tag\n"); + + // make sure we can peek a tag + if (mpack_reader_error(reader) != mpack_ok) + return mpack_tag_nil(); + if (mpack_reader_track_peek_element(reader) != mpack_ok) + return mpack_tag_nil(); + + mpack_tag_t tag = MPACK_TAG_ZERO; + if (mpack_parse_tag(reader, &tag) == 0) + return mpack_tag_nil(); + return tag; +} + +void mpack_discard(mpack_reader_t* reader) { + mpack_tag_t var = mpack_read_tag(reader); + if (mpack_reader_error(reader)) + return; + switch (var.type) { + case mpack_type_str: + mpack_skip_bytes(reader, var.v.l); + mpack_done_str(reader); + break; + case mpack_type_bin: + mpack_skip_bytes(reader, var.v.l); + mpack_done_bin(reader); + break; + #if MPACK_EXTENSIONS + case mpack_type_ext: + mpack_skip_bytes(reader, var.v.l); + mpack_done_ext(reader); + break; + #endif + case mpack_type_array: { + for (; var.v.n > 0; --var.v.n) { + mpack_discard(reader); + if (mpack_reader_error(reader)) + break; + } + mpack_done_array(reader); + break; + } + case mpack_type_map: { + for (; var.v.n > 0; --var.v.n) { + mpack_discard(reader); + mpack_discard(reader); + if (mpack_reader_error(reader)) + break; + } + mpack_done_map(reader); + break; + } + default: + break; + } +} + +#if MPACK_EXTENSIONS +mpack_timestamp_t mpack_read_timestamp(mpack_reader_t* reader, size_t size) { + mpack_timestamp_t timestamp = {0, 0}; + + if (size != 4 && size != 8 && size != 12) { + mpack_reader_flag_error(reader, mpack_error_invalid); + return timestamp; + } + + char buf[12]; + mpack_read_bytes(reader, buf, size); + mpack_done_ext(reader); + if (mpack_reader_error(reader) != mpack_ok) + return timestamp; + + switch (size) { + case 4: + timestamp.seconds = (int64_t)(uint64_t)mpack_load_u32(buf); + break; + + case 8: { + uint64_t packed = mpack_load_u64(buf); + timestamp.seconds = (int64_t)(packed & ((MPACK_UINT64_C(1) << 34) - 1)); + timestamp.nanoseconds = (uint32_t)(packed >> 34); + break; + } + + case 12: + timestamp.nanoseconds = mpack_load_u32(buf); + timestamp.seconds = mpack_load_i64(buf + 4); + break; + + default: + mpack_assert(false, "unreachable"); + break; + } + + if (timestamp.nanoseconds > MPACK_TIMESTAMP_NANOSECONDS_MAX) { + mpack_reader_flag_error(reader, mpack_error_invalid); + mpack_timestamp_t zero = {0, 0}; + return zero; + } + + return timestamp; +} +#endif + +#if MPACK_READ_TRACKING +void mpack_done_type(mpack_reader_t* reader, mpack_type_t type) { + if (mpack_reader_error(reader) == mpack_ok) + mpack_reader_flag_if_error(reader, mpack_track_pop(&reader->track, type)); +} +#endif + +#if MPACK_DEBUG && MPACK_STDIO +static size_t mpack_print_read_prefix(mpack_reader_t* reader, size_t length, char* buffer, size_t buffer_size) { + if (length == 0) + return 0; + + size_t read = (length < buffer_size) ? length : buffer_size; + mpack_read_bytes(reader, buffer, read); + if (mpack_reader_error(reader) != mpack_ok) + return 0; + + mpack_skip_bytes(reader, length - read); + return read; +} + +static void mpack_print_element(mpack_reader_t* reader, mpack_print_t* print, size_t depth) { + mpack_tag_t val = mpack_read_tag(reader); + if (mpack_reader_error(reader) != mpack_ok) + return; + + // We read some bytes from bin and ext so we can print its prefix in hex. + char buffer[MPACK_PRINT_BYTE_COUNT]; + size_t count = 0; + size_t i, j; + + switch (val.type) { + case mpack_type_str: + mpack_print_append_cstr(print, "\""); + for (i = 0; i < val.v.l; ++i) { + char c; + mpack_read_bytes(reader, &c, 1); + if (mpack_reader_error(reader) != mpack_ok) + return; + switch (c) { + case '\n': mpack_print_append_cstr(print, "\\n"); break; + case '\\': mpack_print_append_cstr(print, "\\\\"); break; + case '"': mpack_print_append_cstr(print, "\\\""); break; + default: mpack_print_append(print, &c, 1); break; + } + } + mpack_print_append_cstr(print, "\""); + mpack_done_str(reader); + return; + + case mpack_type_array: + mpack_print_append_cstr(print, "[\n"); + for (i = 0; i < val.v.n; ++i) { + for (j = 0; j < depth + 1; ++j) + mpack_print_append_cstr(print, " "); + mpack_print_element(reader, print, depth + 1); + if (mpack_reader_error(reader) != mpack_ok) + return; + if (i != val.v.n - 1) + mpack_print_append_cstr(print, ","); + mpack_print_append_cstr(print, "\n"); + } + for (i = 0; i < depth; ++i) + mpack_print_append_cstr(print, " "); + mpack_print_append_cstr(print, "]"); + mpack_done_array(reader); + return; + + case mpack_type_map: + mpack_print_append_cstr(print, "{\n"); + for (i = 0; i < val.v.n; ++i) { + for (j = 0; j < depth + 1; ++j) + mpack_print_append_cstr(print, " "); + mpack_print_element(reader, print, depth + 1); + if (mpack_reader_error(reader) != mpack_ok) + return; + mpack_print_append_cstr(print, ": "); + mpack_print_element(reader, print, depth + 1); + if (mpack_reader_error(reader) != mpack_ok) + return; + if (i != val.v.n - 1) + mpack_print_append_cstr(print, ","); + mpack_print_append_cstr(print, "\n"); + } + for (i = 0; i < depth; ++i) + mpack_print_append_cstr(print, " "); + mpack_print_append_cstr(print, "}"); + mpack_done_map(reader); + return; + + // The above cases return so as not to print a pseudo-json value. The + // below cases break and print pseudo-json. + + case mpack_type_bin: + count = mpack_print_read_prefix(reader, mpack_tag_bin_length(&val), buffer, sizeof(buffer)); + mpack_done_bin(reader); + break; + + #if MPACK_EXTENSIONS + case mpack_type_ext: + count = mpack_print_read_prefix(reader, mpack_tag_ext_length(&val), buffer, sizeof(buffer)); + mpack_done_ext(reader); + break; + #endif + + default: + break; + } + + char buf[256]; + mpack_tag_debug_pseudo_json(val, buf, sizeof(buf), buffer, count); + mpack_print_append_cstr(print, buf); +} + +static void mpack_print_and_destroy(mpack_reader_t* reader, mpack_print_t* print, size_t depth) { + size_t i; + for (i = 0; i < depth; ++i) + mpack_print_append_cstr(print, " "); + mpack_print_element(reader, print, depth); + + size_t remaining = mpack_reader_remaining(reader, NULL); + + char buf[256]; + if (mpack_reader_destroy(reader) != mpack_ok) { + mpack_snprintf(buf, sizeof(buf), "\n", mpack_error_to_string(mpack_reader_error(reader))); + buf[sizeof(buf) - 1] = '\0'; + mpack_print_append_cstr(print, buf); + } else if (remaining > 0) { + mpack_snprintf(buf, sizeof(buf), "\n<%i extra bytes at end of message>", (int)remaining); + buf[sizeof(buf) - 1] = '\0'; + mpack_print_append_cstr(print, buf); + } +} + +static void mpack_print_data(const char* data, size_t len, mpack_print_t* print, size_t depth) { + mpack_reader_t reader; + mpack_reader_init_data(&reader, data, len); + mpack_print_and_destroy(&reader, print, depth); +} + +void mpack_print_data_to_buffer(const char* data, size_t data_size, char* buffer, size_t buffer_size) { + if (buffer_size == 0) { + mpack_assert(false, "buffer size is zero!"); + return; + } + + mpack_print_t print; + mpack_memset(&print, 0, sizeof(print)); + print.buffer = buffer; + print.size = buffer_size; + mpack_print_data(data, data_size, &print, 0); + mpack_print_append(&print, "", 1); // null-terminator + mpack_print_flush(&print); + + // we always make sure there's a null-terminator at the end of the buffer + // in case we ran out of space. + print.buffer[print.size - 1] = '\0'; +} + +void mpack_print_data_to_callback(const char* data, size_t size, mpack_print_callback_t callback, void* context) { + char buffer[1024]; + mpack_print_t print; + mpack_memset(&print, 0, sizeof(print)); + print.buffer = buffer; + print.size = sizeof(buffer); + print.callback = callback; + print.context = context; + mpack_print_data(data, size, &print, 0); + mpack_print_flush(&print); +} + +void mpack_print_data_to_file(const char* data, size_t len, FILE* file) { + mpack_assert(data != NULL, "data is NULL"); + mpack_assert(file != NULL, "file is NULL"); + + char buffer[1024]; + mpack_print_t print; + mpack_memset(&print, 0, sizeof(print)); + print.buffer = buffer; + print.size = sizeof(buffer); + print.callback = &mpack_print_file_callback; + print.context = file; + + mpack_print_data(data, len, &print, 2); + mpack_print_append_cstr(&print, "\n"); + mpack_print_flush(&print); +} + +void mpack_print_stdfile_to_callback(FILE* file, mpack_print_callback_t callback, void* context) { + char buffer[1024]; + mpack_print_t print; + mpack_memset(&print, 0, sizeof(print)); + print.buffer = buffer; + print.size = sizeof(buffer); + print.callback = callback; + print.context = context; + + mpack_reader_t reader; + mpack_reader_init_stdfile(&reader, file, false); + mpack_print_and_destroy(&reader, &print, 0); + mpack_print_flush(&print); +} +#endif + +#endif + +MPACK_SILENCE_WARNINGS_END + +/* mpack/mpack-expect.c.c */ + +#define MPACK_INTERNAL 1 + +/* #include "mpack-expect.h" */ + +MPACK_SILENCE_WARNINGS_BEGIN + +#if MPACK_EXPECT + + +// Helpers + +MPACK_STATIC_INLINE uint8_t mpack_expect_native_u8(mpack_reader_t* reader) { + if (mpack_reader_error(reader) != mpack_ok) + return 0; + uint8_t type; + if (!mpack_reader_ensure(reader, sizeof(type))) + return 0; + type = mpack_load_u8(reader->data); + reader->data += sizeof(type); + return type; +} + +#if !MPACK_OPTIMIZE_FOR_SIZE +MPACK_STATIC_INLINE uint16_t mpack_expect_native_u16(mpack_reader_t* reader) { + if (mpack_reader_error(reader) != mpack_ok) + return 0; + uint16_t type; + if (!mpack_reader_ensure(reader, sizeof(type))) + return 0; + type = mpack_load_u16(reader->data); + reader->data += sizeof(type); + return type; +} + +MPACK_STATIC_INLINE uint32_t mpack_expect_native_u32(mpack_reader_t* reader) { + if (mpack_reader_error(reader) != mpack_ok) + return 0; + uint32_t type; + if (!mpack_reader_ensure(reader, sizeof(type))) + return 0; + type = mpack_load_u32(reader->data); + reader->data += sizeof(type); + return type; +} +#endif + +MPACK_STATIC_INLINE uint8_t mpack_expect_type_byte(mpack_reader_t* reader) { + mpack_reader_track_element(reader); + return mpack_expect_native_u8(reader); +} + + +// Basic Number Functions + +uint8_t mpack_expect_u8(mpack_reader_t* reader) { + mpack_tag_t var = mpack_read_tag(reader); + if (var.type == mpack_type_uint) { + if (var.v.u <= MPACK_UINT8_MAX) + return (uint8_t)var.v.u; + } else if (var.type == mpack_type_int) { + if (var.v.i >= 0 && var.v.i <= MPACK_UINT8_MAX) + return (uint8_t)var.v.i; + } + mpack_reader_flag_error(reader, mpack_error_type); + return 0; +} + +uint16_t mpack_expect_u16(mpack_reader_t* reader) { + mpack_tag_t var = mpack_read_tag(reader); + if (var.type == mpack_type_uint) { + if (var.v.u <= MPACK_UINT16_MAX) + return (uint16_t)var.v.u; + } else if (var.type == mpack_type_int) { + if (var.v.i >= 0 && var.v.i <= MPACK_UINT16_MAX) + return (uint16_t)var.v.i; + } + mpack_reader_flag_error(reader, mpack_error_type); + return 0; +} + +uint32_t mpack_expect_u32(mpack_reader_t* reader) { + mpack_tag_t var = mpack_read_tag(reader); + if (var.type == mpack_type_uint) { + if (var.v.u <= MPACK_UINT32_MAX) + return (uint32_t)var.v.u; + } else if (var.type == mpack_type_int) { + if (var.v.i >= 0 && var.v.i <= MPACK_UINT32_MAX) + return (uint32_t)var.v.i; + } + mpack_reader_flag_error(reader, mpack_error_type); + return 0; +} + +uint64_t mpack_expect_u64(mpack_reader_t* reader) { + mpack_tag_t var = mpack_read_tag(reader); + if (var.type == mpack_type_uint) { + return var.v.u; + } else if (var.type == mpack_type_int) { + if (var.v.i >= 0) + return (uint64_t)var.v.i; + } + mpack_reader_flag_error(reader, mpack_error_type); + return 0; +} + +int8_t mpack_expect_i8(mpack_reader_t* reader) { + mpack_tag_t var = mpack_read_tag(reader); + if (var.type == mpack_type_uint) { + if (var.v.u <= MPACK_INT8_MAX) + return (int8_t)var.v.u; + } else if (var.type == mpack_type_int) { + if (var.v.i >= MPACK_INT8_MIN && var.v.i <= MPACK_INT8_MAX) + return (int8_t)var.v.i; + } + mpack_reader_flag_error(reader, mpack_error_type); + return 0; +} + +int16_t mpack_expect_i16(mpack_reader_t* reader) { + mpack_tag_t var = mpack_read_tag(reader); + if (var.type == mpack_type_uint) { + if (var.v.u <= MPACK_INT16_MAX) + return (int16_t)var.v.u; + } else if (var.type == mpack_type_int) { + if (var.v.i >= MPACK_INT16_MIN && var.v.i <= MPACK_INT16_MAX) + return (int16_t)var.v.i; + } + mpack_reader_flag_error(reader, mpack_error_type); + return 0; +} + +int32_t mpack_expect_i32(mpack_reader_t* reader) { + mpack_tag_t var = mpack_read_tag(reader); + if (var.type == mpack_type_uint) { + if (var.v.u <= MPACK_INT32_MAX) + return (int32_t)var.v.u; + } else if (var.type == mpack_type_int) { + if (var.v.i >= MPACK_INT32_MIN && var.v.i <= MPACK_INT32_MAX) + return (int32_t)var.v.i; + } + mpack_reader_flag_error(reader, mpack_error_type); + return 0; +} + +int64_t mpack_expect_i64(mpack_reader_t* reader) { + mpack_tag_t var = mpack_read_tag(reader); + if (var.type == mpack_type_uint) { + if (var.v.u <= MPACK_INT64_MAX) + return (int64_t)var.v.u; + } else if (var.type == mpack_type_int) { + return var.v.i; + } + mpack_reader_flag_error(reader, mpack_error_type); + return 0; +} + +#if MPACK_FLOAT +float mpack_expect_float(mpack_reader_t* reader) { + mpack_tag_t var = mpack_read_tag(reader); + if (var.type == mpack_type_uint) + return (float)var.v.u; + if (var.type == mpack_type_int) + return (float)var.v.i; + if (var.type == mpack_type_float) + return var.v.f; + + if (var.type == mpack_type_double) { + #if MPACK_DOUBLE + return (float)var.v.d; + #else + return mpack_shorten_raw_double_to_float(var.v.d); + #endif + } + + mpack_reader_flag_error(reader, mpack_error_type); + return 0.0f; +} +#endif + +#if MPACK_DOUBLE +double mpack_expect_double(mpack_reader_t* reader) { + mpack_tag_t var = mpack_read_tag(reader); + if (var.type == mpack_type_uint) + return (double)var.v.u; + else if (var.type == mpack_type_int) + return (double)var.v.i; + else if (var.type == mpack_type_float) + return (double)var.v.f; + else if (var.type == mpack_type_double) + return var.v.d; + mpack_reader_flag_error(reader, mpack_error_type); + return 0.0; +} +#endif + +#if MPACK_FLOAT +float mpack_expect_float_strict(mpack_reader_t* reader) { + mpack_tag_t var = mpack_read_tag(reader); + if (var.type == mpack_type_float) + return var.v.f; + mpack_reader_flag_error(reader, mpack_error_type); + return 0.0f; +} +#endif + +#if MPACK_DOUBLE +double mpack_expect_double_strict(mpack_reader_t* reader) { + mpack_tag_t var = mpack_read_tag(reader); + if (var.type == mpack_type_float) + return (double)var.v.f; + else if (var.type == mpack_type_double) + return var.v.d; + mpack_reader_flag_error(reader, mpack_error_type); + return 0.0; +} +#endif + +#if !MPACK_FLOAT +uint32_t mpack_expect_raw_float(mpack_reader_t* reader) { + mpack_tag_t var = mpack_read_tag(reader); + if (var.type == mpack_type_float) + return var.v.f; + mpack_reader_flag_error(reader, mpack_error_type); + return 0; +} +#endif + +#if !MPACK_DOUBLE +uint64_t mpack_expect_raw_double(mpack_reader_t* reader) { + mpack_tag_t var = mpack_read_tag(reader); + if (var.type == mpack_type_double) + return var.v.d; + mpack_reader_flag_error(reader, mpack_error_type); + return 0; +} +#endif + + +// Ranged Number Functions +// +// All ranged functions are identical other than the type, so we +// define their content with a macro. The prototypes are still written +// out in full to support ctags/IDE tools. + +#define MPACK_EXPECT_RANGE_IMPL(name, type_t) \ + \ + /* make sure the range is sensible */ \ + mpack_assert(min_value <= max_value, \ + "min_value %i must be less than or equal to max_value %i", \ + min_value, max_value); \ + \ + /* read the value */ \ + type_t val = mpack_expect_##name(reader); \ + if (mpack_reader_error(reader) != mpack_ok) \ + return min_value; \ + \ + /* make sure it fits */ \ + if (val < min_value || val > max_value) { \ + mpack_reader_flag_error(reader, mpack_error_type); \ + return min_value; \ + } \ + \ + return val; + +uint8_t mpack_expect_u8_range(mpack_reader_t* reader, uint8_t min_value, uint8_t max_value) {MPACK_EXPECT_RANGE_IMPL(u8, uint8_t)} +uint16_t mpack_expect_u16_range(mpack_reader_t* reader, uint16_t min_value, uint16_t max_value) {MPACK_EXPECT_RANGE_IMPL(u16, uint16_t)} +uint32_t mpack_expect_u32_range(mpack_reader_t* reader, uint32_t min_value, uint32_t max_value) {MPACK_EXPECT_RANGE_IMPL(u32, uint32_t)} +uint64_t mpack_expect_u64_range(mpack_reader_t* reader, uint64_t min_value, uint64_t max_value) {MPACK_EXPECT_RANGE_IMPL(u64, uint64_t)} + +int8_t mpack_expect_i8_range(mpack_reader_t* reader, int8_t min_value, int8_t max_value) {MPACK_EXPECT_RANGE_IMPL(i8, int8_t)} +int16_t mpack_expect_i16_range(mpack_reader_t* reader, int16_t min_value, int16_t max_value) {MPACK_EXPECT_RANGE_IMPL(i16, int16_t)} +int32_t mpack_expect_i32_range(mpack_reader_t* reader, int32_t min_value, int32_t max_value) {MPACK_EXPECT_RANGE_IMPL(i32, int32_t)} +int64_t mpack_expect_i64_range(mpack_reader_t* reader, int64_t min_value, int64_t max_value) {MPACK_EXPECT_RANGE_IMPL(i64, int64_t)} + +#if MPACK_FLOAT +float mpack_expect_float_range(mpack_reader_t* reader, float min_value, float max_value) {MPACK_EXPECT_RANGE_IMPL(float, float)} +#endif +#if MPACK_DOUBLE +double mpack_expect_double_range(mpack_reader_t* reader, double min_value, double max_value) {MPACK_EXPECT_RANGE_IMPL(double, double)} +#endif + +uint32_t mpack_expect_map_range(mpack_reader_t* reader, uint32_t min_value, uint32_t max_value) {MPACK_EXPECT_RANGE_IMPL(map, uint32_t)} +uint32_t mpack_expect_array_range(mpack_reader_t* reader, uint32_t min_value, uint32_t max_value) {MPACK_EXPECT_RANGE_IMPL(array, uint32_t)} + + +// Matching Number Functions + +void mpack_expect_uint_match(mpack_reader_t* reader, uint64_t value) { + if (mpack_expect_u64(reader) != value) + mpack_reader_flag_error(reader, mpack_error_type); +} + +void mpack_expect_int_match(mpack_reader_t* reader, int64_t value) { + if (mpack_expect_i64(reader) != value) + mpack_reader_flag_error(reader, mpack_error_type); +} + + +// Other Basic Types + +void mpack_expect_nil(mpack_reader_t* reader) { + if (mpack_expect_type_byte(reader) != 0xc0) + mpack_reader_flag_error(reader, mpack_error_type); +} + +bool mpack_expect_bool(mpack_reader_t* reader) { + uint8_t type = mpack_expect_type_byte(reader); + if ((type & ~1) != 0xc2) + mpack_reader_flag_error(reader, mpack_error_type); + return (bool)(type & 1); +} + +void mpack_expect_true(mpack_reader_t* reader) { + if (mpack_expect_bool(reader) != true) + mpack_reader_flag_error(reader, mpack_error_type); +} + +void mpack_expect_false(mpack_reader_t* reader) { + if (mpack_expect_bool(reader) != false) + mpack_reader_flag_error(reader, mpack_error_type); +} + +#if MPACK_EXTENSIONS +mpack_timestamp_t mpack_expect_timestamp(mpack_reader_t* reader) { + mpack_timestamp_t zero = {0, 0}; + + mpack_tag_t tag = mpack_read_tag(reader); + if (tag.type != mpack_type_ext) { + mpack_reader_flag_error(reader, mpack_error_type); + return zero; + } + if (mpack_tag_ext_exttype(&tag) != MPACK_EXTTYPE_TIMESTAMP) { + mpack_reader_flag_error(reader, mpack_error_type); + return zero; + } + + return mpack_read_timestamp(reader, mpack_tag_ext_length(&tag)); +} + +int64_t mpack_expect_timestamp_truncate(mpack_reader_t* reader) { + return mpack_expect_timestamp(reader).seconds; +} +#endif + + +// Compound Types + +uint32_t mpack_expect_map(mpack_reader_t* reader) { + mpack_tag_t var = mpack_read_tag(reader); + if (var.type == mpack_type_map) + return var.v.n; + mpack_reader_flag_error(reader, mpack_error_type); + return 0; +} + +void mpack_expect_map_match(mpack_reader_t* reader, uint32_t count) { + if (mpack_expect_map(reader) != count) + mpack_reader_flag_error(reader, mpack_error_type); +} + +bool mpack_expect_map_or_nil(mpack_reader_t* reader, uint32_t* count) { + mpack_assert(count != NULL, "count cannot be NULL"); + + mpack_tag_t var = mpack_read_tag(reader); + if (var.type == mpack_type_nil) { + *count = 0; + return false; + } + if (var.type == mpack_type_map) { + *count = var.v.n; + return true; + } + mpack_reader_flag_error(reader, mpack_error_type); + *count = 0; + return false; +} + +bool mpack_expect_map_max_or_nil(mpack_reader_t* reader, uint32_t max_count, uint32_t* count) { + mpack_assert(count != NULL, "count cannot be NULL"); + + bool has_map = mpack_expect_map_or_nil(reader, count); + if (has_map && *count > max_count) { + *count = 0; + mpack_reader_flag_error(reader, mpack_error_type); + return false; + } + return has_map; +} + +uint32_t mpack_expect_array(mpack_reader_t* reader) { + mpack_tag_t var = mpack_read_tag(reader); + if (var.type == mpack_type_array) + return var.v.n; + mpack_reader_flag_error(reader, mpack_error_type); + return 0; +} + +void mpack_expect_array_match(mpack_reader_t* reader, uint32_t count) { + if (mpack_expect_array(reader) != count) + mpack_reader_flag_error(reader, mpack_error_type); +} + +bool mpack_expect_array_or_nil(mpack_reader_t* reader, uint32_t* count) { + mpack_assert(count != NULL, "count cannot be NULL"); + + mpack_tag_t var = mpack_read_tag(reader); + if (var.type == mpack_type_nil) { + *count = 0; + return false; + } + if (var.type == mpack_type_array) { + *count = var.v.n; + return true; + } + mpack_reader_flag_error(reader, mpack_error_type); + *count = 0; + return false; +} + +bool mpack_expect_array_max_or_nil(mpack_reader_t* reader, uint32_t max_count, uint32_t* count) { + mpack_assert(count != NULL, "count cannot be NULL"); + + bool has_array = mpack_expect_array_or_nil(reader, count); + if (has_array && *count > max_count) { + *count = 0; + mpack_reader_flag_error(reader, mpack_error_type); + return false; + } + return has_array; +} + +#ifdef MPACK_MALLOC +void* mpack_expect_array_alloc_impl(mpack_reader_t* reader, size_t element_size, uint32_t max_count, uint32_t* out_count, bool allow_nil) { + mpack_assert(out_count != NULL, "out_count cannot be NULL"); + *out_count = 0; + + uint32_t count; + bool has_array = true; + if (allow_nil) + has_array = mpack_expect_array_max_or_nil(reader, max_count, &count); + else + count = mpack_expect_array_max(reader, max_count); + if (mpack_reader_error(reader)) + return NULL; + + // size 0 is not an error; we return NULL for no elements. + if (count == 0) { + // we call mpack_done_array() automatically ONLY if we are using + // the _or_nil variant. this is the only way to allow nil and empty + // to work the same way. + if (allow_nil && has_array) + mpack_done_array(reader); + return NULL; + } + + void* p = MPACK_MALLOC(element_size * count); + if (p == NULL) { + mpack_reader_flag_error(reader, mpack_error_memory); + return NULL; + } + + *out_count = count; + return p; +} +#endif + + +// Str, Bin and Ext Functions + +uint32_t mpack_expect_str(mpack_reader_t* reader) { + #if MPACK_OPTIMIZE_FOR_SIZE + mpack_tag_t var = mpack_read_tag(reader); + if (var.type == mpack_type_str) + return var.v.l; + mpack_reader_flag_error(reader, mpack_error_type); + return 0; + #else + uint8_t type = mpack_expect_type_byte(reader); + uint32_t count; + + if ((type >> 5) == 5) { + count = type & (uint8_t)~0xe0; + } else if (type == 0xd9) { + count = mpack_expect_native_u8(reader); + } else if (type == 0xda) { + count = mpack_expect_native_u16(reader); + } else if (type == 0xdb) { + count = mpack_expect_native_u32(reader); + } else { + mpack_reader_flag_error(reader, mpack_error_type); + return 0; + } + + #if MPACK_READ_TRACKING + mpack_reader_flag_if_error(reader, mpack_track_push(&reader->track, mpack_type_str, count)); + #endif + return count; + #endif +} + +size_t mpack_expect_str_buf(mpack_reader_t* reader, char* buf, size_t bufsize) { + mpack_assert(buf != NULL, "buf cannot be NULL"); + + size_t length = mpack_expect_str(reader); + if (mpack_reader_error(reader)) + return 0; + + if (length > bufsize) { + mpack_reader_flag_error(reader, mpack_error_too_big); + return 0; + } + + mpack_read_bytes(reader, buf, length); + if (mpack_reader_error(reader)) + return 0; + + mpack_done_str(reader); + return length; +} + +size_t mpack_expect_utf8(mpack_reader_t* reader, char* buf, size_t size) { + mpack_assert(buf != NULL, "buf cannot be NULL"); + + size_t length = mpack_expect_str_buf(reader, buf, size); + + if (!mpack_utf8_check(buf, length)) { + mpack_reader_flag_error(reader, mpack_error_type); + return 0; + } + + return length; +} + +uint32_t mpack_expect_bin(mpack_reader_t* reader) { + mpack_tag_t var = mpack_read_tag(reader); + if (var.type == mpack_type_bin) + return var.v.l; + mpack_reader_flag_error(reader, mpack_error_type); + return 0; +} + +size_t mpack_expect_bin_buf(mpack_reader_t* reader, char* buf, size_t bufsize) { + mpack_assert(buf != NULL, "buf cannot be NULL"); + + size_t binsize = mpack_expect_bin(reader); + if (mpack_reader_error(reader)) + return 0; + if (binsize > bufsize) { + mpack_reader_flag_error(reader, mpack_error_too_big); + return 0; + } + mpack_read_bytes(reader, buf, binsize); + if (mpack_reader_error(reader)) + return 0; + mpack_done_bin(reader); + return binsize; +} + +void mpack_expect_bin_size_buf(mpack_reader_t* reader, char* buf, uint32_t size) { + mpack_assert(buf != NULL, "buf cannot be NULL"); + mpack_expect_bin_size(reader, size); + mpack_read_bytes(reader, buf, size); + mpack_done_bin(reader); +} + +#if MPACK_EXTENSIONS +uint32_t mpack_expect_ext(mpack_reader_t* reader, int8_t* type) { + mpack_tag_t var = mpack_read_tag(reader); + if (var.type == mpack_type_ext) { + *type = mpack_tag_ext_exttype(&var); + return mpack_tag_ext_length(&var); + } + *type = 0; + mpack_reader_flag_error(reader, mpack_error_type); + return 0; +} + +size_t mpack_expect_ext_buf(mpack_reader_t* reader, int8_t* type, char* buf, size_t bufsize) { + mpack_assert(buf != NULL, "buf cannot be NULL"); + + size_t extsize = mpack_expect_ext(reader, type); + if (mpack_reader_error(reader)) + return 0; + if (extsize > bufsize) { + *type = 0; + mpack_reader_flag_error(reader, mpack_error_too_big); + return 0; + } + mpack_read_bytes(reader, buf, extsize); + if (mpack_reader_error(reader)) { + *type = 0; + return 0; + } + mpack_done_ext(reader); + return extsize; +} +#endif + +void mpack_expect_cstr(mpack_reader_t* reader, char* buf, size_t bufsize) { + uint32_t length = mpack_expect_str(reader); + mpack_read_cstr(reader, buf, bufsize, length); + mpack_done_str(reader); +} + +void mpack_expect_utf8_cstr(mpack_reader_t* reader, char* buf, size_t bufsize) { + uint32_t length = mpack_expect_str(reader); + mpack_read_utf8_cstr(reader, buf, bufsize, length); + mpack_done_str(reader); +} + +#ifdef MPACK_MALLOC +static char* mpack_expect_cstr_alloc_unchecked(mpack_reader_t* reader, size_t maxsize, size_t* out_length) { + mpack_assert(out_length != NULL, "out_length cannot be NULL"); + *out_length = 0; + + // make sure argument makes sense + if (maxsize < 1) { + mpack_break("maxsize is zero; you must have room for at least a null-terminator"); + mpack_reader_flag_error(reader, mpack_error_bug); + return NULL; + } + + if (SIZE_MAX < MPACK_UINT32_MAX) { + if (maxsize > SIZE_MAX) + maxsize = SIZE_MAX; + } else { + if (maxsize > (size_t)MPACK_UINT32_MAX) + maxsize = (size_t)MPACK_UINT32_MAX; + } + + size_t length = mpack_expect_str_max(reader, (uint32_t)maxsize - 1); + char* str = mpack_read_bytes_alloc_impl(reader, length, true); + mpack_done_str(reader); + + if (str) + *out_length = length; + return str; +} + +char* mpack_expect_cstr_alloc(mpack_reader_t* reader, size_t maxsize) { + size_t length; + char* str = mpack_expect_cstr_alloc_unchecked(reader, maxsize, &length); + + if (str && !mpack_str_check_no_null(str, length)) { + MPACK_FREE(str); + mpack_reader_flag_error(reader, mpack_error_type); + return NULL; + } + + return str; +} + +char* mpack_expect_utf8_cstr_alloc(mpack_reader_t* reader, size_t maxsize) { + size_t length; + char* str = mpack_expect_cstr_alloc_unchecked(reader, maxsize, &length); + + if (str && !mpack_utf8_check_no_null(str, length)) { + MPACK_FREE(str); + mpack_reader_flag_error(reader, mpack_error_type); + return NULL; + } + + return str; +} +#endif + +void mpack_expect_str_match(mpack_reader_t* reader, const char* str, size_t len) { + mpack_assert(str != NULL, "str cannot be NULL"); + + // expect a str the correct length + if (len > MPACK_UINT32_MAX) + mpack_reader_flag_error(reader, mpack_error_type); + mpack_expect_str_length(reader, (uint32_t)len); + if (mpack_reader_error(reader)) + return; + mpack_reader_track_bytes(reader, (uint32_t)len); + + // check each byte one by one (matched strings are likely to be very small) + for (; len > 0; --len) { + if (mpack_expect_native_u8(reader) != *str++) { + mpack_reader_flag_error(reader, mpack_error_type); + return; + } + } + + mpack_done_str(reader); +} + +void mpack_expect_tag(mpack_reader_t* reader, mpack_tag_t expected) { + mpack_tag_t actual = mpack_read_tag(reader); + if (!mpack_tag_equal(actual, expected)) + mpack_reader_flag_error(reader, mpack_error_type); +} + +#ifdef MPACK_MALLOC +char* mpack_expect_bin_alloc(mpack_reader_t* reader, size_t maxsize, size_t* size) { + mpack_assert(size != NULL, "size cannot be NULL"); + *size = 0; + + if (SIZE_MAX < MPACK_UINT32_MAX) { + if (maxsize > SIZE_MAX) + maxsize = SIZE_MAX; + } else { + if (maxsize > (size_t)MPACK_UINT32_MAX) + maxsize = (size_t)MPACK_UINT32_MAX; + } + + size_t length = mpack_expect_bin_max(reader, (uint32_t)maxsize); + if (mpack_reader_error(reader)) + return NULL; + + char* data = mpack_read_bytes_alloc(reader, length); + mpack_done_bin(reader); + + if (data) + *size = length; + return data; +} +#endif + +#if MPACK_EXTENSIONS && defined(MPACK_MALLOC) +char* mpack_expect_ext_alloc(mpack_reader_t* reader, int8_t* type, size_t maxsize, size_t* size) { + mpack_assert(size != NULL, "size cannot be NULL"); + *size = 0; + + if (SIZE_MAX < MPACK_UINT32_MAX) { + if (maxsize > SIZE_MAX) + maxsize = SIZE_MAX; + } else { + if (maxsize > (size_t)MPACK_UINT32_MAX) + maxsize = (size_t)MPACK_UINT32_MAX; + } + + size_t length = mpack_expect_ext_max(reader, type, (uint32_t)maxsize); + if (mpack_reader_error(reader)) + return NULL; + + char* data = mpack_read_bytes_alloc(reader, length); + mpack_done_ext(reader); + + if (data) { + *size = length; + } else { + *type = 0; + } + return data; +} +#endif + +size_t mpack_expect_enum(mpack_reader_t* reader, const char* strings[], size_t count) { + + // read the string in-place + size_t keylen = mpack_expect_str(reader); + const char* key = mpack_read_bytes_inplace(reader, keylen); + mpack_done_str(reader); + if (mpack_reader_error(reader) != mpack_ok) + return count; + + // find what key it matches + size_t i; + for (i = 0; i < count; ++i) { + const char* other = strings[i]; + size_t otherlen = mpack_strlen(other); + if (keylen == otherlen && mpack_memcmp(key, other, keylen) == 0) + return i; + } + + // no matches + mpack_reader_flag_error(reader, mpack_error_type); + return count; +} + +size_t mpack_expect_enum_optional(mpack_reader_t* reader, const char* strings[], size_t count) { + if (mpack_reader_error(reader) != mpack_ok) + return count; + + mpack_assert(count != 0, "count cannot be zero; no strings are valid!"); + mpack_assert(strings != NULL, "strings cannot be NULL"); + + // the key is only recognized if it is a string + if (mpack_peek_tag(reader).type != mpack_type_str) { + mpack_discard(reader); + return count; + } + + // read the string in-place + size_t keylen = mpack_expect_str(reader); + const char* key = mpack_read_bytes_inplace(reader, keylen); + mpack_done_str(reader); + if (mpack_reader_error(reader) != mpack_ok) + return count; + + // find what key it matches + size_t i; + for (i = 0; i < count; ++i) { + const char* other = strings[i]; + size_t otherlen = mpack_strlen(other); + if (keylen == otherlen && mpack_memcmp(key, other, keylen) == 0) + return i; + } + + // no matches + return count; +} + +size_t mpack_expect_key_uint(mpack_reader_t* reader, bool found[], size_t count) { + if (mpack_reader_error(reader) != mpack_ok) + return count; + + if (count == 0) { + mpack_break("count cannot be zero; no keys are valid!"); + mpack_reader_flag_error(reader, mpack_error_bug); + return count; + } + mpack_assert(found != NULL, "found cannot be NULL"); + + // the key is only recognized if it is an unsigned int + if (mpack_peek_tag(reader).type != mpack_type_uint) { + mpack_discard(reader); + return count; + } + + // read the key + uint64_t value = mpack_expect_u64(reader); + if (mpack_reader_error(reader) != mpack_ok) + return count; + + // unrecognized keys are fine, we just return count + if (value >= count) + return count; + + // check if this key is a duplicate + if (found[value]) { + mpack_reader_flag_error(reader, mpack_error_invalid); + return count; + } + + found[value] = true; + return (size_t)value; +} + +size_t mpack_expect_key_cstr(mpack_reader_t* reader, const char* keys[], bool found[], size_t count) { + size_t i = mpack_expect_enum_optional(reader, keys, count); + + // unrecognized keys are fine, we just return count + if (i == count) + return count; + + // check if this key is a duplicate + mpack_assert(found != NULL, "found cannot be NULL"); + if (found[i]) { + mpack_reader_flag_error(reader, mpack_error_invalid); + return count; + } + + found[i] = true; + return i; +} + +#endif + +MPACK_SILENCE_WARNINGS_END + +/* mpack/mpack-node.c.c */ + +#define MPACK_INTERNAL 1 + +/* #include "mpack-node.h" */ + +MPACK_SILENCE_WARNINGS_BEGIN + +#if MPACK_NODE + +MPACK_STATIC_INLINE const char* mpack_node_data_unchecked(mpack_node_t node) { + mpack_assert(mpack_node_error(node) == mpack_ok, "tree is in an error state!"); + + mpack_type_t type = node.data->type; + MPACK_UNUSED(type); + #if MPACK_EXTENSIONS + mpack_assert(type == mpack_type_str || type == mpack_type_bin || type == mpack_type_ext, + "node of type %i (%s) is not a data type!", type, mpack_type_to_string(type)); + #else + mpack_assert(type == mpack_type_str || type == mpack_type_bin, + "node of type %i (%s) is not a data type!", type, mpack_type_to_string(type)); + #endif + + return node.tree->data + node.data->value.offset; +} + +#if MPACK_EXTENSIONS +MPACK_STATIC_INLINE int8_t mpack_node_exttype_unchecked(mpack_node_t node) { + mpack_assert(mpack_node_error(node) == mpack_ok, "tree is in an error state!"); + + mpack_type_t type = node.data->type; + MPACK_UNUSED(type); + mpack_assert(type == mpack_type_ext, "node of type %i (%s) is not an ext type!", + type, mpack_type_to_string(type)); + + // the exttype of an ext node is stored in the byte preceding the data + return mpack_load_i8(mpack_node_data_unchecked(node) - 1); +} +#endif + + + +/* + * Tree Parsing + */ + +#ifdef MPACK_MALLOC + +// fix up the alloc size to make sure it exactly fits the +// maximum number of nodes it can contain (the allocator will +// waste it back anyway, but we round it down just in case) + +#define MPACK_NODES_PER_PAGE \ + ((MPACK_NODE_PAGE_SIZE - sizeof(mpack_tree_page_t)) / sizeof(mpack_node_data_t) + 1) + +#define MPACK_PAGE_ALLOC_SIZE \ + (sizeof(mpack_tree_page_t) + sizeof(mpack_node_data_t) * (MPACK_NODES_PER_PAGE - 1)) + +#endif + +#ifdef MPACK_MALLOC +/* + * Fills the tree until we have at least enough bytes for the current node. + */ +static bool mpack_tree_reserve_fill(mpack_tree_t* tree) { + mpack_assert(tree->parser.state == mpack_tree_parse_state_in_progress); + + size_t bytes = tree->parser.current_node_reserved; + mpack_assert(bytes > tree->parser.possible_nodes_left, + "there are already enough bytes! call mpack_tree_ensure() instead."); + mpack_log("filling to reserve %i bytes\n", (int)bytes); + + // if the necessary bytes would put us over the maximum tree + // size, fail right away. + // TODO: check for overflow? + if (tree->data_length + bytes > tree->max_size) { + mpack_tree_flag_error(tree, mpack_error_too_big); + return false; + } + + // we'll need a read function to fetch more data. if there's + // no read function, the data should contain an entire message + // (or messages), so we flag it as invalid. + if (tree->read_fn == NULL) { + mpack_log("tree has no read function!\n"); + mpack_tree_flag_error(tree, mpack_error_invalid); + return false; + } + + // expand the buffer if needed + if (tree->data_length + bytes > tree->buffer_capacity) { + + // TODO: check for overflow? + size_t new_capacity = (tree->buffer_capacity == 0) ? MPACK_BUFFER_SIZE : tree->buffer_capacity; + while (new_capacity < tree->data_length + bytes) + new_capacity *= 2; + if (new_capacity > tree->max_size) + new_capacity = tree->max_size; + + mpack_log("expanding buffer from %i to %i\n", (int)tree->buffer_capacity, (int)new_capacity); + + char* new_buffer; + if (tree->buffer == NULL) + new_buffer = (char*)MPACK_MALLOC(new_capacity); + else + new_buffer = (char*)mpack_realloc(tree->buffer, tree->data_length, new_capacity); + + if (new_buffer == NULL) { + mpack_tree_flag_error(tree, mpack_error_memory); + return false; + } + + tree->data = new_buffer; + tree->buffer = new_buffer; + tree->buffer_capacity = new_capacity; + } + + // request as much data as possible, looping until we have + // all the data we need + do { + size_t read = tree->read_fn(tree, tree->buffer + tree->data_length, tree->buffer_capacity - tree->data_length); + + // If the fill function encounters an error, it should flag an error on + // the tree. + if (mpack_tree_error(tree) != mpack_ok) + return false; + + // We guard against fill functions that return -1 just in case. + if (read == (size_t)(-1)) { + mpack_tree_flag_error(tree, mpack_error_io); + return false; + } + + // If the fill function returns 0, the data is not available yet. We + // return false to stop parsing the current node. + if (read == 0) { + mpack_log("not enough data.\n"); + return false; + } + + mpack_log("read %" PRIu32 " more bytes\n", (uint32_t)read); + tree->data_length += read; + tree->parser.possible_nodes_left += read; + } while (tree->parser.possible_nodes_left < bytes); + + return true; +} +#endif + +/* + * Ensures there are enough additional bytes in the tree for the current node + * (including reserved bytes for the children of this node, and in addition to + * the reserved bytes for children of previous compound nodes), reading more + * data if needed. + * + * extra_bytes is the number of additional bytes to reserve for the current + * node beyond the type byte (since one byte is already reserved for each node + * by its parent array or map.) + * + * This may reallocate the tree, which means the tree->data pointer may change! + * + * Returns false if not enough bytes could be read. + */ +MPACK_STATIC_INLINE bool mpack_tree_reserve_bytes(mpack_tree_t* tree, size_t extra_bytes) { + mpack_assert(tree->parser.state == mpack_tree_parse_state_in_progress); + + // We guard against overflow here. A compound type could declare more than + // MPACK_UINT32_MAX contents which overflows SIZE_MAX on 32-bit platforms. We + // flag mpack_error_invalid instead of mpack_error_too_big since it's far + // more likely that the message is corrupt than that the data is valid but + // not parseable on this architecture (see test_read_node_possible() in + // test-node.c .) + if ((uint64_t)tree->parser.current_node_reserved + (uint64_t)extra_bytes > SIZE_MAX) { + mpack_tree_flag_error(tree, mpack_error_invalid); + return false; + } + + tree->parser.current_node_reserved += extra_bytes; + + // Note that possible_nodes_left already accounts for reserved bytes for + // children of previous compound nodes. So even if there are hundreds of + // bytes left in the buffer, we might need to read anyway. + if (tree->parser.current_node_reserved <= tree->parser.possible_nodes_left) + return true; + + #ifdef MPACK_MALLOC + return mpack_tree_reserve_fill(tree); + #else + return false; + #endif +} + +MPACK_STATIC_INLINE size_t mpack_tree_parser_stack_capacity(mpack_tree_t* tree) { + #ifdef MPACK_MALLOC + return tree->parser.stack_capacity; + #else + return sizeof(tree->parser.stack) / sizeof(tree->parser.stack[0]); + #endif +} + +static bool mpack_tree_push_stack(mpack_tree_t* tree, mpack_node_data_t* first_child, size_t total) { + mpack_tree_parser_t* parser = &tree->parser; + mpack_assert(parser->state == mpack_tree_parse_state_in_progress); + + // No need to push empty containers + if (total == 0) + return true; + + // Make sure we have enough room in the stack + if (parser->level + 1 == mpack_tree_parser_stack_capacity(tree)) { + #ifdef MPACK_MALLOC + size_t new_capacity = parser->stack_capacity * 2; + mpack_log("growing parse stack to capacity %i\n", (int)new_capacity); + + // Replace the stack-allocated parsing stack + if (!parser->stack_owned) { + mpack_level_t* new_stack = (mpack_level_t*)MPACK_MALLOC(sizeof(mpack_level_t) * new_capacity); + if (!new_stack) { + mpack_tree_flag_error(tree, mpack_error_memory); + return false; + } + mpack_memcpy(new_stack, parser->stack, sizeof(mpack_level_t) * parser->stack_capacity); + parser->stack = new_stack; + parser->stack_owned = true; + + // Realloc the allocated parsing stack + } else { + mpack_level_t* new_stack = (mpack_level_t*)mpack_realloc(parser->stack, + sizeof(mpack_level_t) * parser->stack_capacity, sizeof(mpack_level_t) * new_capacity); + if (!new_stack) { + mpack_tree_flag_error(tree, mpack_error_memory); + return false; + } + parser->stack = new_stack; + } + parser->stack_capacity = new_capacity; + #else + mpack_tree_flag_error(tree, mpack_error_too_big); + return false; + #endif + } + + // Push the contents of this node onto the parsing stack + ++parser->level; + parser->stack[parser->level].child = first_child; + parser->stack[parser->level].left = total; + return true; +} + +static bool mpack_tree_parse_children(mpack_tree_t* tree, mpack_node_data_t* node) { + mpack_tree_parser_t* parser = &tree->parser; + mpack_assert(parser->state == mpack_tree_parse_state_in_progress); + + mpack_type_t type = node->type; + size_t total = node->len; + + // Calculate total elements to read + if (type == mpack_type_map) { + if ((uint64_t)total * 2 > SIZE_MAX) { + mpack_tree_flag_error(tree, mpack_error_too_big); + return false; + } + total *= 2; + } + + // Make sure we are under our total node limit (TODO can this overflow?) + tree->node_count += total; + if (tree->node_count > tree->max_nodes) { + mpack_tree_flag_error(tree, mpack_error_too_big); + return false; + } + + // Each node is at least one byte. Count these bytes now to make + // sure there is enough data left. + if (!mpack_tree_reserve_bytes(tree, total)) + return false; + + // If there are enough nodes left in the current page, no need to grow + if (total <= parser->nodes_left) { + node->value.children = parser->nodes; + parser->nodes += total; + parser->nodes_left -= total; + + } else { + + #ifdef MPACK_MALLOC + + // We can't grow if we're using a fixed pool (i.e. we didn't start with a page) + if (!tree->next) { + mpack_tree_flag_error(tree, mpack_error_too_big); + return false; + } + + // Otherwise we need to grow, and the node's children need to be contiguous. + // This is a heuristic to decide whether we should waste the remaining space + // in the current page and start a new one, or give the children their + // own page. With a fraction of 1/8, this causes at most 12% additional + // waste. Note that reducing this too much causes less cache coherence and + // more malloc() overhead due to smaller allocations, so there's a tradeoff + // here. This heuristic could use some improvement, especially with custom + // page sizes. + + mpack_tree_page_t* page; + + if (total > MPACK_NODES_PER_PAGE || parser->nodes_left > MPACK_NODES_PER_PAGE / 8) { + // TODO: this should check for overflow + page = (mpack_tree_page_t*)MPACK_MALLOC( + sizeof(mpack_tree_page_t) + sizeof(mpack_node_data_t) * (total - 1)); + if (page == NULL) { + mpack_tree_flag_error(tree, mpack_error_memory); + return false; + } + mpack_log("allocated seperate page %p for %i children, %i left in page of %i total\n", + (void*)page, (int)total, (int)parser->nodes_left, (int)MPACK_NODES_PER_PAGE); + + node->value.children = page->nodes; + + } else { + page = (mpack_tree_page_t*)MPACK_MALLOC(MPACK_PAGE_ALLOC_SIZE); + if (page == NULL) { + mpack_tree_flag_error(tree, mpack_error_memory); + return false; + } + mpack_log("allocated new page %p for %i children, wasting %i in page of %i total\n", + (void*)page, (int)total, (int)parser->nodes_left, (int)MPACK_NODES_PER_PAGE); + + node->value.children = page->nodes; + parser->nodes = page->nodes + total; + parser->nodes_left = MPACK_NODES_PER_PAGE - total; + } + + page->next = tree->next; + tree->next = page; + + #else + // We can't grow if we don't have an allocator + mpack_tree_flag_error(tree, mpack_error_too_big); + return false; + #endif + } + + return mpack_tree_push_stack(tree, node->value.children, total); +} + +static bool mpack_tree_parse_bytes(mpack_tree_t* tree, mpack_node_data_t* node) { + node->value.offset = tree->size + tree->parser.current_node_reserved + 1; + return mpack_tree_reserve_bytes(tree, node->len); +} + +#if MPACK_EXTENSIONS +static bool mpack_tree_parse_ext(mpack_tree_t* tree, mpack_node_data_t* node) { + // reserve space for exttype + tree->parser.current_node_reserved += sizeof(int8_t); + node->type = mpack_type_ext; + return mpack_tree_parse_bytes(tree, node); +} +#endif + +static bool mpack_tree_parse_node_contents(mpack_tree_t* tree, mpack_node_data_t* node) { + mpack_assert(tree->parser.state == mpack_tree_parse_state_in_progress); + mpack_assert(node != NULL, "null node?"); + + // read the type. we've already accounted for this byte in + // possible_nodes_left, so we already know it is in bounds, and we don't + // need to reserve it for this node. + mpack_assert(tree->data_length > tree->size); + uint8_t type = mpack_load_u8(tree->data + tree->size); + mpack_log("node type %x\n", type); + tree->parser.current_node_reserved = 0; + + // as with mpack_read_tag(), the fastest way to parse a node is to switch + // on the first byte, and to explicitly list every possible byte. we switch + // on the first four bits in size-optimized builds. + + #if MPACK_OPTIMIZE_FOR_SIZE + switch (type >> 4) { + + // positive fixnum + case 0x0: case 0x1: case 0x2: case 0x3: + case 0x4: case 0x5: case 0x6: case 0x7: + node->type = mpack_type_uint; + node->value.u = type; + return true; + + // negative fixnum + case 0xe: case 0xf: + node->type = mpack_type_int; + node->value.i = (int8_t)type; + return true; + + // fixmap + case 0x8: + node->type = mpack_type_map; + node->len = (uint32_t)(type & ~0xf0); + return mpack_tree_parse_children(tree, node); + + // fixarray + case 0x9: + node->type = mpack_type_array; + node->len = (uint32_t)(type & ~0xf0); + return mpack_tree_parse_children(tree, node); + + // fixstr + case 0xa: case 0xb: + node->type = mpack_type_str; + node->len = (uint32_t)(type & ~0xe0); + return mpack_tree_parse_bytes(tree, node); + + // not one of the common infix types + default: + break; + } + #endif + + switch (type) { + + #if !MPACK_OPTIMIZE_FOR_SIZE + // positive fixnum + case 0x00: case 0x01: case 0x02: case 0x03: case 0x04: case 0x05: case 0x06: case 0x07: + case 0x08: case 0x09: case 0x0a: case 0x0b: case 0x0c: case 0x0d: case 0x0e: case 0x0f: + case 0x10: case 0x11: case 0x12: case 0x13: case 0x14: case 0x15: case 0x16: case 0x17: + case 0x18: case 0x19: case 0x1a: case 0x1b: case 0x1c: case 0x1d: case 0x1e: case 0x1f: + case 0x20: case 0x21: case 0x22: case 0x23: case 0x24: case 0x25: case 0x26: case 0x27: + case 0x28: case 0x29: case 0x2a: case 0x2b: case 0x2c: case 0x2d: case 0x2e: case 0x2f: + case 0x30: case 0x31: case 0x32: case 0x33: case 0x34: case 0x35: case 0x36: case 0x37: + case 0x38: case 0x39: case 0x3a: case 0x3b: case 0x3c: case 0x3d: case 0x3e: case 0x3f: + case 0x40: case 0x41: case 0x42: case 0x43: case 0x44: case 0x45: case 0x46: case 0x47: + case 0x48: case 0x49: case 0x4a: case 0x4b: case 0x4c: case 0x4d: case 0x4e: case 0x4f: + case 0x50: case 0x51: case 0x52: case 0x53: case 0x54: case 0x55: case 0x56: case 0x57: + case 0x58: case 0x59: case 0x5a: case 0x5b: case 0x5c: case 0x5d: case 0x5e: case 0x5f: + case 0x60: case 0x61: case 0x62: case 0x63: case 0x64: case 0x65: case 0x66: case 0x67: + case 0x68: case 0x69: case 0x6a: case 0x6b: case 0x6c: case 0x6d: case 0x6e: case 0x6f: + case 0x70: case 0x71: case 0x72: case 0x73: case 0x74: case 0x75: case 0x76: case 0x77: + case 0x78: case 0x79: case 0x7a: case 0x7b: case 0x7c: case 0x7d: case 0x7e: case 0x7f: + node->type = mpack_type_uint; + node->value.u = type; + return true; + + // negative fixnum + case 0xe0: case 0xe1: case 0xe2: case 0xe3: case 0xe4: case 0xe5: case 0xe6: case 0xe7: + case 0xe8: case 0xe9: case 0xea: case 0xeb: case 0xec: case 0xed: case 0xee: case 0xef: + case 0xf0: case 0xf1: case 0xf2: case 0xf3: case 0xf4: case 0xf5: case 0xf6: case 0xf7: + case 0xf8: case 0xf9: case 0xfa: case 0xfb: case 0xfc: case 0xfd: case 0xfe: case 0xff: + node->type = mpack_type_int; + node->value.i = (int8_t)type; + return true; + + // fixmap + case 0x80: case 0x81: case 0x82: case 0x83: case 0x84: case 0x85: case 0x86: case 0x87: + case 0x88: case 0x89: case 0x8a: case 0x8b: case 0x8c: case 0x8d: case 0x8e: case 0x8f: + node->type = mpack_type_map; + node->len = (uint32_t)(type & ~0xf0); + return mpack_tree_parse_children(tree, node); + + // fixarray + case 0x90: case 0x91: case 0x92: case 0x93: case 0x94: case 0x95: case 0x96: case 0x97: + case 0x98: case 0x99: case 0x9a: case 0x9b: case 0x9c: case 0x9d: case 0x9e: case 0x9f: + node->type = mpack_type_array; + node->len = (uint32_t)(type & ~0xf0); + return mpack_tree_parse_children(tree, node); + + // fixstr + case 0xa0: case 0xa1: case 0xa2: case 0xa3: case 0xa4: case 0xa5: case 0xa6: case 0xa7: + case 0xa8: case 0xa9: case 0xaa: case 0xab: case 0xac: case 0xad: case 0xae: case 0xaf: + case 0xb0: case 0xb1: case 0xb2: case 0xb3: case 0xb4: case 0xb5: case 0xb6: case 0xb7: + case 0xb8: case 0xb9: case 0xba: case 0xbb: case 0xbc: case 0xbd: case 0xbe: case 0xbf: + node->type = mpack_type_str; + node->len = (uint32_t)(type & ~0xe0); + return mpack_tree_parse_bytes(tree, node); + #endif + + // nil + case 0xc0: + node->type = mpack_type_nil; + return true; + + // bool + case 0xc2: case 0xc3: + node->type = mpack_type_bool; + node->value.b = type & 1; + return true; + + // bin8 + case 0xc4: + node->type = mpack_type_bin; + if (!mpack_tree_reserve_bytes(tree, sizeof(uint8_t))) + return false; + node->len = mpack_load_u8(tree->data + tree->size + 1); + return mpack_tree_parse_bytes(tree, node); + + // bin16 + case 0xc5: + node->type = mpack_type_bin; + if (!mpack_tree_reserve_bytes(tree, sizeof(uint16_t))) + return false; + node->len = mpack_load_u16(tree->data + tree->size + 1); + return mpack_tree_parse_bytes(tree, node); + + // bin32 + case 0xc6: + node->type = mpack_type_bin; + if (!mpack_tree_reserve_bytes(tree, sizeof(uint32_t))) + return false; + node->len = mpack_load_u32(tree->data + tree->size + 1); + return mpack_tree_parse_bytes(tree, node); + + #if MPACK_EXTENSIONS + // ext8 + case 0xc7: + if (!mpack_tree_reserve_bytes(tree, sizeof(uint8_t))) + return false; + node->len = mpack_load_u8(tree->data + tree->size + 1); + return mpack_tree_parse_ext(tree, node); + + // ext16 + case 0xc8: + if (!mpack_tree_reserve_bytes(tree, sizeof(uint16_t))) + return false; + node->len = mpack_load_u16(tree->data + tree->size + 1); + return mpack_tree_parse_ext(tree, node); + + // ext32 + case 0xc9: + if (!mpack_tree_reserve_bytes(tree, sizeof(uint32_t))) + return false; + node->len = mpack_load_u32(tree->data + tree->size + 1); + return mpack_tree_parse_ext(tree, node); + #endif + + // float + case 0xca: + #if MPACK_FLOAT + if (!mpack_tree_reserve_bytes(tree, sizeof(float))) + return false; + node->value.f = mpack_load_float(tree->data + tree->size + 1); + #else + if (!mpack_tree_reserve_bytes(tree, sizeof(uint32_t))) + return false; + node->value.f = mpack_load_u32(tree->data + tree->size + 1); + #endif + node->type = mpack_type_float; + return true; + + // double + case 0xcb: + #if MPACK_DOUBLE + if (!mpack_tree_reserve_bytes(tree, sizeof(double))) + return false; + node->value.d = mpack_load_double(tree->data + tree->size + 1); + #else + if (!mpack_tree_reserve_bytes(tree, sizeof(uint64_t))) + return false; + node->value.d = mpack_load_u64(tree->data + tree->size + 1); + #endif + node->type = mpack_type_double; + return true; + + // uint8 + case 0xcc: + node->type = mpack_type_uint; + if (!mpack_tree_reserve_bytes(tree, sizeof(uint8_t))) + return false; + node->value.u = mpack_load_u8(tree->data + tree->size + 1); + return true; + + // uint16 + case 0xcd: + node->type = mpack_type_uint; + if (!mpack_tree_reserve_bytes(tree, sizeof(uint16_t))) + return false; + node->value.u = mpack_load_u16(tree->data + tree->size + 1); + return true; + + // uint32 + case 0xce: + node->type = mpack_type_uint; + if (!mpack_tree_reserve_bytes(tree, sizeof(uint32_t))) + return false; + node->value.u = mpack_load_u32(tree->data + tree->size + 1); + return true; + + // uint64 + case 0xcf: + node->type = mpack_type_uint; + if (!mpack_tree_reserve_bytes(tree, sizeof(uint64_t))) + return false; + node->value.u = mpack_load_u64(tree->data + tree->size + 1); + return true; + + // int8 + case 0xd0: + node->type = mpack_type_int; + if (!mpack_tree_reserve_bytes(tree, sizeof(int8_t))) + return false; + node->value.i = mpack_load_i8(tree->data + tree->size + 1); + return true; + + // int16 + case 0xd1: + node->type = mpack_type_int; + if (!mpack_tree_reserve_bytes(tree, sizeof(int16_t))) + return false; + node->value.i = mpack_load_i16(tree->data + tree->size + 1); + return true; + + // int32 + case 0xd2: + node->type = mpack_type_int; + if (!mpack_tree_reserve_bytes(tree, sizeof(int32_t))) + return false; + node->value.i = mpack_load_i32(tree->data + tree->size + 1); + return true; + + // int64 + case 0xd3: + node->type = mpack_type_int; + if (!mpack_tree_reserve_bytes(tree, sizeof(int64_t))) + return false; + node->value.i = mpack_load_i64(tree->data + tree->size + 1); + return true; + + #if MPACK_EXTENSIONS + // fixext1 + case 0xd4: + node->len = 1; + return mpack_tree_parse_ext(tree, node); + + // fixext2 + case 0xd5: + node->len = 2; + return mpack_tree_parse_ext(tree, node); + + // fixext4 + case 0xd6: + node->len = 4; + return mpack_tree_parse_ext(tree, node); + + // fixext8 + case 0xd7: + node->len = 8; + return mpack_tree_parse_ext(tree, node); + + // fixext16 + case 0xd8: + node->len = 16; + return mpack_tree_parse_ext(tree, node); + #endif + + // str8 + case 0xd9: + if (!mpack_tree_reserve_bytes(tree, sizeof(uint8_t))) + return false; + node->len = mpack_load_u8(tree->data + tree->size + 1); + node->type = mpack_type_str; + return mpack_tree_parse_bytes(tree, node); + + // str16 + case 0xda: + if (!mpack_tree_reserve_bytes(tree, sizeof(uint16_t))) + return false; + node->len = mpack_load_u16(tree->data + tree->size + 1); + node->type = mpack_type_str; + return mpack_tree_parse_bytes(tree, node); + + // str32 + case 0xdb: + if (!mpack_tree_reserve_bytes(tree, sizeof(uint32_t))) + return false; + node->len = mpack_load_u32(tree->data + tree->size + 1); + node->type = mpack_type_str; + return mpack_tree_parse_bytes(tree, node); + + // array16 + case 0xdc: + if (!mpack_tree_reserve_bytes(tree, sizeof(uint16_t))) + return false; + node->len = mpack_load_u16(tree->data + tree->size + 1); + node->type = mpack_type_array; + return mpack_tree_parse_children(tree, node); + + // array32 + case 0xdd: + if (!mpack_tree_reserve_bytes(tree, sizeof(uint32_t))) + return false; + node->len = mpack_load_u32(tree->data + tree->size + 1); + node->type = mpack_type_array; + return mpack_tree_parse_children(tree, node); + + // map16 + case 0xde: + if (!mpack_tree_reserve_bytes(tree, sizeof(uint16_t))) + return false; + node->len = mpack_load_u16(tree->data + tree->size + 1); + node->type = mpack_type_map; + return mpack_tree_parse_children(tree, node); + + // map32 + case 0xdf: + if (!mpack_tree_reserve_bytes(tree, sizeof(uint32_t))) + return false; + node->len = mpack_load_u32(tree->data + tree->size + 1); + node->type = mpack_type_map; + return mpack_tree_parse_children(tree, node); + + // reserved + case 0xc1: + mpack_tree_flag_error(tree, mpack_error_invalid); + return false; + + #if !MPACK_EXTENSIONS + // ext + case 0xc7: // fallthrough + case 0xc8: // fallthrough + case 0xc9: // fallthrough + // fixext + case 0xd4: // fallthrough + case 0xd5: // fallthrough + case 0xd6: // fallthrough + case 0xd7: // fallthrough + case 0xd8: + mpack_tree_flag_error(tree, mpack_error_unsupported); + return false; + #endif + + #if MPACK_OPTIMIZE_FOR_SIZE + // any other bytes should have been handled by the infix switch + default: + break; + #endif + } + + mpack_assert(0, "unreachable"); + return false; +} + +static bool mpack_tree_parse_node(mpack_tree_t* tree, mpack_node_data_t* node) { + mpack_log("parsing a node at position %i in level %i\n", + (int)tree->size, (int)tree->parser.level); + + if (!mpack_tree_parse_node_contents(tree, node)) { + mpack_log("node parsing returned false\n"); + return false; + } + + tree->parser.possible_nodes_left -= tree->parser.current_node_reserved; + + // The reserve for the current node does not include the initial byte + // previously reserved as part of its parent. + size_t node_size = tree->parser.current_node_reserved + 1; + + // If the parsed type is a map or array, the reserve includes one byte for + // each child. We want to subtract these out of possible_nodes_left, but + // not out of the current size of the tree. + if (node->type == mpack_type_array) + node_size -= node->len; + else if (node->type == mpack_type_map) + node_size -= node->len * 2; + tree->size += node_size; + + mpack_log("parsed a node of type %s of %i bytes and " + "%i additional bytes reserved for children.\n", + mpack_type_to_string(node->type), (int)node_size, + (int)tree->parser.current_node_reserved + 1 - (int)node_size); + + return true; +} + +/* + * We read nodes in a loop instead of recursively for maximum performance. The + * stack holds the amount of children left to read in each level of the tree. + * Parsing can pause and resume when more data becomes available. + */ +static bool mpack_tree_continue_parsing(mpack_tree_t* tree) { + if (mpack_tree_error(tree) != mpack_ok) + return false; + + mpack_tree_parser_t* parser = &tree->parser; + mpack_assert(parser->state == mpack_tree_parse_state_in_progress); + mpack_log("parsing tree elements, %i bytes in buffer\n", (int)tree->data_length); + + // we loop parsing nodes until the parse stack is empty. we break + // by returning out of the function. + while (true) { + mpack_node_data_t* node = parser->stack[parser->level].child; + size_t level = parser->level; + if (!mpack_tree_parse_node(tree, node)) + return false; + --parser->stack[level].left; + ++parser->stack[level].child; + + mpack_assert(mpack_tree_error(tree) == mpack_ok, + "mpack_tree_parse_node() should have returned false due to error!"); + + // pop empty stack levels, exiting the outer loop when the stack is empty. + // (we could tail-optimize containers by pre-emptively popping empty + // stack levels before reading the new element, this way we wouldn't + // have to loop. but we eventually want to use the parse stack to give + // better error messages that contain the location of the error, so + // it needs to be complete.) + while (parser->stack[parser->level].left == 0) { + if (parser->level == 0) + return true; + --parser->level; + } + } +} + +static void mpack_tree_cleanup(mpack_tree_t* tree) { + MPACK_UNUSED(tree); + + #ifdef MPACK_MALLOC + if (tree->parser.stack_owned) { + MPACK_FREE(tree->parser.stack); + tree->parser.stack = NULL; + tree->parser.stack_owned = false; + } + + mpack_tree_page_t* page = tree->next; + while (page != NULL) { + mpack_tree_page_t* next = page->next; + mpack_log("freeing page %p\n", (void*)page); + MPACK_FREE(page); + page = next; + } + tree->next = NULL; + #endif +} + +static bool mpack_tree_parse_start(mpack_tree_t* tree) { + if (mpack_tree_error(tree) != mpack_ok) + return false; + + mpack_tree_parser_t* parser = &tree->parser; + mpack_assert(parser->state != mpack_tree_parse_state_in_progress, + "previous parsing was not finished!"); + + if (parser->state == mpack_tree_parse_state_parsed) + mpack_tree_cleanup(tree); + + mpack_log("starting parse\n"); + tree->parser.state = mpack_tree_parse_state_in_progress; + tree->parser.current_node_reserved = 0; + + // check if we previously parsed a tree + if (tree->size > 0) { + #ifdef MPACK_MALLOC + // if we're buffered, move the remaining data back to the + // start of the buffer + // TODO: This is not ideal performance-wise. We should only move data + // when we need to call the fill function. + // TODO: We could consider shrinking the buffer here, especially if we + // determine that the fill function is providing less than a quarter of + // the buffer size or if messages take up less than a quarter of the + // buffer size. Maybe this should be configurable. + if (tree->buffer != NULL) { + mpack_memmove(tree->buffer, tree->buffer + tree->size, tree->data_length - tree->size); + } + else + #endif + // otherwise advance past the parsed data + { + tree->data += tree->size; + } + tree->data_length -= tree->size; + tree->size = 0; + tree->node_count = 0; + } + + // make sure we have at least one byte available before allocating anything + parser->possible_nodes_left = tree->data_length; + if (!mpack_tree_reserve_bytes(tree, sizeof(uint8_t))) { + tree->parser.state = mpack_tree_parse_state_not_started; + return false; + } + mpack_log("parsing tree at %p starting with byte %x\n", tree->data, (uint8_t)tree->data[0]); + parser->possible_nodes_left -= 1; + tree->node_count = 1; + + #ifdef MPACK_MALLOC + parser->stack = parser->stack_local; + parser->stack_owned = false; + parser->stack_capacity = sizeof(parser->stack_local) / sizeof(*parser->stack_local); + + if (tree->pool == NULL) { + + // allocate first page + mpack_tree_page_t* page = (mpack_tree_page_t*)MPACK_MALLOC(MPACK_PAGE_ALLOC_SIZE); + mpack_log("allocated initial page %p of size %i count %i\n", + (void*)page, (int)MPACK_PAGE_ALLOC_SIZE, (int)MPACK_NODES_PER_PAGE); + if (page == NULL) { + tree->error = mpack_error_memory; + return false; + } + page->next = NULL; + tree->next = page; + + parser->nodes = page->nodes; + parser->nodes_left = MPACK_NODES_PER_PAGE; + } + else + #endif + { + // otherwise use the provided pool + mpack_assert(tree->pool != NULL, "no pool provided?"); + parser->nodes = tree->pool; + parser->nodes_left = tree->pool_count; + } + + tree->root = parser->nodes; + ++parser->nodes; + --parser->nodes_left; + + parser->level = 0; + parser->stack[0].child = tree->root; + parser->stack[0].left = 1; + + return true; +} + +void mpack_tree_parse(mpack_tree_t* tree) { + if (mpack_tree_error(tree) != mpack_ok) + return; + + if (tree->parser.state != mpack_tree_parse_state_in_progress) { + if (!mpack_tree_parse_start(tree)) { + mpack_tree_flag_error(tree, (tree->read_fn == NULL) ? + mpack_error_invalid : mpack_error_io); + return; + } + } + + if (!mpack_tree_continue_parsing(tree)) { + if (mpack_tree_error(tree) != mpack_ok) + return; + + // We're parsing synchronously on a blocking fill function. If we + // didn't completely finish parsing the tree, it's an error. + mpack_log("tree parsing incomplete. flagging error.\n"); + mpack_tree_flag_error(tree, (tree->read_fn == NULL) ? + mpack_error_invalid : mpack_error_io); + return; + } + + mpack_assert(mpack_tree_error(tree) == mpack_ok); + mpack_assert(tree->parser.level == 0); + tree->parser.state = mpack_tree_parse_state_parsed; + mpack_log("parsed tree of %i bytes, %i bytes left\n", (int)tree->size, (int)tree->parser.possible_nodes_left); + mpack_log("%i nodes in final page\n", (int)tree->parser.nodes_left); +} + +bool mpack_tree_try_parse(mpack_tree_t* tree) { + if (mpack_tree_error(tree) != mpack_ok) + return false; + + if (tree->parser.state != mpack_tree_parse_state_in_progress) + if (!mpack_tree_parse_start(tree)) + return false; + + if (!mpack_tree_continue_parsing(tree)) + return false; + + mpack_assert(mpack_tree_error(tree) == mpack_ok); + mpack_assert(tree->parser.level == 0); + tree->parser.state = mpack_tree_parse_state_parsed; + return true; +} + + + +/* + * Tree functions + */ + +mpack_node_t mpack_tree_root(mpack_tree_t* tree) { + if (mpack_tree_error(tree) != mpack_ok) + return mpack_tree_nil_node(tree); + + // We check that a tree was parsed successfully and assert if not. You must + // call mpack_tree_parse() (or mpack_tree_try_parse() with a success + // result) in order to access the root node. + if (tree->parser.state != mpack_tree_parse_state_parsed) { + mpack_break("Tree has not been parsed! " + "Did you call mpack_tree_parse() or mpack_tree_try_parse()?"); + mpack_tree_flag_error(tree, mpack_error_bug); + return mpack_tree_nil_node(tree); + } + + return mpack_node(tree, tree->root); +} + +static void mpack_tree_init_clear(mpack_tree_t* tree) { + mpack_memset(tree, 0, sizeof(*tree)); + tree->nil_node.type = mpack_type_nil; + tree->missing_node.type = mpack_type_missing; + tree->max_size = SIZE_MAX; + tree->max_nodes = SIZE_MAX; +} + +#ifdef MPACK_MALLOC +void mpack_tree_init_data(mpack_tree_t* tree, const char* data, size_t length) { + mpack_tree_init_clear(tree); + + MPACK_STATIC_ASSERT(MPACK_NODE_PAGE_SIZE >= sizeof(mpack_tree_page_t), + "MPACK_NODE_PAGE_SIZE is too small"); + + MPACK_STATIC_ASSERT(MPACK_PAGE_ALLOC_SIZE <= MPACK_NODE_PAGE_SIZE, + "incorrect page rounding?"); + + tree->data = data; + tree->data_length = length; + tree->pool = NULL; + tree->pool_count = 0; + tree->next = NULL; + + mpack_log("===========================\n"); + mpack_log("initializing tree with data of size %i\n", (int)length); +} +#endif + +void mpack_tree_init_pool(mpack_tree_t* tree, const char* data, size_t length, + mpack_node_data_t* node_pool, size_t node_pool_count) +{ + mpack_tree_init_clear(tree); + #ifdef MPACK_MALLOC + tree->next = NULL; + #endif + + if (node_pool_count == 0) { + mpack_break("initial page has no nodes!"); + mpack_tree_flag_error(tree, mpack_error_bug); + return; + } + + tree->data = data; + tree->data_length = length; + tree->pool = node_pool; + tree->pool_count = node_pool_count; + + mpack_log("===========================\n"); + mpack_log("initializing tree with data of size %i and pool of count %i\n", + (int)length, (int)node_pool_count); +} + +void mpack_tree_init_error(mpack_tree_t* tree, mpack_error_t error) { + mpack_tree_init_clear(tree); + tree->error = error; + + mpack_log("===========================\n"); + mpack_log("initializing tree error state %i\n", (int)error); +} + +#ifdef MPACK_MALLOC +void mpack_tree_init_stream(mpack_tree_t* tree, mpack_tree_read_t read_fn, void* context, + size_t max_message_size, size_t max_message_nodes) { + mpack_tree_init_clear(tree); + + tree->read_fn = read_fn; + tree->context = context; + + mpack_tree_set_limits(tree, max_message_size, max_message_nodes); + tree->max_size = max_message_size; + tree->max_nodes = max_message_nodes; + + mpack_log("===========================\n"); + mpack_log("initializing tree with stream, max size %i max nodes %i\n", + (int)max_message_size, (int)max_message_nodes); +} +#endif + +void mpack_tree_set_limits(mpack_tree_t* tree, size_t max_message_size, size_t max_message_nodes) { + mpack_assert(max_message_size > 0); + mpack_assert(max_message_nodes > 0); + tree->max_size = max_message_size; + tree->max_nodes = max_message_nodes; +} + +#if MPACK_STDIO +typedef struct mpack_file_tree_t { + char* data; + size_t size; + char buffer[MPACK_BUFFER_SIZE]; +} mpack_file_tree_t; + +static void mpack_file_tree_teardown(mpack_tree_t* tree) { + mpack_file_tree_t* file_tree = (mpack_file_tree_t*)tree->context; + MPACK_FREE(file_tree->data); + MPACK_FREE(file_tree); +} + +static bool mpack_file_tree_read(mpack_tree_t* tree, mpack_file_tree_t* file_tree, FILE* file, size_t max_bytes) { + + // get the file size + errno = 0; + int error = 0; + fseek(file, 0, SEEK_END); + error |= errno; + long size = ftell(file); + error |= errno; + fseek(file, 0, SEEK_SET); + error |= errno; + + // check for errors + if (error != 0 || size < 0) { + mpack_tree_init_error(tree, mpack_error_io); + return false; + } + if (size == 0) { + mpack_tree_init_error(tree, mpack_error_invalid); + return false; + } + + // make sure the size is less than max_bytes + // (this mess exists to safely convert between long and size_t regardless of their widths) + if (max_bytes != 0 && (((uint64_t)LONG_MAX > (uint64_t)SIZE_MAX && size > (long)SIZE_MAX) || (size_t)size > max_bytes)) { + mpack_tree_init_error(tree, mpack_error_too_big); + return false; + } + + // allocate data + file_tree->data = (char*)MPACK_MALLOC((size_t)size); + if (file_tree->data == NULL) { + mpack_tree_init_error(tree, mpack_error_memory); + return false; + } + + // read the file + long total = 0; + while (total < size) { + size_t read = fread(file_tree->data + total, 1, (size_t)(size - total), file); + if (read <= 0) { + mpack_tree_init_error(tree, mpack_error_io); + MPACK_FREE(file_tree->data); + return false; + } + total += (long)read; + } + + file_tree->size = (size_t)size; + return true; +} + +static bool mpack_tree_file_check_max_bytes(mpack_tree_t* tree, size_t max_bytes) { + + // the C STDIO family of file functions use long (e.g. ftell) + if (max_bytes > LONG_MAX) { + mpack_break("max_bytes of %" PRIu64 " is invalid, maximum is LONG_MAX", (uint64_t)max_bytes); + mpack_tree_init_error(tree, mpack_error_bug); + return false; + } + + return true; +} + +static void mpack_tree_init_stdfile_noclose(mpack_tree_t* tree, FILE* stdfile, size_t max_bytes) { + + // allocate file tree + mpack_file_tree_t* file_tree = (mpack_file_tree_t*) MPACK_MALLOC(sizeof(mpack_file_tree_t)); + if (file_tree == NULL) { + mpack_tree_init_error(tree, mpack_error_memory); + return; + } + + // read all data + if (!mpack_file_tree_read(tree, file_tree, stdfile, max_bytes)) { + MPACK_FREE(file_tree); + return; + } + + mpack_tree_init_data(tree, file_tree->data, file_tree->size); + mpack_tree_set_context(tree, file_tree); + mpack_tree_set_teardown(tree, mpack_file_tree_teardown); +} + +void mpack_tree_init_stdfile(mpack_tree_t* tree, FILE* stdfile, size_t max_bytes, bool close_when_done) { + if (!mpack_tree_file_check_max_bytes(tree, max_bytes)) + return; + + mpack_tree_init_stdfile_noclose(tree, stdfile, max_bytes); + + if (close_when_done) + fclose(stdfile); +} + +void mpack_tree_init_filename(mpack_tree_t* tree, const char* filename, size_t max_bytes) { + if (!mpack_tree_file_check_max_bytes(tree, max_bytes)) + return; + + // open the file + FILE* file = fopen(filename, "rb"); + if (!file) { + mpack_tree_init_error(tree, mpack_error_io); + return; + } + + mpack_tree_init_stdfile(tree, file, max_bytes, true); +} +#endif + +mpack_error_t mpack_tree_destroy(mpack_tree_t* tree) { + mpack_tree_cleanup(tree); + + #ifdef MPACK_MALLOC + if (tree->buffer) + MPACK_FREE(tree->buffer); + #endif + + if (tree->teardown) + tree->teardown(tree); + tree->teardown = NULL; + + return tree->error; +} + +void mpack_tree_flag_error(mpack_tree_t* tree, mpack_error_t error) { + if (tree->error == mpack_ok) { + mpack_log("tree %p setting error %i: %s\n", (void*)tree, (int)error, mpack_error_to_string(error)); + tree->error = error; + if (tree->error_fn) + tree->error_fn(tree, error); + } + +} + + + +/* + * Node misc functions + */ + +void mpack_node_flag_error(mpack_node_t node, mpack_error_t error) { + mpack_tree_flag_error(node.tree, error); +} + +mpack_tag_t mpack_node_tag(mpack_node_t node) { + if (mpack_node_error(node) != mpack_ok) + return mpack_tag_nil(); + + mpack_tag_t tag = MPACK_TAG_ZERO; + + tag.type = node.data->type; + switch (node.data->type) { + case mpack_type_missing: + // If a node is missing, I don't know if it makes sense to ask for + // a tag for it. We'll return a missing tag to match the missing + // node I guess, but attempting to use the tag for anything (like + // writing it for example) will flag mpack_error_bug. + break; + case mpack_type_nil: break; + case mpack_type_bool: tag.v.b = node.data->value.b; break; + case mpack_type_float: tag.v.f = node.data->value.f; break; + case mpack_type_double: tag.v.d = node.data->value.d; break; + case mpack_type_int: tag.v.i = node.data->value.i; break; + case mpack_type_uint: tag.v.u = node.data->value.u; break; + + case mpack_type_str: tag.v.l = node.data->len; break; + case mpack_type_bin: tag.v.l = node.data->len; break; + + #if MPACK_EXTENSIONS + case mpack_type_ext: + tag.v.l = node.data->len; + tag.exttype = mpack_node_exttype_unchecked(node); + break; + #endif + + case mpack_type_array: tag.v.n = node.data->len; break; + case mpack_type_map: tag.v.n = node.data->len; break; + + default: + mpack_assert(0, "unrecognized type %i", (int)node.data->type); + break; + } + return tag; +} + +#if MPACK_DEBUG && MPACK_STDIO +static void mpack_node_print_element(mpack_node_t node, mpack_print_t* print, size_t depth) { + mpack_node_data_t* data = node.data; + size_t i,j; + switch (data->type) { + case mpack_type_str: + { + mpack_print_append_cstr(print, "\""); + const char* bytes = mpack_node_data_unchecked(node); + for (i = 0; i < data->len; ++i) { + char c = bytes[i]; + switch (c) { + case '\n': mpack_print_append_cstr(print, "\\n"); break; + case '\\': mpack_print_append_cstr(print, "\\\\"); break; + case '"': mpack_print_append_cstr(print, "\\\""); break; + default: mpack_print_append(print, &c, 1); break; + } + } + mpack_print_append_cstr(print, "\""); + } + break; + + case mpack_type_array: + mpack_print_append_cstr(print, "[\n"); + for (i = 0; i < data->len; ++i) { + for (j = 0; j < depth + 1; ++j) + mpack_print_append_cstr(print, " "); + mpack_node_print_element(mpack_node_array_at(node, i), print, depth + 1); + if (i != data->len - 1) + mpack_print_append_cstr(print, ","); + mpack_print_append_cstr(print, "\n"); + } + for (i = 0; i < depth; ++i) + mpack_print_append_cstr(print, " "); + mpack_print_append_cstr(print, "]"); + break; + + case mpack_type_map: + mpack_print_append_cstr(print, "{\n"); + for (i = 0; i < data->len; ++i) { + for (j = 0; j < depth + 1; ++j) + mpack_print_append_cstr(print, " "); + mpack_node_print_element(mpack_node_map_key_at(node, i), print, depth + 1); + mpack_print_append_cstr(print, ": "); + mpack_node_print_element(mpack_node_map_value_at(node, i), print, depth + 1); + if (i != data->len - 1) + mpack_print_append_cstr(print, ","); + mpack_print_append_cstr(print, "\n"); + } + for (i = 0; i < depth; ++i) + mpack_print_append_cstr(print, " "); + mpack_print_append_cstr(print, "}"); + break; + + default: + { + const char* prefix = NULL; + size_t prefix_length = 0; + if (mpack_node_type(node) == mpack_type_bin + #if MPACK_EXTENSIONS + || mpack_node_type(node) == mpack_type_ext + #endif + ) { + prefix = mpack_node_data(node); + prefix_length = mpack_node_data_len(node); + } + + char buf[256]; + mpack_tag_t tag = mpack_node_tag(node); + mpack_tag_debug_pseudo_json(tag, buf, sizeof(buf), prefix, prefix_length); + mpack_print_append_cstr(print, buf); + } + break; + } +} + +void mpack_node_print_to_buffer(mpack_node_t node, char* buffer, size_t buffer_size) { + if (buffer_size == 0) { + mpack_assert(false, "buffer size is zero!"); + return; + } + + mpack_print_t print; + mpack_memset(&print, 0, sizeof(print)); + print.buffer = buffer; + print.size = buffer_size; + mpack_node_print_element(node, &print, 0); + mpack_print_append(&print, "", 1); // null-terminator + mpack_print_flush(&print); + + // we always make sure there's a null-terminator at the end of the buffer + // in case we ran out of space. + print.buffer[print.size - 1] = '\0'; +} + +void mpack_node_print_to_callback(mpack_node_t node, mpack_print_callback_t callback, void* context) { + char buffer[1024]; + mpack_print_t print; + mpack_memset(&print, 0, sizeof(print)); + print.buffer = buffer; + print.size = sizeof(buffer); + print.callback = callback; + print.context = context; + mpack_node_print_element(node, &print, 0); + mpack_print_flush(&print); +} + +void mpack_node_print_to_file(mpack_node_t node, FILE* file) { + mpack_assert(file != NULL, "file is NULL"); + + char buffer[1024]; + mpack_print_t print; + mpack_memset(&print, 0, sizeof(print)); + print.buffer = buffer; + print.size = sizeof(buffer); + print.callback = &mpack_print_file_callback; + print.context = file; + + size_t depth = 2; + size_t i; + for (i = 0; i < depth; ++i) + mpack_print_append_cstr(&print, " "); + mpack_node_print_element(node, &print, depth); + mpack_print_append_cstr(&print, "\n"); + mpack_print_flush(&print); +} +#endif + + + +/* + * Node Value Functions + */ + +#if MPACK_EXTENSIONS +mpack_timestamp_t mpack_node_timestamp(mpack_node_t node) { + mpack_timestamp_t timestamp = {0, 0}; + + // we'll let mpack_node_exttype() do most checks + if (mpack_node_exttype(node) != MPACK_EXTTYPE_TIMESTAMP) { + mpack_log("exttype %i\n", mpack_node_exttype(node)); + mpack_node_flag_error(node, mpack_error_type); + return timestamp; + } + + const char* p = mpack_node_data_unchecked(node); + + switch (node.data->len) { + case 4: + timestamp.nanoseconds = 0; + timestamp.seconds = mpack_load_u32(p); + break; + + case 8: { + uint64_t value = mpack_load_u64(p); + timestamp.nanoseconds = (uint32_t)(value >> 34); + timestamp.seconds = value & ((MPACK_UINT64_C(1) << 34) - 1); + break; + } + + case 12: + timestamp.nanoseconds = mpack_load_u32(p); + timestamp.seconds = mpack_load_i64(p + 4); + break; + + default: + mpack_tree_flag_error(node.tree, mpack_error_invalid); + return timestamp; + } + + if (timestamp.nanoseconds > MPACK_TIMESTAMP_NANOSECONDS_MAX) { + mpack_tree_flag_error(node.tree, mpack_error_invalid); + mpack_timestamp_t zero = {0, 0}; + return zero; + } + + return timestamp; +} + +int64_t mpack_node_timestamp_seconds(mpack_node_t node) { + return mpack_node_timestamp(node).seconds; +} + +uint32_t mpack_node_timestamp_nanoseconds(mpack_node_t node) { + return mpack_node_timestamp(node).nanoseconds; +} +#endif + + + +/* + * Node Data Functions + */ + +void mpack_node_check_utf8(mpack_node_t node) { + if (mpack_node_error(node) != mpack_ok) + return; + mpack_node_data_t* data = node.data; + if (data->type != mpack_type_str || !mpack_utf8_check(mpack_node_data_unchecked(node), data->len)) + mpack_node_flag_error(node, mpack_error_type); +} + +void mpack_node_check_utf8_cstr(mpack_node_t node) { + if (mpack_node_error(node) != mpack_ok) + return; + mpack_node_data_t* data = node.data; + if (data->type != mpack_type_str || !mpack_utf8_check_no_null(mpack_node_data_unchecked(node), data->len)) + mpack_node_flag_error(node, mpack_error_type); +} + +size_t mpack_node_copy_data(mpack_node_t node, char* buffer, size_t bufsize) { + if (mpack_node_error(node) != mpack_ok) + return 0; + + mpack_assert(bufsize == 0 || buffer != NULL, "buffer is NULL for maximum of %i bytes", (int)bufsize); + + mpack_type_t type = node.data->type; + if (type != mpack_type_str && type != mpack_type_bin + #if MPACK_EXTENSIONS + && type != mpack_type_ext + #endif + ) { + mpack_node_flag_error(node, mpack_error_type); + return 0; + } + + if (node.data->len > bufsize) { + mpack_node_flag_error(node, mpack_error_too_big); + return 0; + } + + mpack_memcpy(buffer, mpack_node_data_unchecked(node), node.data->len); + return (size_t)node.data->len; +} + +size_t mpack_node_copy_utf8(mpack_node_t node, char* buffer, size_t bufsize) { + if (mpack_node_error(node) != mpack_ok) + return 0; + + mpack_assert(bufsize == 0 || buffer != NULL, "buffer is NULL for maximum of %i bytes", (int)bufsize); + + mpack_type_t type = node.data->type; + if (type != mpack_type_str) { + mpack_node_flag_error(node, mpack_error_type); + return 0; + } + + if (node.data->len > bufsize) { + mpack_node_flag_error(node, mpack_error_too_big); + return 0; + } + + if (!mpack_utf8_check(mpack_node_data_unchecked(node), node.data->len)) { + mpack_node_flag_error(node, mpack_error_type); + return 0; + } + + mpack_memcpy(buffer, mpack_node_data_unchecked(node), node.data->len); + return (size_t)node.data->len; +} + +void mpack_node_copy_cstr(mpack_node_t node, char* buffer, size_t bufsize) { + + // we can't break here because the error isn't recoverable; we + // have to add a null-terminator. + mpack_assert(buffer != NULL, "buffer is NULL"); + mpack_assert(bufsize >= 1, "buffer size is zero; you must have room for at least a null-terminator"); + + if (mpack_node_error(node) != mpack_ok) { + buffer[0] = '\0'; + return; + } + + if (node.data->type != mpack_type_str) { + buffer[0] = '\0'; + mpack_node_flag_error(node, mpack_error_type); + return; + } + + if (node.data->len > bufsize - 1) { + buffer[0] = '\0'; + mpack_node_flag_error(node, mpack_error_too_big); + return; + } + + if (!mpack_str_check_no_null(mpack_node_data_unchecked(node), node.data->len)) { + buffer[0] = '\0'; + mpack_node_flag_error(node, mpack_error_type); + return; + } + + mpack_memcpy(buffer, mpack_node_data_unchecked(node), node.data->len); + buffer[node.data->len] = '\0'; +} + +void mpack_node_copy_utf8_cstr(mpack_node_t node, char* buffer, size_t bufsize) { + + // we can't break here because the error isn't recoverable; we + // have to add a null-terminator. + mpack_assert(buffer != NULL, "buffer is NULL"); + mpack_assert(bufsize >= 1, "buffer size is zero; you must have room for at least a null-terminator"); + + if (mpack_node_error(node) != mpack_ok) { + buffer[0] = '\0'; + return; + } + + if (node.data->type != mpack_type_str) { + buffer[0] = '\0'; + mpack_node_flag_error(node, mpack_error_type); + return; + } + + if (node.data->len > bufsize - 1) { + buffer[0] = '\0'; + mpack_node_flag_error(node, mpack_error_too_big); + return; + } + + if (!mpack_utf8_check_no_null(mpack_node_data_unchecked(node), node.data->len)) { + buffer[0] = '\0'; + mpack_node_flag_error(node, mpack_error_type); + return; + } + + mpack_memcpy(buffer, mpack_node_data_unchecked(node), node.data->len); + buffer[node.data->len] = '\0'; +} + +#ifdef MPACK_MALLOC +char* mpack_node_data_alloc(mpack_node_t node, size_t maxlen) { + if (mpack_node_error(node) != mpack_ok) + return NULL; + + // make sure this is a valid data type + mpack_type_t type = node.data->type; + if (type != mpack_type_str && type != mpack_type_bin + #if MPACK_EXTENSIONS + && type != mpack_type_ext + #endif + ) { + mpack_node_flag_error(node, mpack_error_type); + return NULL; + } + + if (node.data->len > maxlen) { + mpack_node_flag_error(node, mpack_error_too_big); + return NULL; + } + + char* ret = (char*) MPACK_MALLOC((size_t)node.data->len); + if (ret == NULL) { + mpack_node_flag_error(node, mpack_error_memory); + return NULL; + } + + mpack_memcpy(ret, mpack_node_data_unchecked(node), node.data->len); + return ret; +} + +char* mpack_node_cstr_alloc(mpack_node_t node, size_t maxlen) { + if (mpack_node_error(node) != mpack_ok) + return NULL; + + // make sure maxlen makes sense + if (maxlen < 1) { + mpack_break("maxlen is zero; you must have room for at least a null-terminator"); + mpack_node_flag_error(node, mpack_error_bug); + return NULL; + } + + if (node.data->type != mpack_type_str) { + mpack_node_flag_error(node, mpack_error_type); + return NULL; + } + + if (node.data->len > maxlen - 1) { + mpack_node_flag_error(node, mpack_error_too_big); + return NULL; + } + + if (!mpack_str_check_no_null(mpack_node_data_unchecked(node), node.data->len)) { + mpack_node_flag_error(node, mpack_error_type); + return NULL; + } + + char* ret = (char*) MPACK_MALLOC((size_t)(node.data->len + 1)); + if (ret == NULL) { + mpack_node_flag_error(node, mpack_error_memory); + return NULL; + } + + mpack_memcpy(ret, mpack_node_data_unchecked(node), node.data->len); + ret[node.data->len] = '\0'; + return ret; +} + +char* mpack_node_utf8_cstr_alloc(mpack_node_t node, size_t maxlen) { + if (mpack_node_error(node) != mpack_ok) + return NULL; + + // make sure maxlen makes sense + if (maxlen < 1) { + mpack_break("maxlen is zero; you must have room for at least a null-terminator"); + mpack_node_flag_error(node, mpack_error_bug); + return NULL; + } + + if (node.data->type != mpack_type_str) { + mpack_node_flag_error(node, mpack_error_type); + return NULL; + } + + if (node.data->len > maxlen - 1) { + mpack_node_flag_error(node, mpack_error_too_big); + return NULL; + } + + if (!mpack_utf8_check_no_null(mpack_node_data_unchecked(node), node.data->len)) { + mpack_node_flag_error(node, mpack_error_type); + return NULL; + } + + char* ret = (char*) MPACK_MALLOC((size_t)(node.data->len + 1)); + if (ret == NULL) { + mpack_node_flag_error(node, mpack_error_memory); + return NULL; + } + + mpack_memcpy(ret, mpack_node_data_unchecked(node), node.data->len); + ret[node.data->len] = '\0'; + return ret; +} +#endif + + +/* + * Compound Node Functions + */ + +static mpack_node_data_t* mpack_node_map_int_impl(mpack_node_t node, int64_t num) { + if (mpack_node_error(node) != mpack_ok) + return NULL; + + if (node.data->type != mpack_type_map) { + mpack_node_flag_error(node, mpack_error_type); + return NULL; + } + + mpack_node_data_t* found = NULL; + + size_t i; + for (i = 0; i < node.data->len; ++i) { + mpack_node_data_t* key = mpack_node_child(node, i * 2); + + if ((key->type == mpack_type_int && key->value.i == num) || + (key->type == mpack_type_uint && num >= 0 && key->value.u == (uint64_t)num)) + { + if (found) { + mpack_node_flag_error(node, mpack_error_data); + return NULL; + } + found = mpack_node_child(node, i * 2 + 1); + } + } + + if (found) + return found; + + return NULL; +} + +static mpack_node_data_t* mpack_node_map_uint_impl(mpack_node_t node, uint64_t num) { + if (mpack_node_error(node) != mpack_ok) + return NULL; + + if (node.data->type != mpack_type_map) { + mpack_node_flag_error(node, mpack_error_type); + return NULL; + } + + mpack_node_data_t* found = NULL; + + size_t i; + for (i = 0; i < node.data->len; ++i) { + mpack_node_data_t* key = mpack_node_child(node, i * 2); + + if ((key->type == mpack_type_uint && key->value.u == num) || + (key->type == mpack_type_int && key->value.i >= 0 && (uint64_t)key->value.i == num)) + { + if (found) { + mpack_node_flag_error(node, mpack_error_data); + return NULL; + } + found = mpack_node_child(node, i * 2 + 1); + } + } + + if (found) + return found; + + return NULL; +} + +static mpack_node_data_t* mpack_node_map_str_impl(mpack_node_t node, const char* str, size_t length) { + if (mpack_node_error(node) != mpack_ok) + return NULL; + + mpack_assert(length == 0 || str != NULL, "str of length %i is NULL", (int)length); + + if (node.data->type != mpack_type_map) { + mpack_node_flag_error(node, mpack_error_type); + return NULL; + } + + mpack_tree_t* tree = node.tree; + mpack_node_data_t* found = NULL; + + size_t i; + for (i = 0; i < node.data->len; ++i) { + mpack_node_data_t* key = mpack_node_child(node, i * 2); + + if (key->type == mpack_type_str && key->len == length && + mpack_memcmp(str, mpack_node_data_unchecked(mpack_node(tree, key)), length) == 0) { + if (found) { + mpack_node_flag_error(node, mpack_error_data); + return NULL; + } + found = mpack_node_child(node, i * 2 + 1); + } + } + + if (found) + return found; + + return NULL; +} + +static mpack_node_t mpack_node_wrap_lookup(mpack_tree_t* tree, mpack_node_data_t* data) { + if (!data) { + if (tree->error == mpack_ok) + mpack_tree_flag_error(tree, mpack_error_data); + return mpack_tree_nil_node(tree); + } + return mpack_node(tree, data); +} + +static mpack_node_t mpack_node_wrap_lookup_optional(mpack_tree_t* tree, mpack_node_data_t* data) { + if (!data) { + if (tree->error == mpack_ok) + return mpack_tree_missing_node(tree); + return mpack_tree_nil_node(tree); + } + return mpack_node(tree, data); +} + +mpack_node_t mpack_node_map_int(mpack_node_t node, int64_t num) { + return mpack_node_wrap_lookup(node.tree, mpack_node_map_int_impl(node, num)); +} + +mpack_node_t mpack_node_map_int_optional(mpack_node_t node, int64_t num) { + return mpack_node_wrap_lookup_optional(node.tree, mpack_node_map_int_impl(node, num)); +} + +mpack_node_t mpack_node_map_uint(mpack_node_t node, uint64_t num) { + return mpack_node_wrap_lookup(node.tree, mpack_node_map_uint_impl(node, num)); +} + +mpack_node_t mpack_node_map_uint_optional(mpack_node_t node, uint64_t num) { + return mpack_node_wrap_lookup_optional(node.tree, mpack_node_map_uint_impl(node, num)); +} + +mpack_node_t mpack_node_map_str(mpack_node_t node, const char* str, size_t length) { + return mpack_node_wrap_lookup(node.tree, mpack_node_map_str_impl(node, str, length)); +} + +mpack_node_t mpack_node_map_str_optional(mpack_node_t node, const char* str, size_t length) { + return mpack_node_wrap_lookup_optional(node.tree, mpack_node_map_str_impl(node, str, length)); +} + +mpack_node_t mpack_node_map_cstr(mpack_node_t node, const char* cstr) { + mpack_assert(cstr != NULL, "cstr is NULL"); + return mpack_node_map_str(node, cstr, mpack_strlen(cstr)); +} + +mpack_node_t mpack_node_map_cstr_optional(mpack_node_t node, const char* cstr) { + mpack_assert(cstr != NULL, "cstr is NULL"); + return mpack_node_map_str_optional(node, cstr, mpack_strlen(cstr)); +} + +bool mpack_node_map_contains_int(mpack_node_t node, int64_t num) { + return mpack_node_map_int_impl(node, num) != NULL; +} + +bool mpack_node_map_contains_uint(mpack_node_t node, uint64_t num) { + return mpack_node_map_uint_impl(node, num) != NULL; +} + +bool mpack_node_map_contains_str(mpack_node_t node, const char* str, size_t length) { + return mpack_node_map_str_impl(node, str, length) != NULL; +} + +bool mpack_node_map_contains_cstr(mpack_node_t node, const char* cstr) { + mpack_assert(cstr != NULL, "cstr is NULL"); + return mpack_node_map_contains_str(node, cstr, mpack_strlen(cstr)); +} + +size_t mpack_node_enum_optional(mpack_node_t node, const char* strings[], size_t count) { + if (mpack_node_error(node) != mpack_ok) + return count; + + // the value is only recognized if it is a string + if (mpack_node_type(node) != mpack_type_str) + return count; + + // fetch the string + const char* key = mpack_node_str(node); + size_t keylen = mpack_node_strlen(node); + mpack_assert(mpack_node_error(node) == mpack_ok, "these should not fail"); + + // find what key it matches + size_t i; + for (i = 0; i < count; ++i) { + const char* other = strings[i]; + size_t otherlen = mpack_strlen(other); + if (keylen == otherlen && mpack_memcmp(key, other, keylen) == 0) + return i; + } + + // no matches + return count; +} + +size_t mpack_node_enum(mpack_node_t node, const char* strings[], size_t count) { + size_t value = mpack_node_enum_optional(node, strings, count); + if (value == count) + mpack_node_flag_error(node, mpack_error_type); + return value; +} + +mpack_type_t mpack_node_type(mpack_node_t node) { + if (mpack_node_error(node) != mpack_ok) + return mpack_type_nil; + return node.data->type; +} + +bool mpack_node_is_nil(mpack_node_t node) { + if (mpack_node_error(node) != mpack_ok) { + // All nodes are treated as nil nodes when we are in error. + return true; + } + return node.data->type == mpack_type_nil; +} + +bool mpack_node_is_missing(mpack_node_t node) { + if (mpack_node_error(node) != mpack_ok) { + // errors still return nil nodes, not missing nodes. + return false; + } + return node.data->type == mpack_type_missing; +} + +void mpack_node_nil(mpack_node_t node) { + if (mpack_node_error(node) != mpack_ok) + return; + if (node.data->type != mpack_type_nil) + mpack_node_flag_error(node, mpack_error_type); +} + +void mpack_node_missing(mpack_node_t node) { + if (mpack_node_error(node) != mpack_ok) + return; + if (node.data->type != mpack_type_missing) + mpack_node_flag_error(node, mpack_error_type); +} + +bool mpack_node_bool(mpack_node_t node) { + if (mpack_node_error(node) != mpack_ok) + return false; + + if (node.data->type == mpack_type_bool) + return node.data->value.b; + + mpack_node_flag_error(node, mpack_error_type); + return false; +} + +void mpack_node_true(mpack_node_t node) { + if (mpack_node_bool(node) != true) + mpack_node_flag_error(node, mpack_error_type); +} + +void mpack_node_false(mpack_node_t node) { + if (mpack_node_bool(node) != false) + mpack_node_flag_error(node, mpack_error_type); +} + +uint8_t mpack_node_u8(mpack_node_t node) { + if (mpack_node_error(node) != mpack_ok) + return 0; + + if (node.data->type == mpack_type_uint) { + if (node.data->value.u <= MPACK_UINT8_MAX) + return (uint8_t)node.data->value.u; + } else if (node.data->type == mpack_type_int) { + if (node.data->value.i >= 0 && node.data->value.i <= MPACK_UINT8_MAX) + return (uint8_t)node.data->value.i; + } + + mpack_node_flag_error(node, mpack_error_type); + return 0; +} + +int8_t mpack_node_i8(mpack_node_t node) { + if (mpack_node_error(node) != mpack_ok) + return 0; + + if (node.data->type == mpack_type_uint) { + if (node.data->value.u <= MPACK_INT8_MAX) + return (int8_t)node.data->value.u; + } else if (node.data->type == mpack_type_int) { + if (node.data->value.i >= MPACK_INT8_MIN && node.data->value.i <= MPACK_INT8_MAX) + return (int8_t)node.data->value.i; + } + + mpack_node_flag_error(node, mpack_error_type); + return 0; +} + +uint16_t mpack_node_u16(mpack_node_t node) { + if (mpack_node_error(node) != mpack_ok) + return 0; + + if (node.data->type == mpack_type_uint) { + if (node.data->value.u <= MPACK_UINT16_MAX) + return (uint16_t)node.data->value.u; + } else if (node.data->type == mpack_type_int) { + if (node.data->value.i >= 0 && node.data->value.i <= MPACK_UINT16_MAX) + return (uint16_t)node.data->value.i; + } + + mpack_node_flag_error(node, mpack_error_type); + return 0; +} + +int16_t mpack_node_i16(mpack_node_t node) { + if (mpack_node_error(node) != mpack_ok) + return 0; + + if (node.data->type == mpack_type_uint) { + if (node.data->value.u <= MPACK_INT16_MAX) + return (int16_t)node.data->value.u; + } else if (node.data->type == mpack_type_int) { + if (node.data->value.i >= MPACK_INT16_MIN && node.data->value.i <= MPACK_INT16_MAX) + return (int16_t)node.data->value.i; + } + + mpack_node_flag_error(node, mpack_error_type); + return 0; +} + +uint32_t mpack_node_u32(mpack_node_t node) { + if (mpack_node_error(node) != mpack_ok) + return 0; + + if (node.data->type == mpack_type_uint) { + if (node.data->value.u <= MPACK_UINT32_MAX) + return (uint32_t)node.data->value.u; + } else if (node.data->type == mpack_type_int) { + if (node.data->value.i >= 0 && node.data->value.i <= MPACK_UINT32_MAX) + return (uint32_t)node.data->value.i; + } + + mpack_node_flag_error(node, mpack_error_type); + return 0; +} + +int32_t mpack_node_i32(mpack_node_t node) { + if (mpack_node_error(node) != mpack_ok) + return 0; + + if (node.data->type == mpack_type_uint) { + if (node.data->value.u <= MPACK_INT32_MAX) + return (int32_t)node.data->value.u; + } else if (node.data->type == mpack_type_int) { + if (node.data->value.i >= MPACK_INT32_MIN && node.data->value.i <= MPACK_INT32_MAX) + return (int32_t)node.data->value.i; + } + + mpack_node_flag_error(node, mpack_error_type); + return 0; +} + +uint64_t mpack_node_u64(mpack_node_t node) { + if (mpack_node_error(node) != mpack_ok) + return 0; + + if (node.data->type == mpack_type_uint) { + return node.data->value.u; + } else if (node.data->type == mpack_type_int) { + if (node.data->value.i >= 0) + return (uint64_t)node.data->value.i; + } + + mpack_node_flag_error(node, mpack_error_type); + return 0; +} + +int64_t mpack_node_i64(mpack_node_t node) { + if (mpack_node_error(node) != mpack_ok) + return 0; + + if (node.data->type == mpack_type_uint) { + if (node.data->value.u <= (uint64_t)MPACK_INT64_MAX) + return (int64_t)node.data->value.u; + } else if (node.data->type == mpack_type_int) { + return node.data->value.i; + } + + mpack_node_flag_error(node, mpack_error_type); + return 0; +} + +unsigned int mpack_node_uint(mpack_node_t node) { + + // This should be true at compile-time, so this just wraps the 32-bit function. + if (sizeof(unsigned int) == 4) + return (unsigned int)mpack_node_u32(node); + + // Otherwise we use u64 and check the range. + uint64_t val = mpack_node_u64(node); + if (val <= MPACK_UINT_MAX) + return (unsigned int)val; + + mpack_node_flag_error(node, mpack_error_type); + return 0; +} + +int mpack_node_int(mpack_node_t node) { + + // This should be true at compile-time, so this just wraps the 32-bit function. + if (sizeof(int) == 4) + return (int)mpack_node_i32(node); + + // Otherwise we use i64 and check the range. + int64_t val = mpack_node_i64(node); + if (val >= MPACK_INT_MIN && val <= MPACK_INT_MAX) + return (int)val; + + mpack_node_flag_error(node, mpack_error_type); + return 0; +} + +#if MPACK_FLOAT +float mpack_node_float(mpack_node_t node) { + if (mpack_node_error(node) != mpack_ok) + return 0.0f; + + if (node.data->type == mpack_type_uint) + return (float)node.data->value.u; + if (node.data->type == mpack_type_int) + return (float)node.data->value.i; + if (node.data->type == mpack_type_float) + return node.data->value.f; + + if (node.data->type == mpack_type_double) { + #if MPACK_DOUBLE + return (float)node.data->value.d; + #else + return mpack_shorten_raw_double_to_float(node.data->value.d); + #endif + } + + mpack_node_flag_error(node, mpack_error_type); + return 0.0f; +} +#endif + +#if MPACK_DOUBLE +double mpack_node_double(mpack_node_t node) { + if (mpack_node_error(node) != mpack_ok) + return 0.0; + + if (node.data->type == mpack_type_uint) + return (double)node.data->value.u; + else if (node.data->type == mpack_type_int) + return (double)node.data->value.i; + else if (node.data->type == mpack_type_float) + return (double)node.data->value.f; + else if (node.data->type == mpack_type_double) + return node.data->value.d; + + mpack_node_flag_error(node, mpack_error_type); + return 0.0; +} +#endif + +#if MPACK_FLOAT +float mpack_node_float_strict(mpack_node_t node) { + if (mpack_node_error(node) != mpack_ok) + return 0.0f; + + if (node.data->type == mpack_type_float) + return node.data->value.f; + + mpack_node_flag_error(node, mpack_error_type); + return 0.0f; +} +#endif + +#if MPACK_DOUBLE +double mpack_node_double_strict(mpack_node_t node) { + if (mpack_node_error(node) != mpack_ok) + return 0.0; + + if (node.data->type == mpack_type_float) + return (double)node.data->value.f; + else if (node.data->type == mpack_type_double) + return node.data->value.d; + + mpack_node_flag_error(node, mpack_error_type); + return 0.0; +} +#endif + +#if !MPACK_FLOAT +uint32_t mpack_node_raw_float(mpack_node_t node) { + if (mpack_node_error(node) != mpack_ok) + return 0; + + if (node.data->type == mpack_type_float) + return node.data->value.f; + + mpack_node_flag_error(node, mpack_error_type); + return 0; +} +#endif + +#if !MPACK_DOUBLE +uint64_t mpack_node_raw_double(mpack_node_t node) { + if (mpack_node_error(node) != mpack_ok) + return 0; + + if (node.data->type == mpack_type_double) + return node.data->value.d; + + mpack_node_flag_error(node, mpack_error_type); + return 0; +} +#endif + +#if MPACK_EXTENSIONS +int8_t mpack_node_exttype(mpack_node_t node) { + if (mpack_node_error(node) != mpack_ok) + return 0; + + if (node.data->type == mpack_type_ext) + return mpack_node_exttype_unchecked(node); + + mpack_node_flag_error(node, mpack_error_type); + return 0; +} +#endif + +uint32_t mpack_node_data_len(mpack_node_t node) { + if (mpack_node_error(node) != mpack_ok) + return 0; + + mpack_type_t type = node.data->type; + if (type == mpack_type_str || type == mpack_type_bin + #if MPACK_EXTENSIONS + || type == mpack_type_ext + #endif + ) + return (uint32_t)node.data->len; + + mpack_node_flag_error(node, mpack_error_type); + return 0; +} + +size_t mpack_node_strlen(mpack_node_t node) { + if (mpack_node_error(node) != mpack_ok) + return 0; + + if (node.data->type == mpack_type_str) + return (size_t)node.data->len; + + mpack_node_flag_error(node, mpack_error_type); + return 0; +} + +const char* mpack_node_str(mpack_node_t node) { + if (mpack_node_error(node) != mpack_ok) + return NULL; + + mpack_type_t type = node.data->type; + if (type == mpack_type_str) + return mpack_node_data_unchecked(node); + + mpack_node_flag_error(node, mpack_error_type); + return NULL; +} + +const char* mpack_node_data(mpack_node_t node) { + if (mpack_node_error(node) != mpack_ok) + return NULL; + + mpack_type_t type = node.data->type; + if (type == mpack_type_str || type == mpack_type_bin + #if MPACK_EXTENSIONS + || type == mpack_type_ext + #endif + ) + return mpack_node_data_unchecked(node); + + mpack_node_flag_error(node, mpack_error_type); + return NULL; +} + +const char* mpack_node_bin_data(mpack_node_t node) { + if (mpack_node_error(node) != mpack_ok) + return NULL; + + if (node.data->type == mpack_type_bin) + return mpack_node_data_unchecked(node); + + mpack_node_flag_error(node, mpack_error_type); + return NULL; +} + +size_t mpack_node_bin_size(mpack_node_t node) { + if (mpack_node_error(node) != mpack_ok) + return 0; + + if (node.data->type == mpack_type_bin) + return (size_t)node.data->len; + + mpack_node_flag_error(node, mpack_error_type); + return 0; +} + +size_t mpack_node_array_length(mpack_node_t node) { + if (mpack_node_error(node) != mpack_ok) + return 0; + + if (node.data->type != mpack_type_array) { + mpack_node_flag_error(node, mpack_error_type); + return 0; + } + + return (size_t)node.data->len; +} + +mpack_node_t mpack_node_array_at(mpack_node_t node, size_t index) { + if (mpack_node_error(node) != mpack_ok) + return mpack_tree_nil_node(node.tree); + + if (node.data->type != mpack_type_array) { + mpack_node_flag_error(node, mpack_error_type); + return mpack_tree_nil_node(node.tree); + } + + if (index >= node.data->len) { + mpack_node_flag_error(node, mpack_error_data); + return mpack_tree_nil_node(node.tree); + } + + return mpack_node(node.tree, mpack_node_child(node, index)); +} + +size_t mpack_node_map_count(mpack_node_t node) { + if (mpack_node_error(node) != mpack_ok) + return 0; + + if (node.data->type != mpack_type_map) { + mpack_node_flag_error(node, mpack_error_type); + return 0; + } + + return node.data->len; +} + +// internal node map lookup +static mpack_node_t mpack_node_map_at(mpack_node_t node, size_t index, size_t offset) { + if (mpack_node_error(node) != mpack_ok) + return mpack_tree_nil_node(node.tree); + + if (node.data->type != mpack_type_map) { + mpack_node_flag_error(node, mpack_error_type); + return mpack_tree_nil_node(node.tree); + } + + if (index >= node.data->len) { + mpack_node_flag_error(node, mpack_error_data); + return mpack_tree_nil_node(node.tree); + } + + return mpack_node(node.tree, mpack_node_child(node, index * 2 + offset)); +} + +mpack_node_t mpack_node_map_key_at(mpack_node_t node, size_t index) { + return mpack_node_map_at(node, index, 0); +} + +mpack_node_t mpack_node_map_value_at(mpack_node_t node, size_t index) { + return mpack_node_map_at(node, index, 1); +} + +#endif + +MPACK_SILENCE_WARNINGS_END diff --git a/common/src/tap.cpp b/common/src/tap.cpp index cb4537e..1edeb05 100644 --- a/common/src/tap.cpp +++ b/common/src/tap.cpp @@ -143,4 +143,23 @@ int tap_get_mtu(const char *eth) close(sockfd); return ifr.ifr_mtu; +} + +int tap_set_rps(const char *eth, int thread_index, const char *rps_mask) +{ + char file[1024] = {0}; + + snprintf(file, sizeof(file), "/sys/class/net/%s/queues/rx-%d/rps_cpus", eth, thread_index); + + FILE *fp = fopen(file, "w"); + if (fp == NULL) + { + TFE_LOG_ERROR(g_default_logger, "unable to set rps on %s, file %s, %s", eth, file, strerror(errno)); + return -1; + } + + fwrite(rps_mask, strlen(rps_mask), 1, fp); + TFE_LOG_DEBUG(g_default_logger, "set rps '%s' to %s", rps_mask, file); + fclose(fp); + return 0; } \ No newline at end of file diff --git a/common/src/tfe_acceptor_kni.cpp b/common/src/tfe_acceptor_kni.cpp deleted file mode 100644 index a3a54be..0000000 --- a/common/src/tfe_acceptor_kni.cpp +++ /dev/null @@ -1,91 +0,0 @@ -#include -#include - -#include "tfe_cmsg.h" -#include "tfe_tap_rss.h" -#include "tfe_acceptor_kni.h" -#include "tfe_metrics.h" - -/****************************************************************************** - * session_ctx - ******************************************************************************/ - -struct session_ctx *session_ctx_new() -{ - struct session_ctx *ctx = (struct session_ctx *)calloc(1, sizeof(struct session_ctx)); - assert(ctx != NULL); - return ctx; -} - -void session_ctx_free(struct session_ctx *ctx) -{ - if (ctx) - { - if (ctx->cmsg) - { - tfe_cmsg_destroy(ctx->cmsg); - } - - free(ctx); - ctx = 0; - } -} - -/****************************************************************************** - * acceptor_ctx - ******************************************************************************/ -struct acceptor_ctx *acceptor_ctx_create(const char *profile) -{ - struct acceptor_ctx *ctx = ALLOC(struct acceptor_ctx, 1); - - MESA_load_profile_int_def(profile, "system", "firewall_sids", (int *)&(ctx->firewall_sids), 1001); - MESA_load_profile_int_def(profile, "system", "service_chaining_sids", (int *)&(ctx->sce_sids), 1002); - MESA_load_profile_int_def(profile, "system", "nr_worker_threads", (int *)&(ctx->nr_worker_threads), 8); - MESA_load_profile_uint_range(profile, "system", "cpu_affinity_mask", TFE_THREAD_MAX, (unsigned int *)ctx->cpu_affinity_mask); - ctx->nr_worker_threads = MIN(ctx->nr_worker_threads, TFE_THREAD_MAX); - - CPU_ZERO(&ctx->coremask); - for (int i = 0; i < ctx->nr_worker_threads; i++) - { - int cpu_id = ctx->cpu_affinity_mask[i]; - CPU_SET(cpu_id, &ctx->coremask); - } - - ctx->io = packet_io_create(profile, ctx->nr_worker_threads, &ctx->coremask); - if (ctx->io == NULL) - { - goto error_out; - } - - ctx->config = tfe_tap_config_create(profile, ctx->nr_worker_threads); - if (ctx->config == NULL) - { - goto error_out; - } - - ctx->metrics = global_metrics_create(); - if (ctx->metrics == NULL) - { - goto error_out; - } - - return ctx; - -error_out: - acceptor_ctx_destory(ctx); - return NULL; -} - -void acceptor_ctx_destory(struct acceptor_ctx * ctx) -{ - if (ctx) - { - packet_io_destory(ctx->io); - tfe_tap_destory(ctx->config); - global_metrics_destory(ctx->metrics); - - free(ctx); - ctx = NULL; - } - return; -} diff --git a/common/src/tfe_ctrl_packet.cpp b/common/src/tfe_ctrl_packet.cpp index 4fed27f..788ff47 100644 --- a/common/src/tfe_ctrl_packet.cpp +++ b/common/src/tfe_ctrl_packet.cpp @@ -39,7 +39,6 @@ int ctrl_packet_parser_parse(struct ctrl_pkt_parser *handler, const char *data, void ctrl_packet_parser_dump(struct ctrl_pkt_parser *handler) { - uint16_t cmsg_len; if (handler) { TFE_LOG_INFO(g_default_logger, "%s: tsync : %s", LOG_TAG_POLICY, handler->tsync); diff --git a/common/src/tfe_mpack.cpp b/common/src/tfe_mpack.cpp index f6bb9ec..d6aed51 100644 --- a/common/src/tfe_mpack.cpp +++ b/common/src/tfe_mpack.cpp @@ -4,8 +4,8 @@ #include #include #include -#include +#include "mpack.h" #include "tfe_cmsg.h" #include "tfe_utils.h" #include "tfe_ctrl_packet.h" @@ -37,133 +37,139 @@ struct mpack_mmap_id2type { int id; enum tfe_cmsg_tlv_type type; - char *str_name; + const char *str_name; int size; int array_index; }mpack_table[] = { - {.id = 0, .type = TFE_CMSG_POLICY_ID, .str_name = "TFE_CMSG_POLICY_ID", .size = 8}, - {.id = 1, .type = TFE_CMSG_TCP_RESTORE_SEQ, .str_name = "TFE_CMSG_TCP_RESTORE_SEQ", .size = 4}, - {.id = 2, .type = TFE_CMSG_TCP_RESTORE_ACK, .str_name = "TFE_CMSG_TCP_RESTORE_ACK", .size = 4}, - {.id = 3, .type = TFE_CMSG_TCP_RESTORE_MSS_CLIENT, .str_name = "TFE_CMSG_TCP_RESTORE_MSS_CLIENT", .size = 2}, - {.id = 4, .type = TFE_CMSG_TCP_RESTORE_MSS_SERVER, .str_name = "TFE_CMSG_TCP_RESTORE_MSS_SERVER", .size = 2}, - {.id = 5, .type = TFE_CMSG_TCP_RESTORE_WSACLE_CLIENT, .str_name = "TFE_CMSG_TCP_RESTORE_WSACLE_CLIENT", .size = 1}, - {.id = 6, .type = TFE_CMSG_TCP_RESTORE_WSACLE_SERVER, .str_name = "TFE_CMSG_TCP_RESTORE_WSACLE_SERVER", .size = 1}, - {.id = 7, .type = TFE_CMSG_TCP_RESTORE_SACK_CLIENT, .str_name = "TFE_CMSG_TCP_RESTORE_SACK_CLIENT", .size = 1}, - {.id = 8, .type = TFE_CMSG_TCP_RESTORE_SACK_SERVER, .str_name = "TFE_CMSG_TCP_RESTORE_SACK_SERVER", .size = 1}, - {.id = 9, .type = TFE_CMSG_TCP_RESTORE_TS_CLIENT, .str_name = "TFE_CMSG_TCP_RESTORE_TS_CLIENT", .size = 1}, - {.id = 10, .type = TFE_CMSG_TCP_RESTORE_TS_SERVER, .str_name = "TFE_CMSG_TCP_RESTORE_TS_SERVER", .size = 1}, - {.id = 11, .type = TFE_CMSG_TCP_RESTORE_PROTOCOL, .str_name = "TFE_CMSG_TCP_RESTORE_PROTOCOL", .size = 1}, - {.id = 12, .type = TFE_CMSG_TCP_RESTORE_WINDOW_CLIENT, .str_name = "TFE_CMSG_TCP_RESTORE_WINDOW_CLIENT", .size = 2}, - {.id = 13, .type = TFE_CMSG_TCP_RESTORE_WINDOW_SERVER, .str_name = "TFE_CMSG_TCP_RESTORE_WINDOW_SERVER", .size = 2}, - {.id = 14, .type = TFE_CMSG_TCP_RESTORE_TS_CLIENT_VAL, .str_name = "TFE_CMSG_TCP_RESTORE_TS_CLIENT_VAL", .size = 4}, - {.id = 15, .type = TFE_CMSG_TCP_RESTORE_TS_SERVER_VAL, .str_name = "TFE_CMSG_TCP_RESTORE_TS_SERVER_VAL", .size = 4}, - {.id = 16, .type = TFE_CMSG_TCP_RESTORE_INFO_PACKET_CUR_DIR, .str_name = "TFE_CMSG_TCP_RESTORE_INFO_PACKET_CUR_DIR", .size = 1}, - {.id = 17, .type = TFE_CMSG_SRC_SUB_ID, .str_name = "TFE_CMSG_SRC_SUB_ID", .size = 256}, - {.id = 18, .type = TFE_CMSG_DST_SUB_ID, .str_name = "TFE_CMSG_DST_SUB_ID", .size = 256}, - {.id = 19, .type = TFE_CMSG_SRC_ASN, .str_name = "TFE_CMSG_SRC_ASN", .size = 64}, - {.id = 20, .type = TFE_CMSG_DST_ASN, .str_name = "TFE_CMSG_DST_ASN", .size = 64}, - {.id = 21, .type = TFE_CMSG_SRC_ORGANIZATION, .str_name = "TFE_CMSG_SRC_ORGANIZATION", .size = 256}, - {.id = 22, .type = TFE_CMSG_DST_ORGANIZATION, .str_name = "TFE_CMSG_DST_ORGANIZATION", .size = 256}, - {.id = 23, .type = TFE_CMSG_SRC_IP_LOCATION_COUNTRY, .str_name = "TFE_CMSG_SRC_IP_LOCATION_COUNTRY", .size = 256}, - {.id = 24, .type = TFE_CMSG_DST_IP_LOCATION_COUNTRY, .str_name = "TFE_CMSG_DST_IP_LOCATION_COUNTRY", .size = 256}, - {.id = 25, .type = TFE_CMSG_SRC_IP_LOCATION_PROVINE, .str_name = "TFE_CMSG_SRC_IP_LOCATION_PROVINE", .size = 256}, - {.id = 26, .type = TFE_CMSG_DST_IP_LOCATION_PROVINE, .str_name = "TFE_CMSG_DST_IP_LOCATION_PROVINE", .size = 256}, - {.id = 27, .type = TFE_CMSG_SRC_IP_LOCATION_CITY, .str_name = "TFE_CMSG_SRC_IP_LOCATION_CITY", .size = 256}, - {.id = 28, .type = TFE_CMSG_DST_IP_LOCATION_CITY, .str_name = "TFE_CMSG_DST_IP_LOCATION_CITY", .size = 256}, - {.id = 29, .type = TFE_CMSG_SRC_IP_LOCATION_SUBDIVISION, .str_name = "TFE_CMSG_SRC_IP_LOCATION_SUBDIVISION", .size = 256}, - {.id = 30, .type = TFE_CMSG_DST_IP_LOCATION_SUBDIVISION, .str_name = "TFE_CMSG_DST_IP_LOCATION_SUBDIVISION", .size = 256}, - {.id = 31, .type = TFE_CMSG_SSL_CLIENT_JA3_FINGERPRINT, .str_name = "TFE_CMSG_SSL_CLIENT_JA3_FINGERPRINT", .size = 32}, - {.id = 32, .type = TFE_CMSG_FQDN_CAT_ID_VAL, .str_name = "TFE_CMSG_FQDN_CAT_ID_VAL", .size = 4, .array_index = MPACK_ARRAY_FQDN_IDS}, - {.id = 33, .str_name = "TFE_SEQ_SIDS", .size = 2, .array_index = MPACK_ARRAY_SEQ_SIDS}, - {.id = 34, .str_name = "TFE_ACK_SIDS", .size = 2, .array_index = MPACK_ARRAY_ACK_SIDS}, - {.id = 35, .str_name = "TFE_SEQ_ROUTE_CTX", .size = 1, .array_index = MPACK_ARRAY_SEQ_ROUTE_CTX}, - {.id = 36, .str_name = "TFE_ACK_ROUTE_CTX", .size = 1, .array_index = MPACK_ARRAY_ACK_ROUTE_CTX} + {.id = 0, .type = TFE_CMSG_TCP_RESTORE_SEQ, .str_name = "TFE_CMSG_TCP_RESTORE_SEQ", .size = 4}, + {.id = 1, .type = TFE_CMSG_TCP_RESTORE_ACK, .str_name = "TFE_CMSG_TCP_RESTORE_ACK", .size = 4}, + {.id = 2, .type = TFE_CMSG_TCP_RESTORE_MSS_CLIENT, .str_name = "TFE_CMSG_TCP_RESTORE_MSS_CLIENT", .size = 2}, + {.id = 3, .type = TFE_CMSG_TCP_RESTORE_MSS_SERVER, .str_name = "TFE_CMSG_TCP_RESTORE_MSS_SERVER", .size = 2}, + {.id = 4, .type = TFE_CMSG_TCP_RESTORE_WSACLE_CLIENT, .str_name = "TFE_CMSG_TCP_RESTORE_WSACLE_CLIENT", .size = 1}, + {.id = 5, .type = TFE_CMSG_TCP_RESTORE_WSACLE_SERVER, .str_name = "TFE_CMSG_TCP_RESTORE_WSACLE_SERVER", .size = 1}, + {.id = 6, .type = TFE_CMSG_TCP_RESTORE_SACK_CLIENT, .str_name = "TFE_CMSG_TCP_RESTORE_SACK_CLIENT", .size = 1}, + {.id = 7, .type = TFE_CMSG_TCP_RESTORE_SACK_SERVER, .str_name = "TFE_CMSG_TCP_RESTORE_SACK_SERVER", .size = 1}, + {.id = 8, .type = TFE_CMSG_TCP_RESTORE_TS_CLIENT, .str_name = "TFE_CMSG_TCP_RESTORE_TS_CLIENT", .size = 1}, + {.id = 9, .type = TFE_CMSG_TCP_RESTORE_TS_SERVER, .str_name = "TFE_CMSG_TCP_RESTORE_TS_SERVER", .size = 1}, + {.id = 10, .type = TFE_CMSG_TCP_RESTORE_PROTOCOL, .str_name = "TFE_CMSG_TCP_RESTORE_PROTOCOL", .size = 1}, + {.id = 11, .type = TFE_CMSG_TCP_RESTORE_WINDOW_CLIENT, .str_name = "TFE_CMSG_TCP_RESTORE_WINDOW_CLIENT", .size = 2}, + {.id = 12, .type = TFE_CMSG_TCP_RESTORE_WINDOW_SERVER, .str_name = "TFE_CMSG_TCP_RESTORE_WINDOW_SERVER", .size = 2}, + {.id = 13, .type = TFE_CMSG_TCP_RESTORE_TS_CLIENT_VAL, .str_name = "TFE_CMSG_TCP_RESTORE_TS_CLIENT_VAL", .size = 4}, + {.id = 14, .type = TFE_CMSG_TCP_RESTORE_TS_SERVER_VAL, .str_name = "TFE_CMSG_TCP_RESTORE_TS_SERVER_VAL", .size = 4}, + {.id = 15, .type = TFE_CMSG_TCP_RESTORE_INFO_PACKET_CUR_DIR, .str_name = "TFE_CMSG_TCP_RESTORE_INFO_PACKET_CUR_DIR", .size = 1}, + {.id = 16, .type = TFE_CMSG_SRC_SUB_ID, .str_name = "TFE_CMSG_SRC_SUB_ID", .size = 256}, + {.id = 17, .type = TFE_CMSG_DST_SUB_ID, .str_name = "TFE_CMSG_DST_SUB_ID", .size = 256}, + {.id = 18, .type = TFE_CMSG_SRC_ASN, .str_name = "TFE_CMSG_SRC_ASN", .size = 64}, + {.id = 19, .type = TFE_CMSG_DST_ASN, .str_name = "TFE_CMSG_DST_ASN", .size = 64}, + {.id = 20, .type = TFE_CMSG_SRC_ORGANIZATION, .str_name = "TFE_CMSG_SRC_ORGANIZATION", .size = 256}, + {.id = 21, .type = TFE_CMSG_DST_ORGANIZATION, .str_name = "TFE_CMSG_DST_ORGANIZATION", .size = 256}, + {.id = 22, .type = TFE_CMSG_SRC_IP_LOCATION_COUNTRY, .str_name = "TFE_CMSG_SRC_IP_LOCATION_COUNTRY", .size = 256}, + {.id = 23, .type = TFE_CMSG_DST_IP_LOCATION_COUNTRY, .str_name = "TFE_CMSG_DST_IP_LOCATION_COUNTRY", .size = 256}, + {.id = 24, .type = TFE_CMSG_SRC_IP_LOCATION_PROVINE, .str_name = "TFE_CMSG_SRC_IP_LOCATION_PROVINE", .size = 256}, + {.id = 25, .type = TFE_CMSG_DST_IP_LOCATION_PROVINE, .str_name = "TFE_CMSG_DST_IP_LOCATION_PROVINE", .size = 256}, + {.id = 26, .type = TFE_CMSG_SRC_IP_LOCATION_CITY, .str_name = "TFE_CMSG_SRC_IP_LOCATION_CITY", .size = 256}, + {.id = 27, .type = TFE_CMSG_DST_IP_LOCATION_CITY, .str_name = "TFE_CMSG_DST_IP_LOCATION_CITY", .size = 256}, + {.id = 28, .type = TFE_CMSG_SRC_IP_LOCATION_SUBDIVISION, .str_name = "TFE_CMSG_SRC_IP_LOCATION_SUBDIVISION", .size = 256}, + {.id = 29, .type = TFE_CMSG_DST_IP_LOCATION_SUBDIVISION, .str_name = "TFE_CMSG_DST_IP_LOCATION_SUBDIVISION", .size = 256}, + {.id = 30, .type = TFE_CMSG_SSL_CLIENT_JA3_FINGERPRINT, .str_name = "TFE_CMSG_SSL_CLIENT_JA3_FINGERPRINT", .size = 32}, + {.id = 31, .type = TFE_CMSG_FQDN_CAT_ID_VAL, .str_name = "TFE_CMSG_FQDN_CAT_ID_VAL", .size = 4, .array_index = MPACK_ARRAY_FQDN_IDS}, + {.id = 32, .str_name = "TFE_SEQ_SIDS", .size = 2, .array_index = MPACK_ARRAY_SEQ_SIDS}, + {.id = 33, .str_name = "TFE_ACK_SIDS", .size = 2, .array_index = MPACK_ARRAY_ACK_SIDS}, + {.id = 34, .str_name = "TFE_SEQ_ROUTE_CTX", .size = 1, .array_index = MPACK_ARRAY_SEQ_ROUTE_CTX}, + {.id = 35, .str_name = "TFE_ACK_ROUTE_CTX", .size = 1, .array_index = MPACK_ARRAY_ACK_ROUTE_CTX} }; -static void fqdn_id_set_cmsg(struct ctrl_pkt_parser *handler, msgpack_object *ptr, int table_index) +static int fqdn_id_set_cmsg(struct ctrl_pkt_parser *handler, mpack_node_t node, int table_index) { uint32_t fqdn_val[8] = {0}; - tfe_cmsg_set(handler->cmsg, TFE_CMSG_FQDN_CAT_ID_NUM, (const unsigned char *)&ptr->via.array.size, sizeof(uint32_t)); - TFE_LOG_DEBUG(g_default_logger, "%s: session: %lu array fqdn_id num: [%u]", LOG_TAG_CTRLPKT, handler->session_id, ptr->via.array.size); - for (uint32_t j = 0; j < ptr->via.array.size; j++) { - fqdn_val[j] = ptr->via.array.ptr[j].via.u64; - TFE_LOG_DEBUG(g_default_logger, "%s: session: %lu array fqdn_id msgpack cmsg: [%s] -> [%lu]", LOG_TAG_CTRLPKT, handler->session_id, mpack_table[table_index].str_name, ptr->via.array.ptr[j].via.u64); + uint32_t array_cnt = mpack_node_array_length(node); + tfe_cmsg_set(handler->cmsg, TFE_CMSG_FQDN_CAT_ID_NUM, (const unsigned char *)&array_cnt, sizeof(uint32_t)); + TFE_LOG_DEBUG(g_default_logger, "%s: session: %lu array fqdn_id num: [%u]", LOG_TAG_CTRLPKT, handler->session_id, array_cnt); + for (uint32_t i = 0; i < array_cnt; i++) { + fqdn_val[i] = mpack_node_u32(mpack_node_array_at(node, i)); + TFE_LOG_DEBUG(g_default_logger, "%s: session: %lu array fqdn_id msgpack cmsg: [%s] -> [%lu]", LOG_TAG_CTRLPKT, handler->session_id, mpack_table[table_index].str_name, fqdn_val[i]); } - tfe_cmsg_set(handler->cmsg ,TFE_CMSG_FQDN_CAT_ID_VAL, (const unsigned char*)fqdn_val, ptr->via.array.size * sizeof(uint32_t)); - return; + tfe_cmsg_set(handler->cmsg, TFE_CMSG_FQDN_CAT_ID_VAL, (const unsigned char*)fqdn_val, array_cnt * sizeof(uint32_t)); + return 0; } -static void sids_array_parse_mpack(struct ctrl_pkt_parser *handler, msgpack_object *ptr, int table_index, int is_seq) +static int sids_array_parse_mpack(struct ctrl_pkt_parser *handler, mpack_node_t node, int table_index, int is_seq) { - struct sids *sid= is_seq ? &handler->seq_sids : &handler->ack_sids; + struct sids *sid = is_seq ? &handler->seq_sids : &handler->ack_sids; + if (mpack_node_array_length(node) > MR_SID_LIST_MAXLEN) { + TFE_LOG_ERROR(g_default_logger, "%s: session: %lu sid[%u] more than maxlen %d", LOG_TAG_CTRLPKT, handler->session_id, mpack_node_array_length(node), MR_SID_LIST_MAXLEN); + return -1; + } - sid->num = ptr->via.array.size > MR_SID_LIST_MAXLEN ? MR_SID_LIST_MAXLEN : ptr->via.array.size; - TFE_LOG_DEBUG(g_default_logger, "%s: session: %lu array sids num: [%u]", LOG_TAG_CTRLPKT, handler->session_id, ptr->via.array.size); + sid->num = mpack_node_array_length(node); + TFE_LOG_DEBUG(g_default_logger, "%s: session: %lu array sids num: [%u]", LOG_TAG_CTRLPKT, handler->session_id, sid->num); for (int i = 0; i < sid->num; i++) { - sid->elems[i] = ptr->via.array.ptr[i].via.u64; + sid->elems[i] = mpack_node_u16(mpack_node_array_at(node, i)); } - return; + return 0; } -static void route_ctx_parse_mpack(struct ctrl_pkt_parser *handler, msgpack_object *ptr, int table_index, int is_seq) +static int route_ctx_parse_mpack(struct ctrl_pkt_parser *handler, mpack_node_t node, int table_index, int is_seq) { struct route_ctx *ctx = is_seq ? &handler->seq_route_ctx : &handler->ack_route_ctx; + if (mpack_node_array_length(node) > 64) { + TFE_LOG_ERROR(g_default_logger, "%s: session: %lu route ctx[%d] more than maxlen 64", LOG_TAG_CTRLPKT, handler->session_id, mpack_node_array_length(node)); + return -1; + } - ctx->len = ptr->via.array.size > 64 ? 64 : ptr->via.array.size; - TFE_LOG_DEBUG(g_default_logger, "%s: session: %lu array route ctx num: [%u]", LOG_TAG_CTRLPKT, handler->session_id, ptr->via.array.size); + ctx->len = mpack_node_array_length(node); + TFE_LOG_DEBUG(g_default_logger, "%s: session: %lu array route ctx num: [%u]", LOG_TAG_CTRLPKT, handler->session_id, ctx->len); for (int i = 0; i < ctx->len; i++) { - memcpy(ctx->data+i, &ptr->via.array.ptr[i].via.u64, 1); + ctx->data[i] = mpack_node_u8(mpack_node_array_at(node, i)); } - return; + return 0; } -static int proxy_parse_messagepack(msgpack_object *obj, void *ctx) +static int proxy_parse_messagepack(mpack_node_t node, void *ctx) { + uint64_t value = 0; struct ctrl_pkt_parser *handler = (struct ctrl_pkt_parser *)ctx; - for (unsigned int i = 0; i < obj->via.array.size; i++) { - msgpack_object *ptr = &obj->via.array.ptr[i]; + if (mpack_node_is_nil(mpack_node_map_cstr(node, "rule_ids"))) + { + TFE_LOG_ERROR(g_default_logger, "%s: unexpected control packet: (rule_ids no found)", LOG_TAG_CTRLPKT); + return -1; + } + handler->tfe_policy_id_num = mpack_node_array_length(mpack_node_map_cstr(node, "rule_ids")); + for (int i = 0; i < handler->tfe_policy_id_num; i++) { + handler->tfe_policy_ids[i] = mpack_node_u64(mpack_node_array_at(mpack_node_map_cstr(node, "rule_ids"), i)); + } - if (i == 0) { - if (ptr->type == MSGPACK_OBJECT_ARRAY) { - handler->tfe_policy_id_num = ptr->via.array.size; - for (uint32_t j = 0; j < ptr->via.array.size; j++) { - handler->tfe_policy_ids[j] = ptr->via.array.ptr[j].via.u64; - } - tfe_cmsg_set(handler->cmsg, mpack_table[i].type, (const unsigned char *)&handler->tfe_policy_ids[0], sizeof(uint64_t)); - TFE_LOG_DEBUG(g_default_logger, "%s: session: %lu interger msgpack cmsg: [%s] num: [%d]", LOG_TAG_CTRLPKT, handler->session_id, mpack_table[i].str_name, handler->tfe_policy_id_num); - for (int j = 0; j < handler->tfe_policy_id_num; j++) { - TFE_LOG_DEBUG(g_default_logger, "%s: session: %lu policy id:%lu ", LOG_TAG_CTRLPKT, handler->session_id, handler->tfe_policy_ids[j]); - } - } - continue; + if (handler->tfe_policy_id_num) { + tfe_cmsg_set(handler->cmsg, TFE_CMSG_POLICY_ID, (const unsigned char *)&handler->tfe_policy_ids[0], sizeof(uint64_t)); + TFE_LOG_DEBUG(g_default_logger, "%s: session: %lu tfe policy id num: [%d]", LOG_TAG_CTRLPKT, handler->session_id, handler->tfe_policy_id_num); + for (int i = 0; i < handler->tfe_policy_id_num; i++) { + TFE_LOG_DEBUG(g_default_logger, "%s: session: %lu policy id:%lu ", LOG_TAG_CTRLPKT, handler->session_id, handler->tfe_policy_ids[i]); } + } - switch (ptr->type) { - case MSGPACK_OBJECT_POSITIVE_INTEGER: - // TFE_CMSG_TCP_RESTORE_PROTOCOL tsg master 发送数据错误，临时强制设置为1 - if (i == 11) - { - uint8_t protocol = 1; - tfe_cmsg_set(handler->cmsg, TFE_CMSG_TCP_RESTORE_PROTOCOL, (const unsigned char *)&protocol, 1); - } - else - { - tfe_cmsg_set(handler->cmsg, mpack_table[i].type, (const unsigned char *)&ptr->via.u64, mpack_table[i].size); - } - TFE_LOG_DEBUG(g_default_logger, "%s: session: %lu interger msgpack cmsg: [%s] -> [%lu]", LOG_TAG_CTRLPKT, handler->session_id, mpack_table[i].str_name, ptr->via.u64); + mpack_node_t tcp_handshake = mpack_node_map_cstr(node, "tcp_handshake"); + int cmsg_array_cnt = mpack_node_array_length(tcp_handshake); + for (int i = 0; i < cmsg_array_cnt; i++) { + mpack_node_t ptr = mpack_node_array_at(tcp_handshake, i); + + switch (mpack_node_type(ptr)) { + case mpack_type_uint: + value = mpack_node_u64(ptr); + tfe_cmsg_set(handler->cmsg, mpack_table[i].type, (const unsigned char *)&value, mpack_table[i].size); + TFE_LOG_DEBUG(g_default_logger, "%s: session: %lu interger msgpack cmsg: [%s] -> [%lu]", LOG_TAG_CTRLPKT, handler->session_id, mpack_table[i].str_name, value); break; - case MSGPACK_OBJECT_STR: - tfe_cmsg_set(handler->cmsg, mpack_table[i].type, (const unsigned char *)ptr->via.str.ptr, ptr->via.str.size); - TFE_LOG_DEBUG(g_default_logger, "%s: session: %lu string msgpack cmsg: [%s] -> [%s]", LOG_TAG_CTRLPKT, handler->session_id, mpack_table[i].str_name, ptr->via.str.ptr); + case mpack_type_str: + tfe_cmsg_set(handler->cmsg, mpack_table[i].type, (const unsigned char *)mpack_node_str(ptr), mpack_node_strlen(ptr)); + TFE_LOG_DEBUG(g_default_logger, "%s: session: %lu string msgpack cmsg: [%s] -> [%s]", LOG_TAG_CTRLPKT, handler->session_id, mpack_table[i].str_name, mpack_node_str(ptr)); break; - case MSGPACK_OBJECT_NIL: + case mpack_type_nil: TFE_LOG_DEBUG(g_default_logger, "%s: session: %lu msgpack cmsg: [%s] -> [nil]", LOG_TAG_CTRLPKT, handler->session_id, mpack_table[i].str_name); break; - case MSGPACK_OBJECT_ARRAY: + case mpack_type_array: switch(mpack_table[i].array_index) { case MPACK_ARRAY_FQDN_IDS: @@ -195,101 +201,112 @@ static int proxy_parse_messagepack(msgpack_object *obj, void *ctx) int parse_messagepack(const char* data, size_t length, void *ctx) { struct ctrl_pkt_parser *handler = (struct ctrl_pkt_parser *)ctx; - size_t off = 0; - msgpack_object *obj = NULL; - msgpack_object *ptr = NULL; + char buff[16] = {0}; + mpack_node_t params; + mpack_node_t sce_map; + mpack_node_t proxy_map; + mpack_tree_t tree; + mpack_tree_init_data(&tree, data, length); + mpack_tree_parse(&tree); + mpack_node_t root = mpack_tree_root(&tree); + if (mpack_node_is_nil(root)) + { + TFE_LOG_ERROR(g_default_logger, "%s: unexpected control packet: (invalid mpack format)", LOG_TAG_CTRLPKT); + goto error; + } + + if (mpack_node_is_nil(mpack_node_map_cstr(root, "tsync"))) + { + TFE_LOG_ERROR(g_default_logger, "%s: unexpected control packet: (tsync no found)", LOG_TAG_CTRLPKT); + goto error; + } + mpack_node_copy_cstr(mpack_node_map_cstr(root, "tsync"), handler->tsync, sizeof(handler->tsync)); + if (strcmp(handler->tsync, "2.0") != 0) + { + TFE_LOG_ERROR(g_default_logger, "%s: unexpected control packet: (invalid tsync version) %s", LOG_TAG_CTRLPKT, handler->tsync); + goto error; + } + + if (mpack_node_is_nil(mpack_node_map_cstr(root, "session_id"))) + { + TFE_LOG_ERROR(g_default_logger, "%s: unexpected control packet: (session_id no found)", LOG_TAG_CTRLPKT); + goto error; + } + handler->session_id = mpack_node_u64(mpack_node_map_cstr(root, "session_id")); + - msgpack_unpacked unpacked; - msgpack_unpacked_init(&unpacked); - - msgpack_unpack_return ret = msgpack_unpack_next(&unpacked, data, length, &off); - if (ret != MSGPACK_UNPACK_SUCCESS) { - TFE_LOG_DEBUG(g_default_logger, "%s: unexpected control packet: data[%s]", LOG_TAG_CTRLPKT, data); - goto end; + if (mpack_node_is_nil(mpack_node_map_cstr(root, "state"))) + { + TFE_LOG_ERROR(g_default_logger, "%s: unexpected control packet: (state no found)", LOG_TAG_CTRLPKT); + goto error; + } + mpack_node_copy_cstr(mpack_node_map_cstr(root, "state"), buff, sizeof(buff)); + if (strncasecmp(buff, "opening", sizeof(buff)) == 0) + { + handler->state = SESSION_STATE_OPENING; + } + else if (strncasecmp(buff, "active", sizeof(buff)) == 0) + { + handler->state = SESSION_STATE_ACTIVE; + } + else if (strncasecmp(buff, "closing", sizeof(buff)) == 0) + { + handler->state = SESSION_STATE_CLOSING; + } + else if (strncasecmp(buff, "resetall", sizeof(buff)) == 0) + { + handler->state = SESSION_STATE_RESETALL; + } + else + { + TFE_LOG_DEBUG(g_default_logger, "%s: unexpected control packet: (invalid state value) %s", LOG_TAG_CTRLPKT, buff); } - obj = &unpacked.data; - if (obj->type != MSGPACK_OBJECT_ARRAY) { - TFE_LOG_DEBUG(g_default_logger, "%s: unexpected control packet: msgpack type is not MSGPACK_OBJECT_ARRAY", LOG_TAG_CTRLPKT); - goto end; + if (mpack_node_is_nil(mpack_node_map_cstr(root, "method"))) + { + TFE_LOG_ERROR(g_default_logger, "%s: unexpected control packet: (method no found)", LOG_TAG_CTRLPKT); + goto error; } + mpack_node_copy_cstr(mpack_node_map_cstr(root, "method"), handler->method, sizeof(handler->method)); - for (unsigned int i = 0; i < obj->via.array.size; i++) { - ptr = &obj->via.array.ptr[i]; - switch (i) { - case INDEX_TSYNC: - if (ptr->type == MSGPACK_OBJECT_STR) { - memcpy(handler->tsync, ptr->via.str.ptr, ptr->via.str.size); + if (mpack_node_is_nil(mpack_node_map_cstr(root, "params"))) + { + TFE_LOG_ERROR(g_default_logger, "%s: unexpected control packet: (params no found)", LOG_TAG_CTRLPKT); + goto error; + } + params = mpack_node_map_cstr(root, "params"); + + if (!mpack_node_is_nil(mpack_node_map_cstr(params, "sce"))) + { + sce_map = mpack_node_map_cstr(params, "sce"); + if (mpack_node_is_nil(mpack_node_map_cstr(sce_map, "rule_ids"))) + { + TFE_LOG_ERROR(g_default_logger, "%s: unexpected control packet: (sce rule_ids no found)", LOG_TAG_CTRLPKT); + goto error; + } + handler->sce_policy_id_num = mpack_node_array_length(mpack_node_map_cstr(sce_map, "rule_ids")); + for (int i = 0; i < handler->sce_policy_id_num; i++) { + handler->sce_policy_ids[i] = mpack_node_u64(mpack_node_array_at(mpack_node_map_cstr(sce_map, "rule_ids"), i)); + } + + if (handler->sce_policy_id_num) { + TFE_LOG_DEBUG(g_default_logger, "%s: session: %lu sce policy id num: [%d]", LOG_TAG_CTRLPKT, handler->session_id, handler->sce_policy_id_num); + for (int i = 0; i < handler->sce_policy_id_num; i++) { + TFE_LOG_DEBUG(g_default_logger, "%s: session: %lu policy id:%lu ", LOG_TAG_CTRLPKT, handler->session_id, handler->sce_policy_ids[i]); } - else { - TFE_LOG_DEBUG(g_default_logger, "%s: unexpected control packet: (invalid tsync type) %02x", LOG_TAG_CTRLPKT, ptr->type); - } - break; - case INDEX_SESSION_ID: - if (ptr->type == MSGPACK_OBJECT_POSITIVE_INTEGER) { - handler->session_id = ptr->via.u64; - } - else { - TFE_LOG_DEBUG(g_default_logger, "%s: unexpected control packet: (invalid session id type) %02x", LOG_TAG_CTRLPKT, ptr->type); - } - break; - case INDEX_STATE: - if (ptr->type == MSGPACK_OBJECT_STR) { - if (strncasecmp(ptr->via.str.ptr, "opening", ptr->via.str.size) == 0) - { - handler->state = SESSION_STATE_OPENING; - } - else if (strncasecmp(ptr->via.str.ptr, "active", ptr->via.str.size) == 0) - { - handler->state = SESSION_STATE_ACTIVE; - } - else if (strncasecmp(ptr->via.str.ptr, "closing", ptr->via.str.size) == 0) - { - handler->state = SESSION_STATE_CLOSING; - } - else if (strncasecmp(ptr->via.str.ptr, "resetall", ptr->via.str.size) == 0) - { - handler->state = SESSION_STATE_RESETALL; - } - else - { - TFE_LOG_DEBUG(g_default_logger, "%s: unexpected control packet: (invalid state value) %s", LOG_TAG_CTRLPKT, ptr->via.str.ptr); - } - } - else { - TFE_LOG_DEBUG(g_default_logger, "%s: unexpected control packet: (invalid state type) %02x", LOG_TAG_CTRLPKT, ptr->type); - } - break; - case INDEX_METHOD: - if (ptr->type == MSGPACK_OBJECT_STR) { - memcpy(handler->method, ptr->via.str.ptr, ptr->via.str.size); - } - else { - TFE_LOG_DEBUG(g_default_logger, "%s: unexpected control packet: (invalid method type) %02x", LOG_TAG_CTRLPKT, ptr->type); - } - break; - case INDEX_VALUE_SCE: - if (ptr->type == MSGPACK_OBJECT_ARRAY) { - msgpack_object rule_id = ptr->via.array.ptr[0]; - handler->sce_policy_id_num = rule_id.via.array.size; - for (uint32_t j = 0; j < rule_id.via.array.size; j++) { - handler->sce_policy_ids[j] = rule_id.via.array.ptr[j].via.u64; - } - } - break; - case INDEX_VALUE_PROXY: - if (ptr->type == MSGPACK_OBJECT_ARRAY) { - proxy_parse_messagepack(ptr, handler); - } - else { - TFE_LOG_DEBUG(g_default_logger, "%s: unexpected control packet: (invalid proxy type) %02x", LOG_TAG_CTRLPKT, ptr->type); - } - break; - default: - break; } } -end: - msgpack_unpacked_destroy(&unpacked); + + if (mpack_node_is_nil(mpack_node_map_cstr(params, "proxy"))) + { + TFE_LOG_ERROR(g_default_logger, "%s: unexpected control packet: (proxy no found)", LOG_TAG_CTRLPKT); + goto error; + } + proxy_map = mpack_node_map_cstr(params, "proxy"); + proxy_parse_messagepack(proxy_map, handler); + mpack_tree_destroy(&tree); return 0; +error: + mpack_tree_destroy(&tree); + return -1; } diff --git a/common/src/tfe_packet_io.cpp b/common/src/tfe_packet_io.cpp index 17ed84b..699d025 100644 --- a/common/src/tfe_packet_io.cpp +++ b/common/src/tfe_packet_io.cpp @@ -3,15 +3,20 @@ #include #include #include +#include +#include #include #include #include #include -// #include #include -#include "tfe_acceptor_kni.h" +#include +#include + +#include + #include "tfe_ctrl_packet.h" #include "tfe_raw_packet.h" #include "io_uring.h" @@ -21,25 +26,13 @@ #include "tfe_stream.h" #include "raw_socket.h" #include "packet_construct.h" -#include "tfe_tap_rss.h" -#include +#include "mpack.h" +#include "tap.h" +#include "bpf_obj.h" +#include "tfe_session_table.h" +#include "tfe_packet_io.h" + -#include -/* - * add: vxlan_hdr - * del: marsio_buff_ctrlzone_reset() - * +----+ NF2SF +----+ - * | |--------------------------->| | - * | | | | - * | |-------+ | |-------+ - * | NF | | NF2NF (undo) | SF | | SF2SF (del old vxlan_hdr; add new vxlan_hdr) - * | |<------+ | |<------+ - * | | | | - * | |<---------------------------| | - * | | SF2NF | | - * +---+ del: vxlan_hdr +----+ - * add: session_id + route_ctx + sid - */ /****************************************************************************** * Struct @@ -51,12 +44,41 @@ #define SET_TRAFFIC_IS_DECRYPTED(field) (field | TRAFFIC_IS_DECRYPTED) #define CLEAR_TRAFFIC_IS_DECRYPTED(field) (field & ~TRAFFIC_IS_DECRYPTED) + struct config { int bypass_all_traffic; int rx_burst_max; + + int enable_iouring; + int enable_debuglog; + + int ring_size; + int buff_size; + + int flags; + int sq_thread_idle; + + int bpf_debug_log; + int bpf_hash_mode; + int tap_allow_mutilthread; + char bpf_obj[1024]; + + char src_mac[6]; + char tap_mac[6]; + char tap_c_mac[6]; + char tap_s_mac[6]; + char dev_tap[16]; + char dev_tap_c[16]; + char dev_tap_s[16]; + + int tap_rps_enable; + char tap_rps_mask[TFE_SYMBOL_MAX]; + char app_symbol[256]; char dev_nf_interface[256]; + + struct bpf_obj_ctx *tap_bpf_ctx; }; struct device @@ -141,14 +163,11 @@ extern void chaining_policy_enforce(struct chaining_policy_enforcer *enforcer, s * STATIC ******************************************************************************/ -static void time_echo(struct addr_tuple4 inner_addr) +static void time_echo(uint64_t session_id, char *info) { time_t t; time(&t); - - char *addr_string = addr_tuple4_to_str(&inner_addr); - TFE_LOG_ERROR(g_default_logger, "%s: session:%s, time:%s", LOG_TAG_PKTIO, addr_string, ctime(&t)); - free(addr_string); + TFE_LOG_ERROR(g_default_logger, "%s: session:%lu, time:%s %s", LOG_TAG_PKTIO, session_id, ctime(&t), info); } // return 0 : not keepalive packet @@ -173,6 +192,38 @@ static int is_downstream_keepalive_packet(marsio_buff_t *rx_buff) } } +static int tfe_tap_write_per_thread(int tap_fd, const char *data, int data_len, void *logger) +{ + int ret = write(tap_fd, data, data_len); + if (ret != data_len) + { + TFE_LOG_ERROR(g_default_logger, "%s: need send %dB, only send %dB, aborting: %s", LOG_TAG_PKTIO, data_len, ret, strerror(errno)); + } + + return ret; +} + +static struct session_ctx *session_ctx_new() +{ + struct session_ctx *ctx = (struct session_ctx *)calloc(1, sizeof(struct session_ctx)); + assert(ctx != NULL); + return ctx; +} + +static void session_ctx_free(struct session_ctx *ctx) +{ + if (ctx) + { + if (ctx->cmsg) + { + tfe_cmsg_destroy(ctx->cmsg); + } + + free(ctx); + ctx = 0; + } +} + static void session_value_free_cb(void *ctx) { struct session_ctx *s_ctx = (struct session_ctx *)ctx; @@ -659,10 +710,54 @@ static int tcp_restore_set_from_pkg(struct addr_tuple4 *tuple4, struct tcp_resto // return -1 : error static int packet_io_config(const char *profile, struct config *config) { + int ret = 0; + + MESA_load_profile_int_def(profile, "PACKET_IO", "bypass_all_traffic", (int *)&config->bypass_all_traffic, 0); MESA_load_profile_int_def(profile, "PACKET_IO", "rx_burst_max", (int *)&(config->rx_burst_max), 1); MESA_load_profile_string_nodef(profile, "PACKET_IO", "app_symbol", config->app_symbol, sizeof(config->app_symbol)); MESA_load_profile_string_nodef(profile, "PACKET_IO", "dev_nf_interface", config->dev_nf_interface, sizeof(config->dev_nf_interface)); + MESA_load_profile_string_def(profile, "PACKET_IO", "tap_name", config->dev_tap, sizeof(config->dev_tap), "tap0"); + MESA_load_profile_int_nodef(profile, "PACKET_IO", "tap_allow_mutilthread", &config->tap_allow_mutilthread); + MESA_load_profile_string_nodef(profile, "PACKET_IO", "bpf_obj", config->bpf_obj, sizeof(config->bpf_obj)); + MESA_load_profile_int_nodef(profile, "PACKET_IO", "bpf_debug_log", (int *)&config->bpf_debug_log); + MESA_load_profile_int_nodef(profile, "PACKET_IO", "bpf_hash_mode", (int *)&config->bpf_hash_mode); + MESA_load_profile_int_nodef(profile, "PACKET_IO", "tap_rps_enable", &config->tap_rps_enable); + MESA_load_profile_string_nodef(profile, "PACKET_IO", "tap_rps_mask", config->tap_rps_mask, sizeof(config->tap_rps_mask)); + + MESA_load_profile_int_nodef(profile, "PACKET_IO", "enable_iouring", &config->enable_iouring); + MESA_load_profile_int_nodef(profile, "PACKET_IO", "enable_debuglog", &config->enable_debuglog); + MESA_load_profile_int_nodef(profile, "PACKET_IO", "ring_size", &config->ring_size); + MESA_load_profile_int_nodef(profile, "PACKET_IO", "buff_size", &config->buff_size); + MESA_load_profile_int_nodef(profile, "PACKET_IO", "flags", &config->flags); + MESA_load_profile_int_nodef(profile, "PACKET_IO", "sq_thread_idle", &config->sq_thread_idle); + + MESA_load_profile_string_def(profile, "traffic_steering", "device_client", config->dev_tap_c, sizeof(config->dev_tap_c), "tap_c"); + MESA_load_profile_string_def(profile, "traffic_steering", "device_server", config->dev_tap_s, sizeof(config->dev_tap_s), "tap_s"); + + char src_mac_addr[18] = {0}; + ret = MESA_load_profile_string_nodef(profile, "PACKET_IO", "src_mac_addr", src_mac_addr, sizeof(src_mac_addr)); + if(ret < 0){ + TFE_LOG_ERROR(g_default_logger, "%s: invalid src_mac_addr: src_mac_addr not set, profile = %s, section = PACKET_IO", LOG_TAG_PKTIO, profile); + return -1; + } + str_to_mac(src_mac_addr, config->src_mac); + ret = get_mac_by_device_name(config->dev_tap, config->tap_mac); + if (ret != 0) { + TFE_LOG_ERROR(g_default_logger, "%s: invalid tap_name: unable get %s mac", LOG_TAG_PKTIO, config->dev_tap); + return -1; + } + ret = get_mac_by_device_name(config->dev_tap_c, config->tap_c_mac); + if (ret != 0) { + TFE_LOG_ERROR(g_default_logger, "%s: invalid device_client: unable get %s mac", LOG_TAG_PKTIO, config->dev_tap_c); + return -1; + } + ret = get_mac_by_device_name(config->dev_tap_s, config->tap_s_mac); + if (ret != 0) { + TFE_LOG_ERROR(g_default_logger, "%s: invalid device_server: unable get %s mac", LOG_TAG_PKTIO, config->dev_tap_s); + return -1; + } + if (config->rx_burst_max > RX_BURST_MAX) { TFE_LOG_ERROR(g_default_logger, "%s: invalid rx_burst_max, exceeds limit %d", LOG_TAG_PKTIO, RX_BURST_MAX); @@ -685,6 +780,22 @@ static int packet_io_config(const char *profile, struct config *config) TFE_LOG_DEBUG(g_default_logger, "%s: PACKET_IO->rx_burst_max : %d", LOG_TAG_PKTIO, config->rx_burst_max); TFE_LOG_DEBUG(g_default_logger, "%s: PACKET_IO->app_symbol : %s", LOG_TAG_PKTIO, config->app_symbol); TFE_LOG_DEBUG(g_default_logger, "%s: PACKET_IO->dev_nf_interface : %s", LOG_TAG_PKTIO, config->dev_nf_interface); + TFE_LOG_DEBUG(g_default_logger, "%s: PACKET_IO->tap_name : %s", LOG_TAG_PKTIO, config->tap_rps_mask); + TFE_LOG_DEBUG(g_default_logger, "%s: PACKET_IO->tap_allow_mutilthread : %d", LOG_TAG_PKTIO, config->tap_allow_mutilthread); + TFE_LOG_DEBUG(g_default_logger, "%s: PACKET_IO->bpf_obj : %s", LOG_TAG_PKTIO, config->bpf_obj); + TFE_LOG_DEBUG(g_default_logger, "%s: PACKET_IO->bpf_debug_log : %d", LOG_TAG_PKTIO, config->bpf_debug_log); + TFE_LOG_DEBUG(g_default_logger, "%s: PACKET_IO->bpf_hash_mode : %d", LOG_TAG_PKTIO, config->bpf_hash_mode); + TFE_LOG_DEBUG(g_default_logger, "%s: PACKET_IO->tap_rps_enable : %d", LOG_TAG_PKTIO, config->tap_rps_enable); + TFE_LOG_DEBUG(g_default_logger, "%s: PACKET_IO->tap_rps_mask : %s", LOG_TAG_PKTIO, config->tap_rps_mask); + TFE_LOG_DEBUG(g_default_logger, "%s: PACKET_IO->enable_iouring : %d", LOG_TAG_PKTIO, config->enable_iouring); + TFE_LOG_DEBUG(g_default_logger, "%s: PACKET_IO->enable_debuglog : %d", LOG_TAG_PKTIO, config->enable_debuglog); + TFE_LOG_DEBUG(g_default_logger, "%s: PACKET_IO->ring_size : %d", LOG_TAG_PKTIO, config->ring_size); + TFE_LOG_DEBUG(g_default_logger, "%s: PACKET_IO->buff_size : %d", LOG_TAG_PKTIO, config->buff_size); + TFE_LOG_DEBUG(g_default_logger, "%s: PACKET_IO->flags : %d", LOG_TAG_PKTIO, config->flags); + TFE_LOG_DEBUG(g_default_logger, "%s: PACKET_IO->sq_thread_idle : %d", LOG_TAG_PKTIO, config->sq_thread_idle); + TFE_LOG_DEBUG(g_default_logger, "%s: PACKET_IO->device_client : %s", LOG_TAG_PKTIO, config->dev_tap_c); + TFE_LOG_DEBUG(g_default_logger, "%s: PACKET_IO->device_server : %s", LOG_TAG_PKTIO, config->dev_tap_s); + TFE_LOG_DEBUG(g_default_logger, "%s: PACKET_IO->src_mac_addr : %s", LOG_TAG_PKTIO, src_mac_addr); return 0; } @@ -826,28 +937,169 @@ static void packet_io_dump_metadata(marsio_buff_t *tx_buff, struct metadata *met /* { - "tsync": "1.0", + "tsync": "2.0", "session_id": "123456789", "state": "active", "method": "log_update", "params": { - "sf_profile_ids": [ - 2, - 3, - 4, - 5, - 6, - 7 - ] + "proxy": { + "ssl_intercept_info": { + mpack array + } + } } } */ static void send_event_log(struct session_ctx *s_ctx, int thread_seq, void *ctx) { struct acceptor_thread_ctx *thread = (struct acceptor_thread_ctx *)ctx; - struct acceptor_ctx *acceptor_ctx = thread->ref_acceptor_ctx; + struct acceptor_kni_v4 *acceptor_ctx = thread->ref_acceptor_ctx; struct packet_io *packet_io = thread->ref_io; + char *data; + size_t size; + mpack_writer_t writer; + mpack_writer_init_growable(&writer, &data, &size); + + mpack_build_map(&writer); + + mpack_write_cstr(&writer, "tsync"); + mpack_write_cstr(&writer, "2.0"); + + mpack_write_cstr(&writer, "session_id"); + mpack_write_u64(&writer, s_ctx->session_id); + + mpack_write_cstr(&writer, "state"); + mpack_write_cstr(&writer, "active"); + + mpack_write_cstr(&writer, "method"); + mpack_write_cstr(&writer, "log_update"); + + mpack_write_cstr(&writer, "params"); + mpack_build_map(&writer); + + mpack_write_cstr(&writer, "proxy"); + mpack_build_map(&writer); + + mpack_write_cstr(&writer, "ssl_intercept_info"); + mpack_build_array(&writer); // cmsg value begin + + int ret = 0; + uint8_t ssl_intercept_status = 0; + uint16_t length = 0; + ret = tfe_cmsg_get_value(s_ctx->cmsg, TFE_CMSG_SSL_INTERCEPT_STATE, (unsigned char *)&ssl_intercept_status, sizeof(ssl_intercept_status), &length); + if (ret < 0) + { + TFE_LOG_ERROR(g_default_logger, "failed at fetch ssl intercept state from cmsg: %s", strerror(-ret)); + return; + } + + uint64_t ssl_upstream_latency = 0; + ret = tfe_cmsg_get_value(s_ctx->cmsg, TFE_CMSG_SSL_SERVER_SIDE_LATENCY, (unsigned char *)&ssl_upstream_latency, sizeof(ssl_upstream_latency), &length); + if (ret < 0) + { + TFE_LOG_ERROR(g_default_logger, "failed at fetch ssl upstream latency from cmsg: %s", strerror(-ret)); + return; + } + + uint64_t ssl_downstream_latency = 0; + ret = tfe_cmsg_get_value(s_ctx->cmsg, TFE_CMSG_SSL_CLIENT_SIDE_LATENCY, (unsigned char *)&ssl_downstream_latency, sizeof(ssl_downstream_latency), &length); + if (ret < 0) + { + TFE_LOG_ERROR(g_default_logger, "failed at fetch ssl downstream latency from cmsg: %s", strerror(-ret)); + return; + } + + char ssl_upstream_version[64] = {0}; + uint16_t ssl_upstream_version_length = 0; + ret = tfe_cmsg_get_value(s_ctx->cmsg, TFE_CMSG_SSL_SERVER_SIDE_VERSION, (unsigned char *)ssl_upstream_version, sizeof(ssl_upstream_version), &length); + if (ret < 0) + { + TFE_LOG_ERROR(g_default_logger, "failed at fetch ssl upstream version from cmsg: %s", strerror(-ret)); + return; + } + + char ssl_downstream_version[64] = {0}; + uint16_t ssl_downstream_version_length = 0; + ret = tfe_cmsg_get_value(s_ctx->cmsg, TFE_CMSG_SSL_CLIENT_SIDE_VERSION, (unsigned char *)ssl_downstream_version, sizeof(ssl_downstream_version), &ssl_downstream_version_length); + if (ret < 0) + { + TFE_LOG_ERROR(g_default_logger, "failed at fetch ssl downstream version from cmsg: %s", strerror(-ret)); + return; + } + + uint8_t ssl_pinning_state = 0; + ret = tfe_cmsg_get_value(s_ctx->cmsg, TFE_CMSG_SSL_PINNING_STATE, (unsigned char *)&ssl_pinning_state, sizeof(ssl_pinning_state), &length); + if (ret < 0) + { + TFE_LOG_ERROR(g_default_logger, "failed at fetch ssl pinning state from cmsg: %s", strerror(-ret)); + return; + } + + uint8_t ssl_cert_verify = 0; + ret = tfe_cmsg_get_value(s_ctx->cmsg, TFE_CMSG_SSL_CERT_VERIFY, (unsigned char *)&ssl_cert_verify, sizeof(ssl_cert_verify), &length); + if (ret < 0) + { + TFE_LOG_ERROR(g_default_logger, "failed at fetch ssl cert verify from cmsg: %s", strerror(-ret)); + return; + } + + char ssl_error[64] = {0}; + uint16_t ssl_error_length = 0; + ret = tfe_cmsg_get_value(s_ctx->cmsg, TFE_CMSG_SSL_ERROR, (unsigned char *)ssl_error, sizeof(ssl_error), &ssl_error_length); + if (ret < 0) + { + TFE_LOG_ERROR(g_default_logger, "failed at fetch ssl error from cmsg: %s", strerror(-ret)); + return; + } + + char ssl_passthrough_reason[32] = {0}; + uint16_t ssl_passthrough_reason_length = 0; + ret = tfe_cmsg_get_value(s_ctx->cmsg, TFE_CMSG_SSL_PASSTHROUGH_REASON, (unsigned char *)ssl_passthrough_reason, sizeof(ssl_passthrough_reason), &ssl_passthrough_reason_length); + if (ret < 0) + { + TFE_LOG_ERROR(g_default_logger, "failed at fetch ssl passthrough reason from cmsg: %s", strerror(-ret)); + return; + } + + mpack_write_u8(&writer, ssl_intercept_status); + mpack_write_u64(&writer, ssl_upstream_latency); + mpack_write_u64(&writer, ssl_downstream_latency); + mpack_write_str(&writer, ssl_upstream_version, ssl_upstream_version_length); + mpack_write_str(&writer, ssl_downstream_version, ssl_downstream_version_length); + mpack_write_u8(&writer, ssl_pinning_state); + mpack_write_u8(&writer, ssl_cert_verify); + mpack_write_str(&writer, ssl_error, ssl_error_length); + mpack_write_str(&writer, ssl_passthrough_reason, ssl_passthrough_reason_length); + mpack_complete_array(&writer); + mpack_complete_map(&writer); + + mpack_complete_map(&writer); + + mpack_complete_map(&writer); + + // marsio_buff_t *tx_buffs[1]; + // char *raw_packet_header_data = session_ctx->ctrl_meta->raw_data; + // int raw_packet_header_len = session_ctx->ctrl_meta->l7offset; + // marsio_buff_malloc_global(packet_io->instance, tx_buffs, 1, 0, thread_index); + // char *dst = marsio_buff_append(tx_buffs[0], raw_packet_header_len + size); + // memcpy(dst, raw_packet_header_data, raw_packet_header_len); + // memcpy(dst + raw_packet_header_len, data, size); + + // struct metadata meta = {0}; + // meta.session_id = session_ctx->session_id; + // meta.l7offset = raw_packet_header_len; + // meta.is_ctrl_pkt = 1; + // meta.sids.num = 1; + // meta.sids.elems[0] = sce_ctx->firewall_sids; + // route_ctx_copy(&meta.route_ctx, &session_ctx->ctrl_meta->route_ctx); + // mbuff_set_metadata(tx_buffs[0], &meta); + // int nsend = marsio_buff_datalen(tx_buffs[0]); + // marsio_send_burst(packet_io->dev_nf_interface.mr_path, thread_index, tx_buffs, 1); + +end: + mpack_writer_destroy(&writer); + free(data); return; } @@ -856,12 +1108,10 @@ static void send_event_log(struct session_ctx *s_ctx, int thread_seq, void *ctx) static int handle_session_opening(struct metadata *meta, struct ctrl_pkt_parser *parser, int thread_seq, void *ctx) { uint8_t *iptmp = NULL; - int ret = 0; int fd_downstream = 0; int fd_upstream = 0; int fd_fake_c = 0; int fd_fake_s = 0; - uint64_t rule_id = 0; uint16_t size = 0; char *addr_str = NULL; @@ -878,7 +1128,7 @@ static int handle_session_opening(struct metadata *meta, struct ctrl_pkt_parser struct sockaddr_in *in_addr_server = (struct sockaddr_in *)&restore_info.server.addr; struct acceptor_thread_ctx *thread = (struct acceptor_thread_ctx *)ctx; - struct acceptor_ctx *acceptor_ctx = thread->ref_acceptor_ctx; + struct packet_io *packet_io = thread->ref_io; struct raw_pkt_parser raw_parser; raw_packet_parser_init(&raw_parser, meta->session_id, LAYER_TYPE_ALL, 8); @@ -941,7 +1191,7 @@ static int handle_session_opening(struct metadata *meta, struct ctrl_pkt_parser free(addr_str); - fd_upstream = tfe_tcp_restore_fd_create(&(restore_info.client), &(restore_info.server), thread->ref_tap_config->tap_device, 0x65); + fd_upstream = tfe_tcp_restore_fd_create(&(restore_info.client), &(restore_info.server), packet_io->config.dev_tap, 0x65); if (fd_upstream < 0) { TFE_LOG_ERROR(g_default_logger, "Failed at tcp_restore_fd_create(UPSTREAM)"); @@ -949,7 +1199,7 @@ static int handle_session_opening(struct metadata *meta, struct ctrl_pkt_parser } // tcp repair S2C - fd_downstream = tfe_tcp_restore_fd_create(&(restore_info.server), &(restore_info.client), thread->ref_tap_config->tap_device, 0x65); + fd_downstream = tfe_tcp_restore_fd_create(&(restore_info.server), &(restore_info.client), packet_io->config.dev_tap, 0x65); if (fd_downstream < 0) { TFE_LOG_ERROR(g_default_logger, "Failed at tcp_restore_fd_create(DOWNSTREAM)"); @@ -1080,7 +1330,7 @@ static int handle_session_closing(struct metadata *meta, struct ctrl_pkt_parser static int handle_session_resetall(struct metadata *meta, struct ctrl_pkt_parser *parser, int thread_seq, void *ctx) { struct acceptor_thread_ctx *thread = (struct acceptor_thread_ctx *)ctx; - struct acceptor_ctx *acceptor_ctx = thread->ref_acceptor_ctx; + struct acceptor_kni_v4 *acceptor_ctx = thread->ref_acceptor_ctx; TFE_LOG_ERROR(g_default_logger, "%s: session %lu resetall: notification clears all session tables !!!", LOG_TAG_PKTIO, meta->session_id); @@ -1098,7 +1348,7 @@ static int handle_session_resetall(struct metadata *meta, struct ctrl_pkt_parser static int handle_control_packet(struct packet_io *handle, marsio_buff_t *rx_buff, int thread_seq, void *ctx) { struct acceptor_thread_ctx *thread = (struct acceptor_thread_ctx *)ctx; - struct acceptor_ctx *acceptor_ctx = thread->ref_acceptor_ctx; + struct acceptor_kni_v4 *acceptor_ctx = thread->ref_acceptor_ctx; struct global_metrics *g_metrics = thread->ref_metrics; struct metadata meta; @@ -1151,10 +1401,8 @@ static int handle_control_packet(struct packet_io *handle, marsio_buff_t *rx_buf static int handle_raw_packet_from_nf(struct packet_io *handle, marsio_buff_t *rx_buff, int thread_seq, void *ctx) { struct acceptor_thread_ctx *thread = (struct acceptor_thread_ctx *)ctx; - struct acceptor_ctx *acceptor_ctx = thread->ref_acceptor_ctx; + struct packet_io *packet_io = thread->ref_io; struct global_metrics *g_metrics = thread->ref_metrics; - struct addr_tuple4 inner_addr; - memset(&inner_addr, 0, sizeof(struct addr_tuple4)); int raw_len = marsio_buff_datalen(rx_buff); char *raw_data = marsio_buff_mtod(rx_buff); @@ -1169,6 +1417,7 @@ static int handle_raw_packet_from_nf(struct packet_io *handle, marsio_buff_t *rx marsio_send_burst(handle->dev_nf_interface.mr_path, thread_seq, &rx_buff, 1); return -1; } + time_echo(meta.session_id, "raw pkg from nf start"); struct session_node *node = session_table_search_by_id(thread->session_table, meta.session_id); if (node == NULL) @@ -1186,6 +1435,7 @@ static int handle_raw_packet_from_nf(struct packet_io *handle, marsio_buff_t *rx { metadata_deep_copy(s_ctx->raw_meta_e2i, &meta); } + s_ctx->raw_meta_e2i->sids = meta.sids; } else { @@ -1193,14 +1443,15 @@ static int handle_raw_packet_from_nf(struct packet_io *handle, marsio_buff_t *rx { metadata_deep_copy(s_ctx->raw_meta_i2e, &meta); } + s_ctx->raw_meta_i2e->sids = meta.sids; } if (meta.is_decrypted) { // c2s if (meta.is_e2i_dir == s_ctx->c2s_info.is_e2i_dir) { - add_ether_header(raw_data, acceptor_ctx->config->src_mac, acceptor_ctx->config->tap_s_mac); - if (acceptor_ctx->config->enable_iouring) { + add_ether_header(raw_data, packet_io->config.tap_c_mac, packet_io->config.tap_s_mac); + if (packet_io->config.enable_iouring) { io_uring_submit_write_entry(thread->tap_ctx->io_uring_s, raw_data, raw_len); } else { @@ -1210,8 +1461,8 @@ static int handle_raw_packet_from_nf(struct packet_io *handle, marsio_buff_t *rx } // s2c else { - add_ether_header(raw_data, acceptor_ctx->config->src_mac, acceptor_ctx->config->tap_c_mac); - if (acceptor_ctx->config->enable_iouring) { + add_ether_header(raw_data, packet_io->config.tap_s_mac, packet_io->config.tap_c_mac); + if (packet_io->config.enable_iouring) { io_uring_submit_write_entry(thread->tap_ctx->io_uring_c, raw_data, raw_len); } else { @@ -1229,8 +1480,8 @@ static int handle_raw_packet_from_nf(struct packet_io *handle, marsio_buff_t *rx buff_size = raw_len - ((char *)payload - meta->raw_data) + sizeof(struct ethhdr) + sizeof(struct ip) + sizeof(struct tcphdr); #endif // send to tap0 - add_ether_header(raw_data, acceptor_ctx->config->src_mac, acceptor_ctx->config->tap_mac); - if (acceptor_ctx->config->enable_iouring) { + add_ether_header(raw_data, packet_io->config.src_mac, packet_io->config.tap_mac); + if (packet_io->config.enable_iouring) { io_uring_submit_write_entry(thread->tap_ctx->io_uring_fd, raw_data, raw_len); } else { @@ -1239,6 +1490,7 @@ static int handle_raw_packet_from_nf(struct packet_io *handle, marsio_buff_t *rx throughput_metrics_inc(&g_metrics->tap_pkt_tx, 1, raw_len); } marsio_buff_free(handle->instance, &rx_buff, 1, 0, thread_seq); + time_echo(meta.session_id, "raw pkg from nf end"); return 0; } @@ -1246,6 +1498,91 @@ static int handle_raw_packet_from_nf(struct packet_io *handle, marsio_buff_t *rx /****************************************************************************** * EXTERN ******************************************************************************/ +int is_enable_iouring(struct packet_io *handle) +{ + return handle->config.enable_iouring; +} + +void tfe_tap_ctx_destory(struct tap_ctx *handler) +{ + if (handler) { + io_uring_instance_destory(handler->io_uring_fd); + io_uring_instance_destory(handler->io_uring_c); + io_uring_instance_destory(handler->io_uring_s); + if (handler->eventfd > 0) + close(handler->eventfd); + if (handler->eventfd_c > 0) + close(handler->eventfd_c); + if (handler->eventfd_s > 0) + close(handler->eventfd_s); + tap_close(handler->tap_fd); + tap_close(handler->tap_c); + tap_close(handler->tap_s); + + free(handler); + } +} + +struct tap_ctx *tfe_tap_ctx_create(void *ctx) +{ + int ret = 0; + struct acceptor_thread_ctx *thread_ctx = (struct acceptor_thread_ctx *)ctx; + struct acceptor_kni_v4 *acceptor_ctx = thread_ctx->ref_acceptor_ctx; + struct packet_io *packet_io = acceptor_ctx->io; + struct tap_ctx *tap_ctx = (struct tap_ctx *)calloc(1, sizeof(struct tap_ctx)); + assert(tap_ctx != NULL); + + tap_ctx->tap_fd = tap_open(packet_io->config.dev_tap, IFF_TAP | IFF_NO_PI | IFF_MULTI_QUEUE); + tap_ctx->tap_c = tap_open(packet_io->config.dev_tap_c, IFF_TAP | IFF_NO_PI | IFF_MULTI_QUEUE); + tap_ctx->tap_s = tap_open(packet_io->config.dev_tap_s, IFF_TAP | IFF_NO_PI | IFF_MULTI_QUEUE); + + tap_up_link(packet_io->config.dev_tap); + tap_up_link(packet_io->config.dev_tap_c); + tap_up_link(packet_io->config.dev_tap_s); + + // fcntl(2) EFD_NONBLOCK 不生效 + tap_ctx->eventfd = eventfd(0, EFD_NONBLOCK); + tap_ctx->eventfd_c = eventfd(0, EFD_NONBLOCK); + tap_ctx->eventfd_s = eventfd(0, EFD_NONBLOCK); + + if (packet_io->config.enable_iouring) { + bpf_obj_attach(packet_io->config.tap_bpf_ctx, tap_ctx->tap_fd); + bpf_obj_attach(packet_io->config.tap_bpf_ctx, tap_ctx->tap_c); + bpf_obj_attach(packet_io->config.tap_bpf_ctx, tap_ctx->tap_s); + + tap_ctx->io_uring_fd = io_uring_instance_create(tap_ctx->tap_fd, tap_ctx->eventfd, packet_io->config.ring_size, packet_io->config.buff_size, packet_io->config.flags, packet_io->config.sq_thread_idle, packet_io->config.enable_debuglog); + if (tap_ctx->io_uring_fd == NULL) + goto error_out; + tap_ctx->io_uring_c = io_uring_instance_create(tap_ctx->tap_c, tap_ctx->eventfd_c, packet_io->config.ring_size, packet_io->config.buff_size, packet_io->config.flags, packet_io->config.sq_thread_idle, packet_io->config.enable_debuglog); + if (tap_ctx->io_uring_c == NULL) + goto error_out; + tap_ctx->io_uring_s = io_uring_instance_create(tap_ctx->tap_s, tap_ctx->eventfd_s, packet_io->config.ring_size, packet_io->config.buff_size, packet_io->config.flags, packet_io->config.sq_thread_idle, packet_io->config.enable_debuglog); + if (tap_ctx->io_uring_s == NULL) + goto error_out; + + marsio_poll_register_eventfd(packet_io->instance, tap_ctx->eventfd, thread_ctx->thread_index); + marsio_poll_register_eventfd(packet_io->instance, tap_ctx->eventfd_c, thread_ctx->thread_index); + marsio_poll_register_eventfd(packet_io->instance, tap_ctx->eventfd_s, thread_ctx->thread_index); + } + + if (packet_io->config.tap_rps_enable) + { + ret = tap_set_rps(packet_io->config.dev_tap, thread_ctx->thread_index, packet_io->config.tap_rps_mask); + if (ret != 0) + goto error_out; + ret = tap_set_rps(packet_io->config.dev_tap_c, thread_ctx->thread_index, packet_io->config.tap_rps_mask); + if (ret != 0) + goto error_out; + ret = tap_set_rps(packet_io->config.dev_tap_s, thread_ctx->thread_index, packet_io->config.tap_rps_mask); + if (ret != 0) + goto error_out; + } + + return tap_ctx; +error_out: + tfe_tap_ctx_destory(tap_ctx); + return NULL; +} int packet_io_thread_init(struct packet_io *handle, struct acceptor_thread_ctx *thread_ctx) { @@ -1287,6 +1624,12 @@ void packet_io_destory(struct packet_io *handle) handle->instance = NULL; } + if (handle->config.tap_bpf_ctx) + { + bpf_obj_unload(handle->config.tap_bpf_ctx); + handle->config.tap_bpf_ctx = NULL; + } + free(handle); handle = NULL; } @@ -1304,6 +1647,19 @@ struct packet_io *packet_io_create(const char *profile, int thread_num, cpu_set_ goto error_out; } + if (handle->config.tap_allow_mutilthread) + { + handle->config.tap_bpf_ctx = bpf_obj_load(handle->config.bpf_obj, thread_num, handle->config.bpf_hash_mode, handle->config.bpf_debug_log); + if (handle->config.tap_bpf_ctx == NULL) + { + goto error_out; + } + } + else if (thread_num > 1){ + TFE_LOG_ERROR(g_default_logger, "%s: under tap mode, when disable tap_allow_mutilthread, only support one work thread.", LOG_TAG_PKTIO); + goto error_out; + } + handle->instance = marsio_create(); if (handle->instance == NULL) { @@ -1366,6 +1722,17 @@ int packet_io_polling_nf_interface(struct packet_io *handle, int thread_seq, voi return 0; } + if (handle->config.bypass_all_traffic == 1) + { + for (int i = 0; i < nr_recv; i++) + { + int raw_len = marsio_buff_datalen(rx_buffs[i]); + } + + marsio_send_burst(handle->dev_nf_interface.mr_path, thread_seq, rx_buffs, nr_recv); + return nr_recv; + } + for (int j = 0; j < nr_recv; j++) { marsio_buff_t *rx_buff = rx_buffs[j]; @@ -1397,7 +1764,7 @@ int packet_io_polling_nf_interface(struct packet_io *handle, int thread_seq, voi void handle_decryption_packet_from_tap(const char *data, int len, void *args) { struct acceptor_thread_ctx *thread = (struct acceptor_thread_ctx *)args; - struct acceptor_ctx *acceptor_ctx = thread->ref_acceptor_ctx; + struct acceptor_kni_v4 *acceptor_ctx = thread->ref_acceptor_ctx; struct packet_io *packet_io = thread->ref_io; struct addr_tuple4 inner_addr; @@ -1416,6 +1783,7 @@ void handle_decryption_packet_from_tap(const char *data, int len, void *args) return; } struct session_ctx *s_ctx = (struct session_ctx *)node->val_data; + time_echo(s_ctx->session_id, "decryption pkg from nf start"); marsio_buff_t *tx_buffs[1]; int alloc_ret = marsio_buff_malloc_device(packet_io->dev_nf_interface.mr_dev, tx_buffs, 1, 0, thread->thread_index); @@ -1435,8 +1803,9 @@ void handle_decryption_packet_from_tap(const char *data, int len, void *args) meta.is_decrypted = SET_TRAFFIC_IS_DECRYPTED(0); meta.is_ctrl_pkt = 0; meta.l7offset = 0; - meta.sids.num = 1; + meta.sids.num = 2; meta.sids.elems[0] = acceptor_ctx->sce_sids; + meta.sids.elems[1] = acceptor_ctx->proxy_sids; if (memcmp(&inner_addr, &s_ctx->c2s_info.tuple4, sizeof(struct addr_tuple4)) == 0) meta.is_e2i_dir = s_ctx->c2s_info.is_e2i_dir; @@ -1453,6 +1822,7 @@ void handle_decryption_packet_from_tap(const char *data, int len, void *args) } packet_io_set_metadata(tx_buffs[0], &meta); marsio_send_burst(packet_io->dev_nf_interface.mr_path, thread->thread_index, tx_buffs, 1); + time_echo(s_ctx->session_id, "decryption pkg from nf end"); } void handle_raw_packet_from_tap(const char *data, int len, void *args) @@ -1460,7 +1830,7 @@ void handle_raw_packet_from_tap(const char *data, int len, void *args) char *src_mac = NULL; char *dst_mac = NULL; struct acceptor_thread_ctx *thread = (struct acceptor_thread_ctx *)args; - struct acceptor_ctx *acceptor_ctx = thread->ref_acceptor_ctx; + struct acceptor_kni_v4 *acceptor_ctx = thread->ref_acceptor_ctx; struct packet_io *packet_io = thread->ref_io; struct addr_tuple4 inner_addr; @@ -1479,6 +1849,7 @@ void handle_raw_packet_from_tap(const char *data, int len, void *args) return; } struct session_ctx *s_ctx = (struct session_ctx *)node->val_data; + time_echo(s_ctx->session_id, "raw pkg from tap start"); marsio_buff_t *tx_buffs[1]; int alloc_ret = marsio_buff_malloc_device(packet_io->dev_nf_interface.mr_dev, tx_buffs, 1, 0, thread->thread_index); @@ -1519,7 +1890,6 @@ void handle_raw_packet_from_tap(const char *data, int len, void *args) } else { - // raw_meta_i2e->raw_data maybe is null sids_copy(&meta.sids, &s_ctx->raw_meta_i2e->sids); route_ctx_copy(&meta.route_ctx, &s_ctx->raw_meta_i2e->route_ctx); } @@ -1528,4 +1898,5 @@ void handle_raw_packet_from_tap(const char *data, int len, void *args) packet_io_set_metadata(tx_buffs[0], &meta); add_ether_header(dst, src_mac, dst_mac); marsio_send_burst(packet_io->dev_nf_interface.mr_path, thread->thread_index, tx_buffs, 1); + time_echo(s_ctx->session_id, "raw pkg from tap end"); } diff --git a/common/src/tfe_tap_rss.cpp b/common/src/tfe_tap_rss.cpp deleted file mode 100644 index 61286e8..0000000 --- a/common/src/tfe_tap_rss.cpp +++ /dev/null @@ -1,389 +0,0 @@ - -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include -#include -#include -#include -#include -#include - -#if (SUPPORT_BPF) -#include "../../bpf/bpf_conf_user.h" -#include -#include -#endif - -#include "tfe_acceptor_kni.h" -#include "tfe_tap_rss.h" -#include "tfe_utils.h" - -#ifndef TUN_PATH -#define TUN_PATH "/dev/net/tun" -#endif - -struct bpf_ctx -{ - int bpf_prog_fd; - int bpf_map_fd; - - char bpf_file[1024]; -#if (SUPPORT_BPF) - struct bpf_object *bpf_obj; - bpf_conf_t bpf_conf; -#endif -}; - -int tfe_tap_get_bpf_prog_fd(struct bpf_ctx *ctx) -{ - if (ctx) - { - return ctx->bpf_prog_fd; - } - else - { - return -1; - } -} - -#if (SUPPORT_BPF) -void tfe_tap_global_unload_rss_bpf(struct bpf_ctx *ctx) -{ - if (ctx) - { - if (ctx->bpf_prog_fd > 0) - { - close(ctx->bpf_prog_fd); - } - - if (ctx->bpf_obj) - { - bpf_object__close(ctx->bpf_obj); - ctx->bpf_obj = NULL; - } - - free(ctx); - ctx = NULL; - } -} -#else -void tfe_tap_global_unload_rss_bpf(struct bpf_ctx *ctx) -{ -} -#endif - -/* - * bpf_queue_num : worker thread number - * bpf_default_queue : -1: for disable(only use for debug, rss to one queue) - * bpf_hash_mode : 2: hash with src/dst addr - * 4: hash with src/dst addr and src/dst port - * bpf_debug_log : 0 for disable(only use for debug, printf bpf debug log) - */ -#if (SUPPORT_BPF) -struct bpf_ctx *tfe_tap_global_load_rss_bpf(const char *bpf_obj_file, uint32_t bpf_queue_num, uint32_t bpf_hash_mode, uint32_t bpf_debug_log, void *logger) -{ - struct bpf_ctx *ctx = (struct bpf_ctx *)calloc(1, sizeof(struct bpf_ctx)); - strncpy(ctx->bpf_file, bpf_obj_file, strlen(bpf_obj_file)); - - bpf_conf_set_debug_log(&ctx->bpf_conf, bpf_debug_log); - bpf_conf_set_hash_mode(&ctx->bpf_conf, bpf_hash_mode); - bpf_conf_set_queue_num(&ctx->bpf_conf, bpf_queue_num); - - if (bpf_prog_load(ctx->bpf_file, BPF_PROG_TYPE_SOCKET_FILTER, &ctx->bpf_obj, &ctx->bpf_prog_fd) < 0) - { - TFE_LOG_ERROR(g_default_logger, TAP_RSS_LOG_TAG "unable to load bpf object %s, aborting: %s", ctx->bpf_file, strerror(errno)); - goto error; - } - - if (bpf_conf_update_map(&ctx->bpf_conf, ctx->bpf_obj) == -1) - { - goto error; - } - - return ctx; - -error: - tfe_tap_global_unload_rss_bpf(ctx); - - return NULL; -} -#else -struct bpf_ctx *tfe_tap_global_load_rss_bpf(const char *bpf_obj_file, uint32_t bpf_queue_num, uint32_t bpf_hash_mode, uint32_t bpf_debug_log, void *logger) -{ - TFE_LOG_ERROR(g_default_logger, TAP_RSS_LOG_TAG "not support bpf"); - return NULL; -} -#endif - -struct tap_ctx *tfe_tap_ctx_create(void *ctx) -{ - struct acceptor_thread_ctx *thread_ctx = (struct acceptor_thread_ctx *)ctx; - struct acceptor_ctx *acceptor_ctx = thread_ctx->ref_acceptor_ctx; - struct tap_ctx *tap_ctx = (struct tap_ctx *)calloc(1, sizeof(struct tap_ctx)); - assert(tap_ctx != NULL); - - tap_ctx->tap_fd = tfe_tap_open_per_thread(acceptor_ctx->config->tap_device, IFF_TAP | IFF_NO_PI | IFF_MULTI_QUEUE, tfe_tap_get_bpf_prog_fd(acceptor_ctx->config->tap_bpf_ctx), g_default_logger); - tap_ctx->tap_c = tfe_tap_open_per_thread(acceptor_ctx->config->tap_c_device, IFF_TAP | IFF_NO_PI | IFF_MULTI_QUEUE, tfe_tap_get_bpf_prog_fd(acceptor_ctx->config->tap_bpf_ctx), g_default_logger); - tap_ctx->tap_s = tfe_tap_open_per_thread(acceptor_ctx->config->tap_s_device, IFF_TAP | IFF_NO_PI | IFF_MULTI_QUEUE, tfe_tap_get_bpf_prog_fd(acceptor_ctx->config->tap_bpf_ctx), g_default_logger); - - return tap_ctx; -} - -struct tap_config *tfe_tap_config_create(const char *profile, int thread_num) -{ - int ret = 0; - int tap_allow_mutilthread = 0; - uint32_t bpf_debug_log = 0; - uint32_t bpf_hash_mode = 2; - uint32_t bpf_queue_num = thread_num; - char bpf_obj[1024] = {0}; - - struct tap_config *tap = (struct tap_config *)calloc(1, sizeof(struct tap_config)); - assert(tap != NULL); - - MESA_load_profile_int_nodef(profile, "tap", "tap_rps_enable", &tap->tap_rps_enable); - MESA_load_profile_string_def(profile, "tap", "tap_name", tap->tap_device, sizeof(tap->tap_device), "tap0"); - MESA_load_profile_string_def(profile, "traffic_steering", "device_client", tap->tap_c_device, sizeof(tap->tap_c_device), "tap_c"); - MESA_load_profile_string_def(profile, "traffic_steering", "device_server", tap->tap_s_device, sizeof(tap->tap_s_device), "tap_s"); - MESA_load_profile_int_nodef(profile, "tap", "bpf_debug_log", (int *)&bpf_debug_log); - MESA_load_profile_int_nodef(profile, "tap", "bpf_hash_mode", (int *)&bpf_hash_mode); - MESA_load_profile_string_nodef(profile, "tap", "bpf_obj", bpf_obj, sizeof(bpf_obj)); - MESA_load_profile_int_nodef(profile, "tap", "tap_allow_mutilthread", &tap_allow_mutilthread); - - MESA_load_profile_int_nodef(profile, "io_uring", "enable_iouring", &tap->enable_iouring); - MESA_load_profile_int_nodef(profile, "io_uring", "enable_debuglog", &tap->enable_debuglog); - MESA_load_profile_int_nodef(profile, "io_uring", "ring_size", &tap->ring_size); - MESA_load_profile_int_nodef(profile, "io_uring", "buff_size", &tap->buff_size); - MESA_load_profile_int_nodef(profile, "io_uring", "flags", &tap->flags); - MESA_load_profile_int_nodef(profile, "io_uring", "sq_thread_idle", &tap->sq_thread_idle); - - char src_mac_addr_str[TFE_SYMBOL_MAX]; - ret = MESA_load_profile_string_nodef(profile, "system", "src_mac_addr", src_mac_addr_str, sizeof(src_mac_addr_str)); - if(ret < 0){ - TFE_LOG_ERROR(g_default_logger, "MESA_prof_load: src_mac_addr not set, profile = %s, section = system", profile); - goto error_out; - } - str_to_mac(src_mac_addr_str, tap->src_mac); - get_mac_by_device_name(tap->tap_device, tap->tap_mac); - get_mac_by_device_name(tap->tap_c_device, tap->tap_c_mac); - get_mac_by_device_name(tap->tap_s_device, tap->tap_s_mac); - - if (tap->tap_rps_enable) - { - if (MESA_load_profile_string_nodef(profile, "tap", "tap_rps_mask", tap->tap_rps_mask, sizeof(tap->tap_rps_mask)) < 0) - { - TFE_LOG_ERROR(g_default_logger, TAP_RSS_LOG_TAG "under tap mode, when enable tap_rps_enable, tap_rps_mask is required."); - goto error_out; - } - } - - if (tap_allow_mutilthread) - { - tap->tap_bpf_ctx = tfe_tap_global_load_rss_bpf(bpf_obj, bpf_queue_num, bpf_hash_mode, bpf_debug_log, g_default_logger); - if (tap->tap_bpf_ctx == NULL) - { - goto error_out; - } - } - else if (thread_num > 1){ - TFE_LOG_ERROR(g_default_logger, TAP_RSS_LOG_TAG "under tap mode, when disable tap_allow_mutilthread, only support one work thread."); - goto error_out; - } - - return tap; - -error_out: - tfe_tap_destory(tap); - return NULL; -} - -void tfe_tap_destory(struct tap_config *tap) -{ - if (tap) - { - if (tap->tap_bpf_ctx) - { - tfe_tap_global_unload_rss_bpf(tap->tap_bpf_ctx); - tap->tap_bpf_ctx = NULL; - } - - free(tap); - tap = NULL; - } -} - -int tfe_tap_set_rps(void *local_logger, const char *tap_name, int thread_num, const char *rps_mask) -{ - char file[1024] = {0}; - - memset(file, 0, sizeof(file)); - snprintf(file, sizeof(file), "/sys/class/net/%s/queues/rx-%d/rps_cpus", tap_name, thread_num); - - FILE *fp = fopen(file, "w"); - if (fp == NULL) - { - TFE_LOG_ERROR(local_logger, "%s can't open %s, %s", TAP_RSS_LOG_TAG, file, strerror(errno)); - return -1; - } - - fwrite(rps_mask, strlen(rps_mask), 1, fp); - TFE_LOG_DEBUG(local_logger, TAP_RSS_LOG_TAG "set rps '%s' to %s", rps_mask, file); - fclose(fp); - return 0; -} - -int tfe_tap_open_per_thread(const char *tap_dev, int tap_flags, int bpf_prog_fd, void *logger) -{ - int fd = -1; - int tap_fd = -1; - int nonblock_flags = -1; - struct ifreq ifr; - - tap_fd = open(TUN_PATH, O_RDWR); - if (tap_fd == -1) - { - TFE_LOG_ERROR(g_default_logger, TAP_RSS_LOG_TAG "unable to open " TUN_PATH ", aborting: %s", strerror(errno)); - return -1; - } - - memset(&ifr, 0, sizeof(ifr)); - ifr.ifr_flags = tap_flags; - strcpy(ifr.ifr_name, tap_dev); - if (ioctl(tap_fd, TUNSETIFF, &ifr) == -1) - { - TFE_LOG_ERROR(g_default_logger, TAP_RSS_LOG_TAG "unable to attach %s, aborting: %s", tap_dev, strerror(errno)); - goto error; - } - - /* - * The TUNSETPERSIST ioctl can be used to make the TUN/TAP interface persistent. - * In this mode, the interface won't be destroyed when the last process closes the associated /dev/net/tun file descriptor. - */ - /* - if (ioctl(tap_fd, TUNSETPERSIST, 1) == -1) - { - TFE_LOG_ERROR(g_default_logger, TAP_RSS_LOG_TAG "unable to set persist on %s, aborting: %s", tap_dev, strerror(errno)); - goto error; - } - */ -#if (SUPPORT_BPF) - if (bpf_prog_fd > 0) - { - // Set bpf - if (ioctl(tap_fd, TUNSETSTEERINGEBPF, (void *)&bpf_prog_fd) == -1) - { - TFE_LOG_ERROR(g_default_logger, TAP_RSS_LOG_TAG "unable to set bpf on %s, aborting: %s", tap_dev, strerror(errno)); - goto error; - } - } -#endif - - // Set nonblock - nonblock_flags = fcntl(tap_fd, F_GETFL); - if (nonblock_flags == -1) - { - TFE_LOG_ERROR(g_default_logger, TAP_RSS_LOG_TAG "unable to get nonblock flags on %s fd, aborting: %s", tap_dev, strerror(errno)); - goto error; - } - nonblock_flags |= O_NONBLOCK; - if (fcntl(tap_fd, F_SETFL, nonblock_flags) == -1) - { - TFE_LOG_ERROR(g_default_logger, TAP_RSS_LOG_TAG "unable to set nonblock flags on %s fd, aborting: %s", tap_dev, strerror(errno)); - goto error; - } - - // Get MTU - fd = socket(PF_INET, SOCK_DGRAM, 0); - if (fd == -1) - { - TFE_LOG_ERROR(g_default_logger, TAP_RSS_LOG_TAG "unable to create socket, aborting: %s", strerror(errno)); - goto error; - } - - memset(&ifr, 0, sizeof(ifr)); - strcpy(ifr.ifr_name, tap_dev); - if (ioctl(fd, SIOCGIFMTU, &ifr) < 0) - { - TFE_LOG_ERROR(g_default_logger, TAP_RSS_LOG_TAG "unable to get MTU on %s, aborting: %s", tap_dev, strerror(errno)); - goto error; - } - - // Set eth up - if (ioctl(fd, SIOCGIFFLAGS, &ifr) == -1) - { - TFE_LOG_ERROR(g_default_logger, TAP_RSS_LOG_TAG "unable to get link status on %s, aborting: %s", tap_dev, strerror(errno)); - goto error; - } - - if ((ifr.ifr_flags & IFF_UP) == 0) - { - ifr.ifr_flags |= IFF_UP; - if (ioctl(fd, SIOCSIFFLAGS, &ifr) < 0) - { - TFE_LOG_ERROR(g_default_logger, TAP_RSS_LOG_TAG "unable to set link status on %s, aborting: %s", tap_dev, strerror(errno)); - goto error; - } - } - - TFE_LOG_INFO(logger, TAP_RSS_LOG_TAG "using tap device %s with MTU %d", tap_dev, ifr.ifr_mtu); - close(fd); - - return tap_fd; - -error: - - if (fd > 0) - { - close(fd); - fd = -1; - } - - if (tap_fd > 0) - { - close(tap_fd); - tap_fd = -1; - } - - return -1; -} - -void tfe_tap_close_per_thread(int tap_fd) -{ - if (tap_fd > 0) - { - close(tap_fd); - } -} - -int tfe_tap_read_per_thread(int tap_fd, char *buff, int buff_size, void *logger) -{ - int ret = read(tap_fd, buff, buff_size); - if (ret < 0) - { - if (errno != EWOULDBLOCK && errno != EAGAIN) - { - TFE_LOG_ERROR(g_default_logger, TAP_RSS_LOG_TAG "unable to read data from tapfd %d, aborting: %s", tap_fd, strerror(errno)); - } - } - - return ret; -} - -int tfe_tap_write_per_thread(int tap_fd, const char *data, int data_len, void *logger) -{ - int ret = write(tap_fd, data, data_len); - if (ret != data_len) - { - TFE_LOG_ERROR(g_default_logger, TAP_RSS_LOG_TAG "need send %dB, only send %dB, aborting: %s", data_len, ret, strerror(errno)); - } - - return ret; -} \ No newline at end of file diff --git a/common/src/tfe_timestamp.cpp b/common/src/tfe_timestamp.cpp deleted file mode 100644 index 4e8949d..0000000 --- a/common/src/tfe_timestamp.cpp +++ /dev/null @@ -1,65 +0,0 @@ -#include -#include - -#include -#include "tfe_timestamp.h" - -// 1 s = 1000 ms -// 1 ms = 1000 us -// 1 us = 1000 ns - -struct timestamp -{ - struct timespec timestamp; - uint64_t update_interval_ms; -}; - -struct timestamp *timestamp_new(uint64_t update_interval_ms) -{ - struct timestamp *ts = (struct timestamp *)calloc(1, sizeof(struct timestamp)); - ts->update_interval_ms = update_interval_ms; - - timestamp_update(ts); - TFE_LOG_DEBUG(g_default_logger, "%s: TIMESTAMP->update_interval_ms : %lu", LOG_TAG_TIMESTAMP, timestamp_update_interval_ms(ts)); - TFE_LOG_DEBUG(g_default_logger, "%s: TIMESTAMP->current_sec : %lu", LOG_TAG_TIMESTAMP, timestamp_get_sec(ts)); - TFE_LOG_DEBUG(g_default_logger, "%s: TIMESTAMP->current_msec : %lu", LOG_TAG_TIMESTAMP, timestamp_get_msec(ts)); - - return ts; -} - -void timestamp_free(struct timestamp *ts) -{ - if (ts) - { - free(ts); - ts = NULL; - } -} - -void timestamp_update(struct timestamp *ts) -{ - struct timespec temp; - clock_gettime(CLOCK_MONOTONIC, &temp); - ATOMIC_SET(&(ts->timestamp.tv_sec), temp.tv_sec); - ATOMIC_SET(&(ts->timestamp.tv_nsec), temp.tv_nsec); -} - -uint64_t timestamp_update_interval_ms(struct timestamp *ts) -{ - return ts->update_interval_ms; -} - -uint64_t timestamp_get_sec(struct timestamp *ts) -{ - uint64_t sec = ATOMIC_READ(&(ts->timestamp.tv_sec)); - - return sec; -} - -uint64_t timestamp_get_msec(struct timestamp *ts) -{ - uint64_t sec = ATOMIC_READ(&(ts->timestamp.tv_sec)); - uint64_t nsec = ATOMIC_READ(&(ts->timestamp.tv_nsec)); - - return sec * 1000 + nsec / 1000000; -} diff --git a/conf/tfe/tfe.conf b/conf/tfe/tfe.conf index 1f6453f..5352e72 100644 --- a/conf/tfe/tfe.conf +++ b/conf/tfe/tfe.conf @@ -4,8 +4,6 @@ enable_kni_v1=0 enable_kni_v2=0 enable_kni_v3=0 enable_kni_v4=1 -firewall_sids=1001 -service_chaining_sids=1002 # Only when (disable_coredump == 1 || (enable_breakpad == 1 && enable_breakpad_upload == 1)) is satisfied, the core will not be generated locally disable_coredump=0 @@ -23,7 +21,6 @@ cpu_affinity_mask=1-9 # LEAST_CONN = 0; ROUND_ROBIN = 1 load_balance=1 -src_mac_addr = 00:0e:c6:d6:72:c1 # for enable kni v3 [nfq] @@ -179,8 +176,8 @@ enable_steering_ssl=1 so_mask_client=17 # 34: 0x22 so_mask_server=34 -device_client=eth_client -device_server=eth_server +device_client=tap_c +device_server=tap_s http_keepalive_enable=1 http_keepalive_path="/metrics" @@ -230,20 +227,29 @@ app_name="proxy_rule_hits" # for enable kni v4 [packet_io] +packet_io_threads=8 +packet_io_cpu_affinity_mask=1-9 + +firewall_sids=1000 +proxy_sids=1001 +service_chaining_sids=1002 + # bypass_all_traffic:1 NF2NF and SF2SF bypass_all_traffic=0 + rx_burst_max=128 -app_symbol=sce +app_symbol=tfe dev_nf_interface=eth_nf_interface -[tap] +src_mac_addr = 00:0e:c6:d6:72:c1 + +# tap config tap_name=tap0 # 1.tap_allow_mutilthread=1 load bpf rss obj # 2.tap_allow_mutilthread=0 not load bpf rss obj tap_allow_mutilthread=1 -bpf_obj=/opt/tsg/sapp/plug/business/kni/bpf_tun_rss_steering.o -bpf_default_queue=-1 +bpf_obj=/opt/tsg/tfe/resource/bpf/bpf_tun_rss_steering.o # tap_bpf_debug_log: cat /sys/kernel/debug/tracing/trace_pipe bpf_debug_log=0 # 2: BPF 使用二元组分流 @@ -254,7 +260,7 @@ bpf_hash_mode=2 tap_rps_enable=1 tap_rps_mask=0,1fffffff,c0000000,00000000 -[io_uring] +# iouring config enable_iouring=1 enable_debuglog=0 ring_size=1024 diff --git a/platform/CMakeLists.txt b/platform/CMakeLists.txt index 029bdc5..d0612ff 100644 --- a/platform/CMakeLists.txt +++ b/platform/CMakeLists.txt @@ -27,7 +27,6 @@ target_link_libraries(tfe pthread dl nfnetlink MESA_field_stat fieldstat3 breakpad_mini - msgpack ${SYSTEMD_LIBRARIES}) if(ENABLE_PLUGIN_HTTP) diff --git a/platform/include/internal/acceptor_kni_v4.h b/platform/include/internal/acceptor_kni_v4.h index 8c0b5cb..3cf02ba 100644 --- a/platform/include/internal/acceptor_kni_v4.h +++ b/platform/include/internal/acceptor_kni_v4.h @@ -1,13 +1,6 @@ #pragma once struct tfe_proxy; -struct acceptor_kni_v4 -{ - struct tfe_proxy *proxy; - const char *profile; - - struct acceptor_ctx *acceptor; -}; struct acceptor_kni_v4 *acceptor_kni_v4_create(struct tfe_proxy *proxy, const char *profile, void *logger); void acceptor_kni_v4_destroy(); diff --git a/platform/src/acceptor_kni_v4.cpp b/platform/src/acceptor_kni_v4.cpp index 68a6613..8a746d7 100644 --- a/platform/src/acceptor_kni_v4.cpp +++ b/platform/src/acceptor_kni_v4.cpp @@ -6,22 +6,89 @@ #include // for NF_ACCEPT #include #include +#include +#include #include #include #include -#include #include "io_uring.h" -#include "tfe_tap_rss.h" #include "tfe_metrics.h" #include "tfe_tcp_restore.h" #include "acceptor_kni_v4.h" +#include "tap.h" +#include "tfe_packet_io.h" +#include "tfe_session_table.h" + + +static int tfe_tap_read_per_thread(int tap_fd, char *buff, int buff_size, void *logger) +{ + int ret = read(tap_fd, buff, buff_size); + if (ret < 0) + { + if (errno != EWOULDBLOCK && errno != EAGAIN) + { + TFE_LOG_ERROR(g_default_logger, "%s: unable to read data from tapfd %d, aborting: %s", LOG_TAG_PKTIO, tap_fd, strerror(errno)); + } + } + + return ret; +} + +void acceptor_ctx_destory(struct acceptor_kni_v4 * ctx) +{ + if (ctx) + { + packet_io_destory(ctx->io); + global_metrics_destory(ctx->metrics); + + free(ctx); + ctx = NULL; + } + return; +} + +struct acceptor_kni_v4 *acceptor_ctx_create(const char *profile) +{ + struct acceptor_kni_v4 *ctx = ALLOC(struct acceptor_kni_v4, 1); + + MESA_load_profile_int_def(profile, "PACKET_IO", "firewall_sids", (int *)&(ctx->firewall_sids), 1000); + MESA_load_profile_int_def(profile, "PACKET_IO", "proxy_sids", (int *)&(ctx->proxy_sids), 1001); + MESA_load_profile_int_def(profile, "PACKET_IO", "service_chaining_sids", (int *)&(ctx->sce_sids), 1002); + MESA_load_profile_int_def(profile, "PACKET_IO", "packet_io_threads", (int *)&(ctx->nr_worker_threads), 8); + MESA_load_profile_uint_range(profile, "system", "cpu_affinity_mask", TFE_THREAD_MAX, (unsigned int *)ctx->cpu_affinity_mask); + ctx->nr_worker_threads = MIN(ctx->nr_worker_threads, TFE_THREAD_MAX); + + CPU_ZERO(&ctx->coremask); + for (int i = 0; i < ctx->nr_worker_threads; i++) + { + int cpu_id = ctx->cpu_affinity_mask[i]; + CPU_SET(cpu_id, &ctx->coremask); + } + + ctx->io = packet_io_create(profile, ctx->nr_worker_threads, &ctx->coremask); + if (ctx->io == NULL) + { + goto error_out; + } + + ctx->metrics = global_metrics_create(); + if (ctx->metrics == NULL) + { + goto error_out; + } + + return ctx; + +error_out: + acceptor_ctx_destory(ctx); + return NULL; +} static void *worker_thread_cycle(void *arg) { struct acceptor_thread_ctx *thread_ctx = (struct acceptor_thread_ctx *)arg; struct packet_io *handle = thread_ctx->ref_io; - struct acceptor_ctx *acceptor_ctx = thread_ctx->ref_acceptor_ctx; int pkg_len = 0; char thread_name[16]; @@ -38,7 +105,7 @@ static void *worker_thread_cycle(void *arg) goto error_out; } - if (acceptor_ctx->config->enable_iouring) { + if (is_enable_iouring(handle)) { io_uring_register_read_callback(thread_ctx->tap_ctx->io_uring_fd, handle_raw_packet_from_tap, thread_ctx); io_uring_register_read_callback(thread_ctx->tap_ctx->io_uring_c, handle_decryption_packet_from_tap, thread_ctx); io_uring_register_read_callback(thread_ctx->tap_ctx->io_uring_s, handle_decryption_packet_from_tap, thread_ctx); @@ -52,10 +119,10 @@ static void *worker_thread_cycle(void *arg) while(1) { n_pkt_recv_from_nf = packet_io_polling_nf_interface(handle, thread_ctx->thread_index, thread_ctx); - if (acceptor_ctx->config->enable_iouring) { + if (is_enable_iouring(handle)) { n_pkt_recv_from_tap = io_uring_peek_ready_entrys(thread_ctx->tap_ctx->io_uring_fd); n_pkt_recv_from_tap_c = io_uring_peek_ready_entrys(thread_ctx->tap_ctx->io_uring_c); - n_pkt_recv_from_tap_c = io_uring_peek_ready_entrys(thread_ctx->tap_ctx->io_uring_s); + n_pkt_recv_from_tap_s = io_uring_peek_ready_entrys(thread_ctx->tap_ctx->io_uring_s); } else { if ((pkg_len = tfe_tap_read_per_thread(thread_ctx->tap_ctx->tap_fd, thread_ctx->tap_ctx->buff, thread_ctx->tap_ctx->buff_size, g_default_logger)) > 0) @@ -63,22 +130,22 @@ static void *worker_thread_cycle(void *arg) handle_raw_packet_from_tap(thread_ctx->tap_ctx->buff, pkg_len, thread_ctx); } - // if ((pkg_len = tfe_tap_read_per_thread(thread_ctx->tap_ctx->tap_c, thread_ctx->tap_ctx->buff, thread_ctx->tap_ctx->buff_size, g_default_logger)) > 0) - // { - // handle_decryption_packet_from_tap(thread_ctx->tap_ctx->buff, pkg_len, thread_ctx); - // } + if ((pkg_len = tfe_tap_read_per_thread(thread_ctx->tap_ctx->tap_c, thread_ctx->tap_ctx->buff, thread_ctx->tap_ctx->buff_size, g_default_logger)) > 0) + { + handle_decryption_packet_from_tap(thread_ctx->tap_ctx->buff, pkg_len, thread_ctx); + } - // if ((pkg_len = tfe_tap_read_per_thread(thread_ctx->tap_ctx->tap_s, thread_ctx->tap_ctx->buff, thread_ctx->tap_ctx->buff_size, g_default_logger)) > 0) - // { - // handle_decryption_packet_from_tap(thread_ctx->tap_ctx->buff, pkg_len, thread_ctx); - // } + if ((pkg_len = tfe_tap_read_per_thread(thread_ctx->tap_ctx->tap_s, thread_ctx->tap_ctx->buff, thread_ctx->tap_ctx->buff_size, g_default_logger)) > 0) + { + handle_decryption_packet_from_tap(thread_ctx->tap_ctx->buff, pkg_len, thread_ctx); + } } - // if (n_pkt_recv_from_nf == 0) - // { - // packet_io_thread_wait(handle, thread_ctx, 0); - // } + if (n_pkt_recv_from_nf == 0 && n_pkt_recv_from_tap == 0 && n_pkt_recv_from_tap_c == 0 && n_pkt_recv_from_tap_s == 0) + { + packet_io_thread_wait(handle, thread_ctx, -1); + } if (__atomic_fetch_add(&thread_ctx->session_table_need_reset, 0, __ATOMIC_RELAXED) > 0) { @@ -92,17 +159,21 @@ error_out: return (void *)NULL; } -void acceptor_kni_v4_destroy() +void acceptor_kni_v4_destroy(struct acceptor_kni_v4 *ctx) { + if (ctx) + { + packet_io_destory(ctx->io); + + free(ctx); + ctx = NULL; + } return; } struct acceptor_kni_v4 *acceptor_kni_v4_create(struct tfe_proxy *proxy, const char *profile, void *logger) { - int ret = 0; - struct acceptor_kni_v4 *__ctx = (struct acceptor_kni_v4 *)calloc(1, sizeof(struct acceptor_kni_v4)); - - struct acceptor_ctx *acceptor_ctx = acceptor_ctx_create(profile); + struct acceptor_kni_v4 *acceptor_ctx = acceptor_ctx_create(profile); if (acceptor_ctx == NULL) goto error_out; @@ -113,27 +184,15 @@ struct acceptor_kni_v4 *acceptor_kni_v4_create(struct tfe_proxy *proxy, const ch acceptor_ctx->work_threads[i].ref_acceptor_ctx = acceptor_ctx; acceptor_ctx->work_threads[i].tap_ctx = tfe_tap_ctx_create(&acceptor_ctx->work_threads[i]); - if (acceptor_ctx->config->enable_iouring) { - int eventfd = 0; - struct tap_ctx *tap_ctx = acceptor_ctx->work_threads[i].tap_ctx; - tap_ctx->io_uring_fd = io_uring_instance_create(tap_ctx->tap_fd, eventfd, acceptor_ctx->config->ring_size, acceptor_ctx->config->buff_size, acceptor_ctx->config->flags, acceptor_ctx->config->sq_thread_idle, acceptor_ctx->config->enable_debuglog); - tap_ctx->io_uring_c = io_uring_instance_create(tap_ctx->tap_c, eventfd, acceptor_ctx->config->ring_size, acceptor_ctx->config->buff_size, acceptor_ctx->config->flags, acceptor_ctx->config->sq_thread_idle, acceptor_ctx->config->enable_debuglog); - tap_ctx->io_uring_s = io_uring_instance_create(tap_ctx->tap_s, eventfd, acceptor_ctx->config->ring_size, acceptor_ctx->config->buff_size, acceptor_ctx->config->flags, acceptor_ctx->config->sq_thread_idle, acceptor_ctx->config->enable_debuglog); - } + if (acceptor_ctx->work_threads[i].tap_ctx == NULL) + goto error_out; acceptor_ctx->work_threads[i].session_table = session_table_create(); acceptor_ctx->work_threads[i].ref_io = acceptor_ctx->io; acceptor_ctx->work_threads[i].ref_proxy = proxy; - acceptor_ctx->work_threads[i].ref_tap_config = acceptor_ctx->config; acceptor_ctx->work_threads[i].ref_metrics = acceptor_ctx->metrics; + acceptor_ctx->work_threads[i].ref_acceptor_ctx = acceptor_ctx; acceptor_ctx->work_threads[i].session_table_need_reset = 0; - - if (acceptor_ctx->config->tap_rps_enable) - { - ret = tfe_tap_set_rps(g_default_logger, acceptor_ctx->config->tap_device, i, acceptor_ctx->config->tap_rps_mask); - if (ret != 0) - goto error_out; - } } for (int i = 0; i < acceptor_ctx->nr_worker_threads; i++) { @@ -144,9 +203,14 @@ struct acceptor_kni_v4 *acceptor_kni_v4_create(struct tfe_proxy *proxy, const ch } } - return __ctx; + return acceptor_ctx; error_out: - acceptor_kni_v4_destroy(); + for (int i = 0; i < acceptor_ctx->nr_worker_threads; i++) { + tfe_tap_ctx_destory(acceptor_ctx->work_threads[i].tap_ctx); + session_table_destory(acceptor_ctx->work_threads[i].session_table); + } + + acceptor_kni_v4_destroy(acceptor_ctx); return NULL; } \ No newline at end of file diff --git a/platform/src/proxy.cpp b/platform/src/proxy.cpp index e09d3e0..8e467bf 100644 --- a/platform/src/proxy.cpp +++ b/platform/src/proxy.cpp @@ -60,7 +60,6 @@ /* Systemd */ #include -#include "tfe_acceptor_kni.h" extern struct tcp_policy_enforcer *tcp_policy_enforcer_create(void *logger); extern struct chaining_policy_enforcer *chaining_policy_enforcer_create(void *logger); diff --git a/vendor/CMakeLists.txt b/vendor/CMakeLists.txt index ea7d58d..968182e 100644 --- a/vendor/CMakeLists.txt +++ b/vendor/CMakeLists.txt @@ -375,19 +375,3 @@ set_property(TARGET libnetfilter_queue-static PROPERTY INTERFACE_INCLUDE_DIRECTO #add_dependencies(gperftools-static gperftools) #set_property(TARGET gperftools-static PROPERTY IMPORTED_LOCATION ${INSTALL_DIR}/lib/libtcmalloc.a) #set_property(TARGET gperftools-static PROPERTY INTERFACE_INCLUDE_DIRECTORIES ${INSTALL_DIR}/include) - -### msgpack-c 6.0.0 -ExternalProject_Add(msgpack-c PREFIX msgpack-c - URL ${CMAKE_CURRENT_SOURCE_DIR}/msgpack-c-6.0.0.tar.gz - URL_MD5 adc08f48550ce772fe24c0b41166b0de - CMAKE_ARGS -DCMAKE_INSTALL_PREFIX= - -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE} - -DMSGPACK_BUILD_TESTS=OFF) - -ExternalProject_Get_Property(msgpack-c INSTALL_DIR) -file(MAKE_DIRECTORY ${INSTALL_DIR}/include) - -add_library(msgpack STATIC IMPORTED GLOBAL) -add_dependencies(msgpack msgpack-c) -set_property(TARGET msgpack PROPERTY IMPORTED_LOCATION ${INSTALL_DIR}/lib/libmsgpack-c.a) -set_property(TARGET msgpack PROPERTY INTERFACE_INCLUDE_DIRECTORIES ${INSTALL_DIR}/include) \ No newline at end of file diff --git a/vendor/msgpack-c-6.0.0.tar.gz b/vendor/msgpack-c-6.0.0.tar.gz deleted file mode 100644 index 185e89c4ef24dfd2acdb634c6cf963c83c5defbe..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 69341 zcmV(aA9L>En_VDtXQRUbyC1)* zuCA)CeyEv+ALpiZvuSO1wi;WFZRggU&8N=x50CgX@YCJhg}=@2Zi9Spw%g<{dw#&* z8;wq@(`+?=z?lu4jdmZC3Ei^{BXfb!4>y5t2f5{(Mfem9J?%5o^#9?BdE*SdFbcP# z+vs65po2TKzg7Lev)kBB^?#?+==^{hkJH5b=l^;Cza5N@jI-Y1FTLYFs#^a#KONQ9 z)`o-g3smi$o%KgY$hmba<7|9-Jno&GuOa+Qf~9Ypi@Pn0e4Tm|W3qHzXJIUT&?c51 zdZ0>%#lOxS$2KA-jEtq{N39*hTrA8xb#A9E<%0AxG-_*uw~S}w?dj#{s7A`_nMZ$w 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

-Hu$Wv1Y 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 DK+J(f