From 4ab9331285845ced7275b923e8a3a65472e2d88a Mon Sep 17 00:00:00 2001 From: Eduardo Silva Date: Wed, 18 Dec 2024 08:22:48 -0600 Subject: [PATCH] lib: cprofiles: upgrade to v0.1.0 Signed-off-by: Eduardo Silva --- lib/cprofiles/.github/actionlint-matcher.json | 17 + lib/cprofiles/.github/dependabot.yml | 12 + lib/cprofiles/.github/workflows/build.yaml | 163 + lib/cprofiles/.github/workflows/lint.yaml | 32 + lib/cprofiles/.gitignore | 3 + lib/cprofiles/.gitmodules | 1 + lib/cprofiles/CMakeLists.txt | 24 +- .../include/cprofiles/cprof_decode_msgpack.h | 43 + .../{cprof_info.h => cprof_encode_msgpack.h} | 36 +- .../cprofiles/cprof_encode_opentelemetry.h | 46 + .../include/cprofiles/cprof_mpack_utils.h | 57 + .../cprofiles/cprof_mpack_utils_defs.h | 40 + .../include/cprofiles/cprof_variant_utils.h | 643 ++ .../include/cprofiles/cprof_version.h | 36 - lib/cprofiles/lib/mpack/CMakeLists.txt | 31 + lib/cprofiles/lib/mpack/src/mpack/mpack.c | 6472 +++++++++++++++ lib/cprofiles/lib/mpack/src/mpack/mpack.h | 7203 +++++++++++++++++ lib/cprofiles/src/CMakeLists.txt | 5 +- lib/cprofiles/src/cprof_decode_msgpack.c | 2234 +++++ .../src/cprof_decode_opentelemetry.c | 2 +- lib/cprofiles/src/cprof_encode_msgpack.c | 955 +++ .../src/cprof_encode_opentelemetry.c | 2388 ++++++ lib/cprofiles/src/cprof_encode_text.c | 154 +- lib/cprofiles/src/cprof_mpack_utils.c | 488 ++ lib/cprofiles/src/cprof_profile.c | 4 +- lib/cprofiles/src/cprof_resource_profiles.c | 3 +- lib/cprofiles/tests/CMakeLists.txt | 5 +- lib/cprofiles/tests/msgpack_transcoder.c | 701 ++ .../{decoder.c => opentelemetry_transcoder.c} | 296 +- lib/cprofiles/tests/profile.c | 8 +- lib/cprofiles/tests/text_transcoder.c | 660 ++ 31 files changed, 22564 insertions(+), 198 deletions(-) create mode 100644 lib/cprofiles/.github/actionlint-matcher.json create mode 100644 lib/cprofiles/.github/dependabot.yml create mode 100644 lib/cprofiles/.github/workflows/build.yaml create mode 100644 lib/cprofiles/.github/workflows/lint.yaml create mode 100644 lib/cprofiles/.gitignore create mode 100644 lib/cprofiles/include/cprofiles/cprof_decode_msgpack.h rename lib/cprofiles/include/cprofiles/{cprof_info.h => cprof_encode_msgpack.h} (51%) create mode 100644 lib/cprofiles/include/cprofiles/cprof_encode_opentelemetry.h create mode 100644 lib/cprofiles/include/cprofiles/cprof_mpack_utils.h create mode 100644 lib/cprofiles/include/cprofiles/cprof_mpack_utils_defs.h create mode 100644 lib/cprofiles/include/cprofiles/cprof_variant_utils.h delete mode 100644 lib/cprofiles/include/cprofiles/cprof_version.h create mode 100644 lib/cprofiles/lib/mpack/CMakeLists.txt create mode 100644 lib/cprofiles/lib/mpack/src/mpack/mpack.c create mode 100644 lib/cprofiles/lib/mpack/src/mpack/mpack.h create mode 100644 lib/cprofiles/src/cprof_decode_msgpack.c create mode 100644 lib/cprofiles/src/cprof_encode_msgpack.c create mode 100644 lib/cprofiles/src/cprof_encode_opentelemetry.c create mode 100644 lib/cprofiles/src/cprof_mpack_utils.c create mode 100644 lib/cprofiles/tests/msgpack_transcoder.c rename lib/cprofiles/tests/{decoder.c => opentelemetry_transcoder.c} (53%) create mode 100644 lib/cprofiles/tests/text_transcoder.c diff --git a/lib/cprofiles/.github/actionlint-matcher.json b/lib/cprofiles/.github/actionlint-matcher.json new file mode 100644 index 00000000000..7b1ba251e61 --- /dev/null +++ b/lib/cprofiles/.github/actionlint-matcher.json @@ -0,0 +1,17 @@ +{ + "problemMatcher": [ + { + "owner": "actionlint", + "pattern": [ + { + "regexp": "^(?:\\x1b\\[\\d+m)?(.+?)(?:\\x1b\\[\\d+m)*:(?:\\x1b\\[\\d+m)*(\\d+)(?:\\x1b\\[\\d+m)*:(?:\\x1b\\[\\d+m)*(\\d+)(?:\\x1b\\[\\d+m)*: (?:\\x1b\\[\\d+m)*(.+?)(?:\\x1b\\[\\d+m)* \\[(.+?)\\]$", + "file": 1, + "line": 2, + "column": 3, + "message": 4, + "code": 5 + } + ] + } + ] + } \ No newline at end of file diff --git a/lib/cprofiles/.github/dependabot.yml b/lib/cprofiles/.github/dependabot.yml new file mode 100644 index 00000000000..12f9b4a0ba2 --- /dev/null +++ b/lib/cprofiles/.github/dependabot.yml @@ -0,0 +1,12 @@ +# To get started with Dependabot version updates, you'll need to specify which +# package ecosystems to update and where the package manifests are located. +# Please see the documentation for all configuration options: +# https://help.github.com/github/administering-a-repository/configuration-options-for-dependency-updates + +version: 2 +updates: + # Maintain dependencies for GitHub Actions + - package-ecosystem: "github-actions" + directory: "/" + schedule: + interval: "weekly" \ No newline at end of file diff --git a/lib/cprofiles/.github/workflows/build.yaml b/lib/cprofiles/.github/workflows/build.yaml new file mode 100644 index 00000000000..e2835adf286 --- /dev/null +++ b/lib/cprofiles/.github/workflows/build.yaml @@ -0,0 +1,163 @@ +name: Build PR(s) and master branch. +on: + push: + branches: + - master + pull_request: + branches: + - master + types: [opened, reopened, synchronize] +jobs: + build-windows: + name: Build sources on amd64 for ${{ matrix.os }} + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + os: [windows-latest, windows-2019] + permissions: + contents: read + steps: + - uses: actions/checkout@v4 + with: + submodules: true + + - name: Build on ${{ matrix.os }} with vs-2019 + run: | + .\scripts\win_build.bat + + - name: Run unit tests. + run: | + ctest --rerun-failed --output-on-failure -C Debug --test-dir .\tests\ + + build-centos: + name: CentOS 7 build to confirm no issues once used downstream + runs-on: ubuntu-latest + container: centos:7 + permissions: + contents: none + steps: + - name: Set up base image dependencies + run: | + sed -i -e "s/^mirrorlist=http:\/\/mirrorlist.centos.org/#mirrorlist=http:\/\/mirrorlist.centos.org/g" /etc/yum.repos.d/CentOS-Base.repo + sed -i -e "s/^#baseurl=http:\/\/mirror.centos.org/baseurl=http:\/\/vault.centos.org/g" /etc/yum.repos.d/CentOS-Base.repo + yum -y update && \ + yum install -y ca-certificates cmake curl-devel gcc gcc-c++ git make wget && \ + yum install -y epel-release + yum install -y cmake3 + shell: bash + + - name: Clone repo without submodules (1.8.3 version of Git) + run: | + git clone https://github.com/fluent/cprofiles.git + shell: bash + + - name: Check out the branch (1.8.3 version of Git) + env: + BRANCH_NAME: ${{ github.head_ref }} + run: | + git checkout "$BRANCH_NAME" + shell: bash + working-directory: cprofiles + + - name: Fetch the appropriate sub modules + run: | + git submodule init + git submodule update + shell: bash + working-directory: cprofiles + + - name: Run compilation + run: | + cmake3 -DCPROF_DEV=on ../ + make + shell: bash + working-directory: cprofiles/build + + build-unix-arm64: + name: Build sources on arm64 for ${{ matrix.os }} - ${{ matrix.compiler }} + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + os: [ubuntu-latest] + compiler: [ gcc, clang ] + permissions: + contents: read + steps: + - uses: actions/checkout@v4 + with: + submodules: true + + - name: Build on ${{ matrix.os }} with ${{ matrix.compiler }} + uses: uraimo/run-on-arch-action@v2.8.1 + with: + arch: aarch64 + distro: ubuntu20.04 + run: | + apt-get update && \ + apt-get install -y --no-install-recommends \ + build-essential \ + cmake \ + file \ + make + export CC=${{ env.compiler }} + cd build + cmake -DCPROF_TESTS=On ../ + cmake --build . + CTEST_OUTPUT_ON_FAILURE=1 ctest + env: + CC: ${{ matrix.compiler }} + + build-unix-amd64: + name: Build sources on amd64 for ${{ matrix.os }} - ${{ matrix.compiler }} + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + os: [ubuntu-latest, macos-latest] + compiler: [ gcc, clang ] + permissions: + contents: read + steps: + - uses: actions/checkout@v4 + with: + submodules: true + + - name: Build on ${{ matrix.os }} with ${{ matrix.compiler }} + run: | + echo "CC = $CC, CXX = $CXX" + cmake -DCPROF_TESTS=On ../ + cmake --build . + CTEST_OUTPUT_ON_FAILURE=1 ctest + shell: bash + working-directory: build + env: + CC: ${{ matrix.compiler }} + + build-analysis-tests: + name: Build with various code analysis tools + strategy: + fail-fast: false + matrix: + preset: + - clang-sanitize-address + - clang-sanitize-memory + - clang-sanitize-undefined + - clang-sanitize-dataflow + - clang-sanitize-safe-stack + - valgrind + permissions: + contents: read + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + with: + submodules: true + + - uses: docker://lpenz/ghaction-cmake:0.19 + with: + preset: ${{ matrix.preset }} + # dependencies_debian: '' + cmakeflags: '-DCPROF_TESTS=On -DCPROF_DEV=on .' + build_command: make all diff --git a/lib/cprofiles/.github/workflows/lint.yaml b/lib/cprofiles/.github/workflows/lint.yaml new file mode 100644 index 00000000000..b9b8aaead39 --- /dev/null +++ b/lib/cprofiles/.github/workflows/lint.yaml @@ -0,0 +1,32 @@ +name: Lint PRs +on: + pull_request: + workflow_dispatch: + +jobs: + + shellcheck-pr: + runs-on: ubuntu-latest + name: PR - Shellcheck + steps: + - uses: actions/checkout@v4 + - uses: ludeeus/action-shellcheck@master + + actionlint-pr: + runs-on: ubuntu-latest + name: PR - Actionlint + steps: + - uses: actions/checkout@v4 + - run: | + echo "::add-matcher::.github/actionlint-matcher.json" + bash <(curl https://raw.githubusercontent.com/rhysd/actionlint/main/scripts/download-actionlint.bash) + ./actionlint -color -shellcheck= + shell: bash + + docslint-pr: + runs-on: ubuntu-latest + name: PR - Markdownlint + steps: + - uses: actions/checkout@v4 + - name: Run markdownlint + uses: actionshub/markdownlint@v3.1.4 diff --git a/lib/cprofiles/.gitignore b/lib/cprofiles/.gitignore new file mode 100644 index 00000000000..ddc90271d33 --- /dev/null +++ b/lib/cprofiles/.gitignore @@ -0,0 +1,3 @@ +*~ +.vscode/* +build/* \ No newline at end of file diff --git a/lib/cprofiles/.gitmodules b/lib/cprofiles/.gitmodules index 3ae54b77cc1..801a82450d2 100644 --- a/lib/cprofiles/.gitmodules +++ b/lib/cprofiles/.gitmodules @@ -4,3 +4,4 @@ [submodule "lib/fluent-otel-proto"] path = lib/fluent-otel-proto url = https://github.com/fluent/fluent-otel-proto + diff --git a/lib/cprofiles/CMakeLists.txt b/lib/cprofiles/CMakeLists.txt index 51e2db560ee..f1e73d46142 100644 --- a/lib/cprofiles/CMakeLists.txt +++ b/lib/cprofiles/CMakeLists.txt @@ -5,8 +5,8 @@ set(CMAKE_EXPORT_COMPILE_COMMANDS ON) # CMetrics Version set(CPROF_VERSION_MAJOR 0) -set(CPROF_VERSION_MINOR 0) -set(CPROF_VERSION_PATCH 1) +set(CPROF_VERSION_MINOR 1) +set(CPROF_VERSION_PATCH 0) set(CPROF_VERSION_STR "${CPROF_VERSION_MAJOR}.${CPROF_VERSION_MINOR}.${CPROF_VERSION_PATCH}") # Include helpers @@ -56,14 +56,6 @@ endif() include(cmake/libraries.cmake) include(cmake/headers.cmake) -set(CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake/sanitizers-cmake/cmake" ${CMAKE_MODULE_PATH}) -find_package(Sanitizers) - -if(SANITIZE_ADDRESS) - CPROF_DEFINITION(CPROF_HAVE_SANITIZE_ADDRESS) -endif() - - # Include headers and dependency headers include_directories( src @@ -146,14 +138,16 @@ endif() # Configure header files configure_file( "${PROJECT_SOURCE_DIR}/include/cprofiles/cprof_info.h.in" - "${PROJECT_SOURCE_DIR}/include/cprofiles/cprof_info.h" + "${PROJECT_BINARY_DIR}/include/cprofiles/cprof_info.h" ) configure_file( "${PROJECT_SOURCE_DIR}/include/cprofiles/cprof_version.h.in" - "${PROJECT_SOURCE_DIR}/include/cprofiles/cprof_version.h" + "${PROJECT_BINARY_DIR}/include/cprofiles/cprof_version.h" ) +include_directories("${PROJECT_BINARY_DIR}/include/") + # Installation Directories # ======================== if(${CMAKE_SYSTEM_NAME} MATCHES "Windows") @@ -223,7 +217,7 @@ endif() # fluent-otel-proto if (NOT CPROF_HAVE_FLUENT_OTEL_PROTO) include_directories(${CMAKE_CURRENT_SOURCE_DIR}/${CPROF_PATH_LIB_FLUENT_OTEL_PROTO}/include) - CPROF_OPTION(FLUENT_PROTO_METRICS "on") + CPROF_OPTION(FLUENT_PROTO_PROFILES "on") CPROF_OPTION(FLUENT_PROTO_EXAMPLES "off") add_subdirectory(lib/fluent-otel-proto) CPROF_DEFINITION(CPROF_HAVE_FLUENT_OTEL_PROTO) @@ -353,7 +347,6 @@ if(CPROF_SYSTEM_MACOS) if (CPACK_GENERATOR MATCHES "productbuild") set(CPACK_SET_DESTDIR "ON") - configure_file(cpack/macos/welcome.txt.cmakein ${CMAKE_CURRENT_SOURCE_DIR}/welcome.txt) configure_file(LICENSE ${CMAKE_CURRENT_SOURCE_DIR}/LICENSE.txt) find_program(CONVERTER textutil) if (NOT CONVERTER) @@ -363,7 +356,6 @@ if(CPROF_SYSTEM_MACOS) execute_process(COMMAND ${CONVERTER} -convert html "${CMAKE_CURRENT_SOURCE_DIR}/README.md" -output "${CMAKE_CURRENT_SOURCE_DIR}/README.html") endif() set(CPACK_PACKAGE_FILE_NAME "${CMETRICS_PKG}") - set(CPACK_RESOURCE_FILE_WELCOME ${CMAKE_CURRENT_SOURCE_DIR}/welcome.txt) set(CPACK_RESOURCE_FILE_LICENSE ${CMAKE_CURRENT_SOURCE_DIR}/LICENSE.txt) set(CPACK_RESOURCE_FILE_README ${CMAKE_CURRENT_SOURCE_DIR}/README.html) set(CPACK_PRODUCTBUILD_IDENTIFIER "com.calyptia.${CPACK_PACKAGE_NAME}") @@ -371,6 +363,6 @@ if(CPROF_SYSTEM_MACOS) endif() # Create tarball -# add_custom_target(tarball COMMAND "bash" "${CMAKE_CURRENT_SOURCE_DIR}/create-submoduled-tarball.sh" "cprofiles-${CPROF_VERSION_STR}") +add_custom_target(cprofiles_tarball COMMAND "bash" "${CMAKE_CURRENT_SOURCE_DIR}/create-submoduled-tarball.sh" "cprofiles-${CPROF_VERSION_STR}") include(CPack) diff --git a/lib/cprofiles/include/cprofiles/cprof_decode_msgpack.h b/lib/cprofiles/include/cprofiles/cprof_decode_msgpack.h new file mode 100644 index 00000000000..c5013937247 --- /dev/null +++ b/lib/cprofiles/include/cprofiles/cprof_decode_msgpack.h @@ -0,0 +1,43 @@ +/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ + +/* CProfiles + * ======== + * Copyright 2024 The CProfiles Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef CPROF_DECODE_MSGPACK_H +#define CPROF_DECODE_MSGPACK_H + +#include +#include + +#define CPROF_DECODE_MSGPACK_SUCCESS 0 +#define CPROF_DECODE_MSGPACK_ALLOCATION_ERROR 1 +#define CPROF_DECODE_MSGPACK_INSUFFICIENT_DATA 2 +#define CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR 3 + +struct crof_msgpack_decode_context { + struct cprof *inner_context; + mpack_reader_t reader; +}; + +int cprof_decode_msgpack_create(struct cprof **result_context, + unsigned char *in_buf, + size_t in_size, + size_t *offset); + +void cprof_decode_msgpack_destroy(struct cprof *context); + +#endif diff --git a/lib/cprofiles/include/cprofiles/cprof_info.h b/lib/cprofiles/include/cprofiles/cprof_encode_msgpack.h similarity index 51% rename from lib/cprofiles/include/cprofiles/cprof_info.h rename to lib/cprofiles/include/cprofiles/cprof_encode_msgpack.h index 10f06c905cd..b02c86477cf 100644 --- a/lib/cprofiles/include/cprofiles/cprof_info.h +++ b/lib/cprofiles/include/cprofiles/cprof_encode_msgpack.h @@ -2,7 +2,7 @@ /* CProfiles * ======== - * Copyright 2024 The CMetrics Authors + * Copyright 2024 The CProfiles Authors * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -17,24 +17,26 @@ * limitations under the License. */ -#ifndef CPROF_INFO_H -#define CPROF_INFO_H +#ifndef CPROF_ENCODE_MSGPACK_H +#define CPROF_ENCODE_MSGPACK_H -#define CPROF_SOURCE_DIR "/src/fluent-bit" +#include +#include +#include -/* General flags set by /CMakeLists.txt */ -#ifndef CPROF_HAVE_TIMESPEC_GET -#define CPROF_HAVE_TIMESPEC_GET -#endif -#ifndef CPROF_HAVE_GMTIME_R -#define CPROF_HAVE_GMTIME_R -#endif -#ifndef CPROF_HAVE_CFL -#define CPROF_HAVE_CFL -#endif -#ifndef CPROF_HAVE_FLUENT_OTEL_PROTO -#define CPROF_HAVE_FLUENT_OTEL_PROTO -#endif +#define CPROF_ENCODE_MSGPACK_SUCCESS 0 +#define CPROF_ENCODE_MSGPACK_ALLOCATION_ERROR 1 +#define CPROF_ENCODE_MSGPACK_INVALID_ARGUMENT_ERROR 2 + +struct cprof_msgpack_encoding_context { + mpack_writer_t writer; + char *output_buffer; + size_t output_size; +}; + +int cprof_encode_msgpack_create(cfl_sds_t *result_buffer, + struct cprof *profile); +void cprof_encode_msgpack_destroy(cfl_sds_t instance); #endif diff --git a/lib/cprofiles/include/cprofiles/cprof_encode_opentelemetry.h b/lib/cprofiles/include/cprofiles/cprof_encode_opentelemetry.h new file mode 100644 index 00000000000..312a29fc2ea --- /dev/null +++ b/lib/cprofiles/include/cprofiles/cprof_encode_opentelemetry.h @@ -0,0 +1,46 @@ +/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ + +/* CProfiles + * ======== + * Copyright 2024 The CProfiles Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef CPROF_ENCODE_OPENTELEMETRY_H +#define CPROF_ENCODE_OPENTELEMETRY_H + +#include +#include +#include + +#define CPROF_ENCODE_OPENTELEMETRY_SUCCESS 0 +#define CPROF_ENCODE_OPENTELEMETRY_ALLOCATION_ERROR 1 +#define CPROF_ENCODE_OPENTELEMETRY_INVALID_ARGUMENT_ERROR 2 +#define CPROF_ENCODE_OPENTELEMETRY_INTERNAL_ENCODER_ERROR 3 +#define CPROF_ENCODE_OPENTELEMETRY_UNIDENTIFIED_ERROR 99 + +struct cprof_opentelemetry_encoding_context { + struct cprof *inner_context; + Opentelemetry__Proto__Collector__Profiles__V1development__ExportProfilesServiceRequest \ + *export_service_request; + //char *output_buffer; + //size_t output_size; +}; + +int cprof_encode_opentelemetry_create(cfl_sds_t *result_buffer, + struct cprof *profile); + +void cprof_encode_opentelemetry_destroy(cfl_sds_t instance); + +#endif diff --git a/lib/cprofiles/include/cprofiles/cprof_mpack_utils.h b/lib/cprofiles/include/cprofiles/cprof_mpack_utils.h new file mode 100644 index 00000000000..220c1ce8fc1 --- /dev/null +++ b/lib/cprofiles/include/cprofiles/cprof_mpack_utils.h @@ -0,0 +1,57 @@ +/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ + +/* CProfiles + * ======== + * Copyright 2024 The CProfiles Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef CPROF_MPACK_UTILS_H +#define CPROF_MPACK_UTILS_H + +#include +#include +#include + +typedef int (*cprof_mpack_unpacker_entry_callback_fn_t)(mpack_reader_t *reader, + size_t index, + void *context); + +struct cprof_mpack_map_entry_callback_t { + const char *identifier; + cprof_mpack_unpacker_entry_callback_fn_t handler; +}; + +int cprof_mpack_consume_nil_tag(mpack_reader_t *reader); +int cprof_mpack_consume_double_tag(mpack_reader_t *reader, double *output_buffer); +int cprof_mpack_consume_int_tag(mpack_reader_t *reader, int64_t *output_buffer); +int cprof_mpack_consume_int32_tag(mpack_reader_t *reader, int32_t *output_buffer); +int cprof_mpack_consume_int64_tag(mpack_reader_t *reader, int64_t *output_buffer); +int cprof_mpack_consume_uint_tag(mpack_reader_t *reader, uint64_t *output_buffer); +int cprof_mpack_consume_uint32_tag(mpack_reader_t *reader, uint32_t *output_buffer); +int cprof_mpack_consume_uint64_tag(mpack_reader_t *reader, uint64_t *output_buffer); +int cprof_mpack_consume_string_tag(mpack_reader_t *reader, cfl_sds_t *output_buffer); +int cprof_mpack_consume_binary_tag(mpack_reader_t *reader, cfl_sds_t *output_buffer); +int cprof_mpack_consume_string_or_nil_tag(mpack_reader_t *reader, cfl_sds_t *output_buffer); +int cprof_mpack_consume_binary_or_nil_tag(mpack_reader_t *reader, cfl_sds_t *output_buffer); +int cprof_mpack_unpack_map(mpack_reader_t *reader, + struct cprof_mpack_map_entry_callback_t *callback_list, + void *context); +int cprof_mpack_unpack_array(mpack_reader_t *reader, + cprof_mpack_unpacker_entry_callback_fn_t entry_processor_callback, + void *context); +int cprof_mpack_peek_array_length(mpack_reader_t *reader); +mpack_type_t cprof_mpack_peek_type(mpack_reader_t *reader); + +#endif diff --git a/lib/cprofiles/include/cprofiles/cprof_mpack_utils_defs.h b/lib/cprofiles/include/cprofiles/cprof_mpack_utils_defs.h new file mode 100644 index 00000000000..b78d8d89c6e --- /dev/null +++ b/lib/cprofiles/include/cprofiles/cprof_mpack_utils_defs.h @@ -0,0 +1,40 @@ +/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ + +/* CProfiles + * ======== + * Copyright 2024 The CProfiles Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef CPROF_MPACK_UTILS_DEFS_H +#define CPROF_MPACK_UTILS_DEFS_H + +#define CPROF_MPACK_SUCCESS 0 +#define CPROF_MPACK_INSUFFICIENT_DATA 1 +#define CPROF_MPACK_INVALID_ARGUMENT_ERROR 2 +#define CPROF_MPACK_ALLOCATION_ERROR 3 +#define CPROF_MPACK_CORRUPT_INPUT_DATA_ERROR 4 +#define CPROF_MPACK_CONSUME_ERROR 5 +#define CPROF_MPACK_ENGINE_ERROR 6 +#define CPROF_MPACK_PENDING_MAP_ENTRIES 7 +#define CPROF_MPACK_PENDING_ARRAY_ENTRIES 8 +#define CPROF_MPACK_UNEXPECTED_KEY_ERROR 9 +#define CPROF_MPACK_UNEXPECTED_DATA_TYPE_ERROR 10 +#define CPROF_MPACK_ERROR_CUTOFF 20 + +#define CPROF_MPACK_MAX_ARRAY_ENTRY_COUNT 65535 +#define CPROF_MPACK_MAX_MAP_ENTRY_COUNT 1024 +#define CPROF_MPACK_MAX_STRING_LENGTH 1024 + +#endif \ No newline at end of file diff --git a/lib/cprofiles/include/cprofiles/cprof_variant_utils.h b/lib/cprofiles/include/cprofiles/cprof_variant_utils.h new file mode 100644 index 00000000000..f26bc93148c --- /dev/null +++ b/lib/cprofiles/include/cprofiles/cprof_variant_utils.h @@ -0,0 +1,643 @@ +/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ + +/* CProfiles + * ======== + * Copyright 2024 The CProfiles Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef CPROF_VARIANT_UTILS_H +#define CPROF_VARIANT_UTILS_H + +#include + +#define CFL_VARIANT_UTILS_MAXIMUM_FIXED_ARRAY_SIZE 100 +#define CFL_VARIANT_UTILS_INITIAL_ARRAY_SIZE 100 +#define CFL_VARIANT_UTILS_SERIALIZED_ARRAY_SIZE_LIMIT 100000 + +/* These are the only functions meant for general use, + * the reason why the kvlist packing and unpacking + * functions are exposed is the internal and external + * metadata kvlists in the cmetrics context are not + * contained by a variant instance. + * + * Result : + * Upon success all of these return 0, otherwise they will + * raise the innermost error code which should be treated + * as an opaque value. + * + * Notes : + * When decoding -1 means the check after mpack_read_tag + * failed and -2 means the type was not the one expected + */ + +static inline int pack_cfl_variant(mpack_writer_t *writer, + struct cfl_variant *value); + +static inline int pack_cfl_variant_kvlist(mpack_writer_t *writer, + struct cfl_kvlist *kvlist); + +static inline int unpack_cfl_variant(mpack_reader_t *reader, + struct cfl_variant **value); + +static inline int unpack_cfl_kvlist(mpack_reader_t *reader, + struct cfl_kvlist **result_kvlist); + +/* Packers */ +static inline int pack_cfl_variant_string(mpack_writer_t *writer, + char *value) +{ + mpack_write_cstr(writer, value); + + return 0; +} + +static inline int pack_cfl_variant_binary(mpack_writer_t *writer, + char *value, + size_t length) +{ + mpack_write_bin(writer, value, length); + + return 0; +} + +static inline int pack_cfl_variant_boolean(mpack_writer_t *writer, + unsigned int value) +{ + mpack_write_bool(writer, value); + + return 0; +} + +static inline int pack_cfl_variant_int64(mpack_writer_t *writer, + int64_t value) +{ + mpack_write_int(writer, value); + + return 0; +} + +static inline int pack_cfl_variant_double(mpack_writer_t *writer, + double value) +{ + mpack_write_double(writer, value); + + return 0; +} + +static inline int pack_cfl_variant_array(mpack_writer_t *writer, + struct cfl_array *array) +{ + size_t entry_count; + struct cfl_variant *entry_value; + int result; + size_t index; + + entry_count = array->entry_count; + + mpack_start_array(writer, entry_count); + + for (index = 0 ; index < entry_count ; index++) { + entry_value = cfl_array_fetch_by_index(array, index); + + if (entry_value == NULL) { + return -1; + } + + result = pack_cfl_variant(writer, entry_value); + + if (result != 0) { + return result; + } + } + + mpack_finish_array(writer); + + return 0; +} + +static inline int pack_cfl_variant_kvlist(mpack_writer_t *writer, + struct cfl_kvlist *kvlist) { + size_t entry_count; + struct cfl_list *iterator; + struct cfl_kvpair *kvpair; + int result; + + entry_count = cfl_kvlist_count(kvlist); + + mpack_start_map(writer, entry_count); + + cfl_list_foreach(iterator, &kvlist->list) { + kvpair = cfl_list_entry(iterator, struct cfl_kvpair, _head); + + mpack_write_cstr(writer, kvpair->key); + + result = pack_cfl_variant(writer, kvpair->val); + + if (result != 0) { + return result; + } + } + + mpack_finish_map(writer); + + return 0; +} + +static inline int pack_cfl_variant(mpack_writer_t *writer, + struct cfl_variant *value) +{ + int result; + + if (value->type == CFL_VARIANT_STRING) { + result = pack_cfl_variant_string(writer, value->data.as_string); + } + else if (value->type == CFL_VARIANT_BOOL) { + result = pack_cfl_variant_boolean(writer, value->data.as_bool); + } + else if (value->type == CFL_VARIANT_INT) { + result = pack_cfl_variant_int64(writer, value->data.as_int64); + } + else if (value->type == CFL_VARIANT_DOUBLE) { + result = pack_cfl_variant_double(writer, value->data.as_double); + } + else if (value->type == CFL_VARIANT_ARRAY) { + result = pack_cfl_variant_array(writer, value->data.as_array); + } + else if (value->type == CFL_VARIANT_KVLIST) { + result = pack_cfl_variant_kvlist(writer, value->data.as_kvlist); + } + else if (value->type == CFL_VARIANT_BYTES) { + result = pack_cfl_variant_binary(writer, + value->data.as_bytes, + cfl_sds_len(value->data.as_bytes)); + } + else if (value->type == CFL_VARIANT_REFERENCE) { + result = pack_cfl_variant_string(writer, value->data.as_string); + } + else { + result = -1; + } + + return result; +} + +/* Unpackers */ + +static inline int unpack_cfl_variant_read_tag(mpack_reader_t *reader, + mpack_tag_t *tag, + mpack_type_t expected_type) +{ + *tag = mpack_read_tag(reader); + + if (mpack_ok != mpack_reader_error(reader)) { + return -1; + } + + if (mpack_tag_type(tag) != expected_type) { + return -2; + } + + return 0; +} + +static inline int unpack_cfl_array(mpack_reader_t *reader, + struct cfl_array **result_array) +{ + struct cfl_array *internal_array; + size_t entry_count; + struct cfl_variant *entry_value; + int result; + size_t index; + mpack_tag_t tag; + + result = unpack_cfl_variant_read_tag(reader, &tag, mpack_type_array); + + if (result != 0) { + return result; + } + + entry_count = mpack_tag_array_count(&tag); + + if (entry_count >= CFL_VARIANT_UTILS_SERIALIZED_ARRAY_SIZE_LIMIT) { + return -2; + } + + if (entry_count >= CFL_VARIANT_UTILS_MAXIMUM_FIXED_ARRAY_SIZE) { + internal_array = cfl_array_create(CFL_VARIANT_UTILS_INITIAL_ARRAY_SIZE); + } + else { + internal_array = cfl_array_create(entry_count); + } + + if (internal_array == NULL) { + return -3; + } + + if (entry_count >= CFL_VARIANT_UTILS_MAXIMUM_FIXED_ARRAY_SIZE) { + cfl_array_resizable(internal_array, CFL_TRUE); + } + + for (index = 0 ; index < entry_count ; index++) { + result = unpack_cfl_variant(reader, &entry_value); + + if (result != 0) { + cfl_array_destroy(internal_array); + + return -4; + } + + result = cfl_array_append(internal_array, entry_value); + + if (result != 0) { + cfl_array_destroy(internal_array); + + return -5; + } + } + + mpack_done_array(reader); + + if (mpack_reader_error(reader) != mpack_ok) { + cfl_array_destroy(internal_array); + + return -6; + } + + *result_array = internal_array; + + return 0; +} + +static inline int unpack_cfl_kvlist(mpack_reader_t *reader, + struct cfl_kvlist **result_kvlist) +{ + struct cfl_kvlist *internal_kvlist; + char key_name[256]; + size_t entry_count; + size_t key_length; + struct cfl_variant *key_value; + mpack_tag_t key_tag; + int result; + size_t index; + mpack_tag_t tag; + + result = unpack_cfl_variant_read_tag(reader, &tag, mpack_type_map); + + if (result != 0) { + return result; + } + + entry_count = mpack_tag_map_count(&tag); + + internal_kvlist = cfl_kvlist_create(); + + if (internal_kvlist == NULL) { + return -3; + } + + result = 0; + key_value = NULL; + + for (index = 0 ; index < entry_count ; index++) { + result = unpack_cfl_variant_read_tag(reader, &key_tag, mpack_type_str); + + if (result != 0) { + result = -4; + + break; + } + + key_length = mpack_tag_str_length(&key_tag); + + if (key_length >= sizeof(key_name)) { + result = -5; + + break; + } + + mpack_read_cstr(reader, key_name, sizeof(key_name), key_length); + + key_name[key_length] = '\0'; + + mpack_done_str(reader); + + if (mpack_ok != mpack_reader_error(reader)) { + result = -6; + + break; + } + + result = unpack_cfl_variant(reader, &key_value); + + if (result != 0) { + result = -7; + + break; + } + + result = cfl_kvlist_insert(internal_kvlist, key_name, key_value); + + if (result != 0) { + result = -8; + + break; + } + + key_value = NULL; + } + + mpack_done_map(reader); + + if (mpack_reader_error(reader) != mpack_ok) { + result = -9; + } + + if (result != 0) { + cfl_kvlist_destroy(internal_kvlist); + + if (key_value != NULL) { + cfl_variant_destroy(key_value); + } + } + else { + *result_kvlist = internal_kvlist; + } + + return result; +} + +static inline int unpack_cfl_variant_string(mpack_reader_t *reader, + struct cfl_variant **value) +{ + size_t value_length; + char *value_data; + int result; + mpack_tag_t tag; + + result = unpack_cfl_variant_read_tag(reader, &tag, mpack_type_str); + + if (result != 0) { + return result; + } + + value_length = mpack_tag_str_length(&tag); + + value_data = cfl_sds_create_size(value_length + 1); + + if (value_data == NULL) { + return -3; + } + + cfl_sds_set_len(value_data, value_length); + + mpack_read_cstr(reader, value_data, value_length + 1, value_length); + + mpack_done_str(reader); + + if (mpack_reader_error(reader) != mpack_ok) { + cfl_sds_destroy(value_data); + + return -4; + } + + *value = cfl_variant_create_from_reference(value_data); + + if (*value == NULL) { + return -5; + } + + (*value)->type = CFL_VARIANT_STRING; + + return 0; +} + +static inline int unpack_cfl_variant_binary(mpack_reader_t *reader, + struct cfl_variant **value) +{ + size_t value_length; + char *value_data; + int result; + mpack_tag_t tag; + + result = unpack_cfl_variant_read_tag(reader, &tag, mpack_type_bin); + + if (result != 0) { + return result; + } + + value_length = mpack_tag_bin_length(&tag); + + value_data = cfl_sds_create_size(value_length); + + if (value_data == NULL) { + return -3; + } + + cfl_sds_set_len(value_data, value_length); + + mpack_read_bytes(reader, value_data, value_length); + + mpack_done_bin(reader); + + if (mpack_reader_error(reader) != mpack_ok) { + cfl_sds_destroy(value_data); + + return -4; + } + + *value = cfl_variant_create_from_reference(value_data); + + if (*value == NULL) { + return -5; + } + + (*value)->type = CFL_VARIANT_BYTES; + + return 0; +} + +static inline int unpack_cfl_variant_boolean(mpack_reader_t *reader, + struct cfl_variant **value) +{ + int result; + mpack_tag_t tag; + + result = unpack_cfl_variant_read_tag(reader, &tag, mpack_type_bool); + + if (result != 0) { + return result; + } + + *value = cfl_variant_create_from_bool((unsigned int) mpack_tag_bool_value(&tag)); + + if (*value == NULL) { + return -3; + } + + return 0; +} + +static inline int unpack_cfl_variant_uint64(mpack_reader_t *reader, + struct cfl_variant **value) +{ + int result; + mpack_tag_t tag; + + result = unpack_cfl_variant_read_tag(reader, &tag, mpack_type_uint); + + if (result != 0) { + return result; + } + + *value = cfl_variant_create_from_int64((int64_t) mpack_tag_uint_value(&tag)); + + if (*value == NULL) { + return -3; + } + + return 0; +} + +static inline int unpack_cfl_variant_int64(mpack_reader_t *reader, + struct cfl_variant **value) +{ + int result; + mpack_tag_t tag; + + result = unpack_cfl_variant_read_tag(reader, &tag, mpack_type_int); + + if (result != 0) { + return result; + } + + *value = cfl_variant_create_from_int64((int64_t) mpack_tag_int_value(&tag)); + + if (*value == NULL) { + return -3; + } + + return 0; +} + +static inline int unpack_cfl_variant_double(mpack_reader_t *reader, + struct cfl_variant **value) +{ + int result; + mpack_tag_t tag; + + result = unpack_cfl_variant_read_tag(reader, &tag, mpack_type_double); + + if (result != 0) { + return result; + } + + *value = cfl_variant_create_from_double(mpack_tag_double_value(&tag)); + + if (*value == NULL) { + return -3; + } + + return 0; +} + +static inline int unpack_cfl_variant_array(mpack_reader_t *reader, + struct cfl_variant **value) +{ + struct cfl_array *unpacked_array; + int result; + + result = unpack_cfl_array(reader, &unpacked_array); + + if (result != 0) { + return result; + } + + *value = cfl_variant_create_from_array(unpacked_array); + + if (*value == NULL) { + return -3; + } + + return 0; +} + +static inline int unpack_cfl_variant_kvlist(mpack_reader_t *reader, + struct cfl_variant **value) +{ + struct cfl_kvlist *unpacked_kvlist; + int result; + + result = unpack_cfl_kvlist(reader, &unpacked_kvlist); + + if (result != 0) { + return result; + } + + *value = cfl_variant_create_from_kvlist(unpacked_kvlist); + + if (*value == NULL) { + return -3; + } + + return 0; +} + +static inline int unpack_cfl_variant(mpack_reader_t *reader, + struct cfl_variant **value) +{ + mpack_type_t value_type; + int result; + mpack_tag_t tag; + + tag = mpack_peek_tag(reader); + + if (mpack_ok != mpack_reader_error(reader)) { + return -1; + } + + value_type = mpack_tag_type(&tag); + + if (value_type == mpack_type_str) { + result = unpack_cfl_variant_string(reader, value); + } + else if (value_type == mpack_type_bool) { + result = unpack_cfl_variant_boolean(reader, value); + } + else if (value_type == mpack_type_int) { + result = unpack_cfl_variant_int64(reader, value); + } + else if (value_type == mpack_type_uint) { + result = unpack_cfl_variant_uint64(reader, value); + } + else if (value_type == mpack_type_double) { + result = unpack_cfl_variant_double(reader, value); + } + else if (value_type == mpack_type_array) { + result = unpack_cfl_variant_array(reader, value); + } + else if (value_type == mpack_type_map) { + result = unpack_cfl_variant_kvlist(reader, value); + } + else if (value_type == mpack_type_bin) { + result = unpack_cfl_variant_binary(reader, value); + } + else { + result = -1; + } + + return result; +} + +#endif diff --git a/lib/cprofiles/include/cprofiles/cprof_version.h b/lib/cprofiles/include/cprofiles/cprof_version.h deleted file mode 100644 index d2f46894f46..00000000000 --- a/lib/cprofiles/include/cprofiles/cprof_version.h +++ /dev/null @@ -1,36 +0,0 @@ -/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ - -/* Chunk I/O - * ========= - * Copyright 2018 Eduardo Silva - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef CPROF_VERSION_H -#define CPROF_VERSION_H - -/* Helpers to convert/format version string */ -#define STR_HELPER(s) #s -#define STR(s) STR_HELPER(s) - -/* Chunk I/O Version */ -#define CPROF_VERSION_MAJOR 0 -#define CPROF_VERSION_MINOR 0 -#define CPROF_VERSION_PATCH 1 -#define CPROF_VERSION (CPROF_VERSION_MAJOR * 10000 \ - CPROF_VERSION_MINOR * 100 \ - CPROF_VERSION_PATCH) -#define CPROF_VERSION_STR "0.0.1" - -#endif diff --git a/lib/cprofiles/lib/mpack/CMakeLists.txt b/lib/cprofiles/lib/mpack/CMakeLists.txt new file mode 100644 index 00000000000..bc6e731575f --- /dev/null +++ b/lib/cprofiles/lib/mpack/CMakeLists.txt @@ -0,0 +1,31 @@ +set(src + src/mpack/mpack.c + ) + +set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c99") +add_definitions(-DMPACK_EXTENSIONS=1) +add_library(mpack-static STATIC ${src}) + +# Install Library +if(MSVC) + # Rename the output for Windows environment to avoid naming issues + set_target_properties(mpack-static PROPERTIES OUTPUT_NAME libmpack) +else() + set_target_properties(mpack-static PROPERTIES OUTPUT_NAME mpack) +endif(MSVC) + +# Installation Directories +# ======================== +if(${CMAKE_SYSTEM_NAME} MATCHES "Windows") + set(MPACK_INSTALL_LIBDIR "lib") + set(MPACK_INSTALL_INCLUDEDIR "include") +else() + set(MPACK_INSTALL_LIBDIR "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}") + set(MPACK_INSTALL_INCLUDEDIR "${CMAKE_INSTALL_PREFIX}/include") +endif() + +install(TARGETS mpack-static + RUNTIME DESTINATION ${MPACK_INSTALL_BINDIR} + LIBRARY DESTINATION ${MPACK_INSTALL_LIBDIR} + ARCHIVE DESTINATION ${MPACK_INSTALL_LIBDIR} + COMPONENT library) diff --git a/lib/cprofiles/lib/mpack/src/mpack/mpack.c b/lib/cprofiles/lib/mpack/src/mpack/mpack.c new file mode 100644 index 00000000000..337ab0955a6 --- /dev/null +++ b/lib/cprofiles/lib/mpack/src/mpack/mpack.c @@ -0,0 +1,6472 @@ +/** + * The MIT License (MIT) + * + * Copyright (c) 2015-2018 Nicholas Fraser + * + * 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.0 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" */ + + +#if MPACK_DEBUG && MPACK_STDIO +#include +#endif + + + +#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/mpack-common.c.c */ + +#define MPACK_INTERNAL 1 + +/* #include "mpack-common.h" */ + +#if MPACK_DEBUG && MPACK_STDIO +#include +#endif + +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; + for (size_t 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: + mpack_snprintf(buffer, buffer_size, "%f", tag.v.f); + return; + case mpack_type_double: + mpack_snprintf(buffer, buffer_size, "%f", tag.v.d); + 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: + mpack_snprintf(buffer, buffer_size, "float %f", tag.v.f); + return; + case mpack_type_double: + mpack_snprintf(buffer, buffer_size, "double %f", tag.v.d); + return; + case mpack_type_str: + mpack_snprintf(buffer, buffer_size, "str of %u bytes", tag.v.l); + return; + case mpack_type_bin: + mpack_snprintf(buffer, buffer_size, "bin of %u bytes", tag.v.l); + return; + #if MPACK_EXTENSIONS + case mpack_type_ext: + mpack_snprintf(buffer, buffer_size, "ext of type %i, %u bytes", + mpack_tag_ext_exttype(&tag), mpack_tag_ext_length(&tag)); + return; + #endif + case mpack_type_array: + mpack_snprintf(buffer, buffer_size, "array of %u elements", tag.v.n); + return; + case mpack_type_map: + mpack_snprintf(buffer, buffer_size, "map of %u 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].key_needs_value = false; + ++track->count; + return mpack_ok; +} + +mpack_error_t mpack_track_pop(mpack_track_t* track, mpack_type_t type) { + 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; + } + + --track->count; + return mpack_ok; +} + +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->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; + } + + --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 > 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) { + for (size_t 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/mpack-writer.c.c */ + +#define MPACK_INTERNAL 1 + +/* #include "mpack-writer.h" */ + +#if MPACK_WRITER + +#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_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_element(mpack_writer_t* writer) { + if (writer->error == mpack_ok) + mpack_writer_flag_if_error(writer, mpack_track_element(&writer->track, false)); +} + +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 + +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->current = NULL; + writer->end = NULL; + writer->error = mpack_ok; + + #if MPACK_WRITE_TRACKING + mpack_memset(&writer->track, 0, sizeof(writer->track)); + #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->current = 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->current = 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->current = new_buffer + used; + writer->buffer = new_buffer; + writer->end = writer->buffer + new_size; + + // append the extra data + if (count > 0) { + mpack_memcpy(writer->current, data, count); + writer->current += 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->current = 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->current = 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 + mpack_writer_flag_if_error(writer, mpack_track_check_empty(&writer->track)); + if (writer->error != mpack_ok) + 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 (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))); + + // 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->current, p, count); + writer->current += 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->current, p, count); + writer->current += 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 + + // 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_float: mpack_write_float (writer, value.v.f); return; + case mpack_type_double: mpack_write_double(writer, value.v.d); 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_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->current++) = 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 > 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 > 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 > 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 < 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 < 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 < INT32_MIN); + mpack_store_u8(p, 0xd3); + mpack_store_i64(p + 1, value); +} + +MPACK_STATIC_INLINE void mpack_encode_float(char* p, float value) { + mpack_store_u8(p, 0xca); + mpack_store_float(p + 1, value); +} + +MPACK_STATIC_INLINE void mpack_encode_double(char* p, double value) { + mpack_store_u8(p, 0xcb); + mpack_store_double(p + 1, value); +} + +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 > 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 > 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, 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 > 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 > 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 > 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 > 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 > 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->current, __VA_ARGS__)); \ + writer->current += 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 <= 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 <= UINT8_MAX) { + MPACK_WRITE_ENCODED(mpack_encode_u8, MPACK_TAG_SIZE_U8, (uint8_t)value); + } else if (value <= 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 <= UINT8_MAX) { + MPACK_WRITE_ENCODED(mpack_encode_u8, MPACK_TAG_SIZE_U8, (uint8_t)value); + } else if (value <= UINT16_MAX) { + MPACK_WRITE_ENCODED(mpack_encode_u16, MPACK_TAG_SIZE_U16, (uint16_t)value); + } else if (value <= 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 <= 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 >= 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 <= UINT8_MAX) { + MPACK_WRITE_ENCODED(mpack_encode_u8, MPACK_TAG_SIZE_U8, (uint8_t)value); + } else if (value <= 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 >= INT8_MIN) { + MPACK_WRITE_ENCODED(mpack_encode_i8, MPACK_TAG_SIZE_I8, (int8_t)value); + } else if (value >= 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 <= UINT8_MAX) { + MPACK_WRITE_ENCODED(mpack_encode_u8, MPACK_TAG_SIZE_U8, (uint8_t)value); + } else if (value <= UINT16_MAX) { + MPACK_WRITE_ENCODED(mpack_encode_u16, MPACK_TAG_SIZE_U16, (uint16_t)value); + } else if (value <= 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 >= INT8_MIN) { + MPACK_WRITE_ENCODED(mpack_encode_i8, MPACK_TAG_SIZE_I8, (int8_t)value); + } else if (value >= INT16_MIN) { + MPACK_WRITE_ENCODED(mpack_encode_i16, MPACK_TAG_SIZE_I16, (int16_t)value); + } else if (value >= 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); + } +} + +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); +} + +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); +} + +#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: %u", nanoseconds); + mpack_writer_flag_error(writer, mpack_error_bug); + return; + } + + mpack_writer_track_element(writer); + + if (seconds < 0 || seconds >= (INT64_C(1) << 34)) { + MPACK_WRITE_ENCODED(mpack_encode_timestamp_12, MPACK_EXT_SIZE_TIMESTAMP12, seconds, nanoseconds); + } else if (seconds > 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 + +void mpack_start_array(mpack_writer_t* writer, uint32_t count) { + mpack_writer_track_element(writer); + + if (count <= 15) { + MPACK_WRITE_ENCODED(mpack_encode_fixarray, MPACK_TAG_SIZE_FIXARRAY, (uint8_t)count); + } else if (count <= 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); + } + + mpack_writer_track_push(writer, mpack_type_array, count); +} + +void mpack_start_map(mpack_writer_t* writer, uint32_t count) { + mpack_writer_track_element(writer); + + if (count <= 15) { + MPACK_WRITE_ENCODED(mpack_encode_fixmap, MPACK_TAG_SIZE_FIXMAP, (uint8_t)count); + } else if (count <= 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); + } + + mpack_writer_track_push(writer, mpack_type_map, count); +} + +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 <= 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 <= 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 <= UINT8_MAX) { + MPACK_WRITE_ENCODED(mpack_encode_bin8, MPACK_TAG_SIZE_BIN8, (uint8_t)count); + } else if (count <= 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 <= UINT8_MAX) { + MPACK_WRITE_ENCODED(mpack_encode_ext8, MPACK_TAG_SIZE_EXT8, exttype, (uint8_t)count); + } else if (count <= 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(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->current; + mpack_encode_fixstr(p, (uint8_t)count); + mpack_memcpy(p + MPACK_TAG_SIZE_FIXSTR, data, count); + writer->current += count + MPACK_TAG_SIZE_FIXSTR; + } + return; + } + + if (count <= 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->current; + mpack_encode_str8(p, (uint8_t)count); + mpack_memcpy(p + MPACK_TAG_SIZE_STR8, data, count); + writer->current += 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 <= 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(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(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(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 > 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(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 > 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); +} + +#endif + + +/* mpack/mpack-reader.c.c */ + +#define MPACK_INTERNAL 1 + +/* #include "mpack-reader.h" */ + +#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 %u 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; + *tag = mpack_tag_make_float(mpack_load_float(reader->data + 1)); + return MPACK_TAG_SIZE_FLOAT; + + // double + case 0xcb: + if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_DOUBLE)) + return 0; + *tag = mpack_tag_make_double(mpack_load_double(reader->data + 1)); + 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 & ((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; + + switch (val.type) { + case mpack_type_str: + mpack_print_append_cstr(print, "\""); + for (size_t 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 (size_t i = 0; i < val.v.n; ++i) { + for (size_t 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 (size_t 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 (size_t i = 0; i < val.v.n; ++i) { + for (size_t 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 (size_t 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) { + for (size_t 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/mpack-expect.c.c */ + +#define MPACK_INTERNAL 1 + +/* #include "mpack-expect.h" */ + +#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 <= UINT8_MAX) + return (uint8_t)var.v.u; + } else if (var.type == mpack_type_int) { + if (var.v.i >= 0 && var.v.i <= 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 <= UINT16_MAX) + return (uint16_t)var.v.u; + } else if (var.type == mpack_type_int) { + if (var.v.i >= 0 && var.v.i <= 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 <= UINT32_MAX) + return (uint32_t)var.v.u; + } else if (var.type == mpack_type_int) { + if (var.v.i >= 0 && var.v.i <= 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 <= INT8_MAX) + return (int8_t)var.v.u; + } else if (var.type == mpack_type_int) { + if (var.v.i >= INT8_MIN && var.v.i <= 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 <= INT16_MAX) + return (int16_t)var.v.u; + } else if (var.type == mpack_type_int) { + if (var.v.i >= INT16_MIN && var.v.i <= 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 <= INT32_MAX) + return (int32_t)var.v.u; + } else if (var.type == mpack_type_int) { + if (var.v.i >= INT32_MIN && var.v.i <= 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 <= 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; +} + +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; + else if (var.type == mpack_type_int) + return (float)var.v.i; + else if (var.type == mpack_type_float) + return var.v.f; + else if (var.type == mpack_type_double) + return (float)var.v.d; + mpack_reader_flag_error(reader, mpack_error_type); + return 0.0f; +} + +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; +} + +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; +} + +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; +} + + +// 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)} + +float mpack_expect_float_range(mpack_reader_t* reader, float min_value, float max_value) {MPACK_EXPECT_RANGE_IMPL(float, float)} +double mpack_expect_double_range(mpack_reader_t* reader, double min_value, double max_value) {MPACK_EXPECT_RANGE_IMPL(double, double)} + +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 (maxsize > UINT32_MAX) + maxsize = 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 > 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 (maxsize > UINT32_MAX) + maxsize = 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 (maxsize > UINT32_MAX) + maxsize = 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 + for (size_t 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 + for (size_t 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/mpack-node.c.c */ + +#define MPACK_INTERNAL 1 + +/* #include "mpack-node.h" */ + +#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 %u 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 + // 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_tree_reserve_bytes(tree, sizeof(float))) + return false; + node->value.f = mpack_load_float(tree->data + tree->size + 1); + node->type = mpack_type_float; + return true; + + // double + case 0xcb: + if (!mpack_tree_reserve_bytes(tree, sizeof(double))) + return false; + node->value.d = mpack_load_double(tree->data + tree->size + 1); + 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; + switch (data->type) { + case mpack_type_str: + { + mpack_print_append_cstr(print, "\""); + const char* bytes = mpack_node_data_unchecked(node); + for (size_t 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 (size_t i = 0; i < data->len; ++i) { + for (size_t 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 (size_t 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 (size_t i = 0; i < data->len; ++i) { + for (size_t 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 (size_t 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; + for (size_t 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 & ((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; + + for (size_t 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; + + for (size_t 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; + + for (size_t 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 + for (size_t 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 <= 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 <= 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 <= INT8_MAX) + return (int8_t)node.data->value.u; + } else if (node.data->type == mpack_type_int) { + if (node.data->value.i >= INT8_MIN && node.data->value.i <= 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 <= 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 <= 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 <= INT16_MAX) + return (int16_t)node.data->value.u; + } else if (node.data->type == mpack_type_int) { + if (node.data->value.i >= INT16_MIN && node.data->value.i <= 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 <= 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 <= 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 <= INT32_MAX) + return (int32_t)node.data->value.u; + } else if (node.data->type == mpack_type_int) { + if (node.data->value.i >= INT32_MIN && node.data->value.i <= 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)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 <= 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 >= INT_MIN && val <= INT_MAX) + return (int)val; + + mpack_node_flag_error(node, mpack_error_type); + return 0; +} + +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; + else if (node.data->type == mpack_type_int) + return (float)node.data->value.i; + else if (node.data->type == mpack_type_float) + return node.data->value.f; + else if (node.data->type == mpack_type_double) + return (float)node.data->value.d; + + mpack_node_flag_error(node, mpack_error_type); + return 0.0f; +} + +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; +} + +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; +} + +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; +} + +#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 diff --git a/lib/cprofiles/lib/mpack/src/mpack/mpack.h b/lib/cprofiles/lib/mpack/src/mpack/mpack.h new file mode 100644 index 00000000000..7c0b3f17e38 --- /dev/null +++ b/lib/cprofiles/lib/mpack/src/mpack/mpack.h @@ -0,0 +1,7203 @@ +/** + * The MIT License (MIT) + * + * Copyright (c) 2015-2018 Nicholas Fraser + * + * 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.0 amalgamation package. + * + * http://github.com/ludocode/mpack + */ + +#ifndef MPACK_H +#define MPACK_H 1 + +#define MPACK_AMALGAMATED 1 + +#if defined(MPACK_HAS_CONFIG) && MPACK_HAS_CONFIG +#include "mpack-config.h" +#endif + + +/* mpack/mpack-defaults.h.h */ + + +/** + * @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_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 + + +/** + * @} + */ + + +/** + * @name Dependencies + * @{ + */ + +/** + * @def MPACK_HAS_CONFIG + * + * Enables the use of an @c mpack-config.h configuration file for MPack. + * This file must be in the same folder as @c mpack.h, or it must be + * available from your project's include paths. + */ +// This goes in your project settings. + +/** + * @def MPACK_STDLIB + * + * Enables the use of C stdlib. This allows the library to use malloc + * for debugging and in allocation helpers. + */ +#ifndef MPACK_STDLIB +#define MPACK_STDLIB 1 +#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 +#define MPACK_STDIO 1 +#endif + +/** + * @} + */ + + +/** + * @name System 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. + * + * 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. + * + * 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. + * + * 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_STDLIB) && MPACK_STDLIB && !defined(MPACK_MALLOC) +#define MPACK_MALLOC malloc +#define MPACK_REALLOC realloc +#define MPACK_FREE free +#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) && (defined(DEBUG) || defined(_DEBUG)) +#define MPACK_DEBUG 1 +#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 +#define MPACK_STRINGS 1 +#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) && \ + defined(MPACK_DEBUG) && MPACK_DEBUG && \ + defined(MPACK_READER) && MPACK_READER && \ + defined(MPACK_MALLOC) +#define MPACK_READ_TRACKING 1 +#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) && \ + defined(MPACK_DEBUG) && MPACK_DEBUG && \ + defined(MPACK_WRITER) && MPACK_WRITER && \ + defined(MPACK_MALLOC) +#define MPACK_WRITE_TRACKING 1 +#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. + */ +#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 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 4096 +#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 + +/** + * @} + */ + + +/** + * @} + */ + + +/* mpack/mpack-platform.h.h */ + +/** + * @file + * + * Abstracts all platform-specific code from MPack. This contains + * implementations of standard C functions when libc is not available, + * as well as wrappers to library functions. + */ + +#ifndef MPACK_PLATFORM_H +#define MPACK_PLATFORM_H 1 + + + +/* Pre-include checks */ + +#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) && defined(MPACK_INTERNAL) && MPACK_INTERNAL +#define _CRT_SECURE_NO_WARNINGS 1 +#endif + + + +/* Doxygen preprocs */ +#if defined(MPACK_DOXYGEN) && MPACK_DOXYGEN +#define MPACK_HAS_CONFIG 0 +// 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 + + + +/* Include the custom config file if enabled */ + +#if defined(MPACK_HAS_CONFIG) && MPACK_HAS_CONFIG +/* #include "mpack-config.h" */ +#endif + +/* + * Now that the optional config is included, we define the defaults + * for any of the configuration options and other switches that aren't + * yet defined. + */ +#if defined(MPACK_DOXYGEN) && MPACK_DOXYGEN +/* #include "mpack-defaults-doxygen.h" */ +#else +/* #include "mpack-defaults.h" */ +#endif + +/* + * All remaining configuration options that have not yet been set must + * be defined here in order to support -Wundef. + */ +#ifndef MPACK_DEBUG +#define MPACK_DEBUG 0 +#endif +#ifndef MPACK_CUSTOM_BREAK +#define MPACK_CUSTOM_BREAK 0 +#endif +#ifndef MPACK_READ_TRACKING +#define MPACK_READ_TRACKING 0 +#endif +#ifndef MPACK_WRITE_TRACKING +#define MPACK_WRITE_TRACKING 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 +#ifndef MPACK_NO_BUILTINS +#define MPACK_NO_BUILTINS 0 +#endif + + + +/* System headers (based on configuration) */ + +#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 + +#include +#include +#include +#include +#include + +#if MPACK_STDLIB +#include +#include +#endif + +#if MPACK_STDIO +#include +#include +#endif + + + +/* + * Header configuration + */ + +#ifdef __cplusplus + #define MPACK_EXTERN_C_START extern "C" { + #define MPACK_EXTERN_C_END } +#else + #define MPACK_EXTERN_C_START /* nothing */ + #define MPACK_EXTERN_C_END /* nothing */ +#endif + +/* We can't push/pop diagnostics before GCC 4.6, so if you're on a really old + * compiler, MPack does not support the below warning flags. You will have to + * manually disable them to use MPack. */ + +/* GCC versions before 5.1 warn about defining a C99 non-static inline function + * before declaring it (see issue #20). Diagnostic push is not supported before + * GCC 4.6. */ +#if defined(__GNUC__) && !defined(__clang__) + #if (__GNUC__ == 4 && __GNUC_MINOR__ >= 6) || (__GNUC__ == 5 && __GNUC_MINOR__ < 1) + #ifdef __cplusplus + #define MPACK_DECLARED_INLINE_WARNING_START \ + _Pragma ("GCC diagnostic push") \ + _Pragma ("GCC diagnostic ignored \"-Wmissing-declarations\"") + #else + #define MPACK_DECLARED_INLINE_WARNING_START \ + _Pragma ("GCC diagnostic push") \ + _Pragma ("GCC diagnostic ignored \"-Wmissing-prototypes\"") + #endif + #define MPACK_DECLARED_INLINE_WARNING_END \ + _Pragma ("GCC diagnostic pop") + #endif +#endif +#ifndef MPACK_DECLARED_INLINE_WARNING_START + #define MPACK_DECLARED_INLINE_WARNING_START /* nothing */ + #define MPACK_DECLARED_INLINE_WARNING_END /* 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"). Diagnostic push is not + * supported before GCC 4.6. */ +#if defined(__GNUC__) && !defined(__clang__) + #if __GNUC__ == 4 && __GNUC_MINOR__ >= 6 && __GNUC_MINOR__ < 8 + #define MPACK_WSHADOW_WARNING_START \ + _Pragma ("GCC diagnostic push") \ + _Pragma ("GCC diagnostic ignored \"-Wshadow\"") + #define MPACK_WSHADOW_WARNING_END \ + _Pragma ("GCC diagnostic pop") + #endif +#endif +#ifndef MPACK_WSHADOW_WARNING_START + #define MPACK_WSHADOW_WARNING_START /* nothing */ + #define MPACK_WSHADOW_WARNING_END /* nothing */ +#endif + +#define MPACK_HEADER_START \ + MPACK_WSHADOW_WARNING_START \ + MPACK_DECLARED_INLINE_WARNING_START + +#define MPACK_HEADER_END \ + MPACK_DECLARED_INLINE_WARNING_END \ + MPACK_WSHADOW_WARNING_END + +MPACK_HEADER_START +MPACK_EXTERN_C_START + + + +/* 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 + + + +/* 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)) + #define MPACK_RESTRICT __restrict__ + #elif defined(_MSC_VER) + #define MPACK_UNREACHABLE __assume(0) + #define MPACK_NORETURN(fn) __declspec(noreturn) fn + #define MPACK_RESTRICT __restrict + #endif +#endif + +#ifndef MPACK_RESTRICT +#ifdef __cplusplus +#define MPACK_RESTRICT /* nothing, unavailable in C++ */ +#else +#define MPACK_RESTRICT restrict /* required in C99 */ +#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 + + + +/* 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_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. + + #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 + + /** + * @addtogroup config + * @{ + */ + /** + * @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); + /** + * @} + */ + /** + * @} + */ + + 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 + + + +/* Wrap some needed libc functions */ + +#if MPACK_STDLIB + #define mpack_memcmp memcmp + #define mpack_memcpy memcpy + #define mpack_memmove memmove + #define mpack_memset memset + #ifndef mpack_strlen + #define mpack_strlen strlen + #endif + + #if defined(MPACK_UNIT_TESTS) && MPACK_INTERNAL && defined(__GNUC__) + // make sure we don't use the stdlib directly during development + #undef memcmp + #undef memcpy + #undef memmove + #undef memset + #undef strlen + #undef malloc + #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 free + #endif + +#elif defined(__GNUC__) && !MPACK_NO_BUILTINS + // there's not always a builtin memmove for GCC, + // and we don't have a way to test for it + #define mpack_memcmp __builtin_memcmp + #define mpack_memcpy __builtin_memcpy + #define mpack_memset __builtin_memset + #define mpack_strlen __builtin_strlen + +#elif defined(__clang__) && defined(__has_builtin) && !MPACK_NO_BUILTINS + #if __has_builtin(__builtin_memcmp) + #define mpack_memcmp __builtin_memcmp + #endif + #if __has_builtin(__builtin_memcpy) + #define mpack_memcpy __builtin_memcpy + #endif + #if __has_builtin(__builtin_memmove) + #define mpack_memmove __builtin_memmove + #endif + #if __has_builtin(__builtin_memset) + #define mpack_memset __builtin_memset + #endif + #if __has_builtin(__builtin_strlen) + #define mpack_strlen __builtin_strlen + #endif +#endif + +#ifndef mpack_memcmp +int mpack_memcmp(const void* s1, const void* s2, size_t n); +#endif +#ifndef mpack_memcpy +void* mpack_memcpy(void* MPACK_RESTRICT s1, const void* MPACK_RESTRICT s2, size_t n); +#endif +#ifndef mpack_memmove +void* mpack_memmove(void* s1, const void* s2, size_t n); +#endif +#ifndef mpack_memset +void* mpack_memset(void* s, int c, size_t n); +#endif +#ifndef mpack_strlen +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 */ +#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 +#if MPACK_READ_TRACKING && !defined(MPACK_READER) + #error "MPACK_READ_TRACKING requires MPACK_READER." +#endif +#if MPACK_WRITE_TRACKING && !defined(MPACK_WRITER) + #error "MPACK_WRITE_TRACKING requires MPACK_WRITER." +#endif +#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 + + + +/** + * @} + */ + +MPACK_EXTERN_C_END +MPACK_HEADER_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_HEADER_START +MPACK_EXTERN_C_START + + + +/** + * @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 0 /**< The minor version number of MPack. */ +#define MPACK_VERSION_PATCH 0 /**< 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. */ + double d; /*< The value if the type is double. */ + float f; /*< The value if the type is float. */ + bool b; /*< The value if the type is bool. */ + + /* 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; +} + +/** Generates a float tag. */ +MPACK_INLINE mpack_tag_t mpack_tag_make_float(float value) { + mpack_tag_t ret = MPACK_TAG_ZERO; + ret.type = mpack_type_float; + ret.v.f = value; + return ret; +} + +/** Generates a double tag. */ +MPACK_INLINE mpack_tag_t mpack_tag_make_double(double value) { + 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 float mpack_tag_float_value(mpack_tag_t* tag) { + 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 double mpack_tag_double_value(mpack_tag_t* tag) { + 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); +} + +/** \deprecated Renamed to mpack_tag_make_float(). */ +MPACK_INLINE mpack_tag_t mpack_tag_float(float value) { + return mpack_tag_make_float(value); +} + +/** \deprecated Renamed to mpack_tag_make_double(). */ +MPACK_INLINE mpack_tag_t mpack_tag_double(double value) { + return mpack_tag_make_double(value); +} + +/** \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);} + +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; +} + +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; +} + +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); +} + +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); +} + +/** @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; +} 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_pop(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_HEADER_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_HEADER_START +MPACK_EXTERN_C_START + +#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 */ + +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* current; /* 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_WRITE_TRACKING +void mpack_writer_track_push(mpack_writer_t* writer, mpack_type_t type, uint32_t count); +void mpack_writer_track_pop(mpack_writer_t* writer, mpack_type_t type); +void mpack_writer_track_element(mpack_writer_t* writer); +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_pop(mpack_writer_t* writer, mpack_type_t type) { + MPACK_UNUSED(writer); + MPACK_UNUSED(type); +} +MPACK_INLINE void mpack_writer_track_element(mpack_writer_t* writer) { + MPACK_UNUSED(writer); +} +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 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. + * + * 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. + */ +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->current - 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->current); +} + +/** + * 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 + * @{ + */ + +/** Writes a float. */ +void mpack_write_float(mpack_writer_t* writer, float value); + +/** Writes a double. */ +void mpack_write_double(mpack_writer_t* writer, double value); + +/** 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. + * + * @see mpack_finish_array() + */ +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. + * + * 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() + */ +void mpack_start_map(mpack_writer_t* writer, uint32_t count); + +/** + * Finishes writing an array. + * + * This should be called only after a corresponding call to mpack_start_array() + * and after the array contents are written. + * + * 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); +} + +/** + * Finishes writing a map. + * + * This should be called only after a corresponding call to mpack_start_map() + * and after the map contents are written. + * + * 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); +} + +/** + * @} + */ + +/** + * @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. + */ +#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, \ + float: mpack_write_float, \ + double: mpack_write_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_HEADER_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_HEADER_START +MPACK_EXTERN_C_START + +#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_HEADER_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_HEADER_START +MPACK_EXTERN_C_START + +#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); + +/** + * 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); + +/** + * 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); + +/** + * 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); + +/** + * 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); + +/** + * @} + */ + +/** + * @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); +} + +/** + * 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); + +/** + * 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); + +/** + * @} + */ + + + +// 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, 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, INT_MIN, 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_HEADER_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_HEADER_START +MPACK_EXTERN_C_START + +#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. */ + float f; /* The value if the type is float. */ + double d; /* The value if the type is double. */ + 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); + +/** + * 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); + +/** + * 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); + +/** + * 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); + +/** + * 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); + +#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 map, @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 map, @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_HEADER_END + +#endif + + +#endif + diff --git a/lib/cprofiles/src/CMakeLists.txt b/lib/cprofiles/src/CMakeLists.txt index 77e69cad47e..9035139bbc6 100644 --- a/lib/cprofiles/src/CMakeLists.txt +++ b/lib/cprofiles/src/CMakeLists.txt @@ -13,12 +13,15 @@ set(src cprof_sample.c cprof_scope_profiles.c cprof_decode_opentelemetry.c + cprof_encode_opentelemetry.c cprof_encode_text.c + cprof_encode_msgpack.c + cprof_decode_msgpack.c + cprof_mpack_utils.c ) set(src ${src} - ) # Static Library diff --git a/lib/cprofiles/src/cprof_decode_msgpack.c b/lib/cprofiles/src/cprof_decode_msgpack.c new file mode 100644 index 00000000000..5ba805dfbbe --- /dev/null +++ b/lib/cprofiles/src/cprof_decode_msgpack.c @@ -0,0 +1,2234 @@ +/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ + +/* CProfiles + * ========= + * Copyright (C) 2024 The CProfiles Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + +#include +#include +#include +#include + +static int unpack_context_header(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_mpack_map_entry_callback_t callbacks[] = \ + { + {NULL, NULL} + }; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + return cprof_mpack_unpack_map(reader, + callbacks, + user_data); +} + +static int unpack_resource_attributes(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_resource *resource; + int result; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + resource = (struct cprof_resource *) user_data; + + if (resource->attributes != NULL) { + cfl_kvlist_destroy(resource->attributes); + + resource->attributes = NULL; + } + + result = unpack_cfl_kvlist(reader, &resource->attributes); + + if (result != 0) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + return CPROF_DECODE_MSGPACK_SUCCESS; +} + +static int unpack_resource_dropped_attribute_count(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_resource *resource; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + resource = (struct cprof_resource *) user_data; + + return cprof_mpack_consume_uint32_tag(reader, &resource->dropped_attributes_count); +} + +static int unpack_resource_profiles_entry_resource(mpack_reader_t *reader, size_t index, void *user_data) +{ + int result; + struct cprof_resource *resource; + struct cprof_resource_profiles *profiles; + struct cprof_mpack_map_entry_callback_t callbacks[] = \ + { + {"attributes", unpack_resource_attributes}, + {"dropped_attribute_count", unpack_resource_dropped_attribute_count}, + {NULL, NULL} + }; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + profiles = (struct cprof_resource_profiles *) user_data; + + resource = cprof_resource_create(NULL); + + if (resource == NULL) { + return CPROF_DECODE_MSGPACK_ALLOCATION_ERROR; + } + + result = cprof_mpack_unpack_map(reader, + callbacks, + (void *) resource); + + if (result == CPROF_DECODE_MSGPACK_SUCCESS) { + if (profiles->resource != NULL) { + cprof_resource_destroy(profiles->resource); + } + + profiles->resource = resource; + } + else { + cprof_resource_destroy(resource); + } + + return result; +} + +static int unpack_instrumentation_scope_name(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_instrumentation_scope *instrumentation_scope; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + instrumentation_scope = (struct cprof_instrumentation_scope *) user_data; + + if (instrumentation_scope->name != NULL) { + cfl_sds_destroy(instrumentation_scope->name); + + instrumentation_scope->name = NULL; + } + + return cprof_mpack_consume_string_or_nil_tag(reader, &instrumentation_scope->name); +} + +static int unpack_instrumentation_scope_version(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_instrumentation_scope *instrumentation_scope; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + instrumentation_scope = (struct cprof_instrumentation_scope *) user_data; + + if (instrumentation_scope->version != NULL) { + cfl_sds_destroy(instrumentation_scope->version); + + instrumentation_scope->version = NULL; + } + + return cprof_mpack_consume_string_or_nil_tag(reader, &instrumentation_scope->version); +} + +static int unpack_instrumentation_scope_attributes(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_instrumentation_scope *instrumentation_scope; + int result; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + instrumentation_scope = (struct cprof_instrumentation_scope *) user_data; + + if (instrumentation_scope->attributes != NULL) { + cfl_kvlist_destroy(instrumentation_scope->attributes); + + instrumentation_scope->attributes = NULL; + } + + result = unpack_cfl_kvlist(reader, &instrumentation_scope->attributes); + + if (result != 0) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + return CPROF_DECODE_MSGPACK_SUCCESS; +} + +static int unpack_instrumentation_scope_dropped_attribute_count(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_instrumentation_scope *instrumentation_scope; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + instrumentation_scope = (struct cprof_instrumentation_scope *) user_data; + + return cprof_mpack_consume_uint32_tag(reader, &instrumentation_scope->dropped_attributes_count); +} + +static int unpack_scope_profiles_entry_instrumentation_scope(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_instrumentation_scope *instrumentation_scope; + struct cprof_scope_profiles *scope_profiles; + int result; + struct cprof_mpack_map_entry_callback_t callbacks[] = \ + { + {"name", unpack_instrumentation_scope_name}, + {"version", unpack_instrumentation_scope_version}, + {"attributes", unpack_instrumentation_scope_attributes}, + {"dropped_attribute_count", unpack_instrumentation_scope_dropped_attribute_count}, + {NULL, NULL} + }; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + scope_profiles = (struct cprof_scope_profiles *) user_data; + + instrumentation_scope = cprof_instrumentation_scope_create(NULL, NULL, NULL, 0); + + if (instrumentation_scope == NULL) { + return CPROF_DECODE_MSGPACK_ALLOCATION_ERROR; + } + + result = cprof_mpack_unpack_map(reader, + callbacks, + (void *) instrumentation_scope); + + if (result == CPROF_DECODE_MSGPACK_SUCCESS) { + if (scope_profiles->scope != NULL) { + cprof_instrumentation_scope_destroy(scope_profiles->scope); + } + + scope_profiles->scope = instrumentation_scope; + } + + if (result != CPROF_DECODE_MSGPACK_SUCCESS) { + cprof_instrumentation_scope_destroy(instrumentation_scope); + } + + return result; +} + +static int unpack_profile_profile_id(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_profile *profile; + int result; + cfl_sds_t value; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + profile = (struct cprof_profile *) user_data; + + result = cprof_mpack_consume_binary_tag(reader, &value); + + if (result == CPROF_MPACK_SUCCESS) { + if (cfl_sds_len(value) != sizeof(profile->profile_id)) { + cfl_sds_destroy(value); + + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + memcpy(profile->profile_id, + value, + sizeof(profile->profile_id)); + + cfl_sds_destroy(value); + } + + return result; +} + +static int unpack_profile_start_time_unix_nano(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_profile *profile; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + profile = (struct cprof_profile *) user_data; + + return cprof_mpack_consume_int64_tag(reader, &profile->start_time_unix_nano); +} + +static int unpack_profile_end_time_unix_nano(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_profile *profile; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + profile = (struct cprof_profile *) user_data; + + return cprof_mpack_consume_int64_tag(reader, &profile->end_time_unix_nano); +} + +static int unpack_profile_attributes(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_profile *profile; + int result; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + profile = (struct cprof_profile *) user_data; + + if (profile->attributes != NULL) { + cfl_kvlist_destroy(profile->attributes); + + profile->attributes = NULL; + } + + result = unpack_cfl_kvlist(reader, &profile->attributes); + + if (result != 0) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + return CPROF_DECODE_MSGPACK_SUCCESS; +} + +static int unpack_profile_dropped_attributes(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_profile *profile; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + profile = (struct cprof_profile *) user_data; + + return cprof_mpack_consume_uint32_tag(reader, &profile->dropped_attributes_count); +} + +static int unpack_value_type_type(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_value_type *sample_type; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + sample_type = (struct cprof_value_type *) user_data; + + return cprof_mpack_consume_int64_tag(reader, &sample_type->type); +} + +static int unpack_value_type_unit(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_value_type *sample_type; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + sample_type = (struct cprof_value_type *) user_data; + + return cprof_mpack_consume_int64_tag(reader, &sample_type->unit); +} + +static int unpack_value_type_aggregation_temporality(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_value_type *sample_type; + int result; + uint64_t value; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + sample_type = (struct cprof_value_type *) user_data; + + result = cprof_mpack_consume_uint64_tag(reader, &value); + + if (result == CPROF_MPACK_SUCCESS) { + sample_type->aggregation_temporality = (int) value; + } + + return result; +} + +static int unpack_profile_sample_types_entry(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_value_type *sample_type; + struct cprof_profile *profile; + int result; + struct cprof_mpack_map_entry_callback_t callbacks[] = \ + { + {"type", unpack_value_type_type}, + {"unit", unpack_value_type_unit}, + {"aggregation_temporality", unpack_value_type_aggregation_temporality}, + {NULL, NULL} + }; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + profile = (struct cprof_profile *) user_data; + + sample_type = cprof_sample_type_create(profile, 0, 0, 0); + + if (sample_type == NULL) { + return CPROF_DECODE_MSGPACK_ALLOCATION_ERROR; + } + + result = cprof_mpack_unpack_map(reader, + callbacks, + (void *) sample_type); + + /* cprof_sample_type_create automatically attaches the newly created + * instance to the parent profile instance, because of + * that in case of failure we just let the parent destructor take care of + * it. + */ + + return result; +} + +static int unpack_profile_sample_types(mpack_reader_t *reader, size_t index, void *user_data) +{ + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + return cprof_mpack_unpack_array(reader, + unpack_profile_sample_types_entry, + user_data); +} + +static int unpack_profile_sample_location_index_entry(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_sample *sample; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + sample = (struct cprof_sample *) user_data; + + if (index >= sample->location_index_count) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + return cprof_mpack_consume_uint64_tag(reader, &sample->location_index[index]); +} + +static int unpack_profile_sample_location_index(mpack_reader_t *reader, size_t index, void *user_data) +{ + int array_length; + struct cprof_sample *sample; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + sample = (struct cprof_sample *) user_data; + + if (sample->location_index != NULL) { + free(sample->location_index); + + sample->location_index = NULL; + } + + array_length = cprof_mpack_peek_array_length(reader); + + if (array_length > 0) { + sample->location_index = calloc(array_length, sizeof(uint64_t)); + + if (sample->location_index == NULL) { + return CPROF_DECODE_MSGPACK_ALLOCATION_ERROR; + } + + sample->location_index_count = (size_t) array_length; + } + + return cprof_mpack_unpack_array(reader, + unpack_profile_sample_location_index_entry, + user_data); +} + +static int unpack_profile_sample_locations_start_index(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_sample *sample; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + sample = (struct cprof_sample *) user_data; + + return cprof_mpack_consume_uint64_tag(reader, &sample->locations_start_index); +} + +static int unpack_profile_sample_locations_length(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_sample *sample; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + sample = (struct cprof_sample *) user_data; + + return cprof_mpack_consume_uint64_tag(reader, &sample->locations_length); +} + +static int unpack_profile_sample_values_entry(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_sample *sample; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + sample = (struct cprof_sample *) user_data; + + if (index >= sample->value_count) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + return cprof_mpack_consume_int64_tag(reader, &sample->values[index]); +} + +static int unpack_profile_sample_values(mpack_reader_t *reader, size_t index, void *user_data) +{ + int array_length; + struct cprof_sample *sample; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + sample = (struct cprof_sample *) user_data; + + if (sample->values != NULL) { + free(sample->values); + + sample->values = NULL; + } + + array_length = cprof_mpack_peek_array_length(reader); + + if (array_length > 0) { + sample->values = calloc(array_length, sizeof(int64_t)); + + if (sample->values == NULL) { + return CPROF_DECODE_MSGPACK_ALLOCATION_ERROR; + } + + sample->value_count = (size_t) array_length; + } + + return cprof_mpack_unpack_array(reader, + unpack_profile_sample_values_entry, + user_data); +} + +static int unpack_profile_sample_attributes_entry(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_sample *sample; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + sample = (struct cprof_sample *) user_data; + + if (index >= sample->attributes_count) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + return cprof_mpack_consume_uint64_tag(reader, &sample->attributes[index]); +} + +static int unpack_profile_sample_attributes(mpack_reader_t *reader, size_t index, void *user_data) +{ + int array_length; + struct cprof_sample *sample; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + sample = (struct cprof_sample *) user_data; + + if (sample->attributes != NULL) { + free(sample->attributes); + + sample->attributes = NULL; + } + + array_length = cprof_mpack_peek_array_length(reader); + + if (array_length > 0) { + sample->attributes = calloc(array_length, sizeof(uint64_t)); + + if (sample->attributes == NULL) { + return CPROF_DECODE_MSGPACK_ALLOCATION_ERROR; + } + + sample->attributes_count = (size_t) array_length; + } + + return cprof_mpack_unpack_array(reader, + unpack_profile_sample_attributes_entry, + user_data); +} + +static int unpack_profile_sample_link(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_sample *sample; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + sample = (struct cprof_sample *) user_data; + + return cprof_mpack_consume_uint64_tag(reader, &sample->link); +} + +static int unpack_profile_sample_timestamps_unix_nano_entry(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_sample *sample; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + sample = (struct cprof_sample *) user_data; + + if (index >= sample->timestamps_count) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + return cprof_mpack_consume_uint64_tag(reader, &sample->timestamps_unix_nano[index]); +} + +static int unpack_profile_sample_timestamps_unix_nano(mpack_reader_t *reader, size_t index, void *user_data) +{ + int array_length; + struct cprof_sample *sample; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + sample = (struct cprof_sample *) user_data; + + if (sample->timestamps_unix_nano != NULL) { + free(sample->timestamps_unix_nano); + + sample->timestamps_unix_nano = NULL; + } + + array_length = cprof_mpack_peek_array_length(reader); + + if (array_length > 0) { + sample->timestamps_unix_nano = calloc(array_length, sizeof(uint64_t)); + + if (sample->timestamps_unix_nano == NULL) { + return CPROF_DECODE_MSGPACK_ALLOCATION_ERROR; + } + + sample->timestamps_count = (size_t) array_length; + } + + return cprof_mpack_unpack_array(reader, + unpack_profile_sample_timestamps_unix_nano_entry, + user_data); +} + +static int unpack_profile_sample_entry(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_sample *sample; + struct cprof_profile *profile; + int result; + struct cprof_mpack_map_entry_callback_t callbacks[] = \ + { + {"location_index", unpack_profile_sample_location_index}, + {"locations_start_index", unpack_profile_sample_locations_start_index}, + {"locations_length", unpack_profile_sample_locations_length}, + {"values", unpack_profile_sample_values}, + {"attributes", unpack_profile_sample_attributes}, + {"link", unpack_profile_sample_link}, + {"timestamps_unix_nano", unpack_profile_sample_timestamps_unix_nano}, + {NULL, NULL} + }; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + profile = (struct cprof_profile *) user_data; + + sample = cprof_sample_create(profile); + + if (sample == NULL) { + return CPROF_DECODE_MSGPACK_ALLOCATION_ERROR; + } + + result = cprof_mpack_unpack_map(reader, + callbacks, + (void *) sample); + + /* cprof_sample_create automatically attaches the newly created + * instance to the parent profile instance, because of + * that in case of failure we just let the parent destructor take care of + * it. + */ + + return result; +} + +static int unpack_profile_sample(mpack_reader_t *reader, size_t index, void *user_data) +{ + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + return cprof_mpack_unpack_array(reader, + unpack_profile_sample_entry, + user_data); +} + + + + + +static int unpack_profile_mapping_id(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_mapping *mapping; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + mapping = (struct cprof_mapping *) user_data; + + return cprof_mpack_consume_uint64_tag(reader, &mapping->id); +} + +static int unpack_profile_mapping_memory_start(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_mapping *mapping; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + mapping = (struct cprof_mapping *) user_data; + + return cprof_mpack_consume_uint64_tag(reader, &mapping->memory_start); +} + +static int unpack_profile_mapping_memory_limit(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_mapping *mapping; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + mapping = (struct cprof_mapping *) user_data; + + return cprof_mpack_consume_uint64_tag(reader, &mapping->memory_limit); +} + +static int unpack_profile_mapping_file_offset(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_mapping *mapping; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + mapping = (struct cprof_mapping *) user_data; + + return cprof_mpack_consume_uint64_tag(reader, &mapping->file_offset); +} + +static int unpack_profile_mapping_filename(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_mapping *mapping; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + mapping = (struct cprof_mapping *) user_data; + + return cprof_mpack_consume_int64_tag(reader, &mapping->filename); +} + +static int unpack_profile_mapping_attributes_entry(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_mapping *mapping; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + mapping = (struct cprof_mapping *) user_data; + + if (index >= mapping->attributes_count) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + return cprof_mpack_consume_uint64_tag(reader, &mapping->attributes[index]); +} + +static int unpack_profile_mapping_attributes(mpack_reader_t *reader, size_t index, void *user_data) +{ + int array_length; + struct cprof_mapping *mapping; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + mapping = (struct cprof_mapping *) user_data; + + if (mapping->attributes != NULL) { + free(mapping->attributes); + + mapping->attributes = NULL; + } + + array_length = cprof_mpack_peek_array_length(reader); + + if (array_length > 0) { + mapping->attributes = calloc(array_length, sizeof(uint64_t)); + + if (mapping->attributes == NULL) { + return CPROF_DECODE_MSGPACK_ALLOCATION_ERROR; + } + + mapping->attributes_count = (size_t) array_length; + } + + return cprof_mpack_unpack_array(reader, + unpack_profile_mapping_attributes_entry, + user_data); +} + +static int unpack_profile_mapping_has_functions(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_mapping *mapping; + int result; + uint64_t value; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + mapping = (struct cprof_mapping *) user_data; + + result = cprof_mpack_consume_uint64_tag(reader, &value); + + if (result == CPROF_MPACK_SUCCESS) { + mapping->has_functions = (bool) value; + } + + return result; +} + +static int unpack_profile_mapping_has_filenames(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_mapping *mapping; + int result; + uint64_t value; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + mapping = (struct cprof_mapping *) user_data; + + result = cprof_mpack_consume_uint64_tag(reader, &value); + + if (result == CPROF_MPACK_SUCCESS) { + mapping->has_filenames = (bool) value; + } + + return result; +} + +static int unpack_profile_mapping_has_line_numbers(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_mapping *mapping; + int result; + uint64_t value; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + mapping = (struct cprof_mapping *) user_data; + + result = cprof_mpack_consume_uint64_tag(reader, &value); + + if (result == CPROF_MPACK_SUCCESS) { + mapping->has_line_numbers = (bool) value; + } + + return result; +} + +static int unpack_profile_mapping_has_inline_frames(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_mapping *mapping; + int result; + uint64_t value; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + mapping = (struct cprof_mapping *) user_data; + + result = cprof_mpack_consume_uint64_tag(reader, &value); + + if (result == CPROF_MPACK_SUCCESS) { + mapping->has_inline_frames = (bool) value; + } + + return result; +} + +static int unpack_profile_mappings_entry(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_mapping *mapping; + struct cprof_profile *profile; + int result; + struct cprof_mpack_map_entry_callback_t callbacks[] = \ + { + {"id", unpack_profile_mapping_id}, + {"memory_start", unpack_profile_mapping_memory_start}, + {"memory_limit", unpack_profile_mapping_memory_limit}, + {"file_offset", unpack_profile_mapping_file_offset}, + {"filename", unpack_profile_mapping_filename}, + {"attributes", unpack_profile_mapping_attributes}, + {"has_functions", unpack_profile_mapping_has_functions}, + {"has_filenames", unpack_profile_mapping_has_filenames}, + {"has_line_numbers", unpack_profile_mapping_has_line_numbers}, + {"has_inline_frames", unpack_profile_mapping_has_inline_frames}, + {NULL, NULL} + }; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + profile = (struct cprof_profile *) user_data; + + mapping = cprof_mapping_create(profile); + + if (mapping == NULL) { + return CPROF_DECODE_MSGPACK_ALLOCATION_ERROR; + } + + result = cprof_mpack_unpack_map(reader, + callbacks, + (void *) mapping); + + /* cprof_mapping_create automatically attaches the newly created + * instance to the parent profile instance, because of + * that in case of failure we just let the parent destructor take care of + * it. + */ + + return result; +} + +static int unpack_profile_mappings(mpack_reader_t *reader, size_t index, void *user_data) +{ + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + return cprof_mpack_unpack_array(reader, + unpack_profile_mappings_entry, + user_data); +} + + + + + + +static int unpack_location_id(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_location *location; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + location = (struct cprof_location *) user_data; + + return cprof_mpack_consume_uint64_tag(reader, &location->id); +} + +static int unpack_location_mapping_index(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_location *location; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + location = (struct cprof_location *) user_data; + + return cprof_mpack_consume_uint64_tag(reader, &location->mapping_index); +} + +static int unpack_location_address(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_location *location; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + location = (struct cprof_location *) user_data; + + return cprof_mpack_consume_uint64_tag(reader, &location->address); +} + + + + + + + +static int unpack_line_function_index(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_line *line; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + line = (struct cprof_line *) user_data; + + return cprof_mpack_consume_uint64_tag(reader, &line->function_index); +} + +static int unpack_line_line(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_line *line; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + line = (struct cprof_line *) user_data; + + return cprof_mpack_consume_int64_tag(reader, &line->line); +} + +static int unpack_line_column(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_line *line; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + line = (struct cprof_line *) user_data; + + return cprof_mpack_consume_int64_tag(reader, &line->column); +} + +static int unpack_location_lines_entry(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_location *location; + struct cprof_line *line; + int result; + struct cprof_mpack_map_entry_callback_t callbacks[] = \ + { + {"function_index", unpack_line_function_index}, + {"line", unpack_line_line}, + {"column", unpack_line_column}, + {NULL, NULL} + }; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + location = (struct cprof_location *) user_data; + + line = cprof_line_create(location); + + if (line == NULL) { + return CPROF_DECODE_MSGPACK_ALLOCATION_ERROR; + } + + result = cprof_mpack_unpack_map(reader, + callbacks, + (void *) line); + + /* cprof_line_create automatically attaches the newly created + * instance to the parent location instance, because of + * that in case of failure we just let the parent destructor take care of + * it. + */ + + return result; +} + +static int unpack_location_lines(mpack_reader_t *reader, size_t index, void *user_data) +{ + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + return cprof_mpack_unpack_array(reader, + unpack_location_lines_entry, + user_data); +} + +static int unpack_location_attributes_entry(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_location *location; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + location = (struct cprof_location *) user_data; + + if (index >= location->attributes_count) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + return cprof_mpack_consume_uint64_tag(reader, &location->attributes[index]); +} + +static int unpack_location_attributes(mpack_reader_t *reader, size_t index, void *user_data) +{ + int array_length; + struct cprof_location *location; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + location = (struct cprof_location *) user_data; + + if (location->attributes != NULL) { + free(location->attributes); + + location->attributes = NULL; + } + + array_length = cprof_mpack_peek_array_length(reader); + + if (array_length > 0) { + location->attributes = calloc(array_length, sizeof(uint64_t)); + + if (location->attributes == NULL) { + return CPROF_DECODE_MSGPACK_ALLOCATION_ERROR; + } + + location->attributes_count = (size_t) array_length; + } + + return cprof_mpack_unpack_array(reader, + unpack_location_attributes_entry, + user_data); +} + +static int unpack_profile_locations_entry(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_location *location; + struct cprof_profile *profile; + int result; + struct cprof_mpack_map_entry_callback_t callbacks[] = \ + { + {"id", unpack_location_id}, + {"mapping_index", unpack_location_mapping_index}, + {"address", unpack_location_address}, + {"lines", unpack_location_lines}, + {"attributes", unpack_location_attributes}, + {NULL, NULL} + }; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + profile = (struct cprof_profile *) user_data; + + location = cprof_location_create(profile); + + if (location == NULL) { + return CPROF_DECODE_MSGPACK_ALLOCATION_ERROR; + } + + result = cprof_mpack_unpack_map(reader, + callbacks, + (void *) location); + + /* cprof_location_create automatically attaches the newly created + * instance to the parent profile instance, because of + * that in case of failure we just let the parent destructor take care of + * it. + */ + + return result; +} + +static int unpack_profile_locations(mpack_reader_t *reader, size_t index, void *user_data) +{ + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + return cprof_mpack_unpack_array(reader, + unpack_profile_locations_entry, + user_data); +} + + + +static int unpack_profile_location_indices_entry(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_profile *profile; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + profile = (struct cprof_profile *) user_data; + + if (index >= profile->location_indices_count) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + return cprof_mpack_consume_int64_tag(reader, &profile->location_indices[index]); +} + +static int unpack_profile_location_indices(mpack_reader_t *reader, size_t index, void *user_data) +{ + int array_length; + struct cprof_profile *profile; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + profile = (struct cprof_profile *) user_data; + + if (profile->location_indices != NULL) { + free(profile->location_indices); + + profile->location_indices = NULL; + profile->location_indices_count = 0; + } + + array_length = cprof_mpack_peek_array_length(reader); + + if (array_length > 0) { + profile->location_indices = calloc(array_length, sizeof(int64_t)); + + if (profile->location_indices == NULL) { + return CPROF_DECODE_MSGPACK_ALLOCATION_ERROR; + } + + profile->location_indices_count = (size_t) array_length; + } + + return cprof_mpack_unpack_array(reader, + unpack_profile_location_indices_entry, + user_data); +} + + + + + + +static int unpack_function_id(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_function *function; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + function = (struct cprof_function *) user_data; + + return cprof_mpack_consume_uint64_tag(reader, &function->id); +} + +static int unpack_function_name(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_function *function; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + function = (struct cprof_function *) user_data; + + return cprof_mpack_consume_int64_tag(reader, &function->name); +} + +static int unpack_function_system_name(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_function *function; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + function = (struct cprof_function *) user_data; + + return cprof_mpack_consume_int64_tag(reader, &function->system_name); +} + +static int unpack_function_filename(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_function *function; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + function = (struct cprof_function *) user_data; + + return cprof_mpack_consume_int64_tag(reader, &function->filename); +} + +static int unpack_function_start_line(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_function *function; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + function = (struct cprof_function *) user_data; + + return cprof_mpack_consume_int64_tag(reader, &function->start_line); +} + +static int unpack_profile_functions_entry(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_function *function; + struct cprof_profile *profile; + int result; + struct cprof_mpack_map_entry_callback_t callbacks[] = \ + { + {"id", unpack_function_id}, + {"name", unpack_function_name}, + {"system_name", unpack_function_system_name}, + {"filename", unpack_function_filename}, + {"start_line", unpack_function_start_line}, + {NULL, NULL} + }; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + profile = (struct cprof_profile *) user_data; + + function = cprof_function_create(profile); + + if (function == NULL) { + return CPROF_DECODE_MSGPACK_ALLOCATION_ERROR; + } + + result = cprof_mpack_unpack_map(reader, + callbacks, + (void *) function); + + /* cprof_function_create automatically attaches the newly created + * instance to the parent profile instance, because of + * that in case of failure we just let the parent destructor take care of + * it. + */ + + return result; +} + +static int unpack_profile_functions(mpack_reader_t *reader, size_t index, void *user_data) +{ + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + return cprof_mpack_unpack_array(reader, + unpack_profile_functions_entry, + user_data); +} + +static int unpack_profile_attribute_table(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_profile *profile; + int result; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + profile = (struct cprof_profile *) user_data; + + if (profile->attribute_table != NULL) { + cfl_kvlist_destroy(profile->attribute_table); + + profile->attribute_table = NULL; + } + + result = unpack_cfl_kvlist(reader, &profile->attribute_table); + + if (result != 0) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + return CPROF_DECODE_MSGPACK_SUCCESS; +} + + + + + + + + +static int unpack_profile_attribute_unit_attribute_key(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_attribute_unit *attribute_unit; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + attribute_unit = (struct cprof_attribute_unit *) user_data; + + return cprof_mpack_consume_int64_tag(reader, &attribute_unit->attribute_key); +} + +static int unpack_profile_attribute_unit_unit(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_attribute_unit *attribute_unit; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + attribute_unit = (struct cprof_attribute_unit *) user_data; + + return cprof_mpack_consume_int64_tag(reader, &attribute_unit->unit); +} + +static int unpack_profile_attribute_units_entry(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_attribute_unit *attribute_unit; + struct cprof_profile *profile; + int result; + struct cprof_mpack_map_entry_callback_t callbacks[] = \ + { + {"attribute_key", unpack_profile_attribute_unit_attribute_key}, + {"unit", unpack_profile_attribute_unit_unit}, + {NULL, NULL} + }; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + profile = (struct cprof_profile *) user_data; + + attribute_unit = cprof_attribute_unit_create(profile); + + if (attribute_unit == NULL) { + return CPROF_DECODE_MSGPACK_ALLOCATION_ERROR; + } + + result = cprof_mpack_unpack_map(reader, + callbacks, + (void *) attribute_unit); + + /* cprof_attribute_unit_create automatically attaches the newly created + * instance to the parent profile instance, because of + * that in case of failure we just let the parent destructor take care of + * it. + */ + + return result; +} + +static int unpack_profile_attribute_units(mpack_reader_t *reader, size_t index, void *user_data) +{ + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + return cprof_mpack_unpack_array(reader, + unpack_profile_attribute_units_entry, + user_data); +} + + +static int unpack_profile_link_trace_id(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_link *link; + cfl_sds_t value; + int result; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + link = (struct cprof_link *) user_data; + + result = cprof_mpack_consume_binary_tag(reader, &value); + + if (result == CPROF_MPACK_SUCCESS) { + if (cfl_sds_len(value) != sizeof(link->trace_id)) { + cfl_sds_destroy(value); + + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + memcpy(link->trace_id, + value, + sizeof(link->trace_id)); + + cfl_sds_destroy(value); + } + + return result; +} + +static int unpack_profile_link_span_id(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_link *link; + cfl_sds_t value; + int result; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + link = (struct cprof_link *) user_data; + + result = cprof_mpack_consume_binary_tag(reader, &value); + + if (result == CPROF_MPACK_SUCCESS) { + if (cfl_sds_len(value) != sizeof(link->span_id)) { + cfl_sds_destroy(value); + + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + memcpy(link->span_id, + value, + sizeof(link->span_id)); + + cfl_sds_destroy(value); + } + + return result; +} + +static int unpack_profile_link_table_entry(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_link *link; + struct cprof_profile *profile; + int result; + struct cprof_mpack_map_entry_callback_t callbacks[] = \ + { + {"trace_id", unpack_profile_link_trace_id}, + {"span_id", unpack_profile_link_span_id}, + {NULL, NULL} + }; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + profile = (struct cprof_profile *) user_data; + + link = cprof_link_create(profile); + + if (link == NULL) { + return CPROF_DECODE_MSGPACK_ALLOCATION_ERROR; + } + + result = cprof_mpack_unpack_map(reader, + callbacks, + (void *) link); + + /* cprof_link_create automatically attaches the newly created + * instance to the parent profile instance, because of + * that in case of failure we just let the parent destructor take care of + * it. + */ + + return result; +} + +static int unpack_profile_link_table(mpack_reader_t *reader, size_t index, void *user_data) +{ + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + return cprof_mpack_unpack_array(reader, + unpack_profile_link_table_entry, + user_data); +} + + + + + + + + + + + +static int unpack_profile_string_table_entry(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_profile *profile; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + profile = (struct cprof_profile *) user_data; + + if (index >= profile->string_table_count) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + return cprof_mpack_consume_string_tag(reader, &profile->string_table[index]); +} + +static int unpack_profile_string_table(mpack_reader_t *reader, size_t index, void *user_data) +{ + int array_length; + struct cprof_profile *profile; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + profile = (struct cprof_profile *) user_data; + + if (profile->string_table != NULL) { + free(profile->string_table); + + profile->string_table = NULL; + profile->string_table_count = 0; + profile->string_table_size = 0; + } + + array_length = cprof_mpack_peek_array_length(reader); + + if (array_length > 0) { + profile->string_table = calloc(array_length, sizeof(char *)); + + if (profile->string_table == NULL) { + return CPROF_DECODE_MSGPACK_ALLOCATION_ERROR; + } + + profile->string_table_count = (size_t) array_length; + profile->string_table_size = (size_t) array_length; + } + + return cprof_mpack_unpack_array(reader, + unpack_profile_string_table_entry, + user_data); +} + + + +static int unpack_profile_drop_frames(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_profile *profile; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + profile = (struct cprof_profile *) user_data; + + return cprof_mpack_consume_int64_tag(reader, &profile->drop_frames); +} + +static int unpack_profile_keep_frames(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_profile *profile; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + profile = (struct cprof_profile *) user_data; + + return cprof_mpack_consume_int64_tag(reader, &profile->keep_frames); +} + +static int unpack_profile_time_nanos(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_profile *profile; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + profile = (struct cprof_profile *) user_data; + + return cprof_mpack_consume_int64_tag(reader, &profile->time_nanos); +} + +static int unpack_profile_duration_nanos(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_profile *profile; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + profile = (struct cprof_profile *) user_data; + + return cprof_mpack_consume_int64_tag(reader, &profile->duration_nanos); +} + + +static int unpack_profile_period_type(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_profile *profile; + struct cprof_mpack_map_entry_callback_t callbacks[] = \ + { + {"type", unpack_value_type_type}, + {"unit", unpack_value_type_unit}, + {"aggregation_temporality", unpack_value_type_aggregation_temporality}, + {NULL, NULL} + }; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + profile = (struct cprof_profile *) user_data; + + return cprof_mpack_unpack_map(reader, + callbacks, + (void *) &profile->period_type); +} + + +static int unpack_profile_period(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_profile *profile; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + profile = (struct cprof_profile *) user_data; + + return cprof_mpack_consume_int64_tag(reader, &profile->period); +} + + + + +static int unpack_profile_comments_entry(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_profile *profile; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + profile = (struct cprof_profile *) user_data; + + if (index >= profile->comments_count) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + return cprof_mpack_consume_int64_tag(reader, &profile->comments[index]); +} + +static int unpack_profile_comments(mpack_reader_t *reader, size_t index, void *user_data) +{ + int array_length; + struct cprof_profile *profile; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + profile = (struct cprof_profile *) user_data; + + if (profile->comments != NULL) { + free(profile->comments); + + profile->comments = NULL; + profile->comments_count = 0; + } + + array_length = cprof_mpack_peek_array_length(reader); + + if (array_length > 0) { + profile->comments = calloc(array_length, sizeof(int64_t)); + + if (profile->comments == NULL) { + return CPROF_DECODE_MSGPACK_ALLOCATION_ERROR; + } + + profile->comments_count = (size_t) array_length; + } + + return cprof_mpack_unpack_array(reader, + unpack_profile_comments_entry, + user_data); +} + +static int unpack_profile_default_sample_type(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_profile *profile; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + profile = (struct cprof_profile *) user_data; + + return cprof_mpack_consume_int64_tag(reader, &profile->default_sample_type); +} + + + + +static int unpack_scope_profiles_entry_profiles_entry(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_scope_profiles *scope_profiles; + struct cprof_profile *profile; + int result; + struct cprof_mpack_map_entry_callback_t callbacks[] = \ + { + {"profile_id", unpack_profile_profile_id}, + {"start_time_unix_nano", unpack_profile_start_time_unix_nano}, + {"end_time_unix_nano", unpack_profile_end_time_unix_nano}, + {"attributes", unpack_profile_attributes}, + {"dropped_attributes", unpack_profile_dropped_attributes}, + {"sample_types", unpack_profile_sample_types}, + {"sample", unpack_profile_sample}, + {"mappings", unpack_profile_mappings}, + {"locations", unpack_profile_locations}, + {"location_indices", unpack_profile_location_indices}, + {"functions", unpack_profile_functions}, + {"attribute_table", unpack_profile_attribute_table}, + {"attribute_units", unpack_profile_attribute_units}, + {"link_table", unpack_profile_link_table}, + {"string_table", unpack_profile_string_table}, + {"drop_frames", unpack_profile_drop_frames}, + {"keep_frames", unpack_profile_keep_frames}, + {"time_nanos", unpack_profile_time_nanos}, + {"duration_nanos", unpack_profile_duration_nanos}, + {"period_type", unpack_profile_period_type}, + {"period", unpack_profile_period}, + {"comments", unpack_profile_comments}, + {"default_sample_type", unpack_profile_default_sample_type}, + {NULL, NULL} + }; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + scope_profiles = (struct cprof_scope_profiles *) user_data; + + profile = cprof_profile_create(); + + if (profile == NULL) { + return CPROF_DECODE_MSGPACK_ALLOCATION_ERROR; + } + + result = cprof_mpack_unpack_map(reader, + callbacks, + (void *) profile); + + if (result == CPROF_DECODE_MSGPACK_SUCCESS) { + cfl_list_add(&profile->_head, &scope_profiles->profiles); + } + else { + cprof_profile_destroy(profile); + } + + return result; +} + +static int unpack_scope_profiles_entry_profiles(mpack_reader_t *reader, size_t index, void *user_data) +{ + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + return cprof_mpack_unpack_array(reader, + unpack_scope_profiles_entry_profiles_entry, + user_data); +} + + +static int unpack_scope_profiles_entry_schema_url(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_scope_profiles *scope_profiles; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + scope_profiles = (struct cprof_scope_profiles *) user_data; + + if (scope_profiles->schema_url != NULL) { + cfl_sds_destroy(scope_profiles->schema_url); + + scope_profiles->schema_url = NULL; + } + + return cprof_mpack_consume_string_or_nil_tag(reader, &scope_profiles->schema_url); +} + +static int unpack_resource_profiles_entry_scope_profiles_entry(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_resource_profiles *resource_profiles; + struct cprof_scope_profiles *scope_profiles; + int result; + struct cprof_mpack_map_entry_callback_t callbacks[] = \ + { + {"instrumentation_scope", unpack_scope_profiles_entry_instrumentation_scope}, + {"profiles", unpack_scope_profiles_entry_profiles}, + {"schema_url", unpack_scope_profiles_entry_schema_url}, + {NULL, NULL} + }; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + resource_profiles = (struct cprof_resource_profiles *) user_data; + + scope_profiles = cprof_scope_profiles_create(resource_profiles, ""); + + if (scope_profiles == NULL) { + return CPROF_DECODE_MSGPACK_ALLOCATION_ERROR; + } + + result = cprof_mpack_unpack_map(reader, + callbacks, + (void *) scope_profiles); + + /* cprof_scope_profiles_create automatically attaches the newly created + * instance to the parent resource cprof profiles instance, because of + * that in case of failure we just let the parent destructor take care of + * it. + */ + + return result; +} + +static int unpack_resource_profiles_entry_scope_profiles(mpack_reader_t *reader, size_t index, void *user_data) +{ + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + return cprof_mpack_unpack_array(reader, + unpack_resource_profiles_entry_scope_profiles_entry, + user_data); +} + +static int unpack_resource_profiles_entry_schema_url(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_resource_profiles *profile; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + profile = (struct cprof_resource_profiles *) user_data; + + if (profile->schema_url != NULL) { + cfl_sds_destroy(profile->schema_url); + + profile->schema_url = NULL; + } + + return cprof_mpack_consume_string_or_nil_tag(reader, &profile->schema_url); +} + +static int unpack_cprof_resource_profiles_entry(mpack_reader_t *reader, size_t index, void *user_data) +{ + struct cprof_resource_profiles *profiles; + struct cprof *context; + int result; + struct cprof_mpack_map_entry_callback_t callbacks[] = \ + { + {"resource", unpack_resource_profiles_entry_resource}, + {"scope_profiles", unpack_resource_profiles_entry_scope_profiles}, + {"schema_url", unpack_resource_profiles_entry_schema_url}, + {NULL, NULL} + }; + + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + context = (struct cprof *) user_data; + + profiles = cprof_resource_profiles_create(""); + + if (profiles == NULL) { + return CPROF_DECODE_MSGPACK_ALLOCATION_ERROR; + } + + result = cprof_mpack_unpack_map(reader, + callbacks, + (void *) profiles); + + if (result == CPROF_DECODE_MSGPACK_SUCCESS) { + result = cprof_resource_profiles_add(context, profiles); + + if (result != 0) { + result = CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + } + + if (result != CPROF_DECODE_MSGPACK_SUCCESS) { + cprof_resource_profiles_destroy(profiles); + } + + return result; +} + +static int unpack_context_profiles(mpack_reader_t *reader, size_t index, void *user_data) +{ + if (reader == NULL || + user_data == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + return cprof_mpack_unpack_array(reader, + unpack_cprof_resource_profiles_entry, + user_data); +} + + +int unpack_context(struct crof_msgpack_decode_context *context) +{ + struct cprof_mpack_map_entry_callback_t callbacks[] = \ + { + {"meta", unpack_context_header}, + {"profiles", unpack_context_profiles}, + {NULL, NULL} + }; + + if (context == NULL) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + return cprof_mpack_unpack_map(&context->reader, + callbacks, + (void *) context->inner_context); +} + +int cprof_decode_msgpack_create(struct cprof **result_context, + unsigned char *in_buf, + size_t in_size, + size_t *offset) +{ + int result; + struct crof_msgpack_decode_context context; + size_t remainder; + + if (result_context == NULL || + in_buf == NULL || + offset == NULL || + in_size < *offset ) { + return CPROF_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR; + } + + if (in_size == 0 || + (in_size - *offset) == 0) { + return CPROF_DECODE_MSGPACK_INSUFFICIENT_DATA; + } + + memset(&context, 0, sizeof(struct crof_msgpack_decode_context)); + + context.inner_context = cprof_create(); + + if (context.inner_context == NULL) { + return CPROF_DECODE_MSGPACK_ALLOCATION_ERROR; + } + + in_size -= *offset; + + mpack_reader_init_data(&context.reader, (const char *) &in_buf[*offset], in_size); + + result = unpack_context(&context); + + remainder = mpack_reader_remaining(&context.reader, NULL); + + *offset += in_size - remainder; + + mpack_reader_destroy(&context.reader); + + if (result != CPROF_DECODE_MSGPACK_SUCCESS) { + cprof_destroy(context.inner_context); + } + else { + *result_context = context.inner_context; + } + + return result; +} + +void cprof_decode_msgpack_destroy(struct cprof *context) +{ + if (context != NULL) { + cprof_destroy(context); + } +} diff --git a/lib/cprofiles/src/cprof_decode_opentelemetry.c b/lib/cprofiles/src/cprof_decode_opentelemetry.c index 2e24bc7c86a..14038a77ab6 100644 --- a/lib/cprofiles/src/cprof_decode_opentelemetry.c +++ b/lib/cprofiles/src/cprof_decode_opentelemetry.c @@ -501,7 +501,7 @@ static int decode_profile_container_entry(struct cprof_scope_profiles *scope_pro return CPROF_DECODE_OPENTELEMETRY_INVALID_ARGUMENT_ERROR; } - profile = cprof_profile_create(NULL); + profile = cprof_profile_create(); if (profile == NULL) { return CPROF_DECODE_OPENTELEMETRY_ALLOCATION_ERROR; diff --git a/lib/cprofiles/src/cprof_encode_msgpack.c b/lib/cprofiles/src/cprof_encode_msgpack.c new file mode 100644 index 00000000000..99d004e53a2 --- /dev/null +++ b/lib/cprofiles/src/cprof_encode_msgpack.c @@ -0,0 +1,955 @@ +/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ + +/* CProfiles + * ========= + * Copyright (C) 2024 The CProfiles Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + +#include +#include + +static inline void mpack_write_sds_or_nil(mpack_writer_t *writer, + cfl_sds_t value) +{ + if (value != NULL) { + mpack_write_str(writer, + value, + cfl_sds_len(value)); + } + else { + mpack_write_nil(writer); + } +} + +static int encode_string_array( + struct cprof_msgpack_encoding_context *context, + char **data_list, + size_t data_length); + +static int encode_uint64_t_array( + struct cprof_msgpack_encoding_context *context, + uint64_t *data_list, + size_t data_length); + +static int encode_int64_t_array( + struct cprof_msgpack_encoding_context *context, + int64_t *data_list, + size_t data_length); + +static int encode_cprof_value_type( + struct cprof_msgpack_encoding_context *context, + struct cprof_value_type *instance); + +static int encode_cprof_sample( + struct cprof_msgpack_encoding_context *context, + struct cprof_sample *instance); + +static int encode_cprof_mapping( + struct cprof_msgpack_encoding_context *context, + struct cprof_mapping *instance); + +static int encode_cprof_line( + struct cprof_msgpack_encoding_context *context, + struct cprof_line *instance); + +static int encode_cprof_location( + struct cprof_msgpack_encoding_context *context, + struct cprof_location *instance); + +static int encode_cprof_function( + struct cprof_msgpack_encoding_context *context, + struct cprof_function *instance); + +static int encode_cprof_attribute_unit( + struct cprof_msgpack_encoding_context *context, + struct cprof_attribute_unit *instance); + + +static int encode_cprof_link( + struct cprof_msgpack_encoding_context *context, + struct cprof_link *instance); + + +static int encode_cprof_profile( + struct cprof_msgpack_encoding_context *context, + struct cprof_profile *instance); + + +static int encode_cprof_resource_profiles( + struct cprof_msgpack_encoding_context *context, + struct cprof_resource_profiles *instance); + + +static int encode_cprof_instrumentation_scope( + struct cprof_msgpack_encoding_context *context, + struct cprof_instrumentation_scope *instance); + + +static int encode_cprof_resource( + struct cprof_msgpack_encoding_context *context, + struct cprof_resource *instance); + + +static int encode_cprof_scope_profiles( + struct cprof_msgpack_encoding_context *context, + struct cprof_scope_profiles *instance); + + +static int encode_string_array( + struct cprof_msgpack_encoding_context *context, + char **data_list, + size_t data_length) +{ + size_t index; + + mpack_start_array(&context->writer, + data_length); + + for (index = 0 ; index < data_length ; index++) { + mpack_write_cstr(&context->writer, data_list[index]); + } + + mpack_finish_array(&context->writer); + + return CPROF_ENCODE_MSGPACK_SUCCESS; +} + +static int encode_uint64_t_array( + struct cprof_msgpack_encoding_context *context, + uint64_t *data_list, + size_t data_length) +{ + size_t index; + + mpack_start_array(&context->writer, + data_length); + + for (index = 0 ; index < data_length ; index++) { + mpack_write_u64(&context->writer, data_list[index]); + } + + mpack_finish_array(&context->writer); + + return CPROF_ENCODE_MSGPACK_SUCCESS; +} + +static int encode_int64_t_array( + struct cprof_msgpack_encoding_context *context, + int64_t *data_list, + size_t data_length) +{ + size_t index; + + mpack_start_array(&context->writer, + data_length); + + for (index = 0 ; index < data_length ; index++) { + mpack_write_i64(&context->writer, data_list[index]); + } + + mpack_finish_array(&context->writer); + + return CPROF_ENCODE_MSGPACK_SUCCESS; +} + + +static int encode_cprof_value_type( + struct cprof_msgpack_encoding_context *context, + struct cprof_value_type *instance) { + mpack_start_map(&context->writer, 3); + + mpack_write_cstr(&context->writer, "type"); + mpack_write_i64(&context->writer, instance->type); + + mpack_write_cstr(&context->writer, "unit"); + mpack_write_i64(&context->writer, instance->unit); + + mpack_write_cstr(&context->writer, "aggregation_temporality"); + mpack_write_u64(&context->writer, instance->aggregation_temporality); + + mpack_finish_map(&context->writer); + + return CPROF_ENCODE_MSGPACK_SUCCESS; +} + +static int encode_cprof_sample( + struct cprof_msgpack_encoding_context *context, + struct cprof_sample *instance) { + int result; + + mpack_start_map(&context->writer, 7); + + mpack_write_cstr(&context->writer, "location_index"); + + result = encode_uint64_t_array(context, + instance->location_index, + instance->location_index_count); + + if (result != CPROF_ENCODE_MSGPACK_SUCCESS) { + return result; + } + + mpack_write_cstr(&context->writer, "locations_start_index"); + mpack_write_u64(&context->writer, instance->locations_start_index); + + mpack_write_cstr(&context->writer, "locations_length"); + mpack_write_u64(&context->writer, instance->locations_length); + + mpack_write_cstr(&context->writer, "values"); + result = encode_int64_t_array(context, + instance->values, + instance->value_count); + + if (result != CPROF_ENCODE_MSGPACK_SUCCESS) { + return result; + } + + mpack_write_cstr(&context->writer, "attributes"); + result = encode_uint64_t_array(context, + instance->attributes, + instance->attributes_count); + + if (result != CPROF_ENCODE_MSGPACK_SUCCESS) { + return result; + } + + mpack_write_cstr(&context->writer, "link"); + mpack_write_u64(&context->writer, instance->link); + + mpack_write_cstr(&context->writer, "timestamps_unix_nano"); + result = encode_uint64_t_array(context, + instance->timestamps_unix_nano, + instance->timestamps_count); + + if (result != CPROF_ENCODE_MSGPACK_SUCCESS) { + return result; + } + + mpack_finish_map(&context->writer); + + return CPROF_ENCODE_MSGPACK_SUCCESS; +} + +static int encode_cprof_mapping( + struct cprof_msgpack_encoding_context *context, + struct cprof_mapping *instance) { + int result; + + mpack_start_map(&context->writer, 10); + + mpack_write_cstr(&context->writer, "id"); + mpack_write_u64(&context->writer, instance->id); + + mpack_write_cstr(&context->writer, "memory_start"); + mpack_write_u64(&context->writer, instance->memory_start); + + mpack_write_cstr(&context->writer, "memory_limit"); + mpack_write_u64(&context->writer, instance->memory_limit); + + mpack_write_cstr(&context->writer, "file_offset"); + mpack_write_u64(&context->writer, instance->file_offset); + + mpack_write_cstr(&context->writer, "filename"); + mpack_write_i64(&context->writer, instance->filename); + + mpack_write_cstr(&context->writer, "attributes"); + result = encode_uint64_t_array(context, + instance->attributes, + instance->attributes_count); + + if (result != CPROF_ENCODE_MSGPACK_SUCCESS) { + return result; + } + + mpack_write_cstr(&context->writer, "has_functions"); + mpack_write_u64(&context->writer, instance->has_functions); + + mpack_write_cstr(&context->writer, "has_filenames"); + mpack_write_u64(&context->writer, instance->has_filenames); + + mpack_write_cstr(&context->writer, "has_line_numbers"); + mpack_write_u64(&context->writer, instance->has_line_numbers); + + mpack_write_cstr(&context->writer, "has_inline_frames"); + mpack_write_u64(&context->writer, instance->has_inline_frames); + + mpack_finish_map(&context->writer); + + return CPROF_ENCODE_MSGPACK_SUCCESS; +} + + + + + +static int encode_cprof_line( + struct cprof_msgpack_encoding_context *context, + struct cprof_line *instance) { + mpack_start_map(&context->writer, 3); + + mpack_write_cstr(&context->writer, "function_index"); + mpack_write_u64(&context->writer, instance->function_index); + + mpack_write_cstr(&context->writer, "line"); + mpack_write_i64(&context->writer, instance->line); + + mpack_write_cstr(&context->writer, "column"); + mpack_write_i64(&context->writer, instance->column); + + mpack_finish_map(&context->writer); + + return CPROF_ENCODE_MSGPACK_SUCCESS; +} + + + +static int encode_cprof_location( + struct cprof_msgpack_encoding_context *context, + struct cprof_location *instance) { + struct cfl_list *iterator; + int result; + struct cprof_line *line; + + mpack_start_map(&context->writer, 5); + + mpack_write_cstr(&context->writer, "id"); + mpack_write_u64(&context->writer, instance->id); + + mpack_write_cstr(&context->writer, "mapping_index"); + mpack_write_u64(&context->writer, instance->mapping_index); + + mpack_write_cstr(&context->writer, "address"); + mpack_write_u64(&context->writer, instance->address); + + mpack_write_cstr(&context->writer, "lines"); + mpack_start_array(&context->writer, cfl_list_size(&instance->lines)); + + if (!cfl_list_is_empty(&instance->lines)) { + cfl_list_foreach(iterator, + &instance->lines) { + line = cfl_list_entry(iterator, + struct cprof_line, _head); + + result = encode_cprof_line(context, line); + + if (result != CPROF_ENCODE_MSGPACK_SUCCESS) { + return result; + } + } + } + + mpack_finish_array(&context->writer); + + mpack_write_cstr(&context->writer, "attributes"); + + result = encode_uint64_t_array(context, + instance->attributes, + instance->attributes_count); + + if (result != CPROF_ENCODE_MSGPACK_SUCCESS) { + return result; + } + + mpack_finish_map(&context->writer); + + return CPROF_ENCODE_MSGPACK_SUCCESS; +} + + + + +static int encode_cprof_function( + struct cprof_msgpack_encoding_context *context, + struct cprof_function *instance) { + mpack_start_map(&context->writer, 5); + + mpack_write_cstr(&context->writer, "id"); + mpack_write_u64(&context->writer, instance->id); + + mpack_write_cstr(&context->writer, "name"); + mpack_write_i64(&context->writer, instance->name); + + mpack_write_cstr(&context->writer, "system_name"); + mpack_write_i64(&context->writer, instance->system_name); + + mpack_write_cstr(&context->writer, "filename"); + mpack_write_i64(&context->writer, instance->filename); + + mpack_write_cstr(&context->writer, "start_line"); + mpack_write_i64(&context->writer, instance->start_line); + + mpack_finish_map(&context->writer); + + return CPROF_ENCODE_MSGPACK_SUCCESS; +} + + + + +static int encode_cprof_attribute_unit( + struct cprof_msgpack_encoding_context *context, + struct cprof_attribute_unit *instance) { + mpack_start_map(&context->writer, 2); + + mpack_write_cstr(&context->writer, "attribute_key"); + mpack_write_i64(&context->writer, instance->attribute_key); + + mpack_write_cstr(&context->writer, "unit"); + mpack_write_i64(&context->writer, instance->unit); + + mpack_finish_map(&context->writer); + + return CPROF_ENCODE_MSGPACK_SUCCESS; +} + +static int encode_cprof_link( + struct cprof_msgpack_encoding_context *context, + struct cprof_link *instance) +{ + mpack_start_map(&context->writer, 2); + + mpack_write_cstr(&context->writer, "trace_id"); + mpack_write_bin(&context->writer, + (const char *) instance->trace_id, + sizeof(instance->trace_id)); + + mpack_write_cstr(&context->writer, "span_id"); + mpack_write_bin(&context->writer, + (const char *) instance->span_id, + sizeof(instance->span_id)); + + mpack_finish_map(&context->writer); + + return CPROF_ENCODE_MSGPACK_SUCCESS; +} + + +static int encode_cprof_profile( + struct cprof_msgpack_encoding_context *context, + struct cprof_profile *instance) { + struct cprof_attribute_unit *attribute_unit; + struct cprof_value_type *sample_type; + struct cfl_list *iterator; + struct cprof_location *location; + struct cprof_function *function; + struct cprof_mapping *mapping; + struct cprof_sample *sample; + int result; + struct cprof_link *link; + + + mpack_start_map(&context->writer, 23); + + mpack_write_cstr(&context->writer, "profile_id"); + mpack_write_bin(&context->writer, + (const char *) instance->profile_id, + sizeof(instance->profile_id)); + + mpack_write_cstr(&context->writer, "start_time_unix_nano"); + mpack_write_i64(&context->writer, instance->start_time_unix_nano); + + mpack_write_cstr(&context->writer, "end_time_unix_nano"); + mpack_write_i64(&context->writer, instance->end_time_unix_nano); + + mpack_write_cstr(&context->writer, "attributes"); + + result = pack_cfl_variant_kvlist(&context->writer, + instance->attributes); + + if (result != 0) { + return -1; + } + + mpack_write_cstr(&context->writer, "dropped_attributes"); + mpack_write_u32(&context->writer, + instance->dropped_attributes_count); + + mpack_write_cstr(&context->writer, "sample_types"); + + mpack_start_array(&context->writer, cfl_list_size(&instance->sample_type)); + + if (!cfl_list_is_empty(&instance->sample_type)) { + cfl_list_foreach(iterator, + &instance->sample_type) { + sample_type = cfl_list_entry( + iterator, + struct cprof_value_type, _head); + + result = encode_cprof_value_type(context, sample_type); + + if (result != CPROF_ENCODE_MSGPACK_SUCCESS) { + return result; + } + } + } + + mpack_finish_array(&context->writer); + + mpack_write_cstr(&context->writer, "sample"); + + mpack_start_array(&context->writer, cfl_list_size(&instance->samples)); + + if (!cfl_list_is_empty(&instance->samples)) { + cfl_list_foreach(iterator, + &instance->samples) { + sample = cfl_list_entry( + iterator, + struct cprof_sample, _head); + + result = encode_cprof_sample(context, sample); + + if (result != CPROF_ENCODE_MSGPACK_SUCCESS) { + return result; + } + } + } + + mpack_finish_array(&context->writer); + + mpack_write_cstr(&context->writer, "mappings"); + + mpack_start_array(&context->writer, cfl_list_size(&instance->mappings)); + + if (!cfl_list_is_empty(&instance->mappings)) { + cfl_list_foreach(iterator, + &instance->mappings) { + mapping = cfl_list_entry( + iterator, + struct cprof_mapping, _head); + + result = encode_cprof_mapping(context, mapping); + + if (result != CPROF_ENCODE_MSGPACK_SUCCESS) { + return result; + } + } + } + + mpack_finish_array(&context->writer); + + mpack_write_cstr(&context->writer, "locations"); + + mpack_start_array(&context->writer, cfl_list_size(&instance->locations)); + + if (!cfl_list_is_empty(&instance->locations)) { + cfl_list_foreach(iterator, + &instance->locations) { + location = cfl_list_entry( + iterator, + struct cprof_location, _head); + + result = encode_cprof_location(context, location); + + if (result != CPROF_ENCODE_MSGPACK_SUCCESS) { + return result; + } + } + } + + mpack_finish_array(&context->writer); + + mpack_write_cstr(&context->writer, "location_indices"); + + result = encode_int64_t_array(context, + instance->location_indices, + instance->location_indices_count); + + if (result != CPROF_ENCODE_MSGPACK_SUCCESS) { + return result; + } + + mpack_write_cstr(&context->writer, "functions"); + + mpack_start_array(&context->writer, cfl_list_size(&instance->functions)); + + if (!cfl_list_is_empty(&instance->functions)) { + cfl_list_foreach(iterator, + &instance->functions) { + function = cfl_list_entry( + iterator, + struct cprof_function, _head); + + result = encode_cprof_function(context, function); + + if (result != CPROF_ENCODE_MSGPACK_SUCCESS) { + return result; + } + } + } + + mpack_finish_array(&context->writer); + + mpack_write_cstr(&context->writer, "attribute_table"); + + result = pack_cfl_variant_kvlist(&context->writer, + instance->attribute_table); + + if (result != 0) { + return -1; + } + + mpack_write_cstr(&context->writer, "attribute_units"); + + mpack_start_array(&context->writer, cfl_list_size(&instance->attribute_units)); + + if (!cfl_list_is_empty(&instance->attribute_units)) { + cfl_list_foreach(iterator, + &instance->attribute_units) { + attribute_unit = cfl_list_entry( + iterator, + struct cprof_attribute_unit, _head); + + result = encode_cprof_attribute_unit(context, attribute_unit); + + if (result != CPROF_ENCODE_MSGPACK_SUCCESS) { + return result; + } + } + } + + mpack_finish_array(&context->writer); + + mpack_write_cstr(&context->writer, "link_table"); + + mpack_start_array(&context->writer, cfl_list_size(&instance->link_table)); + + if (!cfl_list_is_empty(&instance->link_table)) { + cfl_list_foreach(iterator, + &instance->link_table) { + link = cfl_list_entry( + iterator, + struct cprof_link, _head); + + result = encode_cprof_link(context, link); + + if (result != CPROF_ENCODE_MSGPACK_SUCCESS) { + return result; + } + } + } + + mpack_finish_array(&context->writer); + + mpack_write_cstr(&context->writer, "string_table"); + + result = encode_string_array( + context, + (char **) instance->string_table, + instance->string_table_count); + + if (result != CPROF_ENCODE_MSGPACK_SUCCESS) { + return result; + } + + mpack_write_cstr(&context->writer, "drop_frames"); + mpack_write_i64(&context->writer, instance->drop_frames); + + mpack_write_cstr(&context->writer, "keep_frames"); + mpack_write_i64(&context->writer, instance->keep_frames); + + mpack_write_cstr(&context->writer, "time_nanos"); + mpack_write_i64(&context->writer, instance->time_nanos); + + mpack_write_cstr(&context->writer, "duration_nanos"); + mpack_write_i64(&context->writer, instance->duration_nanos); + + mpack_write_cstr(&context->writer, "period_type"); + result = encode_cprof_value_type(context, &instance->period_type); + + if (result != CPROF_ENCODE_MSGPACK_SUCCESS) { + return result; + } + + mpack_write_cstr(&context->writer, "period"); + mpack_write_i64(&context->writer, instance->period); + + mpack_write_cstr(&context->writer, "comments"); + result = encode_int64_t_array(context, + instance->comments, + instance->comments_count); + + if (result != CPROF_ENCODE_MSGPACK_SUCCESS) { + return result; + } + + mpack_write_cstr(&context->writer, "default_sample_type"); + mpack_write_i64(&context->writer, instance->default_sample_type); + + mpack_finish_map(&context->writer); + + return CPROF_ENCODE_MSGPACK_SUCCESS; +} + +static int encode_cprof_resource_profiles( + struct cprof_msgpack_encoding_context *context, + struct cprof_resource_profiles *instance) { + int result; + struct cfl_list *iterator; + struct cprof_scope_profiles *scope_profile; + + mpack_start_map(&context->writer, 3); + mpack_write_cstr(&context->writer, "resource"); + + result = encode_cprof_resource(context, instance->resource); + + if (result != CPROF_ENCODE_MSGPACK_SUCCESS) { + return result; + } + + mpack_write_cstr(&context->writer, "scope_profiles"); + + mpack_start_array(&context->writer, cfl_list_size(&instance->scope_profiles)); + + if (!cfl_list_is_empty(&instance->scope_profiles)) { + cfl_list_foreach(iterator, + &instance->scope_profiles) { + scope_profile = cfl_list_entry( + iterator, + struct cprof_scope_profiles, _head); + + result = encode_cprof_scope_profiles(context, scope_profile); + + if (result != CPROF_ENCODE_MSGPACK_SUCCESS) { + return result; + } + } + } + + mpack_finish_array(&context->writer); + + mpack_write_cstr(&context->writer, "schema_url"); + + mpack_write_sds_or_nil(&context->writer, + instance->schema_url); + + mpack_finish_map(&context->writer); + + return CPROF_ENCODE_MSGPACK_SUCCESS; +} + +static int encode_cprof_instrumentation_scope( + struct cprof_msgpack_encoding_context *context, + struct cprof_instrumentation_scope *instance) { + int result; + + mpack_start_map(&context->writer, 4); + + mpack_write_cstr(&context->writer, "name"); + mpack_write_sds_or_nil(&context->writer, + instance->name); + + + mpack_write_cstr(&context->writer, "version"); + mpack_write_sds_or_nil(&context->writer, + instance->version); + + + mpack_write_cstr(&context->writer, "attributes"); + + result = pack_cfl_variant_kvlist(&context->writer, + instance->attributes); + + if (result != 0) { + return -1; + } + + mpack_write_cstr(&context->writer, "dropped_attribute_count"); + mpack_write_u32(&context->writer, instance->dropped_attributes_count); + + return CPROF_ENCODE_MSGPACK_SUCCESS; +} + + + +static int encode_cprof_resource( + struct cprof_msgpack_encoding_context *context, + struct cprof_resource *instance) { + int result; + + mpack_start_map(&context->writer, 2); + + mpack_write_cstr(&context->writer, "attributes"); + + result = pack_cfl_variant_kvlist(&context->writer, + instance->attributes); + + if (result != 0) { + return -1; + } + + mpack_write_cstr(&context->writer, "dropped_attribute_count"); + mpack_write_u32(&context->writer, instance->dropped_attributes_count); + + return CPROF_ENCODE_MSGPACK_SUCCESS; +} + + + + + +static int encode_cprof_scope_profiles( + struct cprof_msgpack_encoding_context *context, + struct cprof_scope_profiles *instance) { + int result; + struct cfl_list *iterator; + struct cprof_profile *profile; + + mpack_start_map(&context->writer, 3); + mpack_write_cstr(&context->writer, "instrumentation_scope"); + + result = encode_cprof_instrumentation_scope(context, instance->scope); + + if (result != CPROF_ENCODE_MSGPACK_SUCCESS) { + return result; + } + + mpack_write_cstr(&context->writer, "profiles"); + + mpack_start_array(&context->writer, cfl_list_size(&instance->profiles)); + + if (!cfl_list_is_empty(&instance->profiles)) { + cfl_list_foreach(iterator, + &instance->profiles) { + profile = cfl_list_entry( + iterator, + struct cprof_profile, _head); + + result = encode_cprof_profile(context, profile); + + if (result != CPROF_ENCODE_MSGPACK_SUCCESS) { + return result; + } + } + } + + mpack_finish_array(&context->writer); + + mpack_write_cstr(&context->writer, "schema_url"); + + mpack_write_sds_or_nil(&context->writer, + instance->schema_url); + + mpack_finish_map(&context->writer); + + return CPROF_ENCODE_MSGPACK_SUCCESS; +} + +static int pack_context_header(struct cprof_msgpack_encoding_context *context, + struct cprof *profile) +{ + mpack_write_cstr(&context->writer, "meta"); + mpack_start_map(&context->writer, 0); + mpack_finish_map(&context->writer); + + return 0; +} + +static int pack_context_profiles(struct cprof_msgpack_encoding_context *context, + struct cprof *profile) +{ + int result; + struct cfl_list *iterator; + size_t profile_count; + struct cprof_resource_profiles *resource_profiles; + + profile_count = 0 ; + profile_count = cfl_list_size(&profile->profiles); + + mpack_write_cstr(&context->writer, "profiles"); + mpack_start_array(&context->writer, profile_count); + + if (!cfl_list_is_empty(&profile->profiles)) { + cfl_list_foreach(iterator, + &profile->profiles) { + resource_profiles = cfl_list_entry( + iterator, + struct cprof_resource_profiles, _head); + + result = encode_cprof_resource_profiles(context, resource_profiles); + + if (result != CPROF_ENCODE_MSGPACK_SUCCESS) { + return result; + } + } + } + + mpack_finish_array(&context->writer); + + return CPROF_ENCODE_MSGPACK_SUCCESS; +} + +static int pack_context(struct cprof_msgpack_encoding_context *context, + struct cprof *profile) +{ + int result; + + mpack_start_map(&context->writer, 2); + + result = pack_context_header(context, profile); + + if (result != 0) { + return -1; + } + + result = pack_context_profiles(context, profile); + + if (result != 0) { + return -2; + } + + mpack_finish_map(&context->writer); /* outermost context scope */ + + return 0; +} + +int cprof_encode_msgpack_create(cfl_sds_t *result_buffer, + struct cprof *profile) +{ + int result; + struct cprof_msgpack_encoding_context context; + + *result_buffer = NULL; + + memset(&context, 0, sizeof(context)); + + mpack_writer_init_growable(&context.writer, + &context.output_buffer, + &context.output_size); + + + result = pack_context(&context, profile); + + if (mpack_writer_destroy(&context.writer) != mpack_ok) { + fprintf(stderr, "An error occurred encoding the data!\n"); + } + + if (result == CPROF_ENCODE_MSGPACK_SUCCESS) { + *result_buffer = cfl_sds_create_len(context.output_buffer, context.output_size); + } + + if (context.output_buffer != NULL) { + free(context.output_buffer); + } + + return result; +} + +void cprof_encode_msgpack_destroy(cfl_sds_t instance) +{ + if (instance != NULL) { + cfl_sds_destroy(instance); + } +} diff --git a/lib/cprofiles/src/cprof_encode_opentelemetry.c b/lib/cprofiles/src/cprof_encode_opentelemetry.c new file mode 100644 index 00000000000..59409c21cb7 --- /dev/null +++ b/lib/cprofiles/src/cprof_encode_opentelemetry.c @@ -0,0 +1,2388 @@ +/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ + +/* CProfiles + * ========= + * Copyright (C) 2024 The CProfiles Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + +#include +#include + +static int is_string_releaseable(char *address) + { + return (address != NULL && + address != protobuf_c_empty_string); +} + +static inline Opentelemetry__Proto__Common__V1__AnyValue *cfl_variant_to_otlp_any_value(struct cfl_variant *value); +static inline Opentelemetry__Proto__Common__V1__KeyValue *cfl_variant_kvpair_to_otlp_kvpair(struct cfl_kvpair *input_pair); +static inline Opentelemetry__Proto__Common__V1__AnyValue *cfl_variant_kvlist_to_otlp_any_value(struct cfl_variant *value); + +static inline void otlp_any_value_destroy(Opentelemetry__Proto__Common__V1__AnyValue *value); +static inline void otlp_kvpair_destroy(Opentelemetry__Proto__Common__V1__KeyValue *kvpair); +static inline void otlp_kvlist_destroy(Opentelemetry__Proto__Common__V1__KeyValueList *kvlist); +static inline void otlp_array_destroy(Opentelemetry__Proto__Common__V1__ArrayValue *array); + +static inline void otlp_kvpair_list_destroy(Opentelemetry__Proto__Common__V1__KeyValue **pair_list, size_t entry_count); + +static inline void otlp_kvpair_destroy(Opentelemetry__Proto__Common__V1__KeyValue *kvpair) +{ + if (kvpair != NULL) { + if (kvpair->key != NULL) { + free(kvpair->key); + } + + if (kvpair->value != NULL) { + otlp_any_value_destroy(kvpair->value); + } + + free(kvpair); + } +} + +static inline void otlp_kvlist_destroy(Opentelemetry__Proto__Common__V1__KeyValueList *kvlist) +{ + size_t index; + + if (kvlist != NULL) { + if (kvlist->values != NULL) { + for (index = 0 ; index < kvlist->n_values ; index++) { + otlp_kvpair_destroy(kvlist->values[index]); + } + + free(kvlist->values); + } + + free(kvlist); + } +} + +static inline void otlp_array_destroy(Opentelemetry__Proto__Common__V1__ArrayValue *array) +{ + size_t index; + + if (array != NULL) { + if (array->values != NULL) { + for (index = 0 ; index < array->n_values ; index++) { + otlp_any_value_destroy(array->values[index]); + } + + free(array->values); + } + + free(array); + } +} + +static inline void otlp_any_value_destroy(Opentelemetry__Proto__Common__V1__AnyValue *value) +{ + if (value != NULL) { + if (value->value_case == OPENTELEMETRY__PROTO__COMMON__V1__ANY_VALUE__VALUE_STRING_VALUE) { + if (value->string_value != NULL) { + free(value->string_value); + } + } + else if (value->value_case == OPENTELEMETRY__PROTO__COMMON__V1__ANY_VALUE__VALUE_ARRAY_VALUE) { + if (value->array_value != NULL) { + otlp_array_destroy(value->array_value); + } + } + else if (value->value_case == OPENTELEMETRY__PROTO__COMMON__V1__ANY_VALUE__VALUE_KVLIST_VALUE) { + if (value->kvlist_value != NULL) { + otlp_kvlist_destroy(value->kvlist_value); + } + } + else if (value->value_case == OPENTELEMETRY__PROTO__COMMON__V1__ANY_VALUE__VALUE_BYTES_VALUE) { + if (value->bytes_value.data != NULL) { + free(value->bytes_value.data); + } + } + + free(value); + } +} + +static inline Opentelemetry__Proto__Common__V1__KeyValue **otlp_kvpair_list_initialize(size_t entry_count) +{ + Opentelemetry__Proto__Common__V1__KeyValue **result; + + result = \ + calloc(entry_count, sizeof(Opentelemetry__Proto__Common__V1__KeyValue *)); + + return result; +} + + +static Opentelemetry__Proto__Common__V1__ArrayValue *otlp_array_value_initialize(size_t entry_count) +{ + Opentelemetry__Proto__Common__V1__ArrayValue *value; + + value = calloc(1, sizeof(Opentelemetry__Proto__Common__V1__ArrayValue)); + + if (value != NULL) { + opentelemetry__proto__common__v1__array_value__init(value); + + if (entry_count > 0) { + value->values = \ + calloc(entry_count, + sizeof(Opentelemetry__Proto__Common__V1__AnyValue *)); + + if (value->values == NULL) { + free(value); + + value = NULL; + } + else { + value->n_values = entry_count; + } + } + } + + return value; +} + +static Opentelemetry__Proto__Common__V1__KeyValue *otlp_kvpair_value_initialize() +{ + Opentelemetry__Proto__Common__V1__KeyValue *value; + + value = calloc(1, sizeof(Opentelemetry__Proto__Common__V1__KeyValue)); + + if (value != NULL) { + opentelemetry__proto__common__v1__key_value__init(value); + } + + return value; +} + +static Opentelemetry__Proto__Common__V1__KeyValueList *otlp_kvlist_value_initialize(size_t entry_count) +{ + Opentelemetry__Proto__Common__V1__KeyValueList *value; + + value = calloc(1, sizeof(Opentelemetry__Proto__Common__V1__KeyValueList)); + + if (value != NULL) { + opentelemetry__proto__common__v1__key_value_list__init(value); + + if (entry_count > 0) { + value->values = \ + calloc(entry_count, + sizeof(Opentelemetry__Proto__Common__V1__KeyValue *)); + + if (value->values == NULL) { + free(value); + + value = NULL; + } + else { + value->n_values = entry_count; + } + } + } + + return value; +} + +static Opentelemetry__Proto__Common__V1__AnyValue *otlp_any_value_initialize(int data_type, size_t entry_count) +{ + Opentelemetry__Proto__Common__V1__AnyValue *value; + + value = calloc(1, sizeof(Opentelemetry__Proto__Common__V1__AnyValue)); + + if (value == NULL) { + return NULL; + } + + opentelemetry__proto__common__v1__any_value__init(value); + + if (data_type == CFL_VARIANT_STRING) { + value->value_case = OPENTELEMETRY__PROTO__COMMON__V1__ANY_VALUE__VALUE_STRING_VALUE; + } + else if (data_type == CFL_VARIANT_BOOL) { + value->value_case = OPENTELEMETRY__PROTO__COMMON__V1__ANY_VALUE__VALUE_BOOL_VALUE; + } + else if (data_type == CFL_VARIANT_INT) { + value->value_case = OPENTELEMETRY__PROTO__COMMON__V1__ANY_VALUE__VALUE_INT_VALUE; + } + else if (data_type == CFL_VARIANT_DOUBLE) { + value->value_case = OPENTELEMETRY__PROTO__COMMON__V1__ANY_VALUE__VALUE_DOUBLE_VALUE; + } + else if (data_type == CFL_VARIANT_ARRAY) { + value->value_case = OPENTELEMETRY__PROTO__COMMON__V1__ANY_VALUE__VALUE_ARRAY_VALUE; + + value->array_value = otlp_array_value_initialize(entry_count); + + if (value->array_value == NULL) { + free(value); + + value = NULL; + } + } + else if (data_type == CFL_VARIANT_KVLIST) { + value->value_case = OPENTELEMETRY__PROTO__COMMON__V1__ANY_VALUE__VALUE_KVLIST_VALUE; + + value->kvlist_value = otlp_kvlist_value_initialize(entry_count); + + if (value->kvlist_value == NULL) { + free(value); + + value = NULL; + } + } + else if (data_type == CFL_VARIANT_BYTES) { + value->value_case = OPENTELEMETRY__PROTO__COMMON__V1__ANY_VALUE__VALUE_BYTES_VALUE; + } + else if (data_type == CFL_VARIANT_REFERENCE) { + value->value_case = OPENTELEMETRY__PROTO__COMMON__V1__ANY_VALUE__VALUE_STRING_VALUE; + } + else { + free(value); + + value = NULL; + } + + return value; +} + +static inline Opentelemetry__Proto__Common__V1__KeyValue *cfl_variant_kvpair_to_otlp_kvpair(struct cfl_kvpair *input_pair) +{ + Opentelemetry__Proto__Common__V1__KeyValue *pair; + + pair = otlp_kvpair_value_initialize(); + + if (pair != NULL) { + pair->key = strdup(input_pair->key); + + if (pair->key != NULL) { + pair->value = cfl_variant_to_otlp_any_value(input_pair->val); + + if (pair->value == NULL) { + free(pair->key); + + pair->key = NULL; + } + } + + if (pair->key == NULL) { + free(pair); + + pair = NULL; + } + } + + return pair; +} + +static inline void otlp_kvpair_list_destroy(Opentelemetry__Proto__Common__V1__KeyValue **pair_list, size_t entry_count) +{ + size_t index; + + if (pair_list != NULL) { + for (index = 0 ; index < entry_count ; index++) { + otlp_kvpair_destroy(pair_list[index]); + } + + free(pair_list); + } +} + +static inline Opentelemetry__Proto__Common__V1__KeyValue **cfl_kvlist_to_otlp_kvpair_list(struct cfl_kvlist *kvlist) +{ + size_t entry_count; + Opentelemetry__Proto__Common__V1__KeyValue *keyvalue; + struct cfl_list *iterator; + Opentelemetry__Proto__Common__V1__KeyValue **result; + struct cfl_kvpair *kvpair; + size_t index; + + entry_count = cfl_kvlist_count(kvlist); + + result = otlp_kvpair_list_initialize(entry_count + 1); + + if (result != NULL) { + index = 0; + + cfl_list_foreach(iterator, &kvlist->list) { + kvpair = cfl_list_entry(iterator, struct cfl_kvpair, _head); + + keyvalue = cfl_variant_kvpair_to_otlp_kvpair(kvpair); + + if (keyvalue == NULL) { + otlp_kvpair_list_destroy(result, entry_count); + + result = NULL; + + break; + } + + result[index++] = keyvalue; + } + } + + return result; +} + + +static inline Opentelemetry__Proto__Common__V1__AnyValue *cfl_variant_kvlist_to_otlp_any_value(struct cfl_variant *value) +{ + size_t entry_count; + Opentelemetry__Proto__Common__V1__KeyValue *keyvalue; + struct cfl_list *iterator; + Opentelemetry__Proto__Common__V1__AnyValue *result; + struct cfl_kvpair *kvpair; + struct cfl_kvlist *kvlist; + size_t index; + + + kvlist = value->data.as_kvlist; + + entry_count = cfl_kvlist_count(kvlist); + + result = otlp_any_value_initialize(CFL_VARIANT_KVLIST, entry_count); + + if (result != NULL) { + index = 0; + + cfl_list_foreach(iterator, &kvlist->list) { + kvpair = cfl_list_entry(iterator, struct cfl_kvpair, _head); + + keyvalue = cfl_variant_kvpair_to_otlp_kvpair(kvpair); + + if (keyvalue == NULL) { + otlp_any_value_destroy(result); + + result = NULL; + + break; + } + + result->kvlist_value->values[index++] = keyvalue; + } + } + + return result; +} + + +static inline Opentelemetry__Proto__Common__V1__AnyValue *cfl_variant_array_to_otlp_any_value(struct cfl_variant *value) +{ + size_t entry_count; + Opentelemetry__Proto__Common__V1__AnyValue *entry_value; + Opentelemetry__Proto__Common__V1__AnyValue *result; + struct cfl_array *array; + size_t index; + + array = value->data.as_array; + + entry_count = array->entry_count; + + result = otlp_any_value_initialize(CFL_VARIANT_ARRAY, entry_count); + + if (result != NULL) { + index = 0; + + for (index = 0 ; index < entry_count ; index++) { + entry_value = cfl_variant_to_otlp_any_value(cfl_array_fetch_by_index(array, index)); + + if (entry_value == NULL) { + otlp_any_value_destroy(result); + + result = NULL; + + break; + } + + result->array_value->values[index] = entry_value; + } + } + + return result; +} + +static inline Opentelemetry__Proto__Common__V1__AnyValue *cfl_variant_string_to_otlp_any_value(struct cfl_variant *value) +{ + Opentelemetry__Proto__Common__V1__AnyValue *result; + + result = otlp_any_value_initialize(CFL_VARIANT_STRING, 0); + + if (result != NULL) { + result->string_value = strdup(value->data.as_string); + + if (result->string_value == NULL) { + otlp_any_value_destroy(result); + + result = NULL; + } + } + + return result; +} + +static inline Opentelemetry__Proto__Common__V1__AnyValue *cfl_variant_boolean_to_otlp_any_value(struct cfl_variant *value) +{ + Opentelemetry__Proto__Common__V1__AnyValue *result; + + result = otlp_any_value_initialize(CFL_VARIANT_BOOL, 0); + + if (result != NULL) { + result->bool_value = value->data.as_bool; + } + + return result; +} + +static inline Opentelemetry__Proto__Common__V1__AnyValue *cfl_variant_int64_to_otlp_any_value(struct cfl_variant *value) +{ + Opentelemetry__Proto__Common__V1__AnyValue *result; + + result = otlp_any_value_initialize(CFL_VARIANT_INT, 0); + + if (result != NULL) { + result->int_value = value->data.as_int64; + } + + return result; +} + +static inline Opentelemetry__Proto__Common__V1__AnyValue *cfl_variant_double_to_otlp_any_value(struct cfl_variant *value) +{ + Opentelemetry__Proto__Common__V1__AnyValue *result; + + result = otlp_any_value_initialize(CFL_VARIANT_DOUBLE, 0); + + if (result != NULL) { + result->double_value = value->data.as_double; + } + + return result; +} + +static inline Opentelemetry__Proto__Common__V1__AnyValue *cfl_variant_binary_to_otlp_any_value(struct cfl_variant *value) +{ + Opentelemetry__Proto__Common__V1__AnyValue *result; + + result = otlp_any_value_initialize(CFL_VARIANT_BYTES, 0); + + if (result != NULL) { + result->bytes_value.len = cfl_sds_len(value->data.as_bytes); + result->bytes_value.data = calloc(result->bytes_value.len, sizeof(char)); + + if (result->bytes_value.data) { + memcpy(result->bytes_value.data, value->data.as_bytes, result->bytes_value.len); + } + else { + otlp_any_value_destroy(result); + result = NULL; + } + } + + return result; +} + +static inline Opentelemetry__Proto__Common__V1__AnyValue *cfl_variant_to_otlp_any_value(struct cfl_variant *value) +{ + Opentelemetry__Proto__Common__V1__AnyValue *result; + + if (value->type == CFL_VARIANT_STRING) { + result = cfl_variant_string_to_otlp_any_value(value); + } + else if (value->type == CFL_VARIANT_BOOL) { + result = cfl_variant_boolean_to_otlp_any_value(value); + } + else if (value->type == CFL_VARIANT_INT) { + result = cfl_variant_int64_to_otlp_any_value(value); + } + else if (value->type == CFL_VARIANT_DOUBLE) { + result = cfl_variant_double_to_otlp_any_value(value); + } + else if (value->type == CFL_VARIANT_ARRAY) { + result = cfl_variant_array_to_otlp_any_value(value); + } + else if (value->type == CFL_VARIANT_KVLIST) { + result = cfl_variant_kvlist_to_otlp_any_value(value); + } + else if (value->type == CFL_VARIANT_BYTES) { + result = cfl_variant_binary_to_otlp_any_value(value); + } + else if (value->type == CFL_VARIANT_REFERENCE) { + result = cfl_variant_string_to_otlp_any_value(value); + } + else { + result = NULL; + } + + return result; +} + + + + + + + +static void destroy_attribute( + Opentelemetry__Proto__Common__V1__KeyValue *attribute); + +static void destroy_attribute_list( + Opentelemetry__Proto__Common__V1__KeyValue **attribute_list); + +static Opentelemetry__Proto__Common__V1__KeyValue ** + initialize_attribute_list( + size_t element_count); + +static void destroy_attribute(Opentelemetry__Proto__Common__V1__KeyValue *attribute) +{ + if (attribute != NULL) { + if (attribute->value != NULL) { + if (attribute->value->value_case == \ + OPENTELEMETRY__PROTO__COMMON__V1__ANY_VALUE__VALUE_STRING_VALUE) { + if (is_string_releaseable(attribute->value->string_value)) { + free(attribute->value->string_value); + } + } + + free(attribute->value); + } + + if (is_string_releaseable(attribute->key)) { + free(attribute->key); + } + + free(attribute); + } +} + +static void destroy_attribute_list( + Opentelemetry__Proto__Common__V1__KeyValue **attribute_list) +{ + size_t element_index; + + if (attribute_list != NULL) { + for (element_index = 0 ; + attribute_list[element_index] != NULL ; + element_index++) { + destroy_attribute(attribute_list[element_index]); + + attribute_list[element_index] = NULL; + } + + free(attribute_list); + } +} + +static Opentelemetry__Proto__Common__V1__KeyValue ** + initialize_attribute_list( + size_t element_count) +{ + Opentelemetry__Proto__Common__V1__KeyValue **attribute_list; + + attribute_list = calloc(element_count + 1, + sizeof(Opentelemetry__Proto__Common__V1__KeyValue *)); + + return attribute_list; +} + + + + + +static void destroy_value_type( + Opentelemetry__Proto__Profiles__V1development__ValueType * + instance) +{ + if (instance != NULL) { + free(instance); + } +} + +static void destroy_sample( + Opentelemetry__Proto__Profiles__V1development__Sample * + instance) +{ + if (instance != NULL) { + if (instance->location_index != NULL) { + free(instance->location_index); + } + + if (instance->value != NULL) { + free(instance->value); + } + + if (instance->attributes != NULL) { + free(instance->attributes); + } + + if (instance->timestamps_unix_nano != NULL) { + free(instance->timestamps_unix_nano); + } + + free(instance); + } +} + + +static void destroy_mapping( + Opentelemetry__Proto__Profiles__V1development__Mapping * + instance) +{ + if (instance != NULL) { + if (instance->attributes != NULL) { + free(instance->attributes); + } + + free(instance); + } +} + + +static void destroy_resource( + Opentelemetry__Proto__Resource__V1__Resource * + instance) +{ + if (instance != NULL) { + destroy_attribute_list(instance->attributes); + + free(instance); + } +} + +static void destroy_line( + Opentelemetry__Proto__Profiles__V1development__Line * + instance) +{ + if (instance != NULL) { + free(instance); + } +} + +static void destroy_link( + Opentelemetry__Proto__Profiles__V1development__Link * + instance) +{ + if (instance != NULL) { + if (instance->trace_id.data != NULL) { + if (is_string_releaseable((cfl_sds_t) instance->trace_id.data)) { + cfl_sds_destroy((cfl_sds_t) instance->trace_id.data); + } + } + + if (instance->span_id.data != NULL) { + if (is_string_releaseable((cfl_sds_t) instance->span_id.data)) { + cfl_sds_destroy((cfl_sds_t) instance->span_id.data); + } + } + + free(instance); + } +} + + +static void destroy_location( + Opentelemetry__Proto__Profiles__V1development__Location * + instance) +{ + size_t index; + + if (instance != NULL) { + if (instance->line != NULL) { + for (index = 0 ; index < instance->n_line ; index++) { + destroy_line(instance->line[index]); + } + + free(instance->line); + } + + if (instance->attributes != NULL) { + free(instance->attributes); + } + + free(instance); + } +} + +static void destroy_attribute_unit( + Opentelemetry__Proto__Profiles__V1development__AttributeUnit * + instance) +{ + if (instance != NULL) { + free(instance); + } +} + +static void destroy_function( + Opentelemetry__Proto__Profiles__V1development__Function * + instance) +{ + if (instance != NULL) { + free(instance); + } +} + +static void destroy_instrumentation_scope( + Opentelemetry__Proto__Common__V1__InstrumentationScope * + instance) +{ + if (instance != NULL) { + destroy_attribute_list(instance->attributes); + + if (instance->name != NULL) { + if (is_string_releaseable(instance->name)) { + cfl_sds_destroy(instance->name); + } + } + + if (instance->version != NULL) { + if (is_string_releaseable(instance->version)) { + cfl_sds_destroy(instance->version); + } + } + + free(instance); + } +} + +static void destroy_profile( + Opentelemetry__Proto__Profiles__V1development__Profile * + instance) +{ + size_t index; + + if (instance != NULL) { + if (instance->sample_type != NULL) { + for (index = 0 ; index < instance->n_sample_type ; index++) { + destroy_value_type(instance->sample_type[index]); + } + + free(instance->sample_type); + } + + if (instance->sample != NULL) { + for (index = 0 ; index < instance->n_sample ; index++) { + destroy_sample(instance->sample[index]); + } + + free(instance->sample); + } + + if (instance->mapping != NULL) { + for (index = 0 ; index < instance->n_mapping ; index++) { + destroy_mapping(instance->mapping[index]); + } + + free(instance->mapping); + } + + if (instance->location != NULL) { + for (index = 0 ; index < instance->n_location ; index++) { + destroy_location(instance->location[index]); + } + + free(instance->location); + } + + if (instance->location_indices != NULL) { + free(instance->location_indices); + } + + if (instance->function != NULL) { + for (index = 0 ; index < instance->n_function ; index++) { + destroy_function(instance->function[index]); + } + + free(instance->function); + } + + if (instance->attribute_table != NULL) { + destroy_attribute_list(instance->attribute_table); + } + + for (index = 0 ; index < instance->n_attribute_units ; index++) { + destroy_attribute_unit(instance->attribute_units[index]); + } + + if (instance->link_table != NULL) { + for (index = 0 ; index < instance->n_link_table ; index++) { + destroy_link(instance->link_table[index]); + } + + free(instance->link_table); + } + + if (instance->string_table != NULL) { + for (index = 0 ; index < instance->n_string_table ; index++) { + if (is_string_releaseable(instance->string_table[index])) { + cfl_sds_destroy(instance->string_table[index]); + } + } + + free(instance->string_table); + } + + if (instance->period_type != NULL) { + destroy_value_type(instance->period_type); + } + + if (instance->comment != NULL) { + free(instance->comment); + } + + free(instance); + } +} + +static void destroy_profile_container( + Opentelemetry__Proto__Profiles__V1development__ProfileContainer * + instance) +{ + if (instance != NULL) { + if (instance->profile_id.data != NULL) { + if (is_string_releaseable((cfl_sds_t) instance->profile_id.data)) { + cfl_sds_destroy((cfl_sds_t) instance->profile_id.data); + } + } + + destroy_attribute_list(instance->attributes); + + if (instance->original_payload_format != NULL) { + if (is_string_releaseable(instance->original_payload_format)) { + cfl_sds_destroy(instance->original_payload_format); + } + } + + if (instance->original_payload.data != NULL) { + if (is_string_releaseable((cfl_sds_t) instance->original_payload.data)) { + cfl_sds_destroy((cfl_sds_t) instance->original_payload.data); + } + } + + destroy_profile(instance->profile); + + free(instance); + } +} + +static void destroy_scope_profiles( + Opentelemetry__Proto__Profiles__V1development__ScopeProfiles * + instance) +{ + size_t index; + + if (instance != NULL) { + if (instance->scope != NULL) { + destroy_instrumentation_scope(instance->scope); + } + + if (instance->profiles != NULL) { + for (index = 0 ; index < instance->n_profiles ; index++) { + destroy_profile_container(instance->profiles[index]); + } + + free(instance->profiles); + } + + if (instance->schema_url != NULL) { + if (is_string_releaseable(instance->schema_url)) { + cfl_sds_destroy(instance->schema_url); + } + } + + free(instance); + } +} +static void destroy_resource_profiles( + Opentelemetry__Proto__Profiles__V1development__ResourceProfiles * + instance) +{ + size_t index; + + if (instance != NULL) { + if (instance->resource != NULL) { + destroy_resource(instance->resource); + } + + if (instance->scope_profiles != NULL) { + for (index = 0 ; index < instance->n_scope_profiles ; index++) { + destroy_scope_profiles(instance->scope_profiles[index]); + } + + free(instance->scope_profiles); + } + + if (instance->schema_url != NULL) { + if (is_string_releaseable(instance->schema_url)) { + cfl_sds_destroy(instance->schema_url); + } + } + + free(instance); + } +} + +static void destroy_export_profiles_service_request( + Opentelemetry__Proto__Collector__Profiles__V1development__ExportProfilesServiceRequest * + instance) +{ + size_t index; + + if (instance != NULL) { + if (instance->resource_profiles != NULL) { + for (index = 0 ; index < instance->n_resource_profiles ; index++) { + destroy_resource_profiles(instance->resource_profiles[index]); + } + + free(instance->resource_profiles); + } + + free(instance); + } +} + + + + +static + Opentelemetry__Proto__Profiles__V1development__ValueType * + initialize_value_type() { + Opentelemetry__Proto__Profiles__V1development__ValueType *instance; + + instance = calloc(1, sizeof(Opentelemetry__Proto__Profiles__V1development__ValueType)); + + if (instance == NULL) { + return NULL; + } + + opentelemetry__proto__profiles__v1development__value_type__init(instance); + + return instance; +} + + + +static + Opentelemetry__Proto__Profiles__V1development__Sample * + initialize_sample( + size_t location_index_count, + size_t value_count, + size_t attributes_count, + size_t timestamps_count) { + Opentelemetry__Proto__Profiles__V1development__Sample *instance; + + instance = calloc(1, sizeof(Opentelemetry__Proto__Profiles__V1development__Sample)); + + if (instance == NULL) { + return NULL; + } + + opentelemetry__proto__profiles__v1development__sample__init(instance); + + if (location_index_count > 0) { + instance->location_index = calloc(location_index_count, sizeof(uint64_t)); + + if (instance->location_index == NULL) { + destroy_sample(instance); + + return NULL; + } + + instance->n_location_index = location_index_count; + } + + if (value_count > 0) { + instance->value = calloc(value_count, sizeof(int64_t)); + + if (instance->value == NULL) { + destroy_sample(instance); + + return NULL; + } + + instance->n_value = value_count; + } + + if (attributes_count > 0) { + instance->attributes = calloc(attributes_count, sizeof(uint64_t)); + + if (instance->attributes == NULL) { + destroy_sample(instance); + + return NULL; + } + + instance->n_attributes = attributes_count; + } + + if (timestamps_count > 0) { + instance->timestamps_unix_nano = calloc(timestamps_count, sizeof(uint64_t)); + + if (instance->timestamps_unix_nano == NULL) { + destroy_sample(instance); + + return NULL; + } + + instance->n_timestamps_unix_nano = timestamps_count; + } + + return instance; +} + + + + + + +static + Opentelemetry__Proto__Resource__V1__Resource * + initialize_resource(size_t attribute_count) { + Opentelemetry__Proto__Resource__V1__Resource *instance; + + instance = calloc(1, sizeof(Opentelemetry__Proto__Resource__V1__Resource)); + + if (instance == NULL) { + return NULL; + } + + opentelemetry__proto__resource__v1__resource__init(instance); + + if (attribute_count > 0) { + instance->attributes = initialize_attribute_list(attribute_count); + + if (instance->attributes == NULL) { + free(instance); + + return NULL; + } + } + + instance->n_attributes = attribute_count; + + return instance; +} + +static + Opentelemetry__Proto__Profiles__V1development__AttributeUnit * + initialize_attribute_unit() { + Opentelemetry__Proto__Profiles__V1development__AttributeUnit *instance; + + instance = calloc(1, sizeof(Opentelemetry__Proto__Profiles__V1development__AttributeUnit)); + + if (instance == NULL) { + return NULL; + } + + opentelemetry__proto__profiles__v1development__attribute_unit__init(instance); + + return instance; +} + +static + Opentelemetry__Proto__Profiles__V1development__Line * + initialize_line() { + Opentelemetry__Proto__Profiles__V1development__Line *instance; + + instance = calloc(1, sizeof(Opentelemetry__Proto__Profiles__V1development__Line)); + + if (instance == NULL) { + return NULL; + } + + opentelemetry__proto__profiles__v1development__line__init(instance); + + return instance; +} + +static + Opentelemetry__Proto__Profiles__V1development__Link * + initialize_link() { + Opentelemetry__Proto__Profiles__V1development__Link *instance; + + instance = calloc(1, sizeof(Opentelemetry__Proto__Profiles__V1development__Link)); + + if (instance == NULL) { + return NULL; + } + + opentelemetry__proto__profiles__v1development__link__init(instance); + + return instance; +} + +static + Opentelemetry__Proto__Profiles__V1development__Location * + initialize_location(size_t line_count, size_t attribute_count) { + Opentelemetry__Proto__Profiles__V1development__Location *instance; + + instance = calloc(1, sizeof(Opentelemetry__Proto__Profiles__V1development__Location)); + + if (instance == NULL) { + return NULL; + } + + opentelemetry__proto__profiles__v1development__location__init(instance); + + if (line_count > 0) { + instance->line = calloc(line_count, sizeof(void *)); + + if (instance->line == NULL) { + destroy_location(instance); + + return NULL; + } + + instance->n_line = line_count; + } + + if (attribute_count > 0) { + instance->attributes = calloc(attribute_count, sizeof(uint64_t)); + + if (instance->attributes == NULL) { + destroy_location(instance); + + return NULL; + } + + instance->n_attributes = attribute_count; + } + + return instance; +} + +static + Opentelemetry__Proto__Profiles__V1development__Function * + initialize_function() { + Opentelemetry__Proto__Profiles__V1development__Function *instance; + + instance = calloc(1, sizeof(Opentelemetry__Proto__Profiles__V1development__Function)); + + if (instance == NULL) { + return NULL; + } + + opentelemetry__proto__profiles__v1development__function__init(instance); + + return instance; +} + +static + Opentelemetry__Proto__Profiles__V1development__Mapping * + initialize_mapping(size_t attribute_count) { + Opentelemetry__Proto__Profiles__V1development__Mapping *instance; + + instance = calloc(1, sizeof(Opentelemetry__Proto__Profiles__V1development__Mapping)); + + if (instance == NULL) { + return NULL; + } + + opentelemetry__proto__profiles__v1development__mapping__init(instance); + + if (attribute_count > 0) { + instance->attributes = calloc(attribute_count, sizeof(uint64_t)); + + if (instance->attributes == NULL) { + destroy_mapping(instance); + + return NULL; + } + + instance->n_attributes = attribute_count; + } + + return instance; +} + +static + Opentelemetry__Proto__Common__V1__InstrumentationScope * + initialize_instrumentation_scope(size_t attribute_count) { + Opentelemetry__Proto__Common__V1__InstrumentationScope *instance; + + instance = calloc(1, sizeof(Opentelemetry__Proto__Common__V1__InstrumentationScope)); + + if (instance == NULL) { + return NULL; + } + + opentelemetry__proto__common__v1__instrumentation_scope__init(instance); + + if (attribute_count > 0) { + instance->attributes = initialize_attribute_list(attribute_count); + + if (instance->attributes == NULL) { + free(instance); + + return NULL; + } + } + + instance->n_attributes = attribute_count; + + return instance; +} + +static + Opentelemetry__Proto__Profiles__V1development__Profile * + initialize_profile( + size_t sample_type_count, + size_t sample_count, + size_t mapping_count, + size_t location_count, + size_t location_index_count, + size_t function_count, + size_t attribute_count, + size_t attribute_unit_count, + size_t link_count, + size_t string_count, + size_t comment_count) { + Opentelemetry__Proto__Profiles__V1development__Profile *instance; + + instance = calloc(1, sizeof(Opentelemetry__Proto__Profiles__V1development__Profile)); + + if (instance == NULL) { + return NULL; + } + + opentelemetry__proto__profiles__v1development__profile__init(instance); + + if (sample_type_count > 0) { + instance->sample_type = calloc(sample_type_count, sizeof(void *)); + + if (instance->sample_type == NULL) { + destroy_profile(instance); + + return NULL; + } + + instance->n_sample_type = sample_type_count; + } + + if (sample_count > 0) { + instance->sample = calloc(sample_count, sizeof(void *)); + + if (instance->sample == NULL) { + destroy_profile(instance); + + return NULL; + } + + instance->n_sample = sample_count; + } + + if (mapping_count > 0) { + instance->mapping = calloc(mapping_count, sizeof(void *)); + + if (instance->mapping == NULL) { + destroy_profile(instance); + + return NULL; + } + + instance->n_mapping = mapping_count; + } + + if (location_count > 0) { + instance->location = calloc(location_count, sizeof(void *)); + + if (instance->location == NULL) { + destroy_profile(instance); + + return NULL; + } + + instance->n_location = location_count; + } + + if (location_index_count > 0) { + instance->location_indices = calloc(location_index_count, sizeof(uint64_t)); + + if (instance->location_indices == NULL) { + destroy_profile(instance); + + return NULL; + } + + instance->n_location_indices = location_index_count; + } + + if (function_count > 0) { + instance->function = calloc(function_count, sizeof(void *)); + + if (instance->function == NULL) { + destroy_profile(instance); + + return NULL; + } + + instance->n_function = function_count; + } + + if (attribute_count > 0) { + instance->attribute_table = calloc(attribute_count, sizeof(void *)); + + if (instance->attribute_table == NULL) { + destroy_profile(instance); + + return NULL; + } + + instance->n_attribute_table = attribute_count; + } + + if (attribute_unit_count > 0) { + instance->attribute_units = calloc(attribute_unit_count, sizeof(void *)); + + if (instance->attribute_units == NULL) { + destroy_profile(instance); + + return NULL; + } + + instance->n_attribute_units = attribute_unit_count; + } + + if (link_count > 0) { + instance->link_table = calloc(link_count, sizeof(void *)); + + if (instance->link_table == NULL) { + destroy_profile(instance); + + return NULL; + } + + instance->n_link_table = link_count; + } + + if (string_count > 0) { + instance->string_table = calloc(string_count, sizeof(void *)); + + if (instance->string_table == NULL) { + destroy_profile(instance); + + return NULL; + } + + instance->n_string_table = string_count; + } + + if (comment_count > 0) { + instance->comment = calloc(comment_count, sizeof(void *)); + + if (instance->comment == NULL) { + destroy_profile(instance); + + return NULL; + } + + instance->n_comment = comment_count; + } + + return instance; +} + + +static + Opentelemetry__Proto__Profiles__V1development__ProfileContainer * + initialize_profile_container(size_t attribute_count) { + Opentelemetry__Proto__Profiles__V1development__ProfileContainer *instance; + + instance = calloc(1, sizeof(Opentelemetry__Proto__Profiles__V1development__ProfileContainer)); + + if (instance == NULL) { + return NULL; + } + + opentelemetry__proto__profiles__v1development__profile_container__init(instance); + + if (attribute_count > 0) { + instance->attributes = initialize_attribute_list(attribute_count); + + if (instance->attributes == NULL) { + free(instance); + + return NULL; + } + } + + instance->n_attributes = attribute_count; + + return instance; +} + +static + Opentelemetry__Proto__Profiles__V1development__ScopeProfiles * + initialize_scope_profiles(size_t profiles_count) { + Opentelemetry__Proto__Profiles__V1development__ScopeProfiles *instance; + + instance = calloc(1, sizeof(Opentelemetry__Proto__Profiles__V1development__ScopeProfiles)); + + if (instance == NULL) { + return NULL; + } + + opentelemetry__proto__profiles__v1development__scope_profiles__init(instance); + + instance->profiles = calloc(profiles_count, sizeof(void *)); + + if (instance->profiles == NULL) { + free(instance); + + return NULL; + } + + instance->n_profiles = profiles_count; + + return instance; +} + +static + Opentelemetry__Proto__Profiles__V1development__ResourceProfiles * + initialize_resource_profiles(size_t scope_profiles_count) { + Opentelemetry__Proto__Profiles__V1development__ResourceProfiles *instance; + + instance = calloc(1, sizeof(Opentelemetry__Proto__Profiles__V1development__ResourceProfiles)); + + if (instance == NULL) { + return NULL; + } + + opentelemetry__proto__profiles__v1development__resource_profiles__init(instance); + + instance->scope_profiles = calloc(scope_profiles_count, sizeof(void *)); + + if (instance->scope_profiles == NULL) { + free(instance); + + return NULL; + } + + instance->n_scope_profiles = scope_profiles_count; + + return instance; +} + + +static + Opentelemetry__Proto__Collector__Profiles__V1development__ExportProfilesServiceRequest * + initialize_export_profiles_service_request(size_t resource_profiles_count) { + Opentelemetry__Proto__Collector__Profiles__V1development__ExportProfilesServiceRequest *instance; + + instance = calloc(1, sizeof(Opentelemetry__Proto__Collector__Profiles__V1development__ExportProfilesServiceRequest)); + + if (instance == NULL) { + return NULL; + } + + opentelemetry__proto__collector__profiles__v1development__export_profiles_service_request__init(instance); + + instance->resource_profiles = calloc(resource_profiles_count, sizeof(void *)); + + if (instance->resource_profiles == NULL) { + free(instance); + + return NULL; + } + + instance->n_resource_profiles = resource_profiles_count; + + return instance; +} + + + + + +static int pack_cprof_resource( + Opentelemetry__Proto__Resource__V1__Resource **output_instance, + struct cprof_resource *input_instance) +{ + Opentelemetry__Proto__Resource__V1__Resource *otlp_resource; + + if (input_instance != NULL) { + otlp_resource = initialize_resource(0); + + if (otlp_resource == NULL) { + return CPROF_ENCODE_OPENTELEMETRY_ALLOCATION_ERROR; + } + + otlp_resource->attributes = cfl_kvlist_to_otlp_kvpair_list(input_instance->attributes); + + if (otlp_resource->attributes == NULL) { + destroy_resource(otlp_resource); + + return CPROF_ENCODE_OPENTELEMETRY_ALLOCATION_ERROR; + } + + otlp_resource->n_attributes = cfl_kvlist_count(input_instance->attributes); + + otlp_resource->dropped_attributes_count = \ + input_instance->dropped_attributes_count; + + *output_instance = otlp_resource; + } + + return CPROF_ENCODE_OPENTELEMETRY_SUCCESS; +} + +static int pack_cprof_instrumentation_scope( + Opentelemetry__Proto__Common__V1__InstrumentationScope **output_instance, + struct cprof_instrumentation_scope *input_instance) +{ + Opentelemetry__Proto__Common__V1__InstrumentationScope *otlp_instrumentation_scope; + + if (input_instance != NULL) { + otlp_instrumentation_scope = initialize_instrumentation_scope(0); + + if (otlp_instrumentation_scope == NULL) { + return CPROF_ENCODE_OPENTELEMETRY_ALLOCATION_ERROR; + } + + otlp_instrumentation_scope->attributes = cfl_kvlist_to_otlp_kvpair_list(input_instance->attributes); + + if (otlp_instrumentation_scope->attributes == NULL) { + destroy_instrumentation_scope(otlp_instrumentation_scope); + + return CPROF_ENCODE_OPENTELEMETRY_ALLOCATION_ERROR; + } + + otlp_instrumentation_scope->n_attributes = cfl_kvlist_count(input_instance->attributes); + + if (input_instance->name != NULL) { + otlp_instrumentation_scope->name = cfl_sds_create(input_instance->name); + + if (otlp_instrumentation_scope->name == NULL) { + destroy_instrumentation_scope(otlp_instrumentation_scope); + + return CPROF_ENCODE_OPENTELEMETRY_ALLOCATION_ERROR; + } + } + + if (input_instance->version != NULL) { + otlp_instrumentation_scope->version = cfl_sds_create(input_instance->version); + + if (otlp_instrumentation_scope->version == NULL) { + destroy_instrumentation_scope(otlp_instrumentation_scope); + + return CPROF_ENCODE_OPENTELEMETRY_ALLOCATION_ERROR; + } + } + + otlp_instrumentation_scope->dropped_attributes_count = \ + input_instance->dropped_attributes_count; + + *output_instance = otlp_instrumentation_scope; + } + + return CPROF_ENCODE_OPENTELEMETRY_SUCCESS; +} + +static int pack_cprof_value_type( + Opentelemetry__Proto__Profiles__V1development__ValueType **output_instance, + struct cprof_value_type *input_instance) +{ + Opentelemetry__Proto__Profiles__V1development__ValueType *otlp_value_type; + + otlp_value_type = initialize_value_type(); + + if (otlp_value_type == NULL) { + return CPROF_ENCODE_OPENTELEMETRY_ALLOCATION_ERROR; + } + + otlp_value_type->type = input_instance->type; + otlp_value_type->unit = input_instance->unit; + otlp_value_type->aggregation_temporality = input_instance->aggregation_temporality; + + *output_instance = otlp_value_type; + + return CPROF_ENCODE_OPENTELEMETRY_SUCCESS; +} + +static int pack_cprof_sample( + Opentelemetry__Proto__Profiles__V1development__Sample **output_instance, + struct cprof_sample *input_instance) +{ + Opentelemetry__Proto__Profiles__V1development__Sample *otlp_sample; + size_t index; + + otlp_sample = initialize_sample(input_instance->location_index_count, + input_instance->value_count, + input_instance->attributes_count, + input_instance->timestamps_count); + + if (otlp_sample == NULL) { + return CPROF_ENCODE_OPENTELEMETRY_ALLOCATION_ERROR; + } + + for (index = 0 ; + index < input_instance->location_index_count ; + index++) { + otlp_sample->location_index[index] = input_instance->location_index[index]; + } + + otlp_sample->locations_start_index = input_instance->locations_start_index; + otlp_sample->locations_length = input_instance->locations_length; + + for (index = 0 ; + index < input_instance->value_count ; + index++) { + otlp_sample->value[index] = input_instance->values[index]; + } + + for (index = 0 ; + index < input_instance->attributes_count ; + index++) { + otlp_sample->attributes[index] = input_instance->attributes[index]; + } + + otlp_sample->link = input_instance->link; + + for (index = 0 ; + index < input_instance->timestamps_count ; + index++) { + otlp_sample->timestamps_unix_nano[index] = input_instance->timestamps_unix_nano[index]; + } + + *output_instance = otlp_sample; + + return CPROF_ENCODE_OPENTELEMETRY_SUCCESS; +} + + +static int pack_cprof_mapping( + Opentelemetry__Proto__Profiles__V1development__Mapping **output_instance, + struct cprof_mapping *input_instance) +{ + Opentelemetry__Proto__Profiles__V1development__Mapping *otlp_mapping; + size_t index; + + otlp_mapping = initialize_mapping(input_instance->attributes_count); + + if (otlp_mapping == NULL) { + return CPROF_ENCODE_OPENTELEMETRY_ALLOCATION_ERROR; + } + + otlp_mapping->id = input_instance->id; + otlp_mapping->memory_start = input_instance->memory_start; + otlp_mapping->memory_limit = input_instance->memory_limit; + otlp_mapping->file_offset = input_instance->file_offset; + otlp_mapping->filename = input_instance->filename; + + for (index = 0 ; + index < input_instance->attributes_count ; + index++) { + otlp_mapping->attributes[index] = input_instance->attributes[index]; + } + + otlp_mapping->has_functions = input_instance->has_functions; + otlp_mapping->has_filenames = input_instance->has_filenames; + otlp_mapping->has_line_numbers = input_instance->has_line_numbers; + otlp_mapping->has_inline_frames = input_instance->has_inline_frames; + + *output_instance = otlp_mapping; + + return CPROF_ENCODE_OPENTELEMETRY_SUCCESS; +} + + + +static int pack_cprof_line( + Opentelemetry__Proto__Profiles__V1development__Line **output_instance, + struct cprof_line *input_instance) +{ + Opentelemetry__Proto__Profiles__V1development__Line *otlp_line; + + otlp_line = initialize_line(); + + if (otlp_line == NULL) { + return CPROF_ENCODE_OPENTELEMETRY_ALLOCATION_ERROR; + } + + otlp_line->function_index = input_instance->function_index; + otlp_line->line = input_instance->line; + otlp_line->column = input_instance->column; + + *output_instance = otlp_line; + + return CPROF_ENCODE_OPENTELEMETRY_SUCCESS; +} + +static int pack_cprof_location( + Opentelemetry__Proto__Profiles__V1development__Location **output_instance, + struct cprof_location *input_instance) +{ + Opentelemetry__Proto__Profiles__V1development__Location *otlp_location; + struct cfl_list *iterator; + int result; + struct cprof_line *line; + size_t index; + + otlp_location = initialize_location(cfl_list_size(&input_instance->lines), + input_instance->attributes_count); + + if (otlp_location == NULL) { + return CPROF_ENCODE_OPENTELEMETRY_ALLOCATION_ERROR; + } + + otlp_location->id = input_instance->id; + otlp_location->mapping_index = input_instance->mapping_index; + otlp_location->address = input_instance->address; + + + index = 0; + cfl_list_foreach(iterator, + &input_instance->lines) { + line = cfl_list_entry( + iterator, + struct cprof_line, _head); + + result = pack_cprof_line( + &otlp_location->line[index], + line); + + if (result != CPROF_ENCODE_OPENTELEMETRY_SUCCESS) { + destroy_location(otlp_location); + + return result; + } + + index++; + } + + otlp_location->is_folded = input_instance->is_folded; + + for (index = 0 ; + index < input_instance->attributes_count ; + index++) { + otlp_location->attributes[index] = input_instance->attributes[index]; + } + + *output_instance = otlp_location; + + return CPROF_ENCODE_OPENTELEMETRY_SUCCESS; +} + +static int pack_cprof_function( + Opentelemetry__Proto__Profiles__V1development__Function **output_instance, + struct cprof_function *input_instance) +{ + Opentelemetry__Proto__Profiles__V1development__Function *otlp_function; + + otlp_function = initialize_function(); + + if (otlp_function == NULL) { + return CPROF_ENCODE_OPENTELEMETRY_ALLOCATION_ERROR; + } + + otlp_function->id = input_instance->id; + otlp_function->name = input_instance->name; + otlp_function->system_name = input_instance->system_name; + otlp_function->filename = input_instance->filename; + otlp_function->start_line = input_instance->start_line; + + *output_instance = otlp_function; + + return CPROF_ENCODE_OPENTELEMETRY_SUCCESS; +} + +static int pack_cprof_attribute_unit( + Opentelemetry__Proto__Profiles__V1development__AttributeUnit **output_instance, + struct cprof_attribute_unit *input_instance) +{ + Opentelemetry__Proto__Profiles__V1development__AttributeUnit *otlp_attribute_unit; + + otlp_attribute_unit = initialize_attribute_unit(); + + if (otlp_attribute_unit == NULL) { + return CPROF_ENCODE_OPENTELEMETRY_ALLOCATION_ERROR; + } + + otlp_attribute_unit->attribute_key = input_instance->attribute_key; + otlp_attribute_unit->unit = input_instance->unit; + + *output_instance = otlp_attribute_unit; + + return CPROF_ENCODE_OPENTELEMETRY_SUCCESS; +} + +static int pack_cprof_link( + Opentelemetry__Proto__Profiles__V1development__Link **output_instance, + struct cprof_link *input_instance) +{ + Opentelemetry__Proto__Profiles__V1development__Link *otlp_link; + + otlp_link = initialize_link(); + + if (otlp_link == NULL) { + return CPROF_ENCODE_OPENTELEMETRY_ALLOCATION_ERROR; + } + + otlp_link->trace_id.data = \ + (uint8_t *) cfl_sds_create_len((const char *) input_instance->trace_id, + sizeof(input_instance->trace_id)); + + if (otlp_link->trace_id.data == NULL) { + destroy_link(otlp_link); + + return CPROF_ENCODE_OPENTELEMETRY_ALLOCATION_ERROR; + } + + otlp_link->trace_id.len = sizeof(input_instance->trace_id); + + + otlp_link->span_id.data = \ + (uint8_t *) cfl_sds_create_len((const char *) input_instance->span_id, + sizeof(input_instance->span_id)); + + if (otlp_link->span_id.data == NULL) { + destroy_link(otlp_link); + + return CPROF_ENCODE_OPENTELEMETRY_ALLOCATION_ERROR; + } + + otlp_link->span_id.len = sizeof(input_instance->span_id); + + + *output_instance = otlp_link; + + return CPROF_ENCODE_OPENTELEMETRY_SUCCESS; +} + +static int pack_cprof_profile( + Opentelemetry__Proto__Profiles__V1development__Profile **output_instance, + struct cprof_profile *input_instance) +{ + Opentelemetry__Proto__Profiles__V1development__Profile *otlp_profile; + struct cfl_list *iterator; + struct cprof_sample *sample; + struct cprof_link *link; + struct cprof_mapping *mapping; + struct cprof_location *location; + struct cprof_function *function; + struct cprof_value_type *sample_type; + struct cprof_attribute_unit *attribute_unit; + int result; + size_t index; + + otlp_profile = initialize_profile(cfl_list_size(&input_instance->sample_type), + cfl_list_size(&input_instance->samples), + cfl_list_size(&input_instance->mappings), + cfl_list_size(&input_instance->locations), + input_instance->location_indices_count, + cfl_list_size(&input_instance->functions), + 0, + cfl_list_size(&input_instance->attribute_units), + cfl_list_size(&input_instance->link_table), + input_instance->string_table_count, + input_instance->comments_count); + + if (otlp_profile == NULL) { + return CPROF_ENCODE_OPENTELEMETRY_ALLOCATION_ERROR; + } + + index = 0; + cfl_list_foreach(iterator, + &input_instance->sample_type) { + sample_type = cfl_list_entry( + iterator, + struct cprof_value_type, _head); + + result = pack_cprof_value_type( + &otlp_profile->sample_type[index], + sample_type); + + if (result != CPROF_ENCODE_OPENTELEMETRY_SUCCESS) { + destroy_profile(otlp_profile); + + return result; + } + + index++; + } + + index = 0; + cfl_list_foreach(iterator, + &input_instance->samples) { + sample = cfl_list_entry( + iterator, + struct cprof_sample, _head); + + result = pack_cprof_sample( + &otlp_profile->sample[index], + sample); + + if (result != CPROF_ENCODE_OPENTELEMETRY_SUCCESS) { + destroy_profile(otlp_profile); + + return result; + } + + index++; + } + + index = 0; + cfl_list_foreach(iterator, + &input_instance->mappings) { + mapping = cfl_list_entry( + iterator, + struct cprof_mapping, _head); + + result = pack_cprof_mapping( + &otlp_profile->mapping[index], + mapping); + + if (result != CPROF_ENCODE_OPENTELEMETRY_SUCCESS) { + destroy_profile(otlp_profile); + + return result; + } + + index++; + } + + index = 0; + cfl_list_foreach(iterator, + &input_instance->locations) { + location = cfl_list_entry( + iterator, + struct cprof_location, _head); + + result = pack_cprof_location( + &otlp_profile->location[index], + location); + + if (result != CPROF_ENCODE_OPENTELEMETRY_SUCCESS) { + destroy_profile(otlp_profile); + + return result; + } + + index++; + } + + for (index = 0 ; + index < input_instance->location_indices_count ; + index++) { + otlp_profile->location_indices[index] = input_instance->location_indices[index]; + } + + index = 0; + cfl_list_foreach(iterator, + &input_instance->functions) { + function = cfl_list_entry( + iterator, + struct cprof_function, _head); + + result = pack_cprof_function( + &otlp_profile->function[index], + function); + + if (result != CPROF_ENCODE_OPENTELEMETRY_SUCCESS) { + destroy_profile(otlp_profile); + + return result; + } + + index++; + } + + if (input_instance->attribute_table != NULL) { + otlp_profile->attribute_table = cfl_kvlist_to_otlp_kvpair_list(input_instance->attribute_table); + + if (otlp_profile->attribute_table == NULL) { + destroy_profile(otlp_profile); + + return CPROF_ENCODE_OPENTELEMETRY_ALLOCATION_ERROR; + } + + otlp_profile->n_attribute_table = cfl_kvlist_count(input_instance->attribute_table); + } + + index = 0; + cfl_list_foreach(iterator, + &input_instance->attribute_units) { + attribute_unit = cfl_list_entry( + iterator, + struct cprof_attribute_unit, _head); + + result = pack_cprof_attribute_unit( + &otlp_profile->attribute_units[index], + attribute_unit); + + if (result != CPROF_ENCODE_OPENTELEMETRY_SUCCESS) { + destroy_profile(otlp_profile); + + return result; + } + + index++; + } + + index = 0; + cfl_list_foreach(iterator, + &input_instance->link_table) { + link = cfl_list_entry( + iterator, + struct cprof_link, _head); + + result = pack_cprof_link( + &otlp_profile->link_table[index], + link); + + if (result != CPROF_ENCODE_OPENTELEMETRY_SUCCESS) { + destroy_profile(otlp_profile); + + return result; + } + + index++; + } + + for (index = 0 ; + index < input_instance->string_table_count ; + index++) { + otlp_profile->string_table[index] = cfl_sds_create(input_instance->string_table[index]); + + if (otlp_profile->string_table[index] == NULL) { + destroy_profile(otlp_profile); + + return CPROF_ENCODE_OPENTELEMETRY_ALLOCATION_ERROR; + } + } + + otlp_profile->drop_frames = input_instance->drop_frames; + otlp_profile->keep_frames = input_instance->keep_frames; + otlp_profile->time_nanos = input_instance->time_nanos; + otlp_profile->duration_nanos = input_instance->duration_nanos; + + result = pack_cprof_value_type( + &otlp_profile->period_type, + &input_instance->period_type); + + if (result != CPROF_ENCODE_OPENTELEMETRY_SUCCESS) { + destroy_profile(otlp_profile); + + return result; + } + + otlp_profile->period = input_instance->period; + + for (index = 0 ; + index < input_instance->comments_count ; + index++) { + otlp_profile->comment[index] = input_instance->comments[index]; + } + + otlp_profile->default_sample_type = input_instance->default_sample_type; + + *output_instance = otlp_profile; + + return CPROF_ENCODE_OPENTELEMETRY_SUCCESS; +} + +static int pack_cprof_profile_container( + Opentelemetry__Proto__Profiles__V1development__ProfileContainer **output_instance, + struct cprof_profile *input_instance) +{ + Opentelemetry__Proto__Profiles__V1development__ProfileContainer *otlp_profile_container; + int result; + + otlp_profile_container = initialize_profile_container(0); + + if (otlp_profile_container == NULL) { + return CPROF_ENCODE_OPENTELEMETRY_ALLOCATION_ERROR; + } + + otlp_profile_container->profile_id.data = \ + (uint8_t *) cfl_sds_create_len((const char *) input_instance->profile_id, + sizeof(input_instance->profile_id)); + + if (otlp_profile_container->profile_id.data == NULL) { + destroy_profile_container(otlp_profile_container); + + return CPROF_ENCODE_OPENTELEMETRY_ALLOCATION_ERROR; + } + + otlp_profile_container->profile_id.len = sizeof(input_instance->profile_id); + + otlp_profile_container->start_time_unix_nano = (uint64_t) input_instance->start_time_unix_nano; + otlp_profile_container->end_time_unix_nano = (uint64_t) input_instance->end_time_unix_nano; + + otlp_profile_container->attributes = cfl_kvlist_to_otlp_kvpair_list(input_instance->attributes); + + if (otlp_profile_container->attributes == NULL) { + destroy_profile_container(otlp_profile_container); + + return CPROF_ENCODE_OPENTELEMETRY_ALLOCATION_ERROR; + } + + otlp_profile_container->n_attributes = cfl_kvlist_count(input_instance->attributes); + + otlp_profile_container->dropped_attributes_count = input_instance->dropped_attributes_count; + + if (input_instance->original_payload_format != NULL) { + otlp_profile_container->original_payload_format = \ + cfl_sds_create(input_instance->original_payload_format); + + if (otlp_profile_container->original_payload_format == NULL) { + destroy_profile_container(otlp_profile_container); + + return CPROF_ENCODE_OPENTELEMETRY_ALLOCATION_ERROR; + } + } + + if (input_instance->original_payload != NULL) { + otlp_profile_container->original_payload.data = \ + (uint8_t *) cfl_sds_create_len(input_instance->original_payload, + cfl_sds_len(input_instance->original_payload)); + + if (otlp_profile_container->original_payload.data == NULL) { + destroy_profile_container(otlp_profile_container); + + return CPROF_ENCODE_OPENTELEMETRY_ALLOCATION_ERROR; + } + + otlp_profile_container->original_payload.len = cfl_sds_len(input_instance->original_payload); + } + + result = pack_cprof_profile(&otlp_profile_container->profile, input_instance); + + if (result != CPROF_ENCODE_OPENTELEMETRY_SUCCESS) { + destroy_profile_container(otlp_profile_container); + + return result; + } + + *output_instance = otlp_profile_container; + + return CPROF_ENCODE_OPENTELEMETRY_SUCCESS; +} + + +static int pack_cprof_scope_profiles( + Opentelemetry__Proto__Profiles__V1development__ScopeProfiles **output_instance, + struct cprof_scope_profiles *input_instance) +{ + Opentelemetry__Proto__Profiles__V1development__ScopeProfiles *otlp_scope_profiles; + struct cfl_list *iterator; + struct cprof_profile *profile; + int result; + size_t index; + + otlp_scope_profiles = initialize_scope_profiles(cfl_list_size(&input_instance->profiles)); + + if (otlp_scope_profiles == NULL) { + return CPROF_ENCODE_OPENTELEMETRY_ALLOCATION_ERROR; + } + + if (input_instance->scope != NULL) { + result = pack_cprof_instrumentation_scope(&otlp_scope_profiles->scope, input_instance->scope); + + if (result != CPROF_ENCODE_OPENTELEMETRY_SUCCESS) { + return result; + } + } + + index = 0; + cfl_list_foreach(iterator, + &input_instance->profiles) { + profile = cfl_list_entry( + iterator, + struct cprof_profile, _head); + + result = pack_cprof_profile_container( + &otlp_scope_profiles->profiles[index], + profile); + + if (result != CPROF_ENCODE_OPENTELEMETRY_SUCCESS) { + destroy_scope_profiles(otlp_scope_profiles); + + return result; + } + + index++; + } + + if (input_instance->schema_url != NULL) { + otlp_scope_profiles->schema_url = cfl_sds_create(input_instance->schema_url); + + if (otlp_scope_profiles->schema_url == NULL) { + destroy_scope_profiles(otlp_scope_profiles); + + return CPROF_ENCODE_OPENTELEMETRY_ALLOCATION_ERROR; + } + } + + *output_instance = otlp_scope_profiles; + + return CPROF_ENCODE_OPENTELEMETRY_SUCCESS; +} + +static int pack_cprof_resource_profiles( + Opentelemetry__Proto__Profiles__V1development__ResourceProfiles **output_instance, + struct cprof_resource_profiles *input_instance) +{ + Opentelemetry__Proto__Profiles__V1development__ResourceProfiles *otlp_resource_profiles; + struct cprof_scope_profiles *scope_profiles; + struct cfl_list *iterator; + int result; + size_t index; + + otlp_resource_profiles = initialize_resource_profiles(cfl_list_size(&input_instance->scope_profiles)); + + if (otlp_resource_profiles == NULL) { + return CPROF_ENCODE_OPENTELEMETRY_ALLOCATION_ERROR; + } + + result = pack_cprof_resource(&otlp_resource_profiles->resource, input_instance->resource); + + if (result != CPROF_ENCODE_OPENTELEMETRY_SUCCESS) { + return result; + } + + index = 0; + cfl_list_foreach(iterator, + &input_instance->scope_profiles) { + scope_profiles = cfl_list_entry( + iterator, + struct cprof_scope_profiles, _head); + + result = pack_cprof_scope_profiles( + &otlp_resource_profiles->scope_profiles[index], + scope_profiles); + + if (result != CPROF_ENCODE_OPENTELEMETRY_SUCCESS) { + destroy_resource_profiles(otlp_resource_profiles); + + return result; + } + + index++; + } + + if (input_instance->schema_url != NULL) { + otlp_resource_profiles->schema_url = cfl_sds_create(input_instance->schema_url); + + if (otlp_resource_profiles->schema_url == NULL) { + destroy_resource_profiles(otlp_resource_profiles); + + return CPROF_ENCODE_OPENTELEMETRY_ALLOCATION_ERROR; + } + } + + *output_instance = otlp_resource_profiles; + + return CPROF_ENCODE_OPENTELEMETRY_SUCCESS; +} + + +static int pack_context_profiles( + struct cprof_opentelemetry_encoding_context *context, + struct cprof *profile) +{ + size_t index; + int result; + struct cfl_list *iterator; + struct cprof_resource_profiles *resource_profiles; + + context->export_service_request = \ + initialize_export_profiles_service_request(cfl_list_size(&profile->profiles)); + + if (context->export_service_request == NULL) { + return CPROF_ENCODE_OPENTELEMETRY_ALLOCATION_ERROR; + } + + index = 0; + cfl_list_foreach(iterator, + &profile->profiles) { + resource_profiles = cfl_list_entry( + iterator, + struct cprof_resource_profiles, _head); + + result = pack_cprof_resource_profiles( + &context->export_service_request->resource_profiles[index], + resource_profiles); + + if (result != CPROF_ENCODE_OPENTELEMETRY_SUCCESS) { + destroy_export_profiles_service_request(context->export_service_request); + + return result; + } + + index++; + } + + return CPROF_ENCODE_OPENTELEMETRY_SUCCESS; +} + +static int pack_context( + struct cprof_opentelemetry_encoding_context *context, + struct cprof *profile) +{ + memset(context, 0, sizeof(struct cprof_opentelemetry_encoding_context)); + + context->inner_context = profile; + + return pack_context_profiles(context, profile); +} + +static cfl_sds_t render_opentelemetry_context_to_sds( + struct cprof_opentelemetry_encoding_context *context) +{ + cfl_sds_t result_buffer; + size_t result_size; + + result_size = opentelemetry__proto__collector__profiles__v1development__export_profiles_service_request__get_packed_size( + context->export_service_request); + + result_buffer = cfl_sds_create_size(result_size); + + if(result_buffer != NULL) { + opentelemetry__proto__collector__profiles__v1development__export_profiles_service_request__pack( + context->export_service_request, + (uint8_t *) result_buffer); + + cfl_sds_set_len(result_buffer, result_size); + } + + return result_buffer; +} + +int cprof_encode_opentelemetry_create(cfl_sds_t *result_buffer, + struct cprof *profile) +{ + int result; + struct cprof_opentelemetry_encoding_context context; + + *result_buffer = NULL; + + result = pack_context(&context, profile); + + if (result == CPROF_ENCODE_OPENTELEMETRY_SUCCESS) { + *result_buffer = render_opentelemetry_context_to_sds(&context); + + if (*result_buffer == NULL) { + result = CPROF_ENCODE_OPENTELEMETRY_INTERNAL_ENCODER_ERROR; + } + + destroy_export_profiles_service_request(context.export_service_request); + } + + return result; +} + +void cprof_encode_opentelemetry_destroy(cfl_sds_t instance) +{ + if (instance != NULL) { + cfl_sds_destroy(instance); + } +} diff --git a/lib/cprofiles/src/cprof_encode_text.c b/lib/cprofiles/src/cprof_encode_text.c index 218a72b5b63..299af8aa2e2 100644 --- a/lib/cprofiles/src/cprof_encode_text.c +++ b/lib/cprofiles/src/cprof_encode_text.c @@ -208,7 +208,6 @@ static int increment_indentation_level( static int decrement_indentation_level( struct cprof_text_encoding_context *context) { - cfl_sds_t result; if (context->indentation_level <= 0) { return CPROF_ENCODE_TEXT_SUCCESS; } @@ -297,7 +296,6 @@ static int encode_string( { char *local_indentation; cfl_sds_t result; - size_t index; if (indent) { local_indentation = (char *) context->indentation_buffer; @@ -329,7 +327,6 @@ static int encode_double( { char *local_indentation; cfl_sds_t result; - size_t index; if (indent) { local_indentation = (char *) context->indentation_buffer; @@ -361,7 +358,6 @@ static int encode_uint64_t( { char *local_indentation; cfl_sds_t result; - size_t index; if (indent) { local_indentation = (char *) context->indentation_buffer; @@ -393,7 +389,6 @@ static int encode_int64_t( { char *local_indentation; cfl_sds_t result; - size_t index; if (indent) { local_indentation = (char *) context->indentation_buffer; @@ -426,7 +421,6 @@ static int encode_bool( char *local_indentation; char *local_value; cfl_sds_t result; - size_t index; if (indent) { local_indentation = (char *) context->indentation_buffer; @@ -716,7 +710,6 @@ static int encode_cfl_kvlist( cfl_sds_t sds_result; struct cfl_list *iterator; int result; - size_t index; struct cfl_kvpair *entry; if (indent) { @@ -858,7 +851,7 @@ static int encode_cfl_variant( indent, prefix, suffix, - value->data.as_bytes, + (uint8_t *) value->data.as_bytes, cfl_sds_len(value->data.as_bytes), CFL_TRUE); break; @@ -970,18 +963,15 @@ static int encode_cprof_value_type( static int encode_cprof_sample( struct cprof_text_encoding_context *context, struct cprof_sample *instance) { - cfl_sds_t sds_result; - int result; - size_t index; - + int result; - result = encode_int64_t_array(context, - CFL_TRUE, - "Location index : [ ", - ", ", - "]\n", - instance->location_index, - instance->location_index_count); + result = encode_uint64_t_array(context, + CFL_TRUE, + "Location index : [ ", + ", ", + "]\n", + instance->location_index, + instance->location_index_count); if (result != CPROF_ENCODE_TEXT_SUCCESS) { return result; @@ -1067,8 +1057,7 @@ static int encode_cprof_sample( static int encode_cprof_mapping( struct cprof_text_encoding_context *context, struct cprof_mapping *instance) { - int result; - size_t index; + int result; result = encode_uint64_t(context, CFL_TRUE, @@ -1183,8 +1172,7 @@ static int encode_cprof_mapping( static int encode_cprof_line( struct cprof_text_encoding_context *context, struct cprof_line *instance) { - int result; - size_t index; + int result; result = encode_uint64_t(context, CFL_TRUE, @@ -1226,7 +1214,6 @@ static int encode_cprof_location( struct cprof_location *instance) { struct cfl_list *iterator; int result; - size_t index; struct cprof_line *line; result = encode_uint64_t(context, @@ -1316,8 +1303,7 @@ static int encode_cprof_location( static int encode_cprof_function( struct cprof_text_encoding_context *context, struct cprof_function *instance) { - int result; - size_t index; + int result; result = encode_uint64_t(context, CFL_TRUE, @@ -1378,8 +1364,7 @@ static int encode_cprof_function( static int encode_cprof_attribute_unit( struct cprof_text_encoding_context *context, struct cprof_attribute_unit *instance) { - int result; - size_t index; + int result; result = encode_int64_t(context, CFL_TRUE, @@ -1408,8 +1393,7 @@ static int encode_cprof_link( struct cprof_text_encoding_context *context, struct cprof_link *instance) { - int result; - size_t index; + int result; result = encode_bytes(context, CFL_TRUE, @@ -1450,7 +1434,6 @@ static int encode_cprof_profile( struct cprof_mapping *mapping; struct cprof_sample *sample; int result; - size_t index; struct cprof_link *link; result = encode_bytes(context, @@ -1654,13 +1637,13 @@ static int encode_cprof_profile( } } - result = encode_uint64_t_array(context, - CFL_TRUE, - "Location indices : [ ", - ", ", - "]\n", - instance->location_indices, - instance->location_indices_count); + result = encode_int64_t_array(context, + CFL_TRUE, + "Location indices : [ ", + ", ", + "]\n", + instance->location_indices, + instance->location_indices_count); if (result != CPROF_ENCODE_TEXT_SUCCESS) { return result; @@ -1909,7 +1892,7 @@ static int encode_cprof_resource_profiles( struct cprof_resource_profiles *instance) { int result; struct cfl_list *iterator; - struct cprof_scope_profile *scope_profile; + struct cprof_scope_profiles *scope_profile; result = encode_string(context, CFL_TRUE, @@ -1996,9 +1979,7 @@ static int encode_cprof_resource_profiles( static int encode_cprof_instrumentation_scope( struct cprof_text_encoding_context *context, struct cprof_instrumentation_scope *instance) { - int result; - struct cfl_list *iterator; - struct cprof_profile *profile; + int result; result = encode_string(context, CFL_TRUE, @@ -2166,6 +2147,91 @@ static int encode_cprof_scope_profiles( return CPROF_ENCODE_TEXT_SUCCESS; } + + + + + + + + + + + + + + + + + + + +void print_profile(struct cprof_profile *profile) +{ + int i; + int sample_index = 0; + uint64_t location_idx; + char *tmp; + struct cfl_list *head; + struct cfl_list *type_head; + struct cprof_sample *sample; + struct cprof_value_type *sample_type; + + printf("\n"); + printf("--- profile debug\n"); + printf("Profile Duration: %" PRId64 " nanoseconds\n\n", profile->duration_nanos); + printf("Samples:\n"); + + cfl_list_foreach(head, &profile->samples) { + sample = cfl_list_entry(head, struct cprof_sample, _head); + + printf(" Sample #%d:\n", ++sample_index); + + printf(" Locations:\n"); + for (i = 0; i < sample->location_index_count; ++i) { + location_idx = sample->location_index[i]; + tmp = profile->string_table[location_idx]; + if (tmp[0] == '\0') { + printf(" [Empty String: No Function Name]\n"); + } else { + printf(" Function: %s\n", tmp); + } + } + + printf(" Values:\n"); + size_t value_index = 0; + cfl_list_foreach(type_head, &profile->sample_type) { + sample_type = cfl_list_entry(type_head, struct cprof_value_type, _head); + if (value_index < sample->value_count) { + printf(" %s: %" PRId64 " %s\n", + profile->string_table[sample_type->type], + sample->values[value_index], + profile->string_table[sample_type->unit]); + } + value_index++; + } + + if (sample->timestamps_count > 0) { + printf(" Timestamps:\n"); + for (i = 0; i < sample->timestamps_count; ++i) { + printf(" Timestamp %d: %" PRIu64 " ns\n", i, sample->timestamps_unix_nano[i]); + } + } else { + printf(" [No Timestamps]\n"); + } + + printf("\n"); // Add space between samples for readability + } + printf("String Table:\n"); + for (i = 0; i < profile->string_table_count; i++) { + printf(" %d: '%s'\n", i, profile->string_table[i]); + } + printf("\n"); +} + + + + int cprof_encode_text_create(cfl_sds_t *result_buffer, struct cprof *profile) { @@ -2190,6 +2256,10 @@ int cprof_encode_text_create(cfl_sds_t *result_buffer, return CPROF_ENCODE_TEXT_ALLOCATION_ERROR; } + memset(context.indentation_buffer, + 0, + cfl_sds_alloc(context.indentation_buffer)); + context.indentation_level_size = 4; context.indentation_character = ' '; diff --git a/lib/cprofiles/src/cprof_mpack_utils.c b/lib/cprofiles/src/cprof_mpack_utils.c new file mode 100644 index 00000000000..c204218cf21 --- /dev/null +++ b/lib/cprofiles/src/cprof_mpack_utils.c @@ -0,0 +1,488 @@ +/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ + +/* CProfiles + * ======== + * Copyright 2024 The CProfiles Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include + +int cprof_mpack_consume_string_or_nil_tag(mpack_reader_t *reader, cfl_sds_t *output_buffer) +{ + int result; + + if (cprof_mpack_peek_type(reader) == mpack_type_str) { + result = cprof_mpack_consume_string_tag(reader, output_buffer); + } + else if (cprof_mpack_peek_type(reader) == mpack_type_nil) { + result = cprof_mpack_consume_nil_tag(reader); + + *output_buffer = NULL; + } + else { + result = CPROF_MPACK_UNEXPECTED_DATA_TYPE_ERROR; + } + + return result; +} + +int cprof_mpack_consume_binary_or_nil_tag(mpack_reader_t *reader, cfl_sds_t *output_buffer) +{ + int result; + + if (cprof_mpack_peek_type(reader) == mpack_type_bin) { + result = cprof_mpack_consume_binary_tag(reader, output_buffer); + } + else if (cprof_mpack_peek_type(reader) == mpack_type_nil) { + result = cprof_mpack_consume_nil_tag(reader); + + *output_buffer = NULL; + } + else { + result = CPROF_MPACK_UNEXPECTED_DATA_TYPE_ERROR; + } + + return result; +} + +int cprof_mpack_consume_nil_tag(mpack_reader_t *reader) +{ + mpack_tag_t tag; + + if (NULL == reader) { + return CPROF_MPACK_INVALID_ARGUMENT_ERROR; + } + + tag = mpack_read_tag(reader); + + if (mpack_ok != mpack_reader_error(reader)) { + return CPROF_MPACK_ENGINE_ERROR; + } + + if (mpack_type_nil != mpack_tag_type(&tag)) { + return CPROF_MPACK_UNEXPECTED_DATA_TYPE_ERROR; + } + + return CPROF_MPACK_SUCCESS; +} + +int cprof_mpack_consume_double_tag(mpack_reader_t *reader, double *output_buffer) +{ + mpack_tag_t tag; + + if (NULL == output_buffer) { + return CPROF_MPACK_INVALID_ARGUMENT_ERROR; + } + + if (NULL == reader) { + return CPROF_MPACK_INVALID_ARGUMENT_ERROR; + } + + tag = mpack_read_tag(reader); + + if (mpack_ok != mpack_reader_error(reader)) { + return CPROF_MPACK_ENGINE_ERROR; + } + + if (mpack_type_double != mpack_tag_type(&tag)) { + return CPROF_MPACK_UNEXPECTED_DATA_TYPE_ERROR; + } + + *output_buffer = mpack_tag_double_value(&tag); + + return CPROF_MPACK_SUCCESS; +} + +int cprof_mpack_consume_uint_tag(mpack_reader_t *reader, uint64_t *output_buffer) +{ + mpack_tag_t tag; + + if (NULL == output_buffer) { + return CPROF_MPACK_INVALID_ARGUMENT_ERROR; + } + + if (NULL == reader) { + return CPROF_MPACK_INVALID_ARGUMENT_ERROR; + } + + tag = mpack_read_tag(reader); + + if (mpack_ok != mpack_reader_error(reader)) { + return CPROF_MPACK_ENGINE_ERROR; + } + + if (mpack_type_int == mpack_tag_type(&tag)) { + *output_buffer = (uint64_t) mpack_tag_int_value(&tag); + } + else if (mpack_type_uint == mpack_tag_type(&tag)) { + *output_buffer = (uint64_t) mpack_tag_uint_value(&tag); + } + else { + return CPROF_MPACK_UNEXPECTED_DATA_TYPE_ERROR; + } + + return CPROF_MPACK_SUCCESS; +} + +int cprof_mpack_consume_uint32_tag(mpack_reader_t *reader, uint32_t *output_buffer) +{ + int result; + uint64_t value; + + result = cprof_mpack_consume_uint_tag(reader, &value); + + if (result == CPROF_MPACK_SUCCESS) { + *output_buffer = (uint32_t) value; + } + + return result; +} + +int cprof_mpack_consume_uint64_tag(mpack_reader_t *reader, uint64_t *output_buffer) +{ + return cprof_mpack_consume_uint_tag(reader, output_buffer); +} + +int cprof_mpack_consume_int_tag(mpack_reader_t *reader, int64_t *output_buffer) +{ + mpack_tag_t tag; + + if (NULL == output_buffer) { + return CPROF_MPACK_INVALID_ARGUMENT_ERROR; + } + + if (NULL == reader) { + return CPROF_MPACK_INVALID_ARGUMENT_ERROR; + } + + tag = mpack_read_tag(reader); + + if (mpack_ok != mpack_reader_error(reader)) { + return CPROF_MPACK_ENGINE_ERROR; + } + + if (mpack_type_int == mpack_tag_type(&tag)) { + *output_buffer = (int64_t) mpack_tag_int_value(&tag); + } + else if (mpack_type_uint == mpack_tag_type(&tag)) { + *output_buffer = (int64_t) mpack_tag_uint_value(&tag); + } + else { + return CPROF_MPACK_UNEXPECTED_DATA_TYPE_ERROR; + } + + return CPROF_MPACK_SUCCESS; +} + +int cprof_mpack_consume_int32_tag(mpack_reader_t *reader, int32_t *output_buffer) +{ + int result; + int64_t value; + + result = cprof_mpack_consume_int_tag(reader, &value); + + if (result == CPROF_MPACK_SUCCESS) { + *output_buffer = (int32_t) value; + } + + return result; +} + +int cprof_mpack_consume_int64_tag(mpack_reader_t *reader, int64_t *output_buffer) +{ + return cprof_mpack_consume_int_tag(reader, output_buffer); +} + +int cprof_mpack_consume_string_tag(mpack_reader_t *reader, cfl_sds_t *output_buffer) +{ + uint32_t string_length; + mpack_tag_t tag; + + if (NULL == output_buffer) { + return CPROF_MPACK_INVALID_ARGUMENT_ERROR; + } + + if (NULL == reader) { + return CPROF_MPACK_INVALID_ARGUMENT_ERROR; + } + + tag = mpack_read_tag(reader); + + if (mpack_ok != mpack_reader_error(reader)) { + return CPROF_MPACK_ENGINE_ERROR; + } + + if (mpack_type_str != mpack_tag_type(&tag)) { + return CPROF_MPACK_UNEXPECTED_DATA_TYPE_ERROR; + } + + string_length = mpack_tag_str_length(&tag); + + /* This validation only applies to cmetrics and its use cases, we know + * for a fact that our label names and values are not supposed to be really + * long so a huge value here probably means that the data stream got corrupted. + */ + + if (CPROF_MPACK_MAX_STRING_LENGTH < string_length) { + return CPROF_MPACK_CORRUPT_INPUT_DATA_ERROR; + } + + *output_buffer = cfl_sds_create_size(string_length + 1); + + if (NULL == *output_buffer) { + return CPROF_MPACK_ALLOCATION_ERROR; + } + + cfl_sds_set_len(*output_buffer, string_length); + + mpack_read_cstr(reader, *output_buffer, string_length + 1, string_length); + + if (mpack_ok != mpack_reader_error(reader)) { + cfl_sds_destroy(*output_buffer); + + *output_buffer = NULL; + + return CPROF_MPACK_ENGINE_ERROR; + } + + mpack_done_str(reader); + + if (mpack_ok != mpack_reader_error(reader)) { + cfl_sds_destroy(*output_buffer); + + *output_buffer = NULL; + + return CPROF_MPACK_ENGINE_ERROR; + } + + return CPROF_MPACK_SUCCESS; +} + +int cprof_mpack_consume_binary_tag(mpack_reader_t *reader, cfl_sds_t *output_buffer) +{ + uint32_t string_length; + mpack_tag_t tag; + + if (NULL == output_buffer) { + return CPROF_MPACK_INVALID_ARGUMENT_ERROR; + } + + if (NULL == reader) { + return CPROF_MPACK_INVALID_ARGUMENT_ERROR; + } + + tag = mpack_read_tag(reader); + + if (mpack_ok != mpack_reader_error(reader)) { + return CPROF_MPACK_ENGINE_ERROR; + } + + if (mpack_type_bin != mpack_tag_type(&tag)) { + return CPROF_MPACK_UNEXPECTED_DATA_TYPE_ERROR; + } + + string_length = mpack_tag_bin_length(&tag); + + *output_buffer = cfl_sds_create_size(string_length); + + if (NULL == *output_buffer) { + return CPROF_MPACK_ALLOCATION_ERROR; + } + + cfl_sds_set_len(*output_buffer, string_length); + + mpack_read_bytes(reader, *output_buffer, string_length); + + if (mpack_ok != mpack_reader_error(reader)) { + cfl_sds_destroy(*output_buffer); + + *output_buffer = NULL; + + return CPROF_MPACK_ENGINE_ERROR; + } + + mpack_done_bin(reader); + + if (mpack_ok != mpack_reader_error(reader)) { + cfl_sds_destroy(*output_buffer); + + *output_buffer = NULL; + + return CPROF_MPACK_ENGINE_ERROR; + } + + return CPROF_MPACK_SUCCESS; +} + +int cprof_mpack_unpack_map(mpack_reader_t *reader, + struct cprof_mpack_map_entry_callback_t *callback_list, + void *context) +{ + struct cprof_mpack_map_entry_callback_t *callback_entry; + uint32_t entry_index; + uint32_t entry_count; + cfl_sds_t key_name; + int result; + mpack_tag_t tag; + + tag = mpack_read_tag(reader); + + if (mpack_ok != mpack_reader_error(reader)) { + return CPROF_MPACK_ENGINE_ERROR; + } + + if (mpack_type_map != mpack_tag_type(&tag)) { + return CPROF_MPACK_UNEXPECTED_DATA_TYPE_ERROR; + } + + entry_count = mpack_tag_map_count(&tag); + + /* This validation only applies to cmetrics and its use cases, we know + * how our schema looks and how many entries the different fields have and none + * of those exceed the number we set CPROF_MPACK_MAX_MAP_ENTRY_COUNT to which is 10. + * Making these sanity checks optional or configurable in runtime might be worth + * the itme and complexity cost but that's something I don't know at the moment. + */ + + if (CPROF_MPACK_MAX_MAP_ENTRY_COUNT < entry_count) { + return CPROF_MPACK_CORRUPT_INPUT_DATA_ERROR; + } + + result = 0; + + for (entry_index = 0 ; 0 == result && entry_index < entry_count ; entry_index++) { + result = cprof_mpack_consume_string_tag(reader, &key_name); + + if (CPROF_MPACK_SUCCESS == result) { + callback_entry = callback_list; + result = CPROF_MPACK_UNEXPECTED_KEY_ERROR; + + while (CPROF_MPACK_UNEXPECTED_KEY_ERROR == result && + NULL != callback_entry->identifier) { + + if (0 == strcmp(callback_entry->identifier, key_name)) { + result = callback_entry->handler(reader, entry_index, context); + } + + callback_entry++; + } + + cfl_sds_destroy(key_name); + } + } + + if (CPROF_MPACK_SUCCESS == result) { + mpack_done_map(reader); + + if (mpack_ok != mpack_reader_error(reader)) + { + return CPROF_MPACK_PENDING_MAP_ENTRIES; + } + } + + return result; +} + +int cprof_mpack_unpack_array(mpack_reader_t *reader, + cprof_mpack_unpacker_entry_callback_fn_t entry_processor_callback, + void *context) +{ + uint32_t entry_index; + uint32_t entry_count; + mpack_tag_t tag; + int result; + + tag = mpack_read_tag(reader); + + if (mpack_ok != mpack_reader_error(reader)) + { + return CPROF_MPACK_ENGINE_ERROR; + } + + if (mpack_type_array != mpack_tag_type(&tag)) { + return CPROF_MPACK_UNEXPECTED_DATA_TYPE_ERROR; + } + + entry_count = mpack_tag_array_count(&tag); + + /* This validation only applies to cmetrics and its use cases, we know + * that in our schema we have the following arrays : + * label text dictionary (strings) + * dimension labels (indexes) + * metric values + * dimension values + * + * IMO none of these arrays should be huge so I think using 65535 as a limit + * gives us more than enough wiggle space (in reality I don't expect any of these + * arrays to hold more than 128 values but I could be wrong as that probably depends + * on the flush interval) + */ + + if (CPROF_MPACK_MAX_ARRAY_ENTRY_COUNT < entry_count) { + return CPROF_MPACK_CORRUPT_INPUT_DATA_ERROR; + } + + result = CPROF_MPACK_SUCCESS; + + for (entry_index = 0 ; + CPROF_MPACK_SUCCESS == result && entry_index < entry_count ; + entry_index++) { + result = entry_processor_callback(reader, entry_index, context); + } + + if (CPROF_MPACK_SUCCESS == result) { + mpack_done_array(reader); + + if (mpack_ok != mpack_reader_error(reader)) + { + return CPROF_MPACK_PENDING_ARRAY_ENTRIES; + } + } + + return result; +} + +int cprof_mpack_peek_array_length(mpack_reader_t *reader) +{ + mpack_tag_t tag; + + tag = mpack_peek_tag(reader); + + if (mpack_ok != mpack_reader_error(reader)) + { + return 0; + } + + if (mpack_type_array != mpack_tag_type(&tag)) { + return 0; + } + + return mpack_tag_array_count(&tag); +} + +mpack_type_t cprof_mpack_peek_type(mpack_reader_t *reader) +{ + mpack_tag_t tag; + + tag = mpack_peek_tag(reader); + + if (mpack_reader_error(reader) != mpack_ok) { + return mpack_type_missing; + } + + return mpack_tag_type(&tag); +} diff --git a/lib/cprofiles/src/cprof_profile.c b/lib/cprofiles/src/cprof_profile.c index 66d62b3619d..2c833a4661a 100644 --- a/lib/cprofiles/src/cprof_profile.c +++ b/lib/cprofiles/src/cprof_profile.c @@ -98,7 +98,7 @@ void cprof_profile_destroy(struct cprof_profile *instance) struct cfl_list *iterator_backup; struct cprof_attribute_unit *attribute_unit; struct cprof_value_type *value_type; - struct cprof_mapping *location; + struct cprof_location *location; struct cprof_function *function; struct cfl_list *iterator; struct cprof_mapping *mapping; @@ -239,7 +239,7 @@ size_t cprof_profile_string_add(struct cprof_profile *profile, char *str, int st str_len = strlen(str); } - if (!profile->string_table) { + if (!profile->string_table && str_len > 0) { profile->string_table = malloc(alloc_size * sizeof(cfl_sds_t)); if (!profile->string_table) { return -1; diff --git a/lib/cprofiles/src/cprof_resource_profiles.c b/lib/cprofiles/src/cprof_resource_profiles.c index f0bec38e8b6..a2374930412 100644 --- a/lib/cprofiles/src/cprof_resource_profiles.c +++ b/lib/cprofiles/src/cprof_resource_profiles.c @@ -60,8 +60,7 @@ void cprof_resource_profiles_destroy(struct cprof_resource_profiles *instance) { iterator_backup, &instance->scope_profiles) { scope_profiles = cfl_list_entry(iterator, - struct cprof_scope_profiles, - _head); + struct cprof_scope_profiles, _head); cfl_list_del(&scope_profiles->_head); diff --git a/lib/cprofiles/tests/CMakeLists.txt b/lib/cprofiles/tests/CMakeLists.txt index cdecff12811..0da202814b1 100644 --- a/lib/cprofiles/tests/CMakeLists.txt +++ b/lib/cprofiles/tests/CMakeLists.txt @@ -1,5 +1,8 @@ set(UNIT_TESTS_FILES - decoder.c + profile.c + msgpack_transcoder.c + opentelemetry_transcoder.c + text_transcoder.c ) set(CPROF_TESTS_DATA_PATH "${CMAKE_CURRENT_SOURCE_DIR}/data") diff --git a/lib/cprofiles/tests/msgpack_transcoder.c b/lib/cprofiles/tests/msgpack_transcoder.c new file mode 100644 index 00000000000..a14bec1c6b6 --- /dev/null +++ b/lib/cprofiles/tests/msgpack_transcoder.c @@ -0,0 +1,701 @@ +/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ + +/* CProfiles + * ========= + * Copyright (C) 2024 The CProfiles Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include "cprof_tests.h" +#include +#include + +#include +#include +#include + +unsigned char serialized_data[] = { + 0x82, 0xA4, 0x6D, 0x65, 0x74, 0x61, 0x80, 0xA8, 0x70, 0x72, 0x6F, 0x66, + 0x69, 0x6C, 0x65, 0x73, 0x91, 0x83, 0xA8, 0x72, 0x65, 0x73, 0x6F, 0x75, + 0x72, 0x63, 0x65, 0x82, 0xAA, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, + 0x74, 0x65, 0x73, 0x85, 0xA7, 0x68, 0x6F, 0x73, 0x74, 0x2E, 0x69, 0x64, + 0xA1, 0x30, 0xA7, 0x68, 0x6F, 0x73, 0x74, 0x2E, 0x69, 0x70, 0xA9, 0x31, + 0x32, 0x37, 0x2E, 0x30, 0x2E, 0x30, 0x2E, 0x31, 0xA9, 0x68, 0x6F, 0x73, + 0x74, 0x2E, 0x6E, 0x61, 0x6D, 0x65, 0xAC, 0x6C, 0x69, 0x6D, 0x61, 0x2D, + 0x64, 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74, 0xAF, 0x73, 0x65, 0x72, 0x76, + 0x69, 0x63, 0x65, 0x2E, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6F, 0x6E, 0xA0, + 0xA9, 0x6F, 0x73, 0x2E, 0x6B, 0x65, 0x72, 0x6E, 0x65, 0x6C, 0xA5, 0x36, + 0x2E, 0x35, 0x2E, 0x30, 0xB7, 0x64, 0x72, 0x6F, 0x70, 0x70, 0x65, 0x64, + 0x5F, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x5F, 0x63, + 0x6F, 0x75, 0x6E, 0x74, 0x00, 0xAE, 0x73, 0x63, 0x6F, 0x70, 0x65, 0x5F, + 0x70, 0x72, 0x6F, 0x66, 0x69, 0x6C, 0x65, 0x73, 0x91, 0x83, 0xB5, 0x69, + 0x6E, 0x73, 0x74, 0x72, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x61, 0x74, 0x69, + 0x6F, 0x6E, 0x5F, 0x73, 0x63, 0x6F, 0x70, 0x65, 0x84, 0xA4, 0x6E, 0x61, + 0x6D, 0x65, 0xA0, 0xA7, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6F, 0x6E, 0xA0, + 0xAA, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x80, + 0xB7, 0x64, 0x72, 0x6F, 0x70, 0x70, 0x65, 0x64, 0x5F, 0x61, 0x74, 0x74, + 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x5F, 0x63, 0x6F, 0x75, 0x6E, 0x74, + 0x00, 0xA8, 0x70, 0x72, 0x6F, 0x66, 0x69, 0x6C, 0x65, 0x73, 0x91, 0xDE, + 0x00, 0x17, 0xAA, 0x70, 0x72, 0x6F, 0x66, 0x69, 0x6C, 0x65, 0x5F, 0x69, + 0x64, 0xC4, 0x10, 0xA4, 0x58, 0x33, 0xE6, 0x18, 0xE6, 0x34, 0x8D, 0xD6, + 0xFE, 0x00, 0x58, 0x56, 0xF5, 0xA7, 0x54, 0xB4, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x5F, 0x74, 0x69, 0x6D, 0x65, 0x5F, 0x75, 0x6E, 0x69, 0x78, 0x5F, + 0x6E, 0x61, 0x6E, 0x6F, 0xCF, 0x18, 0x04, 0xC7, 0x53, 0x2C, 0xAC, 0x39, + 0x69, 0xB2, 0x65, 0x6E, 0x64, 0x5F, 0x74, 0x69, 0x6D, 0x65, 0x5F, 0x75, + 0x6E, 0x69, 0x78, 0x5F, 0x6E, 0x61, 0x6E, 0x6F, 0xCF, 0x18, 0x04, 0xC7, + 0x53, 0x2C, 0xAC, 0x39, 0x69, 0xAA, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, + 0x75, 0x74, 0x65, 0x73, 0x80, 0xB2, 0x64, 0x72, 0x6F, 0x70, 0x70, 0x65, + 0x64, 0x5F, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, + 0x00, 0xAC, 0x73, 0x61, 0x6D, 0x70, 0x6C, 0x65, 0x5F, 0x74, 0x79, 0x70, + 0x65, 0x73, 0x91, 0x83, 0xA4, 0x74, 0x79, 0x70, 0x65, 0x01, 0xA4, 0x75, + 0x6E, 0x69, 0x74, 0x02, 0xB7, 0x61, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, + 0x74, 0x69, 0x6F, 0x6E, 0x5F, 0x74, 0x65, 0x6D, 0x70, 0x6F, 0x72, 0x61, + 0x6C, 0x69, 0x74, 0x79, 0x00, 0xA6, 0x73, 0x61, 0x6D, 0x70, 0x6C, 0x65, + 0x93, 0x87, 0xAE, 0x6C, 0x6F, 0x63, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x5F, + 0x69, 0x6E, 0x64, 0x65, 0x78, 0x90, 0xB5, 0x6C, 0x6F, 0x63, 0x61, 0x74, + 0x69, 0x6F, 0x6E, 0x73, 0x5F, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5F, 0x69, + 0x6E, 0x64, 0x65, 0x78, 0x00, 0xB0, 0x6C, 0x6F, 0x63, 0x61, 0x74, 0x69, + 0x6F, 0x6E, 0x73, 0x5F, 0x6C, 0x65, 0x6E, 0x67, 0x74, 0x68, 0x05, 0xA6, + 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x91, 0x01, 0xAA, 0x61, 0x74, 0x74, + 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x92, 0x01, 0x02, 0xA4, 0x6C, + 0x69, 0x6E, 0x6B, 0x00, 0xB4, 0x74, 0x69, 0x6D, 0x65, 0x73, 0x74, 0x61, + 0x6D, 0x70, 0x73, 0x5F, 0x75, 0x6E, 0x69, 0x78, 0x5F, 0x6E, 0x61, 0x6E, + 0x6F, 0x91, 0xCF, 0x18, 0x04, 0xC7, 0x52, 0xCA, 0x52, 0xB5, 0x76, 0x87, + 0xAE, 0x6C, 0x6F, 0x63, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x5F, 0x69, 0x6E, + 0x64, 0x65, 0x78, 0x90, 0xB5, 0x6C, 0x6F, 0x63, 0x61, 0x74, 0x69, 0x6F, + 0x6E, 0x73, 0x5F, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5F, 0x69, 0x6E, 0x64, + 0x65, 0x78, 0x05, 0xB0, 0x6C, 0x6F, 0x63, 0x61, 0x74, 0x69, 0x6F, 0x6E, + 0x73, 0x5F, 0x6C, 0x65, 0x6E, 0x67, 0x74, 0x68, 0x0E, 0xA6, 0x76, 0x61, + 0x6C, 0x75, 0x65, 0x73, 0x91, 0x01, 0xAA, 0x61, 0x74, 0x74, 0x72, 0x69, + 0x62, 0x75, 0x74, 0x65, 0x73, 0x92, 0x06, 0x07, 0xA4, 0x6C, 0x69, 0x6E, + 0x6B, 0x00, 0xB4, 0x74, 0x69, 0x6D, 0x65, 0x73, 0x74, 0x61, 0x6D, 0x70, + 0x73, 0x5F, 0x75, 0x6E, 0x69, 0x78, 0x5F, 0x6E, 0x61, 0x6E, 0x6F, 0x91, + 0xCF, 0x18, 0x04, 0xC7, 0x53, 0x11, 0xD8, 0xE9, 0xA8, 0x87, 0xAE, 0x6C, + 0x6F, 0x63, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x5F, 0x69, 0x6E, 0x64, 0x65, + 0x78, 0x90, 0xB5, 0x6C, 0x6F, 0x63, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x73, + 0x5F, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, + 0x13, 0xB0, 0x6C, 0x6F, 0x63, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x73, 0x5F, + 0x6C, 0x65, 0x6E, 0x67, 0x74, 0x68, 0x12, 0xA6, 0x76, 0x61, 0x6C, 0x75, + 0x65, 0x73, 0x91, 0x01, 0xAA, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, + 0x74, 0x65, 0x73, 0x92, 0x09, 0x0A, 0xA4, 0x6C, 0x69, 0x6E, 0x6B, 0x00, + 0xB4, 0x74, 0x69, 0x6D, 0x65, 0x73, 0x74, 0x61, 0x6D, 0x70, 0x73, 0x5F, + 0x75, 0x6E, 0x69, 0x78, 0x5F, 0x6E, 0x61, 0x6E, 0x6F, 0x91, 0xCF, 0x18, + 0x04, 0xC7, 0x53, 0x2C, 0xAC, 0x39, 0x69, 0xA8, 0x6D, 0x61, 0x70, 0x70, + 0x69, 0x6E, 0x67, 0x73, 0x93, 0x8A, 0xA2, 0x69, 0x64, 0x00, 0xAC, 0x6D, + 0x65, 0x6D, 0x6F, 0x72, 0x79, 0x5F, 0x73, 0x74, 0x61, 0x72, 0x74, 0x00, + 0xAC, 0x6D, 0x65, 0x6D, 0x6F, 0x72, 0x79, 0x5F, 0x6C, 0x69, 0x6D, 0x69, + 0x74, 0x00, 0xAB, 0x66, 0x69, 0x6C, 0x65, 0x5F, 0x6F, 0x66, 0x66, 0x73, + 0x65, 0x74, 0x00, 0xA8, 0x66, 0x69, 0x6C, 0x65, 0x6E, 0x61, 0x6D, 0x65, + 0x00, 0xAA, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, + 0x90, 0xAD, 0x68, 0x61, 0x73, 0x5F, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, + 0x6F, 0x6E, 0x73, 0x00, 0xAD, 0x68, 0x61, 0x73, 0x5F, 0x66, 0x69, 0x6C, + 0x65, 0x6E, 0x61, 0x6D, 0x65, 0x73, 0x00, 0xB0, 0x68, 0x61, 0x73, 0x5F, + 0x6C, 0x69, 0x6E, 0x65, 0x5F, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x73, + 0x00, 0xB1, 0x68, 0x61, 0x73, 0x5F, 0x69, 0x6E, 0x6C, 0x69, 0x6E, 0x65, + 0x5F, 0x66, 0x72, 0x61, 0x6D, 0x65, 0x73, 0x00, 0x8A, 0xA2, 0x69, 0x64, + 0x00, 0xAC, 0x6D, 0x65, 0x6D, 0x6F, 0x72, 0x79, 0x5F, 0x73, 0x74, 0x61, + 0x72, 0x74, 0xCE, 0x00, 0x40, 0x00, 0x00, 0xAC, 0x6D, 0x65, 0x6D, 0x6F, + 0x72, 0x79, 0x5F, 0x6C, 0x69, 0x6D, 0x69, 0x74, 0xCE, 0x01, 0x1D, 0x00, + 0x00, 0xAB, 0x66, 0x69, 0x6C, 0x65, 0x5F, 0x6F, 0x66, 0x66, 0x73, 0x65, + 0x74, 0x00, 0xA8, 0x66, 0x69, 0x6C, 0x65, 0x6E, 0x61, 0x6D, 0x65, 0x08, + 0xAA, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x92, + 0x04, 0x05, 0xAD, 0x68, 0x61, 0x73, 0x5F, 0x66, 0x75, 0x6E, 0x63, 0x74, + 0x69, 0x6F, 0x6E, 0x73, 0x00, 0xAD, 0x68, 0x61, 0x73, 0x5F, 0x66, 0x69, + 0x6C, 0x65, 0x6E, 0x61, 0x6D, 0x65, 0x73, 0x00, 0xB0, 0x68, 0x61, 0x73, + 0x5F, 0x6C, 0x69, 0x6E, 0x65, 0x5F, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, + 0x73, 0x00, 0xB1, 0x68, 0x61, 0x73, 0x5F, 0x69, 0x6E, 0x6C, 0x69, 0x6E, + 0x65, 0x5F, 0x66, 0x72, 0x61, 0x6D, 0x65, 0x73, 0x00, 0x8A, 0xA2, 0x69, + 0x64, 0x00, 0xAC, 0x6D, 0x65, 0x6D, 0x6F, 0x72, 0x79, 0x5F, 0x73, 0x74, + 0x61, 0x72, 0x74, 0xCE, 0x00, 0x01, 0x00, 0x00, 0xAC, 0x6D, 0x65, 0x6D, + 0x6F, 0x72, 0x79, 0x5F, 0x6C, 0x69, 0x6D, 0x69, 0x74, 0xCE, 0x00, 0xFE, + 0xE0, 0x00, 0xAB, 0x66, 0x69, 0x6C, 0x65, 0x5F, 0x6F, 0x66, 0x66, 0x73, + 0x65, 0x74, 0x00, 0xA8, 0x66, 0x69, 0x6C, 0x65, 0x6E, 0x61, 0x6D, 0x65, + 0x0A, 0xAA, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, + 0x91, 0x08, 0xAD, 0x68, 0x61, 0x73, 0x5F, 0x66, 0x75, 0x6E, 0x63, 0x74, + 0x69, 0x6F, 0x6E, 0x73, 0x00, 0xAD, 0x68, 0x61, 0x73, 0x5F, 0x66, 0x69, + 0x6C, 0x65, 0x6E, 0x61, 0x6D, 0x65, 0x73, 0x00, 0xB0, 0x68, 0x61, 0x73, + 0x5F, 0x6C, 0x69, 0x6E, 0x65, 0x5F, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, + 0x73, 0x00, 0xB1, 0x68, 0x61, 0x73, 0x5F, 0x69, 0x6E, 0x6C, 0x69, 0x6E, + 0x65, 0x5F, 0x66, 0x72, 0x61, 0x6D, 0x65, 0x73, 0x00, 0xA9, 0x6C, 0x6F, + 0x63, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x73, 0xDC, 0x00, 0x25, 0x85, 0xA2, + 0x69, 0x64, 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, 0x5F, + 0x69, 0x6E, 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, 0x65, + 0x73, 0x73, 0xCE, 0x00, 0x10, 0xE0, 0xDB, 0xA5, 0x6C, 0x69, 0x6E, 0x65, + 0x73, 0x91, 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, + 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x01, 0xA4, 0x6C, 0x69, 0x6E, 0x65, + 0x00, 0xA6, 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, 0x74, + 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, 0xA2, + 0x69, 0x64, 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, 0x5F, + 0x69, 0x6E, 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, 0x65, + 0x73, 0x73, 0xCE, 0x01, 0x54, 0x85, 0xC7, 0xA5, 0x6C, 0x69, 0x6E, 0x65, + 0x73, 0x91, 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, + 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x02, 0xA4, 0x6C, 0x69, 0x6E, 0x65, + 0x00, 0xA6, 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, 0x74, + 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, 0xA2, + 0x69, 0x64, 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, 0x5F, + 0x69, 0x6E, 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, 0x65, + 0x73, 0x73, 0xCE, 0x00, 0x0E, 0x8A, 0x37, 0xA5, 0x6C, 0x69, 0x6E, 0x65, + 0x73, 0x91, 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, + 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x03, 0xA4, 0x6C, 0x69, 0x6E, 0x65, + 0x00, 0xA6, 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, 0x74, + 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, 0xA2, + 0x69, 0x64, 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, 0x5F, + 0x69, 0x6E, 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, 0x65, + 0x73, 0x73, 0xCE, 0x00, 0x0F, 0x4B, 0x77, 0xA5, 0x6C, 0x69, 0x6E, 0x65, + 0x73, 0x91, 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, + 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x04, 0xA4, 0x6C, 0x69, 0x6E, 0x65, + 0x00, 0xA6, 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, 0x74, + 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, 0xA2, + 0x69, 0x64, 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, 0x5F, + 0x69, 0x6E, 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, 0x65, + 0x73, 0x73, 0xCD, 0x7D, 0x07, 0xA5, 0x6C, 0x69, 0x6E, 0x65, 0x73, 0x91, + 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x5F, 0x69, + 0x6E, 0x64, 0x65, 0x78, 0x05, 0xA4, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0xA6, + 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, 0x74, 0x74, 0x72, + 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, 0xA2, 0x69, 0x64, + 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, 0x5F, 0x69, 0x6E, + 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, + 0xCE, 0x00, 0x48, 0x6B, 0x43, 0xA5, 0x6C, 0x69, 0x6E, 0x65, 0x73, 0x91, + 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x5F, 0x69, + 0x6E, 0x64, 0x65, 0x78, 0x06, 0xA4, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0xA6, + 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, 0x74, 0x74, 0x72, + 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, 0xA2, 0x69, 0x64, + 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, 0x5F, 0x69, 0x6E, + 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, + 0xCE, 0x00, 0x4C, 0xDA, 0xBB, 0xA5, 0x6C, 0x69, 0x6E, 0x65, 0x73, 0x91, + 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x5F, 0x69, + 0x6E, 0x64, 0x65, 0x78, 0x07, 0xA4, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0xA6, + 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, 0x74, 0x74, 0x72, + 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, 0xA2, 0x69, 0x64, + 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, 0x5F, 0x69, 0x6E, + 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, + 0xCE, 0x00, 0x4C, 0xDB, 0xE7, 0xA5, 0x6C, 0x69, 0x6E, 0x65, 0x73, 0x91, + 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x5F, 0x69, + 0x6E, 0x64, 0x65, 0x78, 0x08, 0xA4, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0xA6, + 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, 0x74, 0x74, 0x72, + 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, 0xA2, 0x69, 0x64, + 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, 0x5F, 0x69, 0x6E, + 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, + 0xCE, 0x00, 0x2E, 0x6A, 0x93, 0xA5, 0x6C, 0x69, 0x6E, 0x65, 0x73, 0x91, + 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x5F, 0x69, + 0x6E, 0x64, 0x65, 0x78, 0x09, 0xA4, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0xA6, + 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, 0x74, 0x74, 0x72, + 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, 0xA2, 0x69, 0x64, + 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, 0x5F, 0x69, 0x6E, + 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, + 0xCE, 0x00, 0x2E, 0x06, 0x57, 0xA5, 0x6C, 0x69, 0x6E, 0x65, 0x73, 0x91, + 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x5F, 0x69, + 0x6E, 0x64, 0x65, 0x78, 0x0A, 0xA4, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0xA6, + 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, 0x74, 0x74, 0x72, + 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, 0xA2, 0x69, 0x64, + 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, 0x5F, 0x69, 0x6E, + 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, + 0xCE, 0x00, 0x2E, 0x89, 0x97, 0xA5, 0x6C, 0x69, 0x6E, 0x65, 0x73, 0x91, + 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x5F, 0x69, + 0x6E, 0x64, 0x65, 0x78, 0x0B, 0xA4, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0xA6, + 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, 0x74, 0x74, 0x72, + 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, 0xA2, 0x69, 0x64, + 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, 0x5F, 0x69, 0x6E, + 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, + 0xCE, 0x00, 0x2E, 0x94, 0x1F, 0xA5, 0x6C, 0x69, 0x6E, 0x65, 0x73, 0x91, + 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x5F, 0x69, + 0x6E, 0x64, 0x65, 0x78, 0x0C, 0xA4, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0xA6, + 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, 0x74, 0x74, 0x72, + 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, 0xA2, 0x69, 0x64, + 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, 0x5F, 0x69, 0x6E, + 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, + 0xCE, 0x00, 0x02, 0x3D, 0x6B, 0xA5, 0x6C, 0x69, 0x6E, 0x65, 0x73, 0x91, + 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x5F, 0x69, + 0x6E, 0x64, 0x65, 0x78, 0x0D, 0xA4, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0xA6, + 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, 0x74, 0x74, 0x72, + 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, 0xA2, 0x69, 0x64, + 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, 0x5F, 0x69, 0x6E, + 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, + 0xCE, 0x00, 0x02, 0x3F, 0x53, 0xA5, 0x6C, 0x69, 0x6E, 0x65, 0x73, 0x91, + 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x5F, 0x69, + 0x6E, 0x64, 0x65, 0x78, 0x0E, 0xA4, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0xA6, + 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, 0x74, 0x74, 0x72, + 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, 0xA2, 0x69, 0x64, + 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, 0x5F, 0x69, 0x6E, + 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, + 0xCE, 0x00, 0x02, 0x3F, 0xB7, 0xA5, 0x6C, 0x69, 0x6E, 0x65, 0x73, 0x91, + 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x5F, 0x69, + 0x6E, 0x64, 0x65, 0x78, 0x0F, 0xA4, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0xA6, + 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, 0x74, 0x74, 0x72, + 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, 0xA2, 0x69, 0x64, + 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, 0x5F, 0x69, 0x6E, + 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, + 0xCE, 0x01, 0x53, 0xDE, 0xA7, 0xA5, 0x6C, 0x69, 0x6E, 0x65, 0x73, 0x91, + 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x5F, 0x69, + 0x6E, 0x64, 0x65, 0x78, 0x10, 0xA4, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0xA6, + 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, 0x74, 0x74, 0x72, + 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, 0xA2, 0x69, 0x64, + 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, 0x5F, 0x69, 0x6E, + 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, + 0xCE, 0x01, 0x53, 0xE5, 0x4F, 0xA5, 0x6C, 0x69, 0x6E, 0x65, 0x73, 0x91, + 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x5F, 0x69, + 0x6E, 0x64, 0x65, 0x78, 0x11, 0xA4, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0xA6, + 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, 0x74, 0x74, 0x72, + 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, 0xA2, 0x69, 0x64, + 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, 0x5F, 0x69, 0x6E, + 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, + 0xCD, 0x1E, 0x47, 0xA5, 0x6C, 0x69, 0x6E, 0x65, 0x73, 0x91, 0x83, 0xAE, + 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x5F, 0x69, 0x6E, 0x64, + 0x65, 0x78, 0x12, 0xA4, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0xA6, 0x63, 0x6F, + 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, + 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, 0xA2, 0x69, 0x64, 0x00, 0xAD, + 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, 0x5F, 0x69, 0x6E, 0x64, 0x65, + 0x78, 0x01, 0xA7, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0xCE, 0x00, + 0x40, 0x53, 0x1F, 0xA5, 0x6C, 0x69, 0x6E, 0x65, 0x73, 0x90, 0xAA, 0x61, + 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x03, 0x85, + 0xA2, 0x69, 0x64, 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, + 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, + 0x65, 0x73, 0x73, 0xCE, 0x00, 0x4A, 0x66, 0x9F, 0xA5, 0x6C, 0x69, 0x6E, + 0x65, 0x73, 0x91, 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, + 0x6E, 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x13, 0xA4, 0x6C, 0x69, 0x6E, + 0x65, 0x00, 0xA6, 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, + 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, + 0xA2, 0x69, 0x64, 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, + 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, + 0x65, 0x73, 0x73, 0xCE, 0x00, 0x4B, 0x2F, 0xC3, 0xA5, 0x6C, 0x69, 0x6E, + 0x65, 0x73, 0x91, 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, + 0x6E, 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x14, 0xA4, 0x6C, 0x69, 0x6E, + 0x65, 0x00, 0xA6, 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, + 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, + 0xA2, 0x69, 0x64, 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, + 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, + 0x65, 0x73, 0x73, 0xCE, 0x00, 0x4B, 0x4F, 0xB3, 0xA5, 0x6C, 0x69, 0x6E, + 0x65, 0x73, 0x91, 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, + 0x6E, 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x15, 0xA4, 0x6C, 0x69, 0x6E, + 0x65, 0x00, 0xA6, 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, + 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, + 0xA2, 0x69, 0x64, 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, + 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, + 0x65, 0x73, 0x73, 0xCE, 0x00, 0x48, 0x30, 0x9B, 0xA5, 0x6C, 0x69, 0x6E, + 0x65, 0x73, 0x91, 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, + 0x6E, 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x16, 0xA4, 0x6C, 0x69, 0x6E, + 0x65, 0x00, 0xA6, 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, + 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, + 0xA2, 0x69, 0x64, 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, + 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, + 0x65, 0x73, 0x73, 0xCE, 0x01, 0x21, 0xB4, 0x4B, 0xA5, 0x6C, 0x69, 0x6E, + 0x65, 0x73, 0x91, 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, + 0x6E, 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x17, 0xA4, 0x6C, 0x69, 0x6E, + 0x65, 0x00, 0xA6, 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, + 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, + 0xA2, 0x69, 0x64, 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, + 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, + 0x65, 0x73, 0x73, 0xCE, 0x01, 0x21, 0xF1, 0xEB, 0xA5, 0x6C, 0x69, 0x6E, + 0x65, 0x73, 0x91, 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, + 0x6E, 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x18, 0xA4, 0x6C, 0x69, 0x6E, + 0x65, 0x00, 0xA6, 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, + 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, + 0xA2, 0x69, 0x64, 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, + 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, + 0x65, 0x73, 0x73, 0xCE, 0x01, 0x3F, 0x97, 0x7B, 0xA5, 0x6C, 0x69, 0x6E, + 0x65, 0x73, 0x91, 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, + 0x6E, 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x19, 0xA4, 0x6C, 0x69, 0x6E, + 0x65, 0x00, 0xA6, 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, + 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, + 0xA2, 0x69, 0x64, 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, + 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, + 0x65, 0x73, 0x73, 0xCE, 0x01, 0x3F, 0x98, 0x67, 0xA5, 0x6C, 0x69, 0x6E, + 0x65, 0x73, 0x91, 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, + 0x6E, 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x1A, 0xA4, 0x6C, 0x69, 0x6E, + 0x65, 0x00, 0xA6, 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, + 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, + 0xA2, 0x69, 0x64, 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, + 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, + 0x65, 0x73, 0x73, 0xCE, 0x01, 0x21, 0x48, 0x6F, 0xA5, 0x6C, 0x69, 0x6E, + 0x65, 0x73, 0x91, 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, + 0x6E, 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x1B, 0xA4, 0x6C, 0x69, 0x6E, + 0x65, 0x00, 0xA6, 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, + 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, + 0xA2, 0x69, 0x64, 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, + 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, + 0x65, 0x73, 0x73, 0xCE, 0x01, 0x21, 0x79, 0xF7, 0xA5, 0x6C, 0x69, 0x6E, + 0x65, 0x73, 0x91, 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, + 0x6E, 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x1C, 0xA4, 0x6C, 0x69, 0x6E, + 0x65, 0x00, 0xA6, 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, + 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, + 0xA2, 0x69, 0x64, 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, + 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, + 0x65, 0x73, 0x73, 0xCE, 0x01, 0x21, 0x7A, 0xCB, 0xA5, 0x6C, 0x69, 0x6E, + 0x65, 0x73, 0x91, 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, + 0x6E, 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x1D, 0xA4, 0x6C, 0x69, 0x6E, + 0x65, 0x00, 0xA6, 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, + 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, + 0xA2, 0x69, 0x64, 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, + 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, + 0x65, 0x73, 0x73, 0xCE, 0x00, 0x02, 0x3D, 0x6B, 0xA5, 0x6C, 0x69, 0x6E, + 0x65, 0x73, 0x91, 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, + 0x6E, 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x0D, 0xA4, 0x6C, 0x69, 0x6E, + 0x65, 0x00, 0xA6, 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, + 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, + 0xA2, 0x69, 0x64, 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, + 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, + 0x65, 0x73, 0x73, 0xCE, 0x00, 0x02, 0x3F, 0x53, 0xA5, 0x6C, 0x69, 0x6E, + 0x65, 0x73, 0x91, 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, + 0x6E, 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x0E, 0xA4, 0x6C, 0x69, 0x6E, + 0x65, 0x00, 0xA6, 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, + 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, + 0xA2, 0x69, 0x64, 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, + 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, + 0x65, 0x73, 0x73, 0xCE, 0x00, 0x02, 0x3F, 0xB7, 0xA5, 0x6C, 0x69, 0x6E, + 0x65, 0x73, 0x91, 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, + 0x6E, 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x0F, 0xA4, 0x6C, 0x69, 0x6E, + 0x65, 0x00, 0xA6, 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, + 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, + 0xA2, 0x69, 0x64, 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, + 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, + 0x65, 0x73, 0x73, 0xCE, 0x01, 0x53, 0xDE, 0xA7, 0xA5, 0x6C, 0x69, 0x6E, + 0x65, 0x73, 0x91, 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, + 0x6E, 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x10, 0xA4, 0x6C, 0x69, 0x6E, + 0x65, 0x00, 0xA6, 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, + 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, + 0xA2, 0x69, 0x64, 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, + 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, + 0x65, 0x73, 0x73, 0xCE, 0x01, 0x53, 0xE5, 0x4F, 0xA5, 0x6C, 0x69, 0x6E, + 0x65, 0x73, 0x91, 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, + 0x6E, 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x11, 0xA4, 0x6C, 0x69, 0x6E, + 0x65, 0x00, 0xA6, 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, + 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, + 0xA2, 0x69, 0x64, 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, + 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, + 0x65, 0x73, 0x73, 0xCD, 0x1E, 0x47, 0xA5, 0x6C, 0x69, 0x6E, 0x65, 0x73, + 0x91, 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x5F, + 0x69, 0x6E, 0x64, 0x65, 0x78, 0x12, 0xA4, 0x6C, 0x69, 0x6E, 0x65, 0x00, + 0xA6, 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, 0x74, 0x74, + 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, 0xA2, 0x69, + 0x64, 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, 0x5F, 0x69, + 0x6E, 0x64, 0x65, 0x78, 0x02, 0xA7, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, + 0x73, 0xCE, 0x00, 0x01, 0x5F, 0xAF, 0xA5, 0x6C, 0x69, 0x6E, 0x65, 0x73, + 0x90, 0xAA, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, + 0x91, 0x03, 0xB0, 0x6C, 0x6F, 0x63, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x5F, + 0x69, 0x6E, 0x64, 0x69, 0x63, 0x65, 0x73, 0xDC, 0x00, 0x25, 0x00, 0x01, + 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, + 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, + 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, 0xA9, + 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x73, 0xDC, 0x00, 0x1E, + 0x85, 0xA2, 0x69, 0x64, 0x00, 0xA4, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xAB, + 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x5F, 0x6E, 0x61, 0x6D, 0x65, 0x00, + 0xA8, 0x66, 0x69, 0x6C, 0x65, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xAA, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x5F, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0x85, 0xA2, + 0x69, 0x64, 0x00, 0xA4, 0x6E, 0x61, 0x6D, 0x65, 0x18, 0xAB, 0x73, 0x79, + 0x73, 0x74, 0x65, 0x6D, 0x5F, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xA8, 0x66, + 0x69, 0x6C, 0x65, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xAA, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x5F, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0x85, 0xA2, 0x69, 0x64, + 0x00, 0xA4, 0x6E, 0x61, 0x6D, 0x65, 0x10, 0xAB, 0x73, 0x79, 0x73, 0x74, + 0x65, 0x6D, 0x5F, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xA8, 0x66, 0x69, 0x6C, + 0x65, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xAA, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x5F, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0x85, 0xA2, 0x69, 0x64, 0x00, 0xA4, + 0x6E, 0x61, 0x6D, 0x65, 0x24, 0xAB, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, + 0x5F, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xA8, 0x66, 0x69, 0x6C, 0x65, 0x6E, + 0x61, 0x6D, 0x65, 0x00, 0xAA, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5F, 0x6C, + 0x69, 0x6E, 0x65, 0x00, 0x85, 0xA2, 0x69, 0x64, 0x00, 0xA4, 0x6E, 0x61, + 0x6D, 0x65, 0x19, 0xAB, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x5F, 0x6E, + 0x61, 0x6D, 0x65, 0x00, 0xA8, 0x66, 0x69, 0x6C, 0x65, 0x6E, 0x61, 0x6D, + 0x65, 0x00, 0xAA, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5F, 0x6C, 0x69, 0x6E, + 0x65, 0x00, 0x85, 0xA2, 0x69, 0x64, 0x00, 0xA4, 0x6E, 0x61, 0x6D, 0x65, + 0x21, 0xAB, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x5F, 0x6E, 0x61, 0x6D, + 0x65, 0x00, 0xA8, 0x66, 0x69, 0x6C, 0x65, 0x6E, 0x61, 0x6D, 0x65, 0x00, + 0xAA, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5F, 0x6C, 0x69, 0x6E, 0x65, 0x00, + 0x85, 0xA2, 0x69, 0x64, 0x00, 0xA4, 0x6E, 0x61, 0x6D, 0x65, 0x1A, 0xAB, + 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x5F, 0x6E, 0x61, 0x6D, 0x65, 0x00, + 0xA8, 0x66, 0x69, 0x6C, 0x65, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xAA, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x5F, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0x85, 0xA2, + 0x69, 0x64, 0x00, 0xA4, 0x6E, 0x61, 0x6D, 0x65, 0x25, 0xAB, 0x73, 0x79, + 0x73, 0x74, 0x65, 0x6D, 0x5F, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xA8, 0x66, + 0x69, 0x6C, 0x65, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xAA, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x5F, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0x85, 0xA2, 0x69, 0x64, + 0x00, 0xA4, 0x6E, 0x61, 0x6D, 0x65, 0x0B, 0xAB, 0x73, 0x79, 0x73, 0x74, + 0x65, 0x6D, 0x5F, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xA8, 0x66, 0x69, 0x6C, + 0x65, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xAA, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x5F, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0x85, 0xA2, 0x69, 0x64, 0x00, 0xA4, + 0x6E, 0x61, 0x6D, 0x65, 0x26, 0xAB, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, + 0x5F, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xA8, 0x66, 0x69, 0x6C, 0x65, 0x6E, + 0x61, 0x6D, 0x65, 0x00, 0xAA, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5F, 0x6C, + 0x69, 0x6E, 0x65, 0x00, 0x85, 0xA2, 0x69, 0x64, 0x00, 0xA4, 0x6E, 0x61, + 0x6D, 0x65, 0x11, 0xAB, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x5F, 0x6E, + 0x61, 0x6D, 0x65, 0x00, 0xA8, 0x66, 0x69, 0x6C, 0x65, 0x6E, 0x61, 0x6D, + 0x65, 0x00, 0xAA, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5F, 0x6C, 0x69, 0x6E, + 0x65, 0x00, 0x85, 0xA2, 0x69, 0x64, 0x00, 0xA4, 0x6E, 0x61, 0x6D, 0x65, + 0x14, 0xAB, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x5F, 0x6E, 0x61, 0x6D, + 0x65, 0x00, 0xA8, 0x66, 0x69, 0x6C, 0x65, 0x6E, 0x61, 0x6D, 0x65, 0x00, + 0xAA, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5F, 0x6C, 0x69, 0x6E, 0x65, 0x00, + 0x85, 0xA2, 0x69, 0x64, 0x00, 0xA4, 0x6E, 0x61, 0x6D, 0x65, 0x15, 0xAB, + 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x5F, 0x6E, 0x61, 0x6D, 0x65, 0x00, + 0xA8, 0x66, 0x69, 0x6C, 0x65, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xAA, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x5F, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0x85, 0xA2, + 0x69, 0x64, 0x00, 0xA4, 0x6E, 0x61, 0x6D, 0x65, 0x12, 0xAB, 0x73, 0x79, + 0x73, 0x74, 0x65, 0x6D, 0x5F, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xA8, 0x66, + 0x69, 0x6C, 0x65, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xAA, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x5F, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0x85, 0xA2, 0x69, 0x64, + 0x00, 0xA4, 0x6E, 0x61, 0x6D, 0x65, 0x22, 0xAB, 0x73, 0x79, 0x73, 0x74, + 0x65, 0x6D, 0x5F, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xA8, 0x66, 0x69, 0x6C, + 0x65, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xAA, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x5F, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0x85, 0xA2, 0x69, 0x64, 0x00, 0xA4, + 0x6E, 0x61, 0x6D, 0x65, 0x16, 0xAB, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, + 0x5F, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xA8, 0x66, 0x69, 0x6C, 0x65, 0x6E, + 0x61, 0x6D, 0x65, 0x00, 0xAA, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5F, 0x6C, + 0x69, 0x6E, 0x65, 0x00, 0x85, 0xA2, 0x69, 0x64, 0x00, 0xA4, 0x6E, 0x61, + 0x6D, 0x65, 0x0E, 0xAB, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x5F, 0x6E, + 0x61, 0x6D, 0x65, 0x00, 0xA8, 0x66, 0x69, 0x6C, 0x65, 0x6E, 0x61, 0x6D, + 0x65, 0x00, 0xAA, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5F, 0x6C, 0x69, 0x6E, + 0x65, 0x00, 0x85, 0xA2, 0x69, 0x64, 0x00, 0xA4, 0x6E, 0x61, 0x6D, 0x65, + 0x1B, 0xAB, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x5F, 0x6E, 0x61, 0x6D, + 0x65, 0x00, 0xA8, 0x66, 0x69, 0x6C, 0x65, 0x6E, 0x61, 0x6D, 0x65, 0x00, + 0xAA, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5F, 0x6C, 0x69, 0x6E, 0x65, 0x00, + 0x85, 0xA2, 0x69, 0x64, 0x00, 0xA4, 0x6E, 0x61, 0x6D, 0x65, 0x1E, 0xAB, + 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x5F, 0x6E, 0x61, 0x6D, 0x65, 0x00, + 0xA8, 0x66, 0x69, 0x6C, 0x65, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xAA, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x5F, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0x85, 0xA2, + 0x69, 0x64, 0x00, 0xA4, 0x6E, 0x61, 0x6D, 0x65, 0x17, 0xAB, 0x73, 0x79, + 0x73, 0x74, 0x65, 0x6D, 0x5F, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xA8, 0x66, + 0x69, 0x6C, 0x65, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xAA, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x5F, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0x85, 0xA2, 0x69, 0x64, + 0x00, 0xA4, 0x6E, 0x61, 0x6D, 0x65, 0x27, 0xAB, 0x73, 0x79, 0x73, 0x74, + 0x65, 0x6D, 0x5F, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xA8, 0x66, 0x69, 0x6C, + 0x65, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xAA, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x5F, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0x85, 0xA2, 0x69, 0x64, 0x00, 0xA4, + 0x6E, 0x61, 0x6D, 0x65, 0x0C, 0xAB, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, + 0x5F, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xA8, 0x66, 0x69, 0x6C, 0x65, 0x6E, + 0x61, 0x6D, 0x65, 0x00, 0xAA, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5F, 0x6C, + 0x69, 0x6E, 0x65, 0x00, 0x85, 0xA2, 0x69, 0x64, 0x00, 0xA4, 0x6E, 0x61, + 0x6D, 0x65, 0x13, 0xAB, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x5F, 0x6E, + 0x61, 0x6D, 0x65, 0x00, 0xA8, 0x66, 0x69, 0x6C, 0x65, 0x6E, 0x61, 0x6D, + 0x65, 0x00, 0xAA, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5F, 0x6C, 0x69, 0x6E, + 0x65, 0x00, 0x85, 0xA2, 0x69, 0x64, 0x00, 0xA4, 0x6E, 0x61, 0x6D, 0x65, + 0x1F, 0xAB, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x5F, 0x6E, 0x61, 0x6D, + 0x65, 0x00, 0xA8, 0x66, 0x69, 0x6C, 0x65, 0x6E, 0x61, 0x6D, 0x65, 0x00, + 0xAA, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5F, 0x6C, 0x69, 0x6E, 0x65, 0x00, + 0x85, 0xA2, 0x69, 0x64, 0x00, 0xA4, 0x6E, 0x61, 0x6D, 0x65, 0x23, 0xAB, + 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x5F, 0x6E, 0x61, 0x6D, 0x65, 0x00, + 0xA8, 0x66, 0x69, 0x6C, 0x65, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xAA, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x5F, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0x85, 0xA2, + 0x69, 0x64, 0x00, 0xA4, 0x6E, 0x61, 0x6D, 0x65, 0x0F, 0xAB, 0x73, 0x79, + 0x73, 0x74, 0x65, 0x6D, 0x5F, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xA8, 0x66, + 0x69, 0x6C, 0x65, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xAA, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x5F, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0x85, 0xA2, 0x69, 0x64, + 0x00, 0xA4, 0x6E, 0x61, 0x6D, 0x65, 0x1C, 0xAB, 0x73, 0x79, 0x73, 0x74, + 0x65, 0x6D, 0x5F, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xA8, 0x66, 0x69, 0x6C, + 0x65, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xAA, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x5F, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0x85, 0xA2, 0x69, 0x64, 0x00, 0xA4, + 0x6E, 0x61, 0x6D, 0x65, 0x0D, 0xAB, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, + 0x5F, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xA8, 0x66, 0x69, 0x6C, 0x65, 0x6E, + 0x61, 0x6D, 0x65, 0x00, 0xAA, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5F, 0x6C, + 0x69, 0x6E, 0x65, 0x00, 0x85, 0xA2, 0x69, 0x64, 0x00, 0xA4, 0x6E, 0x61, + 0x6D, 0x65, 0x20, 0xAB, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x5F, 0x6E, + 0x61, 0x6D, 0x65, 0x00, 0xA8, 0x66, 0x69, 0x6C, 0x65, 0x6E, 0x61, 0x6D, + 0x65, 0x00, 0xAA, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5F, 0x6C, 0x69, 0x6E, + 0x65, 0x00, 0x85, 0xA2, 0x69, 0x64, 0x00, 0xA4, 0x6E, 0x61, 0x6D, 0x65, + 0x1D, 0xAB, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x5F, 0x6E, 0x61, 0x6D, + 0x65, 0x00, 0xA8, 0x66, 0x69, 0x6C, 0x65, 0x6E, 0x61, 0x6D, 0x65, 0x00, + 0xAA, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5F, 0x6C, 0x69, 0x6E, 0x65, 0x00, + 0xAF, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x5F, 0x74, + 0x61, 0x62, 0x6C, 0x65, 0x8B, 0xB2, 0x70, 0x72, 0x6F, 0x66, 0x69, 0x6C, + 0x65, 0x2E, 0x66, 0x72, 0x61, 0x6D, 0x65, 0x2E, 0x74, 0x79, 0x70, 0x65, + 0xA6, 0x6B, 0x65, 0x72, 0x6E, 0x65, 0x6C, 0xAC, 0x63, 0x6F, 0x6E, 0x74, + 0x61, 0x69, 0x6E, 0x65, 0x72, 0x2E, 0x69, 0x64, 0xA1, 0x2F, 0xAB, 0x74, + 0x68, 0x72, 0x65, 0x61, 0x64, 0x2E, 0x6E, 0x61, 0x6D, 0x65, 0xAB, 0x6B, + 0x77, 0x6F, 0x72, 0x6B, 0x65, 0x72, 0x2F, 0x36, 0x3A, 0x31, 0xB2, 0x70, + 0x72, 0x6F, 0x66, 0x69, 0x6C, 0x65, 0x2E, 0x66, 0x72, 0x61, 0x6D, 0x65, + 0x2E, 0x74, 0x79, 0x70, 0x65, 0xA6, 0x6E, 0x61, 0x74, 0x69, 0x76, 0x65, + 0xBF, 0x70, 0x72, 0x6F, 0x63, 0x65, 0x73, 0x73, 0x2E, 0x65, 0x78, 0x65, + 0x63, 0x75, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2E, 0x62, 0x75, 0x69, 0x6C, + 0x64, 0x5F, 0x69, 0x64, 0x2E, 0x67, 0x6E, 0x75, 0xD9, 0x28, 0x33, 0x34, + 0x31, 0x39, 0x61, 0x33, 0x65, 0x66, 0x30, 0x30, 0x31, 0x35, 0x34, 0x35, + 0x64, 0x38, 0x65, 0x65, 0x39, 0x66, 0x63, 0x64, 0x34, 0x62, 0x31, 0x38, + 0x64, 0x34, 0x63, 0x65, 0x31, 0x37, 0x32, 0x30, 0x35, 0x37, 0x65, 0x33, + 0x33, 0x39, 0xD9, 0x25, 0x70, 0x72, 0x6F, 0x63, 0x65, 0x73, 0x73, 0x2E, + 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2E, 0x62, + 0x75, 0x69, 0x6C, 0x64, 0x5F, 0x69, 0x64, 0x2E, 0x70, 0x72, 0x6F, 0x66, + 0x69, 0x6C, 0x69, 0x6E, 0x67, 0xD9, 0x20, 0x37, 0x30, 0x35, 0x62, 0x64, + 0x66, 0x31, 0x34, 0x39, 0x38, 0x30, 0x66, 0x32, 0x63, 0x32, 0x32, 0x64, + 0x63, 0x34, 0x64, 0x65, 0x32, 0x65, 0x36, 0x35, 0x37, 0x36, 0x65, 0x64, + 0x66, 0x66, 0x38, 0xAC, 0x63, 0x6F, 0x6E, 0x74, 0x61, 0x69, 0x6E, 0x65, + 0x72, 0x2E, 0x69, 0x64, 0xD9, 0x2A, 0x2F, 0x75, 0x73, 0x65, 0x72, 0x2E, + 0x73, 0x6C, 0x69, 0x63, 0x65, 0x2F, 0x75, 0x73, 0x65, 0x72, 0x2D, 0x35, + 0x30, 0x31, 0x2E, 0x73, 0x6C, 0x69, 0x63, 0x65, 0x2F, 0x73, 0x65, 0x73, + 0x73, 0x69, 0x6F, 0x6E, 0x2D, 0x32, 0x2E, 0x73, 0x63, 0x6F, 0x70, 0x65, + 0xAB, 0x74, 0x68, 0x72, 0x65, 0x61, 0x64, 0x2E, 0x6E, 0x61, 0x6D, 0x65, + 0xAD, 0x65, 0x62, 0x70, 0x66, 0x2D, 0x70, 0x72, 0x6F, 0x66, 0x69, 0x6C, + 0x65, 0x72, 0xD9, 0x25, 0x70, 0x72, 0x6F, 0x63, 0x65, 0x73, 0x73, 0x2E, + 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2E, 0x62, + 0x75, 0x69, 0x6C, 0x64, 0x5F, 0x69, 0x64, 0x2E, 0x70, 0x72, 0x6F, 0x66, + 0x69, 0x6C, 0x69, 0x6E, 0x67, 0xD9, 0x20, 0x64, 0x37, 0x38, 0x30, 0x31, + 0x36, 0x30, 0x34, 0x65, 0x38, 0x62, 0x38, 0x39, 0x64, 0x64, 0x61, 0x63, + 0x66, 0x65, 0x31, 0x39, 0x38, 0x39, 0x39, 0x64, 0x36, 0x62, 0x61, 0x33, + 0x35, 0x36, 0x34, 0xAC, 0x63, 0x6F, 0x6E, 0x74, 0x61, 0x69, 0x6E, 0x65, + 0x72, 0x2E, 0x69, 0x64, 0xD9, 0x48, 0x2F, 0x75, 0x73, 0x65, 0x72, 0x2E, + 0x73, 0x6C, 0x69, 0x63, 0x65, 0x2F, 0x75, 0x73, 0x65, 0x72, 0x2D, 0x35, + 0x30, 0x31, 0x2E, 0x73, 0x6C, 0x69, 0x63, 0x65, 0x2F, 0x75, 0x73, 0x65, + 0x72, 0x40, 0x35, 0x30, 0x31, 0x2E, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, + 0x65, 0x2F, 0x61, 0x70, 0x70, 0x2E, 0x73, 0x6C, 0x69, 0x63, 0x65, 0x2F, + 0x63, 0x6F, 0x6E, 0x74, 0x61, 0x69, 0x6E, 0x65, 0x72, 0x64, 0x2E, 0x73, + 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0xAB, 0x74, 0x68, 0x72, 0x65, 0x61, + 0x64, 0x2E, 0x6E, 0x61, 0x6D, 0x65, 0xAA, 0x63, 0x6F, 0x6E, 0x74, 0x61, + 0x69, 0x6E, 0x65, 0x72, 0x64, 0xAF, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, + 0x75, 0x74, 0x65, 0x5F, 0x75, 0x6E, 0x69, 0x74, 0x73, 0x90, 0xAA, 0x6C, + 0x69, 0x6E, 0x6B, 0x5F, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x90, 0xAC, 0x73, + 0x74, 0x72, 0x69, 0x6E, 0x67, 0x5F, 0x74, 0x61, 0x62, 0x6C, 0x65, 0xDC, + 0x00, 0x28, 0xA0, 0xA7, 0x73, 0x61, 0x6D, 0x70, 0x6C, 0x65, 0x73, 0xA5, + 0x63, 0x6F, 0x75, 0x6E, 0x74, 0xA3, 0x63, 0x70, 0x75, 0xAB, 0x6E, 0x61, + 0x6E, 0x6F, 0x73, 0x65, 0x63, 0x6F, 0x6E, 0x64, 0x73, 0xB6, 0x41, 0x54, + 0x73, 0x51, 0x46, 0x31, 0x72, 0x72, 0x49, 0x63, 0x30, 0x35, 0x74, 0x65, + 0x6A, 0x66, 0x79, 0x65, 0x73, 0x5A, 0x52, 0x77, 0xD9, 0x20, 0x62, 0x61, + 0x31, 0x63, 0x39, 0x61, 0x35, 0x61, 0x38, 0x32, 0x35, 0x36, 0x61, 0x36, + 0x65, 0x66, 0x33, 0x65, 0x36, 0x36, 0x33, 0x63, 0x63, 0x37, 0x33, 0x31, + 0x36, 0x38, 0x30, 0x33, 0x64, 0x39, 0xB6, 0x7A, 0x6A, 0x32, 0x51, 0x75, + 0x43, 0x52, 0x61, 0x70, 0x75, 0x6E, 0x30, 0x32, 0x73, 0x79, 0x68, 0x6C, + 0x41, 0x48, 0x71, 0x54, 0x77, 0xAD, 0x65, 0x62, 0x70, 0x66, 0x2D, 0x70, + 0x72, 0x6F, 0x66, 0x69, 0x6C, 0x65, 0x72, 0xB6, 0x36, 0x34, 0x41, 0x49, + 0x75, 0x76, 0x39, 0x69, 0x70, 0x47, 0x42, 0x41, 0x41, 0x64, 0x30, 0x52, + 0x5A, 0x6D, 0x76, 0x4C, 0x4C, 0x77, 0xAA, 0x63, 0x6F, 0x6E, 0x74, 0x61, + 0x69, 0x6E, 0x65, 0x72, 0x64, 0xB3, 0x5F, 0x5F, 0x63, 0x68, 0x65, 0x63, + 0x6B, 0x5F, 0x6F, 0x62, 0x6A, 0x65, 0x63, 0x74, 0x5F, 0x73, 0x69, 0x7A, + 0x65, 0xB1, 0x6F, 0x62, 0x6A, 0x5F, 0x63, 0x67, 0x72, 0x6F, 0x75, 0x70, + 0x5F, 0x63, 0x68, 0x61, 0x72, 0x67, 0x65, 0xAD, 0x5F, 0x5F, 0x73, 0x6F, + 0x63, 0x6B, 0x5F, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0xA7, 0x65, 0x6C, + 0x30, 0x5F, 0x73, 0x76, 0x63, 0xAC, 0x75, 0x6E, 0x69, 0x78, 0x5F, 0x63, + 0x72, 0x65, 0x61, 0x74, 0x65, 0x31, 0xA8, 0x73, 0x63, 0x68, 0x65, 0x64, + 0x75, 0x6C, 0x65, 0xB0, 0x62, 0x70, 0x66, 0x5F, 0x6D, 0x61, 0x70, 0x5F, + 0x64, 0x6F, 0x5F, 0x62, 0x61, 0x74, 0x63, 0x68, 0xAE, 0x69, 0x6E, 0x76, + 0x6F, 0x6B, 0x65, 0x5F, 0x73, 0x79, 0x73, 0x63, 0x61, 0x6C, 0x6C, 0xB0, + 0x6B, 0x6D, 0x65, 0x6D, 0x5F, 0x63, 0x61, 0x63, 0x68, 0x65, 0x5F, 0x61, + 0x6C, 0x6C, 0x6F, 0x63, 0xA9, 0x5F, 0x5F, 0x73, 0x79, 0x73, 0x5F, 0x62, + 0x70, 0x66, 0xAF, 0x5F, 0x5F, 0x61, 0x72, 0x6D, 0x36, 0x34, 0x5F, 0x73, + 0x79, 0x73, 0x5F, 0x62, 0x70, 0x66, 0xAA, 0x64, 0x6F, 0x5F, 0x65, 0x6C, + 0x30, 0x5F, 0x73, 0x76, 0x63, 0xB9, 0x70, 0x72, 0x6F, 0x70, 0x61, 0x67, + 0x61, 0x74, 0x65, 0x5F, 0x70, 0x72, 0x6F, 0x74, 0x65, 0x63, 0x74, 0x65, + 0x64, 0x5F, 0x75, 0x73, 0x61, 0x67, 0x65, 0xB9, 0x66, 0x69, 0x6E, 0x69, + 0x73, 0x68, 0x5F, 0x74, 0x61, 0x73, 0x6B, 0x5F, 0x73, 0x77, 0x69, 0x74, + 0x63, 0x68, 0x2E, 0x69, 0x73, 0x72, 0x61, 0x2E, 0x30, 0xA7, 0x6B, 0x74, + 0x68, 0x72, 0x65, 0x61, 0x64, 0xB3, 0x5F, 0x5F, 0x63, 0x68, 0x65, 0x63, + 0x6B, 0x5F, 0x68, 0x65, 0x61, 0x70, 0x5F, 0x6F, 0x62, 0x6A, 0x65, 0x63, + 0x74, 0xB4, 0x65, 0x6C, 0x30, 0x74, 0x5F, 0x36, 0x34, 0x5F, 0x73, 0x79, + 0x6E, 0x63, 0x5F, 0x68, 0x61, 0x6E, 0x64, 0x6C, 0x65, 0x72, 0xAB, 0x75, + 0x6E, 0x69, 0x78, 0x5F, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0xB2, 0x5F, + 0x5F, 0x61, 0x72, 0x6D, 0x36, 0x34, 0x5F, 0x73, 0x79, 0x73, 0x5F, 0x73, + 0x6F, 0x63, 0x6B, 0x65, 0x74, 0xAC, 0x65, 0x6C, 0x30, 0x74, 0x5F, 0x36, + 0x34, 0x5F, 0x73, 0x79, 0x6E, 0x63, 0xAD, 0x73, 0x6B, 0x5F, 0x70, 0x72, + 0x6F, 0x74, 0x5F, 0x61, 0x6C, 0x6C, 0x6F, 0x63, 0xAC, 0x5F, 0x5F, 0x73, + 0x79, 0x73, 0x5F, 0x73, 0x6F, 0x63, 0x6B, 0x65, 0x74, 0xAD, 0x72, 0x65, + 0x74, 0x5F, 0x66, 0x72, 0x6F, 0x6D, 0x5F, 0x66, 0x6F, 0x72, 0x6B, 0xBA, + 0x65, 0x6C, 0x30, 0x5F, 0x73, 0x76, 0x63, 0x5F, 0x63, 0x6F, 0x6D, 0x6D, + 0x6F, 0x6E, 0x2E, 0x63, 0x6F, 0x6E, 0x73, 0x74, 0x70, 0x72, 0x6F, 0x70, + 0x2E, 0x30, 0xA8, 0x73, 0x6B, 0x5F, 0x61, 0x6C, 0x6C, 0x6F, 0x63, 0xAD, + 0x77, 0x6F, 0x72, 0x6B, 0x65, 0x72, 0x5F, 0x74, 0x68, 0x72, 0x65, 0x61, + 0x64, 0xBA, 0x5F, 0x5F, 0x63, 0x68, 0x65, 0x63, 0x6B, 0x5F, 0x6F, 0x62, + 0x6A, 0x65, 0x63, 0x74, 0x5F, 0x73, 0x69, 0x7A, 0x65, 0x2E, 0x70, 0x61, + 0x72, 0x74, 0x2E, 0x30, 0xB8, 0x67, 0x65, 0x6E, 0x65, 0x72, 0x69, 0x63, + 0x5F, 0x6D, 0x61, 0x70, 0x5F, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x5F, + 0x62, 0x61, 0x74, 0x63, 0x68, 0xB0, 0x74, 0x72, 0x79, 0x5F, 0x63, 0x68, + 0x61, 0x72, 0x67, 0x65, 0x5F, 0x6D, 0x65, 0x6D, 0x63, 0x67, 0xAB, 0x64, + 0x72, 0x6F, 0x70, 0x5F, 0x66, 0x72, 0x61, 0x6D, 0x65, 0x73, 0x00, 0xAB, + 0x6B, 0x65, 0x65, 0x70, 0x5F, 0x66, 0x72, 0x61, 0x6D, 0x65, 0x73, 0x00, + 0xAA, 0x74, 0x69, 0x6D, 0x65, 0x5F, 0x6E, 0x61, 0x6E, 0x6F, 0x73, 0xCF, + 0x18, 0x04, 0xC7, 0x53, 0x2C, 0xAC, 0x39, 0x69, 0xAE, 0x64, 0x75, 0x72, + 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x5F, 0x6E, 0x61, 0x6E, 0x6F, 0x73, 0x00, + 0xAB, 0x70, 0x65, 0x72, 0x69, 0x6F, 0x64, 0x5F, 0x74, 0x79, 0x70, 0x65, + 0x83, 0xA4, 0x74, 0x79, 0x70, 0x65, 0x03, 0xA4, 0x75, 0x6E, 0x69, 0x74, + 0x04, 0xB7, 0x61, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6F, + 0x6E, 0x5F, 0x74, 0x65, 0x6D, 0x70, 0x6F, 0x72, 0x61, 0x6C, 0x69, 0x74, + 0x79, 0x00, 0xA6, 0x70, 0x65, 0x72, 0x69, 0x6F, 0x64, 0xCE, 0x02, 0xFA, + 0xF0, 0x80, 0xA8, 0x63, 0x6F, 0x6D, 0x6D, 0x65, 0x6E, 0x74, 0x73, 0x90, + 0xB3, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74, 0x5F, 0x73, 0x61, 0x6D, + 0x70, 0x6C, 0x65, 0x5F, 0x74, 0x79, 0x70, 0x65, 0x00, 0xAA, 0x73, 0x63, + 0x68, 0x65, 0x6D, 0x61, 0x5F, 0x75, 0x72, 0x6C, 0xA0, 0xAA, 0x73, 0x63, + 0x68, 0x65, 0x6D, 0x61, 0x5F, 0x75, 0x72, 0x6C, 0xA0 +}; + +#ifdef __CPROF_INCLUDE_DEBUG_HELPERS__ +int create_dump_file(char *filename, unsigned char *buffer, size_t buffer_length) +{ + FILE *output_file; + + output_file = fopen(filename, "wb+"); + + if (output_file == NULL) { + return -1; + } + + fwrite(buffer, + sizeof(unsigned char), + buffer_length, + output_file); + + fclose(output_file); +} +#endif + +static void test_encoder() +{ + cfl_sds_t msgpack_encoder_result; + struct cprof *context; + int result; + size_t offset; + + offset = 0; + context = NULL; + + result = cprof_decode_msgpack_create(&context, + (unsigned char *) serialized_data, + sizeof(serialized_data), + &offset); + + TEST_CHECK(result == CPROF_DECODE_MSGPACK_SUCCESS); + TEST_CHECK(offset == sizeof(serialized_data)); + + if (result == CPROF_DECODE_MSGPACK_SUCCESS) { + result = cprof_encode_msgpack_create(&msgpack_encoder_result, context); + + TEST_CHECK(result == CPROF_ENCODE_MSGPACK_SUCCESS); + + if (result == CPROF_ENCODE_MSGPACK_SUCCESS) { + cprof_encode_msgpack_destroy(msgpack_encoder_result); + } + + cprof_decode_msgpack_destroy(context); + } +} + +static void test_decoder() +{ + struct cprof *context; + int result; + size_t offset; + + offset = 0; + context = NULL; + + result = cprof_decode_msgpack_create(&context, + (unsigned char *) serialized_data, + sizeof(serialized_data), + &offset); + + TEST_CHECK(result == CPROF_DECODE_MSGPACK_SUCCESS); + TEST_CHECK(offset == sizeof(serialized_data)); + + if (result == CPROF_DECODE_MSGPACK_SUCCESS) { + cprof_decode_msgpack_destroy(context); + } +} + +TEST_LIST = { + {"encoder", test_encoder}, + {"decoder", test_decoder}, + { 0 } +}; diff --git a/lib/cprofiles/tests/decoder.c b/lib/cprofiles/tests/opentelemetry_transcoder.c similarity index 53% rename from lib/cprofiles/tests/decoder.c rename to lib/cprofiles/tests/opentelemetry_transcoder.c index 5b80be4361a..7c59e25fbd1 100644 --- a/lib/cprofiles/tests/decoder.c +++ b/lib/cprofiles/tests/opentelemetry_transcoder.c @@ -20,12 +20,13 @@ #include #include "cprof_tests.h" #include -#include +#include #include #include #include +/* unsigned char encoded_packet[] = { 0x0A, 0x9F, 0x11, 0x0A, 0x72, 0x0A, 0x0E, 0x0A, 0x07, 0x68, 0x6F, 0x73, 0x74, 0x2E, 0x69, 0x64, 0x12, 0x03, 0x0A, 0x01, 0x30, 0x0A, 0x16, 0x0A, 0x07, 0x68, 0x6F, 0x73, 0x74, 0x2E, \ 0x69, 0x70, 0x12, 0x0B, 0x0A, 0x09, 0x31, 0x32, 0x37, 0x2E, 0x30, 0x2E, 0x30, 0x2E, 0x31, 0x0A, 0x1B, 0x0A, 0x09, 0x68, 0x6F, 0x73, 0x74, 0x2E, 0x6E, 0x61, 0x6D, 0x65, 0x12, 0x0E, \ 0x0A, 0x0C, 0x6C, 0x69, 0x6D, 0x61, 0x2D, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74, 0x0A, 0x15, 0x0A, 0x0F, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2E, 0x76, 0x65, 0x72, 0x73, \ @@ -101,74 +102,228 @@ unsigned char encoded_packet[] = { 0x0A, 0x9F, 0x11, 0x0A, 0x72, 0x0A, 0x0E, 0x 0x65, 0x2F, 0x63, 0x6F, 0x6E, 0x74, 0x61, 0x69, 0x6E, 0x65, 0x72, 0x64, 0x2E, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x82, 0x01, 0x1B, 0x0A, 0x0B, 0x74, 0x68, 0x72, 0x65, 0x61, \ 0x64, 0x2E, 0x6E, 0x61, 0x6D, 0x65, 0x12, 0x0C, 0x0A, 0x0A, 0x63, 0x6F, 0x6E, 0x74, 0x61, 0x69, 0x6E, 0x65, 0x72, 0x64 }; +*/ -static void print_profile_(struct cprof_profile *profile) +unsigned char serialized_data[] = { + 0x0A, 0x9F, 0x11, 0x0A, 0x72, 0x0A, 0x0E, 0x0A, 0x07, 0x68, 0x6F, 0x73, + 0x74, 0x2E, 0x69, 0x64, 0x12, 0x03, 0x0A, 0x01, 0x30, 0x0A, 0x16, 0x0A, + 0x07, 0x68, 0x6F, 0x73, 0x74, 0x2E, 0x69, 0x70, 0x12, 0x0B, 0x0A, 0x09, + 0x31, 0x32, 0x37, 0x2E, 0x30, 0x2E, 0x30, 0x2E, 0x31, 0x0A, 0x1B, 0x0A, + 0x09, 0x68, 0x6F, 0x73, 0x74, 0x2E, 0x6E, 0x61, 0x6D, 0x65, 0x12, 0x0E, + 0x0A, 0x0C, 0x6C, 0x69, 0x6D, 0x61, 0x2D, 0x64, 0x65, 0x66, 0x61, 0x75, + 0x6C, 0x74, 0x0A, 0x15, 0x0A, 0x0F, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, + 0x65, 0x2E, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6F, 0x6E, 0x12, 0x02, 0x0A, + 0x00, 0x0A, 0x14, 0x0A, 0x09, 0x6F, 0x73, 0x2E, 0x6B, 0x65, 0x72, 0x6E, + 0x65, 0x6C, 0x12, 0x07, 0x0A, 0x05, 0x36, 0x2E, 0x35, 0x2E, 0x30, 0x12, + 0xA8, 0x10, 0x0A, 0x00, 0x12, 0xA3, 0x10, 0x0A, 0x10, 0xA4, 0x58, 0x33, + 0xE6, 0x18, 0xE6, 0x34, 0x8D, 0xD6, 0xFE, 0x00, 0x58, 0x56, 0xF5, 0xA7, + 0x54, 0x11, 0x69, 0x39, 0xAC, 0x2C, 0x53, 0xC7, 0x04, 0x18, 0x19, 0x69, + 0x39, 0xAC, 0x2C, 0x53, 0xC7, 0x04, 0x18, 0x42, 0xFC, 0x0F, 0x0A, 0x04, + 0x08, 0x01, 0x10, 0x02, 0x12, 0x16, 0x12, 0x01, 0x01, 0x40, 0x05, 0x48, + 0x05, 0x52, 0x02, 0x01, 0x02, 0x6A, 0x09, 0xF6, 0xEA, 0xCA, 0xD2, 0xAC, + 0xEA, 0xB1, 0x82, 0x18, 0x12, 0x18, 0x12, 0x01, 0x01, 0x38, 0x05, 0x40, + 0x0E, 0x48, 0x07, 0x52, 0x02, 0x06, 0x07, 0x6A, 0x09, 0xA8, 0xD3, 0xE3, + 0x8E, 0xB1, 0xEA, 0xB1, 0x82, 0x18, 0x12, 0x18, 0x12, 0x01, 0x01, 0x38, + 0x13, 0x40, 0x12, 0x48, 0x09, 0x52, 0x02, 0x09, 0x0A, 0x6A, 0x09, 0xE9, + 0xF2, 0xB0, 0xE5, 0xB2, 0xEA, 0xB1, 0x82, 0x18, 0x1A, 0x04, 0x30, 0x06, + 0x58, 0x01, 0x1A, 0x10, 0x10, 0x80, 0x80, 0x80, 0x02, 0x18, 0x80, 0x80, + 0xF4, 0x08, 0x28, 0x08, 0x62, 0x02, 0x04, 0x05, 0x1A, 0x0E, 0x10, 0x80, + 0x80, 0x04, 0x18, 0x80, 0xC0, 0xFB, 0x07, 0x28, 0x0A, 0x62, 0x01, 0x08, + 0x22, 0x0B, 0x18, 0xDB, 0xC1, 0x43, 0x22, 0x02, 0x08, 0x01, 0x3A, 0x01, + 0x00, 0x22, 0x0C, 0x18, 0xC7, 0x8B, 0xD2, 0x0A, 0x22, 0x02, 0x08, 0x02, + 0x3A, 0x01, 0x00, 0x22, 0x0B, 0x18, 0xB7, 0x94, 0x3A, 0x22, 0x02, 0x08, + 0x03, 0x3A, 0x01, 0x00, 0x22, 0x0B, 0x18, 0xF7, 0x96, 0x3D, 0x22, 0x02, + 0x08, 0x04, 0x3A, 0x01, 0x00, 0x22, 0x0B, 0x18, 0x87, 0xFA, 0x01, 0x22, + 0x02, 0x08, 0x05, 0x3A, 0x01, 0x00, 0x22, 0x0C, 0x18, 0xC3, 0xD6, 0xA1, + 0x02, 0x22, 0x02, 0x08, 0x06, 0x3A, 0x01, 0x00, 0x22, 0x0C, 0x18, 0xBB, + 0xB5, 0xB3, 0x02, 0x22, 0x02, 0x08, 0x07, 0x3A, 0x01, 0x00, 0x22, 0x0C, + 0x18, 0xE7, 0xB7, 0xB3, 0x02, 0x22, 0x02, 0x08, 0x08, 0x3A, 0x01, 0x00, + 0x22, 0x0C, 0x18, 0x93, 0xD5, 0xB9, 0x01, 0x22, 0x02, 0x08, 0x09, 0x3A, + 0x01, 0x00, 0x22, 0x0C, 0x18, 0xD7, 0x8C, 0xB8, 0x01, 0x22, 0x02, 0x08, + 0x0A, 0x3A, 0x01, 0x00, 0x22, 0x0C, 0x18, 0x97, 0x93, 0xBA, 0x01, 0x22, + 0x02, 0x08, 0x0B, 0x3A, 0x01, 0x00, 0x22, 0x0C, 0x18, 0x9F, 0xA8, 0xBA, + 0x01, 0x22, 0x02, 0x08, 0x0C, 0x3A, 0x01, 0x00, 0x22, 0x0B, 0x18, 0xEB, + 0xFA, 0x08, 0x22, 0x02, 0x08, 0x0D, 0x3A, 0x01, 0x00, 0x22, 0x0B, 0x18, + 0xD3, 0xFE, 0x08, 0x22, 0x02, 0x08, 0x0E, 0x3A, 0x01, 0x00, 0x22, 0x0B, + 0x18, 0xB7, 0xFF, 0x08, 0x22, 0x02, 0x08, 0x0F, 0x3A, 0x01, 0x00, 0x22, + 0x0C, 0x18, 0xA7, 0xBD, 0xCF, 0x0A, 0x22, 0x02, 0x08, 0x10, 0x3A, 0x01, + 0x00, 0x22, 0x0C, 0x18, 0xCF, 0xCA, 0xCF, 0x0A, 0x22, 0x02, 0x08, 0x11, + 0x3A, 0x01, 0x00, 0x22, 0x0A, 0x18, 0xC7, 0x3C, 0x22, 0x02, 0x08, 0x12, + 0x3A, 0x01, 0x00, 0x22, 0x0A, 0x10, 0x01, 0x18, 0x9F, 0xA6, 0x81, 0x02, + 0x3A, 0x01, 0x03, 0x22, 0x0C, 0x18, 0x9F, 0xCD, 0xA9, 0x02, 0x22, 0x02, + 0x08, 0x13, 0x3A, 0x01, 0x00, 0x22, 0x0C, 0x18, 0xC3, 0xDF, 0xAC, 0x02, + 0x22, 0x02, 0x08, 0x14, 0x3A, 0x01, 0x00, 0x22, 0x0C, 0x18, 0xB3, 0x9F, + 0xAD, 0x02, 0x22, 0x02, 0x08, 0x15, 0x3A, 0x01, 0x00, 0x22, 0x0C, 0x18, + 0x9B, 0xE1, 0xA0, 0x02, 0x22, 0x02, 0x08, 0x16, 0x3A, 0x01, 0x00, 0x22, + 0x0C, 0x18, 0xCB, 0xE8, 0x86, 0x09, 0x22, 0x02, 0x08, 0x17, 0x3A, 0x01, + 0x00, 0x22, 0x0C, 0x18, 0xEB, 0xE3, 0x87, 0x09, 0x22, 0x02, 0x08, 0x18, + 0x3A, 0x01, 0x00, 0x22, 0x0C, 0x18, 0xFB, 0xAE, 0xFE, 0x09, 0x22, 0x02, + 0x08, 0x19, 0x3A, 0x01, 0x00, 0x22, 0x0C, 0x18, 0xE7, 0xB0, 0xFE, 0x09, + 0x22, 0x02, 0x08, 0x1A, 0x3A, 0x01, 0x00, 0x22, 0x0C, 0x18, 0xEF, 0x90, + 0x85, 0x09, 0x22, 0x02, 0x08, 0x1B, 0x3A, 0x01, 0x00, 0x22, 0x0C, 0x18, + 0xF7, 0xF3, 0x85, 0x09, 0x22, 0x02, 0x08, 0x1C, 0x3A, 0x01, 0x00, 0x22, + 0x0C, 0x18, 0xCB, 0xF5, 0x85, 0x09, 0x22, 0x02, 0x08, 0x1D, 0x3A, 0x01, + 0x00, 0x22, 0x0B, 0x18, 0xEB, 0xFA, 0x08, 0x22, 0x02, 0x08, 0x0D, 0x3A, + 0x01, 0x00, 0x22, 0x0B, 0x18, 0xD3, 0xFE, 0x08, 0x22, 0x02, 0x08, 0x0E, + 0x3A, 0x01, 0x00, 0x22, 0x0B, 0x18, 0xB7, 0xFF, 0x08, 0x22, 0x02, 0x08, + 0x0F, 0x3A, 0x01, 0x00, 0x22, 0x0C, 0x18, 0xA7, 0xBD, 0xCF, 0x0A, 0x22, + 0x02, 0x08, 0x10, 0x3A, 0x01, 0x00, 0x22, 0x0C, 0x18, 0xCF, 0xCA, 0xCF, + 0x0A, 0x22, 0x02, 0x08, 0x11, 0x3A, 0x01, 0x00, 0x22, 0x0A, 0x18, 0xC7, + 0x3C, 0x22, 0x02, 0x08, 0x12, 0x3A, 0x01, 0x00, 0x22, 0x09, 0x10, 0x02, + 0x18, 0xAF, 0xBF, 0x05, 0x3A, 0x01, 0x03, 0x2A, 0x00, 0x2A, 0x02, 0x10, + 0x18, 0x2A, 0x02, 0x10, 0x10, 0x2A, 0x02, 0x10, 0x24, 0x2A, 0x02, 0x10, + 0x19, 0x2A, 0x02, 0x10, 0x21, 0x2A, 0x02, 0x10, 0x1A, 0x2A, 0x02, 0x10, + 0x25, 0x2A, 0x02, 0x10, 0x0B, 0x2A, 0x02, 0x10, 0x26, 0x2A, 0x02, 0x10, + 0x11, 0x2A, 0x02, 0x10, 0x14, 0x2A, 0x02, 0x10, 0x15, 0x2A, 0x02, 0x10, + 0x12, 0x2A, 0x02, 0x10, 0x22, 0x2A, 0x02, 0x10, 0x16, 0x2A, 0x02, 0x10, + 0x0E, 0x2A, 0x02, 0x10, 0x1B, 0x2A, 0x02, 0x10, 0x1E, 0x2A, 0x02, 0x10, + 0x17, 0x2A, 0x02, 0x10, 0x27, 0x2A, 0x02, 0x10, 0x0C, 0x2A, 0x02, 0x10, + 0x13, 0x2A, 0x02, 0x10, 0x1F, 0x2A, 0x02, 0x10, 0x23, 0x2A, 0x02, 0x10, + 0x0F, 0x2A, 0x02, 0x10, 0x1C, 0x2A, 0x02, 0x10, 0x0D, 0x2A, 0x02, 0x10, + 0x20, 0x2A, 0x02, 0x10, 0x1D, 0x32, 0x00, 0x32, 0x07, 0x73, 0x61, 0x6D, + 0x70, 0x6C, 0x65, 0x73, 0x32, 0x05, 0x63, 0x6F, 0x75, 0x6E, 0x74, 0x32, + 0x03, 0x63, 0x70, 0x75, 0x32, 0x0B, 0x6E, 0x61, 0x6E, 0x6F, 0x73, 0x65, + 0x63, 0x6F, 0x6E, 0x64, 0x73, 0x32, 0x16, 0x41, 0x54, 0x73, 0x51, 0x46, + 0x31, 0x72, 0x72, 0x49, 0x63, 0x30, 0x35, 0x74, 0x65, 0x6A, 0x66, 0x79, + 0x65, 0x73, 0x5A, 0x52, 0x77, 0x32, 0x20, 0x62, 0x61, 0x31, 0x63, 0x39, + 0x61, 0x35, 0x61, 0x38, 0x32, 0x35, 0x36, 0x61, 0x36, 0x65, 0x66, 0x33, + 0x65, 0x36, 0x36, 0x33, 0x63, 0x63, 0x37, 0x33, 0x31, 0x36, 0x38, 0x30, + 0x33, 0x64, 0x39, 0x32, 0x16, 0x7A, 0x6A, 0x32, 0x51, 0x75, 0x43, 0x52, + 0x61, 0x70, 0x75, 0x6E, 0x30, 0x32, 0x73, 0x79, 0x68, 0x6C, 0x41, 0x48, + 0x71, 0x54, 0x77, 0x32, 0x0D, 0x65, 0x62, 0x70, 0x66, 0x2D, 0x70, 0x72, + 0x6F, 0x66, 0x69, 0x6C, 0x65, 0x72, 0x32, 0x16, 0x36, 0x34, 0x41, 0x49, + 0x75, 0x76, 0x39, 0x69, 0x70, 0x47, 0x42, 0x41, 0x41, 0x64, 0x30, 0x52, + 0x5A, 0x6D, 0x76, 0x4C, 0x4C, 0x77, 0x32, 0x0A, 0x63, 0x6F, 0x6E, 0x74, + 0x61, 0x69, 0x6E, 0x65, 0x72, 0x64, 0x32, 0x13, 0x5F, 0x5F, 0x63, 0x68, + 0x65, 0x63, 0x6B, 0x5F, 0x6F, 0x62, 0x6A, 0x65, 0x63, 0x74, 0x5F, 0x73, + 0x69, 0x7A, 0x65, 0x32, 0x11, 0x6F, 0x62, 0x6A, 0x5F, 0x63, 0x67, 0x72, + 0x6F, 0x75, 0x70, 0x5F, 0x63, 0x68, 0x61, 0x72, 0x67, 0x65, 0x32, 0x0D, + 0x5F, 0x5F, 0x73, 0x6F, 0x63, 0x6B, 0x5F, 0x63, 0x72, 0x65, 0x61, 0x74, + 0x65, 0x32, 0x07, 0x65, 0x6C, 0x30, 0x5F, 0x73, 0x76, 0x63, 0x32, 0x0C, + 0x75, 0x6E, 0x69, 0x78, 0x5F, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x31, + 0x32, 0x08, 0x73, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6C, 0x65, 0x32, 0x10, + 0x62, 0x70, 0x66, 0x5F, 0x6D, 0x61, 0x70, 0x5F, 0x64, 0x6F, 0x5F, 0x62, + 0x61, 0x74, 0x63, 0x68, 0x32, 0x0E, 0x69, 0x6E, 0x76, 0x6F, 0x6B, 0x65, + 0x5F, 0x73, 0x79, 0x73, 0x63, 0x61, 0x6C, 0x6C, 0x32, 0x10, 0x6B, 0x6D, + 0x65, 0x6D, 0x5F, 0x63, 0x61, 0x63, 0x68, 0x65, 0x5F, 0x61, 0x6C, 0x6C, + 0x6F, 0x63, 0x32, 0x09, 0x5F, 0x5F, 0x73, 0x79, 0x73, 0x5F, 0x62, 0x70, + 0x66, 0x32, 0x0F, 0x5F, 0x5F, 0x61, 0x72, 0x6D, 0x36, 0x34, 0x5F, 0x73, + 0x79, 0x73, 0x5F, 0x62, 0x70, 0x66, 0x32, 0x0A, 0x64, 0x6F, 0x5F, 0x65, + 0x6C, 0x30, 0x5F, 0x73, 0x76, 0x63, 0x32, 0x19, 0x70, 0x72, 0x6F, 0x70, + 0x61, 0x67, 0x61, 0x74, 0x65, 0x5F, 0x70, 0x72, 0x6F, 0x74, 0x65, 0x63, + 0x74, 0x65, 0x64, 0x5F, 0x75, 0x73, 0x61, 0x67, 0x65, 0x32, 0x19, 0x66, + 0x69, 0x6E, 0x69, 0x73, 0x68, 0x5F, 0x74, 0x61, 0x73, 0x6B, 0x5F, 0x73, + 0x77, 0x69, 0x74, 0x63, 0x68, 0x2E, 0x69, 0x73, 0x72, 0x61, 0x2E, 0x30, + 0x32, 0x07, 0x6B, 0x74, 0x68, 0x72, 0x65, 0x61, 0x64, 0x32, 0x13, 0x5F, + 0x5F, 0x63, 0x68, 0x65, 0x63, 0x6B, 0x5F, 0x68, 0x65, 0x61, 0x70, 0x5F, + 0x6F, 0x62, 0x6A, 0x65, 0x63, 0x74, 0x32, 0x14, 0x65, 0x6C, 0x30, 0x74, + 0x5F, 0x36, 0x34, 0x5F, 0x73, 0x79, 0x6E, 0x63, 0x5F, 0x68, 0x61, 0x6E, + 0x64, 0x6C, 0x65, 0x72, 0x32, 0x0B, 0x75, 0x6E, 0x69, 0x78, 0x5F, 0x63, + 0x72, 0x65, 0x61, 0x74, 0x65, 0x32, 0x12, 0x5F, 0x5F, 0x61, 0x72, 0x6D, + 0x36, 0x34, 0x5F, 0x73, 0x79, 0x73, 0x5F, 0x73, 0x6F, 0x63, 0x6B, 0x65, + 0x74, 0x32, 0x0C, 0x65, 0x6C, 0x30, 0x74, 0x5F, 0x36, 0x34, 0x5F, 0x73, + 0x79, 0x6E, 0x63, 0x32, 0x0D, 0x73, 0x6B, 0x5F, 0x70, 0x72, 0x6F, 0x74, + 0x5F, 0x61, 0x6C, 0x6C, 0x6F, 0x63, 0x32, 0x0C, 0x5F, 0x5F, 0x73, 0x79, + 0x73, 0x5F, 0x73, 0x6F, 0x63, 0x6B, 0x65, 0x74, 0x32, 0x0D, 0x72, 0x65, + 0x74, 0x5F, 0x66, 0x72, 0x6F, 0x6D, 0x5F, 0x66, 0x6F, 0x72, 0x6B, 0x32, + 0x1A, 0x65, 0x6C, 0x30, 0x5F, 0x73, 0x76, 0x63, 0x5F, 0x63, 0x6F, 0x6D, + 0x6D, 0x6F, 0x6E, 0x2E, 0x63, 0x6F, 0x6E, 0x73, 0x74, 0x70, 0x72, 0x6F, + 0x70, 0x2E, 0x30, 0x32, 0x08, 0x73, 0x6B, 0x5F, 0x61, 0x6C, 0x6C, 0x6F, + 0x63, 0x32, 0x0D, 0x77, 0x6F, 0x72, 0x6B, 0x65, 0x72, 0x5F, 0x74, 0x68, + 0x72, 0x65, 0x61, 0x64, 0x32, 0x1A, 0x5F, 0x5F, 0x63, 0x68, 0x65, 0x63, + 0x6B, 0x5F, 0x6F, 0x62, 0x6A, 0x65, 0x63, 0x74, 0x5F, 0x73, 0x69, 0x7A, + 0x65, 0x2E, 0x70, 0x61, 0x72, 0x74, 0x2E, 0x30, 0x32, 0x18, 0x67, 0x65, + 0x6E, 0x65, 0x72, 0x69, 0x63, 0x5F, 0x6D, 0x61, 0x70, 0x5F, 0x75, 0x70, + 0x64, 0x61, 0x74, 0x65, 0x5F, 0x62, 0x61, 0x74, 0x63, 0x68, 0x32, 0x10, + 0x74, 0x72, 0x79, 0x5F, 0x63, 0x68, 0x61, 0x72, 0x67, 0x65, 0x5F, 0x6D, + 0x65, 0x6D, 0x63, 0x67, 0x48, 0xE9, 0xF2, 0xB0, 0xE5, 0xB2, 0xEA, 0xB1, + 0x82, 0x18, 0x5A, 0x04, 0x08, 0x03, 0x10, 0x04, 0x60, 0x80, 0xE1, 0xEB, + 0x17, 0x7A, 0x25, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, + 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, + 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, + 0x21, 0x22, 0x23, 0x24, 0x82, 0x01, 0x1E, 0x0A, 0x12, 0x70, 0x72, 0x6F, + 0x66, 0x69, 0x6C, 0x65, 0x2E, 0x66, 0x72, 0x61, 0x6D, 0x65, 0x2E, 0x74, + 0x79, 0x70, 0x65, 0x12, 0x08, 0x0A, 0x06, 0x6B, 0x65, 0x72, 0x6E, 0x65, + 0x6C, 0x82, 0x01, 0x13, 0x0A, 0x0C, 0x63, 0x6F, 0x6E, 0x74, 0x61, 0x69, + 0x6E, 0x65, 0x72, 0x2E, 0x69, 0x64, 0x12, 0x03, 0x0A, 0x01, 0x2F, 0x82, + 0x01, 0x1C, 0x0A, 0x0B, 0x74, 0x68, 0x72, 0x65, 0x61, 0x64, 0x2E, 0x6E, + 0x61, 0x6D, 0x65, 0x12, 0x0D, 0x0A, 0x0B, 0x6B, 0x77, 0x6F, 0x72, 0x6B, + 0x65, 0x72, 0x2F, 0x36, 0x3A, 0x31, 0x82, 0x01, 0x1E, 0x0A, 0x12, 0x70, + 0x72, 0x6F, 0x66, 0x69, 0x6C, 0x65, 0x2E, 0x66, 0x72, 0x61, 0x6D, 0x65, + 0x2E, 0x74, 0x79, 0x70, 0x65, 0x12, 0x08, 0x0A, 0x06, 0x6E, 0x61, 0x74, + 0x69, 0x76, 0x65, 0x82, 0x01, 0x4D, 0x0A, 0x1F, 0x70, 0x72, 0x6F, 0x63, + 0x65, 0x73, 0x73, 0x2E, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x61, 0x62, + 0x6C, 0x65, 0x2E, 0x62, 0x75, 0x69, 0x6C, 0x64, 0x5F, 0x69, 0x64, 0x2E, + 0x67, 0x6E, 0x75, 0x12, 0x2A, 0x0A, 0x28, 0x33, 0x34, 0x31, 0x39, 0x61, + 0x33, 0x65, 0x66, 0x30, 0x30, 0x31, 0x35, 0x34, 0x35, 0x64, 0x38, 0x65, + 0x65, 0x39, 0x66, 0x63, 0x64, 0x34, 0x62, 0x31, 0x38, 0x64, 0x34, 0x63, + 0x65, 0x31, 0x37, 0x32, 0x30, 0x35, 0x37, 0x65, 0x33, 0x33, 0x39, 0x82, + 0x01, 0x4B, 0x0A, 0x25, 0x70, 0x72, 0x6F, 0x63, 0x65, 0x73, 0x73, 0x2E, + 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2E, 0x62, + 0x75, 0x69, 0x6C, 0x64, 0x5F, 0x69, 0x64, 0x2E, 0x70, 0x72, 0x6F, 0x66, + 0x69, 0x6C, 0x69, 0x6E, 0x67, 0x12, 0x22, 0x0A, 0x20, 0x37, 0x30, 0x35, + 0x62, 0x64, 0x66, 0x31, 0x34, 0x39, 0x38, 0x30, 0x66, 0x32, 0x63, 0x32, + 0x32, 0x64, 0x63, 0x34, 0x64, 0x65, 0x32, 0x65, 0x36, 0x35, 0x37, 0x36, + 0x65, 0x64, 0x66, 0x66, 0x38, 0x82, 0x01, 0x3C, 0x0A, 0x0C, 0x63, 0x6F, + 0x6E, 0x74, 0x61, 0x69, 0x6E, 0x65, 0x72, 0x2E, 0x69, 0x64, 0x12, 0x2C, + 0x0A, 0x2A, 0x2F, 0x75, 0x73, 0x65, 0x72, 0x2E, 0x73, 0x6C, 0x69, 0x63, + 0x65, 0x2F, 0x75, 0x73, 0x65, 0x72, 0x2D, 0x35, 0x30, 0x31, 0x2E, 0x73, + 0x6C, 0x69, 0x63, 0x65, 0x2F, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6F, 0x6E, + 0x2D, 0x32, 0x2E, 0x73, 0x63, 0x6F, 0x70, 0x65, 0x82, 0x01, 0x1E, 0x0A, + 0x0B, 0x74, 0x68, 0x72, 0x65, 0x61, 0x64, 0x2E, 0x6E, 0x61, 0x6D, 0x65, + 0x12, 0x0F, 0x0A, 0x0D, 0x65, 0x62, 0x70, 0x66, 0x2D, 0x70, 0x72, 0x6F, + 0x66, 0x69, 0x6C, 0x65, 0x72, 0x82, 0x01, 0x4B, 0x0A, 0x25, 0x70, 0x72, + 0x6F, 0x63, 0x65, 0x73, 0x73, 0x2E, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, + 0x61, 0x62, 0x6C, 0x65, 0x2E, 0x62, 0x75, 0x69, 0x6C, 0x64, 0x5F, 0x69, + 0x64, 0x2E, 0x70, 0x72, 0x6F, 0x66, 0x69, 0x6C, 0x69, 0x6E, 0x67, 0x12, + 0x22, 0x0A, 0x20, 0x64, 0x37, 0x38, 0x30, 0x31, 0x36, 0x30, 0x34, 0x65, + 0x38, 0x62, 0x38, 0x39, 0x64, 0x64, 0x61, 0x63, 0x66, 0x65, 0x31, 0x39, + 0x38, 0x39, 0x39, 0x64, 0x36, 0x62, 0x61, 0x33, 0x35, 0x36, 0x34, 0x82, + 0x01, 0x5A, 0x0A, 0x0C, 0x63, 0x6F, 0x6E, 0x74, 0x61, 0x69, 0x6E, 0x65, + 0x72, 0x2E, 0x69, 0x64, 0x12, 0x4A, 0x0A, 0x48, 0x2F, 0x75, 0x73, 0x65, + 0x72, 0x2E, 0x73, 0x6C, 0x69, 0x63, 0x65, 0x2F, 0x75, 0x73, 0x65, 0x72, + 0x2D, 0x35, 0x30, 0x31, 0x2E, 0x73, 0x6C, 0x69, 0x63, 0x65, 0x2F, 0x75, + 0x73, 0x65, 0x72, 0x40, 0x35, 0x30, 0x31, 0x2E, 0x73, 0x65, 0x72, 0x76, + 0x69, 0x63, 0x65, 0x2F, 0x61, 0x70, 0x70, 0x2E, 0x73, 0x6C, 0x69, 0x63, + 0x65, 0x2F, 0x63, 0x6F, 0x6E, 0x74, 0x61, 0x69, 0x6E, 0x65, 0x72, 0x64, + 0x2E, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x82, 0x01, 0x1B, 0x0A, + 0x0B, 0x74, 0x68, 0x72, 0x65, 0x61, 0x64, 0x2E, 0x6E, 0x61, 0x6D, 0x65, + 0x12, 0x0C, 0x0A, 0x0A, 0x63, 0x6F, 0x6E, 0x74, 0x61, 0x69, 0x6E, 0x65, + 0x72, 0x64 +}; + +static void test_encoder() { - int i; - int sample_index = 0; - uint64_t location_idx; - char *tmp; - struct cfl_list *head; - struct cfl_list *type_head; - struct cprof_sample *sample; - struct cprof_value_type *sample_type; - - printf("\n"); - printf("--- profile debug\n"); - printf("Profile Duration: %" PRId64 " nanoseconds\n\n", profile->duration_nanos); - printf("Samples:\n"); - - cfl_list_foreach(head, &profile->samples) { - sample = cfl_list_entry(head, struct cprof_sample, _head); - - printf(" Sample #%d:\n", ++sample_index); - - printf(" Locations:\n"); - for (i = 0; i < sample->location_index_count; ++i) { - location_idx = sample->location_index[i]; - tmp = profile->string_table[location_idx]; - if (tmp[0] == '\0') { - printf(" [Empty String: No Function Name]\n"); - } else { - printf(" Function: %s\n", tmp); - } - } + cfl_sds_t otlp_encoder_result; + struct cprof *context; + int result; + size_t offset; - printf(" Values:\n"); - size_t value_index = 0; - cfl_list_foreach(type_head, &profile->sample_type) { - sample_type = cfl_list_entry(type_head, struct cprof_value_type, _head); - if (value_index < sample->value_count) { - printf(" %s: %" PRId64 " %s\n", - profile->string_table[sample_type->type], - sample->values[value_index], - profile->string_table[sample_type->unit]); - } - value_index++; - } + offset = 0; + context = NULL; + + result = cprof_decode_opentelemetry_create(&context, + serialized_data, + sizeof(serialized_data), + &offset); + + TEST_CHECK(result == CPROF_DECODE_OPENTELEMETRY_SUCCESS); + + if (result == CPROF_DECODE_OPENTELEMETRY_SUCCESS) { + result = cprof_encode_opentelemetry_create(&otlp_encoder_result, context); - if (sample->timestamps_count > 0) { - printf(" Timestamps:\n"); - for (size_t i = 0; i < sample->timestamps_count; ++i) { - printf(" Timestamp %zu: %" PRIu64 " ns\n", i, sample->timestamps_unix_nano[i]); - } - } else { - printf(" [No Timestamps]\n"); + TEST_CHECK(result == CPROF_ENCODE_OPENTELEMETRY_SUCCESS); + + if (result == CPROF_ENCODE_OPENTELEMETRY_SUCCESS) { + cprof_encode_opentelemetry_destroy(otlp_encoder_result); } - printf("\n"); // Add space between samples for readability - } - printf("String Table:\n"); - for (i = 0; i < profile->string_table_count; i++) { - printf(" %d: '%s'\n", i, profile->string_table[i]); + cprof_decode_opentelemetry_destroy(context); } - printf("\n"); } -/* a basic test */ static void test_decoder() { - cfl_sds_t text_result; struct cprof *context; int result; size_t offset; @@ -176,33 +331,20 @@ static void test_decoder() offset = 0; context = NULL; - printf("TEST CASE\n"); - result = cprof_decode_opentelemetry_create(&context, - encoded_packet, - sizeof(encoded_packet), - &offset); - - if (result == CPROF_DECODE_OPENTELEMETRY_SUCCESS) { - result = cprof_encode_text_create(&text_result, context); - - if (result != CPROF_ENCODE_TEXT_SUCCESS) { - printf("TEXT ENCODING FAILED WITH ERROR : %d\n", result); - } - else { - printf("\n\n\n%s\n\n\n", text_result); - /* cprof_encode_text_destroy(text_result); */ - } - + serialized_data, + sizeof(serialized_data), + &offset); + TEST_CHECK(result == CPROF_DECODE_OPENTELEMETRY_SUCCESS); + if (result == CPROF_DECODE_OPENTELEMETRY_SUCCESS) { cprof_decode_opentelemetry_destroy(context); } } TEST_LIST = { + {"encoder", test_encoder}, {"decoder", test_decoder}, { 0 } }; - - diff --git a/lib/cprofiles/tests/profile.c b/lib/cprofiles/tests/profile.c index a983bf8b0c3..fcc22c460f5 100644 --- a/lib/cprofiles/tests/profile.c +++ b/lib/cprofiles/tests/profile.c @@ -35,7 +35,6 @@ void print_profile(struct cprof_profile *profile) struct cfl_list *type_head; struct cprof_sample *sample; struct cprof_value_type *sample_type; - size_t value_index = 0; printf("\n"); printf("--- profile debug\n"); @@ -59,6 +58,7 @@ void print_profile(struct cprof_profile *profile) } printf(" Values:\n"); + size_t value_index = 0; cfl_list_foreach(type_head, &profile->sample_type) { sample_type = cfl_list_entry(type_head, struct cprof_value_type, _head); if (value_index < sample->value_count) { @@ -73,7 +73,7 @@ void print_profile(struct cprof_profile *profile) if (sample->timestamps_count > 0) { printf(" Timestamps:\n"); for (i = 0; i < sample->timestamps_count; ++i) { - printf(" Timestamp %zu: %" PRIu64 " ns\n", i, sample->timestamps_unix_nano[i]); + printf(" Timestamp %d: %" PRIu64 " ns\n", i, sample->timestamps_unix_nano[i]); } } else { printf(" [No Timestamps]\n"); @@ -108,7 +108,7 @@ static void test_profile() TEST_CHECK(cprof != NULL); /* create profile */ - profile = cprof_profile_create(cprof); + profile = cprof_profile_create(); TEST_CHECK(profile != NULL); cprof_sample_type_str_create(profile, "CPU time", "ns", CPROF_AGGREGATION_TEMPORALITY_CUMULATIVE); @@ -154,6 +154,8 @@ static void test_profile() print_profile(profile); + cprof_profile_destroy(profile); + /* destroy context */ cprof_destroy(cprof); } diff --git a/lib/cprofiles/tests/text_transcoder.c b/lib/cprofiles/tests/text_transcoder.c new file mode 100644 index 00000000000..32aa074a1ce --- /dev/null +++ b/lib/cprofiles/tests/text_transcoder.c @@ -0,0 +1,660 @@ +/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ + +/* CProfiles + * ========= + * Copyright (C) 2024 The CProfiles Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include "cprof_tests.h" +#include +#include + +#include +#include +#include + +unsigned char serialized_data[] = { + 0x82, 0xA4, 0x6D, 0x65, 0x74, 0x61, 0x80, 0xA8, 0x70, 0x72, 0x6F, 0x66, + 0x69, 0x6C, 0x65, 0x73, 0x91, 0x83, 0xA8, 0x72, 0x65, 0x73, 0x6F, 0x75, + 0x72, 0x63, 0x65, 0x82, 0xAA, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, + 0x74, 0x65, 0x73, 0x85, 0xA7, 0x68, 0x6F, 0x73, 0x74, 0x2E, 0x69, 0x64, + 0xA1, 0x30, 0xA7, 0x68, 0x6F, 0x73, 0x74, 0x2E, 0x69, 0x70, 0xA9, 0x31, + 0x32, 0x37, 0x2E, 0x30, 0x2E, 0x30, 0x2E, 0x31, 0xA9, 0x68, 0x6F, 0x73, + 0x74, 0x2E, 0x6E, 0x61, 0x6D, 0x65, 0xAC, 0x6C, 0x69, 0x6D, 0x61, 0x2D, + 0x64, 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74, 0xAF, 0x73, 0x65, 0x72, 0x76, + 0x69, 0x63, 0x65, 0x2E, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6F, 0x6E, 0xA0, + 0xA9, 0x6F, 0x73, 0x2E, 0x6B, 0x65, 0x72, 0x6E, 0x65, 0x6C, 0xA5, 0x36, + 0x2E, 0x35, 0x2E, 0x30, 0xB7, 0x64, 0x72, 0x6F, 0x70, 0x70, 0x65, 0x64, + 0x5F, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x5F, 0x63, + 0x6F, 0x75, 0x6E, 0x74, 0x00, 0xAE, 0x73, 0x63, 0x6F, 0x70, 0x65, 0x5F, + 0x70, 0x72, 0x6F, 0x66, 0x69, 0x6C, 0x65, 0x73, 0x91, 0x83, 0xB5, 0x69, + 0x6E, 0x73, 0x74, 0x72, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x61, 0x74, 0x69, + 0x6F, 0x6E, 0x5F, 0x73, 0x63, 0x6F, 0x70, 0x65, 0x84, 0xA4, 0x6E, 0x61, + 0x6D, 0x65, 0xA0, 0xA7, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6F, 0x6E, 0xA0, + 0xAA, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x80, + 0xB7, 0x64, 0x72, 0x6F, 0x70, 0x70, 0x65, 0x64, 0x5F, 0x61, 0x74, 0x74, + 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x5F, 0x63, 0x6F, 0x75, 0x6E, 0x74, + 0x00, 0xA8, 0x70, 0x72, 0x6F, 0x66, 0x69, 0x6C, 0x65, 0x73, 0x91, 0xDE, + 0x00, 0x17, 0xAA, 0x70, 0x72, 0x6F, 0x66, 0x69, 0x6C, 0x65, 0x5F, 0x69, + 0x64, 0xC4, 0x10, 0xA4, 0x58, 0x33, 0xE6, 0x18, 0xE6, 0x34, 0x8D, 0xD6, + 0xFE, 0x00, 0x58, 0x56, 0xF5, 0xA7, 0x54, 0xB4, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x5F, 0x74, 0x69, 0x6D, 0x65, 0x5F, 0x75, 0x6E, 0x69, 0x78, 0x5F, + 0x6E, 0x61, 0x6E, 0x6F, 0xCF, 0x18, 0x04, 0xC7, 0x53, 0x2C, 0xAC, 0x39, + 0x69, 0xB2, 0x65, 0x6E, 0x64, 0x5F, 0x74, 0x69, 0x6D, 0x65, 0x5F, 0x75, + 0x6E, 0x69, 0x78, 0x5F, 0x6E, 0x61, 0x6E, 0x6F, 0xCF, 0x18, 0x04, 0xC7, + 0x53, 0x2C, 0xAC, 0x39, 0x69, 0xAA, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, + 0x75, 0x74, 0x65, 0x73, 0x80, 0xB2, 0x64, 0x72, 0x6F, 0x70, 0x70, 0x65, + 0x64, 0x5F, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, + 0x00, 0xAC, 0x73, 0x61, 0x6D, 0x70, 0x6C, 0x65, 0x5F, 0x74, 0x79, 0x70, + 0x65, 0x73, 0x91, 0x83, 0xA4, 0x74, 0x79, 0x70, 0x65, 0x01, 0xA4, 0x75, + 0x6E, 0x69, 0x74, 0x02, 0xB7, 0x61, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, + 0x74, 0x69, 0x6F, 0x6E, 0x5F, 0x74, 0x65, 0x6D, 0x70, 0x6F, 0x72, 0x61, + 0x6C, 0x69, 0x74, 0x79, 0x00, 0xA6, 0x73, 0x61, 0x6D, 0x70, 0x6C, 0x65, + 0x93, 0x87, 0xAE, 0x6C, 0x6F, 0x63, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x5F, + 0x69, 0x6E, 0x64, 0x65, 0x78, 0x90, 0xB5, 0x6C, 0x6F, 0x63, 0x61, 0x74, + 0x69, 0x6F, 0x6E, 0x73, 0x5F, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5F, 0x69, + 0x6E, 0x64, 0x65, 0x78, 0x00, 0xB0, 0x6C, 0x6F, 0x63, 0x61, 0x74, 0x69, + 0x6F, 0x6E, 0x73, 0x5F, 0x6C, 0x65, 0x6E, 0x67, 0x74, 0x68, 0x05, 0xA6, + 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x91, 0x01, 0xAA, 0x61, 0x74, 0x74, + 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x92, 0x01, 0x02, 0xA4, 0x6C, + 0x69, 0x6E, 0x6B, 0x00, 0xB4, 0x74, 0x69, 0x6D, 0x65, 0x73, 0x74, 0x61, + 0x6D, 0x70, 0x73, 0x5F, 0x75, 0x6E, 0x69, 0x78, 0x5F, 0x6E, 0x61, 0x6E, + 0x6F, 0x91, 0xCF, 0x18, 0x04, 0xC7, 0x52, 0xCA, 0x52, 0xB5, 0x76, 0x87, + 0xAE, 0x6C, 0x6F, 0x63, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x5F, 0x69, 0x6E, + 0x64, 0x65, 0x78, 0x90, 0xB5, 0x6C, 0x6F, 0x63, 0x61, 0x74, 0x69, 0x6F, + 0x6E, 0x73, 0x5F, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5F, 0x69, 0x6E, 0x64, + 0x65, 0x78, 0x05, 0xB0, 0x6C, 0x6F, 0x63, 0x61, 0x74, 0x69, 0x6F, 0x6E, + 0x73, 0x5F, 0x6C, 0x65, 0x6E, 0x67, 0x74, 0x68, 0x0E, 0xA6, 0x76, 0x61, + 0x6C, 0x75, 0x65, 0x73, 0x91, 0x01, 0xAA, 0x61, 0x74, 0x74, 0x72, 0x69, + 0x62, 0x75, 0x74, 0x65, 0x73, 0x92, 0x06, 0x07, 0xA4, 0x6C, 0x69, 0x6E, + 0x6B, 0x00, 0xB4, 0x74, 0x69, 0x6D, 0x65, 0x73, 0x74, 0x61, 0x6D, 0x70, + 0x73, 0x5F, 0x75, 0x6E, 0x69, 0x78, 0x5F, 0x6E, 0x61, 0x6E, 0x6F, 0x91, + 0xCF, 0x18, 0x04, 0xC7, 0x53, 0x11, 0xD8, 0xE9, 0xA8, 0x87, 0xAE, 0x6C, + 0x6F, 0x63, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x5F, 0x69, 0x6E, 0x64, 0x65, + 0x78, 0x90, 0xB5, 0x6C, 0x6F, 0x63, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x73, + 0x5F, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, + 0x13, 0xB0, 0x6C, 0x6F, 0x63, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x73, 0x5F, + 0x6C, 0x65, 0x6E, 0x67, 0x74, 0x68, 0x12, 0xA6, 0x76, 0x61, 0x6C, 0x75, + 0x65, 0x73, 0x91, 0x01, 0xAA, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, + 0x74, 0x65, 0x73, 0x92, 0x09, 0x0A, 0xA4, 0x6C, 0x69, 0x6E, 0x6B, 0x00, + 0xB4, 0x74, 0x69, 0x6D, 0x65, 0x73, 0x74, 0x61, 0x6D, 0x70, 0x73, 0x5F, + 0x75, 0x6E, 0x69, 0x78, 0x5F, 0x6E, 0x61, 0x6E, 0x6F, 0x91, 0xCF, 0x18, + 0x04, 0xC7, 0x53, 0x2C, 0xAC, 0x39, 0x69, 0xA8, 0x6D, 0x61, 0x70, 0x70, + 0x69, 0x6E, 0x67, 0x73, 0x93, 0x8A, 0xA2, 0x69, 0x64, 0x00, 0xAC, 0x6D, + 0x65, 0x6D, 0x6F, 0x72, 0x79, 0x5F, 0x73, 0x74, 0x61, 0x72, 0x74, 0x00, + 0xAC, 0x6D, 0x65, 0x6D, 0x6F, 0x72, 0x79, 0x5F, 0x6C, 0x69, 0x6D, 0x69, + 0x74, 0x00, 0xAB, 0x66, 0x69, 0x6C, 0x65, 0x5F, 0x6F, 0x66, 0x66, 0x73, + 0x65, 0x74, 0x00, 0xA8, 0x66, 0x69, 0x6C, 0x65, 0x6E, 0x61, 0x6D, 0x65, + 0x00, 0xAA, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, + 0x90, 0xAD, 0x68, 0x61, 0x73, 0x5F, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, + 0x6F, 0x6E, 0x73, 0x00, 0xAD, 0x68, 0x61, 0x73, 0x5F, 0x66, 0x69, 0x6C, + 0x65, 0x6E, 0x61, 0x6D, 0x65, 0x73, 0x00, 0xB0, 0x68, 0x61, 0x73, 0x5F, + 0x6C, 0x69, 0x6E, 0x65, 0x5F, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x73, + 0x00, 0xB1, 0x68, 0x61, 0x73, 0x5F, 0x69, 0x6E, 0x6C, 0x69, 0x6E, 0x65, + 0x5F, 0x66, 0x72, 0x61, 0x6D, 0x65, 0x73, 0x00, 0x8A, 0xA2, 0x69, 0x64, + 0x00, 0xAC, 0x6D, 0x65, 0x6D, 0x6F, 0x72, 0x79, 0x5F, 0x73, 0x74, 0x61, + 0x72, 0x74, 0xCE, 0x00, 0x40, 0x00, 0x00, 0xAC, 0x6D, 0x65, 0x6D, 0x6F, + 0x72, 0x79, 0x5F, 0x6C, 0x69, 0x6D, 0x69, 0x74, 0xCE, 0x01, 0x1D, 0x00, + 0x00, 0xAB, 0x66, 0x69, 0x6C, 0x65, 0x5F, 0x6F, 0x66, 0x66, 0x73, 0x65, + 0x74, 0x00, 0xA8, 0x66, 0x69, 0x6C, 0x65, 0x6E, 0x61, 0x6D, 0x65, 0x08, + 0xAA, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x92, + 0x04, 0x05, 0xAD, 0x68, 0x61, 0x73, 0x5F, 0x66, 0x75, 0x6E, 0x63, 0x74, + 0x69, 0x6F, 0x6E, 0x73, 0x00, 0xAD, 0x68, 0x61, 0x73, 0x5F, 0x66, 0x69, + 0x6C, 0x65, 0x6E, 0x61, 0x6D, 0x65, 0x73, 0x00, 0xB0, 0x68, 0x61, 0x73, + 0x5F, 0x6C, 0x69, 0x6E, 0x65, 0x5F, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, + 0x73, 0x00, 0xB1, 0x68, 0x61, 0x73, 0x5F, 0x69, 0x6E, 0x6C, 0x69, 0x6E, + 0x65, 0x5F, 0x66, 0x72, 0x61, 0x6D, 0x65, 0x73, 0x00, 0x8A, 0xA2, 0x69, + 0x64, 0x00, 0xAC, 0x6D, 0x65, 0x6D, 0x6F, 0x72, 0x79, 0x5F, 0x73, 0x74, + 0x61, 0x72, 0x74, 0xCE, 0x00, 0x01, 0x00, 0x00, 0xAC, 0x6D, 0x65, 0x6D, + 0x6F, 0x72, 0x79, 0x5F, 0x6C, 0x69, 0x6D, 0x69, 0x74, 0xCE, 0x00, 0xFE, + 0xE0, 0x00, 0xAB, 0x66, 0x69, 0x6C, 0x65, 0x5F, 0x6F, 0x66, 0x66, 0x73, + 0x65, 0x74, 0x00, 0xA8, 0x66, 0x69, 0x6C, 0x65, 0x6E, 0x61, 0x6D, 0x65, + 0x0A, 0xAA, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, + 0x91, 0x08, 0xAD, 0x68, 0x61, 0x73, 0x5F, 0x66, 0x75, 0x6E, 0x63, 0x74, + 0x69, 0x6F, 0x6E, 0x73, 0x00, 0xAD, 0x68, 0x61, 0x73, 0x5F, 0x66, 0x69, + 0x6C, 0x65, 0x6E, 0x61, 0x6D, 0x65, 0x73, 0x00, 0xB0, 0x68, 0x61, 0x73, + 0x5F, 0x6C, 0x69, 0x6E, 0x65, 0x5F, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, + 0x73, 0x00, 0xB1, 0x68, 0x61, 0x73, 0x5F, 0x69, 0x6E, 0x6C, 0x69, 0x6E, + 0x65, 0x5F, 0x66, 0x72, 0x61, 0x6D, 0x65, 0x73, 0x00, 0xA9, 0x6C, 0x6F, + 0x63, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x73, 0xDC, 0x00, 0x25, 0x85, 0xA2, + 0x69, 0x64, 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, 0x5F, + 0x69, 0x6E, 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, 0x65, + 0x73, 0x73, 0xCE, 0x00, 0x10, 0xE0, 0xDB, 0xA5, 0x6C, 0x69, 0x6E, 0x65, + 0x73, 0x91, 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, + 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x01, 0xA4, 0x6C, 0x69, 0x6E, 0x65, + 0x00, 0xA6, 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, 0x74, + 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, 0xA2, + 0x69, 0x64, 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, 0x5F, + 0x69, 0x6E, 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, 0x65, + 0x73, 0x73, 0xCE, 0x01, 0x54, 0x85, 0xC7, 0xA5, 0x6C, 0x69, 0x6E, 0x65, + 0x73, 0x91, 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, + 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x02, 0xA4, 0x6C, 0x69, 0x6E, 0x65, + 0x00, 0xA6, 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, 0x74, + 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, 0xA2, + 0x69, 0x64, 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, 0x5F, + 0x69, 0x6E, 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, 0x65, + 0x73, 0x73, 0xCE, 0x00, 0x0E, 0x8A, 0x37, 0xA5, 0x6C, 0x69, 0x6E, 0x65, + 0x73, 0x91, 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, + 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x03, 0xA4, 0x6C, 0x69, 0x6E, 0x65, + 0x00, 0xA6, 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, 0x74, + 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, 0xA2, + 0x69, 0x64, 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, 0x5F, + 0x69, 0x6E, 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, 0x65, + 0x73, 0x73, 0xCE, 0x00, 0x0F, 0x4B, 0x77, 0xA5, 0x6C, 0x69, 0x6E, 0x65, + 0x73, 0x91, 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, + 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x04, 0xA4, 0x6C, 0x69, 0x6E, 0x65, + 0x00, 0xA6, 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, 0x74, + 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, 0xA2, + 0x69, 0x64, 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, 0x5F, + 0x69, 0x6E, 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, 0x65, + 0x73, 0x73, 0xCD, 0x7D, 0x07, 0xA5, 0x6C, 0x69, 0x6E, 0x65, 0x73, 0x91, + 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x5F, 0x69, + 0x6E, 0x64, 0x65, 0x78, 0x05, 0xA4, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0xA6, + 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, 0x74, 0x74, 0x72, + 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, 0xA2, 0x69, 0x64, + 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, 0x5F, 0x69, 0x6E, + 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, + 0xCE, 0x00, 0x48, 0x6B, 0x43, 0xA5, 0x6C, 0x69, 0x6E, 0x65, 0x73, 0x91, + 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x5F, 0x69, + 0x6E, 0x64, 0x65, 0x78, 0x06, 0xA4, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0xA6, + 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, 0x74, 0x74, 0x72, + 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, 0xA2, 0x69, 0x64, + 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, 0x5F, 0x69, 0x6E, + 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, + 0xCE, 0x00, 0x4C, 0xDA, 0xBB, 0xA5, 0x6C, 0x69, 0x6E, 0x65, 0x73, 0x91, + 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x5F, 0x69, + 0x6E, 0x64, 0x65, 0x78, 0x07, 0xA4, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0xA6, + 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, 0x74, 0x74, 0x72, + 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, 0xA2, 0x69, 0x64, + 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, 0x5F, 0x69, 0x6E, + 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, + 0xCE, 0x00, 0x4C, 0xDB, 0xE7, 0xA5, 0x6C, 0x69, 0x6E, 0x65, 0x73, 0x91, + 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x5F, 0x69, + 0x6E, 0x64, 0x65, 0x78, 0x08, 0xA4, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0xA6, + 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, 0x74, 0x74, 0x72, + 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, 0xA2, 0x69, 0x64, + 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, 0x5F, 0x69, 0x6E, + 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, + 0xCE, 0x00, 0x2E, 0x6A, 0x93, 0xA5, 0x6C, 0x69, 0x6E, 0x65, 0x73, 0x91, + 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x5F, 0x69, + 0x6E, 0x64, 0x65, 0x78, 0x09, 0xA4, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0xA6, + 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, 0x74, 0x74, 0x72, + 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, 0xA2, 0x69, 0x64, + 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, 0x5F, 0x69, 0x6E, + 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, + 0xCE, 0x00, 0x2E, 0x06, 0x57, 0xA5, 0x6C, 0x69, 0x6E, 0x65, 0x73, 0x91, + 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x5F, 0x69, + 0x6E, 0x64, 0x65, 0x78, 0x0A, 0xA4, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0xA6, + 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, 0x74, 0x74, 0x72, + 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, 0xA2, 0x69, 0x64, + 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, 0x5F, 0x69, 0x6E, + 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, + 0xCE, 0x00, 0x2E, 0x89, 0x97, 0xA5, 0x6C, 0x69, 0x6E, 0x65, 0x73, 0x91, + 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x5F, 0x69, + 0x6E, 0x64, 0x65, 0x78, 0x0B, 0xA4, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0xA6, + 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, 0x74, 0x74, 0x72, + 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, 0xA2, 0x69, 0x64, + 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, 0x5F, 0x69, 0x6E, + 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, + 0xCE, 0x00, 0x2E, 0x94, 0x1F, 0xA5, 0x6C, 0x69, 0x6E, 0x65, 0x73, 0x91, + 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x5F, 0x69, + 0x6E, 0x64, 0x65, 0x78, 0x0C, 0xA4, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0xA6, + 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, 0x74, 0x74, 0x72, + 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, 0xA2, 0x69, 0x64, + 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, 0x5F, 0x69, 0x6E, + 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, + 0xCE, 0x00, 0x02, 0x3D, 0x6B, 0xA5, 0x6C, 0x69, 0x6E, 0x65, 0x73, 0x91, + 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x5F, 0x69, + 0x6E, 0x64, 0x65, 0x78, 0x0D, 0xA4, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0xA6, + 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, 0x74, 0x74, 0x72, + 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, 0xA2, 0x69, 0x64, + 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, 0x5F, 0x69, 0x6E, + 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, + 0xCE, 0x00, 0x02, 0x3F, 0x53, 0xA5, 0x6C, 0x69, 0x6E, 0x65, 0x73, 0x91, + 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x5F, 0x69, + 0x6E, 0x64, 0x65, 0x78, 0x0E, 0xA4, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0xA6, + 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, 0x74, 0x74, 0x72, + 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, 0xA2, 0x69, 0x64, + 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, 0x5F, 0x69, 0x6E, + 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, + 0xCE, 0x00, 0x02, 0x3F, 0xB7, 0xA5, 0x6C, 0x69, 0x6E, 0x65, 0x73, 0x91, + 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x5F, 0x69, + 0x6E, 0x64, 0x65, 0x78, 0x0F, 0xA4, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0xA6, + 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, 0x74, 0x74, 0x72, + 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, 0xA2, 0x69, 0x64, + 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, 0x5F, 0x69, 0x6E, + 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, + 0xCE, 0x01, 0x53, 0xDE, 0xA7, 0xA5, 0x6C, 0x69, 0x6E, 0x65, 0x73, 0x91, + 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x5F, 0x69, + 0x6E, 0x64, 0x65, 0x78, 0x10, 0xA4, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0xA6, + 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, 0x74, 0x74, 0x72, + 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, 0xA2, 0x69, 0x64, + 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, 0x5F, 0x69, 0x6E, + 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, + 0xCE, 0x01, 0x53, 0xE5, 0x4F, 0xA5, 0x6C, 0x69, 0x6E, 0x65, 0x73, 0x91, + 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x5F, 0x69, + 0x6E, 0x64, 0x65, 0x78, 0x11, 0xA4, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0xA6, + 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, 0x74, 0x74, 0x72, + 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, 0xA2, 0x69, 0x64, + 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, 0x5F, 0x69, 0x6E, + 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, + 0xCD, 0x1E, 0x47, 0xA5, 0x6C, 0x69, 0x6E, 0x65, 0x73, 0x91, 0x83, 0xAE, + 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x5F, 0x69, 0x6E, 0x64, + 0x65, 0x78, 0x12, 0xA4, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0xA6, 0x63, 0x6F, + 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, + 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, 0xA2, 0x69, 0x64, 0x00, 0xAD, + 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, 0x5F, 0x69, 0x6E, 0x64, 0x65, + 0x78, 0x01, 0xA7, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0xCE, 0x00, + 0x40, 0x53, 0x1F, 0xA5, 0x6C, 0x69, 0x6E, 0x65, 0x73, 0x90, 0xAA, 0x61, + 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x03, 0x85, + 0xA2, 0x69, 0x64, 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, + 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, + 0x65, 0x73, 0x73, 0xCE, 0x00, 0x4A, 0x66, 0x9F, 0xA5, 0x6C, 0x69, 0x6E, + 0x65, 0x73, 0x91, 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, + 0x6E, 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x13, 0xA4, 0x6C, 0x69, 0x6E, + 0x65, 0x00, 0xA6, 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, + 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, + 0xA2, 0x69, 0x64, 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, + 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, + 0x65, 0x73, 0x73, 0xCE, 0x00, 0x4B, 0x2F, 0xC3, 0xA5, 0x6C, 0x69, 0x6E, + 0x65, 0x73, 0x91, 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, + 0x6E, 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x14, 0xA4, 0x6C, 0x69, 0x6E, + 0x65, 0x00, 0xA6, 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, + 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, + 0xA2, 0x69, 0x64, 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, + 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, + 0x65, 0x73, 0x73, 0xCE, 0x00, 0x4B, 0x4F, 0xB3, 0xA5, 0x6C, 0x69, 0x6E, + 0x65, 0x73, 0x91, 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, + 0x6E, 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x15, 0xA4, 0x6C, 0x69, 0x6E, + 0x65, 0x00, 0xA6, 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, + 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, + 0xA2, 0x69, 0x64, 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, + 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, + 0x65, 0x73, 0x73, 0xCE, 0x00, 0x48, 0x30, 0x9B, 0xA5, 0x6C, 0x69, 0x6E, + 0x65, 0x73, 0x91, 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, + 0x6E, 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x16, 0xA4, 0x6C, 0x69, 0x6E, + 0x65, 0x00, 0xA6, 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, + 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, + 0xA2, 0x69, 0x64, 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, + 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, + 0x65, 0x73, 0x73, 0xCE, 0x01, 0x21, 0xB4, 0x4B, 0xA5, 0x6C, 0x69, 0x6E, + 0x65, 0x73, 0x91, 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, + 0x6E, 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x17, 0xA4, 0x6C, 0x69, 0x6E, + 0x65, 0x00, 0xA6, 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, + 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, + 0xA2, 0x69, 0x64, 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, + 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, + 0x65, 0x73, 0x73, 0xCE, 0x01, 0x21, 0xF1, 0xEB, 0xA5, 0x6C, 0x69, 0x6E, + 0x65, 0x73, 0x91, 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, + 0x6E, 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x18, 0xA4, 0x6C, 0x69, 0x6E, + 0x65, 0x00, 0xA6, 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, + 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, + 0xA2, 0x69, 0x64, 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, + 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, + 0x65, 0x73, 0x73, 0xCE, 0x01, 0x3F, 0x97, 0x7B, 0xA5, 0x6C, 0x69, 0x6E, + 0x65, 0x73, 0x91, 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, + 0x6E, 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x19, 0xA4, 0x6C, 0x69, 0x6E, + 0x65, 0x00, 0xA6, 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, + 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, + 0xA2, 0x69, 0x64, 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, + 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, + 0x65, 0x73, 0x73, 0xCE, 0x01, 0x3F, 0x98, 0x67, 0xA5, 0x6C, 0x69, 0x6E, + 0x65, 0x73, 0x91, 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, + 0x6E, 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x1A, 0xA4, 0x6C, 0x69, 0x6E, + 0x65, 0x00, 0xA6, 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, + 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, + 0xA2, 0x69, 0x64, 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, + 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, + 0x65, 0x73, 0x73, 0xCE, 0x01, 0x21, 0x48, 0x6F, 0xA5, 0x6C, 0x69, 0x6E, + 0x65, 0x73, 0x91, 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, + 0x6E, 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x1B, 0xA4, 0x6C, 0x69, 0x6E, + 0x65, 0x00, 0xA6, 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, + 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, + 0xA2, 0x69, 0x64, 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, + 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, + 0x65, 0x73, 0x73, 0xCE, 0x01, 0x21, 0x79, 0xF7, 0xA5, 0x6C, 0x69, 0x6E, + 0x65, 0x73, 0x91, 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, + 0x6E, 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x1C, 0xA4, 0x6C, 0x69, 0x6E, + 0x65, 0x00, 0xA6, 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, + 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, + 0xA2, 0x69, 0x64, 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, + 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, + 0x65, 0x73, 0x73, 0xCE, 0x01, 0x21, 0x7A, 0xCB, 0xA5, 0x6C, 0x69, 0x6E, + 0x65, 0x73, 0x91, 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, + 0x6E, 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x1D, 0xA4, 0x6C, 0x69, 0x6E, + 0x65, 0x00, 0xA6, 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, + 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, + 0xA2, 0x69, 0x64, 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, + 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, + 0x65, 0x73, 0x73, 0xCE, 0x00, 0x02, 0x3D, 0x6B, 0xA5, 0x6C, 0x69, 0x6E, + 0x65, 0x73, 0x91, 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, + 0x6E, 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x0D, 0xA4, 0x6C, 0x69, 0x6E, + 0x65, 0x00, 0xA6, 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, + 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, + 0xA2, 0x69, 0x64, 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, + 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, + 0x65, 0x73, 0x73, 0xCE, 0x00, 0x02, 0x3F, 0x53, 0xA5, 0x6C, 0x69, 0x6E, + 0x65, 0x73, 0x91, 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, + 0x6E, 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x0E, 0xA4, 0x6C, 0x69, 0x6E, + 0x65, 0x00, 0xA6, 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, + 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, + 0xA2, 0x69, 0x64, 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, + 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, + 0x65, 0x73, 0x73, 0xCE, 0x00, 0x02, 0x3F, 0xB7, 0xA5, 0x6C, 0x69, 0x6E, + 0x65, 0x73, 0x91, 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, + 0x6E, 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x0F, 0xA4, 0x6C, 0x69, 0x6E, + 0x65, 0x00, 0xA6, 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, + 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, + 0xA2, 0x69, 0x64, 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, + 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, + 0x65, 0x73, 0x73, 0xCE, 0x01, 0x53, 0xDE, 0xA7, 0xA5, 0x6C, 0x69, 0x6E, + 0x65, 0x73, 0x91, 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, + 0x6E, 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x10, 0xA4, 0x6C, 0x69, 0x6E, + 0x65, 0x00, 0xA6, 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, + 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, + 0xA2, 0x69, 0x64, 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, + 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, + 0x65, 0x73, 0x73, 0xCE, 0x01, 0x53, 0xE5, 0x4F, 0xA5, 0x6C, 0x69, 0x6E, + 0x65, 0x73, 0x91, 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, + 0x6E, 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x11, 0xA4, 0x6C, 0x69, 0x6E, + 0x65, 0x00, 0xA6, 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, + 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, + 0xA2, 0x69, 0x64, 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, + 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x00, 0xA7, 0x61, 0x64, 0x64, 0x72, + 0x65, 0x73, 0x73, 0xCD, 0x1E, 0x47, 0xA5, 0x6C, 0x69, 0x6E, 0x65, 0x73, + 0x91, 0x83, 0xAE, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x5F, + 0x69, 0x6E, 0x64, 0x65, 0x78, 0x12, 0xA4, 0x6C, 0x69, 0x6E, 0x65, 0x00, + 0xA6, 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x00, 0xAA, 0x61, 0x74, 0x74, + 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x91, 0x00, 0x85, 0xA2, 0x69, + 0x64, 0x00, 0xAD, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, 0x5F, 0x69, + 0x6E, 0x64, 0x65, 0x78, 0x02, 0xA7, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, + 0x73, 0xCE, 0x00, 0x01, 0x5F, 0xAF, 0xA5, 0x6C, 0x69, 0x6E, 0x65, 0x73, + 0x90, 0xAA, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, + 0x91, 0x03, 0xB0, 0x6C, 0x6F, 0x63, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x5F, + 0x69, 0x6E, 0x64, 0x69, 0x63, 0x65, 0x73, 0xDC, 0x00, 0x25, 0x00, 0x01, + 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, + 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, + 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, 0xA9, + 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x73, 0xDC, 0x00, 0x1E, + 0x85, 0xA2, 0x69, 0x64, 0x00, 0xA4, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xAB, + 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x5F, 0x6E, 0x61, 0x6D, 0x65, 0x00, + 0xA8, 0x66, 0x69, 0x6C, 0x65, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xAA, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x5F, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0x85, 0xA2, + 0x69, 0x64, 0x00, 0xA4, 0x6E, 0x61, 0x6D, 0x65, 0x18, 0xAB, 0x73, 0x79, + 0x73, 0x74, 0x65, 0x6D, 0x5F, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xA8, 0x66, + 0x69, 0x6C, 0x65, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xAA, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x5F, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0x85, 0xA2, 0x69, 0x64, + 0x00, 0xA4, 0x6E, 0x61, 0x6D, 0x65, 0x10, 0xAB, 0x73, 0x79, 0x73, 0x74, + 0x65, 0x6D, 0x5F, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xA8, 0x66, 0x69, 0x6C, + 0x65, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xAA, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x5F, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0x85, 0xA2, 0x69, 0x64, 0x00, 0xA4, + 0x6E, 0x61, 0x6D, 0x65, 0x24, 0xAB, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, + 0x5F, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xA8, 0x66, 0x69, 0x6C, 0x65, 0x6E, + 0x61, 0x6D, 0x65, 0x00, 0xAA, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5F, 0x6C, + 0x69, 0x6E, 0x65, 0x00, 0x85, 0xA2, 0x69, 0x64, 0x00, 0xA4, 0x6E, 0x61, + 0x6D, 0x65, 0x19, 0xAB, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x5F, 0x6E, + 0x61, 0x6D, 0x65, 0x00, 0xA8, 0x66, 0x69, 0x6C, 0x65, 0x6E, 0x61, 0x6D, + 0x65, 0x00, 0xAA, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5F, 0x6C, 0x69, 0x6E, + 0x65, 0x00, 0x85, 0xA2, 0x69, 0x64, 0x00, 0xA4, 0x6E, 0x61, 0x6D, 0x65, + 0x21, 0xAB, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x5F, 0x6E, 0x61, 0x6D, + 0x65, 0x00, 0xA8, 0x66, 0x69, 0x6C, 0x65, 0x6E, 0x61, 0x6D, 0x65, 0x00, + 0xAA, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5F, 0x6C, 0x69, 0x6E, 0x65, 0x00, + 0x85, 0xA2, 0x69, 0x64, 0x00, 0xA4, 0x6E, 0x61, 0x6D, 0x65, 0x1A, 0xAB, + 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x5F, 0x6E, 0x61, 0x6D, 0x65, 0x00, + 0xA8, 0x66, 0x69, 0x6C, 0x65, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xAA, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x5F, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0x85, 0xA2, + 0x69, 0x64, 0x00, 0xA4, 0x6E, 0x61, 0x6D, 0x65, 0x25, 0xAB, 0x73, 0x79, + 0x73, 0x74, 0x65, 0x6D, 0x5F, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xA8, 0x66, + 0x69, 0x6C, 0x65, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xAA, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x5F, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0x85, 0xA2, 0x69, 0x64, + 0x00, 0xA4, 0x6E, 0x61, 0x6D, 0x65, 0x0B, 0xAB, 0x73, 0x79, 0x73, 0x74, + 0x65, 0x6D, 0x5F, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xA8, 0x66, 0x69, 0x6C, + 0x65, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xAA, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x5F, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0x85, 0xA2, 0x69, 0x64, 0x00, 0xA4, + 0x6E, 0x61, 0x6D, 0x65, 0x26, 0xAB, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, + 0x5F, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xA8, 0x66, 0x69, 0x6C, 0x65, 0x6E, + 0x61, 0x6D, 0x65, 0x00, 0xAA, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5F, 0x6C, + 0x69, 0x6E, 0x65, 0x00, 0x85, 0xA2, 0x69, 0x64, 0x00, 0xA4, 0x6E, 0x61, + 0x6D, 0x65, 0x11, 0xAB, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x5F, 0x6E, + 0x61, 0x6D, 0x65, 0x00, 0xA8, 0x66, 0x69, 0x6C, 0x65, 0x6E, 0x61, 0x6D, + 0x65, 0x00, 0xAA, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5F, 0x6C, 0x69, 0x6E, + 0x65, 0x00, 0x85, 0xA2, 0x69, 0x64, 0x00, 0xA4, 0x6E, 0x61, 0x6D, 0x65, + 0x14, 0xAB, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x5F, 0x6E, 0x61, 0x6D, + 0x65, 0x00, 0xA8, 0x66, 0x69, 0x6C, 0x65, 0x6E, 0x61, 0x6D, 0x65, 0x00, + 0xAA, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5F, 0x6C, 0x69, 0x6E, 0x65, 0x00, + 0x85, 0xA2, 0x69, 0x64, 0x00, 0xA4, 0x6E, 0x61, 0x6D, 0x65, 0x15, 0xAB, + 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x5F, 0x6E, 0x61, 0x6D, 0x65, 0x00, + 0xA8, 0x66, 0x69, 0x6C, 0x65, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xAA, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x5F, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0x85, 0xA2, + 0x69, 0x64, 0x00, 0xA4, 0x6E, 0x61, 0x6D, 0x65, 0x12, 0xAB, 0x73, 0x79, + 0x73, 0x74, 0x65, 0x6D, 0x5F, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xA8, 0x66, + 0x69, 0x6C, 0x65, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xAA, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x5F, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0x85, 0xA2, 0x69, 0x64, + 0x00, 0xA4, 0x6E, 0x61, 0x6D, 0x65, 0x22, 0xAB, 0x73, 0x79, 0x73, 0x74, + 0x65, 0x6D, 0x5F, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xA8, 0x66, 0x69, 0x6C, + 0x65, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xAA, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x5F, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0x85, 0xA2, 0x69, 0x64, 0x00, 0xA4, + 0x6E, 0x61, 0x6D, 0x65, 0x16, 0xAB, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, + 0x5F, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xA8, 0x66, 0x69, 0x6C, 0x65, 0x6E, + 0x61, 0x6D, 0x65, 0x00, 0xAA, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5F, 0x6C, + 0x69, 0x6E, 0x65, 0x00, 0x85, 0xA2, 0x69, 0x64, 0x00, 0xA4, 0x6E, 0x61, + 0x6D, 0x65, 0x0E, 0xAB, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x5F, 0x6E, + 0x61, 0x6D, 0x65, 0x00, 0xA8, 0x66, 0x69, 0x6C, 0x65, 0x6E, 0x61, 0x6D, + 0x65, 0x00, 0xAA, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5F, 0x6C, 0x69, 0x6E, + 0x65, 0x00, 0x85, 0xA2, 0x69, 0x64, 0x00, 0xA4, 0x6E, 0x61, 0x6D, 0x65, + 0x1B, 0xAB, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x5F, 0x6E, 0x61, 0x6D, + 0x65, 0x00, 0xA8, 0x66, 0x69, 0x6C, 0x65, 0x6E, 0x61, 0x6D, 0x65, 0x00, + 0xAA, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5F, 0x6C, 0x69, 0x6E, 0x65, 0x00, + 0x85, 0xA2, 0x69, 0x64, 0x00, 0xA4, 0x6E, 0x61, 0x6D, 0x65, 0x1E, 0xAB, + 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x5F, 0x6E, 0x61, 0x6D, 0x65, 0x00, + 0xA8, 0x66, 0x69, 0x6C, 0x65, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xAA, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x5F, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0x85, 0xA2, + 0x69, 0x64, 0x00, 0xA4, 0x6E, 0x61, 0x6D, 0x65, 0x17, 0xAB, 0x73, 0x79, + 0x73, 0x74, 0x65, 0x6D, 0x5F, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xA8, 0x66, + 0x69, 0x6C, 0x65, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xAA, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x5F, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0x85, 0xA2, 0x69, 0x64, + 0x00, 0xA4, 0x6E, 0x61, 0x6D, 0x65, 0x27, 0xAB, 0x73, 0x79, 0x73, 0x74, + 0x65, 0x6D, 0x5F, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xA8, 0x66, 0x69, 0x6C, + 0x65, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xAA, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x5F, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0x85, 0xA2, 0x69, 0x64, 0x00, 0xA4, + 0x6E, 0x61, 0x6D, 0x65, 0x0C, 0xAB, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, + 0x5F, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xA8, 0x66, 0x69, 0x6C, 0x65, 0x6E, + 0x61, 0x6D, 0x65, 0x00, 0xAA, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5F, 0x6C, + 0x69, 0x6E, 0x65, 0x00, 0x85, 0xA2, 0x69, 0x64, 0x00, 0xA4, 0x6E, 0x61, + 0x6D, 0x65, 0x13, 0xAB, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x5F, 0x6E, + 0x61, 0x6D, 0x65, 0x00, 0xA8, 0x66, 0x69, 0x6C, 0x65, 0x6E, 0x61, 0x6D, + 0x65, 0x00, 0xAA, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5F, 0x6C, 0x69, 0x6E, + 0x65, 0x00, 0x85, 0xA2, 0x69, 0x64, 0x00, 0xA4, 0x6E, 0x61, 0x6D, 0x65, + 0x1F, 0xAB, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x5F, 0x6E, 0x61, 0x6D, + 0x65, 0x00, 0xA8, 0x66, 0x69, 0x6C, 0x65, 0x6E, 0x61, 0x6D, 0x65, 0x00, + 0xAA, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5F, 0x6C, 0x69, 0x6E, 0x65, 0x00, + 0x85, 0xA2, 0x69, 0x64, 0x00, 0xA4, 0x6E, 0x61, 0x6D, 0x65, 0x23, 0xAB, + 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x5F, 0x6E, 0x61, 0x6D, 0x65, 0x00, + 0xA8, 0x66, 0x69, 0x6C, 0x65, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xAA, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x5F, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0x85, 0xA2, + 0x69, 0x64, 0x00, 0xA4, 0x6E, 0x61, 0x6D, 0x65, 0x0F, 0xAB, 0x73, 0x79, + 0x73, 0x74, 0x65, 0x6D, 0x5F, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xA8, 0x66, + 0x69, 0x6C, 0x65, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xAA, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x5F, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0x85, 0xA2, 0x69, 0x64, + 0x00, 0xA4, 0x6E, 0x61, 0x6D, 0x65, 0x1C, 0xAB, 0x73, 0x79, 0x73, 0x74, + 0x65, 0x6D, 0x5F, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xA8, 0x66, 0x69, 0x6C, + 0x65, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xAA, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x5F, 0x6C, 0x69, 0x6E, 0x65, 0x00, 0x85, 0xA2, 0x69, 0x64, 0x00, 0xA4, + 0x6E, 0x61, 0x6D, 0x65, 0x0D, 0xAB, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, + 0x5F, 0x6E, 0x61, 0x6D, 0x65, 0x00, 0xA8, 0x66, 0x69, 0x6C, 0x65, 0x6E, + 0x61, 0x6D, 0x65, 0x00, 0xAA, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5F, 0x6C, + 0x69, 0x6E, 0x65, 0x00, 0x85, 0xA2, 0x69, 0x64, 0x00, 0xA4, 0x6E, 0x61, + 0x6D, 0x65, 0x20, 0xAB, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x5F, 0x6E, + 0x61, 0x6D, 0x65, 0x00, 0xA8, 0x66, 0x69, 0x6C, 0x65, 0x6E, 0x61, 0x6D, + 0x65, 0x00, 0xAA, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5F, 0x6C, 0x69, 0x6E, + 0x65, 0x00, 0x85, 0xA2, 0x69, 0x64, 0x00, 0xA4, 0x6E, 0x61, 0x6D, 0x65, + 0x1D, 0xAB, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x5F, 0x6E, 0x61, 0x6D, + 0x65, 0x00, 0xA8, 0x66, 0x69, 0x6C, 0x65, 0x6E, 0x61, 0x6D, 0x65, 0x00, + 0xAA, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5F, 0x6C, 0x69, 0x6E, 0x65, 0x00, + 0xAF, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x5F, 0x74, + 0x61, 0x62, 0x6C, 0x65, 0x8B, 0xB2, 0x70, 0x72, 0x6F, 0x66, 0x69, 0x6C, + 0x65, 0x2E, 0x66, 0x72, 0x61, 0x6D, 0x65, 0x2E, 0x74, 0x79, 0x70, 0x65, + 0xA6, 0x6B, 0x65, 0x72, 0x6E, 0x65, 0x6C, 0xAC, 0x63, 0x6F, 0x6E, 0x74, + 0x61, 0x69, 0x6E, 0x65, 0x72, 0x2E, 0x69, 0x64, 0xA1, 0x2F, 0xAB, 0x74, + 0x68, 0x72, 0x65, 0x61, 0x64, 0x2E, 0x6E, 0x61, 0x6D, 0x65, 0xAB, 0x6B, + 0x77, 0x6F, 0x72, 0x6B, 0x65, 0x72, 0x2F, 0x36, 0x3A, 0x31, 0xB2, 0x70, + 0x72, 0x6F, 0x66, 0x69, 0x6C, 0x65, 0x2E, 0x66, 0x72, 0x61, 0x6D, 0x65, + 0x2E, 0x74, 0x79, 0x70, 0x65, 0xA6, 0x6E, 0x61, 0x74, 0x69, 0x76, 0x65, + 0xBF, 0x70, 0x72, 0x6F, 0x63, 0x65, 0x73, 0x73, 0x2E, 0x65, 0x78, 0x65, + 0x63, 0x75, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2E, 0x62, 0x75, 0x69, 0x6C, + 0x64, 0x5F, 0x69, 0x64, 0x2E, 0x67, 0x6E, 0x75, 0xD9, 0x28, 0x33, 0x34, + 0x31, 0x39, 0x61, 0x33, 0x65, 0x66, 0x30, 0x30, 0x31, 0x35, 0x34, 0x35, + 0x64, 0x38, 0x65, 0x65, 0x39, 0x66, 0x63, 0x64, 0x34, 0x62, 0x31, 0x38, + 0x64, 0x34, 0x63, 0x65, 0x31, 0x37, 0x32, 0x30, 0x35, 0x37, 0x65, 0x33, + 0x33, 0x39, 0xD9, 0x25, 0x70, 0x72, 0x6F, 0x63, 0x65, 0x73, 0x73, 0x2E, + 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2E, 0x62, + 0x75, 0x69, 0x6C, 0x64, 0x5F, 0x69, 0x64, 0x2E, 0x70, 0x72, 0x6F, 0x66, + 0x69, 0x6C, 0x69, 0x6E, 0x67, 0xD9, 0x20, 0x37, 0x30, 0x35, 0x62, 0x64, + 0x66, 0x31, 0x34, 0x39, 0x38, 0x30, 0x66, 0x32, 0x63, 0x32, 0x32, 0x64, + 0x63, 0x34, 0x64, 0x65, 0x32, 0x65, 0x36, 0x35, 0x37, 0x36, 0x65, 0x64, + 0x66, 0x66, 0x38, 0xAC, 0x63, 0x6F, 0x6E, 0x74, 0x61, 0x69, 0x6E, 0x65, + 0x72, 0x2E, 0x69, 0x64, 0xD9, 0x2A, 0x2F, 0x75, 0x73, 0x65, 0x72, 0x2E, + 0x73, 0x6C, 0x69, 0x63, 0x65, 0x2F, 0x75, 0x73, 0x65, 0x72, 0x2D, 0x35, + 0x30, 0x31, 0x2E, 0x73, 0x6C, 0x69, 0x63, 0x65, 0x2F, 0x73, 0x65, 0x73, + 0x73, 0x69, 0x6F, 0x6E, 0x2D, 0x32, 0x2E, 0x73, 0x63, 0x6F, 0x70, 0x65, + 0xAB, 0x74, 0x68, 0x72, 0x65, 0x61, 0x64, 0x2E, 0x6E, 0x61, 0x6D, 0x65, + 0xAD, 0x65, 0x62, 0x70, 0x66, 0x2D, 0x70, 0x72, 0x6F, 0x66, 0x69, 0x6C, + 0x65, 0x72, 0xD9, 0x25, 0x70, 0x72, 0x6F, 0x63, 0x65, 0x73, 0x73, 0x2E, + 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2E, 0x62, + 0x75, 0x69, 0x6C, 0x64, 0x5F, 0x69, 0x64, 0x2E, 0x70, 0x72, 0x6F, 0x66, + 0x69, 0x6C, 0x69, 0x6E, 0x67, 0xD9, 0x20, 0x64, 0x37, 0x38, 0x30, 0x31, + 0x36, 0x30, 0x34, 0x65, 0x38, 0x62, 0x38, 0x39, 0x64, 0x64, 0x61, 0x63, + 0x66, 0x65, 0x31, 0x39, 0x38, 0x39, 0x39, 0x64, 0x36, 0x62, 0x61, 0x33, + 0x35, 0x36, 0x34, 0xAC, 0x63, 0x6F, 0x6E, 0x74, 0x61, 0x69, 0x6E, 0x65, + 0x72, 0x2E, 0x69, 0x64, 0xD9, 0x48, 0x2F, 0x75, 0x73, 0x65, 0x72, 0x2E, + 0x73, 0x6C, 0x69, 0x63, 0x65, 0x2F, 0x75, 0x73, 0x65, 0x72, 0x2D, 0x35, + 0x30, 0x31, 0x2E, 0x73, 0x6C, 0x69, 0x63, 0x65, 0x2F, 0x75, 0x73, 0x65, + 0x72, 0x40, 0x35, 0x30, 0x31, 0x2E, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, + 0x65, 0x2F, 0x61, 0x70, 0x70, 0x2E, 0x73, 0x6C, 0x69, 0x63, 0x65, 0x2F, + 0x63, 0x6F, 0x6E, 0x74, 0x61, 0x69, 0x6E, 0x65, 0x72, 0x64, 0x2E, 0x73, + 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0xAB, 0x74, 0x68, 0x72, 0x65, 0x61, + 0x64, 0x2E, 0x6E, 0x61, 0x6D, 0x65, 0xAA, 0x63, 0x6F, 0x6E, 0x74, 0x61, + 0x69, 0x6E, 0x65, 0x72, 0x64, 0xAF, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, + 0x75, 0x74, 0x65, 0x5F, 0x75, 0x6E, 0x69, 0x74, 0x73, 0x90, 0xAA, 0x6C, + 0x69, 0x6E, 0x6B, 0x5F, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x90, 0xAC, 0x73, + 0x74, 0x72, 0x69, 0x6E, 0x67, 0x5F, 0x74, 0x61, 0x62, 0x6C, 0x65, 0xDC, + 0x00, 0x28, 0xA0, 0xA7, 0x73, 0x61, 0x6D, 0x70, 0x6C, 0x65, 0x73, 0xA5, + 0x63, 0x6F, 0x75, 0x6E, 0x74, 0xA3, 0x63, 0x70, 0x75, 0xAB, 0x6E, 0x61, + 0x6E, 0x6F, 0x73, 0x65, 0x63, 0x6F, 0x6E, 0x64, 0x73, 0xB6, 0x41, 0x54, + 0x73, 0x51, 0x46, 0x31, 0x72, 0x72, 0x49, 0x63, 0x30, 0x35, 0x74, 0x65, + 0x6A, 0x66, 0x79, 0x65, 0x73, 0x5A, 0x52, 0x77, 0xD9, 0x20, 0x62, 0x61, + 0x31, 0x63, 0x39, 0x61, 0x35, 0x61, 0x38, 0x32, 0x35, 0x36, 0x61, 0x36, + 0x65, 0x66, 0x33, 0x65, 0x36, 0x36, 0x33, 0x63, 0x63, 0x37, 0x33, 0x31, + 0x36, 0x38, 0x30, 0x33, 0x64, 0x39, 0xB6, 0x7A, 0x6A, 0x32, 0x51, 0x75, + 0x43, 0x52, 0x61, 0x70, 0x75, 0x6E, 0x30, 0x32, 0x73, 0x79, 0x68, 0x6C, + 0x41, 0x48, 0x71, 0x54, 0x77, 0xAD, 0x65, 0x62, 0x70, 0x66, 0x2D, 0x70, + 0x72, 0x6F, 0x66, 0x69, 0x6C, 0x65, 0x72, 0xB6, 0x36, 0x34, 0x41, 0x49, + 0x75, 0x76, 0x39, 0x69, 0x70, 0x47, 0x42, 0x41, 0x41, 0x64, 0x30, 0x52, + 0x5A, 0x6D, 0x76, 0x4C, 0x4C, 0x77, 0xAA, 0x63, 0x6F, 0x6E, 0x74, 0x61, + 0x69, 0x6E, 0x65, 0x72, 0x64, 0xB3, 0x5F, 0x5F, 0x63, 0x68, 0x65, 0x63, + 0x6B, 0x5F, 0x6F, 0x62, 0x6A, 0x65, 0x63, 0x74, 0x5F, 0x73, 0x69, 0x7A, + 0x65, 0xB1, 0x6F, 0x62, 0x6A, 0x5F, 0x63, 0x67, 0x72, 0x6F, 0x75, 0x70, + 0x5F, 0x63, 0x68, 0x61, 0x72, 0x67, 0x65, 0xAD, 0x5F, 0x5F, 0x73, 0x6F, + 0x63, 0x6B, 0x5F, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0xA7, 0x65, 0x6C, + 0x30, 0x5F, 0x73, 0x76, 0x63, 0xAC, 0x75, 0x6E, 0x69, 0x78, 0x5F, 0x63, + 0x72, 0x65, 0x61, 0x74, 0x65, 0x31, 0xA8, 0x73, 0x63, 0x68, 0x65, 0x64, + 0x75, 0x6C, 0x65, 0xB0, 0x62, 0x70, 0x66, 0x5F, 0x6D, 0x61, 0x70, 0x5F, + 0x64, 0x6F, 0x5F, 0x62, 0x61, 0x74, 0x63, 0x68, 0xAE, 0x69, 0x6E, 0x76, + 0x6F, 0x6B, 0x65, 0x5F, 0x73, 0x79, 0x73, 0x63, 0x61, 0x6C, 0x6C, 0xB0, + 0x6B, 0x6D, 0x65, 0x6D, 0x5F, 0x63, 0x61, 0x63, 0x68, 0x65, 0x5F, 0x61, + 0x6C, 0x6C, 0x6F, 0x63, 0xA9, 0x5F, 0x5F, 0x73, 0x79, 0x73, 0x5F, 0x62, + 0x70, 0x66, 0xAF, 0x5F, 0x5F, 0x61, 0x72, 0x6D, 0x36, 0x34, 0x5F, 0x73, + 0x79, 0x73, 0x5F, 0x62, 0x70, 0x66, 0xAA, 0x64, 0x6F, 0x5F, 0x65, 0x6C, + 0x30, 0x5F, 0x73, 0x76, 0x63, 0xB9, 0x70, 0x72, 0x6F, 0x70, 0x61, 0x67, + 0x61, 0x74, 0x65, 0x5F, 0x70, 0x72, 0x6F, 0x74, 0x65, 0x63, 0x74, 0x65, + 0x64, 0x5F, 0x75, 0x73, 0x61, 0x67, 0x65, 0xB9, 0x66, 0x69, 0x6E, 0x69, + 0x73, 0x68, 0x5F, 0x74, 0x61, 0x73, 0x6B, 0x5F, 0x73, 0x77, 0x69, 0x74, + 0x63, 0x68, 0x2E, 0x69, 0x73, 0x72, 0x61, 0x2E, 0x30, 0xA7, 0x6B, 0x74, + 0x68, 0x72, 0x65, 0x61, 0x64, 0xB3, 0x5F, 0x5F, 0x63, 0x68, 0x65, 0x63, + 0x6B, 0x5F, 0x68, 0x65, 0x61, 0x70, 0x5F, 0x6F, 0x62, 0x6A, 0x65, 0x63, + 0x74, 0xB4, 0x65, 0x6C, 0x30, 0x74, 0x5F, 0x36, 0x34, 0x5F, 0x73, 0x79, + 0x6E, 0x63, 0x5F, 0x68, 0x61, 0x6E, 0x64, 0x6C, 0x65, 0x72, 0xAB, 0x75, + 0x6E, 0x69, 0x78, 0x5F, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0xB2, 0x5F, + 0x5F, 0x61, 0x72, 0x6D, 0x36, 0x34, 0x5F, 0x73, 0x79, 0x73, 0x5F, 0x73, + 0x6F, 0x63, 0x6B, 0x65, 0x74, 0xAC, 0x65, 0x6C, 0x30, 0x74, 0x5F, 0x36, + 0x34, 0x5F, 0x73, 0x79, 0x6E, 0x63, 0xAD, 0x73, 0x6B, 0x5F, 0x70, 0x72, + 0x6F, 0x74, 0x5F, 0x61, 0x6C, 0x6C, 0x6F, 0x63, 0xAC, 0x5F, 0x5F, 0x73, + 0x79, 0x73, 0x5F, 0x73, 0x6F, 0x63, 0x6B, 0x65, 0x74, 0xAD, 0x72, 0x65, + 0x74, 0x5F, 0x66, 0x72, 0x6F, 0x6D, 0x5F, 0x66, 0x6F, 0x72, 0x6B, 0xBA, + 0x65, 0x6C, 0x30, 0x5F, 0x73, 0x76, 0x63, 0x5F, 0x63, 0x6F, 0x6D, 0x6D, + 0x6F, 0x6E, 0x2E, 0x63, 0x6F, 0x6E, 0x73, 0x74, 0x70, 0x72, 0x6F, 0x70, + 0x2E, 0x30, 0xA8, 0x73, 0x6B, 0x5F, 0x61, 0x6C, 0x6C, 0x6F, 0x63, 0xAD, + 0x77, 0x6F, 0x72, 0x6B, 0x65, 0x72, 0x5F, 0x74, 0x68, 0x72, 0x65, 0x61, + 0x64, 0xBA, 0x5F, 0x5F, 0x63, 0x68, 0x65, 0x63, 0x6B, 0x5F, 0x6F, 0x62, + 0x6A, 0x65, 0x63, 0x74, 0x5F, 0x73, 0x69, 0x7A, 0x65, 0x2E, 0x70, 0x61, + 0x72, 0x74, 0x2E, 0x30, 0xB8, 0x67, 0x65, 0x6E, 0x65, 0x72, 0x69, 0x63, + 0x5F, 0x6D, 0x61, 0x70, 0x5F, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x5F, + 0x62, 0x61, 0x74, 0x63, 0x68, 0xB0, 0x74, 0x72, 0x79, 0x5F, 0x63, 0x68, + 0x61, 0x72, 0x67, 0x65, 0x5F, 0x6D, 0x65, 0x6D, 0x63, 0x67, 0xAB, 0x64, + 0x72, 0x6F, 0x70, 0x5F, 0x66, 0x72, 0x61, 0x6D, 0x65, 0x73, 0x00, 0xAB, + 0x6B, 0x65, 0x65, 0x70, 0x5F, 0x66, 0x72, 0x61, 0x6D, 0x65, 0x73, 0x00, + 0xAA, 0x74, 0x69, 0x6D, 0x65, 0x5F, 0x6E, 0x61, 0x6E, 0x6F, 0x73, 0xCF, + 0x18, 0x04, 0xC7, 0x53, 0x2C, 0xAC, 0x39, 0x69, 0xAE, 0x64, 0x75, 0x72, + 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x5F, 0x6E, 0x61, 0x6E, 0x6F, 0x73, 0x00, + 0xAB, 0x70, 0x65, 0x72, 0x69, 0x6F, 0x64, 0x5F, 0x74, 0x79, 0x70, 0x65, + 0x83, 0xA4, 0x74, 0x79, 0x70, 0x65, 0x03, 0xA4, 0x75, 0x6E, 0x69, 0x74, + 0x04, 0xB7, 0x61, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6F, + 0x6E, 0x5F, 0x74, 0x65, 0x6D, 0x70, 0x6F, 0x72, 0x61, 0x6C, 0x69, 0x74, + 0x79, 0x00, 0xA6, 0x70, 0x65, 0x72, 0x69, 0x6F, 0x64, 0xCE, 0x02, 0xFA, + 0xF0, 0x80, 0xA8, 0x63, 0x6F, 0x6D, 0x6D, 0x65, 0x6E, 0x74, 0x73, 0x90, + 0xB3, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74, 0x5F, 0x73, 0x61, 0x6D, + 0x70, 0x6C, 0x65, 0x5F, 0x74, 0x79, 0x70, 0x65, 0x00, 0xAA, 0x73, 0x63, + 0x68, 0x65, 0x6D, 0x61, 0x5F, 0x75, 0x72, 0x6C, 0xA0, 0xAA, 0x73, 0x63, + 0x68, 0x65, 0x6D, 0x61, 0x5F, 0x75, 0x72, 0x6C, 0xA0 +}; + +static void test_encoder() +{ + cfl_sds_t text_encoder_result; + struct cprof *context; + int result; + size_t offset; + + offset = 0; + context = NULL; + + result = cprof_decode_msgpack_create(&context, + (unsigned char *) serialized_data, + sizeof(serialized_data), + &offset); + + TEST_CHECK(result == CPROF_DECODE_MSGPACK_SUCCESS); + TEST_CHECK(offset == sizeof(serialized_data)); + + if (result == CPROF_DECODE_MSGPACK_SUCCESS) { + result = cprof_encode_text_create(&text_encoder_result, context); + + TEST_CHECK(result == CPROF_ENCODE_TEXT_SUCCESS); + + if (result == CPROF_ENCODE_TEXT_SUCCESS) { + TEST_CHECK(cfl_sds_len(text_encoder_result) > 1); + + cprof_encode_text_destroy(text_encoder_result); + } + + cprof_decode_msgpack_destroy(context); + } +} + +TEST_LIST = { + {"encoder", test_encoder}, + { 0 } +};