Logger: handle situation when git sha1 is empty

This reverts commit dcd6088afe.

.gitlab-ci.yml

@@ -2,6 +2,7 @@ stages:
   - build
   - test
   - synthesis
+  - release
 
 build:x86:gcc:
   stage: build
@@ -49,13 +50,13 @@ build:x86:driver:
   needs: []
   artifacts:
     paths:
-      - "jfjoch_driver_*.tar.gz"
+      - "jfjoch_driver.tar.gz"
     expire_in: 1 week
   script:
     - cd fpga/pcie_driver
     - make
     - bash pack.sh
-    - mv jfjoch_driver_*.tar.gz ../..
+    - mv jfjoch_driver.tar.gz ../..
 
 build:x86:vitis_hls:
   stage: build
@@ -93,10 +94,10 @@ build:x86:frontend:
     - npm install
     - npm run build
     - cd build
-    - zip -r ../../frontend.${CI_COMMIT_SHORT_SHA}.zip *
+    - tar czf ../../jfjoch_frontend.tar.gz *
   artifacts:
     paths:
-      - frontend.${CI_COMMIT_SHORT_SHA}.zip
+      - jfjoch_frontend.tar.gz
     expire_in: 1 week
 
 test:x86:gcc:
@@ -112,18 +113,16 @@ test:x86:gcc:
   tags:
     - gcc
     - x86
-    - ib
   script:
     - source /opt/rh/gcc-toolset-12/enable 
     - mkdir -p build
     - cd build
     - cmake -DCMAKE_BUILD_TYPE=Release ..
-    - make -j48 CatchTest CompressionBenchmark HDF5DatasetWriteTest
+    - make -j48 CatchTest HDF5DatasetWriteTest
     - cd tests
     - ./CatchTest -r junit -o report.xml
     - cd ../tools
     - ./HDF5DatasetWriteTest ../../tests/test_data/compression_benchmark.h5
-    - numactl -m 0 -N 0 ./CompressionBenchmark ../../tests/test_data/compression_benchmark.h5
   artifacts:
     expire_in: 1 week
     reports:
@@ -229,43 +228,47 @@ test:x86:xia2.ssx:
 
 synthesis:vivado_pcie_100g:
   stage: synthesis
+  dependencies: []
   variables:
     GIT_SUBMODULE_STRATEGY: recursive
     CC: gcc
     CXX: g++
-  allow_failure: true
   rules:
     - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
     - if: $CI_PIPELINE_SOURCE == "push"
+      allow_failure: true
       changes:
         - fpga/hls/*
         - fpga/hdl/*
         - fpga/scripts/*
         - fpga/xdc/*
-        - fpga/include/jfjoch_fpga.h
+        - fpga/pcie_driver/jfjoch_fpga.h
+    - when: manual
+      allow_failure: true
   tags:
     - vivado
   artifacts:
     paths:
-      - "*.mcs"
+      - "jfjoch_fpga_pcie_100g.mcs"
     expire_in: 1 week
   script:
     - source /opt/rh/gcc-toolset-12/enable 
     - source /opt/Xilinx/Vivado/2022.1/settings64.sh
+    - touch jfjoch_fpga_pcie_100g.mcs
     - mkdir -p build
     - cd build
     - /usr/bin/cmake ..
-    - make pcie_100g
-    - mv fpga/*.mcs ..
-  needs: ["build:x86:gcc", "build:x86:vitis_hls", "test:x86:gcc"]
+    - make -j4 pcie_100g
+    - mv fpga/jfjoch_fpga_pcie_100g.mcs ..
+  needs: ["build:x86:gcc", "test:x86:gcc"]
 
 synthesis:vivado_pcie_8x10g:
   stage: synthesis
+  dependencies: []
   variables:
     GIT_SUBMODULE_STRATEGY: recursive
     CC: gcc
     CXX: g++
-  allow_failure: true
   rules:
     - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
     - if: $CI_PIPELINE_SOURCE == "push"
@@ -274,19 +277,47 @@ synthesis:vivado_pcie_8x10g:
         - fpga/hdl/*
         - fpga/scripts/*
         - fpga/xdc/*
-        - fpga/include/jfjoch_fpga.h
+        - fpga/pcie_driver/jfjoch_fpga.h
+      allow_failure: true
+    - when: manual
+      allow_failure: true
   tags:
     - vivado
   artifacts:
     paths:
-      - "*.mcs"
+      - "jfjoch_fpga_pcie_8x10g.mcs"
     expire_in: 1 week
   script:
     - source /opt/rh/gcc-toolset-12/enable
     - source /opt/Xilinx/Vivado/2022.1/settings64.sh
+    - touch jfjoch_fpga_pcie_8x10g.mcs
     - mkdir -p build
     - cd build
     - /usr/bin/cmake ..
-    - make pcie_8x10g
-    - mv fpga/*.mcs ..
-  needs: [ "build:x86:gcc", "build:x86:vitis_hls", "test:x86:gcc" ]
+    - make -j4 pcie_8x10g
+    - mv fpga/jfjoch_fpga_pcie_8x10g.mcs ..
+  needs: [ "build:x86:gcc", "test:x86:gcc" ]
+
+release:
+  stage: release
+  when: manual
+  tags:
+    - x86
+  dependencies:
+    - synthesis:vivado_pcie_8x10g
+    - synthesis:vivado_pcie_100g
+    - build:x86:frontend
+    - build:x86:driver
+  script:
+    - export PACKAGE_VERSION=`head -n1 VERSION`
+    - export PACKAGE_REGISTRY_URL="${CI_API_V4_URL}/projects/${CI_PROJECT_ID}/packages/generic/jungfraujoch/${PACKAGE_VERSION}"
+    - 'curl --header "JOB-TOKEN: $CI_JOB_TOKEN" --upload-file jfjoch_driver.tar.gz "${PACKAGE_REGISTRY_URL}/jfjoch_driver.tar.gz"'
+    - 'curl --header "JOB-TOKEN: $CI_JOB_TOKEN" --upload-file jfjoch_frontend.tar.gz "${PACKAGE_REGISTRY_URL}/jfjoch_frontend.tar.gz"'
+    - 'curl --header "JOB-TOKEN: $CI_JOB_TOKEN" --upload-file jfjoch_fpga_pcie_100g.mcs "${PACKAGE_REGISTRY_URL}/jfjoch_fpga_pcie_100g.mcs"'
+    - 'curl --header "JOB-TOKEN: $CI_JOB_TOKEN" --upload-file jfjoch_fpga_pcie_8x10g.mcs "${PACKAGE_REGISTRY_URL}/jfjoch_fpga_pcie_8x10g.mcs"'
+    - >
+      release-cli create --name "Release $PACKAGE_VERSION" --tag-name $PACKAGE_VERSION
+      --assets-link "{\"name\":\"jfjoch_driver.tar.gz\",\"url\":\"${PACKAGE_REGISTRY_URL}/jfjoch_driver.tar.gz\"}"
+      --assets-link "{\"name\":\"jfjoch_frontend.tar.gz\",\"url\":\"${PACKAGE_REGISTRY_URL}/jfjoch_frontend.tar.gz\"}"
+      --assets-link "{\"name\":\"jfjoch_fpga_pcie_8x10g.mcs\",\"url\":\"${PACKAGE_REGISTRY_URL}/jfjoch_fpga_pcie_8x10g.mcs\"}"
+      --assets-link "{\"name\":\"jfjoch_fpga_pcie_100g.mcs\",\"url\":\"${PACKAGE_REGISTRY_URL}/jfjoch_fpga_pcie_100g.mcs\"}"

.gitmodules

@@ -1,19 +0,0 @@
-[submodule "image_analysis/fast-feedback-indexer"]
-	path = image_analysis/fast-feedback-indexer
-	url = https://github.com/paulscherrerinstitute/fast-feedback-indexer/
-[submodule "frame_serialize/tinycbor"]
-	path = frame_serialize/tinycbor
-	url = https://github.com/intel/tinycbor
-[submodule "compression/zstd"]
-	path = compression/zstd
-	url = https://github.com/facebook/zstd
-[submodule "detector_control/slsDetectorPackage"]
-	path = detector_control/slsDetectorPackage
-	url = https://github.com/fleon-psi/slsDetectorPackage
-	branch = "jfjoch-shmem"
-[submodule "compression/bitshuffle_hperf"]
-	path = compression/bitshuffle_hperf
-	url = https://github.com/kalcutter/bitshuffle
-[submodule "broker/pistache"]
-	path = broker/pistache
-	url = https://github.com/fleon-psi/pistache

CMakeLists.txt

@@ -9,6 +9,9 @@ SET(CMAKE_CXX_STANDARD_REQUIRED True)
 SET(CMAKE_CXX_FLAGS_RELEASE "-O3 -march=native -mtune=native -Wno-deprecated-enum-enum-conversion")
 SET(CMAKE_C_FLAGS_RELEASE "-O3 -march=native -mtune=native")
 
+SET(ZSTD_LEGACY_SUPPORT OFF)
+SET(ZSTD_MULTITHREAD_SUPPORT OFF)
+
 INCLUDE(CheckLanguage)
 CHECK_LANGUAGE(CUDA)
 
@@ -39,8 +42,34 @@ FIND_LIBRARY(NUMA_LIBRARY NAMES numa DOC "NUMA Library")
 CHECK_INCLUDE_FILE(numaif.h HAS_NUMAIF)
 CHECK_INCLUDE_FILE(numa.h HAS_NUMA_H)
 
-LIST(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
-#FIND_PACKAGE(ZeroMQ 4 REQUIRED)
+include(FetchContent)
+
+FetchContent_Declare(
+        pistache_http
+        GIT_REPOSITORY https://github.com/fleon-psi/pistache
+        GIT_TAG       51553b92cc7bb25ac792462722ddd4fae33d14b1
+)
+
+FetchContent_Declare(
+        zstd
+        GIT_REPOSITORY https://github.com/facebook/zstd
+        GIT_TAG 794ea1b0afca0f020f4e57b6732332231fb23c70
+        SOURCE_SUBDIR build/cmake
+)
+
+FetchContent_Declare(
+        sls_detector_package
+        GIT_REPOSITORY https://github.com/fleon-psi/slsDetectorPackage
+        GIT_TAG bae261433241ff2f458350e26ab026f00f01c427
+)
+
+FetchContent_Declare(
+        catch2
+        GIT_REPOSITORY https://github.com/catchorg/Catch2
+        GIT_TAG 4e8d92b
+)
+
+FetchContent_MakeAvailable(pistache_http zstd sls_detector_package catch2)
 
 ADD_SUBDIRECTORY(jungfrau)
 ADD_SUBDIRECTORY(compression)
@@ -48,7 +77,6 @@ ADD_SUBDIRECTORY(common)
 ADD_SUBDIRECTORY(writer)
 ADD_SUBDIRECTORY(frame_serialize)
 
-ADD_SUBDIRECTORY(broker/pistache)
 ADD_SUBDIRECTORY(detector_control)
 IF (JFJOCH_WRITER_ONLY)
     MESSAGE(STATUS "Compiling HDF5 writer only")

Dockerfile

@@ -1,3 +1,5 @@
+# MAX IV docker config
+
 FROM harbor.maxiv.lu.se/dockerhub/library/ubuntu:22.04
 
 RUN set -ex;  \

README.md

@@ -44,21 +44,21 @@ Optional:
 * Node.js - to make frontend
 * libtorch - for resolution estimation using model from Stanford - see below
 
-Provided as GIT submodules: 
+Automatically downloaded by CMake: 
 * SLS Detector Package - see [github.com/slsdetectorgroup/slsDetectorPackage](https://github.com/slsdetectorgroup/slsDetectorPackage)
-* tinycbor (Intel) - see [github.com/intel/tinycbor](https://github.com/intel/tinycbor)
 * Zstandard (Facebook) - see [github.com/facebook/zstd](https://github.com/facebook/zstd)
 * Pistache webserver  - see [github.com/pistacheio/pistache](https://github.com/pistacheio/pistache)
 * Fast feedback indexer (Hans-Christian Stadler, PSI) - see [github.com/paulscherrerinstitute/fast-feedback-indexer](https://github.com/paulscherrerinstitute/fast-feedback-indexer)
-* fast replacement for Bitshuffle pre-compression filter (Kal Cutter, DECTRIS)  - see [github.com/kalcutter/bitshuffle](https://github.com/kalcutter/bitshuffle)
+* Catch2 testing library - see [github.com/catchorg/Catch2](https://github.com/catchorg/Catch2)
 
-For license check LICENSE file in respective directory
+Please follow the link provided above to check for LICENSE file
 
 Directly included in the repository:
 * JSON parser/writer from N. Lohmann - see [github.com/nlohmann/json](https://github.com/nlohmann/json)
-* Catch2 testing library - see [github.com/catchorg/Catch2](https://github.com/catchorg/Catch2)
 * Xilinx arbitrary precision arithmetic headers - see [github.com/Xilinx/HLS_arbitrary_Precision_Types](https://github.com/Xilinx/HLS_arbitrary_Precision_Types)
 * Bitshuffle filter from K. Masui - see [github.com/kiyo-masui/bitshuffle](https://github.com/kiyo-masui/bitshuffle)
+* Fast replacement for Bitshuffle pre-compression filter (Kal Cutter, DECTRIS)  - see [github.com/kalcutter/bitshuffle](https://github.com/kalcutter/bitshuffle)
+* Tinycbor (Intel) - see [github.com/intel/tinycbor](https://github.com/intel/tinycbor)
 * LZ4 compression by Y.Collet - see [github.com/lz4/lz4](https://github.com/lz4/lz4)
 * Spdlog logging library - see [github.com/gabime/spdlog](https://github.com/gabime/spdlog)
 * ZeroMQ library (through slsDetectorPackage) - see [github.com/zeromq/libzmq](https://github.com/zeromq/libzmq)
@@ -68,9 +68,9 @@ For license check LICENSE file in respective directory
 ### Software components
 
 * `jfjoch_broker` in `broker` - main service running on the Jungfraujoch server, responsible for control of the detector and data acquisition;
-  Example configuration `jfjoch_broker` for the modules is given in configuration files present in `etc` directory.
+  Example configuration `jfjoch_broker` for the modules is given in configuration files present in `etc` directory. See [details](broker/README.md).
 * `jfjoch_writer` in `writer` - HDF5 writer; HDF5 writer is designed to work on the same or separate server system. It has rather limited requirements in terms of performance and memory.
-  The goal is to separate data acquisition node with custom FPGA hardware and file system node with stronger security/stability requirements.
+  The goal is to separate data acquisition node with custom FPGA hardware and file system node with stronger security/stability requirements. See [details](writer/README.md).
 
 ### Compilation
 Use the following commands:
@@ -85,7 +85,7 @@ make jfjoch
 
 ### Compilation (writer only)
 In most use cases it is better to have a separate machine, with access to distributed file system, for writing.
-Such machine needs only a HDF5 writer service with less dependencies. For compilation use the following commands:
+Such machine needs only a HDF5 writer service with fewer dependencies. For compilation use the following commands:
 
 ```
 git submodule update --init --recursive
@@ -96,8 +96,7 @@ make jfjoch
 ```
 
 ## Versions
-**FPGA release** is as hexadecimal number indicted in the [jfjoch_fpga.h](fpga/pcie_driver/jfjoch_fpga.h) as JFJOCH_FPGA_RELEASE constant. 
-It is also included in the name of FPGA firmware file (.mcs) and kernel driver archive. This number indicated breaking changes in the FPGA firmware interface. 
+**FPGA release** is as hexadecimal number indicted in the [jfjoch_fpga.h](fpga/pcie_driver/jfjoch_fpga.h) as JFJOCH_FPGA_RELEASE constant. This number indicated breaking changes in the FPGA firmware interface. 
 FPGA release has to be consistent between FPGA firmware, kernel driver and `jfjoch_broker` - both kernel driver and software won't work in case of version mismatch. 
 Commits to `main` branch with the same FPGA release version are OK to mix between components.
 
@@ -125,7 +124,6 @@ Contrary to standard CMake way, frontend will be built in "source" `frontend_ui/
  
 Automated test routine is then accessible as `tests/CatchTest`. There are also benchmark routines:
 
-* `CompressionBenchmark` to measure compression bandwidth (single threaded)
 * `HDF5DatasetWriteTest` to measure HDF5 dataset writing speed (single threaded)
 * `jfjoch_spot_finding_test` to apply spot finding and indexing routines in Jungfraujoch to an example dataset - this is equivalent to FPGA spot finding algorithm, but NOT performance equivalent as it is particularly not-efficient
 * `jfjoch_action_test` to test quality/performance of FPGA card(s) and software routines

VERSION

@@ -0,0 +1 @@
+1.0.0-test5

broker/CMakeLists.txt

@@ -1,4 +1,5 @@
 AUX_SOURCE_DIRECTORY(gen/model MODEL_SOURCES)
+
 ADD_LIBRARY(JFJochAPI STATIC ${MODEL_SOURCES} gen/api/DefaultApi.cpp gen/api/DefaultApi.h)
 
 TARGET_LINK_LIBRARIES(JFJochAPI pistache_static)
@@ -15,5 +16,3 @@ ADD_EXECUTABLE(jfjoch_broker jfjoch_broker.cpp)
 TARGET_LINK_LIBRARIES(jfjoch_broker JFJochBroker)
 
 INSTALL(TARGETS jfjoch_broker RUNTIME)
-
-

broker/JFJochBrokerHttp.cpp

@@ -316,6 +316,8 @@ inline PreviewJPEGSettings Convert(const org::openapitools::server::model::Previ
     ret.saturation_value = input.getSaturation();
     ret.show_roi = input.isShowRoi();
     ret.show_indexed = input.isShowIndexed();
+    if (input.resolutionRingIsSet())
+        ret.resolution_ring = input.getResolutionRing();
     return ret;
 }
 

broker/JFJochBrokerHttp.h

@@ -7,11 +7,12 @@
 #include <pistache/endpoint.h>
 #include <pistache/router.h>
 #include <pistache/client.h>
+#include <pistache/http.h>
 
 #include "../common/Logger.h"
 #include "JFJochStateMachine.h"
 #include "gen/api/DefaultApi.h"
-#include "pistache/include/pistache/http.h"
+
 
 class JFJochBrokerHttp : public org::openapitools::server::api::DefaultApi {
     Logger logger{"JFJochBroker"};

broker/README.md

@@ -15,7 +15,13 @@ Till this happens, it is recommended to go through example files in the [etc/](.
 ## Setting up a local test for Jungfraujoch
 For development, it is possible to setup a local installation of Jungfraujoch. 
 This will work without FPGA installed in the computer and allows to test Jungfraujoch software layer, including
-ZeroMQ streaming and file writing. There are few necessary steps:
+ZeroMQ streaming and file writing. 
+
+The workflow simulates FPGA behavior, by running high-level synthesis code on the CPU - the performance is therefore 
+very low, as fixed-point calculations have large performance penalty on CPU. In the CPU simulation mode, one can simulate 
+using only a single FPGA device. 
+
+To run the test:
 
 ### Compile Jungfraujoch with frontend
 ```
@@ -38,6 +44,7 @@ Start writer:
 cd build/writer
 ./jfjoch_writer tcp://127.0.0.1:5500
 ```
+
 ### Run tests
 To run test a Python script is provided:
 ```
@@ -45,3 +52,7 @@ cd tests/test_data
 python jfjoch_broker_test.py
 ```
 The script will initialize Jungfraujoch, import test image and start data collection.
+
+### Expected result
+You can observe online data analysis by opening the following web page: [http://localhost:5232](http://localhost:5232).
+Also in the `build/writer` subdirectory a dataset with images should be written.

broker/gen/model/Preview_settings.cpp

@@ -30,6 +30,8 @@ Preview_settings::Preview_settings()
     m_Jpeg_qualityIsSet = false;
     m_Show_indexed = false;
     m_Show_indexedIsSet = false;
+    m_Resolution_ring = 0.0f;
+    m_Resolution_ringIsSet = false;
     
 }
 
@@ -90,7 +92,26 @@ bool Preview_settings::validate(std::stringstream& msg, const std::string& pathP
         }
 
     }
+             
+    if (resolutionRingIsSet())
+    {
+        const float& value = m_Resolution_ring;
+        const std::string currentValuePath = _pathPrefix + ".resolutionRing";
+                
         
+        if (value < static_cast<float>(0.1))
+        {
+            success = false;
+            msg << currentValuePath << ": must be greater than or equal to 0.1;";
+        }
+        if (value > static_cast<float>(100.0))
+        {
+            success = false;
+            msg << currentValuePath << ": must be less than or equal to 100.0;";
+        }
+
+    }
+    
     return success;
 }
 
@@ -112,7 +133,10 @@ bool Preview_settings::operator==(const Preview_settings& rhs) const
     ((!jpegQualityIsSet() && !rhs.jpegQualityIsSet()) || (jpegQualityIsSet() && rhs.jpegQualityIsSet() && getJpegQuality() == rhs.getJpegQuality())) &&
     
     
-    ((!showIndexedIsSet() && !rhs.showIndexedIsSet()) || (showIndexedIsSet() && rhs.showIndexedIsSet() && isShowIndexed() == rhs.isShowIndexed()))
+    ((!showIndexedIsSet() && !rhs.showIndexedIsSet()) || (showIndexedIsSet() && rhs.showIndexedIsSet() && isShowIndexed() == rhs.isShowIndexed())) &&
+    
+    
+    ((!resolutionRingIsSet() && !rhs.resolutionRingIsSet()) || (resolutionRingIsSet() && rhs.resolutionRingIsSet() && getResolutionRing() == rhs.getResolutionRing()))
     
     ;
 }
@@ -134,6 +158,8 @@ void to_json(nlohmann::json& j, const Preview_settings& o)
         j["jpeg_quality"] = o.m_Jpeg_quality;
     if(o.showIndexedIsSet())
         j["show_indexed"] = o.m_Show_indexed;
+    if(o.resolutionRingIsSet())
+        j["resolution_ring"] = o.m_Resolution_ring;
     
 }
 
@@ -160,6 +186,11 @@ void from_json(const nlohmann::json& j, Preview_settings& o)
         j.at("show_indexed").get_to(o.m_Show_indexed);
         o.m_Show_indexedIsSet = true;
     } 
+    if(j.find("resolution_ring") != j.end())
+    {
+        j.at("resolution_ring").get_to(o.m_Resolution_ring);
+        o.m_Resolution_ringIsSet = true;
+    } 
     
 }
 
@@ -239,6 +270,23 @@ void Preview_settings::unsetShow_indexed()
 {
     m_Show_indexedIsSet = false;
 }
+float Preview_settings::getResolutionRing() const
+{
+    return m_Resolution_ring;
+}
+void Preview_settings::setResolutionRing(float const value)
+{
+    m_Resolution_ring = value;
+    m_Resolution_ringIsSet = true;
+}
+bool Preview_settings::resolutionRingIsSet() const
+{
+    return m_Resolution_ringIsSet;
+}
+void Preview_settings::unsetResolution_ring()
+{
+    m_Resolution_ringIsSet = false;
+}
 
 
 } // namespace org::openapitools::server::model

broker/gen/model/Preview_settings.h

@@ -90,6 +90,13 @@ public:
     void setShowIndexed(bool const value);
     bool showIndexedIsSet() const;
     void unsetShow_indexed();
+    /// <summary>
+    /// 
+    /// </summary>
+    float getResolutionRing() const;
+    void setResolutionRing(float const value);
+    bool resolutionRingIsSet() const;
+    void unsetResolution_ring();
 
     friend void to_json(nlohmann::json& j, const Preview_settings& o);
     friend void from_json(const nlohmann::json& j, Preview_settings& o);
@@ -104,6 +111,8 @@ protected:
     bool m_Jpeg_qualityIsSet;
     bool m_Show_indexed;
     bool m_Show_indexedIsSet;
+    float m_Resolution_ring;
+    bool m_Resolution_ringIsSet;
     
 };
 

broker/jfjoch_api.yaml

@@ -623,7 +623,11 @@ components:
         show_indexed:
           type: boolean
           description: "Preview indexed images only"
-
+        resolution_ring:
+          type: number
+          format: float
+          minimum: 0.1
+          maximum: 100.0
     error_message:
       type: object
       required:

cmake/FindZeroMQ.cmake

@@ -1,27 +0,0 @@
-#From: https://github.com/zeromq/cppzmq/
-set(PKG_CONFIG_USE_CMAKE_PREFIX_PATH ON)
-find_package(PkgConfig)
-pkg_check_modules(PC_LIBZMQ QUIET libzmq)
-
-set(ZeroMQ_VERSION ${PC_LIBZMQ_VERSION})
-find_library(ZeroMQ_LIBRARY NAMES libzmq.so libzmq.dylib libzmq.dll
-        PATHS ${PC_LIBZMQ_LIBDIR} ${PC_LIBZMQ_LIBRARY_DIRS})
-find_library(ZeroMQ_STATIC_LIBRARY NAMES libzmq-static.a libzmq.a libzmq.dll.a
-        PATHS ${PC_LIBZMQ_LIBDIR} ${PC_LIBZMQ_LIBRARY_DIRS})
-
-if(ZeroMQ_LIBRARY OR ZeroMQ_STATIC_LIBRARY)
-    set(ZeroMQ_FOUND ON)
-endif()
-
-if (TARGET libzmq)
-    # avoid errors defining targets twice
-    return()
-endif()
-
-add_library(libzmq SHARED IMPORTED)
-set_property(TARGET libzmq PROPERTY INTERFACE_INCLUDE_DIRECTORIES ${PC_LIBZMQ_INCLUDE_DIRS})
-set_property(TARGET libzmq PROPERTY IMPORTED_LOCATION ${ZeroMQ_LIBRARY})
-
-add_library(libzmq-static STATIC IMPORTED ${PC_LIBZMQ_INCLUDE_DIRS})
-set_property(TARGET libzmq-static PROPERTY INTERFACE_INCLUDE_DIRECTORIES ${PC_LIBZMQ_INCLUDE_DIRS})
-set_property(TARGET libzmq-static PROPERTY IMPORTED_LOCATION ${ZeroMQ_STATIC_LIBRARY})

common/CMakeLists.txt

@@ -16,8 +16,10 @@ EXECUTE_PROCESS(COMMAND
         OUTPUT_VARIABLE GIT_DATE
         ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
 
-MESSAGE(STATUS "Git SHA1: ${GIT_SHA1}")
-MESSAGE(STATUS "Git date: ${GIT_DATE}")
+FILE(STRINGS ../VERSION PACKAGE_VERSION)
+MESSAGE(STATUS "Jungfraujoch git SHA1: ${GIT_SHA1}")
+MESSAGE(STATUS "Jungfraujoch git date: ${GIT_DATE}")
+MESSAGE(STATUS "Jungfraujoch version: ${PACKAGE_VERSION}")
 
 CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/GitInfo.cpp.in" "${CMAKE_CURRENT_BINARY_DIR}/GitInfo.cpp" @ONLY)
 

common/GitInfo.cpp.in

@@ -9,3 +9,7 @@ std::string jfjoch_git_sha1() {
 std::string jfjoch_git_date() {
     return "@GIT_DATE@";
 }
+
+std::string jfjoch_version() {
+    return "@PACKAGE_VERSION@";
+}

common/GitInfo.h

@@ -7,5 +7,6 @@
 
 std::string jfjoch_git_sha1();
 std::string jfjoch_git_date();
+std::string jfjoch_version();
 
 #endif //JUNGFRAUJOCH_GITINFO_H

common/Logger.cpp

@@ -16,7 +16,10 @@ Logger::Logger(const std::string &service_name, const std::string &file_name) {
         sinks.push_back(std::make_shared<spdlog::sinks::daily_file_sink_mt>(file_name, 23, 59));
 
     spdlog_logger = std::make_shared<spdlog::logger>(service_name, std::begin(sinks), std::end(sinks));
-    spdlog_logger->info("Git sha {} ({})", jfjoch_git_sha1().substr(0, 6), jfjoch_git_date());
+    if (jfjoch_git_sha1().empty())
+        spdlog_logger->info("Version {}", jfjoch_version());
+    else
+        spdlog_logger->info("Version {} (git {} {})", jfjoch_version(), jfjoch_git_sha1().substr(0, 6), jfjoch_git_date());
 }
 
 void Logger::ErrorException(const std::exception &e) {

compression/CMakeLists.txt

@@ -4,8 +4,8 @@ ADD_LIBRARY(Compression STATIC
         bitshuffle/bitshuffle.c
         bitshuffle/bitshuffle_core.c
         bitshuffle/iochain.c
-        bitshuffle_hperf/src/bitshuffle.c
-        bitshuffle_hperf/src/bitshuffle.h
+        bitshuffle_hperf/bitshuffle.c
+        bitshuffle_hperf/bitshuffle.h
         JFJochZstdCompressor.cpp
         JFJochZstdCompressor.h
         JFJochCompressor.cpp
@@ -14,10 +14,7 @@ ADD_LIBRARY(Compression STATIC
         MaxCompressedSize.cpp
         MaxCompressedSize.h)
 
-SET(ZSTD_LEGACY_SUPPORT OFF)
-SET(ZSTD_MULTITHREAD_SUPPORT OFF)
 
 TARGET_COMPILE_DEFINITIONS(Compression PUBLIC -DZSTD_SUPPORT -DUSE_ZSTD)
 TARGET_LINK_LIBRARIES(Compression libzstd_static)
 TARGET_INCLUDE_DIRECTORIES(Compression PUBLIC . zstd/lib)
-ADD_SUBDIRECTORY(zstd/build/cmake)

compression/JFJochCompressor.cpp

@@ -5,7 +5,7 @@
 #include <stdexcept>
 #include <cstring>
 #include <bitshuffle/bitshuffle_internals.h>
-#include <bitshuffle_hperf/src/bitshuffle.h>
+#include <bitshuffle_hperf/bitshuffle.h>
 #include <zstd.h>
 #include <lz4/lz4.h>
 

compression/bitshuffle_hperf/LICENSE-APACHE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2023 Kal Conley
+
+   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.

compression/bitshuffle_hperf/bitshuffle.h

@@ -0,0 +1,68 @@
+/* SPDX-License-Identifier: MIT OR Apache-2.0 */
+/* Copyright (c) 2023 Kal Conley
+ */
+#ifndef BITSHUFFLE_H_
+#define BITSHUFFLE_H_
+
+#include <stddef.h>
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+/* Transpose bits for compression.
+ *
+ * This function performs Bitshuffle transposition of a single block. The block
+ * size in bytes is given by the product of `size` and `elem_size`.
+ *
+ * If required, the `scratch` argument must point to a buffer that the function
+ * uses for scratch purposes. The size of this buffer is given by the block
+ * size.
+ *
+ * On success, the function returns 0; otherwise, -1 is returned to indicate an
+ * error. In case of error, the memory pointed to by `out` and `scratch` is left
+ * unmodified.
+ *
+ * Pointer arguments of this function have C99 `restrict` semantics. If the
+ * `out`, `in`, or `scratch` buffers overlap, the behavior is undefined.
+ *
+ * Errors
+ * ------
+ * The function returns -1 to indicate an error if:
+ *
+ * - The `scratch` argument is `NULL` and a scratch buffer is required for the
+ *   specified element size.
+ * - The `size` argument is not a multiple of 8.
+ */
+int bitshuf_encode_block(char* out, const char* in, char* scratch, size_t size, size_t elem_size);
+
+/* Untranspose bits after decompression.
+ *
+ * This function performs the inverse of `bitshuf_encode_block()`.
+ *
+ * If required, the `scratch` argument must point to a buffer that the function
+ * uses for scratch purposes. The size of this buffer is given by the block
+ * size.
+ *
+ * On success, the function returns 0; otherwise, -1 is returned to indicate an
+ * error. In case of error, the memory pointed to by `out` and `scratch` is left
+ * unmodified.
+ *
+ * Pointer arguments of this function have C99 `restrict` semantics. If the
+ * `out`, `in`, or `scratch` buffers overlap, the behavior is undefined.
+ *
+ * Errors
+ * ------
+ * The function returns -1 to indicate an error if:
+ *
+ * - The `scratch` argument is `NULL` and a scratch buffer is required for the
+ *   specified element size.
+ * - The `size` argument is not a multiple of 8.
+ */
+int bitshuf_decode_block(char* out, const char* in, char* scratch, size_t size, size_t elem_size);
+
+#if defined(__cplusplus)
+} /* extern "C" */
+#endif
+
+#endif /* BITSHUFFLE_H_ */

detector_control/CMakeLists.txt

@@ -1,4 +1,3 @@
-ADD_SUBDIRECTORY(slsDetectorPackage)
 INSTALL(TARGETS sls_detector_put sls_detector_get RUNTIME)
 
 ADD_LIBRARY(JFJochDetector STATIC DetectorWrapper.cpp DetectorWrapper.h)

fpga/hls/spot_finder_mask.cpp

@@ -66,10 +66,12 @@ void spot_finder_mask(STREAM_768 &data_in,
             ap_uint<5> col = i % 32;
 
             for (int j = 0; j < 32; j++) {
-                if ((line == 255)
+                if ((line == 0)
+                    || (line == 255)
                     || (line == 256)
-                    || (((col == 7) || (col == 15) || (col == 23)) && (j == 31))
-                    || (((col == 8) || (col == 16) || (col == 24)) && (j ==  0))
+                    || (line == 511)
+                    || (((col == 7) || (col == 15) || (col == 23) || (col == 31)) && (j == 31))
+                    || (((col == 0) || (col == 8) || (col == 16) || (col == 24)) && (j ==  0))
                     || (pixel_val[j] == INT24_MIN)
                     || (pixel_val[j] == INT24_MAX)
                     || ((d[j] != 0) && (d[j] < min_d_value))

fpga/pcie_driver/pack.sh

@@ -3,4 +3,4 @@
 GIT_SHA1=`git describe --match=NeVeRmAtCh --always --abbrev=8`
 RELEASE_LEVEL=`grep "#define JFJOCH_FPGA_RELEASE" jfjoch_fpga.h | awk -F"0x" '{print $2}'`
 
-tar cvzf jfjoch_driver_rel${RELEASE_LEVEL}_${GIT_SHA1}.tar.gz *.c *.h README.md Makefile dkms.conf install_dkms.sh >/dev/null 2>&1
+tar cvzf jfjoch_driver.tar.gz *.c *.h README.md Makefile dkms.conf install_dkms.sh >/dev/null 2>&1

fpga/scripts/setup_action.sh

@@ -33,7 +33,12 @@ ACTION_TYPE=`grep "#define JFJOCH_FPGA_MAGIC" ${SRC_DIR}/pcie_driver/jfjoch_fpga
 RELEASE_LEVEL=`grep "#define JFJOCH_FPGA_RELEASE" ${SRC_DIR}/pcie_driver/jfjoch_fpga.h | awk -F"0x" '{print $2}'`
 MAX_MODULES_FPGA=`grep "#define MAX_MODULES_FPGA" ${SRC_DIR}/pcie_driver/jfjoch_fpga.h  |tr -s " " |cut -f3 -d" "`
 
-GIT_SHA1=`git describe --match=NeVeRmAtCh --always --abbrev=8`
+git describe --match=NeVeRmAtCh --always --abbrev=8
+if [ $? -eq 0 ]; then
+  GIT_SHA1=`git describe --match=NeVeRmAtCh --always --abbrev=8`
+else
+  GIT_SHA1=0
+fi
 
 SRC="define JFJOCH_MAGIC 32'h.*"
 DST="define JFJOCH_MAGIC 32'h${ACTION_TYPE}"

fpga/scripts/synth_and_impl.tcl

@@ -23,7 +23,7 @@ if {$part eq {xcvu35p-fsvh2104-2-e}} {
     set interface "SPIx8"
 }
 
-set bitstream_name jfjoch_${flow}_${fpga_name}_rel@RELEASE_LEVEL@_@GIT_SHA1@
+set bitstream_name jfjoch_fpga_${flow}
 
 puts "Part $part Flash size ${fpga_flash_size} Flow ${flow} Image name ${bitstream_name}"
 set log_file synth.log

frame_serialize/CBORStream2Deserializer.cpp

@@ -1,7 +1,6 @@
 // Copyright (2019-2023) Paul Scherrer Institute
 
 #include "CBORStream2Deserializer.h"
-#include "tinycbor/src/cbor.h"
 #include "CborErr.h"
 #include "CborUtil.h"
 #include <nlohmann/json.hpp>

frame_serialize/CBORStream2Deserializer.h

@@ -9,7 +9,7 @@
 #include <memory>
 
 #include "../common/SpotToSave.h"
-#include "tinycbor/src/cbor.h"
+#include "tinycbor/cbor.h"
 #include "JFJochMessages.h"
 #include <mutex>
 

frame_serialize/CBORStream2Serializer.cpp

@@ -1,7 +1,7 @@
 // Copyright (2019-2023) Paul Scherrer Institute
 
 #include "CBORStream2Serializer.h"
-#include "tinycbor/src/cbor.h"
+#include "tinycbor/cbor.h"
 #include "CborErr.h"
 #include "CborUtil.h"
 #include <nlohmann/json.hpp>

frame_serialize/CMakeLists.txt

@@ -1,16 +1,21 @@
+ADD_LIBRARY(tinycbor STATIC
+        tinycbor/cborparser_dup_string.c
+        tinycbor/cborencoder.c
+        tinycbor/cborencoder_close_container_checked.c
+        tinycbor/cborencoder_float.c
+        tinycbor/cborparser.c
+        tinycbor/cborparser_float.c
+        tinycbor/cborpretty.c
+        tinycbor/cborerrorstrings.c
+        tinycbor/cbor.h
+        tinycbor/tinycbor-version.h)
+
 ADD_LIBRARY(CBORStream2FrameSerialize STATIC
         CBORStream2Serializer.cpp CBORStream2Serializer.h
         CBORStream2Deserializer.cpp CBORStream2Deserializer.h
-        tinycbor/src/cborparser_dup_string.c
-        tinycbor/src/cborencoder.c
-        tinycbor/src/cborencoder_close_container_checked.c
-        tinycbor/src/cborencoder_float.c
-        tinycbor/src/cborparser.c
-        tinycbor/src/cborparser_float.c
-        tinycbor/src/cborpretty.c
-        tinycbor/src/cborerrorstrings.c
-        tinycbor/src/cbor.h
-        tinycbor/src/tinycbor-version.h CborErr.h CborUtil.h JFJochMessages.h)
+        CborErr.h CborUtil.h JFJochMessages.h)
+
+TARGET_LINK_LIBRARIES(CBORStream2FrameSerialize tinycbor)
 
 ADD_LIBRARY(ImagePusher STATIC
         ImagePusher.cpp ImagePusher.h

frame_serialize/CborErr.h

@@ -3,7 +3,7 @@
 #ifndef JUNGFRAUJOCH_CBORERR_H
 #define JUNGFRAUJOCH_CBORERR_H
 
-#include "tinycbor/src/cbor.h"
+#include "tinycbor/cbor.h"
 #include "../common/JFJochException.h"
 
 inline void cborErr(CborError err) {

frame_serialize/CborUtil.h

@@ -3,7 +3,7 @@
 #ifndef JUNGFRAUJOCH_CBORUTIL_H
 #define JUNGFRAUJOCH_CBORUTIL_H
 
-#include "tinycbor/src/cbor.h"
+#include "tinycbor/cbor.h"
 
 constexpr const CborTag TagMultiDimArray      = 40;
 constexpr const CborTag TagDECTRISCompression = 56500;

frame_serialize/tinycbor/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Intel Corporation
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

frame_serialize/tinycbor/cbor.h

@@ -0,0 +1,724 @@
+/****************************************************************************
+**
+** Copyright (C) 2021 Intel Corporation
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+** copies of the Software, and to permit persons to whom the Software is
+** furnished to do so, subject to the following conditions:
+**
+** The above copyright notice and this permission notice shall be included in
+** all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+** OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+** THE SOFTWARE.
+**
+****************************************************************************/
+
+#ifndef CBOR_H
+#define CBOR_H
+
+#ifndef assert
+#include <assert.h>
+#endif
+#include <limits.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+#include <stdio.h>
+
+#include "tinycbor-version.h"
+
+#define TINYCBOR_VERSION            ((TINYCBOR_VERSION_MAJOR << 16) | (TINYCBOR_VERSION_MINOR << 8) | TINYCBOR_VERSION_PATCH)
+
+#ifdef __cplusplus
+extern "C" {
+#else
+#include <stdbool.h>
+#endif
+
+#ifndef SIZE_MAX
+/* Some systems fail to define SIZE_MAX in <stdint.h>, even though C99 requires it...
+ * Conversion from signed to unsigned is defined in 6.3.1.3 (Signed and unsigned integers) p2,
+ * which says: "the value is converted by repeatedly adding or subtracting one more than the
+ * maximum value that can be represented in the new type until the value is in the range of the
+ * new type."
+ * So -1 gets converted to size_t by adding SIZE_MAX + 1, which results in SIZE_MAX.
+ */
+#  define SIZE_MAX ((size_t)-1)
+#endif
+
+#ifndef CBOR_API
+#  define CBOR_API
+#endif
+#ifndef CBOR_PRIVATE_API
+#  define CBOR_PRIVATE_API
+#endif
+#ifndef CBOR_INLINE_API
+#  if defined(__cplusplus)
+#    define CBOR_INLINE inline
+#    define CBOR_INLINE_API inline
+#  else
+#    define CBOR_INLINE_API static CBOR_INLINE
+#    if defined(_MSC_VER)
+#      define CBOR_INLINE __inline
+#    elif defined(__GNUC__)
+#      define CBOR_INLINE __inline__
+#    elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+#      define CBOR_INLINE inline
+#    else
+#      define CBOR_INLINE
+#    endif
+#  endif
+#endif
+
+typedef enum CborType {
+    CborIntegerType     = 0x00,
+    CborByteStringType  = 0x40,
+    CborTextStringType  = 0x60,
+    CborArrayType       = 0x80,
+    CborMapType         = 0xa0,
+    CborTagType         = 0xc0,
+    CborSimpleType      = 0xe0,
+    CborBooleanType     = 0xf5,
+    CborNullType        = 0xf6,
+    CborUndefinedType   = 0xf7,
+    CborHalfFloatType   = 0xf9,
+    CborFloatType       = 0xfa,
+    CborDoubleType      = 0xfb,
+
+    CborInvalidType     = 0xff              /* equivalent to the break byte, so it will never be used */
+} CborType;
+
+typedef uint64_t CborTag;
+typedef enum CborKnownTags {
+    CborDateTimeStringTag          = 0,
+    CborUnixTime_tTag              = 1,
+    CborPositiveBignumTag          = 2,
+    CborNegativeBignumTag          = 3,
+    CborDecimalTag                 = 4,
+    CborBigfloatTag                = 5,
+    CborCOSE_Encrypt0Tag           = 16,
+    CborCOSE_Mac0Tag               = 17,
+    CborCOSE_Sign1Tag              = 18,
+    CborExpectedBase64urlTag       = 21,
+    CborExpectedBase64Tag          = 22,
+    CborExpectedBase16Tag          = 23,
+    CborEncodedCborTag             = 24,
+    CborUrlTag                     = 32,
+    CborBase64urlTag               = 33,
+    CborBase64Tag                  = 34,
+    CborRegularExpressionTag       = 35,
+    CborMimeMessageTag             = 36,
+    CborCOSE_EncryptTag            = 96,
+    CborCOSE_MacTag                = 97,
+    CborCOSE_SignTag               = 98,
+    CborSignatureTag               = 55799
+} CborKnownTags;
+
+/* #define the constants so we can check with #ifdef */
+#define CborDateTimeStringTag CborDateTimeStringTag
+#define CborUnixTime_tTag CborUnixTime_tTag
+#define CborPositiveBignumTag CborPositiveBignumTag
+#define CborNegativeBignumTag CborNegativeBignumTag
+#define CborDecimalTag CborDecimalTag
+#define CborBigfloatTag CborBigfloatTag
+#define CborCOSE_Encrypt0Tag CborCOSE_Encrypt0Tag
+#define CborCOSE_Mac0Tag CborCOSE_Mac0Tag
+#define CborCOSE_Sign1Tag CborCOSE_Sign1Tag
+#define CborExpectedBase64urlTag CborExpectedBase64urlTag
+#define CborExpectedBase64Tag CborExpectedBase64Tag
+#define CborExpectedBase16Tag CborExpectedBase16Tag
+#define CborEncodedCborTag CborEncodedCborTag
+#define CborUrlTag CborUrlTag
+#define CborBase64urlTag CborBase64urlTag
+#define CborBase64Tag CborBase64Tag
+#define CborRegularExpressionTag CborRegularExpressionTag
+#define CborMimeMessageTag CborMimeMessageTag
+#define CborCOSE_EncryptTag CborCOSE_EncryptTag
+#define CborCOSE_MacTag CborCOSE_MacTag
+#define CborCOSE_SignTag CborCOSE_SignTag
+#define CborSignatureTag CborSignatureTag
+
+/* Error API */
+
+typedef enum CborError {
+    CborNoError = 0,
+
+    /* errors in all modes */
+    CborUnknownError,
+    CborErrorUnknownLength,         /* request for length in array, map, or string with indeterminate length */
+    CborErrorAdvancePastEOF,
+    CborErrorIO,
+
+    /* parser errors streaming errors */
+    CborErrorGarbageAtEnd = 256,
+    CborErrorUnexpectedEOF,
+    CborErrorUnexpectedBreak,
+    CborErrorUnknownType,           /* can only happen in major type 7 */
+    CborErrorIllegalType,           /* type not allowed here */
+    CborErrorIllegalNumber,
+    CborErrorIllegalSimpleType,     /* types of value less than 32 encoded in two bytes */
+    CborErrorNoMoreStringChunks,
+
+    /* parser errors in strict mode parsing only */
+    CborErrorUnknownSimpleType = 512,
+    CborErrorUnknownTag,
+    CborErrorInappropriateTagForType,
+    CborErrorDuplicateObjectKeys,
+    CborErrorInvalidUtf8TextString,
+    CborErrorExcludedType,
+    CborErrorExcludedValue,
+    CborErrorImproperValue,
+    CborErrorOverlongEncoding,
+    CborErrorMapKeyNotString,
+    CborErrorMapNotSorted,
+    CborErrorMapKeysNotUnique,
+
+    /* encoder errors */
+    CborErrorTooManyItems = 768,
+    CborErrorTooFewItems,
+
+    /* internal implementation errors */
+    CborErrorDataTooLarge = 1024,
+    CborErrorNestingTooDeep,
+    CborErrorUnsupportedType,
+    CborErrorUnimplementedValidation,
+
+    /* errors in converting to JSON */
+    CborErrorJsonObjectKeyIsAggregate = 1280,
+    CborErrorJsonObjectKeyNotString,
+    CborErrorJsonNotImplemented,
+
+    CborErrorOutOfMemory = (int) (~0U / 2 + 1),
+    CborErrorInternalError = (int) (~0U / 2)    /* INT_MAX on two's complement machines */
+} CborError;
+
+CBOR_API const char *cbor_error_string(CborError error);
+
+/* Encoder API */
+
+typedef enum CborEncoderAppendType
+{
+    CborEncoderAppendCborData = 0,
+    CborEncoderAppendStringData = 1
+} CborEncoderAppendType;
+
+typedef CborError (*CborEncoderWriteFunction)(void *, const void *, size_t, CborEncoderAppendType);
+
+enum CborEncoderFlags
+{
+    CborIteratorFlag_WriterFunction         = 0x01,
+    CborIteratorFlag_ContainerIsMap_        = 0x20
+};
+
+struct CborEncoder
+{
+    union {
+        uint8_t *ptr;
+        ptrdiff_t bytes_needed;
+        CborEncoderWriteFunction writer;
+    } data;
+    uint8_t *end;
+    size_t remaining;
+    int flags;
+};
+typedef struct CborEncoder CborEncoder;
+
+static const size_t CborIndefiniteLength = SIZE_MAX;
+
+#ifndef CBOR_NO_ENCODER_API
+CBOR_API void cbor_encoder_init(CborEncoder *encoder, uint8_t *buffer, size_t size, int flags);
+CBOR_API void cbor_encoder_init_writer(CborEncoder *encoder, CborEncoderWriteFunction writer, void *);
+CBOR_API CborError cbor_encode_uint(CborEncoder *encoder, uint64_t value);
+CBOR_API CborError cbor_encode_int(CborEncoder *encoder, int64_t value);
+CBOR_API CborError cbor_encode_negative_int(CborEncoder *encoder, uint64_t absolute_value);
+CBOR_API CborError cbor_encode_simple_value(CborEncoder *encoder, uint8_t value);
+CBOR_API CborError cbor_encode_tag(CborEncoder *encoder, CborTag tag);
+CBOR_API CborError cbor_encode_text_string(CborEncoder *encoder, const char *string, size_t length);
+CBOR_INLINE_API CborError cbor_encode_text_stringz(CborEncoder *encoder, const char *string)
+{ return cbor_encode_text_string(encoder, string, strlen(string)); }
+CBOR_API CborError cbor_encode_byte_string(CborEncoder *encoder, const uint8_t *string, size_t length);
+CBOR_API CborError cbor_encode_floating_point(CborEncoder *encoder, CborType fpType, const void *value);
+
+CBOR_INLINE_API CborError cbor_encode_boolean(CborEncoder *encoder, bool value)
+{ return cbor_encode_simple_value(encoder, (int)value - 1 + (CborBooleanType & 0x1f)); }
+CBOR_INLINE_API CborError cbor_encode_null(CborEncoder *encoder)
+{ return cbor_encode_simple_value(encoder, CborNullType & 0x1f); }
+CBOR_INLINE_API CborError cbor_encode_undefined(CborEncoder *encoder)
+{ return cbor_encode_simple_value(encoder, CborUndefinedType & 0x1f); }
+
+CBOR_INLINE_API CborError cbor_encode_half_float(CborEncoder *encoder, const void *value)
+{ return cbor_encode_floating_point(encoder, CborHalfFloatType, value); }
+CBOR_API CborError cbor_encode_float_as_half_float(CborEncoder *encoder, float value);
+CBOR_INLINE_API CborError cbor_encode_float(CborEncoder *encoder, float value)
+{ return cbor_encode_floating_point(encoder, CborFloatType, &value); }
+CBOR_INLINE_API CborError cbor_encode_double(CborEncoder *encoder, double value)
+{ return cbor_encode_floating_point(encoder, CborDoubleType, &value); }
+
+CBOR_API CborError cbor_encoder_create_array(CborEncoder *parentEncoder, CborEncoder *arrayEncoder, size_t length);
+CBOR_API CborError cbor_encoder_create_map(CborEncoder *parentEncoder, CborEncoder *mapEncoder, size_t length);
+CBOR_API CborError cbor_encoder_close_container(CborEncoder *parentEncoder, const CborEncoder *containerEncoder);
+CBOR_API CborError cbor_encoder_close_container_checked(CborEncoder *parentEncoder, const CborEncoder *containerEncoder);
+
+CBOR_INLINE_API uint8_t *_cbor_encoder_get_buffer_pointer(const CborEncoder *encoder)
+{
+    return encoder->data.ptr;
+}
+
+CBOR_INLINE_API size_t cbor_encoder_get_buffer_size(const CborEncoder *encoder, const uint8_t *buffer)
+{
+    return (size_t)(encoder->data.ptr - buffer);
+}
+
+CBOR_INLINE_API size_t cbor_encoder_get_extra_bytes_needed(const CborEncoder *encoder)
+{
+    return encoder->end ? 0 : (size_t)encoder->data.bytes_needed;
+}
+#endif /* CBOR_NO_ENCODER_API */
+
+/* Parser API */
+
+enum CborParserGlobalFlags
+{
+    CborParserFlag_ExternalSource           = 0x01
+};
+
+enum CborParserIteratorFlags
+{
+    /* used for all types, but not during string chunk iteration
+     * (values are static-asserted, don't change) */
+    CborIteratorFlag_IntegerValueIs64Bit    = 0x01,
+    CborIteratorFlag_IntegerValueTooLarge   = 0x02,
+
+    /* used only for CborIntegerType */
+    CborIteratorFlag_NegativeInteger        = 0x04,
+
+    /* used only during string iteration */
+    CborIteratorFlag_BeforeFirstStringChunk = 0x04,
+    CborIteratorFlag_IteratingStringChunks  = 0x08,
+
+    /* used for arrays, maps and strings, including during chunk iteration */
+    CborIteratorFlag_UnknownLength          = 0x10,
+
+    /* used for maps, but must be kept for all types
+     * (ContainerIsMap value must be CborMapType - CborArrayType) */
+    CborIteratorFlag_ContainerIsMap         = 0x20,
+    CborIteratorFlag_NextIsMapKey           = 0x40
+};
+
+struct CborValue;
+struct CborParserOperations
+{
+    bool (*can_read_bytes)(void *token, size_t len);
+    void *(*read_bytes)(void *token, void *dst, size_t offset, size_t len);
+    void (*advance_bytes)(void *token, size_t len);
+    CborError (*transfer_string)(void *token, const void **userptr, size_t offset, size_t len);
+};
+
+struct CborParser
+{
+    union {
+        const uint8_t *end;
+        const struct CborParserOperations *ops;
+    } source;
+    enum CborParserGlobalFlags flags;
+};
+typedef struct CborParser CborParser;
+
+struct CborValue
+{
+    const CborParser *parser;
+    union {
+        const uint8_t *ptr;
+        void *token;
+    } source;
+    uint32_t remaining;
+    uint16_t extra;
+    uint8_t type;
+    uint8_t flags;
+};
+typedef struct CborValue CborValue;
+
+#ifndef CBOR_NO_PARSER_API
+CBOR_API CborError cbor_parser_init(const uint8_t *buffer, size_t size, uint32_t flags, CborParser *parser, CborValue *it);
+CBOR_API CborError cbor_parser_init_reader(const struct CborParserOperations *ops, CborParser *parser, CborValue *it, void *token);
+
+CBOR_API CborError cbor_value_validate_basic(const CborValue *it);
+
+CBOR_INLINE_API bool cbor_value_at_end(const CborValue *it)
+{ return it->remaining == 0; }
+CBOR_INLINE_API const uint8_t *cbor_value_get_next_byte(const CborValue *it)
+{ return it->source.ptr; }
+CBOR_API CborError cbor_value_reparse(CborValue *it);
+CBOR_API CborError cbor_value_advance_fixed(CborValue *it);
+CBOR_API CborError cbor_value_advance(CborValue *it);
+CBOR_INLINE_API bool cbor_value_is_container(const CborValue *it)
+{ return it->type == CborArrayType || it->type == CborMapType; }
+CBOR_API CborError cbor_value_enter_container(const CborValue *it, CborValue *recursed);
+CBOR_API CborError cbor_value_leave_container(CborValue *it, const CborValue *recursed);
+
+CBOR_PRIVATE_API uint64_t _cbor_value_decode_int64_internal(const CborValue *value);
+CBOR_INLINE_API uint64_t _cbor_value_extract_int64_helper(const CborValue *value)
+{
+    return value->flags & CborIteratorFlag_IntegerValueTooLarge ?
+                _cbor_value_decode_int64_internal(value) : value->extra;
+}
+
+CBOR_INLINE_API bool cbor_value_is_valid(const CborValue *value)
+{ return value && value->type != CborInvalidType; }
+CBOR_INLINE_API CborType cbor_value_get_type(const CborValue *value)
+{ return (CborType)value->type; }
+
+/* Null & undefined type */
+CBOR_INLINE_API bool cbor_value_is_null(const CborValue *value)
+{ return value->type == CborNullType; }
+CBOR_INLINE_API bool cbor_value_is_undefined(const CborValue *value)
+{ return value->type == CborUndefinedType; }
+
+/* Booleans */
+CBOR_INLINE_API bool cbor_value_is_boolean(const CborValue *value)
+{ return value->type == CborBooleanType; }
+CBOR_INLINE_API CborError cbor_value_get_boolean(const CborValue *value, bool *result)
+{
+    assert(cbor_value_is_boolean(value));
+    *result = !!value->extra;
+    return CborNoError;
+}
+
+/* Simple types */
+CBOR_INLINE_API bool cbor_value_is_simple_type(const CborValue *value)
+{ return value->type == CborSimpleType; }
+CBOR_INLINE_API CborError cbor_value_get_simple_type(const CborValue *value, uint8_t *result)
+{
+    assert(cbor_value_is_simple_type(value));
+    *result = (uint8_t)value->extra;
+    return CborNoError;
+}
+
+/* Integers */
+CBOR_INLINE_API bool cbor_value_is_integer(const CborValue *value)
+{ return value->type == CborIntegerType; }
+CBOR_INLINE_API bool cbor_value_is_unsigned_integer(const CborValue *value)
+{ return cbor_value_is_integer(value) && (value->flags & CborIteratorFlag_NegativeInteger) == 0; }
+CBOR_INLINE_API bool cbor_value_is_negative_integer(const CborValue *value)
+{ return cbor_value_is_integer(value) && (value->flags & CborIteratorFlag_NegativeInteger); }
+
+CBOR_INLINE_API CborError cbor_value_get_raw_integer(const CborValue *value, uint64_t *result)
+{
+    assert(cbor_value_is_integer(value));
+    *result = _cbor_value_extract_int64_helper(value);
+    return CborNoError;
+}
+
+CBOR_INLINE_API CborError cbor_value_get_uint64(const CborValue *value, uint64_t *result)
+{
+    assert(cbor_value_is_unsigned_integer(value));
+    *result = _cbor_value_extract_int64_helper(value);
+    return CborNoError;
+}
+
+CBOR_INLINE_API CborError cbor_value_get_int64(const CborValue *value, int64_t *result)
+{
+    assert(cbor_value_is_integer(value));
+    *result = (int64_t) _cbor_value_extract_int64_helper(value);
+    if (value->flags & CborIteratorFlag_NegativeInteger)
+        *result = -*result - 1;
+    return CborNoError;
+}
+
+CBOR_INLINE_API CborError cbor_value_get_int(const CborValue *value, int *result)
+{
+    assert(cbor_value_is_integer(value));
+    *result = (int) _cbor_value_extract_int64_helper(value);
+    if (value->flags & CborIteratorFlag_NegativeInteger)
+        *result = -*result - 1;
+    return CborNoError;
+}
+
+CBOR_API CborError cbor_value_get_int64_checked(const CborValue *value, int64_t *result);
+CBOR_API CborError cbor_value_get_int_checked(const CborValue *value, int *result);
+
+CBOR_INLINE_API bool cbor_value_is_length_known(const CborValue *value)
+{ return (value->flags & CborIteratorFlag_UnknownLength) == 0; }
+
+/* Tags */
+CBOR_INLINE_API bool cbor_value_is_tag(const CborValue *value)
+{ return value->type == CborTagType; }
+CBOR_INLINE_API CborError cbor_value_get_tag(const CborValue *value, CborTag *result)
+{
+    assert(cbor_value_is_tag(value));
+    *result = _cbor_value_extract_int64_helper(value);
+    return CborNoError;
+}
+CBOR_API CborError cbor_value_skip_tag(CborValue *it);
+
+/* Strings */
+CBOR_INLINE_API bool cbor_value_is_byte_string(const CborValue *value)
+{ return value->type == CborByteStringType; }
+CBOR_INLINE_API bool cbor_value_is_text_string(const CborValue *value)
+{ return value->type == CborTextStringType; }
+
+CBOR_INLINE_API CborError cbor_value_get_string_length(const CborValue *value, size_t *length)
+{
+    uint64_t v;
+    assert(cbor_value_is_byte_string(value) || cbor_value_is_text_string(value));
+    if (!cbor_value_is_length_known(value))
+        return CborErrorUnknownLength;
+    v = _cbor_value_extract_int64_helper(value);
+    *length = (size_t)v;
+    if (*length != v)
+        return CborErrorDataTooLarge;
+    return CborNoError;
+}
+
+CBOR_PRIVATE_API CborError _cbor_value_copy_string(const CborValue *value, void *buffer,
+                                                   size_t *buflen, CborValue *next);
+CBOR_PRIVATE_API CborError _cbor_value_dup_string(const CborValue *value, void **buffer,
+                                                  size_t *buflen, CborValue *next);
+
+CBOR_API CborError cbor_value_calculate_string_length(const CborValue *value, size_t *length);
+
+CBOR_INLINE_API CborError cbor_value_copy_text_string(const CborValue *value, char *buffer,
+                                                      size_t *buflen, CborValue *next)
+{
+    assert(cbor_value_is_text_string(value));
+    return _cbor_value_copy_string(value, buffer, buflen, next);
+}
+CBOR_INLINE_API CborError cbor_value_copy_byte_string(const CborValue *value, uint8_t *buffer,
+                                                      size_t *buflen, CborValue *next)
+{
+    assert(cbor_value_is_byte_string(value));
+    return _cbor_value_copy_string(value, buffer, buflen, next);
+}
+
+CBOR_INLINE_API CborError cbor_value_dup_text_string(const CborValue *value, char **buffer,
+                                                     size_t *buflen, CborValue *next)
+{
+    assert(cbor_value_is_text_string(value));
+    return _cbor_value_dup_string(value, (void **)buffer, buflen, next);
+}
+CBOR_INLINE_API CborError cbor_value_dup_byte_string(const CborValue *value, uint8_t **buffer,
+                                                     size_t *buflen, CborValue *next)
+{
+    assert(cbor_value_is_byte_string(value));
+    return _cbor_value_dup_string(value, (void **)buffer, buflen, next);
+}
+
+CBOR_PRIVATE_API CborError _cbor_value_get_string_chunk_size(const CborValue *value, size_t *len);
+CBOR_INLINE_API CborError cbor_value_get_string_chunk_size(const CborValue *value, size_t *len)
+{
+    assert(value->flags & CborIteratorFlag_IteratingStringChunks);
+    return _cbor_value_get_string_chunk_size(value, len);
+}
+
+CBOR_INLINE_API bool cbor_value_string_iteration_at_end(const CborValue *value)
+{
+    size_t dummy;
+    return cbor_value_get_string_chunk_size(value, &dummy) == CborErrorNoMoreStringChunks;
+}
+
+CBOR_PRIVATE_API CborError _cbor_value_begin_string_iteration(CborValue *value);
+CBOR_INLINE_API CborError cbor_value_begin_string_iteration(CborValue *value)
+{
+    assert(cbor_value_is_text_string(value) || cbor_value_is_byte_string(value));
+    assert(!(value->flags & CborIteratorFlag_IteratingStringChunks));
+    return _cbor_value_begin_string_iteration(value);
+}
+
+CBOR_PRIVATE_API CborError _cbor_value_finish_string_iteration(CborValue *value);
+CBOR_INLINE_API CborError cbor_value_finish_string_iteration(CborValue *value)
+{
+    assert(cbor_value_string_iteration_at_end(value));
+    return _cbor_value_finish_string_iteration(value);
+}
+
+CBOR_PRIVATE_API CborError _cbor_value_get_string_chunk(const CborValue *value, const void **bufferptr,
+                                                        size_t *len, CborValue *next);
+CBOR_INLINE_API CborError cbor_value_get_text_string_chunk(const CborValue *value, const char **bufferptr,
+                                                           size_t *len, CborValue *next)
+{
+    assert(cbor_value_is_text_string(value));
+    return _cbor_value_get_string_chunk(value, (const void **)bufferptr, len, next);
+}
+CBOR_INLINE_API CborError cbor_value_get_byte_string_chunk(const CborValue *value, const uint8_t **bufferptr,
+                                                           size_t *len, CborValue *next)
+{
+    assert(cbor_value_is_byte_string(value));
+    return _cbor_value_get_string_chunk(value, (const void **)bufferptr, len, next);
+}
+
+CBOR_API CborError cbor_value_text_string_equals(const CborValue *value, const char *string, bool *result);
+
+/* Maps and arrays */
+CBOR_INLINE_API bool cbor_value_is_array(const CborValue *value)
+{ return value->type == CborArrayType; }
+CBOR_INLINE_API bool cbor_value_is_map(const CborValue *value)
+{ return value->type == CborMapType; }
+
+CBOR_INLINE_API CborError cbor_value_get_array_length(const CborValue *value, size_t *length)
+{
+    uint64_t v;
+    assert(cbor_value_is_array(value));
+    if (!cbor_value_is_length_known(value))
+        return CborErrorUnknownLength;
+    v = _cbor_value_extract_int64_helper(value);
+    *length = (size_t)v;
+    if (*length != v)
+        return CborErrorDataTooLarge;
+    return CborNoError;
+}
+
+CBOR_INLINE_API CborError cbor_value_get_map_length(const CborValue *value, size_t *length)
+{
+    uint64_t v;
+    assert(cbor_value_is_map(value));
+    if (!cbor_value_is_length_known(value))
+        return CborErrorUnknownLength;
+    v = _cbor_value_extract_int64_helper(value);
+    *length = (size_t)v;
+    if (*length != v)
+        return CborErrorDataTooLarge;
+    return CborNoError;
+}
+
+CBOR_API CborError cbor_value_map_find_value(const CborValue *map, const char *string, CborValue *element);
+
+/* Floating point */
+CBOR_INLINE_API bool cbor_value_is_half_float(const CborValue *value)
+{ return value->type == CborHalfFloatType; }
+CBOR_API CborError cbor_value_get_half_float_as_float(const CborValue *value, float *result);
+CBOR_INLINE_API CborError cbor_value_get_half_float(const CborValue *value, void *result)
+{
+    assert(cbor_value_is_half_float(value));
+    assert((value->flags & CborIteratorFlag_IntegerValueTooLarge) == 0);
+
+    /* size has already been computed */
+    memcpy(result, &value->extra, sizeof(value->extra));
+    return CborNoError;
+}
+
+CBOR_INLINE_API bool cbor_value_is_float(const CborValue *value)
+{ return value->type == CborFloatType; }
+CBOR_INLINE_API CborError cbor_value_get_float(const CborValue *value, float *result)
+{
+    uint32_t data;
+    assert(cbor_value_is_float(value));
+    assert(value->flags & CborIteratorFlag_IntegerValueTooLarge);
+    data = (uint32_t)_cbor_value_decode_int64_internal(value);
+    memcpy(result, &data, sizeof(*result));
+    return CborNoError;
+}
+
+CBOR_INLINE_API bool cbor_value_is_double(const CborValue *value)
+{ return value->type == CborDoubleType; }
+CBOR_INLINE_API CborError cbor_value_get_double(const CborValue *value, double *result)
+{
+    uint64_t data;
+    assert(cbor_value_is_double(value));
+    assert(value->flags & CborIteratorFlag_IntegerValueTooLarge);
+    data = _cbor_value_decode_int64_internal(value);
+    memcpy(result, &data, sizeof(*result));
+    return CborNoError;
+}
+
+/* Validation API */
+#ifndef CBOR_NO_VALIDATION_API
+
+enum CborValidationFlags {
+    /* Bit mapping:
+     *  bits 0-7 (8 bits):      canonical format
+     *  bits 8-11 (4 bits):     canonical format & strict mode
+     *  bits 12-20 (8 bits):    strict mode
+     *  bits 21-31 (10 bits):   other
+     */
+
+    CborValidateShortestIntegrals           = 0x0001,
+    CborValidateShortestFloatingPoint       = 0x0002,
+    CborValidateShortestNumbers             = CborValidateShortestIntegrals | CborValidateShortestFloatingPoint,
+    CborValidateNoIndeterminateLength       = 0x0100,
+    CborValidateMapIsSorted                 = 0x0200 | CborValidateNoIndeterminateLength,
+
+    CborValidateCanonicalFormat             = 0x0fff,
+
+    CborValidateMapKeysAreUnique            = 0x1000 | CborValidateMapIsSorted,
+    CborValidateTagUse                      = 0x2000,
+    CborValidateUtf8                        = 0x4000,
+
+    CborValidateStrictMode                  = 0xfff00,
+
+    CborValidateMapKeysAreString            = 0x100000,
+    CborValidateNoUndefined                 = 0x200000,
+    CborValidateNoTags                      = 0x400000,
+    CborValidateFiniteFloatingPoint         = 0x800000,
+    /* unused                               = 0x1000000, */
+    /* unused                               = 0x2000000, */
+
+    CborValidateNoUnknownSimpleTypesSA      = 0x4000000,
+    CborValidateNoUnknownSimpleTypes        = 0x8000000 | CborValidateNoUnknownSimpleTypesSA,
+    CborValidateNoUnknownTagsSA             = 0x10000000,
+    CborValidateNoUnknownTagsSR             = 0x20000000 | CborValidateNoUnknownTagsSA,
+    CborValidateNoUnknownTags               = 0x40000000 | CborValidateNoUnknownTagsSR,
+
+    CborValidateCompleteData                = (int)0x80000000,
+
+    CborValidateStrictest                   = (int)~0U,
+    CborValidateBasic                       = 0
+};
+
+CBOR_API CborError cbor_value_validate(const CborValue *it, uint32_t flags);
+#endif /* CBOR_NO_VALIDATION_API */
+
+/* Human-readable (dump) API */
+#ifndef CBOR_NO_PRETTY_API
+
+enum CborPrettyFlags {
+    CborPrettyNumericEncodingIndicators     = 0x01,
+    CborPrettyTextualEncodingIndicators     = 0,
+
+    CborPrettyIndicateIndeterminateLength   = 0x02,
+    CborPrettyIndicateIndetermineLength     = CborPrettyIndicateIndeterminateLength, /* deprecated */
+    CborPrettyIndicateOverlongNumbers       = 0x04,
+
+    CborPrettyShowStringFragments           = 0x100,
+    CborPrettyMergeStringFragments          = 0,
+
+    CborPrettyDefaultFlags          = CborPrettyIndicateIndeterminateLength
+};
+
+typedef CborError (*CborStreamFunction)(void *token, const char *fmt, ...)
+#ifdef __GNUC__
+    __attribute__((__format__(printf, 2, 3)))
+#endif
+;
+
+CBOR_API CborError cbor_value_to_pretty_stream(CborStreamFunction streamFunction, void *token, CborValue *value, int flags);
+
+/* The following API requires a hosted C implementation (uses FILE*) */
+#if !defined(__STDC_HOSTED__) || __STDC_HOSTED__-0 == 1
+CBOR_API CborError cbor_value_to_pretty_advance_flags(FILE *out, CborValue *value, int flags);
+CBOR_API CborError cbor_value_to_pretty_advance(FILE *out, CborValue *value);
+CBOR_INLINE_API CborError cbor_value_to_pretty(FILE *out, const CborValue *value)
+{
+    CborValue copy = *value;
+    return cbor_value_to_pretty_advance_flags(out, &copy, CborPrettyDefaultFlags);
+}
+#endif /* __STDC_HOSTED__ check */
+
+#endif /* CBOR_NO_PRETTY_API */
+
+#endif /* CBOR_NO_PARSER_API */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CBOR_H */
+

frame_serialize/tinycbor/cborencoder.c

@@ -0,0 +1,690 @@
+/****************************************************************************
+**
+** Copyright (C) 2021 Intel Corporation
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+** copies of the Software, and to permit persons to whom the Software is
+** furnished to do so, subject to the following conditions:
+**
+** The above copyright notice and this permission notice shall be included in
+** all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+** OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+** THE SOFTWARE.
+**
+****************************************************************************/
+
+#ifndef _BSD_SOURCE
+#define _BSD_SOURCE 1
+#endif
+#ifndef _DEFAULT_SOURCE
+#define _DEFAULT_SOURCE 1
+#endif
+#ifndef __STDC_LIMIT_MACROS
+#  define __STDC_LIMIT_MACROS 1
+#endif
+#define __STDC_WANT_IEC_60559_TYPES_EXT__
+
+#include "cbor.h"
+#include "cborinternal_p.h"
+#include "compilersupport_p.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+/**
+ * \defgroup CborEncoding Encoding to CBOR
+ * \brief Group of functions used to encode data to CBOR.
+ *
+ * CborEncoder is used to encode data into a CBOR stream. The outermost
+ * CborEncoder is initialized by calling cbor_encoder_init(), with the buffer
+ * where the CBOR stream will be stored. The outermost CborEncoder is usually
+ * used to encode exactly one item, most often an array or map. It is possible
+ * to encode more than one item, but care must then be taken on the decoder
+ * side to ensure the state is reset after each item was decoded.
+ *
+ * Nested CborEncoder objects are created using cbor_encoder_create_array() and
+ * cbor_encoder_create_map(), later closed with cbor_encoder_close_container()
+ * or cbor_encoder_close_container_checked(). The pairs of creation and closing
+ * must be exactly matched and their parameters are always the same.
+ *
+ * CborEncoder writes directly to the user-supplied buffer, without extra
+ * buffering. CborEncoder does not allocate memory and CborEncoder objects are
+ * usually created on the stack of the encoding functions.
+ *
+ * The example below initializes a CborEncoder object with a buffer and encodes
+ * a single integer.
+ *
+ * \code
+ *      uint8_t buf[16];
+ *      CborEncoder encoder;
+ *      cbor_encoder_init(&encoder, buf, sizeof(buf), 0);
+ *      cbor_encode_int(&encoder, some_value);
+ * \endcode
+ *
+ * As explained before, usually the outermost CborEncoder object is used to add
+ * one array or map, which in turn contains multiple elements. The example
+ * below creates a CBOR map with one element: a key "foo" and a boolean value.
+ *
+ * \code
+ *      uint8_t buf[16];
+ *      CborEncoder encoder, mapEncoder;
+ *      cbor_encoder_init(&encoder, buf, sizeof(buf), 0);
+ *      cbor_encoder_create_map(&encoder, &mapEncoder, 1);
+ *      cbor_encode_text_stringz(&mapEncoder, "foo");
+ *      cbor_encode_boolean(&mapEncoder, some_value);
+ *      cbor_encoder_close_container(&encoder, &mapEncoder);
+ * \endcode
+ *
+ * <h3 class="groupheader">Error checking and buffer size</h3>
+ *
+ * All functions operating on CborEncoder return a condition of type CborError.
+ * If the encoding was successful, they return CborNoError. Some functions do
+ * extra checking on the input provided and may return some other error
+ * conditions (for example, cbor_encode_simple_value() checks that the type is
+ * of the correct type).
+ *
+ * In addition, all functions check whether the buffer has enough bytes to
+ * encode the item being appended. If that is not possible, they return
+ * CborErrorOutOfMemory.
+ *
+ * It is possible to continue with the encoding of data past the first function
+ * that returns CborErrorOutOfMemory. CborEncoder functions will not overrun
+ * the buffer, but will instead count how many more bytes are needed to
+ * complete the encoding. At the end, you can obtain that count by calling
+ * cbor_encoder_get_extra_bytes_needed().
+ *
+ * \section1 Finalizing the encoding
+ *
+ * Once all items have been appended and the containers have all been properly
+ * closed, the user-supplied buffer will contain the CBOR stream and may be
+ * immediately used. To obtain the size of the buffer, call
+ * cbor_encoder_get_buffer_size() with the original buffer pointer.
+ *
+ * The example below illustrates how one can encode an item with error checking
+ * and then pass on the buffer for network sending.
+ *
+ * \code
+ *      uint8_t buf[16];
+ *      CborError err;
+ *      CborEncoder encoder, mapEncoder;
+ *      cbor_encoder_init(&encoder, buf, sizeof(buf), 0);
+ *      err = cbor_encoder_create_map(&encoder, &mapEncoder, 1);
+ *      if (err)
+ *          return err;
+ *      err = cbor_encode_text_stringz(&mapEncoder, "foo");
+ *      if (err)
+ *          return err;
+ *      err = cbor_encode_boolean(&mapEncoder, some_value);
+ *      if (err)
+ *          return err;
+ *      err = cbor_encoder_close_container_checked(&encoder, &mapEncoder);
+ *      if (err)
+ *          return err;
+ *
+ *      size_t len = cbor_encoder_get_buffer_size(&encoder, buf);
+ *      send_payload(buf, len);
+ *      return CborNoError;
+ * \endcode
+ *
+ * Finally, the example below expands on the one above and also
+ * deals with dynamically growing the buffer if the initial allocation wasn't
+ * big enough. Note the two places where the error checking was replaced with
+ * an cbor_assertion, showing where the author assumes no error can occur.
+ *
+ * \code
+ * uint8_t *encode_string_array(const char **strings, int n, size_t *bufsize)
+ * {
+ *     CborError err;
+ *     CborEncoder encoder, arrayEncoder;
+ *     size_t size = 256;
+ *     uint8_t *buf = NULL;
+ *
+ *     while (1) {
+ *         int i;
+ *         size_t more_bytes;
+ *         uint8_t *nbuf = realloc(buf, size);
+ *         if (nbuf == NULL)
+ *             goto error;
+ *         buf = nbuf;
+ *
+ *         cbor_encoder_init(&encoder, buf, size, 0);
+ *         err = cbor_encoder_create_array(&encoder, &arrayEncoder, n);
+ *         cbor_assert(!err);         // can't fail, the buffer is always big enough
+ *
+ *         for (i = 0; i < n; ++i) {
+ *             err = cbor_encode_text_stringz(&arrayEncoder, strings[i]);
+ *             if (err && err != CborErrorOutOfMemory)
+ *                 goto error;
+ *         }
+ *
+ *         err = cbor_encoder_close_container_checked(&encoder, &arrayEncoder);
+ *         cbor_assert(!err);         // shouldn't fail!
+ *
+ *         more_bytes = cbor_encoder_get_extra_bytes_needed(encoder);
+ *         if (more_size) {
+ *             // buffer wasn't big enough, try again
+ *             size += more_bytes;
+ *             continue;
+ *         }
+ *
+ *         *bufsize = cbor_encoder_get_buffer_size(encoder, buf);
+ *         return buf;
+ *     }
+ *  error:
+ *     free(buf);
+ *     return NULL;
+ *  }
+ * \endcode
+ */
+
+/**
+ * \addtogroup CborEncoding
+ * @{
+ */
+
+/**
+ * \struct CborEncoder
+ * Structure used to encode to CBOR.
+ */
+
+/**
+ * Initializes a CborEncoder structure \a encoder by pointing it to buffer \a
+ * buffer of size \a size. The \a flags field is currently unused and must be
+ * zero.
+ */
+void cbor_encoder_init(CborEncoder *encoder, uint8_t *buffer, size_t size, int flags)
+{
+    encoder->data.ptr = buffer;
+    encoder->end = buffer + size;
+    encoder->remaining = 2;
+    encoder->flags = flags;
+}
+
+void cbor_encoder_init_writer(CborEncoder *encoder, CborEncoderWriteFunction writer, void *token)
+{
+#ifdef CBOR_ENCODER_WRITE_FUNCTION
+    (void) writer;
+#else
+    encoder->data.writer = writer;
+#endif
+    encoder->end = (uint8_t *)token;
+    encoder->remaining = 2;
+    encoder->flags = CborIteratorFlag_WriterFunction;
+}
+
+static inline void put16(void *where, uint16_t v)
+{
+    uint16_t v_be = cbor_htons(v);
+    memcpy(where, &v_be, sizeof(v_be));
+}
+
+/* Note: Since this is currently only used in situations where OOM is the only
+ * valid error, we KNOW this to be true.  Thus, this function now returns just 'true',
+ * but if in the future, any function starts returning a non-OOM error, this will need
+ * to be changed to the test.  At the moment, this is done to prevent more branches
+ * being created in the tinycbor output */
+static inline bool isOomError(CborError err)
+{
+    if (CBOR_ENCODER_WRITER_CONTROL < 0)
+        return true;
+
+    /* CborErrorOutOfMemory is the only negative error code, intentionally
+     * so we can write the test like this */
+    return (int)err < 0;
+}
+
+static inline void put32(void *where, uint32_t v)
+{
+    uint32_t v_be = cbor_htonl(v);
+    memcpy(where, &v_be, sizeof(v_be));
+}
+
+static inline void put64(void *where, uint64_t v)
+{
+    uint64_t v_be = cbor_htonll(v);
+    memcpy(where, &v_be, sizeof(v_be));
+}
+
+static inline bool would_overflow(CborEncoder *encoder, size_t len)
+{
+    ptrdiff_t remaining = (ptrdiff_t)encoder->end;
+    remaining -= remaining ? (ptrdiff_t)encoder->data.ptr : encoder->data.bytes_needed;
+    remaining -= (ptrdiff_t)len;
+    return unlikely(remaining < 0);
+}
+
+static inline void advance_ptr(CborEncoder *encoder, size_t n)
+{
+    if (encoder->end)
+        encoder->data.ptr += n;
+    else
+        encoder->data.bytes_needed += n;
+}
+
+static inline CborError append_to_buffer(CborEncoder *encoder, const void *data, size_t len,
+                                         CborEncoderAppendType appendType)
+{
+    if (CBOR_ENCODER_WRITER_CONTROL >= 0) {
+        if (encoder->flags & CborIteratorFlag_WriterFunction || CBOR_ENCODER_WRITER_CONTROL != 0) {
+#  ifdef CBOR_ENCODER_WRITE_FUNCTION
+            return CBOR_ENCODER_WRITE_FUNCTION(encoder->end, data, len, appendType);
+#  else
+            return encoder->data.writer(encoder->end, data, len, appendType);
+#  endif
+        }
+    }
+
+#if CBOR_ENCODER_WRITER_CONTROL <= 0
+    if (would_overflow(encoder, len)) {
+        if (encoder->end != NULL) {
+            len -= encoder->end - encoder->data.ptr;
+            encoder->end = NULL;
+            encoder->data.bytes_needed = 0;
+        }
+
+        advance_ptr(encoder, len);
+        return CborErrorOutOfMemory;
+    }
+
+    memcpy(encoder->data.ptr, data, len);
+    encoder->data.ptr += len;
+#endif
+    return CborNoError;
+}
+
+static inline CborError append_byte_to_buffer(CborEncoder *encoder, uint8_t byte)
+{
+    return append_to_buffer(encoder, &byte, 1, CborEncoderAppendCborData);
+}
+
+static inline CborError encode_number_no_update(CborEncoder *encoder, uint64_t ui, uint8_t shiftedMajorType)
+{
+    /* Little-endian would have been so much more convenient here:
+     * We could just write at the beginning of buf but append_to_buffer
+     * only the necessary bytes.
+     * Since it has to be big endian, do it the other way around:
+     * write from the end. */
+    uint64_t buf[2];
+    uint8_t *const bufend = (uint8_t *)buf + sizeof(buf);
+    uint8_t *bufstart = bufend - 1;
+    put64(buf + 1, ui);     /* we probably have a bunch of zeros in the beginning */
+
+    if (ui < Value8Bit) {
+        *bufstart += shiftedMajorType;
+    } else {
+        uint8_t more = 0;
+        if (ui > 0xffU)
+            ++more;
+        if (ui > 0xffffU)
+            ++more;
+        if (ui > 0xffffffffU)
+            ++more;
+        bufstart -= (size_t)1 << more;
+        *bufstart = shiftedMajorType + Value8Bit + more;
+    }
+
+    return append_to_buffer(encoder, bufstart, bufend - bufstart, CborEncoderAppendCborData);
+}
+
+static inline void saturated_decrement(CborEncoder *encoder)
+{
+    if (encoder->remaining)
+        --encoder->remaining;
+}
+
+static inline CborError encode_number(CborEncoder *encoder, uint64_t ui, uint8_t shiftedMajorType)
+{
+    saturated_decrement(encoder);
+    return encode_number_no_update(encoder, ui, shiftedMajorType);
+}
+
+/**
+ * Appends the unsigned 64-bit integer \a value to the CBOR stream provided by
+ * \a encoder.
+ *
+ * \sa cbor_encode_negative_int, cbor_encode_int
+ */
+CborError cbor_encode_uint(CborEncoder *encoder, uint64_t value)
+{
+    return encode_number(encoder, value, UnsignedIntegerType << MajorTypeShift);
+}
+
+/**
+ * Appends the negative 64-bit integer whose absolute value is \a
+ * absolute_value to the CBOR stream provided by \a encoder.
+ *
+ * If the value \a absolute_value is zero, this function encodes -2^64.
+ *
+ * \sa cbor_encode_uint, cbor_encode_int
+ */
+CborError cbor_encode_negative_int(CborEncoder *encoder, uint64_t absolute_value)
+{
+    return encode_number(encoder, absolute_value - 1, NegativeIntegerType << MajorTypeShift);
+}
+
+/**
+ * Appends the signed 64-bit integer \a value to the CBOR stream provided by
+ * \a encoder.
+ *
+ * \sa cbor_encode_negative_int, cbor_encode_uint
+ */
+CborError cbor_encode_int(CborEncoder *encoder, int64_t value)
+{
+    /* adapted from code in RFC 7049 appendix C (pseudocode) */
+    uint64_t ui = value >> 63;              /* extend sign to whole length */
+    uint8_t majorType = ui & 0x20;          /* extract major type */
+    ui ^= value;                            /* complement negatives */
+    return encode_number(encoder, ui, majorType);
+}
+
+/**
+ * Appends the CBOR Simple Type of value \a value to the CBOR stream provided by
+ * \a encoder.
+ *
+ * This function may return error CborErrorIllegalSimpleType if the \a value
+ * variable contains a number that is not a valid simple type.
+ */
+CborError cbor_encode_simple_value(CborEncoder *encoder, uint8_t value)
+{
+#ifndef CBOR_ENCODER_NO_CHECK_USER
+    /* check if this is a valid simple type */
+    if (value >= HalfPrecisionFloat && value <= Break)
+        return CborErrorIllegalSimpleType;
+#endif
+    return encode_number(encoder, value, SimpleTypesType << MajorTypeShift);
+}
+
+/**
+ * Appends the floating-point value of type \a fpType and pointed to by \a
+ * value to the CBOR stream provided by \a encoder. The value of \a fpType must
+ * be one of CborHalfFloatType, CborFloatType or CborDoubleType, otherwise the
+ * behavior of this function is undefined.
+ *
+ * This function is useful for code that needs to pass through floating point
+ * values but does not wish to have the actual floating-point code.
+ *
+ * \sa cbor_encode_half_float, cbor_encode_float_as_half_float, cbor_encode_float, cbor_encode_double
+ */
+CborError cbor_encode_floating_point(CborEncoder *encoder, CborType fpType, const void *value)
+{
+    unsigned size;
+    uint8_t buf[1 + sizeof(uint64_t)];
+    cbor_assert(fpType == CborHalfFloatType || fpType == CborFloatType || fpType == CborDoubleType);
+    buf[0] = fpType;
+
+    size = 2U << (fpType - CborHalfFloatType);
+    if (size == 8)
+        put64(buf + 1, *(const uint64_t*)value);
+    else if (size == 4)
+        put32(buf + 1, *(const uint32_t*)value);
+    else
+        put16(buf + 1, *(const uint16_t*)value);
+    saturated_decrement(encoder);
+    return append_to_buffer(encoder, buf, size + 1, CborEncoderAppendCborData);
+}
+
+/**
+ * Appends the CBOR tag \a tag to the CBOR stream provided by \a encoder.
+ *
+ * \sa CborTag
+ */
+CborError cbor_encode_tag(CborEncoder *encoder, CborTag tag)
+{
+    /* tags don't count towards the number of elements in an array or map */
+    return encode_number_no_update(encoder, tag, TagType << MajorTypeShift);
+}
+
+static CborError encode_string(CborEncoder *encoder, size_t length, uint8_t shiftedMajorType, const void *string)
+{
+    CborError err = encode_number(encoder, length, shiftedMajorType);
+    if (err && !isOomError(err))
+        return err;
+    return append_to_buffer(encoder, string, length, CborEncoderAppendStringData);
+}
+
+/**
+ * \fn CborError cbor_encode_text_stringz(CborEncoder *encoder, const char *string)
+ *
+ * Appends the null-terminated text string \a string to the CBOR stream
+ * provided by \a encoder. CBOR requires that \a string be valid UTF-8, but
+ * TinyCBOR makes no verification of correctness. The terminating null is not
+ * included in the stream.
+ *
+ * \sa cbor_encode_text_string, cbor_encode_byte_string
+ */
+
+/**
+ * Appends the byte string \a string of length \a length to the CBOR stream
+ * provided by \a encoder. CBOR byte strings are arbitrary raw data.
+ *
+ * \sa cbor_encode_text_stringz, cbor_encode_text_string
+ */
+CborError cbor_encode_byte_string(CborEncoder *encoder, const uint8_t *string, size_t length)
+{
+    return encode_string(encoder, length, ByteStringType << MajorTypeShift, string);
+}
+
+/**
+ * Appends the text string \a string of length \a length to the CBOR stream
+ * provided by \a encoder. CBOR requires that \a string be valid UTF-8, but
+ * TinyCBOR makes no verification of correctness.
+ *
+ * \sa CborError cbor_encode_text_stringz, cbor_encode_byte_string
+ */
+CborError cbor_encode_text_string(CborEncoder *encoder, const char *string, size_t length)
+{
+    return encode_string(encoder, length, TextStringType << MajorTypeShift, string);
+}
+
+#ifdef __GNUC__
+__attribute__((noinline))
+#endif
+static CborError create_container(CborEncoder *encoder, CborEncoder *container, size_t length, uint8_t shiftedMajorType)
+{
+    CborError err;
+    container->data.ptr = encoder->data.ptr;
+    container->end = encoder->end;
+    saturated_decrement(encoder);
+    container->remaining = length + 1;      /* overflow ok on CborIndefiniteLength */
+
+    cbor_static_assert((int)CborIteratorFlag_ContainerIsMap_ == (int)CborIteratorFlag_ContainerIsMap);
+    cbor_static_assert(((MapType << MajorTypeShift) & CborIteratorFlag_ContainerIsMap) == CborIteratorFlag_ContainerIsMap);
+    cbor_static_assert(((ArrayType << MajorTypeShift) & CborIteratorFlag_ContainerIsMap) == 0);
+    container->flags = shiftedMajorType & CborIteratorFlag_ContainerIsMap;
+    if (CBOR_ENCODER_WRITER_CONTROL == 0)
+        container->flags |= encoder->flags & CborIteratorFlag_WriterFunction;
+
+    if (length == CborIndefiniteLength) {
+        container->flags |= CborIteratorFlag_UnknownLength;
+        err = append_byte_to_buffer(container, shiftedMajorType + IndefiniteLength);
+    } else {
+        if (shiftedMajorType & CborIteratorFlag_ContainerIsMap)
+            container->remaining += length;
+        err = encode_number_no_update(container, length, shiftedMajorType);
+    }
+    return err;
+}
+
+/**
+ * Creates a CBOR array in the CBOR stream provided by \a parentEncoder and
+ * initializes \a arrayEncoder so that items can be added to the array using
+ * the CborEncoder functions. The array must be terminated by calling either
+ * cbor_encoder_close_container() or cbor_encoder_close_container_checked()
+ * with the same \a encoder and \a arrayEncoder parameters.
+ *
+ * The number of items inserted into the array must be exactly \a length items,
+ * otherwise the stream is invalid. If the number of items is not known when
+ * creating the array, the constant \ref CborIndefiniteLength may be passed as
+ * length instead, and an indefinite length array is created.
+ *
+ * \sa cbor_encoder_create_map
+ */
+CborError cbor_encoder_create_array(CborEncoder *parentEncoder, CborEncoder *arrayEncoder, size_t length)
+{
+    return create_container(parentEncoder, arrayEncoder, length, ArrayType << MajorTypeShift);
+}
+
+/**
+ * Creates a CBOR map in the CBOR stream provided by \a parentEncoder and
+ * initializes \a mapEncoder so that items can be added to the map using
+ * the CborEncoder functions. The map must be terminated by calling either
+ * cbor_encoder_close_container() or cbor_encoder_close_container_checked()
+ * with the same \a encoder and \a mapEncoder parameters.
+ *
+ * The number of pair of items inserted into the map must be exactly \a length
+ * items, otherwise the stream is invalid. If the number is not known
+ * when creating the map, the constant \ref CborIndefiniteLength may be passed as
+ * length instead, and an indefinite length map is created.
+ *
+ * \b{Implementation limitation:} TinyCBOR cannot encode more than SIZE_MAX/2
+ * key-value pairs in the stream. If the length \a length is larger than this
+ * value (and is not \ref CborIndefiniteLength), this function returns error
+ * CborErrorDataTooLarge.
+ *
+ * \sa cbor_encoder_create_array
+ */
+CborError cbor_encoder_create_map(CborEncoder *parentEncoder, CborEncoder *mapEncoder, size_t length)
+{
+    if (length != CborIndefiniteLength && length > SIZE_MAX / 2)
+        return CborErrorDataTooLarge;
+    return create_container(parentEncoder, mapEncoder, length, MapType << MajorTypeShift);
+}
+
+/**
+ * Closes the CBOR container (array or map) provided by \a containerEncoder and
+ * updates the CBOR stream provided by \a encoder. Both parameters must be the
+ * same as were passed to cbor_encoder_create_array() or
+ * cbor_encoder_create_map().
+ *
+ * Since version 0.5, this function verifies that the number of items (or pairs
+ * of items, in the case of a map) was correct. It is no longer necessary to call
+ * cbor_encoder_close_container_checked() instead.
+ *
+ * \sa cbor_encoder_create_array(), cbor_encoder_create_map()
+ */
+CborError cbor_encoder_close_container(CborEncoder *parentEncoder, const CborEncoder *containerEncoder)
+{
+    // synchronise buffer state with that of the container
+    parentEncoder->end = containerEncoder->end;
+    parentEncoder->data = containerEncoder->data;
+
+    if (containerEncoder->flags & CborIteratorFlag_UnknownLength)
+        return append_byte_to_buffer(parentEncoder, BreakByte);
+
+    if (containerEncoder->remaining != 1)
+        return containerEncoder->remaining == 0 ? CborErrorTooManyItems : CborErrorTooFewItems;
+
+    if (!parentEncoder->end)
+        return CborErrorOutOfMemory;    /* keep the state */
+
+    return CborNoError;
+}
+
+/**
+ * \fn CborError cbor_encode_boolean(CborEncoder *encoder, bool value)
+ *
+ * Appends the boolean value \a value to the CBOR stream provided by \a encoder.
+ */
+
+/**
+ * \fn CborError cbor_encode_null(CborEncoder *encoder)
+ *
+ * Appends the CBOR type representing a null value to the CBOR stream provided
+ * by \a encoder.
+ *
+ * \sa cbor_encode_undefined()
+ */
+
+/**
+ * \fn CborError cbor_encode_undefined(CborEncoder *encoder)
+ *
+ * Appends the CBOR type representing an undefined value to the CBOR stream
+ * provided by \a encoder.
+ *
+ * \sa cbor_encode_null()
+ */
+
+/**
+ * \fn CborError cbor_encode_half_float(CborEncoder *encoder, const void *value)
+ *
+ * Appends the IEEE 754 half-precision (16-bit) floating point value pointed to
+ * by \a value to the CBOR stream provided by \a encoder.
+ *
+ * \sa cbor_encode_floating_point(), cbor_encode_float(), cbor_encode_double()
+ */
+
+/**
+ * \fn CborError cbor_encode_float_as_half_float(CborEncoder *encoder, float value)
+ *
+ * Convert the IEEE 754 single-precision (32-bit) floating point value \a value
+ * to the IEEE 754 half-precision (16-bit) floating point value and append it
+ * to the CBOR stream provided by \a encoder.
+ * The \a value should be in the range of the IEEE 754 half-precision floating point type,
+ * INFINITY, -INFINITY, or NAN, otherwise the behavior of this function is undefined.
+ *
+ * \sa cbor_encode_floating_point(), cbor_encode_float(), cbor_encode_double()
+ */
+
+/**
+ * \fn CborError cbor_encode_float(CborEncoder *encoder, float value)
+ *
+ * Appends the IEEE 754 single-precision (32-bit) floating point value \a value
+ * to the CBOR stream provided by \a encoder.
+ *
+ * \sa cbor_encode_floating_point(), cbor_encode_half_float(), cbor_encode_float_as_half_float(), cbor_encode_double()
+ */
+
+/**
+ * \fn CborError cbor_encode_double(CborEncoder *encoder, double value)
+ *
+ * Appends the IEEE 754 double-precision (64-bit) floating point value \a value
+ * to the CBOR stream provided by \a encoder.
+ *
+ * \sa cbor_encode_floating_point(), cbor_encode_half_float(), cbor_encode_float_as_half_float(), cbor_encode_float()
+ */
+
+/**
+ * \fn size_t cbor_encoder_get_buffer_size(const CborEncoder *encoder, const uint8_t *buffer)
+ *
+ * Returns the total size of the buffer starting at \a buffer after the
+ * encoding finished without errors. The \a encoder and \a buffer arguments
+ * must be the same as supplied to cbor_encoder_init().
+ *
+ * If the encoding process had errors, the return value of this function is
+ * meaningless. If the only errors were CborErrorOutOfMemory, instead use
+ * cbor_encoder_get_extra_bytes_needed() to find out by how much to grow the
+ * buffer before encoding again.
+ *
+ * See \ref CborEncoding for an example of using this function.
+ *
+ * \sa cbor_encoder_init(), cbor_encoder_get_extra_bytes_needed(), CborEncoding
+ */
+
+/**
+ * \fn size_t cbor_encoder_get_extra_bytes_needed(const CborEncoder *encoder)
+ *
+ * Returns how many more bytes the original buffer supplied to
+ * cbor_encoder_init() needs to be extended by so that no CborErrorOutOfMemory
+ * condition will happen for the encoding. If the buffer was big enough, this
+ * function returns 0. The \a encoder must be the original argument as passed
+ * to cbor_encoder_init().
+ *
+ * This function is usually called after an encoding sequence ended with one or
+ * more CborErrorOutOfMemory errors, but no other error. If any other error
+ * happened, the return value of this function is meaningless.
+ *
+ * See \ref CborEncoding for an example of using this function.
+ *
+ * \sa cbor_encoder_init(), cbor_encoder_get_buffer_size(), CborEncoding
+ */
+
+/** @} */

frame_serialize/tinycbor/cborencoder_close_container_checked.c

@@ -0,0 +1,58 @@
+/****************************************************************************
+**
+** Copyright (C) 2015 Intel Corporation
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+** copies of the Software, and to permit persons to whom the Software is
+** furnished to do so, subject to the following conditions:
+**
+** The above copyright notice and this permission notice shall be included in
+** all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+** OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+** THE SOFTWARE.
+**
+****************************************************************************/
+
+#define _BSD_SOURCE 1
+#define _DEFAULT_SOURCE 1
+#ifndef __STDC_LIMIT_MACROS
+#  define __STDC_LIMIT_MACROS 1
+#endif
+#define __STDC_WANT_IEC_60559_TYPES_EXT__
+
+#include "cbor.h"
+
+/**
+ * \addtogroup CborEncoding
+ * @{
+ */
+
+/**
+ * @deprecated
+ *
+ * Closes the CBOR container (array or map) provided by \a containerEncoder and
+ * updates the CBOR stream provided by \a encoder. Both parameters must be the
+ * same as were passed to cbor_encoder_create_array() or
+ * cbor_encoder_create_map().
+ *
+ * Prior to version 0.5, cbor_encoder_close_container() did not check the
+ * number of items added. Since that version, it does and now
+ * cbor_encoder_close_container_checked() is no longer needed.
+ *
+ * \sa cbor_encoder_create_array(), cbor_encoder_create_map()
+ */
+CborError cbor_encoder_close_container_checked(CborEncoder *encoder, const CborEncoder *containerEncoder)
+{
+    return cbor_encoder_close_container(encoder, containerEncoder);
+}
+
+/** @} */

frame_serialize/tinycbor/cborencoder_float.c

@@ -0,0 +1,43 @@
+/****************************************************************************
+**
+** Copyright (C) 2019 S.Phirsov
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+** copies of the Software, and to permit persons to whom the Software is
+** furnished to do so, subject to the following conditions:
+**
+** The above copyright notice and this permission notice shall be included in
+** all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+** OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+** THE SOFTWARE.
+**
+****************************************************************************/
+
+#define _BSD_SOURCE 1
+#define _DEFAULT_SOURCE 1
+#ifndef __STDC_LIMIT_MACROS
+#  define __STDC_LIMIT_MACROS 1
+#endif
+#define __STDC_WANT_IEC_60559_TYPES_EXT__
+
+#include "cbor.h"
+
+#include "cborinternal_p.h"
+
+#ifndef CBOR_NO_HALF_FLOAT_TYPE
+CborError cbor_encode_float_as_half_float(CborEncoder *encoder, float value)
+{
+    uint16_t v = (uint16_t)encode_half(value);
+
+    return cbor_encode_floating_point(encoder, CborHalfFloatType, &v);
+}
+#endif

frame_serialize/tinycbor/cborerrorstrings.c

@@ -0,0 +1,188 @@
+/****************************************************************************
+**
+** Copyright (C) 2021 Intel Corporation
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+** copies of the Software, and to permit persons to whom the Software is
+** furnished to do so, subject to the following conditions:
+**
+** The above copyright notice and this permission notice shall be included in
+** all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+** OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+** THE SOFTWARE.
+**
+****************************************************************************/
+
+#include "cbor.h"
+
+#ifndef _
+#  define _(msg)    msg
+#endif
+
+/**
+ * \enum CborError
+ * \ingroup CborGlobals
+ * The CborError enum contains the possible error values used by the CBOR encoder and decoder.
+ *
+ * TinyCBOR functions report success by returning CborNoError, or one error
+ * condition by returning one of the values below. One exception is the
+ * out-of-memory condition (CborErrorOutOfMemory), which the functions for \ref
+ * CborEncoding may report in bit-wise OR with other conditions.
+ *
+ * This technique allows code to determine whether the only error condition was
+ * a lack of buffer space, which may not be a fatal condition if the buffer can
+ * be resized. Additionally, the functions for \ref CborEncoding may continue
+ * to be used even after CborErrorOutOfMemory is returned, and instead they
+ * will simply calculate the extra space needed.
+ *
+ * \value CborNoError                   No error occurred
+ * \omitvalue CborUnknownError
+ * \value CborErrorUnknownLength        Request for the length of an array, map or string whose length is not provided in the CBOR stream
+ * \value CborErrorAdvancePastEOF       Not enough data in the stream to decode item (decoding would advance past end of stream)
+ * \value CborErrorIO                   An I/O error occurred, probably due to an out-of-memory situation
+ * \value CborErrorGarbageAtEnd         Bytes exist past the end of the CBOR stream
+ * \value CborErrorUnexpectedEOF        End of stream reached unexpectedly
+ * \value CborErrorUnexpectedBreak      A CBOR break byte was found where not expected
+ * \value CborErrorUnknownType          An unknown type (future extension to CBOR) was found in the stream
+ * \value CborErrorIllegalType          An invalid type was found while parsing a chunked CBOR string
+ * \value CborErrorIllegalNumber        An illegal initial byte (encoding unspecified additional information) was found
+ * \value CborErrorIllegalSimpleType    An illegal encoding of a CBOR Simple Type of value less than 32 was found
+ * \omitvalue CborErrorUnknownSimpleType
+ * \omitvalue CborErrorUnknownTag
+ * \omitvalue CborErrorInappropriateTagForType
+ * \omitvalue CborErrorDuplicateObjectKeys
+ * \value CborErrorInvalidUtf8TextString Illegal UTF-8 encoding found while parsing CBOR Text String
+ * \value CborErrorTooManyItems         Too many items were added to CBOR map or array of pre-determined length
+ * \value CborErrorTooFewItems          Too few items were added to CBOR map or array of pre-determined length
+ * \value CborErrorDataTooLarge         Data item size exceeds TinyCBOR's implementation limits
+ * \value CborErrorNestingTooDeep       Data item nesting exceeds TinyCBOR's implementation limits
+ * \omitvalue CborErrorUnsupportedType
+ * \value CborErrorJsonObjectKeyIsAggregate Conversion to JSON failed because the key in a map is a CBOR map or array
+ * \value CborErrorJsonObjectKeyNotString Conversion to JSON failed because the key in a map is not a text string
+ * \value CborErrorOutOfMemory          During CBOR encoding, the buffer provided is insufficient for encoding the data item;
+ *                                      in other situations, TinyCBOR failed to allocate memory
+ * \value CborErrorInternalError        An internal error occurred in TinyCBOR
+ */
+
+/**
+ * \ingroup CborGlobals
+ * Returns the error string corresponding to the CBOR error condition \a error.
+ */
+const char *cbor_error_string(CborError error)
+{
+    switch (error) {
+    case CborNoError:
+        return "";
+
+    case CborUnknownError:
+        return _("unknown error");
+
+    case CborErrorOutOfMemory:
+        return _("out of memory/need more memory");
+
+    case CborErrorUnknownLength:
+        return _("unknown length (attempted to get the length of a map/array/string of indeterminate length");
+
+    case CborErrorAdvancePastEOF:
+        return _("attempted to advance past EOF");
+
+    case CborErrorIO:
+        return _("I/O error");
+
+    case CborErrorGarbageAtEnd:
+        return _("garbage after the end of the content");
+
+    case CborErrorUnexpectedEOF:
+        return _("unexpected end of data");
+
+    case CborErrorUnexpectedBreak:
+        return _("unexpected 'break' byte");
+
+    case CborErrorUnknownType:
+        return _("illegal byte (encodes future extension type)");
+
+    case CborErrorIllegalType:
+        return _("mismatched string type in chunked string");
+
+    case CborErrorIllegalNumber:
+        return _("illegal initial byte (encodes unspecified additional information)");
+
+    case CborErrorIllegalSimpleType:
+        return _("illegal encoding of simple type smaller than 32");
+
+    case CborErrorNoMoreStringChunks:
+        return _("no more byte or text strings available");
+
+    case CborErrorUnknownSimpleType:
+        return _("unknown simple type");
+
+    case CborErrorUnknownTag:
+        return _("unknown tag");
+
+    case CborErrorInappropriateTagForType:
+        return _("inappropriate tag for type");
+
+    case CborErrorDuplicateObjectKeys:
+        return _("duplicate keys in object");
+
+    case CborErrorInvalidUtf8TextString:
+        return _("invalid UTF-8 content in string");
+
+    case CborErrorExcludedType:
+        return _("excluded type found");
+
+    case CborErrorExcludedValue:
+        return _("excluded value found");
+
+    case CborErrorImproperValue:
+    case CborErrorOverlongEncoding:
+        return _("value encoded in non-canonical form");
+
+    case CborErrorMapKeyNotString:
+    case CborErrorJsonObjectKeyNotString:
+        return _("key in map is not a string");
+
+    case CborErrorMapNotSorted:
+        return _("map is not sorted");
+
+    case CborErrorMapKeysNotUnique:
+        return _("map keys are not unique");
+
+    case CborErrorTooManyItems:
+        return _("too many items added to encoder");
+
+    case CborErrorTooFewItems:
+        return _("too few items added to encoder");
+
+    case CborErrorDataTooLarge:
+        return _("internal error: data too large");
+
+    case CborErrorNestingTooDeep:
+        return _("internal error: too many nested containers found in recursive function");
+
+    case CborErrorUnsupportedType:
+        return _("unsupported type");
+
+    case CborErrorUnimplementedValidation:
+        return _("validation not implemented for the current parser state");
+
+    case CborErrorJsonObjectKeyIsAggregate:
+        return _("conversion to JSON failed: key in object is an array or map");
+
+    case CborErrorJsonNotImplemented:
+        return _("conversion to JSON failed: open_memstream unavailable");
+
+    case CborErrorInternalError:
+        return _("internal error");
+    }
+    return cbor_error_string(CborUnknownError);
+}

frame_serialize/tinycbor/cborinternal_p.h

@@ -0,0 +1,343 @@
+/****************************************************************************
+**
+** Copyright (C) 2021 Intel Corporation
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+** copies of the Software, and to permit persons to whom the Software is
+** furnished to do so, subject to the following conditions:
+**
+** The above copyright notice and this permission notice shall be included in
+** all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+** OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+** THE SOFTWARE.
+**
+****************************************************************************/
+
+#ifndef CBORINTERNAL_P_H
+#define CBORINTERNAL_P_H
+
+/* Dependent source files (*.c) must define __STDC_WANT_IEC_60559_TYPES_EXT__
+ * before <float.h> is (transitively) first included.
+ */
+#if !defined(__STDC_WANT_IEC_60559_TYPES_EXT__)
+#  error __STDC_WANT_IEC_60559_TYPES_EXT__ not defined
+#endif
+
+#include "compilersupport_p.h"
+
+#ifndef CBOR_NO_FLOATING_POINT
+#  include <float.h>
+#  include <math.h>
+#  include <string.h>
+#else
+#  ifndef CBOR_NO_HALF_FLOAT_TYPE
+#    define CBOR_NO_HALF_FLOAT_TYPE     1
+#  endif
+#endif
+
+#ifndef CBOR_NO_HALF_FLOAT_TYPE
+/* Check for FLT16_MANT_DIG using integer comparison. Clang headers incorrectly
+ * define this macro unconditionally when __STDC_WANT_IEC_60559_TYPES_EXT__
+ * is defined (regardless of actual support for _Float16).
+ */
+#  if FLT16_MANT_DIG > 0 || __FLT16_MANT_DIG__ > 0
+static inline unsigned short encode_half(float x)
+{
+    unsigned short h;
+    _Float16 f = (_Float16)x;
+    memcpy(&h, &f, 2);
+    return h;
+}
+
+static inline float decode_half(unsigned short x)
+{
+    _Float16 f;
+    memcpy(&f, &x, 2);
+    return (float)f;
+}
+#  elif defined(__F16C__) || defined(__AVX2__)
+#    include <immintrin.h>
+static inline unsigned short encode_half(float val)
+{
+    __m128i m = _mm_cvtps_ph(_mm_set_ss(val), _MM_FROUND_CUR_DIRECTION);
+    return _mm_extract_epi16(m, 0);
+}
+static inline float decode_half(unsigned short half)
+{
+    __m128i m = _mm_cvtsi32_si128(half);
+    return _mm_cvtss_f32(_mm_cvtph_ps(m));
+}
+#  else
+/* software implementation of float-to-fp16 conversions */
+static inline unsigned short encode_half(double val)
+{
+    uint64_t v;
+    int sign, exp, mant;
+    memcpy(&v, &val, sizeof(v));
+    sign = v >> 63 << 15;
+    exp = (v >> 52) & 0x7ff;
+    mant = v << 12 >> 12 >> (53-11);    /* keep only the 11 most significant bits of the mantissa */
+    exp -= 1023;
+    if (exp == 1024) {
+        /* infinity or NaN */
+        exp = 16;
+        mant >>= 1;
+    } else if (exp >= 16) {
+        /* overflow, as largest number */
+        exp = 15;
+        mant = 1023;
+    } else if (exp >= -14) {
+        /* regular normal */
+    } else if (exp >= -24) {
+        /* subnormal */
+        mant |= 1024;
+        mant >>= -(exp + 14);
+        exp = -15;
+    } else {
+        /* underflow, make zero */
+        return 0;
+    }
+
+    /* safe cast here as bit operations above guarantee not to overflow */
+    return (unsigned short)(sign | ((exp + 15) << 10) | mant);
+}
+
+/* this function was copied & adapted from RFC 7049 Appendix D */
+static inline double decode_half(unsigned short half)
+{
+    int exp = (half >> 10) & 0x1f;
+    int mant = half & 0x3ff;
+    double val;
+    if (exp == 0) val = ldexp(mant, -24);
+    else if (exp != 31) val = ldexp(mant + 1024, exp - 25);
+    else val = mant == 0 ? INFINITY : NAN;
+    return half & 0x8000 ? -val : val;
+}
+#  endif
+#endif /* CBOR_NO_HALF_FLOAT_TYPE */
+
+#ifndef CBOR_INTERNAL_API
+#  define CBOR_INTERNAL_API
+#endif
+
+#ifndef CBOR_PARSER_MAX_RECURSIONS
+#  define CBOR_PARSER_MAX_RECURSIONS 1024
+#endif
+
+#ifndef CBOR_ENCODER_WRITER_CONTROL
+#  define CBOR_ENCODER_WRITER_CONTROL   0
+#endif
+#ifndef CBOR_PARSER_READER_CONTROL
+#  define CBOR_PARSER_READER_CONTROL    0
+#endif
+
+/*
+ * CBOR Major types
+ * Encoded in the high 3 bits of the descriptor byte
+ * See http://tools.ietf.org/html/rfc7049#section-2.1
+ */
+typedef enum CborMajorTypes {
+    UnsignedIntegerType = 0U,
+    NegativeIntegerType = 1U,
+    ByteStringType = 2U,
+    TextStringType = 3U,
+    ArrayType = 4U,
+    MapType = 5U,           /* a.k.a. object */
+    TagType = 6U,
+    SimpleTypesType = 7U
+} CborMajorTypes;
+
+/*
+ * CBOR simple and floating point types
+ * Encoded in the low 8 bits of the descriptor byte when the
+ * Major Type is 7.
+ */
+typedef enum CborSimpleTypes {
+    FalseValue              = 20,
+    TrueValue               = 21,
+    NullValue               = 22,
+    UndefinedValue          = 23,
+    SimpleTypeInNextByte    = 24,   /* not really a simple type */
+    HalfPrecisionFloat      = 25,   /* ditto */
+    SinglePrecisionFloat    = 26,   /* ditto */
+    DoublePrecisionFloat    = 27,   /* ditto */
+    Break                   = 31
+} CborSimpleTypes;
+
+enum {
+    SmallValueBitLength     = 5U,
+    SmallValueMask          = (1U << SmallValueBitLength) - 1,      /* 31 */
+    Value8Bit               = 24U,
+    Value16Bit              = 25U,
+    Value32Bit              = 26U,
+    Value64Bit              = 27U,
+    IndefiniteLength        = 31U,
+
+    MajorTypeShift          = SmallValueBitLength,
+    MajorTypeMask           = (int) (~0U << MajorTypeShift),
+
+    BreakByte               = (unsigned)Break | (SimpleTypesType << MajorTypeShift)
+};
+
+static inline void copy_current_position(CborValue *dst, const CborValue *src)
+{
+    /* This "if" is here for pedantry only: the two branches should perform
+     * the same memory operation. */
+    if (src->parser->flags & CborParserFlag_ExternalSource)
+        dst->source.token = src->source.token;
+    else
+        dst->source.ptr = src->source.ptr;
+}
+
+static inline bool can_read_bytes(const CborValue *it, size_t n)
+{
+    if (CBOR_PARSER_READER_CONTROL >= 0) {
+        if (it->parser->flags & CborParserFlag_ExternalSource || CBOR_PARSER_READER_CONTROL != 0) {
+#ifdef CBOR_PARSER_CAN_READ_BYTES_FUNCTION
+            return CBOR_PARSER_CAN_READ_BYTES_FUNCTION(it->source.token, n);
+#else
+            return it->parser->source.ops->can_read_bytes(it->source.token, n);
+#endif
+        }
+    }
+
+    /* Convert the pointer subtraction to size_t since end >= ptr
+     * (this prevents issues with (ptrdiff_t)n becoming negative).
+     */
+    return (size_t)(it->parser->source.end - it->source.ptr) >= n;
+}
+
+static inline void advance_bytes(CborValue *it, size_t n)
+{
+    if (CBOR_PARSER_READER_CONTROL >= 0) {
+        if (it->parser->flags & CborParserFlag_ExternalSource || CBOR_PARSER_READER_CONTROL != 0) {
+#ifdef CBOR_PARSER_ADVANCE_BYTES_FUNCTION
+            CBOR_PARSER_ADVANCE_BYTES_FUNCTION(it->source.token, n);
+#else
+            it->parser->source.ops->advance_bytes(it->source.token, n);
+#endif
+            return;
+        }
+    }
+
+    it->source.ptr += n;
+}
+
+static inline CborError transfer_string(CborValue *it, const void **ptr, size_t offset, size_t len)
+{
+    if (CBOR_PARSER_READER_CONTROL >= 0) {
+        if (it->parser->flags & CborParserFlag_ExternalSource || CBOR_PARSER_READER_CONTROL != 0) {
+#ifdef CBOR_PARSER_TRANSFER_STRING_FUNCTION
+            return CBOR_PARSER_TRANSFER_STRING_FUNCTION(it->source.token, ptr, offset, len);
+#else
+            return it->parser->source.ops->transfer_string(it->source.token, ptr, offset, len);
+#endif
+        }
+    }
+
+    it->source.ptr += offset;
+    if (can_read_bytes(it, len)) {
+        *CONST_CAST(const void **, ptr) = it->source.ptr;
+        it->source.ptr += len;
+        return CborNoError;
+    }
+    return CborErrorUnexpectedEOF;
+}
+
+static inline void *read_bytes_unchecked(const CborValue *it, void *dst, size_t offset, size_t n)
+{
+    if (CBOR_PARSER_READER_CONTROL >= 0) {
+        if (it->parser->flags & CborParserFlag_ExternalSource || CBOR_PARSER_READER_CONTROL != 0) {
+#ifdef CBOR_PARSER_READ_BYTES_FUNCTION
+            return CBOR_PARSER_READ_BYTES_FUNCTION(it->source.token, dst, offset, n);
+#else
+            return it->parser->source.ops->read_bytes(it->source.token, dst, offset, n);
+#endif
+        }
+    }
+
+    return memcpy(dst, it->source.ptr + offset, n);
+}
+
+#ifdef __GNUC__
+__attribute__((warn_unused_result))
+#endif
+static inline void *read_bytes(const CborValue *it, void *dst, size_t offset, size_t n)
+{
+    if (can_read_bytes(it, offset + n))
+        return read_bytes_unchecked(it, dst, offset, n);
+    return NULL;
+}
+
+static inline uint16_t read_uint8(const CborValue *it, size_t offset)
+{
+    uint8_t result;
+    read_bytes_unchecked(it, &result, offset, sizeof(result));
+    return result;
+}
+
+static inline uint16_t read_uint16(const CborValue *it, size_t offset)
+{
+    uint16_t result;
+    read_bytes_unchecked(it, &result, offset, sizeof(result));
+    return cbor_ntohs(result);
+}
+
+static inline uint32_t read_uint32(const CborValue *it, size_t offset)
+{
+    uint32_t result;
+    read_bytes_unchecked(it, &result, offset, sizeof(result));
+    return cbor_ntohl(result);
+}
+
+static inline uint64_t read_uint64(const CborValue *it, size_t offset)
+{
+    uint64_t result;
+    read_bytes_unchecked(it, &result, offset, sizeof(result));
+    return cbor_ntohll(result);
+}
+
+static inline CborError extract_number_checked(const CborValue *it, uint64_t *value, size_t *bytesUsed)
+{
+    uint8_t descriptor;
+    size_t bytesNeeded = 0;
+
+    /* We've already verified that there's at least one byte to be read */
+    read_bytes_unchecked(it, &descriptor, 0, 1);
+    descriptor &= SmallValueMask;
+    if (descriptor < Value8Bit) {
+        *value = descriptor;
+    } else if (unlikely(descriptor > Value64Bit)) {
+        return CborErrorIllegalNumber;
+    } else {
+        bytesNeeded = (size_t)(1 << (descriptor - Value8Bit));
+        if (!can_read_bytes(it, 1 + bytesNeeded))
+            return CborErrorUnexpectedEOF;
+        if (descriptor <= Value16Bit) {
+            if (descriptor == Value16Bit)
+                *value = read_uint16(it, 1);
+            else
+                *value = read_uint8(it, 1);
+        } else {
+            if (descriptor == Value32Bit)
+                *value = read_uint32(it, 1);
+            else
+                *value = read_uint64(it, 1);
+        }
+    }
+
+    if (bytesUsed)
+        *bytesUsed = bytesNeeded;
+    return CborNoError;
+}
+
+#endif /* CBORINTERNAL_P_H */

frame_serialize/tinycbor/cborjson.h

@@ -0,0 +1,62 @@
+/****************************************************************************
+**
+** Copyright (C) 2015 Intel Corporation
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+** copies of the Software, and to permit persons to whom the Software is
+** furnished to do so, subject to the following conditions:
+**
+** The above copyright notice and this permission notice shall be included in
+** all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+** OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+** THE SOFTWARE.
+**
+****************************************************************************/
+
+#ifndef CBORJSON_H
+#define CBORJSON_H
+
+#include "cbor.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Conversion to JSON */
+enum CborToJsonFlags
+{
+    CborConvertAddMetadata = 1,
+    CborConvertTagsToObjects = 2,
+    CborConvertIgnoreTags = 0,
+
+    CborConvertObeyByteStringTags = 0,
+    CborConvertByteStringsToBase64Url = 4,
+
+    CborConvertRequireMapStringKeys = 0,
+    CborConvertStringifyMapKeys = 8,
+
+    CborConvertDefaultFlags = 0
+};
+
+CBOR_API CborError cbor_value_to_json_advance(FILE *out, CborValue *value, int flags);
+CBOR_INLINE_API CborError cbor_value_to_json(FILE *out, const CborValue *value, int flags)
+{
+    CborValue copy = *value;
+    return cbor_value_to_json_advance(out, &copy, flags);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CBORJSON_H */
+

frame_serialize/tinycbor/cborparser_dup_string.c

@@ -0,0 +1,127 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 Intel Corporation
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+** copies of the Software, and to permit persons to whom the Software is
+** furnished to do so, subject to the following conditions:
+**
+** The above copyright notice and this permission notice shall be included in
+** all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+** OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+** THE SOFTWARE.
+**
+****************************************************************************/
+
+#ifndef _BSD_SOURCE
+#define _BSD_SOURCE 1
+#endif
+#ifndef _DEFAULT_SOURCE
+#define _DEFAULT_SOURCE 1
+#endif
+#ifndef __STDC_LIMIT_MACROS
+#  define __STDC_LIMIT_MACROS 1
+#endif
+#define __STDC_WANT_IEC_60559_TYPES_EXT__
+
+#include "cbor.h"
+#include "compilersupport_p.h"
+
+#if defined(CBOR_CUSTOM_ALLOC_INCLUDE)
+#  include CBOR_CUSTOM_ALLOC_INCLUDE
+#else
+#  include <stdlib.h>
+#  define cbor_malloc malloc
+#  define cbor_free   free
+#endif
+
+/**
+ * \fn CborError cbor_value_dup_text_string(const CborValue *value, char **buffer, size_t *buflen, CborValue *next)
+ *
+ * Allocates memory for the string pointed by \a value and copies it into this
+ * buffer. The pointer to the buffer is stored in \a buffer and the number of
+ * bytes copied is stored in \a buflen (those variables must not be NULL).
+ *
+ * If the iterator \a value does not point to a text string, the behaviour is
+ * undefined, so checking with \ref cbor_value_get_type or \ref
+ * cbor_value_is_text_string is recommended.
+ *
+ * If \c malloc returns a NULL pointer, this function will return error
+ * condition \ref CborErrorOutOfMemory.
+ *
+ * On success, \c{*buffer} will contain a valid pointer that must be freed by
+ * calling \c{free()}. This is the case even for zero-length strings.
+ *
+ * The \a next pointer, if not null, will be updated to point to the next item
+ * after this string. If \a value points to the last item, then \a next will be
+ * invalid.
+ *
+ * This function may not run in constant time (it will run in O(n) time on the
+ * number of chunks). It requires constant memory (O(1)) in addition to the
+ * malloc'ed block.
+ *
+ * \note This function does not perform UTF-8 validation on the incoming text
+ * string.
+ *
+ * \sa cbor_value_get_text_string_chunk(), cbor_value_copy_text_string(), cbor_value_dup_byte_string()
+ */
+
+/**
+ * \fn CborError cbor_value_dup_byte_string(const CborValue *value, uint8_t **buffer, size_t *buflen, CborValue *next)
+ *
+ * Allocates memory for the string pointed by \a value and copies it into this
+ * buffer. The pointer to the buffer is stored in \a buffer and the number of
+ * bytes copied is stored in \a buflen (those variables must not be NULL).
+ *
+ * If the iterator \a value does not point to a byte string, the behaviour is
+ * undefined, so checking with \ref cbor_value_get_type or \ref
+ * cbor_value_is_byte_string is recommended.
+ *
+ * If \c malloc returns a NULL pointer, this function will return error
+ * condition \ref CborErrorOutOfMemory.
+ *
+ * On success, \c{*buffer} will contain a valid pointer that must be freed by
+ * calling \c{free()}. This is the case even for zero-length strings.
+ *
+ * The \a next pointer, if not null, will be updated to point to the next item
+ * after this string. If \a value points to the last item, then \a next will be
+ * invalid.
+ *
+ * This function may not run in constant time (it will run in O(n) time on the
+ * number of chunks). It requires constant memory (O(1)) in addition to the
+ * malloc'ed block.
+ *
+ * \sa cbor_value_get_text_string_chunk(), cbor_value_copy_byte_string(), cbor_value_dup_text_string()
+ */
+CborError _cbor_value_dup_string(const CborValue *value, void **buffer, size_t *buflen, CborValue *next)
+{
+    CborError err;
+    cbor_assert(buffer);
+    cbor_assert(buflen);
+    *buflen = SIZE_MAX;
+    err = _cbor_value_copy_string(value, NULL, buflen, NULL);
+    if (err)
+        return err;
+
+    ++*buflen;
+    *buffer = cbor_malloc(*buflen);
+    if (!*buffer) {
+        /* out of memory */
+        return CborErrorOutOfMemory;
+    }
+    err = _cbor_value_copy_string(value, *buffer, buflen, next);
+    if (err) {
+        cbor_free(*buffer);
+        return err;
+    }
+    return CborNoError;
+}

frame_serialize/tinycbor/cborparser_float.c

@@ -0,0 +1,55 @@
+/****************************************************************************
+**
+** Copyright (C) 2019 S.Phirsov
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+** copies of the Software, and to permit persons to whom the Software is
+** furnished to do so, subject to the following conditions:
+**
+** The above copyright notice and this permission notice shall be included in
+** all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+** OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+** THE SOFTWARE.
+**
+****************************************************************************/
+
+#define _BSD_SOURCE 1
+#define _DEFAULT_SOURCE 1
+#ifndef __STDC_LIMIT_MACROS
+#  define __STDC_LIMIT_MACROS 1
+#endif
+#define __STDC_WANT_IEC_60559_TYPES_EXT__
+
+#include "cbor.h"
+
+#include "cborinternal_p.h"
+
+#ifndef CBOR_NO_HALF_FLOAT_TYPE
+/**
+ * Retrieves the CBOR half-precision floating point (16-bit) value that \a
+ * value points to, converts it to the float and store it in \a result.
+ * If the iterator \a value does not point to a half-precision floating
+ * point value, the behavior is undefined, so checking with \ref
+ * cbor_value_get_type or with \ref cbor_value_is_half_float is recommended.
+ * \sa cbor_value_get_type(), cbor_value_is_valid(), cbor_value_is_half_float(), cbor_value_get_half_float(), cbor_value_get_float()
+ */
+CborError cbor_value_get_half_float_as_float(const CborValue *value, float *result)
+{
+    uint16_t v;
+    CborError err = cbor_value_get_half_float(value, &v);
+    cbor_assert(err == CborNoError);
+
+    *result = (float)decode_half((unsigned short)v);
+
+    return CborNoError;
+}
+#endif

frame_serialize/tinycbor/cborpretty.c

@@ -0,0 +1,583 @@
+/****************************************************************************
+**
+** Copyright (C) 2021 Intel Corporation
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+** copies of the Software, and to permit persons to whom the Software is
+** furnished to do so, subject to the following conditions:
+**
+** The above copyright notice and this permission notice shall be included in
+** all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+** OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+** THE SOFTWARE.
+**
+****************************************************************************/
+
+#define _BSD_SOURCE 1
+#define _DEFAULT_SOURCE 1
+#ifndef __STDC_LIMIT_MACROS
+#  define __STDC_LIMIT_MACROS 1
+#endif
+#define __STDC_WANT_IEC_60559_TYPES_EXT__
+
+#include "cbor.h"
+#include "cborinternal_p.h"
+#include "compilersupport_p.h"
+#include "utf8_p.h"
+
+#include <inttypes.h>
+#include <string.h>
+
+/**
+ * \defgroup CborPretty Converting CBOR to text
+ * \brief Group of functions used to convert CBOR to text form.
+ *
+ * This group contains two functions that can be used to convert a \ref
+ * CborValue object to a text representation. This module attempts to follow
+ * the recommendations from RFC 7049 section 6 "Diagnostic Notation", though it
+ * has a few differences. They are noted below.
+ *
+ * TinyCBOR does not provide a way to convert from the text representation back
+ * to encoded form. To produce a text form meant to be parsed, CborToJson is
+ * recommended instead.
+ *
+ * Either of the functions in this section will attempt to convert exactly one
+ * CborValue object to text. Those functions may return any error documented
+ * for the functions for CborParsing. In addition, if the C standard library
+ * stream functions return with error, the text conversion will return with
+ * error CborErrorIO.
+ *
+ * These functions also perform UTF-8 validation in CBOR text strings. If they
+ * encounter a sequence of bytes that is not permitted in UTF-8, they will return
+ * CborErrorInvalidUtf8TextString. That includes encoding of surrogate points
+ * in UTF-8.
+ *
+ * \warning The output type produced by these functions is not guaranteed to
+ * remain stable. A future update of TinyCBOR may produce different output for
+ * the same input and parsers may be unable to handle it.
+ *
+ * \sa CborParsing, CborToJson, cbor_parser_init()
+ */
+
+/**
+ * \addtogroup CborPretty
+ * @{
+ * <h2 class="groupheader">Text format</h2>
+ *
+ * As described in RFC 7049 section 6 "Diagnostic Notation", the format is
+ * largely borrowed from JSON, but modified to suit CBOR's different data
+ * types. TinyCBOR makes further modifications to distinguish different, but
+ * similar values.
+ *
+ * CBOR values are currently encoded as follows:
+ * \par Integrals (unsigned and negative)
+ *      Base-10 (decimal) text representation of the value
+ * \par Byte strings:
+ *      <tt>"h'"</tt> followed by the Base16 (hex) representation of the binary data, followed by an ending quote (')
+ * \par Text strings:
+ *      C-style escaped string in quotes, with C11/C++11 escaping of Unicode codepoints above U+007F.
+ * \par Tags:
+ *      Tag value, with the tagged value in parentheses. No special encoding of the tagged value is performed.
+ * \par Simple types:
+ *      <tt>"simple(nn)"</tt> where \c nn is the simple value
+ * \par Null:
+ *      \c null
+ * \par Undefined:
+ *      \c undefined
+ * \par Booleans:
+ *      \c true or \c false
+ * \par Floating point:
+ *      If NaN or infinite, the actual words \c NaN or \c infinite.
+ *      Otherwise, the decimal representation with as many digits as necessary to ensure no loss of information.
+ *      By default, float values are suffixed by "f" and half-float values suffixed by "f16" (doubles have no suffix).
+ *      If the CborPrettyNumericEncodingIndicators flag is active, the values instead are encoded following the
+ *      Section 6 recommended encoding indicators: float values are suffixed with "_2" and half-float with "_1".
+ *      A decimal point is always present.
+ * \par Arrays:
+ *      Comma-separated list of elements, enclosed in square brackets ("[" and "]").
+ * \par Maps:
+ *      Comma-separated list of key-value pairs, with the key and value separated
+ *      by a colon (":"), enclosed in curly braces ("{" and "}").
+ *
+ * The CborPrettyFlags enumerator contains flags to control some aspects of the
+ * encoding:
+ * \par String fragmentation
+ *      When the CborPrettyShowStringFragments option is active, text and byte
+ *      strings that are transmitted in fragments are shown instead inside
+ *      parentheses ("(" and ")") with no preceding number and each fragment is
+ *      displayed individually. If a tag precedes the string, then the output
+ *      will contain a double set of parentheses. If the option is not active,
+ *      the fragments are merged together and the display will not show any
+ *      difference from a string transmitted with determinate length.
+ * \par Encoding indicators
+ *      Numbers and lengths in CBOR can be encoded in multiple representations.
+ *      If the CborPrettyIndicateOverlongNumbers option is active, numbers
+ *      and lengths that are transmitted in a longer encoding than necessary
+ *      will be indicated, by appending an underscore ("_") to either the
+ *      number or the opening bracket or brace, followed by a number
+ *      indicating the CBOR additional information: 0 for 1 byte, 1 for 2
+ *      bytes, 2 for 4 bytes and 3 for 8 bytes.
+ *      If the CborPrettyIndicateIndeterminateLength option is active, maps,
+ *      arrays and strings encoded with indeterminate length will be marked by
+ *      an underscore after the opening bracket or brace or the string (if not
+ *      showing fragments), without a number after it.
+ */
+
+/**
+ * \enum CborPrettyFlags
+ * The CborPrettyFlags enum contains flags that control the conversion of CBOR to text format.
+ *
+ * \value CborPrettyNumericEncodingIndicators   Use numeric encoding indicators instead of textual for float and half-float.
+ * \value CborPrettyTextualEncodingIndicators   Use textual encoding indicators for float ("f") and half-float ("f16").
+ * \value CborPrettyIndicateIndeterminateLength (default) Indicate when a map or array has indeterminate length.
+ * \value CborPrettyIndicateOverlongNumbers     Indicate when a number or length was encoded with more bytes than needed.
+ * \value CborPrettyShowStringFragments         If the byte or text string is transmitted in chunks, show each individually.
+ * \value CborPrettyMergeStringFragment         Merge all chunked byte or text strings and display them in a single entry.
+ * \value CborPrettyDefaultFlags                Default conversion flags.
+ */
+
+#ifndef CBOR_NO_FLOATING_POINT
+static inline bool convertToUint64(double v, uint64_t *absolute)
+{
+    double supremum;
+    v = fabs(v);
+
+    /* C11 standard section 6.3.1.4 "Real floating and integer" says:
+     *
+     *  1 When a finite value of real floating type is converted to an integer
+     *    type other than _Bool, the fractional part is discarded (i.e., the
+     *    value is truncated toward zero). If the value of the integral part
+     *    cannot be represented by the integer type, the behavior is undefined.
+     *
+     * So we must perform a range check that v <= UINT64_MAX, but we can't use
+     * UINT64_MAX + 1.0 because the standard continues:
+     *
+     *  2 When a value of integer type is converted to a real floating type, if
+     *    the value being converted can be represented exactly in the new type,
+     *    it is unchanged. If the value being converted is in the range of
+     *    values that can be represented but cannot be represented exactly, the
+     *    result is either the nearest higher or nearest lower representable
+     *    value, chosen in an implementation-defined manner.
+     */
+    supremum = -2.0 * INT64_MIN;     /* -2 * (- 2^63) == 2^64 */
+    if (v >= supremum)
+        return false;
+
+    /* Now we can convert, these two conversions cannot be UB */
+    *absolute = v;
+    return *absolute == v;
+}
+#endif
+
+static void printRecursionLimit(CborStreamFunction stream, void *out)
+{
+    stream(out, "<nesting too deep, recursion stopped>");
+}
+
+static CborError hexDump(CborStreamFunction stream, void *out, const void *ptr, size_t n)
+{
+    const uint8_t *buffer = (const uint8_t *)ptr;
+    CborError err = CborNoError;
+    while (n-- && !err)
+        err = stream(out, "%02" PRIx8, *buffer++);
+
+    return err;
+}
+
+/* This function decodes buffer as UTF-8 and prints as escaped UTF-16.
+ * On UTF-8 decoding error, it returns CborErrorInvalidUtf8TextString */
+static CborError utf8EscapedDump(CborStreamFunction stream, void *out, const void *ptr, size_t n)
+{
+    const uint8_t *buffer = (const uint8_t *)ptr;
+    const uint8_t * const end = buffer + n;
+    CborError err = CborNoError;
+
+    while (buffer < end && !err) {
+        uint32_t uc = get_utf8(&buffer, end);
+        if (uc == ~0U)
+            return CborErrorInvalidUtf8TextString;
+
+        if (uc < 0x80) {
+            /* single-byte UTF-8 */
+            unsigned char escaped = (unsigned char)uc;
+            if (uc < 0x7f && uc >= 0x20 && uc != '\\' && uc != '"') {
+                err = stream(out, "%c", (char)uc);
+                continue;
+            }
+
+            /* print as an escape sequence */
+            switch (uc) {
+            case '"':
+            case '\\':
+                break;
+            case '\b':
+                escaped = 'b';
+                break;
+            case '\f':
+                escaped = 'f';
+                break;
+            case '\n':
+                escaped = 'n';
+                break;
+            case '\r':
+                escaped = 'r';
+                break;
+            case '\t':
+                escaped = 't';
+                break;
+            default:
+                goto print_utf16;
+            }
+            err = stream(out, "\\%c", escaped);
+            continue;
+        }
+
+        /* now print the sequence */
+        if (uc > 0xffffU) {
+            /* needs surrogate pairs */
+            err = stream(out, "\\u%04" PRIX32 "\\u%04" PRIX32,
+                         (uc >> 10) + 0xd7c0,    /* high surrogate */
+                         (uc % 0x0400) + 0xdc00);
+        } else {
+print_utf16:
+            /* no surrogate pair needed */
+            err = stream(out, "\\u%04" PRIX32, uc);
+        }
+    }
+    return err;
+}
+
+static const char *resolve_indicator(const CborValue *it, int flags)
+{
+    static const char indicators[8][3] = {
+        "_0", "_1", "_2", "_3",
+        "", "", "",             /* these are not possible */
+        "_"
+    };
+    const char *no_indicator = indicators[5];   /* empty string */
+    uint8_t additional_information;
+    uint8_t expected_information;
+    uint64_t value;
+    CborError err;
+
+    if (!read_bytes(it, &additional_information, 0, 1))
+        return NULL;    /* CborErrorUnexpectedEOF */
+
+    additional_information &= SmallValueMask;
+    if (additional_information < Value8Bit)
+        return no_indicator;
+
+    /* determine whether to show anything */
+    if ((flags & CborPrettyIndicateIndeterminateLength) &&
+            additional_information == IndefiniteLength)
+        return indicators[IndefiniteLength - Value8Bit];
+    if ((flags & CborPrettyIndicateOverlongNumbers) == 0)
+        return no_indicator;
+
+    err = extract_number_checked(it, &value, NULL);
+    if (err)
+        return NULL;    /* CborErrorUnexpectedEOF */
+
+    expected_information = Value8Bit - 1;
+    if (value >= Value8Bit)
+        ++expected_information;
+    if (value > 0xffU)
+        ++expected_information;
+    if (value > 0xffffU)
+        ++expected_information;
+    if (value > 0xffffffffU)
+        ++expected_information;
+    return expected_information == additional_information ?
+                no_indicator :
+                indicators[additional_information - Value8Bit];
+}
+
+static const char *get_indicator(const CborValue *it, int flags)
+{
+    return resolve_indicator(it, flags);
+}
+
+static CborError value_to_pretty(CborStreamFunction stream, void *out, CborValue *it, int flags, int recursionsLeft);
+static CborError container_to_pretty(CborStreamFunction stream, void *out, CborValue *it, CborType containerType,
+                                     int flags, int recursionsLeft)
+{
+    const char *comma = "";
+    CborError err = CborNoError;
+
+    if (!recursionsLeft) {
+        printRecursionLimit(stream, out);
+        while (!cbor_value_at_end(it) && !err) {
+            err = cbor_value_advance(it);
+        }
+        return err;     /* do allow the dumping to continue (if the advance was OK) */
+    }
+
+    while (!cbor_value_at_end(it) && !err) {
+        err = stream(out, "%s", comma);
+        comma = ", ";
+
+        if (!err)
+            err = value_to_pretty(stream, out, it, flags, recursionsLeft);
+
+        if (containerType == CborArrayType)
+            continue;
+
+        /* map: that was the key, so get the value */
+        if (!err)
+            err = stream(out, ": ");
+        if (!err)
+            err = value_to_pretty(stream, out, it, flags, recursionsLeft);
+    }
+    return err;
+}
+
+static CborError value_to_pretty(CborStreamFunction stream, void *out, CborValue *it, int flags, int recursionsLeft)
+{
+    CborError err = CborNoError;
+    CborType type = cbor_value_get_type(it);
+    switch (type) {
+    case CborArrayType:
+    case CborMapType: {
+        /* recursive type */
+        CborValue recursed;
+        const char *indicator = get_indicator(it, flags);
+        const char *space = *indicator ? " " : indicator;
+
+        err = stream(out, "%c%s%s", type == CborArrayType ? '[' : '{', indicator, space);
+        if (err)
+            return err;
+
+        err = cbor_value_enter_container(it, &recursed);
+        if (err) {
+            copy_current_position(it, &recursed);
+            return err;       /* parse error */
+        }
+        err = container_to_pretty(stream, out, &recursed, type, flags, recursionsLeft - 1);
+        if (err) {
+            copy_current_position(it, &recursed);
+            return err;       /* parse error */
+        }
+        err = cbor_value_leave_container(it, &recursed);
+        if (err)
+            return err;       /* parse error */
+
+        return stream(out, type == CborArrayType ? "]" : "}");
+    }
+
+    case CborIntegerType: {
+        uint64_t val;
+        cbor_value_get_raw_integer(it, &val);    /* can't fail */
+
+        if (cbor_value_is_unsigned_integer(it)) {
+            err = stream(out, "%" PRIu64, val);
+        } else {
+            /* CBOR stores the negative number X as -1 - X
+             * (that is, -1 is stored as 0, -2 as 1 and so forth) */
+            if (++val) {                /* unsigned overflow may happen */
+                err = stream(out, "-%" PRIu64, val);
+            } else {
+                /* overflown
+                 *   0xffff`ffff`ffff`ffff + 1 =
+                 * 0x1`0000`0000`0000`0000 = 18446744073709551616 (2^64) */
+                err = stream(out, "-18446744073709551616");
+            }
+        }
+        if (!err)
+            err = stream(out, "%s", get_indicator(it, flags));
+        break;
+    }
+
+    case CborByteStringType:
+    case CborTextStringType: {
+        size_t n = 0;
+        const void *ptr;
+        bool showingFragments = (flags & CborPrettyShowStringFragments) && !cbor_value_is_length_known(it);
+        const char *separator = "";
+        char close = '\'';
+        char open[3] = "h'";
+        const char *indicator = NULL;
+
+        if (type == CborTextStringType) {
+            close = open[0] = '"';
+            open[1] = '\0';
+        }
+
+        if (showingFragments)
+            err = stream(out, "(_ ");
+        else
+            err = stream(out, "%s", open);
+
+        if (!err)
+            err = cbor_value_begin_string_iteration(it);
+        while (!err) {
+            if (showingFragments || indicator == NULL) {
+                /* any iteration, except the second for a non-chunked string */
+                indicator = resolve_indicator(it, flags);
+            }
+
+            err = _cbor_value_get_string_chunk(it, &ptr, &n, it);
+            if (err == CborErrorNoMoreStringChunks) {
+                err = cbor_value_finish_string_iteration(it);
+                break;
+            }
+
+            if (!err && showingFragments)
+                err = stream(out, "%s%s", separator, open);
+            if (!err)
+                err = (type == CborByteStringType ?
+                           hexDump(stream, out, ptr, n) :
+                           utf8EscapedDump(stream, out, ptr, n));
+            if (!err && showingFragments) {
+                err = stream(out, "%c%s", close, indicator);
+                separator = ", ";
+            }
+        }
+
+        if (!err) {
+            if (showingFragments)
+                err = stream(out, ")");
+            else
+                err = stream(out, "%c%s", close, indicator);
+        }
+        return err;
+    }
+
+    case CborTagType: {
+        CborTag tag;
+        cbor_value_get_tag(it, &tag);       /* can't fail */
+        err = stream(out, "%" PRIu64 "%s(", tag, get_indicator(it, flags));
+        if (!err)
+            err = cbor_value_advance_fixed(it);
+        if (!err && recursionsLeft)
+            err = value_to_pretty(stream, out, it, flags, recursionsLeft - 1);
+        else if (!err)
+            printRecursionLimit(stream, out);
+        if (!err)
+            err = stream(out, ")");
+        return err;
+    }
+
+    case CborSimpleType: {
+        /* simple types can't fail and can't have overlong encoding */
+        uint8_t simple_type;
+        cbor_value_get_simple_type(it, &simple_type);
+        err = stream(out, "simple(%" PRIu8 ")", simple_type);
+        break;
+    }
+
+    case CborNullType:
+        err = stream(out, "null");
+        break;
+
+    case CborUndefinedType:
+        err = stream(out, "undefined");
+        break;
+
+    case CborBooleanType: {
+        bool val;
+        cbor_value_get_boolean(it, &val);       /* can't fail */
+        err = stream(out, val ? "true" : "false");
+        break;
+    }
+
+#ifndef CBOR_NO_FLOATING_POINT
+    case CborDoubleType: {
+        const char *suffix;
+        double val;
+        int r;
+        uint64_t ival;
+
+        if (false) {
+            float f;
+    case CborFloatType:
+            cbor_value_get_float(it, &f);
+            val = f;
+            suffix = flags & CborPrettyNumericEncodingIndicators ? "_2" : "f";
+        } else if (false) {
+            uint16_t f16;
+    case CborHalfFloatType:
+#ifndef CBOR_NO_HALF_FLOAT_TYPE
+            cbor_value_get_half_float(it, &f16);
+            val = decode_half(f16);
+            suffix = flags & CborPrettyNumericEncodingIndicators ? "_1" : "f16";
+#else
+            (void)f16;
+            err = CborErrorUnsupportedType;
+            break;
+#endif
+        } else {
+            cbor_value_get_double(it, &val);
+            suffix = "";
+        }
+
+        if ((flags & CborPrettyNumericEncodingIndicators) == 0) {
+            r = fpclassify(val);
+            if (r == FP_NAN || r == FP_INFINITE)
+                suffix = "";
+        }
+
+        if (convertToUint64(val, &ival)) {
+            /* this double value fits in a 64-bit integer, so show it as such
+             * (followed by a floating point suffix, to disambiguate) */
+            err = stream(out, "%s%" PRIu64 ".%s", val < 0 ? "-" : "", ival, suffix);
+        } else {
+            /* this number is definitely not a 64-bit integer */
+            err = stream(out, "%." DBL_DECIMAL_DIG_STR "g%s", val, suffix);
+        }
+        break;
+    }
+#else
+    case CborDoubleType:
+    case CborFloatType:
+    case CborHalfFloatType:
+        err = CborErrorUnsupportedType;
+        break;
+#endif /* !CBOR_NO_FLOATING_POINT */
+
+    case CborInvalidType:
+        err = stream(out, "invalid");
+        if (err)
+            return err;
+        return CborErrorUnknownType;
+    }
+
+    if (!err)
+        err = cbor_value_advance_fixed(it);
+    return err;
+}
+
+/**
+ * Converts the current CBOR type pointed by \a value to its textual
+ * representation and writes it to the stream by calling the \a streamFunction.
+ * If an error occurs, this function returns an error code similar to
+ * \ref CborParsing.
+ *
+ * The textual representation can be controlled by the \a flags parameter (see
+ * \ref CborPrettyFlags for more information).
+ *
+ * If no error ocurred, this function advances \a value to the next element.
+ * Often, concatenating the text representation of multiple elements can be
+ * done by appending a comma to the output stream in between calls to this
+ * function.
+ *
+ * The \a streamFunction function will be called with the \a token value as the
+ * first parameter and a printf-style format string as the second, with a variable
+ * number of further parameters.
+ *
+ * \sa cbor_value_to_pretty(), cbor_value_to_json_advance()
+ */
+CborError cbor_value_to_pretty_stream(CborStreamFunction streamFunction, void *token, CborValue *value, int flags)
+{
+    return value_to_pretty(streamFunction, token, value, flags, CBOR_PARSER_MAX_RECURSIONS);
+}
+
+/** @} */

frame_serialize/tinycbor/cborpretty_stdio.c

@@ -0,0 +1,87 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 Intel Corporation
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+** copies of the Software, and to permit persons to whom the Software is
+** furnished to do so, subject to the following conditions:
+**
+** The above copyright notice and this permission notice shall be included in
+** all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+** OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+** THE SOFTWARE.
+**
+****************************************************************************/
+
+#include "cbor.h"
+#include <stdarg.h>
+#include <stdio.h>
+
+static CborError cbor_fprintf(void *out, const char *fmt, ...)
+{
+    int n;
+
+    va_list list;
+    va_start(list, fmt);
+    n = vfprintf((FILE *)out, fmt, list);
+    va_end(list);
+
+    return n < 0 ? CborErrorIO : CborNoError;
+}
+
+/**
+ * \fn CborError cbor_value_to_pretty(FILE *out, const CborValue *value)
+ *
+ * Converts the current CBOR type pointed to by \a value to its textual
+ * representation and writes it to the \a out stream. If an error occurs, this
+ * function returns an error code similar to CborParsing.
+ *
+ * \sa cbor_value_to_pretty_advance(), cbor_value_to_json_advance()
+ */
+
+/**
+ * Converts the current CBOR type pointed to by \a value to its textual
+ * representation and writes it to the \a out stream. If an error occurs, this
+ * function returns an error code similar to CborParsing.
+ *
+ * If no error ocurred, this function advances \a value to the next element.
+ * Often, concatenating the text representation of multiple elements can be
+ * done by appending a comma to the output stream in between calls to this
+ * function.
+ *
+ * \sa cbor_value_to_pretty(), cbor_value_to_pretty_stream(), cbor_value_to_json_advance()
+ */
+CborError cbor_value_to_pretty_advance(FILE *out, CborValue *value)
+{
+    return cbor_value_to_pretty_stream(cbor_fprintf, out, value, CborPrettyDefaultFlags);
+}
+
+/**
+ * Converts the current CBOR type pointed to by \a value to its textual
+ * representation and writes it to the \a out stream. If an error occurs, this
+ * function returns an error code similar to CborParsing.
+ *
+ * The textual representation can be controlled by the \a flags parameter (see
+ * CborPrettyFlags for more information).
+ *
+ * If no error ocurred, this function advances \a value to the next element.
+ * Often, concatenating the text representation of multiple elements can be
+ * done by appending a comma to the output stream in between calls to this
+ * function.
+ *
+ * \sa cbor_value_to_pretty_stream(), cbor_value_to_pretty(), cbor_value_to_json_advance()
+ */
+CborError cbor_value_to_pretty_advance_flags(FILE *out, CborValue *value, int flags)
+{
+    return cbor_value_to_pretty_stream(cbor_fprintf, out, value, flags);
+}
+

frame_serialize/tinycbor/cbortojson.c

@@ -0,0 +1,709 @@
+/****************************************************************************
+**
+** Copyright (C) 2021 Intel Corporation
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+** copies of the Software, and to permit persons to whom the Software is
+** furnished to do so, subject to the following conditions:
+**
+** The above copyright notice and this permission notice shall be included in
+** all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+** OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+** THE SOFTWARE.
+**
+****************************************************************************/
+
+#define _BSD_SOURCE 1
+#define _DEFAULT_SOURCE 1
+#define _GNU_SOURCE 1
+#ifndef __STDC_LIMIT_MACROS
+#  define __STDC_LIMIT_MACROS 1
+#endif
+#define __STDC_WANT_IEC_60559_TYPES_EXT__
+
+#include "cbor.h"
+#include "cborjson.h"
+#include "cborinternal_p.h"
+#include "compilersupport_p.h"
+#include "cborinternal_p.h"
+
+#include <inttypes.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/**
+ * \defgroup CborToJson Converting CBOR to JSON
+ * \brief Group of functions used to convert CBOR to JSON.
+ *
+ * This group contains two functions that can be used to convert a \ref
+ * CborValue object to an equivalent JSON representation. This module attempts
+ * to follow the recommendations from RFC 7049 section 4.1 "Converting from
+ * CBOR to JSON", though it has a few differences. They are noted below.
+ *
+ * These functions produce a "minified" JSON output, with no spacing,
+ * indentation or line breaks. If those are necessary, they need to be applied
+ * in a post-processing phase.
+ *
+ * Note that JSON cannot support all CBOR types with fidelity, so the
+ * conversion is usually lossy. For that reason, TinyCBOR supports adding a set
+ * of metadata JSON values that can be used by a JSON-to-CBOR converter to
+ * restore the original data types.
+ *
+ * The TinyCBOR library does not provide a way to convert from JSON
+ * representation back to encoded form. However, it provides a tool called
+ * \c json2cbor which can be used for that purpose. That tool supports the
+ * metadata format that these functions may produce.
+ *
+ * Either of the functions in this section will attempt to convert exactly one
+ * CborValue object to JSON. Those functions may return any error documented
+ * for the functions for CborParsing. In addition, if the C standard library
+ * stream functions return with error, the text conversion will return with
+ * error CborErrorIO.
+ *
+ * These functions also perform UTF-8 validation in CBOR text strings. If they
+ * encounter a sequence of bytes that is not permitted in UTF-8, they will return
+ * CborErrorInvalidUtf8TextString. That includes encoding of surrogate points
+ * in UTF-8.
+ *
+ * \warning The metadata produced by these functions is not guaranteed to
+ * remain stable. A future update of TinyCBOR may produce different output for
+ * the same input and parsers may be unable to handle it.
+ *
+ * \sa CborParsing, CborPretty, cbor_parser_init()
+ */
+
+/**
+ * \addtogroup CborToJson
+ * @{
+ * <h2 class="groupheader">Conversion limitations</h2>
+ *
+ * When converting from CBOR to JSON, there may be information loss. This
+ * section lists the possible scenarios.
+ *
+ * \par Number precision:
+ * ALL JSON numbers, due to its JavaScript heritage, are IEEE 754
+ * double-precision floating point. This means JSON is not capable of
+ * representing all integers numbers outside the range [-(2<sup>53</sup>)+1,
+ * 2<sup>53</sup>-1] and is not capable of representing NaN or infinite. If the
+ * CBOR data contains a number outside the valid range, the conversion will
+ * lose precision. If the input was NaN or infinite, the result of the
+ * conversion will be the JSON null value. In addition, the distinction between
+ * half-, single- and double-precision is lost.
+ *
+ * \par
+ * If enabled, the original value and original type are stored in the metadata.
+ *
+ * \par Non-native types:
+ * CBOR's type system is richer than JSON's, which means some data values
+ * cannot be represented when converted to JSON. The conversion silently turns
+ * them into strings: CBOR simple types become "simple(nn)" where \c nn is the
+ * simple type's value, with the exception of CBOR undefined, which becomes
+ * "undefined", while CBOR byte strings are converted to an Base16, Base64, or
+ * Base64url encoding
+ *
+ * \par
+ * If enabled, the original type is stored in the metadata.
+ *
+ * \par Presence of tags:
+ * JSON has no support for tagged values, so by default tags are dropped when
+ * converting to JSON. However, if the CborConvertObeyByteStringTags option is
+ * active (default), then certain known tags are honored and are used to format
+ * the conversion of the tagged byte string to JSON.
+ *
+ * \par
+ * If the CborConvertTagsToObjects option is active, then the tag and the
+ * tagged value are converted to a JSON object. Otherwise, if enabled, the
+ * last (innermost) tag is stored in the metadata.
+ *
+ * \par Non-string keys in maps:
+ * JSON requires all Object keys to be strings, while CBOR does not. By
+ * default, if a non-string key is found, the conversion fails with error
+ * CborErrorJsonObjectKeyNotString. If the CborConvertStringifyMapKeys option
+ * is active, then the conversion attempts to create a string representation
+ * using CborPretty. Note that the \c json2cbor tool is not able to parse this
+ * back to the original form.
+ *
+ * \par Duplicate keys in maps:
+ * Neither JSON nor CBOR allow duplicated keys, but current TinyCBOR does not
+ * validate that this is the case. If there are duplicated keys in the input,
+ * they will be repeated in the output, which many JSON tools may flag as
+ * invalid. In addition to that, if the CborConvertStringifyMapKeys option is
+ * active, it is possible that a non-string key in a CBOR map will be converted
+ * to a string form that is identical to another key.
+ *
+ * \par
+ * When metadata support is active, the conversion will add extra key-value
+ * pairs to the JSON output so it can store the metadata. It is possible that
+ * the keys for the metadata clash with existing keys in the JSON map.
+ */
+
+extern FILE *open_memstream(char **bufptr, size_t *sizeptr);
+
+enum ConversionStatusFlags {
+    TypeWasNotNative            = 0x100,    /* anything but strings, boolean, null, arrays and maps */
+    TypeWasTagged               = 0x200,
+    NumberPrecisionWasLost      = 0x400,
+    NumberWasNaN                = 0x800,
+    NumberWasInfinite           = 0x1000,
+    NumberWasNegative           = 0x2000,   /* only used with NumberWasInifite or NumberWasTooBig */
+
+    FinalTypeMask               = 0xff
+};
+
+typedef struct ConversionStatus {
+    CborTag lastTag;
+    uint64_t originalNumber;
+    int flags;
+} ConversionStatus;
+
+static CborError value_to_json(FILE *out, CborValue *it, int flags, CborType type, ConversionStatus *status);
+
+static CborError dump_bytestring_base16(char **result, CborValue *it)
+{
+    static const char characters[] = "0123456789abcdef";
+    size_t i;
+    size_t n = 0;
+    uint8_t *buffer;
+    CborError err = cbor_value_calculate_string_length(it, &n);
+    if (err)
+        return err;
+
+    /* a Base16 (hex) output is twice as big as our buffer */
+    buffer = (uint8_t *)malloc(n * 2 + 1);
+    if (buffer == NULL)
+        /* out of memory */
+        return CborErrorOutOfMemory;
+
+    *result = (char *)buffer;
+
+    /* let cbor_value_copy_byte_string know we have an extra byte for the terminating NUL */
+    ++n;
+    err = cbor_value_copy_byte_string(it, buffer + n - 1, &n, it);
+    cbor_assert(err == CborNoError);
+
+    for (i = 0; i < n; ++i) {
+        uint8_t byte = buffer[n + i];
+        buffer[2*i]     = characters[byte >> 4];
+        buffer[2*i + 1] = characters[byte & 0xf];
+    }
+    return CborNoError;
+}
+
+static CborError generic_dump_base64(char **result, CborValue *it, const char alphabet[65])
+{
+    size_t n = 0, i;
+    uint8_t *buffer, *out, *in;
+    CborError err = cbor_value_calculate_string_length(it, &n);
+    if (err)
+        return err;
+
+    /* a Base64 output (untruncated) has 4 bytes for every 3 in the input */
+    size_t len = (n + 5) / 3 * 4;
+    buffer = (uint8_t *)malloc(len + 1);
+    if (buffer == NULL)
+        /* out of memory */
+        return CborErrorOutOfMemory;
+
+    out = buffer;
+    *result = (char *)buffer;
+
+    /* we read our byte string at the tail end of the buffer
+     * so we can do an in-place conversion while iterating forwards */
+    in = buffer + len - n;
+
+    /* let cbor_value_copy_byte_string know we have an extra byte for the terminating NUL */
+    ++n;
+    err = cbor_value_copy_byte_string(it, in, &n, it);
+    cbor_assert(err == CborNoError);
+
+    uint_least32_t val = 0;
+    for (i = 0; n - i >= 3; i += 3) {
+        /* read 3 bytes x 8 bits = 24 bits */
+        if (false) {
+#ifdef __GNUC__
+        } else if (i) {
+            __builtin_memcpy(&val, in + i - 1, sizeof(val));
+            val = cbor_ntohl(val);
+#endif
+        } else {
+            val = (in[i] << 16) | (in[i + 1] << 8) | in[i + 2];
+        }
+
+        /* write 4 chars x 6 bits = 24 bits */
+        *out++ = alphabet[(val >> 18) & 0x3f];
+        *out++ = alphabet[(val >> 12) & 0x3f];
+        *out++ = alphabet[(val >> 6) & 0x3f];
+        *out++ = alphabet[val & 0x3f];
+    }
+
+    /* maybe 1 or 2 bytes left */
+    if (n - i) {
+        /* we can read in[i + 1] even if it's past the end of the string because
+         * we know (by construction) that it's a NUL byte */
+#ifdef __GNUC__
+        uint16_t val16;
+        __builtin_memcpy(&val16, in + i, sizeof(val16));
+        val = cbor_ntohs(val16);
+#else
+        val = (in[i] << 8) | in[i + 1];
+#endif
+        val <<= 8;
+
+        /* the 65th character in the alphabet is our filler: either '=' or '\0' */
+        out[4] = '\0';
+        out[3] = alphabet[64];
+        if (n - i == 2) {
+            /* write the third char in 3 chars x 6 bits = 18 bits */
+            out[2] = alphabet[(val >> 6) & 0x3f];
+        } else {
+            out[2] = alphabet[64];  /* filler */
+        }
+        out[1] = alphabet[(val >> 12) & 0x3f];
+        out[0] = alphabet[(val >> 18) & 0x3f];
+    } else {
+        out[0] = '\0';
+    }
+
+    return CborNoError;
+}
+
+static CborError dump_bytestring_base64(char **result, CborValue *it)
+{
+    static const char alphabet[] = "ABCDEFGH" "IJKLMNOP" "QRSTUVWX" "YZabcdef"
+                                   "ghijklmn" "opqrstuv" "wxyz0123" "456789+/" "=";
+    return generic_dump_base64(result, it, alphabet);
+}
+
+static CborError dump_bytestring_base64url(char **result, CborValue *it)
+{
+    static const char alphabet[] = "ABCDEFGH" "IJKLMNOP" "QRSTUVWX" "YZabcdef"
+                                   "ghijklmn" "opqrstuv" "wxyz0123" "456789-_";
+    return generic_dump_base64(result, it, alphabet);
+}
+
+static CborError add_value_metadata(FILE *out, CborType type, const ConversionStatus *status)
+{
+    int flags = status->flags;
+    if (flags & TypeWasTagged) {
+        /* extract the tagged type, which may be JSON native */
+        type = flags & FinalTypeMask;
+        flags &= ~(FinalTypeMask | TypeWasTagged);
+
+        if (fprintf(out, "\"tag\":\"%" PRIu64 "\"%s", status->lastTag,
+                    flags & ~TypeWasTagged ? "," : "") < 0)
+            return CborErrorIO;
+    }
+
+    if (!flags)
+        return CborNoError;
+
+    /* print at least the type */
+    if (fprintf(out, "\"t\":%d", type) < 0)
+        return CborErrorIO;
+
+    if (flags & NumberWasNaN)
+        if (fprintf(out, ",\"v\":\"nan\"") < 0)
+            return CborErrorIO;
+    if (flags & NumberWasInfinite)
+        if (fprintf(out, ",\"v\":\"%sinf\"", flags & NumberWasNegative ? "-" : "") < 0)
+            return CborErrorIO;
+    if (flags & NumberPrecisionWasLost)
+        if (fprintf(out, ",\"v\":\"%c%" PRIx64 "\"", flags & NumberWasNegative ? '-' : '+',
+                    status->originalNumber) < 0)
+            return CborErrorIO;
+    if (type == CborSimpleType)
+        if (fprintf(out, ",\"v\":%d", (int)status->originalNumber) < 0)
+            return CborErrorIO;
+    return CborNoError;
+}
+
+static CborError find_tagged_type(CborValue *it, CborTag *tag, CborType *type)
+{
+    CborError err = CborNoError;
+    *type = cbor_value_get_type(it);
+    while (*type == CborTagType) {
+        cbor_value_get_tag(it, tag);    /* can't fail */
+        err = cbor_value_advance_fixed(it);
+        if (err)
+            return err;
+
+        *type = cbor_value_get_type(it);
+    }
+    return err;
+}
+
+static CborError tagged_value_to_json(FILE *out, CborValue *it, int flags, ConversionStatus *status)
+{
+    CborTag tag;
+    CborError err;
+
+    if (flags & CborConvertTagsToObjects) {
+        cbor_value_get_tag(it, &tag);       /* can't fail */
+        err = cbor_value_advance_fixed(it);
+        if (err)
+            return err;
+
+        if (fprintf(out, "{\"tag%" PRIu64 "\":", tag) < 0)
+            return CborErrorIO;
+
+        CborType type = cbor_value_get_type(it);
+        err = value_to_json(out, it, flags, type, status);
+        if (err)
+            return err;
+        if (flags & CborConvertAddMetadata && status->flags) {
+            if (fprintf(out, ",\"tag%" PRIu64 "$cbor\":{", tag) < 0 ||
+                    add_value_metadata(out, type, status) != CborNoError ||
+                    fputc('}', out) < 0)
+                return CborErrorIO;
+        }
+        if (fputc('}', out) < 0)
+            return CborErrorIO;
+        status->flags = TypeWasNotNative | CborTagType;
+        return CborNoError;
+    }
+
+    CborType type;
+    err = find_tagged_type(it, &status->lastTag, &type);
+    if (err)
+        return err;
+    tag = status->lastTag;
+
+    /* special handling of byte strings? */
+    if (type == CborByteStringType && (flags & CborConvertByteStringsToBase64Url) == 0 &&
+            (tag == CborNegativeBignumTag || tag == CborExpectedBase16Tag || tag == CborExpectedBase64Tag)) {
+        char *str;
+        const char *pre = "";
+
+        if (tag == CborNegativeBignumTag) {
+            pre = "~";
+            err = dump_bytestring_base64url(&str, it);
+        } else if (tag == CborExpectedBase64Tag) {
+            err = dump_bytestring_base64(&str, it);
+        } else { /* tag == CborExpectedBase16Tag */
+            err = dump_bytestring_base16(&str, it);
+        }
+        if (err)
+            return err;
+        err = fprintf(out, "\"%s%s\"", pre, str) < 0 ? CborErrorIO : CborNoError;
+        free(str);
+        status->flags = TypeWasNotNative | TypeWasTagged | CborByteStringType;
+        return err;
+    }
+
+    /* no special handling */
+    err = value_to_json(out, it, flags, type, status);
+    status->flags |= TypeWasTagged | type;
+    return err;
+}
+
+static CborError stringify_map_key(char **key, CborValue *it, int flags, CborType type)
+{
+    (void)flags;    /* unused */
+    (void)type;     /* unused */
+#ifdef WITHOUT_OPEN_MEMSTREAM
+    (void)key;      /* unused */
+    (void)it;       /* unused */
+    return CborErrorJsonNotImplemented;
+#else
+    size_t size;
+
+    FILE *memstream = open_memstream(key, &size);
+    if (memstream == NULL)
+        return CborErrorOutOfMemory;        /* could also be EMFILE, but it's unlikely */
+    CborError err = cbor_value_to_pretty_advance(memstream, it);
+
+    if (unlikely(fclose(memstream) < 0 || *key == NULL))
+        return CborErrorInternalError;
+    return err;
+#endif
+}
+
+static CborError array_to_json(FILE *out, CborValue *it, int flags, ConversionStatus *status)
+{
+    const char *comma = "";
+    while (!cbor_value_at_end(it)) {
+        if (fprintf(out, "%s", comma) < 0)
+            return CborErrorIO;
+        comma = ",";
+
+        CborError err = value_to_json(out, it, flags, cbor_value_get_type(it), status);
+        if (err)
+            return err;
+    }
+    return CborNoError;
+}
+
+static CborError map_to_json(FILE *out, CborValue *it, int flags, ConversionStatus *status)
+{
+    const char *comma = "";
+    CborError err;
+    while (!cbor_value_at_end(it)) {
+        char *key;
+        if (fprintf(out, "%s", comma) < 0)
+            return CborErrorIO;
+        comma = ",";
+
+        CborType keyType = cbor_value_get_type(it);
+        if (likely(keyType == CborTextStringType)) {
+            size_t n = 0;
+            err = cbor_value_dup_text_string(it, &key, &n, it);
+        } else if (flags & CborConvertStringifyMapKeys) {
+            err = stringify_map_key(&key, it, flags, keyType);
+        } else {
+            return CborErrorJsonObjectKeyNotString;
+        }
+        if (err)
+            return err;
+
+        /* first, print the key */
+        if (fprintf(out, "\"%s\":", key) < 0) {
+            free(key);
+            return CborErrorIO;
+        }
+
+        /* then, print the value */
+        CborType valueType = cbor_value_get_type(it);
+        err = value_to_json(out, it, flags, valueType, status);
+
+        /* finally, print any metadata we may have */
+        if (flags & CborConvertAddMetadata) {
+            if (!err && keyType != CborTextStringType) {
+                if (fprintf(out, ",\"%s$keycbordump\":true", key) < 0)
+                    err = CborErrorIO;
+            }
+            if (!err && status->flags) {
+                if (fprintf(out, ",\"%s$cbor\":{", key) < 0 ||
+                        add_value_metadata(out, valueType, status) != CborNoError ||
+                        fputc('}', out) < 0)
+                    err = CborErrorIO;
+            }
+        }
+
+        free(key);
+        if (err)
+            return err;
+    }
+    return CborNoError;
+}
+
+static CborError value_to_json(FILE *out, CborValue *it, int flags, CborType type, ConversionStatus *status)
+{
+    CborError err;
+    status->flags = 0;
+
+    switch (type) {
+    case CborArrayType:
+    case CborMapType: {
+        /* recursive type */
+        CborValue recursed;
+        err = cbor_value_enter_container(it, &recursed);
+        if (err) {
+            copy_current_position(it, &recursed);
+            return err;       /* parse error */
+        }
+        if (fputc(type == CborArrayType ? '[' : '{', out) < 0)
+            return CborErrorIO;
+
+        err = (type == CborArrayType) ?
+                  array_to_json(out, &recursed, flags, status) :
+                  map_to_json(out, &recursed, flags, status);
+        if (err) {
+            copy_current_position(it, &recursed);
+            return err;       /* parse error */
+        }
+
+        if (fputc(type == CborArrayType ? ']' : '}', out) < 0)
+            return CborErrorIO;
+        err = cbor_value_leave_container(it, &recursed);
+        if (err)
+            return err;       /* parse error */
+
+        status->flags = 0;    /* reset, there are never conversion errors for us */
+        return CborNoError;
+    }
+
+    case CborIntegerType: {
+        double num;     /* JS numbers are IEEE double precision */
+        uint64_t val;
+        cbor_value_get_raw_integer(it, &val);    /* can't fail */
+        num = (double)val;
+
+        if (cbor_value_is_negative_integer(it)) {
+            num = -num - 1;                     /* convert to negative */
+            if ((uint64_t)(-num - 1) != val) {
+                status->flags = NumberPrecisionWasLost | NumberWasNegative;
+                status->originalNumber = val;
+            }
+        } else {
+            if ((uint64_t)num != val) {
+                status->flags = NumberPrecisionWasLost;
+                status->originalNumber = val;
+            }
+        }
+        if (fprintf(out, "%.0f", num) < 0)  /* this number has no fraction, so no decimal points please */
+            return CborErrorIO;
+        break;
+    }
+
+    case CborByteStringType:
+    case CborTextStringType: {
+        char *str;
+        if (type == CborByteStringType) {
+            err = dump_bytestring_base64url(&str, it);
+            status->flags = TypeWasNotNative;
+        } else {
+            size_t n = 0;
+            err = cbor_value_dup_text_string(it, &str, &n, it);
+        }
+        if (err)
+            return err;
+        err = (fprintf(out, "\"%s\"", str) < 0) ? CborErrorIO : CborNoError;
+        free(str);
+        return err;
+    }
+
+    case CborTagType:
+        return tagged_value_to_json(out, it, flags, status);
+
+    case CborSimpleType: {
+        uint8_t simple_type;
+        cbor_value_get_simple_type(it, &simple_type);  /* can't fail */
+        status->flags = TypeWasNotNative;
+        status->originalNumber = simple_type;
+        if (fprintf(out, "\"simple(%" PRIu8 ")\"", simple_type) < 0)
+            return CborErrorIO;
+        break;
+    }
+
+    case CborNullType:
+        if (fprintf(out, "null") < 0)
+            return CborErrorIO;
+        break;
+
+    case CborUndefinedType:
+        status->flags = TypeWasNotNative;
+        if (fprintf(out, "\"undefined\"") < 0)
+            return CborErrorIO;
+        break;
+
+    case CborBooleanType: {
+        bool val;
+        cbor_value_get_boolean(it, &val);       /* can't fail */
+        if (fprintf(out, val ? "true" : "false") < 0)
+            return CborErrorIO;
+        break;
+    }
+
+#ifndef CBOR_NO_FLOATING_POINT
+    case CborDoubleType: {
+        double val;
+        if (false) {
+            float f;
+    case CborFloatType:
+            status->flags = TypeWasNotNative;
+            cbor_value_get_float(it, &f);
+            val = f;
+        } else if (false) {
+            uint16_t f16;
+    case CborHalfFloatType:
+#  ifndef CBOR_NO_HALF_FLOAT_TYPE
+            status->flags = TypeWasNotNative;
+            cbor_value_get_half_float(it, &f16);
+            val = decode_half(f16);
+#  else
+            (void)f16;
+            err = CborErrorUnsupportedType;
+            break;
+#  endif
+        } else {
+            cbor_value_get_double(it, &val);
+        }
+
+        int r = fpclassify(val);
+        if (r == FP_NAN || r == FP_INFINITE) {
+            if (fprintf(out, "null") < 0)
+                return CborErrorIO;
+            status->flags |= r == FP_NAN ? NumberWasNaN :
+                                           NumberWasInfinite | (val < 0 ? NumberWasNegative : 0);
+        } else {
+            uint64_t ival = (uint64_t)fabs(val);
+            if ((double)ival == fabs(val)) {
+                /* print as integer so we get the full precision */
+                r = fprintf(out, "%s%" PRIu64, val < 0 ? "-" : "", ival);
+                status->flags |= TypeWasNotNative;   /* mark this integer number as a double */
+            } else {
+                /* this number is definitely not a 64-bit integer */
+                r = fprintf(out, "%." DBL_DECIMAL_DIG_STR "g", val);
+            }
+            if (r < 0)
+                return CborErrorIO;
+        }
+        break;
+    }
+#else
+    case CborDoubleType:
+    case CborFloatType:
+    case CborHalfFloatType:
+        err = CborErrorUnsupportedType;
+        break;
+#endif /* !CBOR_NO_FLOATING_POINT */
+
+    case CborInvalidType:
+        return CborErrorUnknownType;
+    }
+
+    return cbor_value_advance_fixed(it);
+}
+
+/**
+ * \enum CborToJsonFlags
+ * The CborToJsonFlags enum contains flags that control the conversion of CBOR to JSON.
+ *
+ * \value CborConvertAddMetadata        Adds metadata to facilitate restoration of the original CBOR data.
+ * \value CborConvertTagsToObjects      Converts CBOR tags to JSON objects
+ * \value CborConvertIgnoreTags         (default) Ignore CBOR tags, except for byte strings
+ * \value CborConvertObeyByteStringTags (default) Honor formatting of CBOR byte strings if so tagged
+ * \value CborConvertByteStringsToBase64Url Force the conversion of all CBOR byte strings to Base64url encoding, despite any tags
+ * \value CborConvertRequireMapStringKeys (default) Require CBOR map keys to be strings, failing the conversion if they are not
+ * \value CborConvertStringifyMapKeys   Convert non-string keys in CBOR maps to a string form
+ * \value CborConvertDefaultFlags       Default conversion flags.
+ */
+
+/**
+ * \fn CborError cbor_value_to_json(FILE *out, const CborValue *value, int flags)
+ *
+ * Converts the current CBOR type pointed to by \a value to JSON and writes that
+ * to the \a out stream. If an error occurs, this function returns an error
+ * code similar to CborParsing. The \a flags parameter indicates one or more of
+ * the flags from CborToJsonFlags that control the conversion.
+ *
+ * \sa cbor_value_to_json_advance(), cbor_value_to_pretty()
+ */
+
+/**
+ * Converts the current CBOR type pointed to by \a value to JSON and writes that
+ * to the \a out stream. If an error occurs, this function returns an error
+ * code similar to CborParsing. The \a flags parameter indicates one or more of
+ * the flags from CborToJsonFlags that control the conversion.
+ *
+ * If no error ocurred, this function advances \a value to the next element.
+ *
+ * \sa cbor_value_to_json(), cbor_value_to_pretty_advance()
+ */
+CborError cbor_value_to_json_advance(FILE *out, CborValue *value, int flags)
+{
+    ConversionStatus status;
+    return value_to_json(out, value, flags, cbor_value_get_type(value), &status);
+}
+
+/** @} */

frame_serialize/tinycbor/cborvalidation.c

@@ -0,0 +1,658 @@
+/****************************************************************************
+**
+** Copyright (C) 2021 Intel Corporation
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+** copies of the Software, and to permit persons to whom the Software is
+** furnished to do so, subject to the following conditions:
+**
+** The above copyright notice and this permission notice shall be included in
+** all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+** OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+** THE SOFTWARE.
+**
+****************************************************************************/
+
+#define _BSD_SOURCE 1
+#define _DEFAULT_SOURCE 1
+#ifndef __STDC_LIMIT_MACROS
+#  define __STDC_LIMIT_MACROS 1
+#endif
+#define __STDC_WANT_IEC_60559_TYPES_EXT__
+
+#include "cbor.h"
+#include "cborinternal_p.h"
+#include "compilersupport_p.h"
+#include "utf8_p.h"
+
+#include <string.h>
+
+#ifndef CBOR_NO_FLOATING_POINT
+#  include <float.h>
+#  include <math.h>
+#endif
+
+
+#ifndef CBOR_PARSER_MAX_RECURSIONS
+#  define CBOR_PARSER_MAX_RECURSIONS 1024
+#endif
+
+/**
+ * \addtogroup CborParsing
+ * @{
+ */
+
+/**
+ * \enum CborValidationFlags
+ * The CborValidationFlags enum contains flags that control the validation of a
+ * CBOR stream.
+ *
+ * \value CborValidateBasic         Validates only the syntactic correctedness of the stream.
+ * \value CborValidateCanonical     Validates that the stream is in canonical format, according to
+ *                                  RFC 7049 section 3.9.
+ * \value CborValidateStrictMode    Performs strict validation, according to RFC 7049 section 3.10.
+ * \value CborValidateStrictest     Attempt to perform the strictest validation we know of.
+ *
+ * \value CborValidateShortestIntegrals     (Canonical) Validate that integral numbers and lengths are
+ *                                          enconded in their shortest form possible.
+ * \value CborValidateShortestFloatingPoint (Canonical) Validate that floating-point numbers are encoded
+ *                                          in their shortest form possible.
+ * \value CborValidateShortestNumbers       (Canonical) Validate both integral and floating-point numbers
+ *                                          are in their shortest form possible.
+ * \value CborValidateNoIndeterminateLength (Canonical) Validate that no string, array or map uses
+ *                                          indeterminate length encoding.
+ * \value CborValidateMapIsSorted           (Canonical & Strict mode) Validate that map keys appear in
+ *                                          sorted order.
+ * \value CborValidateMapKeysAreUnique      (Strict mode) Validate that map keys are unique.
+ * \value CborValidateTagUse                (Strict mode) Validate that known tags are used with the
+ *                                          correct types. This does not validate that the content of
+ *                                          those types is syntactically correct. For example, this
+ *                                          option validates that tag 1 (DateTimeString) is used with
+ *                                          a Text String, but it does not validate that the string is
+ *                                          a valid date/time representation.
+ * \value CborValidateUtf8                  (Strict mode) Validate that text strings are appropriately
+ *                                          encoded in UTF-8.
+ * \value CborValidateMapKeysAreString      Validate that all map keys are text strings.
+ * \value CborValidateNoUndefined           Validate that no elements of type "undefined" are present.
+ * \value CborValidateNoTags                Validate that no tags are used.
+ * \value CborValidateFiniteFloatingPoint   Validate that all floating point numbers are finite (no NaN or
+ *                                          infinities are allowed).
+ * \value CborValidateCompleteData          Validate that the stream is complete and there is no more data
+ *                                          in the buffer.
+ * \value CborValidateNoUnknownSimpleTypesSA Validate that all Standards Action simple types are registered
+ *                                          with IANA.
+ * \value CborValidateNoUnknownSimpleTypes  Validate that all simple types used are registered with IANA.
+ * \value CborValidateNoUnknownTagsSA       Validate that all Standard Actions tags are registered with IANA.
+ * \value CborValidateNoUnknownTagsSR       Validate that all Standard Actions and Specification Required tags
+ *                                          are registered with IANA (see below for limitations).
+ * \value CborValidateNoUnkonwnTags         Validate that all tags are registered with IANA
+ *                                          (see below for limitations).
+ *
+ * \par Simple type registry
+ * The CBOR specification requires that registration for use of the first 19
+ * simple types must be done by way of Standards Action. The rest of the simple
+ * types only require a specification. The official list can be obtained from
+ *  https://www.iana.org/assignments/cbor-simple-values/cbor-simple-values.xhtml.
+ *
+ * \par
+ * There are no registered simple types recognized by this release of TinyCBOR
+ * (beyond those defined by RFC 7049).
+ *
+ * \par Tag registry
+ * The CBOR specification requires that registration for use of the first 23
+ * tags must be done by way of Standards Action. The next up to tag 255 only
+ * require a specification. Finally, all other tags can be registered on a
+ * first-come-first-serve basis. The official list can be ontained from
+ *  https://www.iana.org/assignments/cbor-tags/cbor-tags.xhtml.
+ *
+ * \par
+ * Given the variability of this list, TinyCBOR cannot recognize all tags
+ * registered with IANA. Instead, the implementation only recognizes tags
+ * that are backed by an RFC.
+ *
+ * \par
+ * These are the tags known to the current TinyCBOR release:
+<table>
+  <tr>
+    <th>Tag</th>
+    <th>Data Item</th>
+    <th>Semantics</th>
+  </tr>
+  <tr>
+    <td>0</td>
+    <td>UTF-8 text string</td>
+    <td>Standard date/time string</td>
+  </tr>
+  <tr>
+    <td>1</td>
+    <td>integer</td>
+    <td>Epoch-based date/time</td>
+  </tr>
+  <tr>
+    <td>2</td>
+    <td>byte string</td>
+    <td>Positive bignum</td>
+  </tr>
+  <tr>
+    <td>3</td>
+    <td>byte string</td>
+    <td>Negative bignum</td>
+  </tr>
+  <tr>
+    <td>4</td>
+    <td>array</td>
+    <td>Decimal fraction</td>
+  </tr>
+  <tr>
+    <td>5</td>
+    <td>array</td>
+    <td>Bigfloat</td>
+  </tr>
+  <tr>
+    <td>16</td>
+    <td>array</td>
+    <td>COSE Single Recipient Encrypted Data Object (RFC 8152)</td>
+  </tr>
+  <tr>
+    <td>17</td>
+    <td>array</td>
+    <td>COSE Mac w/o Recipients Object (RFC 8152)</td>
+  </tr>
+  <tr>
+    <td>18</td>
+    <td>array</td>
+    <td>COSE Single Signer Data Object (RFC 8162)</td>
+  </tr>
+  <tr>
+    <td>21</td>
+    <td>byte string, array, map</td>
+    <td>Expected conversion to base64url encoding</td>
+  </tr>
+  <tr>
+    <td>22</td>
+    <td>byte string, array, map</td>
+    <td>Expected conversion to base64 encoding</td>
+  </tr>
+  <tr>
+    <td>23</td>
+    <td>byte string, array, map</td>
+    <td>Expected conversion to base16 encoding</td>
+  </tr>
+  <tr>
+    <td>24</td>
+    <td>byte string</td>
+    <td>Encoded CBOR data item</td>
+  </tr>
+  <tr>
+    <td>32</td>
+    <td>UTF-8 text string</td>
+    <td>URI</td>
+  </tr>
+  <tr>
+    <td>33</td>
+    <td>UTF-8 text string</td>
+    <td>base64url</td>
+  </tr>
+  <tr>
+    <td>34</td>
+    <td>UTF-8 text string</td>
+    <td>base64</td>
+  </tr>
+  <tr>
+    <td>35</td>
+    <td>UTF-8 text string</td>
+    <td>Regular expression</td>
+  </tr>
+  <tr>
+    <td>36</td>
+    <td>UTF-8 text string</td>
+    <td>MIME message</td>
+  </tr>
+  <tr>
+    <td>96</td>
+    <td>array</td>
+    <td>COSE Encrypted Data Object (RFC 8152)</td>
+  </tr>
+  <tr>
+    <td>97</td>
+    <td>array</td>
+    <td>COSE MACed Data Object (RFC 8152)</td>
+  </tr>
+  <tr>
+    <td>98</td>
+    <td>array</td>
+    <td>COSE Signed Data Object (RFC 8152)</td>
+  </tr>
+  <tr>
+    <td>55799</td>
+    <td>any</td>
+    <td>Self-describe CBOR</td>
+  </tr>
+</table>
+ */
+
+struct KnownTagData { uint32_t tag; uint32_t types; };
+static const struct KnownTagData knownTagData[] = {
+    { 0, (uint32_t)CborTextStringType },
+    { 1, (uint32_t)(CborIntegerType+1) },
+    { 2, (uint32_t)CborByteStringType },
+    { 3, (uint32_t)CborByteStringType },
+    { 4, (uint32_t)CborArrayType },
+    { 5, (uint32_t)CborArrayType },
+    { 16, (uint32_t)CborArrayType },
+    { 17, (uint32_t)CborArrayType },
+    { 18, (uint32_t)CborArrayType },
+    { 21, (uint32_t)CborByteStringType | ((uint32_t)CborArrayType << 8) | ((uint32_t)CborMapType << 16) },
+    { 22, (uint32_t)CborByteStringType | ((uint32_t)CborArrayType << 8) | ((uint32_t)CborMapType << 16) },
+    { 23, (uint32_t)CborByteStringType | ((uint32_t)CborArrayType << 8) | ((uint32_t)CborMapType << 16) },
+    { 24, (uint32_t)CborByteStringType },
+    { 32, (uint32_t)CborTextStringType },
+    { 33, (uint32_t)CborTextStringType },
+    { 34, (uint32_t)CborTextStringType },
+    { 35, (uint32_t)CborTextStringType },
+    { 36, (uint32_t)CborTextStringType },
+    { 96, (uint32_t)CborArrayType },
+    { 97, (uint32_t)CborArrayType },
+    { 98, (uint32_t)CborArrayType },
+    { 55799, 0U }
+};
+
+static CborError validate_value(CborValue *it, uint32_t flags, int recursionLeft);
+
+static inline CborError validate_utf8_string(const void *ptr, size_t n)
+{
+    const uint8_t *buffer = (const uint8_t *)ptr;
+    const uint8_t * const end = buffer + n;
+    while (buffer < end) {
+        uint32_t uc = get_utf8(&buffer, end);
+        if (uc == ~0U)
+            return CborErrorInvalidUtf8TextString;
+    }
+    return CborNoError;
+}
+
+static inline CborError validate_simple_type(uint8_t simple_type, uint32_t flags)
+{
+    /* At current time, all known simple types are those from RFC 7049,
+     * which are parsed by the parser into different CBOR types.
+     * That means that if we've got here, the type is unknown */
+    if (simple_type < 32)
+        return (flags & CborValidateNoUnknownSimpleTypesSA) ? CborErrorUnknownSimpleType : CborNoError;
+    return (flags & CborValidateNoUnknownSimpleTypes) == CborValidateNoUnknownSimpleTypes ?
+                CborErrorUnknownSimpleType : CborNoError;
+}
+
+static inline CborError validate_number(const CborValue *it, CborType type, uint32_t flags)
+{
+    CborError err = CborNoError;
+    size_t bytesUsed, bytesNeeded;
+    uint64_t value;
+
+    if ((flags & CborValidateShortestIntegrals) == 0)
+        return err;
+    if (type >= CborHalfFloatType && type <= CborDoubleType)
+        return err;     /* checked elsewhere */
+
+    err = extract_number_checked(it, &value, &bytesUsed);
+    if (err)
+        return err;
+
+    bytesNeeded = 0;
+    if (value >= Value8Bit)
+        ++bytesNeeded;
+    if (value > 0xffU)
+        ++bytesNeeded;
+    if (value > 0xffffU)
+        bytesNeeded += 2;
+    if (value > 0xffffffffU)
+        bytesNeeded += 4;
+    if (bytesNeeded < bytesUsed)
+        return CborErrorOverlongEncoding;
+    return CborNoError;
+}
+
+static inline CborError validate_tag(CborValue *it, CborTag tag, uint32_t flags, int recursionLeft)
+{
+    CborType type = cbor_value_get_type(it);
+    const size_t knownTagCount = sizeof(knownTagData) / sizeof(knownTagData[0]);
+    const struct KnownTagData *tagData = knownTagData;
+    const struct KnownTagData * const knownTagDataEnd = knownTagData + knownTagCount;
+
+    if (!recursionLeft)
+        return CborErrorNestingTooDeep;
+    if (flags & CborValidateNoTags)
+        return CborErrorExcludedType;
+
+    /* find the tag data, if any */
+    for ( ; tagData != knownTagDataEnd; ++tagData) {
+        if (tagData->tag < tag)
+            continue;
+        if (tagData->tag > tag)
+            tagData = NULL;
+        break;
+    }
+    if (tagData == knownTagDataEnd)
+        tagData = NULL;
+
+    if (flags & CborValidateNoUnknownTags && !tagData) {
+        /* tag not found */
+        if (flags & CborValidateNoUnknownTagsSA && tag < 24)
+            return CborErrorUnknownTag;
+        if ((flags & CborValidateNoUnknownTagsSR) == CborValidateNoUnknownTagsSR && tag < 256)
+            return CborErrorUnknownTag;
+        if ((flags & CborValidateNoUnknownTags) == CborValidateNoUnknownTags)
+            return CborErrorUnknownTag;
+    }
+
+    if (flags & CborValidateTagUse && tagData && tagData->types) {
+        uint32_t allowedTypes = tagData->types;
+
+        /* correct Integer so it's not zero */
+        if (type == CborIntegerType)
+            type = (CborType)(type + 1);
+
+        while (allowedTypes) {
+            if ((uint8_t)(allowedTypes & 0xff) == type)
+                break;
+            allowedTypes >>= 8;
+        }
+        if (!allowedTypes)
+            return CborErrorInappropriateTagForType;
+    }
+
+    return validate_value(it, flags, recursionLeft);
+}
+
+#ifndef CBOR_NO_FLOATING_POINT
+static inline CborError validate_floating_point(CborValue *it, CborType type, uint32_t flags)
+{
+    CborError err;
+    int r;
+    double val;
+    float valf;
+    uint16_t valf16 = 0x7c01;       /* dummy value, an infinity */
+
+    if (type != CborDoubleType) {
+        if (type == CborFloatType) {
+            err = cbor_value_get_float(it, &valf);
+            val = valf;
+        } else {
+#  ifdef CBOR_NO_HALF_FLOAT_TYPE
+            (void)valf16;
+            return CborErrorUnsupportedType;
+#  else
+            err = cbor_value_get_half_float(it, &valf16);
+            val = decode_half(valf16);
+#  endif
+        }
+    } else {
+        err = cbor_value_get_double(it, &val);
+    }
+    cbor_assert(err == CborNoError);     /* can't fail */
+
+    r = fpclassify(val);
+    if (r == FP_NAN || r == FP_INFINITE) {
+        if (flags & CborValidateFiniteFloatingPoint)
+            return CborErrorExcludedValue;
+        if (flags & CborValidateShortestFloatingPoint) {
+            if (type == CborDoubleType)
+                return CborErrorOverlongEncoding;
+#  ifndef CBOR_NO_HALF_FLOAT_TYPE
+            if (type == CborFloatType)
+                return CborErrorOverlongEncoding;
+            if (r == FP_NAN && valf16 != 0x7e00)
+                return CborErrorImproperValue;
+            if (r == FP_INFINITE && valf16 != 0x7c00 && valf16 != 0xfc00)
+                return CborErrorImproperValue;
+#  endif
+        }
+    }
+
+    if (flags & CborValidateShortestFloatingPoint && type > CborHalfFloatType) {
+        if (type == CborDoubleType) {
+            valf = (float)val;
+            if ((double)valf == val)
+                return CborErrorOverlongEncoding;
+        }
+#  ifndef CBOR_NO_HALF_FLOAT_TYPE
+        if (type == CborFloatType) {
+            valf16 = encode_half(valf);
+            if (valf == decode_half(valf16))
+                return CborErrorOverlongEncoding;
+        }
+#  endif
+    }
+
+    return CborNoError;
+}
+#endif
+
+static CborError validate_container(CborValue *it, int containerType, uint32_t flags, int recursionLeft)
+{
+    CborError err;
+    const uint8_t *previous = NULL;
+    const uint8_t *previous_end = NULL;
+
+    if (!recursionLeft)
+        return CborErrorNestingTooDeep;
+
+    while (!cbor_value_at_end(it)) {
+        const uint8_t *current = cbor_value_get_next_byte(it);
+
+        if (containerType == CborMapType) {
+            if (flags & CborValidateMapKeysAreString) {
+                CborType type = cbor_value_get_type(it);
+                if (type == CborTagType) {
+                    /* skip the tags */
+                    CborValue copy = *it;
+                    err = cbor_value_skip_tag(&copy);
+                    if (err)
+                        return err;
+                    type = cbor_value_get_type(&copy);
+                }
+                if (type != CborTextStringType)
+                    return CborErrorMapKeyNotString;
+            }
+        }
+
+        err = validate_value(it, flags, recursionLeft);
+        if (err)
+            return err;
+
+        if (containerType != CborMapType)
+            continue;
+
+        if (flags & CborValidateMapIsSorted) {
+            if (it->parser->flags & CborParserFlag_ExternalSource)
+                return CborErrorUnimplementedValidation;
+            if (previous) {
+                size_t bytelen1 = (size_t)(previous_end - previous);
+                size_t bytelen2 = (size_t)(cbor_value_get_next_byte(it) - current);
+                int r = memcmp(previous, current, bytelen1 <= bytelen2 ? bytelen1 : bytelen2);
+
+                if (r == 0 && bytelen1 != bytelen2)
+                    r = bytelen1 < bytelen2 ? -1 : +1;
+                if (r > 0)
+                    return CborErrorMapNotSorted;
+                if (r == 0 && (flags & CborValidateMapKeysAreUnique) == CborValidateMapKeysAreUnique)
+                    return CborErrorMapKeysNotUnique;
+            }
+
+            previous = current;
+            previous_end = cbor_value_get_next_byte(it);
+        }
+
+        /* map: that was the key, so get the value */
+        err = validate_value(it, flags, recursionLeft);
+        if (err)
+            return err;
+    }
+    return CborNoError;
+}
+
+static CborError validate_value(CborValue *it, uint32_t flags, int recursionLeft)
+{
+    CborError err;
+    CborType type = cbor_value_get_type(it);
+
+    if (cbor_value_is_length_known(it)) {
+        err = validate_number(it, type, flags);
+        if (err)
+            return err;
+    } else {
+        if (flags & CborValidateNoIndeterminateLength)
+            return CborErrorUnknownLength;
+    }
+
+    switch (type) {
+    case CborArrayType:
+    case CborMapType: {
+        /* recursive type */
+        CborValue recursed;
+        err = cbor_value_enter_container(it, &recursed);
+        if (!err)
+            err = validate_container(&recursed, type, flags, recursionLeft - 1);
+        if (err) {
+            copy_current_position(it, &recursed);
+            return err;
+        }
+        err = cbor_value_leave_container(it, &recursed);
+        if (err)
+            return err;
+        return CborNoError;
+    }
+
+    case CborIntegerType: {
+        uint64_t val;
+        err = cbor_value_get_raw_integer(it, &val);
+        cbor_assert(err == CborNoError);         /* can't fail */
+
+        break;
+    }
+
+    case CborByteStringType:
+    case CborTextStringType: {
+        size_t n = 0;
+        const void *ptr;
+
+        err = cbor_value_begin_string_iteration(it);
+        if (err)
+            return err;
+
+        while (1) {
+            CborValue next;
+            err = _cbor_value_get_string_chunk(it, &ptr, &n, &next);
+            if (!err) {
+                err = validate_number(it, type, flags);
+                if (err)
+                    return err;
+            }
+
+            *it = next;
+            if (err == CborErrorNoMoreStringChunks)
+                return cbor_value_finish_string_iteration(it);
+            if (err)
+                return err;
+
+            if (type == CborTextStringType && flags & CborValidateUtf8) {
+                err = validate_utf8_string(ptr, n);
+                if (err)
+                    return err;
+            }
+        }
+
+        return CborNoError;
+    }
+
+    case CborTagType: {
+        CborTag tag;
+        err = cbor_value_get_tag(it, &tag);
+        cbor_assert(err == CborNoError);     /* can't fail */
+
+        err = cbor_value_advance_fixed(it);
+        if (err)
+            return err;
+        err = validate_tag(it, tag, flags, recursionLeft - 1);
+        if (err)
+            return err;
+
+        return CborNoError;
+    }
+
+    case CborSimpleType: {
+        uint8_t simple_type;
+        err = cbor_value_get_simple_type(it, &simple_type);
+        cbor_assert(err == CborNoError);     /* can't fail */
+        err = validate_simple_type(simple_type, flags);
+        if (err)
+            return err;
+        break;
+    }
+
+    case CborNullType:
+    case CborBooleanType:
+        break;
+
+    case CborUndefinedType:
+        if (flags & CborValidateNoUndefined)
+            return CborErrorExcludedType;
+        break;
+
+    case CborHalfFloatType:
+    case CborFloatType:
+    case CborDoubleType: {
+#ifdef CBOR_NO_FLOATING_POINT
+        return CborErrorUnsupportedType;
+#else
+        err = validate_floating_point(it, type, flags);
+        if (err)
+            return err;
+        break;
+#endif /* !CBOR_NO_FLOATING_POINT */
+    }
+
+    case CborInvalidType:
+        return CborErrorUnknownType;
+    }
+
+    err = cbor_value_advance_fixed(it);
+    return err;
+}
+
+/**
+ * Performs a full validation, controlled by the \a flags options, of the CBOR
+ * stream pointed by \a it and returns the error it found. If no error was
+ * found, it returns CborNoError and the application can iterate over the items
+ * with certainty that no errors will appear during parsing.
+ *
+ * If \a flags is CborValidateBasic, the result should be the same as
+ * cbor_value_validate_basic().
+ *
+ * This function has the same timing and memory requirements as
+ * cbor_value_advance() and cbor_value_validate_basic().
+ *
+ * \sa CborValidationFlags, cbor_value_validate_basic(), cbor_value_advance()
+ */
+CborError cbor_value_validate(const CborValue *it, uint32_t flags)
+{
+    CborValue value = *it;
+    CborError err = validate_value(&value, flags, CBOR_PARSER_MAX_RECURSIONS);
+    if (err)
+        return err;
+    if (flags & CborValidateCompleteData && can_read_bytes(&value, 1))
+        return CborErrorGarbageAtEnd;
+    return CborNoError;
+}
+
+/**
+ * @}
+ */

frame_serialize/tinycbor/compilersupport_p.h

@@ -0,0 +1,221 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 Intel Corporation
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+** copies of the Software, and to permit persons to whom the Software is
+** furnished to do so, subject to the following conditions:
+**
+** The above copyright notice and this permission notice shall be included in
+** all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+** OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+** THE SOFTWARE.
+**
+****************************************************************************/
+
+#ifndef COMPILERSUPPORT_H
+#define COMPILERSUPPORT_H
+
+#include "cbor.h"
+
+#ifndef _BSD_SOURCE
+#  define _BSD_SOURCE
+#endif
+#ifndef _DEFAULT_SOURCE
+#  define _DEFAULT_SOURCE
+#endif
+#ifndef assert
+#  include <assert.h>
+#endif
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
+#ifndef __cplusplus
+#  include <stdbool.h>
+#endif
+
+#if __STDC_VERSION__ >= 201112L || (defined(__cplusplus) && __cplusplus >= 201103L) || (defined(__cpp_static_assert) && __cpp_static_assert >= 200410)
+#  define cbor_static_assert(x)         static_assert(x, #x)
+#elif !defined(__cplusplus) && defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 406) && (__STDC_VERSION__ > 199901L)
+#  define cbor_static_assert(x)         _Static_assert(x, #x)
+#else
+#  define cbor_static_assert(x)         ((void)sizeof(char[2*!!(x) - 1]))
+#endif
+#if __STDC_VERSION__ >= 199901L || defined(__cplusplus)
+/* inline is a keyword */
+#else
+/* use the definition from cbor.h */
+#  define inline    CBOR_INLINE
+#endif
+
+#ifdef NDEBUG
+#  define cbor_assert(cond)     do { if (!(cond)) unreachable(); } while (0)
+#else
+#  define cbor_assert(cond)     assert(cond)
+#endif
+
+#ifndef STRINGIFY
+#define STRINGIFY(x)            STRINGIFY2(x)
+#endif
+#define STRINGIFY2(x)           #x
+
+#if !defined(UINT32_MAX) || !defined(INT64_MAX)
+/* C89? We can define UINT32_MAX portably, but not INT64_MAX */
+#  error "Your system has stdint.h but that doesn't define UINT32_MAX or INT64_MAX"
+#endif
+
+#ifndef DBL_DECIMAL_DIG
+/* DBL_DECIMAL_DIG is C11 */
+#  define DBL_DECIMAL_DIG       17
+#endif
+#define DBL_DECIMAL_DIG_STR     STRINGIFY(DBL_DECIMAL_DIG)
+
+#if defined(__GNUC__) && defined(__i386__) && !defined(__iamcu__)
+#  define CBOR_INTERNAL_API_CC          __attribute__((regparm(3)))
+#elif defined(_MSC_VER) && defined(_M_IX86)
+#  define CBOR_INTERNAL_API_CC          __fastcall
+#else
+#  define CBOR_INTERNAL_API_CC
+#endif
+
+#ifndef __has_builtin
+#  define __has_builtin(x)  0
+#endif
+
+#if (defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 403)) || \
+    (__has_builtin(__builtin_bswap64) && __has_builtin(__builtin_bswap32))
+#  if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+#    define cbor_ntohll     __builtin_bswap64
+#    define cbor_htonll     __builtin_bswap64
+#    define cbor_ntohl      __builtin_bswap32
+#    define cbor_htonl      __builtin_bswap32
+#    ifdef __INTEL_COMPILER
+#      define cbor_ntohs    _bswap16
+#      define cbor_htons    _bswap16
+#    elif (__GNUC__ * 100 + __GNUC_MINOR__ >= 608) || __has_builtin(__builtin_bswap16)
+#      define cbor_ntohs    __builtin_bswap16
+#      define cbor_htons    __builtin_bswap16
+#    else
+#      define cbor_ntohs(x) (((uint16_t)(x) >> 8) | ((uint16_t)(x) << 8))
+#      define cbor_htons    cbor_ntohs
+#    endif
+#  else
+#    define cbor_ntohll
+#    define cbor_htonll
+#    define cbor_ntohl
+#    define cbor_htonl
+#    define cbor_ntohs
+#    define cbor_htons
+#  endif
+#elif defined(__sun)
+#  include <sys/byteorder.h>
+#elif defined(_MSC_VER)
+/* MSVC, which implies Windows, which implies little-endian and sizeof(long) == 4 */
+#  include <stdlib.h>
+#  define cbor_ntohll       _byteswap_uint64
+#  define cbor_htonll       _byteswap_uint64
+#  define cbor_ntohl        _byteswap_ulong
+#  define cbor_htonl        _byteswap_ulong
+#  define cbor_ntohs        _byteswap_ushort
+#  define cbor_htons        _byteswap_ushort
+#elif defined(__ICCARM__)
+#  if __LITTLE_ENDIAN__ == 1
+#    include <intrinsics.h>
+#    define ntohll(x)       ((__REV((uint32_t)(x)) * UINT64_C(0x100000000)) + (__REV((x) >> 32)))
+#    define htonll          ntohll
+#    define cbor_ntohl     __REV
+#    define cbor_htonl     __REV
+#    define cbor_ntohs     __REVSH
+#    define cbor_htons     __REVSH
+#  else
+#    define cbor_ntohll
+#    define cbor_htonll
+#    define cbor_ntohl
+#    define cbor_htonl
+#    define cbor_ntohs
+#    define cbor_htons
+#  endif
+#endif
+#ifndef cbor_ntohs
+#  include <arpa/inet.h>
+#  define cbor_ntohs        ntohs
+#  define cbor_htons        htons
+#endif
+#ifndef cbor_ntohl
+#  include <arpa/inet.h>
+#  define cbor_ntohl        ntohl
+#  define cbor_htonl        htonl
+#endif
+#ifndef cbor_ntohll
+#  define cbor_ntohll       ntohll
+#  define cbor_htonll       htonll
+/* ntohll isn't usually defined */
+#  ifndef ntohll
+#    if (defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__) || \
+    (defined(__BYTE_ORDER) && defined(__BIG_ENDIAN) && __BYTE_ORDER == __BIG_ENDIAN) || \
+    (defined(BYTE_ORDER) && defined(BIG_ENDIAN) && BYTE_ORDER == BIG_ENDIAN) || \
+    (defined(_BIG_ENDIAN) && !defined(_LITTLE_ENDIAN)) || (defined(__BIG_ENDIAN__) && !defined(__LITTLE_ENDIAN__)) || \
+    defined(__ARMEB__) || defined(__MIPSEB__) || defined(__s390__) || defined(__sparc__)
+#      define ntohll
+#      define htonll
+#    elif (defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) || \
+    (defined(__BYTE_ORDER) && defined(__LITTLE_ENDIAN) && __BYTE_ORDER == __LITTLE_ENDIAN) || \
+    (defined(BYTE_ORDER) && defined(LITTLE_ENDIAN) && BYTE_ORDER == LITTLE_ENDIAN) || \
+    defined(_LITTLE_ENDIAN) || defined(__LITTLE_ENDIAN__) || defined(__ARMEL__) || defined(__MIPSEL__) || \
+    defined(__i386) || defined(__i386__) || defined(__x86_64) || defined(__x86_64__) || defined(__amd64)
+#      define ntohll(x)       ((cbor_ntohl((uint32_t)(x)) * UINT64_C(0x100000000)) + (cbor_ntohl((x) >> 32)))
+#      define htonll          ntohll
+#    else
+#      error "Unable to determine byte order!"
+#    endif
+#  endif
+#endif
+
+
+#ifdef __cplusplus
+#  define CONST_CAST(t, v)  const_cast<t>(v)
+#else
+/* C-style const_cast without triggering a warning with -Wcast-qual */
+#  define CONST_CAST(t, v)  (t)(uintptr_t)(v)
+#endif
+
+#ifdef __GNUC__
+#ifndef likely
+#  define likely(x)     __builtin_expect(!!(x), 1)
+#endif
+#ifndef unlikely
+#  define unlikely(x)   __builtin_expect(!!(x), 0)
+#endif
+#  define unreachable() __builtin_unreachable()
+#elif defined(_MSC_VER)
+#  define likely(x)     (x)
+#  define unlikely(x)   (x)
+#  define unreachable() __assume(0)
+#else
+#  define likely(x)     (x)
+#  define unlikely(x)   (x)
+#  define unreachable() do {} while (0)
+#endif
+
+static inline bool add_check_overflow(size_t v1, size_t v2, size_t *r)
+{
+#if ((defined(__GNUC__) && (__GNUC__ >= 5)) && !defined(__INTEL_COMPILER)) || __has_builtin(__builtin_add_overflow)
+    return __builtin_add_overflow(v1, v2, r);
+#else
+    /* unsigned additions are well-defined */
+    *r = v1 + v2;
+    return v1 > v1 + v2;
+#endif
+}
+
+#endif /* COMPILERSUPPORT_H */

frame_serialize/tinycbor/open_memstream.c

@@ -0,0 +1,114 @@
+/****************************************************************************
+**
+** Copyright (C) 2015 Intel Corporation
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+** copies of the Software, and to permit persons to whom the Software is
+** furnished to do so, subject to the following conditions:
+**
+** The above copyright notice and this permission notice shall be included in
+** all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+** OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+** THE SOFTWARE.
+**
+****************************************************************************/
+
+#define _BSD_SOURCE 1
+#define _DEFAULT_SOURCE 1
+#define _GNU_SOURCE 1
+
+#include <sys/types.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#if defined(__unix__) || defined(__APPLE__)
+#  include <unistd.h>
+#endif
+#ifdef __APPLE__
+typedef int RetType;
+typedef int LenType;
+#elif __linux__
+typedef ssize_t RetType;
+typedef size_t LenType;
+#else
+#  error "Cannot implement open_memstream!"
+#endif
+
+#include "compilersupport_p.h"
+
+struct Buffer
+{
+    char **ptr;
+    size_t *len;
+    size_t alloc;
+};
+
+static RetType write_to_buffer(void *cookie, const char *data, LenType len)
+{
+    struct Buffer *b = (struct Buffer *)cookie;
+    char *ptr = *b->ptr;
+    size_t newsize;
+
+    errno = EFBIG;
+    if (unlikely(add_check_overflow(*b->len, len, &newsize)))
+        return -1;
+
+    if (newsize >= b->alloc) { // NB! one extra byte is needed to avoid buffer overflow at close_buffer
+        // make room
+        size_t newalloc = newsize + newsize / 2 + 1;    // give 50% more room
+        ptr = realloc(ptr, newalloc);
+        if (ptr == NULL)
+            return -1;
+        b->alloc = newalloc;
+        *b->ptr = ptr;
+    }
+
+    memcpy(ptr + *b->len, data, len);
+    *b->len = newsize;
+    return len;
+}
+
+static int close_buffer(void *cookie)
+{
+    struct Buffer *b = (struct Buffer *)cookie;
+    if (*b->ptr)
+        (*b->ptr)[*b->len] = '\0';
+    free(b);
+    return 0;
+}
+
+FILE *open_memstream(char **bufptr, size_t *lenptr)
+{
+    struct Buffer *b = (struct Buffer *)malloc(sizeof(struct Buffer));
+    if (b == NULL)
+        return NULL;
+    b->alloc = 0;
+    b->len = lenptr;
+    b->ptr = bufptr;
+    *bufptr = NULL;
+    *lenptr = 0;
+
+#ifdef __APPLE__
+    return funopen(b, NULL, write_to_buffer, NULL, close_buffer);
+#elif __linux__
+    static const cookie_io_functions_t vtable = {
+        NULL,
+        write_to_buffer,
+        NULL,
+        close_buffer
+    };
+    return fopencookie(b, "w", vtable);
+#endif
+}
+

frame_serialize/tinycbor/tinycbor-version.h

@@ -0,0 +1,3 @@
+#define TINYCBOR_VERSION_MAJOR      0
+#define TINYCBOR_VERSION_MINOR      6
+#define TINYCBOR_VERSION_PATCH      0

frame_serialize/tinycbor/utf8_p.h

@@ -0,0 +1,104 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 Intel Corporation
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+** copies of the Software, and to permit persons to whom the Software is
+** furnished to do so, subject to the following conditions:
+**
+** The above copyright notice and this permission notice shall be included in
+** all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+** OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+** THE SOFTWARE.
+**
+****************************************************************************/
+
+#ifndef CBOR_UTF8_H
+#define CBOR_UTF8_H
+
+#include "compilersupport_p.h"
+
+#include <stdint.h>
+
+static inline uint32_t get_utf8(const uint8_t **buffer, const uint8_t *end)
+{
+    int charsNeeded;
+    uint32_t uc, min_uc;
+    uint8_t b;
+    ptrdiff_t n = end - *buffer;
+    if (n == 0)
+        return ~0U;
+
+    uc = *(*buffer)++;
+    if (uc < 0x80) {
+        /* single-byte UTF-8 */
+        return uc;
+    }
+
+    /* multi-byte UTF-8, decode it */
+    if (unlikely(uc <= 0xC1))
+        return ~0U;
+    if (uc < 0xE0) {
+        /* two-byte UTF-8 */
+        charsNeeded = 2;
+        min_uc = 0x80;
+        uc &= 0x1f;
+    } else if (uc < 0xF0) {
+        /* three-byte UTF-8 */
+        charsNeeded = 3;
+        min_uc = 0x800;
+        uc &= 0x0f;
+    } else if (uc < 0xF5) {
+        /* four-byte UTF-8 */
+        charsNeeded = 4;
+        min_uc = 0x10000;
+        uc &= 0x07;
+    } else {
+        return ~0U;
+    }
+
+    if (n < charsNeeded)
+        return ~0U;
+
+    /* first continuation character */
+    b = *(*buffer)++;
+    if ((b & 0xc0) != 0x80)
+        return ~0U;
+    uc <<= 6;
+    uc |= b & 0x3f;
+
+    if (charsNeeded > 2) {
+        /* second continuation character */
+        b = *(*buffer)++;
+        if ((b & 0xc0) != 0x80)
+            return ~0U;
+        uc <<= 6;
+        uc |= b & 0x3f;
+
+        if (charsNeeded > 3) {
+            /* third continuation character */
+            b = *(*buffer)++;
+            if ((b & 0xc0) != 0x80)
+                return ~0U;
+            uc <<= 6;
+            uc |= b & 0x3f;
+        }
+    }
+
+    /* overlong sequence? surrogate pair? out or range? */
+    if (uc < min_uc || uc - 0xd800U < 2048U || uc > 0x10ffff)
+        return ~0U;
+
+    return uc;
+}
+
+#endif /* CBOR_UTF8_H */

frontend_ui/src/components/PreviewImage.tsx

@@ -14,6 +14,7 @@ type MyState = {
     update: boolean,
     connection_error: boolean
 }
+
 class PreviewImage extends Component<MyProps, MyState> {
     interval: NodeJS.Timer | undefined;
 
@@ -24,7 +25,8 @@ class PreviewImage extends Component<MyProps, MyState> {
             jpeg_quality: 95,
             show_spots: true,
             show_roi: false,
-            show_indexed: false
+            show_indexed: false,
+            resolution_ring: 0.5
         },
         s_url: "",
         update: true,
@@ -70,6 +72,17 @@ class PreviewImage extends Component<MyProps, MyState> {
         );
     }
 
+    setResolutionRing = (event: Event, newValue: number | number[]) => {
+        this.setState(prevState => (
+            {
+                settings : {
+                    ...prevState.settings,
+                    resolution_ring: newValue as number
+                }
+            }
+        ));
+    }
+
     showIndexedToggle = (event: React.ChangeEvent<HTMLInputElement>) => {
         this.setState(prevState => (
             {
@@ -133,6 +146,13 @@ class PreviewImage extends Component<MyProps, MyState> {
                             onChange={this.setSaturation} valueLabelDisplay="auto"/> <br/>Saturation value
                 </Box>
                 &nbsp;&nbsp;&nbsp;
+                <Box sx={{ width: 200 }}>
+                    <Slider disabled={this.state.connection_error}
+                            value={(this.state.settings.resolution_ring === undefined) ? 0.5 : Number(this.state.settings.resolution_ring)}
+                            min={0.5} max={5.0} step={0.1}
+                            onChange={this.setResolutionRing} valueLabelDisplay="auto"/> <br/>Resolution Ring
+                </Box> &nbsp;&nbsp;&nbsp;
+
             </Stack>
             <br/>
             {

frontend_ui/src/openapi/models/preview_settings.ts

@@ -27,5 +27,6 @@ export type preview_settings = {
      * Preview indexed images only
      */
     show_indexed?: boolean;
+    resolution_ring?: number;
 };
 

image_analysis/CMakeLists.txt

@@ -18,7 +18,14 @@ TARGET_INCLUDE_DIRECTORIES(JFJochImageAnalysis PUBLIC fast-feedback-indexer/eige
 
 IF (CMAKE_CUDA_COMPILER)
     SET(CMAKE_CUDA_ARCHITECTURES 70 75 80 86 89)
-    ADD_SUBDIRECTORY(fast-feedback-indexer)
+
+    FetchContent_Declare(
+            fast-indexer
+            GIT_REPOSITORY https://github.com/paulscherrerinstitute/fast-feedback-indexer/
+            GIT_TAG 2d6fa7511f240eeb4918dd7647edd0642e987317
+    )
+
+    FetchContent_MakeAvailable(fast-indexer)
     TARGET_LINK_LIBRARIES(JFJochImageAnalysis fast_indexer_static)
 ELSE()
     MESSAGE(WARNING "CUDA is strongly recommended for image analysis." )

include/spdlog/LICENSE

@@ -22,5 +22,5 @@ THE SOFTWARE.
 
 -- NOTE: Third party dependency used by this software --
 This software depends on the fmt lib (MIT License),
-and users must comply to its license: https://github.com/fmtlib/fmt/blob/master/LICENSE.rst
+and users must comply to its license: https://raw.githubusercontent.com/fmtlib/fmt/master/LICENSE
 

include/spdlog/async.h

@@ -18,9 +18,9 @@
 #include <spdlog/details/registry.h>
 #include <spdlog/details/thread_pool.h>
 
+#include <functional>
 #include <memory>
 #include <mutex>
-#include <functional>
 
 namespace spdlog {
 
@@ -31,12 +31,10 @@ static const size_t default_async_q_size = 8192;
 // async logger factory - creates async loggers backed with thread pool.
 // if a global thread pool doesn't already exist, create it with default queue
 // size of 8192 items and single thread.
-template<async_overflow_policy OverflowPolicy = async_overflow_policy::block>
-struct async_factory_impl
-{
-    template<typename Sink, typename... SinkArgs>
-    static std::shared_ptr<async_logger> create(std::string logger_name, SinkArgs &&... args)
-    {
+template <async_overflow_policy OverflowPolicy = async_overflow_policy::block>
+struct async_factory_impl {
+    template <typename Sink, typename... SinkArgs>
+    static std::shared_ptr<async_logger> create(std::string logger_name, SinkArgs &&...args) {
         auto &registry_inst = details::registry::instance();
 
         // create global thread pool if not already exists..
@@ -44,14 +42,14 @@ struct async_factory_impl
         auto &mutex = registry_inst.tp_mutex();
         std::lock_guard<std::recursive_mutex> tp_lock(mutex);
         auto tp = registry_inst.get_tp();
-        if (tp == nullptr)
-        {
+        if (tp == nullptr) {
             tp = std::make_shared<details::thread_pool>(details::default_async_q_size, 1U);
             registry_inst.set_tp(tp);
         }
 
         auto sink = std::make_shared<Sink>(std::forward<SinkArgs>(args)...);
-        auto new_logger = std::make_shared<async_logger>(std::move(logger_name), std::move(sink), std::move(tp), OverflowPolicy);
+        auto new_logger = std::make_shared<async_logger>(std::move(logger_name), std::move(sink),
+                                                         std::move(tp), OverflowPolicy);
         registry_inst.initialize_logger(new_logger);
         return new_logger;
     }
@@ -60,40 +58,43 @@ struct async_factory_impl
 using async_factory = async_factory_impl<async_overflow_policy::block>;
 using async_factory_nonblock = async_factory_impl<async_overflow_policy::overrun_oldest>;
 
-template<typename Sink, typename... SinkArgs>
-inline std::shared_ptr<spdlog::logger> create_async(std::string logger_name, SinkArgs &&... sink_args)
-{
-    return async_factory::create<Sink>(std::move(logger_name), std::forward<SinkArgs>(sink_args)...);
+template <typename Sink, typename... SinkArgs>
+inline std::shared_ptr<spdlog::logger> create_async(std::string logger_name,
+                                                    SinkArgs &&...sink_args) {
+    return async_factory::create<Sink>(std::move(logger_name),
+                                       std::forward<SinkArgs>(sink_args)...);
 }
 
-template<typename Sink, typename... SinkArgs>
-inline std::shared_ptr<spdlog::logger> create_async_nb(std::string logger_name, SinkArgs &&... sink_args)
-{
-    return async_factory_nonblock::create<Sink>(std::move(logger_name), std::forward<SinkArgs>(sink_args)...);
+template <typename Sink, typename... SinkArgs>
+inline std::shared_ptr<spdlog::logger> create_async_nb(std::string logger_name,
+                                                       SinkArgs &&...sink_args) {
+    return async_factory_nonblock::create<Sink>(std::move(logger_name),
+                                                std::forward<SinkArgs>(sink_args)...);
 }
 
 // set global thread pool.
-inline void init_thread_pool(
-    size_t q_size, size_t thread_count, std::function<void()> on_thread_start, std::function<void()> on_thread_stop)
-{
-    auto tp = std::make_shared<details::thread_pool>(q_size, thread_count, on_thread_start, on_thread_stop);
+inline void init_thread_pool(size_t q_size,
+                             size_t thread_count,
+                             std::function<void()> on_thread_start,
+                             std::function<void()> on_thread_stop) {
+    auto tp = std::make_shared<details::thread_pool>(q_size, thread_count, on_thread_start,
+                                                     on_thread_stop);
     details::registry::instance().set_tp(std::move(tp));
 }
 
-inline void init_thread_pool(size_t q_size, size_t thread_count, std::function<void()> on_thread_start)
-{
+inline void init_thread_pool(size_t q_size,
+                             size_t thread_count,
+                             std::function<void()> on_thread_start) {
     init_thread_pool(q_size, thread_count, on_thread_start, [] {});
 }
 
-inline void init_thread_pool(size_t q_size, size_t thread_count)
-{
+inline void init_thread_pool(size_t q_size, size_t thread_count) {
     init_thread_pool(
         q_size, thread_count, [] {}, [] {});
 }
 
 // get the global thread pool.
-inline std::shared_ptr<spdlog::details::thread_pool> thread_pool()
-{
+inline std::shared_ptr<spdlog::details::thread_pool> thread_pool() {
     return details::registry::instance().get_tp();
 }
-} // namespace spdlog
+}  // namespace spdlog

include/spdlog/async_logger-inl.h

@@ -4,88 +4,82 @@
 #pragma once
 
 #ifndef SPDLOG_HEADER_ONLY
-#    include <spdlog/async_logger.h>
+    #include <spdlog/async_logger.h>
 #endif
 
-#include <spdlog/sinks/sink.h>
 #include <spdlog/details/thread_pool.h>
+#include <spdlog/sinks/sink.h>
 
 #include <memory>
 #include <string>
 
-SPDLOG_INLINE spdlog::async_logger::async_logger(
-    std::string logger_name, sinks_init_list sinks_list, std::weak_ptr<details::thread_pool> tp, async_overflow_policy overflow_policy)
-    : async_logger(std::move(logger_name), sinks_list.begin(), sinks_list.end(), std::move(tp), overflow_policy)
-{}
+SPDLOG_INLINE spdlog::async_logger::async_logger(std::string logger_name,
+                                                 sinks_init_list sinks_list,
+                                                 std::weak_ptr<details::thread_pool> tp,
+                                                 async_overflow_policy overflow_policy)
+    : async_logger(std::move(logger_name),
+                   sinks_list.begin(),
+                   sinks_list.end(),
+                   std::move(tp),
+                   overflow_policy) {}
 
-SPDLOG_INLINE spdlog::async_logger::async_logger(
-    std::string logger_name, sink_ptr single_sink, std::weak_ptr<details::thread_pool> tp, async_overflow_policy overflow_policy)
-    : async_logger(std::move(logger_name), {std::move(single_sink)}, std::move(tp), overflow_policy)
-{}
+SPDLOG_INLINE spdlog::async_logger::async_logger(std::string logger_name,
+                                                 sink_ptr single_sink,
+                                                 std::weak_ptr<details::thread_pool> tp,
+                                                 async_overflow_policy overflow_policy)
+    : async_logger(
+          std::move(logger_name), {std::move(single_sink)}, std::move(tp), overflow_policy) {}
 
 // send the log message to the thread pool
-SPDLOG_INLINE void spdlog::async_logger::sink_it_(const details::log_msg &msg)
-{
-    if (auto pool_ptr = thread_pool_.lock())
-    {
+SPDLOG_INLINE void spdlog::async_logger::sink_it_(const details::log_msg &msg){
+    SPDLOG_TRY{if (auto pool_ptr = thread_pool_.lock()){
         pool_ptr->post_log(shared_from_this(), msg, overflow_policy_);
-    }
-    else
-    {
-        throw_spdlog_ex("async log: thread pool doesn't exist anymore");
-    }
+}
+else {
+    throw_spdlog_ex("async log: thread pool doesn't exist anymore");
+}
+}
+SPDLOG_LOGGER_CATCH(msg.source)
 }
 
 // send flush request to the thread pool
-SPDLOG_INLINE void spdlog::async_logger::flush_()
-{
-    if (auto pool_ptr = thread_pool_.lock())
-    {
-        pool_ptr->post_flush(shared_from_this(), overflow_policy_);
-    }
-    else
-    {
-        throw_spdlog_ex("async flush: thread pool doesn't exist anymore");
-    }
+SPDLOG_INLINE void spdlog::async_logger::flush_(){SPDLOG_TRY{auto pool_ptr = thread_pool_.lock();
+if (!pool_ptr) {
+    throw_spdlog_ex("async flush: thread pool doesn't exist anymore");
+}
+
+std::future<void> future = pool_ptr->post_flush(shared_from_this(), overflow_policy_);
+// Wait for the flush operation to complete.
+// This might throw exception if the flush message get dropped because of overflow.
+future.get();
+}
+SPDLOG_LOGGER_CATCH(source_loc())
 }
 
 //
 // backend functions - called from the thread pool to do the actual job
 //
-SPDLOG_INLINE void spdlog::async_logger::backend_sink_it_(const details::log_msg &msg)
-{
-    for (auto &sink : sinks_)
-    {
-        if (sink->should_log(msg.level))
-        {
-            SPDLOG_TRY
-            {
-                sink->log(msg);
-            }
+SPDLOG_INLINE void spdlog::async_logger::backend_sink_it_(const details::log_msg &msg) {
+    for (auto &sink : sinks_) {
+        if (sink->should_log(msg.level)) {
+            SPDLOG_TRY { sink->log(msg); }
             SPDLOG_LOGGER_CATCH(msg.source)
         }
     }
 
-    if (should_flush_(msg))
-    {
+    if (should_flush_(msg)) {
         backend_flush_();
     }
 }
 
-SPDLOG_INLINE void spdlog::async_logger::backend_flush_()
-{
-    for (auto &sink : sinks_)
-    {
-        SPDLOG_TRY
-        {
-            sink->flush();
-        }
+SPDLOG_INLINE void spdlog::async_logger::backend_flush_() {
+    for (auto &sink : sinks_) {
+        SPDLOG_TRY { sink->flush(); }
         SPDLOG_LOGGER_CATCH(source_loc())
     }
 }
 
-SPDLOG_INLINE std::shared_ptr<spdlog::logger> spdlog::async_logger::clone(std::string new_name)
-{
+SPDLOG_INLINE std::shared_ptr<spdlog::logger> spdlog::async_logger::clone(std::string new_name) {
     auto cloned = std::make_shared<spdlog::async_logger>(*this);
     cloned->name_ = std::move(new_name);
     return cloned;

include/spdlog/async_logger.h

@@ -19,35 +19,41 @@
 namespace spdlog {
 
 // Async overflow policy - block by default.
-enum class async_overflow_policy
-{
-    block,         // Block until message can be enqueued
-    overrun_oldest // Discard oldest message in the queue if full when trying to
-                   // add new item.
+enum class async_overflow_policy {
+    block,           // Block until message can be enqueued
+    overrun_oldest,  // Discard oldest message in the queue if full when trying to
+                     // add new item.
+    discard_new      // Discard new message if the queue is full when trying to add new item.
 };
 
 namespace details {
 class thread_pool;
 }
 
-class SPDLOG_API async_logger final : public std::enable_shared_from_this<async_logger>, public logger
-{
+class SPDLOG_API async_logger final : public std::enable_shared_from_this<async_logger>,
+                                      public logger {
     friend class details::thread_pool;
 
 public:
-    template<typename It>
-    async_logger(std::string logger_name, It begin, It end, std::weak_ptr<details::thread_pool> tp,
-        async_overflow_policy overflow_policy = async_overflow_policy::block)
-        : logger(std::move(logger_name), begin, end)
-        , thread_pool_(std::move(tp))
-        , overflow_policy_(overflow_policy)
-    {}
+    template <typename It>
+    async_logger(std::string logger_name,
+                 It begin,
+                 It end,
+                 std::weak_ptr<details::thread_pool> tp,
+                 async_overflow_policy overflow_policy = async_overflow_policy::block)
+        : logger(std::move(logger_name), begin, end),
+          thread_pool_(std::move(tp)),
+          overflow_policy_(overflow_policy) {}
 
-    async_logger(std::string logger_name, sinks_init_list sinks_list, std::weak_ptr<details::thread_pool> tp,
-        async_overflow_policy overflow_policy = async_overflow_policy::block);
+    async_logger(std::string logger_name,
+                 sinks_init_list sinks_list,
+                 std::weak_ptr<details::thread_pool> tp,
+                 async_overflow_policy overflow_policy = async_overflow_policy::block);
 
-    async_logger(std::string logger_name, sink_ptr single_sink, std::weak_ptr<details::thread_pool> tp,
-        async_overflow_policy overflow_policy = async_overflow_policy::block);
+    async_logger(std::string logger_name,
+                 sink_ptr single_sink,
+                 std::weak_ptr<details::thread_pool> tp,
+                 async_overflow_policy overflow_policy = async_overflow_policy::block);
 
     std::shared_ptr<logger> clone(std::string new_name) override;
 
@@ -61,8 +67,8 @@ private:
     std::weak_ptr<details::thread_pool> thread_pool_;
     async_overflow_policy overflow_policy_;
 };
-} // namespace spdlog
+}  // namespace spdlog
 
 #ifdef SPDLOG_HEADER_ONLY
-#    include "async_logger-inl.h"
+    #include "async_logger-inl.h"
 #endif

include/spdlog/cfg/argv.h

@@ -21,24 +21,20 @@ namespace spdlog {
 namespace cfg {
 
 // search for SPDLOG_LEVEL= in the args and use it to init the levels
-inline void load_argv_levels(int argc, const char **argv)
-{
+inline void load_argv_levels(int argc, const char **argv) {
     const std::string spdlog_level_prefix = "SPDLOG_LEVEL=";
-    for (int i = 1; i < argc; i++)
-    {
+    for (int i = 1; i < argc; i++) {
         std::string arg = argv[i];
-        if (arg.find(spdlog_level_prefix) == 0)
-        {
+        if (arg.find(spdlog_level_prefix) == 0) {
             auto levels_string = arg.substr(spdlog_level_prefix.size());
             helpers::load_levels(levels_string);
         }
     }
 }
 
-inline void load_argv_levels(int argc, char **argv)
-{
+inline void load_argv_levels(int argc, char **argv) {
     load_argv_levels(argc, const_cast<const char **>(argv));
 }
 
-} // namespace cfg
-} // namespace spdlog
+}  // namespace cfg
+}  // namespace spdlog

include/spdlog/cfg/env.h

@@ -3,8 +3,8 @@
 
 #pragma once
 #include <spdlog/cfg/helpers.h>
-#include <spdlog/details/registry.h>
 #include <spdlog/details/os.h>
+#include <spdlog/details/registry.h>
 
 //
 // Init levels and patterns from env variables SPDLOG_LEVEL
@@ -25,14 +25,12 @@
 
 namespace spdlog {
 namespace cfg {
-inline void load_env_levels()
-{
+inline void load_env_levels() {
     auto env_val = details::os::getenv("SPDLOG_LEVEL");
-    if (!env_val.empty())
-    {
+    if (!env_val.empty()) {
         helpers::load_levels(env_val);
     }
 }
 
-} // namespace cfg
-} // namespace spdlog
+}  // namespace cfg
+}  // namespace spdlog

include/spdlog/cfg/helpers-inl.h

@@ -4,33 +4,32 @@
 #pragma once
 
 #ifndef SPDLOG_HEADER_ONLY
-#    include <spdlog/cfg/helpers.h>
+    #include <spdlog/cfg/helpers.h>
 #endif
 
-#include <spdlog/spdlog.h>
 #include <spdlog/details/os.h>
 #include <spdlog/details/registry.h>
+#include <spdlog/spdlog.h>
 
 #include <algorithm>
+#include <sstream>
 #include <string>
 #include <utility>
-#include <sstream>
 
 namespace spdlog {
 namespace cfg {
 namespace helpers {
 
 // inplace convert to lowercase
-inline std::string &to_lower_(std::string &str)
-{
-    std::transform(
-        str.begin(), str.end(), str.begin(), [](char ch) { return static_cast<char>((ch >= 'A' && ch <= 'Z') ? ch + ('a' - 'A') : ch); });
+inline std::string &to_lower_(std::string &str) {
+    std::transform(str.begin(), str.end(), str.begin(), [](char ch) {
+        return static_cast<char>((ch >= 'A' && ch <= 'Z') ? ch + ('a' - 'A') : ch);
+    });
     return str;
 }
 
 // inplace trim spaces
-inline std::string &trim_(std::string &str)
-{
+inline std::string &trim_(std::string &str) {
     const char *spaces = " \n\r\t";
     str.erase(str.find_last_not_of(spaces) + 1);
     str.erase(0, str.find_first_not_of(spaces));
@@ -44,16 +43,12 @@ inline std::string &trim_(std::string &str)
 // "key=" => ("key", "")
 // "val" => ("", "val")
 
-inline std::pair<std::string, std::string> extract_kv_(char sep, const std::string &str)
-{
+inline std::pair<std::string, std::string> extract_kv_(char sep, const std::string &str) {
     auto n = str.find(sep);
     std::string k, v;
-    if (n == std::string::npos)
-    {
+    if (n == std::string::npos) {
         v = str;
-    }
-    else
-    {
+    } else {
         k = str.substr(0, n);
         v = str.substr(n + 1);
     }
@@ -62,15 +57,12 @@ inline std::pair<std::string, std::string> extract_kv_(char sep, const std::stri
 
 // return vector of key/value pairs from sequence of "K1=V1,K2=V2,.."
 // "a=AAA,b=BBB,c=CCC,.." => {("a","AAA"),("b","BBB"),("c", "CCC"),...}
-inline std::unordered_map<std::string, std::string> extract_key_vals_(const std::string &str)
-{
+inline std::unordered_map<std::string, std::string> extract_key_vals_(const std::string &str) {
     std::string token;
     std::istringstream token_stream(str);
     std::unordered_map<std::string, std::string> rv{};
-    while (std::getline(token_stream, token, ','))
-    {
-        if (token.empty())
-        {
+    while (std::getline(token_stream, token, ',')) {
+        if (token.empty()) {
             continue;
         }
         auto kv = extract_kv_('=', token);
@@ -79,10 +71,8 @@ inline std::unordered_map<std::string, std::string> extract_key_vals_(const std:
     return rv;
 }
 
-SPDLOG_INLINE void load_levels(const std::string &input)
-{
-    if (input.empty() || input.size() > 512)
-    {
+SPDLOG_INLINE void load_levels(const std::string &input) {
+    if (input.empty() || input.size() > 512) {
         return;
     }
 
@@ -91,30 +81,27 @@ SPDLOG_INLINE void load_levels(const std::string &input)
     level::level_enum global_level = level::info;
     bool global_level_found = false;
 
-    for (auto &name_level : key_vals)
-    {
+    for (auto &name_level : key_vals) {
         auto &logger_name = name_level.first;
         auto level_name = to_lower_(name_level.second);
         auto level = level::from_str(level_name);
         // ignore unrecognized level names
-        if (level == level::off && level_name != "off")
-        {
+        if (level == level::off && level_name != "off") {
             continue;
         }
-        if (logger_name.empty()) // no logger name indicate global level
+        if (logger_name.empty())  // no logger name indicate global level
         {
             global_level_found = true;
             global_level = level;
-        }
-        else
-        {
+        } else {
             levels[logger_name] = level;
         }
     }
 
-    details::registry::instance().set_levels(std::move(levels), global_level_found ? &global_level : nullptr);
+    details::registry::instance().set_levels(std::move(levels),
+                                             global_level_found ? &global_level : nullptr);
 }
 
-} // namespace helpers
-} // namespace cfg
-} // namespace spdlog
+}  // namespace helpers
+}  // namespace cfg
+}  // namespace spdlog

include/spdlog/cfg/helpers.h

@@ -19,11 +19,11 @@ namespace helpers {
 // turn off all logging except for logger1 and logger2: "off,logger1=debug,logger2=info"
 //
 SPDLOG_API void load_levels(const std::string &txt);
-} // namespace helpers
+}  // namespace helpers
 
-} // namespace cfg
-} // namespace spdlog
+}  // namespace cfg
+}  // namespace spdlog
 
 #ifdef SPDLOG_HEADER_ONLY
-#    include "helpers-inl.h"
-#endif // SPDLOG_HEADER_ONLY
+    #include "helpers-inl.h"
+#endif  // SPDLOG_HEADER_ONLY

include/spdlog/common-inl.h

@@ -4,7 +4,7 @@
 #pragma once
 
 #ifndef SPDLOG_HEADER_ONLY
-#    include <spdlog/common.h>
+    #include <spdlog/common.h>
 #endif
 
 #include <algorithm>
@@ -20,41 +20,34 @@ constexpr
 
 static const char *short_level_names[] SPDLOG_SHORT_LEVEL_NAMES;
 
-SPDLOG_INLINE const string_view_t &to_string_view(spdlog::level::level_enum l) SPDLOG_NOEXCEPT
-{
+SPDLOG_INLINE const string_view_t &to_string_view(spdlog::level::level_enum l) SPDLOG_NOEXCEPT {
     return level_string_views[l];
 }
 
-SPDLOG_INLINE const char *to_short_c_str(spdlog::level::level_enum l) SPDLOG_NOEXCEPT
-{
+SPDLOG_INLINE const char *to_short_c_str(spdlog::level::level_enum l) SPDLOG_NOEXCEPT {
     return short_level_names[l];
 }
 
-SPDLOG_INLINE spdlog::level::level_enum from_str(const std::string &name) SPDLOG_NOEXCEPT
-{
+SPDLOG_INLINE spdlog::level::level_enum from_str(const std::string &name) SPDLOG_NOEXCEPT {
     auto it = std::find(std::begin(level_string_views), std::end(level_string_views), name);
     if (it != std::end(level_string_views))
         return static_cast<level::level_enum>(std::distance(std::begin(level_string_views), it));
 
     // check also for "warn" and "err" before giving up..
-    if (name == "warn")
-    {
+    if (name == "warn") {
         return level::warn;
     }
-    if (name == "err")
-    {
+    if (name == "err") {
         return level::err;
     }
     return level::off;
 }
-} // namespace level
+}  // namespace level
 
 SPDLOG_INLINE spdlog_ex::spdlog_ex(std::string msg)
-    : msg_(std::move(msg))
-{}
+    : msg_(std::move(msg)) {}
 
-SPDLOG_INLINE spdlog_ex::spdlog_ex(const std::string &msg, int last_errno)
-{
+SPDLOG_INLINE spdlog_ex::spdlog_ex(const std::string &msg, int last_errno) {
 #ifdef SPDLOG_USE_STD_FORMAT
     msg_ = std::system_error(std::error_code(last_errno, std::generic_category()), msg).what();
 #else
@@ -64,19 +57,12 @@ SPDLOG_INLINE spdlog_ex::spdlog_ex(const std::string &msg, int last_errno)
 #endif
 }
 
-SPDLOG_INLINE const char *spdlog_ex::what() const SPDLOG_NOEXCEPT
-{
-    return msg_.c_str();
-}
+SPDLOG_INLINE const char *spdlog_ex::what() const SPDLOG_NOEXCEPT { return msg_.c_str(); }
 
-SPDLOG_INLINE void throw_spdlog_ex(const std::string &msg, int last_errno)
-{
+SPDLOG_INLINE void throw_spdlog_ex(const std::string &msg, int last_errno) {
     SPDLOG_THROW(spdlog_ex(msg, last_errno));
 }
 
-SPDLOG_INLINE void throw_spdlog_ex(std::string msg)
-{
-    SPDLOG_THROW(spdlog_ex(std::move(msg)));
-}
+SPDLOG_INLINE void throw_spdlog_ex(std::string msg) { SPDLOG_THROW(spdlog_ex(std::move(msg))); }
 
-} // namespace spdlog
+}  // namespace spdlog

include/spdlog/common.h

@@ -3,106 +3,121 @@
 
 #pragma once
 
-#include <spdlog/tweakme.h>
 #include <spdlog/details/null_mutex.h>
+#include <spdlog/tweakme.h>
 
 #include <atomic>
 #include <chrono>
+#include <cstdio>
+#include <exception>
+#include <functional>
 #include <initializer_list>
 #include <memory>
-#include <exception>
 #include <string>
 #include <type_traits>
-#include <functional>
-#include <cstdio>
 
 #ifdef SPDLOG_USE_STD_FORMAT
-#    include <string_view>
+    #include <version>
+    #if __cpp_lib_format >= 202207L
+        #include <format>
+    #else
+        #include <string_view>
+    #endif
 #endif
 
 #ifdef SPDLOG_COMPILED_LIB
-#    undef SPDLOG_HEADER_ONLY
-#    if defined(SPDLOG_SHARED_LIB)
-#        if defined(_WIN32)
-#            ifdef spdlog_EXPORTS
-#                define SPDLOG_API __declspec(dllexport)
-#            else // !spdlog_EXPORTS
-#                define SPDLOG_API __declspec(dllimport)
-#            endif
-#        else // !defined(_WIN32)
-#            define SPDLOG_API __attribute__((visibility("default")))
-#        endif
-#    else // !defined(SPDLOG_SHARED_LIB)
-#        define SPDLOG_API
-#    endif
-#    define SPDLOG_INLINE
-#else // !defined(SPDLOG_COMPILED_LIB)
-#    define SPDLOG_API
-#    define SPDLOG_HEADER_ONLY
-#    define SPDLOG_INLINE inline
-#endif // #ifdef SPDLOG_COMPILED_LIB
+    #undef SPDLOG_HEADER_ONLY
+    #if defined(SPDLOG_SHARED_LIB)
+        #if defined(_WIN32)
+            #ifdef spdlog_EXPORTS
+                #define SPDLOG_API __declspec(dllexport)
+            #else  // !spdlog_EXPORTS
+                #define SPDLOG_API __declspec(dllimport)
+            #endif
+        #else  // !defined(_WIN32)
+            #define SPDLOG_API __attribute__((visibility("default")))
+        #endif
+    #else  // !defined(SPDLOG_SHARED_LIB)
+        #define SPDLOG_API
+    #endif
+    #define SPDLOG_INLINE
+#else  // !defined(SPDLOG_COMPILED_LIB)
+    #define SPDLOG_API
+    #define SPDLOG_HEADER_ONLY
+    #define SPDLOG_INLINE inline
+#endif  // #ifdef SPDLOG_COMPILED_LIB
 
 #include <spdlog/fmt/fmt.h>
 
-#if !defined(SPDLOG_USE_STD_FORMAT) && FMT_VERSION >= 80000 // backward compatibility with fmt versions older than 8
-#    define SPDLOG_FMT_RUNTIME(format_string) fmt::runtime(format_string)
-#    define SPDLOG_FMT_STRING(format_string) FMT_STRING(format_string)
-#    if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
-#        include <spdlog/fmt/xchar.h>
-#    endif
+#if !defined(SPDLOG_USE_STD_FORMAT) && \
+    FMT_VERSION >= 80000  // backward compatibility with fmt versions older than 8
+    #define SPDLOG_FMT_RUNTIME(format_string) fmt::runtime(format_string)
+    #define SPDLOG_FMT_STRING(format_string) FMT_STRING(format_string)
+    #if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
+        #include <spdlog/fmt/xchar.h>
+    #endif
 #else
-#    define SPDLOG_FMT_RUNTIME(format_string) format_string
-#    define SPDLOG_FMT_STRING(format_string) format_string
+    #define SPDLOG_FMT_RUNTIME(format_string) format_string
+    #define SPDLOG_FMT_STRING(format_string) format_string
 #endif
 
 // visual studio up to 2013 does not support noexcept nor constexpr
 #if defined(_MSC_VER) && (_MSC_VER < 1900)
-#    define SPDLOG_NOEXCEPT _NOEXCEPT
-#    define SPDLOG_CONSTEXPR
-#    define SPDLOG_CONSTEXPR_FUNC
+    #define SPDLOG_NOEXCEPT _NOEXCEPT
+    #define SPDLOG_CONSTEXPR
 #else
-#    define SPDLOG_NOEXCEPT noexcept
-#    define SPDLOG_CONSTEXPR constexpr
-#    if __cplusplus >= 201402L
-#        define SPDLOG_CONSTEXPR_FUNC constexpr
-#    else
-#        define SPDLOG_CONSTEXPR_FUNC
-#    endif
+    #define SPDLOG_NOEXCEPT noexcept
+    #define SPDLOG_CONSTEXPR constexpr
+#endif
+
+// If building with std::format, can just use constexpr, otherwise if building with fmt
+// SPDLOG_CONSTEXPR_FUNC needs to be set the same as FMT_CONSTEXPR to avoid situations where
+// a constexpr function in spdlog could end up calling a non-constexpr function in fmt
+// depending on the compiler
+// If fmt determines it can't use constexpr, we should inline the function instead
+#ifdef SPDLOG_USE_STD_FORMAT
+    #define SPDLOG_CONSTEXPR_FUNC constexpr
+#else  // Being built with fmt
+    #if FMT_USE_CONSTEXPR
+        #define SPDLOG_CONSTEXPR_FUNC FMT_CONSTEXPR
+    #else
+        #define SPDLOG_CONSTEXPR_FUNC inline
+    #endif
 #endif
 
 #if defined(__GNUC__) || defined(__clang__)
-#    define SPDLOG_DEPRECATED __attribute__((deprecated))
+    #define SPDLOG_DEPRECATED __attribute__((deprecated))
 #elif defined(_MSC_VER)
-#    define SPDLOG_DEPRECATED __declspec(deprecated)
+    #define SPDLOG_DEPRECATED __declspec(deprecated)
 #else
-#    define SPDLOG_DEPRECATED
+    #define SPDLOG_DEPRECATED
 #endif
 
 // disable thread local on msvc 2013
 #ifndef SPDLOG_NO_TLS
-#    if (defined(_MSC_VER) && (_MSC_VER < 1900)) || defined(__cplusplus_winrt)
-#        define SPDLOG_NO_TLS 1
-#    endif
+    #if (defined(_MSC_VER) && (_MSC_VER < 1900)) || defined(__cplusplus_winrt)
+        #define SPDLOG_NO_TLS 1
+    #endif
 #endif
 
 #ifndef SPDLOG_FUNCTION
-#    define SPDLOG_FUNCTION static_cast<const char *>(__FUNCTION__)
+    #define SPDLOG_FUNCTION static_cast<const char *>(__FUNCTION__)
 #endif
 
 #ifdef SPDLOG_NO_EXCEPTIONS
-#    define SPDLOG_TRY
-#    define SPDLOG_THROW(ex)                                                                                                               \
-        do                                                                                                                                 \
-        {                                                                                                                                  \
-            printf("spdlog fatal error: %s\n", ex.what());                                                                                 \
-            std::abort();                                                                                                                  \
+    #define SPDLOG_TRY
+    #define SPDLOG_THROW(ex)                               \
+        do {                                               \
+            printf("spdlog fatal error: %s\n", ex.what()); \
+            std::abort();                                  \
         } while (0)
-#    define SPDLOG_CATCH_STD
+    #define SPDLOG_CATCH_STD
 #else
-#    define SPDLOG_TRY try
-#    define SPDLOG_THROW(ex) throw(ex)
-#    define SPDLOG_CATCH_STD                                                                                                               \
-        catch (const std::exception &) {}
+    #define SPDLOG_TRY try
+    #define SPDLOG_THROW(ex) throw(ex)
+    #define SPDLOG_CATCH_STD             \
+        catch (const std::exception &) { \
+        }
 #endif
 
 namespace spdlog {
@@ -115,12 +130,12 @@ class sink;
 
 #if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
 using filename_t = std::wstring;
-// allow macro expansion to occur in SPDLOG_FILENAME_T
-#    define SPDLOG_FILENAME_T_INNER(s) L##s
-#    define SPDLOG_FILENAME_T(s) SPDLOG_FILENAME_T_INNER(s)
+    // allow macro expansion to occur in SPDLOG_FILENAME_T
+    #define SPDLOG_FILENAME_T_INNER(s) L##s
+    #define SPDLOG_FILENAME_T(s) SPDLOG_FILENAME_T_INNER(s)
 #else
 using filename_t = std::string;
-#    define SPDLOG_FILENAME_T(s) s
+    #define SPDLOG_FILENAME_T(s) s
 #endif
 
 using log_clock = std::chrono::system_clock;
@@ -133,61 +148,79 @@ namespace fmt_lib = std;
 using string_view_t = std::string_view;
 using memory_buf_t = std::string;
 
-template<typename... Args>
+template <typename... Args>
+    #if __cpp_lib_format >= 202207L
+using format_string_t = std::format_string<Args...>;
+    #else
 using format_string_t = std::string_view;
+    #endif
 
-template<class T, class Char = char>
-struct is_convertible_to_basic_format_string : std::integral_constant<bool, std::is_convertible<T, std::basic_string_view<Char>>::value>
-{};
+template <class T, class Char = char>
+struct is_convertible_to_basic_format_string
+    : std::integral_constant<bool, std::is_convertible<T, std::basic_string_view<Char>>::value> {};
 
-#    if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
+    #if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
 using wstring_view_t = std::wstring_view;
 using wmemory_buf_t = std::wstring;
 
-template<typename... Args>
+template <typename... Args>
+        #if __cpp_lib_format >= 202207L
+using wformat_string_t = std::wformat_string<Args...>;
+        #else
 using wformat_string_t = std::wstring_view;
-#    endif
-#    define SPDLOG_BUF_TO_STRING(x) x
-#else // use fmt lib instead of std::format
+        #endif
+    #endif
+    #define SPDLOG_BUF_TO_STRING(x) x
+#else  // use fmt lib instead of std::format
 namespace fmt_lib = fmt;
 
 using string_view_t = fmt::basic_string_view<char>;
 using memory_buf_t = fmt::basic_memory_buffer<char, 250>;
 
-template<typename... Args>
+template <typename... Args>
 using format_string_t = fmt::format_string<Args...>;
 
-template<class T>
+template <class T>
 using remove_cvref_t = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
 
-// clang doesn't like SFINAE disabled constructor in std::is_convertible<> so have to repeat the condition from basic_format_string here,
-// in addition, fmt::basic_runtime<Char> is only convertible to basic_format_string<Char> but not basic_string_view<Char>
-template<class T, class Char = char>
+template <typename Char>
+    #if FMT_VERSION >= 90101
+using fmt_runtime_string = fmt::runtime_format_string<Char>;
+    #else
+using fmt_runtime_string = fmt::basic_runtime<Char>;
+    #endif
+
+// clang doesn't like SFINAE disabled constructor in std::is_convertible<> so have to repeat the
+// condition from basic_format_string here, in addition, fmt::basic_runtime<Char> is only
+// convertible to basic_format_string<Char> but not basic_string_view<Char>
+template <class T, class Char = char>
 struct is_convertible_to_basic_format_string
     : std::integral_constant<bool,
-          std::is_convertible<T, fmt::basic_string_view<Char>>::value || std::is_same<remove_cvref_t<T>, fmt::basic_runtime<Char>>::value>
-{};
+                             std::is_convertible<T, fmt::basic_string_view<Char>>::value ||
+                                 std::is_same<remove_cvref_t<T>, fmt_runtime_string<Char>>::value> {
+};
 
-#    if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
+    #if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
 using wstring_view_t = fmt::basic_string_view<wchar_t>;
 using wmemory_buf_t = fmt::basic_memory_buffer<wchar_t, 250>;
 
-template<typename... Args>
+template <typename... Args>
 using wformat_string_t = fmt::wformat_string<Args...>;
-#    endif
-#    define SPDLOG_BUF_TO_STRING(x) fmt::to_string(x)
+    #endif
+    #define SPDLOG_BUF_TO_STRING(x) fmt::to_string(x)
 #endif
 
 #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
-#    ifndef _WIN32
-#        error SPDLOG_WCHAR_TO_UTF8_SUPPORT only supported on windows
-#    endif // _WIN32
-#endif     // SPDLOG_WCHAR_TO_UTF8_SUPPORT
+    #ifndef _WIN32
+        #error SPDLOG_WCHAR_TO_UTF8_SUPPORT only supported on windows
+    #endif  // _WIN32
+#endif      // SPDLOG_WCHAR_TO_UTF8_SUPPORT
 
-template<class T>
-struct is_convertible_to_any_format_string : std::integral_constant<bool, is_convertible_to_basic_format_string<T, char>::value ||
-                                                                              is_convertible_to_basic_format_string<T, wchar_t>::value>
-{};
+template <class T>
+struct is_convertible_to_any_format_string
+    : std::integral_constant<bool,
+                             is_convertible_to_basic_format_string<T, char>::value ||
+                                 is_convertible_to_basic_format_string<T, wchar_t>::value> {};
 
 #if defined(SPDLOG_NO_ATOMIC_LEVELS)
 using level_t = details::null_atomic_int;
@@ -204,13 +237,12 @@ using level_t = std::atomic<int>;
 #define SPDLOG_LEVEL_OFF 6
 
 #if !defined(SPDLOG_ACTIVE_LEVEL)
-#    define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_INFO
+    #define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_INFO
 #endif
 
 // Log level enum
 namespace level {
-enum level_enum : int
-{
+enum level_enum : int {
     trace = SPDLOG_LEVEL_TRACE,
     debug = SPDLOG_LEVEL_DEBUG,
     info = SPDLOG_LEVEL_INFO,
@@ -230,52 +262,44 @@ enum level_enum : int
 #define SPDLOG_LEVEL_NAME_OFF spdlog::string_view_t("off", 3)
 
 #if !defined(SPDLOG_LEVEL_NAMES)
-#    define SPDLOG_LEVEL_NAMES                                                                                                             \
-        {                                                                                                                                  \
-            SPDLOG_LEVEL_NAME_TRACE, SPDLOG_LEVEL_NAME_DEBUG, SPDLOG_LEVEL_NAME_INFO, SPDLOG_LEVEL_NAME_WARNING, SPDLOG_LEVEL_NAME_ERROR,  \
-                SPDLOG_LEVEL_NAME_CRITICAL, SPDLOG_LEVEL_NAME_OFF                                                                          \
+    #define SPDLOG_LEVEL_NAMES                                                                  \
+        {                                                                                       \
+            SPDLOG_LEVEL_NAME_TRACE, SPDLOG_LEVEL_NAME_DEBUG, SPDLOG_LEVEL_NAME_INFO,           \
+                SPDLOG_LEVEL_NAME_WARNING, SPDLOG_LEVEL_NAME_ERROR, SPDLOG_LEVEL_NAME_CRITICAL, \
+                SPDLOG_LEVEL_NAME_OFF                                                           \
         }
 #endif
 
 #if !defined(SPDLOG_SHORT_LEVEL_NAMES)
 
-#    define SPDLOG_SHORT_LEVEL_NAMES                                                                                                       \
-        {                                                                                                                                  \
-            "T", "D", "I", "W", "E", "C", "O"                                                                                              \
-        }
+    #define SPDLOG_SHORT_LEVEL_NAMES \
+        { "T", "D", "I", "W", "E", "C", "O" }
 #endif
 
 SPDLOG_API const string_view_t &to_string_view(spdlog::level::level_enum l) SPDLOG_NOEXCEPT;
 SPDLOG_API const char *to_short_c_str(spdlog::level::level_enum l) SPDLOG_NOEXCEPT;
 SPDLOG_API spdlog::level::level_enum from_str(const std::string &name) SPDLOG_NOEXCEPT;
 
-} // namespace level
+}  // namespace level
 
 //
 // Color mode used by sinks with color support.
 //
-enum class color_mode
-{
-    always,
-    automatic,
-    never
-};
+enum class color_mode { always, automatic, never };
 
 //
 // Pattern time - specific time getting to use for pattern_formatter.
 // local time by default
 //
-enum class pattern_time_type
-{
-    local, // log localtime
-    utc    // log utc
+enum class pattern_time_type {
+    local,  // log localtime
+    utc     // log utc
 };
 
 //
 // Log exception
 //
-class SPDLOG_API spdlog_ex : public std::exception
-{
+class SPDLOG_API spdlog_ex : public std::exception {
 public:
     explicit spdlog_ex(std::string msg);
     spdlog_ex(const std::string &msg, int last_errno);
@@ -288,32 +312,25 @@ private:
 [[noreturn]] SPDLOG_API void throw_spdlog_ex(const std::string &msg, int last_errno);
 [[noreturn]] SPDLOG_API void throw_spdlog_ex(std::string msg);
 
-struct source_loc
-{
+struct source_loc {
     SPDLOG_CONSTEXPR source_loc() = default;
     SPDLOG_CONSTEXPR source_loc(const char *filename_in, int line_in, const char *funcname_in)
-        : filename{filename_in}
-        , line{line_in}
-        , funcname{funcname_in}
-    {}
+        : filename{filename_in},
+          line{line_in},
+          funcname{funcname_in} {}
 
-    SPDLOG_CONSTEXPR bool empty() const SPDLOG_NOEXCEPT
-    {
-        return line == 0;
-    }
+    SPDLOG_CONSTEXPR bool empty() const SPDLOG_NOEXCEPT { return line <= 0; }
     const char *filename{nullptr};
     int line{0};
     const char *funcname{nullptr};
 };
 
-struct file_event_handlers
-{
+struct file_event_handlers {
     file_event_handlers()
-        : before_open(nullptr)
-        , after_open(nullptr)
-        , before_close(nullptr)
-        , after_close(nullptr)
-    {}
+        : before_open(nullptr),
+          after_open(nullptr),
+          before_close(nullptr),
+          after_close(nullptr) {}
 
     std::function<void(const filename_t &filename)> before_open;
     std::function<void(const filename_t &filename, std::FILE *file_stream)> after_open;
@@ -323,39 +340,72 @@ struct file_event_handlers
 
 namespace details {
 
-// make_unique support for pre c++14
+// to_string_view
 
-#if __cplusplus >= 201402L // C++14 and beyond
+SPDLOG_CONSTEXPR_FUNC spdlog::string_view_t to_string_view(const memory_buf_t &buf)
+    SPDLOG_NOEXCEPT {
+    return spdlog::string_view_t{buf.data(), buf.size()};
+}
+
+SPDLOG_CONSTEXPR_FUNC spdlog::string_view_t to_string_view(spdlog::string_view_t str)
+    SPDLOG_NOEXCEPT {
+    return str;
+}
+
+#if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
+SPDLOG_CONSTEXPR_FUNC spdlog::wstring_view_t to_string_view(const wmemory_buf_t &buf)
+    SPDLOG_NOEXCEPT {
+    return spdlog::wstring_view_t{buf.data(), buf.size()};
+}
+
+SPDLOG_CONSTEXPR_FUNC spdlog::wstring_view_t to_string_view(spdlog::wstring_view_t str)
+    SPDLOG_NOEXCEPT {
+    return str;
+}
+#endif
+
+#ifndef SPDLOG_USE_STD_FORMAT
+template <typename T, typename... Args>
+inline fmt::basic_string_view<T> to_string_view(fmt::basic_format_string<T, Args...> fmt) {
+    return fmt;
+}
+#elif __cpp_lib_format >= 202207L
+template <typename T, typename... Args>
+SPDLOG_CONSTEXPR_FUNC std::basic_string_view<T> to_string_view(
+    std::basic_format_string<T, Args...> fmt) SPDLOG_NOEXCEPT {
+    return fmt.get();
+}
+#endif
+
+// make_unique support for pre c++14
+#if __cplusplus >= 201402L  // C++14 and beyond
 using std::enable_if_t;
 using std::make_unique;
 #else
-template<bool B, class T = void>
+template <bool B, class T = void>
 using enable_if_t = typename std::enable_if<B, T>::type;
 
-template<typename T, typename... Args>
-std::unique_ptr<T> make_unique(Args &&... args)
-{
+template <typename T, typename... Args>
+std::unique_ptr<T> make_unique(Args &&...args) {
     static_assert(!std::is_array<T>::value, "arrays not supported");
     return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
 }
 #endif
 
 // to avoid useless casts (see https://github.com/nlohmann/json/issues/2893#issuecomment-889152324)
-template<typename T, typename U, enable_if_t<!std::is_same<T, U>::value, int> = 0>
-constexpr T conditional_static_cast(U value)
-{
+template <typename T, typename U, enable_if_t<!std::is_same<T, U>::value, int> = 0>
+constexpr T conditional_static_cast(U value) {
     return static_cast<T>(value);
 }
 
-template<typename T, typename U, enable_if_t<std::is_same<T, U>::value, int> = 0>
-constexpr T conditional_static_cast(U value)
-{
+template <typename T, typename U, enable_if_t<std::is_same<T, U>::value, int> = 0>
+constexpr T conditional_static_cast(U value) {
     return value;
 }
 
-} // namespace details
-} // namespace spdlog
+}  // namespace details
+}  // namespace spdlog
 
 #ifdef SPDLOG_HEADER_ONLY
-#    include "common-inl.h"
+    #include "common-inl.h"
 #endif

include/spdlog/details/backtracer-inl.h

@@ -4,66 +4,60 @@
 #pragma once
 
 #ifndef SPDLOG_HEADER_ONLY
-#    include <spdlog/details/backtracer.h>
+    #include <spdlog/details/backtracer.h>
 #endif
 namespace spdlog {
 namespace details {
-SPDLOG_INLINE backtracer::backtracer(const backtracer &other)
-{
+SPDLOG_INLINE backtracer::backtracer(const backtracer &other) {
     std::lock_guard<std::mutex> lock(other.mutex_);
     enabled_ = other.enabled();
     messages_ = other.messages_;
 }
 
-SPDLOG_INLINE backtracer::backtracer(backtracer &&other) SPDLOG_NOEXCEPT
-{
+SPDLOG_INLINE backtracer::backtracer(backtracer &&other) SPDLOG_NOEXCEPT {
     std::lock_guard<std::mutex> lock(other.mutex_);
     enabled_ = other.enabled();
     messages_ = std::move(other.messages_);
 }
 
-SPDLOG_INLINE backtracer &backtracer::operator=(backtracer other)
-{
+SPDLOG_INLINE backtracer &backtracer::operator=(backtracer other) {
     std::lock_guard<std::mutex> lock(mutex_);
     enabled_ = other.enabled();
     messages_ = std::move(other.messages_);
     return *this;
 }
 
-SPDLOG_INLINE void backtracer::enable(size_t size)
-{
+SPDLOG_INLINE void backtracer::enable(size_t size) {
     std::lock_guard<std::mutex> lock{mutex_};
     enabled_.store(true, std::memory_order_relaxed);
     messages_ = circular_q<log_msg_buffer>{size};
 }
 
-SPDLOG_INLINE void backtracer::disable()
-{
+SPDLOG_INLINE void backtracer::disable() {
     std::lock_guard<std::mutex> lock{mutex_};
     enabled_.store(false, std::memory_order_relaxed);
 }
 
-SPDLOG_INLINE bool backtracer::enabled() const
-{
-    return enabled_.load(std::memory_order_relaxed);
-}
+SPDLOG_INLINE bool backtracer::enabled() const { return enabled_.load(std::memory_order_relaxed); }
 
-SPDLOG_INLINE void backtracer::push_back(const log_msg &msg)
-{
+SPDLOG_INLINE void backtracer::push_back(const log_msg &msg) {
     std::lock_guard<std::mutex> lock{mutex_};
     messages_.push_back(log_msg_buffer{msg});
 }
 
-// pop all items in the q and apply the given fun on each of them.
-SPDLOG_INLINE void backtracer::foreach_pop(std::function<void(const details::log_msg &)> fun)
-{
+SPDLOG_INLINE bool backtracer::empty() const {
     std::lock_guard<std::mutex> lock{mutex_};
-    while (!messages_.empty())
-    {
+    return messages_.empty();
+}
+
+// pop all items in the q and apply the given fun on each of them.
+SPDLOG_INLINE void backtracer::foreach_pop(std::function<void(const details::log_msg &)> fun) {
+    std::lock_guard<std::mutex> lock{mutex_};
+    while (!messages_.empty()) {
         auto &front_msg = messages_.front();
         fun(front_msg);
         messages_.pop_front();
     }
 }
-} // namespace details
-} // namespace spdlog
+}  // namespace details
+}  // namespace spdlog

include/spdlog/details/backtracer.h

@@ -3,20 +3,19 @@
 
 #pragma once
 
-#include <spdlog/details/log_msg_buffer.h>
 #include <spdlog/details/circular_q.h>
+#include <spdlog/details/log_msg_buffer.h>
 
 #include <atomic>
-#include <mutex>
 #include <functional>
+#include <mutex>
 
 // Store log messages in circular buffer.
 // Useful for storing debug data in case of error/warning happens.
 
 namespace spdlog {
 namespace details {
-class SPDLOG_API backtracer
-{
+class SPDLOG_API backtracer {
     mutable std::mutex mutex_;
     std::atomic<bool> enabled_{false};
     circular_q<log_msg_buffer> messages_;
@@ -32,14 +31,15 @@ public:
     void disable();
     bool enabled() const;
     void push_back(const log_msg &msg);
+    bool empty() const;
 
     // pop all items in the q and apply the given fun on each of them.
     void foreach_pop(std::function<void(const details::log_msg &)> fun);
 };
 
-} // namespace details
-} // namespace spdlog
+}  // namespace details
+}  // namespace spdlog
 
 #ifdef SPDLOG_HEADER_ONLY
-#    include "backtracer-inl.h"
+    #include "backtracer-inl.h"
 #endif

include/spdlog/details/circular_q.h

@@ -4,14 +4,15 @@
 // circular q view of std::vector.
 #pragma once
 
-#include <vector>
 #include <cassert>
+#include <vector>
+
+#include "spdlog/common.h"
 
 namespace spdlog {
 namespace details {
-template<typename T>
-class circular_q
-{
+template <typename T>
+class circular_q {
     size_t max_items_ = 0;
     typename std::vector<T>::size_type head_ = 0;
     typename std::vector<T>::size_type tail_ = 0;
@@ -25,35 +26,29 @@ public:
     circular_q() = default;
 
     explicit circular_q(size_t max_items)
-        : max_items_(max_items + 1) // one item is reserved as marker for full q
-        , v_(max_items_)
-    {}
+        : max_items_(max_items + 1)  // one item is reserved as marker for full q
+          ,
+          v_(max_items_) {}
 
     circular_q(const circular_q &) = default;
     circular_q &operator=(const circular_q &) = default;
 
     // move cannot be default,
     // since we need to reset head_, tail_, etc to zero in the moved object
-    circular_q(circular_q &&other) SPDLOG_NOEXCEPT
-    {
-        copy_moveable(std::move(other));
-    }
+    circular_q(circular_q &&other) SPDLOG_NOEXCEPT { copy_moveable(std::move(other)); }
 
-    circular_q &operator=(circular_q &&other) SPDLOG_NOEXCEPT
-    {
+    circular_q &operator=(circular_q &&other) SPDLOG_NOEXCEPT {
         copy_moveable(std::move(other));
         return *this;
     }
 
     // push back, overrun (oldest) item if no room left
-    void push_back(T &&item)
-    {
-        if (max_items_ > 0)
-        {
+    void push_back(T &&item) {
+        if (max_items_ > 0) {
             v_[tail_] = std::move(item);
             tail_ = (tail_ + 1) % max_items_;
 
-            if (tail_ == head_) // overrun last item if full
+            if (tail_ == head_)  // overrun last item if full
             {
                 head_ = (head_ + 1) % max_items_;
                 ++overrun_counter_;
@@ -63,73 +58,47 @@ public:
 
     // Return reference to the front item.
     // If there are no elements in the container, the behavior is undefined.
-    const T &front() const
-    {
-        return v_[head_];
-    }
+    const T &front() const { return v_[head_]; }
 
-    T &front()
-    {
-        return v_[head_];
-    }
+    T &front() { return v_[head_]; }
 
     // Return number of elements actually stored
-    size_t size() const
-    {
-        if (tail_ >= head_)
-        {
+    size_t size() const {
+        if (tail_ >= head_) {
             return tail_ - head_;
-        }
-        else
-        {
+        } else {
             return max_items_ - (head_ - tail_);
         }
     }
 
     // Return const reference to item by index.
     // If index is out of range 0…size()-1, the behavior is undefined.
-    const T &at(size_t i) const
-    {
+    const T &at(size_t i) const {
         assert(i < size());
         return v_[(head_ + i) % max_items_];
     }
 
     // Pop item from front.
     // If there are no elements in the container, the behavior is undefined.
-    void pop_front()
-    {
-        head_ = (head_ + 1) % max_items_;
-    }
+    void pop_front() { head_ = (head_ + 1) % max_items_; }
 
-    bool empty() const
-    {
-        return tail_ == head_;
-    }
+    bool empty() const { return tail_ == head_; }
 
-    bool full() const
-    {
+    bool full() const {
         // head is ahead of the tail by 1
-        if (max_items_ > 0)
-        {
+        if (max_items_ > 0) {
             return ((tail_ + 1) % max_items_) == head_;
         }
         return false;
     }
 
-    size_t overrun_counter() const
-    {
-        return overrun_counter_;
-    }
+    size_t overrun_counter() const { return overrun_counter_; }
 
-    void reset_overrun_counter()
-    {
-        overrun_counter_ = 0;
-    }
+    void reset_overrun_counter() { overrun_counter_ = 0; }
 
 private:
     // copy from other&& and reset it to disabled state
-    void copy_moveable(circular_q &&other) SPDLOG_NOEXCEPT
-    {
+    void copy_moveable(circular_q &&other) SPDLOG_NOEXCEPT {
         max_items_ = other.max_items_;
         head_ = other.head_;
         tail_ = other.tail_;
@@ -142,5 +111,5 @@ private:
         other.overrun_counter_ = 0;
     }
 };
-} // namespace details
-} // namespace spdlog
+}  // namespace details
+}  // namespace spdlog

include/spdlog/details/console_globals.h

@@ -3,30 +3,26 @@
 
 #pragma once
 
-#include <spdlog/details/null_mutex.h>
 #include <mutex>
+#include <spdlog/details/null_mutex.h>
 
 namespace spdlog {
 namespace details {
 
-struct console_mutex
-{
+struct console_mutex {
     using mutex_t = std::mutex;
-    static mutex_t &mutex()
-    {
+    static mutex_t &mutex() {
         static mutex_t s_mutex;
         return s_mutex;
     }
 };
 
-struct console_nullmutex
-{
+struct console_nullmutex {
     using mutex_t = null_mutex;
-    static mutex_t &mutex()
-    {
+    static mutex_t &mutex() {
         static mutex_t s_mutex;
         return s_mutex;
     }
 };
-} // namespace details
-} // namespace spdlog
+}  // namespace details
+}  // namespace spdlog

include/spdlog/details/file_helper-inl.h

@@ -4,11 +4,11 @@
 #pragma once
 
 #ifndef SPDLOG_HEADER_ONLY
-#    include <spdlog/details/file_helper.h>
+    #include <spdlog/details/file_helper.h>
 #endif
 
-#include <spdlog/details/os.h>
 #include <spdlog/common.h>
+#include <spdlog/details/os.h>
 
 #include <cerrno>
 #include <chrono>
@@ -21,47 +21,36 @@ namespace spdlog {
 namespace details {
 
 SPDLOG_INLINE file_helper::file_helper(const file_event_handlers &event_handlers)
-    : event_handlers_(event_handlers)
-{}
+    : event_handlers_(event_handlers) {}
 
-SPDLOG_INLINE file_helper::~file_helper()
-{
-    close();
-}
+SPDLOG_INLINE file_helper::~file_helper() { close(); }
 
-SPDLOG_INLINE void file_helper::open(const filename_t &fname, bool truncate)
-{
+SPDLOG_INLINE void file_helper::open(const filename_t &fname, bool truncate) {
     close();
     filename_ = fname;
 
     auto *mode = SPDLOG_FILENAME_T("ab");
     auto *trunc_mode = SPDLOG_FILENAME_T("wb");
 
-    if (event_handlers_.before_open)
-    {
+    if (event_handlers_.before_open) {
         event_handlers_.before_open(filename_);
     }
-    for (int tries = 0; tries < open_tries_; ++tries)
-    {
+    for (int tries = 0; tries < open_tries_; ++tries) {
         // create containing folder if not exists already.
         os::create_dir(os::dir_name(fname));
-        if (truncate)
-        {
+        if (truncate) {
             // Truncate by opening-and-closing a tmp file in "wb" mode, always
             // opening the actual log-we-write-to in "ab" mode, since that
             // interacts more politely with eternal processes that might
             // rotate/truncate the file underneath us.
             std::FILE *tmp;
-            if (os::fopen_s(&tmp, fname, trunc_mode))
-            {
+            if (os::fopen_s(&tmp, fname, trunc_mode)) {
                 continue;
             }
             std::fclose(tmp);
         }
-        if (!os::fopen_s(&fd_, fname, mode))
-        {
-            if (event_handlers_.after_open)
-            {
+        if (!os::fopen_s(&fd_, fname, mode)) {
+            if (event_handlers_.after_open) {
                 event_handlers_.after_open(filename_, fd_);
             }
             return;
@@ -70,68 +59,61 @@ SPDLOG_INLINE void file_helper::open(const filename_t &fname, bool truncate)
         details::os::sleep_for_millis(open_interval_);
     }
 
-    throw_spdlog_ex("Failed opening file " + os::filename_to_str(filename_) + " for writing", errno);
+    throw_spdlog_ex("Failed opening file " + os::filename_to_str(filename_) + " for writing",
+                    errno);
 }
 
-SPDLOG_INLINE void file_helper::reopen(bool truncate)
-{
-    if (filename_.empty())
-    {
+SPDLOG_INLINE void file_helper::reopen(bool truncate) {
+    if (filename_.empty()) {
         throw_spdlog_ex("Failed re opening file - was not opened before");
     }
     this->open(filename_, truncate);
 }
 
-SPDLOG_INLINE void file_helper::flush()
-{
-    if (std::fflush(fd_) != 0)
-    {
+SPDLOG_INLINE void file_helper::flush() {
+    if (std::fflush(fd_) != 0) {
         throw_spdlog_ex("Failed flush to file " + os::filename_to_str(filename_), errno);
     }
 }
 
-SPDLOG_INLINE void file_helper::close()
-{
-    if (fd_ != nullptr)
-    {
-        if (event_handlers_.before_close)
-        {
+SPDLOG_INLINE void file_helper::sync() {
+    if (!os::fsync(fd_)) {
+        throw_spdlog_ex("Failed to fsync file " + os::filename_to_str(filename_), errno);
+    }
+}
+
+SPDLOG_INLINE void file_helper::close() {
+    if (fd_ != nullptr) {
+        if (event_handlers_.before_close) {
             event_handlers_.before_close(filename_, fd_);
         }
 
         std::fclose(fd_);
         fd_ = nullptr;
 
-        if (event_handlers_.after_close)
-        {
+        if (event_handlers_.after_close) {
             event_handlers_.after_close(filename_);
         }
     }
 }
 
-SPDLOG_INLINE void file_helper::write(const memory_buf_t &buf)
-{
+SPDLOG_INLINE void file_helper::write(const memory_buf_t &buf) {
+    if (fd_ == nullptr) return;
     size_t msg_size = buf.size();
     auto data = buf.data();
-    if (std::fwrite(data, 1, msg_size, fd_) != msg_size)
-    {
+    if (std::fwrite(data, 1, msg_size, fd_) != msg_size) {
         throw_spdlog_ex("Failed writing to file " + os::filename_to_str(filename_), errno);
     }
 }
 
-SPDLOG_INLINE size_t file_helper::size() const
-{
-    if (fd_ == nullptr)
-    {
+SPDLOG_INLINE size_t file_helper::size() const {
+    if (fd_ == nullptr) {
         throw_spdlog_ex("Cannot use size() on closed file " + os::filename_to_str(filename_));
     }
     return os::filesize(fd_);
 }
 
-SPDLOG_INLINE const filename_t &file_helper::filename() const
-{
-    return filename_;
-}
+SPDLOG_INLINE const filename_t &file_helper::filename() const { return filename_; }
 
 //
 // return file path and its extension:
@@ -146,21 +128,19 @@ SPDLOG_INLINE const filename_t &file_helper::filename() const
 // ".mylog" => (".mylog". "")
 // "my_folder/.mylog" => ("my_folder/.mylog", "")
 // "my_folder/.mylog.txt" => ("my_folder/.mylog", ".txt")
-SPDLOG_INLINE std::tuple<filename_t, filename_t> file_helper::split_by_extension(const filename_t &fname)
-{
+SPDLOG_INLINE std::tuple<filename_t, filename_t> file_helper::split_by_extension(
+    const filename_t &fname) {
     auto ext_index = fname.rfind('.');
 
     // no valid extension found - return whole path and empty string as
     // extension
-    if (ext_index == filename_t::npos || ext_index == 0 || ext_index == fname.size() - 1)
-    {
+    if (ext_index == filename_t::npos || ext_index == 0 || ext_index == fname.size() - 1) {
         return std::make_tuple(fname, filename_t());
     }
 
     // treat cases like "/etc/rc.d/somelogfile or "/abc/.hiddenfile"
     auto folder_index = fname.find_last_of(details::os::folder_seps_filename);
-    if (folder_index != filename_t::npos && folder_index >= ext_index - 1)
-    {
+    if (folder_index != filename_t::npos && folder_index >= ext_index - 1) {
         return std::make_tuple(fname, filename_t());
     }
 
@@ -168,5 +148,5 @@ SPDLOG_INLINE std::tuple<filename_t, filename_t> file_helper::split_by_extension
     return std::make_tuple(fname.substr(0, ext_index), fname.substr(ext_index));
 }
 
-} // namespace details
-} // namespace spdlog
+}  // namespace details
+}  // namespace spdlog

include/spdlog/details/file_helper.h

@@ -13,8 +13,7 @@ namespace details {
 // When failing to open a file, retry several times(5) with a delay interval(10 ms).
 // Throw spdlog_ex exception on errors.
 
-class SPDLOG_API file_helper
-{
+class SPDLOG_API file_helper {
 public:
     file_helper() = default;
     explicit file_helper(const file_event_handlers &event_handlers);
@@ -26,6 +25,7 @@ public:
     void open(const filename_t &fname, bool truncate = false);
     void reopen(bool truncate);
     void flush();
+    void sync();
     void close();
     void write(const memory_buf_t &buf);
     size_t size() const;
@@ -53,9 +53,9 @@ private:
     filename_t filename_;
     file_event_handlers event_handlers_;
 };
-} // namespace details
-} // namespace spdlog
+}  // namespace details
+}  // namespace spdlog
 
 #ifdef SPDLOG_HEADER_ONLY
-#    include "file_helper-inl.h"
+    #include "file_helper-inl.h"
 #endif

include/spdlog/details/fmt_helper.h

@@ -3,14 +3,14 @@
 #pragma once
 
 #include <chrono>
-#include <type_traits>
 #include <iterator>
-#include <spdlog/fmt/fmt.h>
 #include <spdlog/common.h>
+#include <spdlog/fmt/fmt.h>
+#include <type_traits>
 
 #ifdef SPDLOG_USE_STD_FORMAT
-#    include <charconv>
-#    include <limits>
+    #include <charconv>
+    #include <limits>
 #endif
 
 // Some fmt helpers to efficiently format and pad ints and strings
@@ -18,145 +18,117 @@ namespace spdlog {
 namespace details {
 namespace fmt_helper {
 
-inline spdlog::string_view_t to_string_view(const memory_buf_t &buf) SPDLOG_NOEXCEPT
-{
-    return spdlog::string_view_t{buf.data(), buf.size()};
-}
-
-inline void append_string_view(spdlog::string_view_t view, memory_buf_t &dest)
-{
+inline void append_string_view(spdlog::string_view_t view, memory_buf_t &dest) {
     auto *buf_ptr = view.data();
     dest.append(buf_ptr, buf_ptr + view.size());
 }
 
 #ifdef SPDLOG_USE_STD_FORMAT
-template<typename T>
-inline void append_int(T n, memory_buf_t &dest)
-{
+template <typename T>
+inline void append_int(T n, memory_buf_t &dest) {
     // Buffer should be large enough to hold all digits (digits10 + 1) and a sign
     SPDLOG_CONSTEXPR const auto BUF_SIZE = std::numeric_limits<T>::digits10 + 2;
     char buf[BUF_SIZE];
 
     auto [ptr, ec] = std::to_chars(buf, buf + BUF_SIZE, n, 10);
-    if (ec == std::errc())
-    {
+    if (ec == std::errc()) {
         dest.append(buf, ptr);
-    }
-    else
-    {
+    } else {
         throw_spdlog_ex("Failed to format int", static_cast<int>(ec));
     }
 }
 #else
-template<typename T>
-inline void append_int(T n, memory_buf_t &dest)
-{
+template <typename T>
+inline void append_int(T n, memory_buf_t &dest) {
     fmt::format_int i(n);
     dest.append(i.data(), i.data() + i.size());
 }
 #endif
 
-template<typename T>
-SPDLOG_CONSTEXPR_FUNC unsigned int count_digits_fallback(T n)
-{
+template <typename T>
+SPDLOG_CONSTEXPR_FUNC unsigned int count_digits_fallback(T n) {
     // taken from fmt: https://github.com/fmtlib/fmt/blob/8.0.1/include/fmt/format.h#L899-L912
     unsigned int count = 1;
-    for (;;)
-    {
+    for (;;) {
         // Integer division is slow so do it for a group of four digits instead
         // of for every digit. The idea comes from the talk by Alexandrescu
         // "Three Optimization Tips for C++". See speed-test for a comparison.
-        if (n < 10)
-            return count;
-        if (n < 100)
-            return count + 1;
-        if (n < 1000)
-            return count + 2;
-        if (n < 10000)
-            return count + 3;
+        if (n < 10) return count;
+        if (n < 100) return count + 1;
+        if (n < 1000) return count + 2;
+        if (n < 10000) return count + 3;
         n /= 10000u;
         count += 4;
     }
 }
 
-template<typename T>
-inline unsigned int count_digits(T n)
-{
-    using count_type = typename std::conditional<(sizeof(T) > sizeof(uint32_t)), uint64_t, uint32_t>::type;
+template <typename T>
+inline unsigned int count_digits(T n) {
+    using count_type =
+        typename std::conditional<(sizeof(T) > sizeof(uint32_t)), uint64_t, uint32_t>::type;
 #ifdef SPDLOG_USE_STD_FORMAT
     return count_digits_fallback(static_cast<count_type>(n));
 #else
     return static_cast<unsigned int>(fmt::
-// fmt 7.0.0 renamed the internal namespace to detail.
-// See: https://github.com/fmtlib/fmt/issues/1538
-#    if FMT_VERSION < 70000
-            internal
-#    else
-            detail
-#    endif
-        ::count_digits(static_cast<count_type>(n)));
+    // fmt 7.0.0 renamed the internal namespace to detail.
+    // See: https://github.com/fmtlib/fmt/issues/1538
+    #if FMT_VERSION < 70000
+                                         internal
+    #else
+                                         detail
+    #endif
+                                     ::count_digits(static_cast<count_type>(n)));
 #endif
 }
 
-inline void pad2(int n, memory_buf_t &dest)
-{
-    if (n >= 0 && n < 100) // 0-99
+inline void pad2(int n, memory_buf_t &dest) {
+    if (n >= 0 && n < 100)  // 0-99
     {
         dest.push_back(static_cast<char>('0' + n / 10));
         dest.push_back(static_cast<char>('0' + n % 10));
-    }
-    else // unlikely, but just in case, let fmt deal with it
+    } else  // unlikely, but just in case, let fmt deal with it
     {
         fmt_lib::format_to(std::back_inserter(dest), SPDLOG_FMT_STRING("{:02}"), n);
     }
 }
 
-template<typename T>
-inline void pad_uint(T n, unsigned int width, memory_buf_t &dest)
-{
+template <typename T>
+inline void pad_uint(T n, unsigned int width, memory_buf_t &dest) {
     static_assert(std::is_unsigned<T>::value, "pad_uint must get unsigned T");
-    for (auto digits = count_digits(n); digits < width; digits++)
-    {
+    for (auto digits = count_digits(n); digits < width; digits++) {
         dest.push_back('0');
     }
     append_int(n, dest);
 }
 
-template<typename T>
-inline void pad3(T n, memory_buf_t &dest)
-{
+template <typename T>
+inline void pad3(T n, memory_buf_t &dest) {
     static_assert(std::is_unsigned<T>::value, "pad3 must get unsigned T");
-    if (n < 1000)
-    {
+    if (n < 1000) {
         dest.push_back(static_cast<char>(n / 100 + '0'));
         n = n % 100;
         dest.push_back(static_cast<char>((n / 10) + '0'));
         dest.push_back(static_cast<char>((n % 10) + '0'));
-    }
-    else
-    {
+    } else {
         append_int(n, dest);
     }
 }
 
-template<typename T>
-inline void pad6(T n, memory_buf_t &dest)
-{
+template <typename T>
+inline void pad6(T n, memory_buf_t &dest) {
     pad_uint(n, 6, dest);
 }
 
-template<typename T>
-inline void pad9(T n, memory_buf_t &dest)
-{
+template <typename T>
+inline void pad9(T n, memory_buf_t &dest) {
     pad_uint(n, 9, dest);
 }
 
 // return fraction of a second of the given time_point.
 // e.g.
 // fraction<std::milliseconds>(tp) -> will return the millis part of the second
-template<typename ToDuration>
-inline ToDuration time_fraction(log_clock::time_point tp)
-{
+template <typename ToDuration>
+inline ToDuration time_fraction(log_clock::time_point tp) {
     using std::chrono::duration_cast;
     using std::chrono::seconds;
     auto duration = tp.time_since_epoch();
@@ -164,6 +136,6 @@ inline ToDuration time_fraction(log_clock::time_point tp)
     return duration_cast<ToDuration>(duration) - duration_cast<ToDuration>(secs);
 }
 
-} // namespace fmt_helper
-} // namespace details
-} // namespace spdlog
+}  // namespace fmt_helper
+}  // namespace details
+}  // namespace spdlog

include/spdlog/details/log_msg-inl.h

@@ -4,7 +4,7 @@
 #pragma once
 
 #ifndef SPDLOG_HEADER_ONLY
-#    include <spdlog/details/log_msg.h>
+    #include <spdlog/details/log_msg.h>
 #endif
 
 #include <spdlog/details/os.h>
@@ -12,26 +12,33 @@
 namespace spdlog {
 namespace details {
 
-SPDLOG_INLINE log_msg::log_msg(spdlog::log_clock::time_point log_time, spdlog::source_loc loc, string_view_t a_logger_name,
-    spdlog::level::level_enum lvl, spdlog::string_view_t msg)
-    : logger_name(a_logger_name)
-    , level(lvl)
-    , time(log_time)
+SPDLOG_INLINE log_msg::log_msg(spdlog::log_clock::time_point log_time,
+                               spdlog::source_loc loc,
+                               string_view_t a_logger_name,
+                               spdlog::level::level_enum lvl,
+                               spdlog::string_view_t msg)
+    : logger_name(a_logger_name),
+      level(lvl),
+      time(log_time)
 #ifndef SPDLOG_NO_THREAD_ID
-    , thread_id(os::thread_id())
+      ,
+      thread_id(os::thread_id())
 #endif
-    , source(loc)
-    , payload(msg)
-{}
+      ,
+      source(loc),
+      payload(msg) {
+}
 
-SPDLOG_INLINE log_msg::log_msg(
-    spdlog::source_loc loc, string_view_t a_logger_name, spdlog::level::level_enum lvl, spdlog::string_view_t msg)
-    : log_msg(os::now(), loc, a_logger_name, lvl, msg)
-{}
+SPDLOG_INLINE log_msg::log_msg(spdlog::source_loc loc,
+                               string_view_t a_logger_name,
+                               spdlog::level::level_enum lvl,
+                               spdlog::string_view_t msg)
+    : log_msg(os::now(), loc, a_logger_name, lvl, msg) {}
 
-SPDLOG_INLINE log_msg::log_msg(string_view_t a_logger_name, spdlog::level::level_enum lvl, spdlog::string_view_t msg)
-    : log_msg(os::now(), source_loc{}, a_logger_name, lvl, msg)
-{}
+SPDLOG_INLINE log_msg::log_msg(string_view_t a_logger_name,
+                               spdlog::level::level_enum lvl,
+                               spdlog::string_view_t msg)
+    : log_msg(os::now(), source_loc{}, a_logger_name, lvl, msg) {}
 
-} // namespace details
-} // namespace spdlog
+}  // namespace details
+}  // namespace spdlog

include/spdlog/details/log_msg.h

@@ -8,10 +8,13 @@
 
 namespace spdlog {
 namespace details {
-struct SPDLOG_API log_msg
-{
+struct SPDLOG_API log_msg {
     log_msg() = default;
-    log_msg(log_clock::time_point log_time, source_loc loc, string_view_t logger_name, level::level_enum lvl, string_view_t msg);
+    log_msg(log_clock::time_point log_time,
+            source_loc loc,
+            string_view_t logger_name,
+            level::level_enum lvl,
+            string_view_t msg);
     log_msg(source_loc loc, string_view_t logger_name, level::level_enum lvl, string_view_t msg);
     log_msg(string_view_t logger_name, level::level_enum lvl, string_view_t msg);
     log_msg(const log_msg &other) = default;
@@ -29,9 +32,9 @@ struct SPDLOG_API log_msg
     source_loc source;
     string_view_t payload;
 };
-} // namespace details
-} // namespace spdlog
+}  // namespace details
+}  // namespace spdlog
 
 #ifdef SPDLOG_HEADER_ONLY
-#    include "log_msg-inl.h"
+    #include "log_msg-inl.h"
 #endif

include/spdlog/details/log_msg_buffer-inl.h

@@ -4,35 +4,33 @@
 #pragma once
 
 #ifndef SPDLOG_HEADER_ONLY
-#    include <spdlog/details/log_msg_buffer.h>
+    #include <spdlog/details/log_msg_buffer.h>
 #endif
 
 namespace spdlog {
 namespace details {
 
 SPDLOG_INLINE log_msg_buffer::log_msg_buffer(const log_msg &orig_msg)
-    : log_msg{orig_msg}
-{
+    : log_msg{orig_msg} {
     buffer.append(logger_name.begin(), logger_name.end());
     buffer.append(payload.begin(), payload.end());
     update_string_views();
 }
 
 SPDLOG_INLINE log_msg_buffer::log_msg_buffer(const log_msg_buffer &other)
-    : log_msg{other}
-{
+    : log_msg{other} {
     buffer.append(logger_name.begin(), logger_name.end());
     buffer.append(payload.begin(), payload.end());
     update_string_views();
 }
 
-SPDLOG_INLINE log_msg_buffer::log_msg_buffer(log_msg_buffer &&other) SPDLOG_NOEXCEPT : log_msg{other}, buffer{std::move(other.buffer)}
-{
+SPDLOG_INLINE log_msg_buffer::log_msg_buffer(log_msg_buffer &&other) SPDLOG_NOEXCEPT
+    : log_msg{other},
+      buffer{std::move(other.buffer)} {
     update_string_views();
 }
 
-SPDLOG_INLINE log_msg_buffer &log_msg_buffer::operator=(const log_msg_buffer &other)
-{
+SPDLOG_INLINE log_msg_buffer &log_msg_buffer::operator=(const log_msg_buffer &other) {
     log_msg::operator=(other);
     buffer.clear();
     buffer.append(other.buffer.data(), other.buffer.data() + other.buffer.size());
@@ -40,19 +38,17 @@ SPDLOG_INLINE log_msg_buffer &log_msg_buffer::operator=(const log_msg_buffer &ot
     return *this;
 }
 
-SPDLOG_INLINE log_msg_buffer &log_msg_buffer::operator=(log_msg_buffer &&other) SPDLOG_NOEXCEPT
-{
+SPDLOG_INLINE log_msg_buffer &log_msg_buffer::operator=(log_msg_buffer &&other) SPDLOG_NOEXCEPT {
     log_msg::operator=(other);
     buffer = std::move(other.buffer);
     update_string_views();
     return *this;
 }
 
-SPDLOG_INLINE void log_msg_buffer::update_string_views()
-{
+SPDLOG_INLINE void log_msg_buffer::update_string_views() {
     logger_name = string_view_t{buffer.data(), logger_name.size()};
     payload = string_view_t{buffer.data() + logger_name.size(), payload.size()};
 }
 
-} // namespace details
-} // namespace spdlog
+}  // namespace details
+}  // namespace spdlog

include/spdlog/details/log_msg_buffer.h

@@ -11,8 +11,7 @@ namespace details {
 // Extend log_msg with internal buffer to store its payload.
 // This is needed since log_msg holds string_views that points to stack data.
 
-class SPDLOG_API log_msg_buffer : public log_msg
-{
+class SPDLOG_API log_msg_buffer : public log_msg {
     memory_buf_t buffer;
     void update_string_views();
 
@@ -25,9 +24,9 @@ public:
     log_msg_buffer &operator=(log_msg_buffer &&other) SPDLOG_NOEXCEPT;
 };
 
-} // namespace details
-} // namespace spdlog
+}  // namespace details
+}  // namespace spdlog
 
 #ifdef SPDLOG_HEADER_ONLY
-#    include "log_msg_buffer-inl.h"
+    #include "log_msg_buffer-inl.h"
 #endif

include/spdlog/details/mpmc_blocking_q.h

@@ -12,25 +12,23 @@
 
 #include <spdlog/details/circular_q.h>
 
+#include <atomic>
 #include <condition_variable>
 #include <mutex>
 
 namespace spdlog {
 namespace details {
 
-template<typename T>
-class mpmc_blocking_queue
-{
+template <typename T>
+class mpmc_blocking_queue {
 public:
     using item_type = T;
     explicit mpmc_blocking_queue(size_t max_items)
-        : q_(max_items)
-    {}
+        : q_(max_items) {}
 
 #ifndef __MINGW32__
     // try to enqueue and block if no room left
-    void enqueue(T &&item)
-    {
+    void enqueue(T &&item) {
         {
             std::unique_lock<std::mutex> lock(queue_mutex_);
             pop_cv_.wait(lock, [this] { return !this->q_.full(); });
@@ -40,8 +38,7 @@ public:
     }
 
     // enqueue immediately. overrun oldest message in the queue if no room left.
-    void enqueue_nowait(T &&item)
-    {
+    void enqueue_nowait(T &&item) {
         {
             std::unique_lock<std::mutex> lock(queue_mutex_);
             q_.push_back(std::move(item));
@@ -49,14 +46,29 @@ public:
         push_cv_.notify_one();
     }
 
-    // try to dequeue item. if no item found. wait up to timeout and try again
-    // Return true, if succeeded dequeue item, false otherwise
-    bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration)
-    {
+    void enqueue_if_have_room(T &&item) {
+        bool pushed = false;
         {
             std::unique_lock<std::mutex> lock(queue_mutex_);
-            if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); }))
-            {
+            if (!q_.full()) {
+                q_.push_back(std::move(item));
+                pushed = true;
+            }
+        }
+
+        if (pushed) {
+            push_cv_.notify_one();
+        } else {
+            ++discard_counter_;
+        }
+    }
+
+    // dequeue with a timeout.
+    // Return true, if succeeded dequeue item, false otherwise
+    bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration) {
+        {
+            std::unique_lock<std::mutex> lock(queue_mutex_);
+            if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); })) {
                 return false;
             }
             popped_item = std::move(q_.front());
@@ -66,13 +78,23 @@ public:
         return true;
     }
 
+    // blocking dequeue without a timeout.
+    void dequeue(T &popped_item) {
+        {
+            std::unique_lock<std::mutex> lock(queue_mutex_);
+            push_cv_.wait(lock, [this] { return !this->q_.empty(); });
+            popped_item = std::move(q_.front());
+            q_.pop_front();
+        }
+        pop_cv_.notify_one();
+    }
+
 #else
     // apparently mingw deadlocks if the mutex is released before cv.notify_one(),
     // so release the mutex at the very end each function.
 
     // try to enqueue and block if no room left
-    void enqueue(T &&item)
-    {
+    void enqueue(T &&item) {
         std::unique_lock<std::mutex> lock(queue_mutex_);
         pop_cv_.wait(lock, [this] { return !this->q_.full(); });
         q_.push_back(std::move(item));
@@ -80,20 +102,32 @@ public:
     }
 
     // enqueue immediately. overrun oldest message in the queue if no room left.
-    void enqueue_nowait(T &&item)
-    {
+    void enqueue_nowait(T &&item) {
         std::unique_lock<std::mutex> lock(queue_mutex_);
         q_.push_back(std::move(item));
         push_cv_.notify_one();
     }
 
-    // try to dequeue item. if no item found. wait up to timeout and try again
-    // Return true, if succeeded dequeue item, false otherwise
-    bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration)
-    {
+    void enqueue_if_have_room(T &&item) {
+        bool pushed = false;
         std::unique_lock<std::mutex> lock(queue_mutex_);
-        if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); }))
-        {
+        if (!q_.full()) {
+            q_.push_back(std::move(item));
+            pushed = true;
+        }
+
+        if (pushed) {
+            push_cv_.notify_one();
+        } else {
+            ++discard_counter_;
+        }
+    }
+
+    // dequeue with a timeout.
+    // Return true, if succeeded dequeue item, false otherwise
+    bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration) {
+        std::unique_lock<std::mutex> lock(queue_mutex_);
+        if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); })) {
             return false;
         }
         popped_item = std::move(q_.front());
@@ -102,31 +136,42 @@ public:
         return true;
     }
 
+    // blocking dequeue without a timeout.
+    void dequeue(T &popped_item) {
+        std::unique_lock<std::mutex> lock(queue_mutex_);
+        push_cv_.wait(lock, [this] { return !this->q_.empty(); });
+        popped_item = std::move(q_.front());
+        q_.pop_front();
+        pop_cv_.notify_one();
+    }
+
 #endif
 
-    size_t overrun_counter()
-    {
+    size_t overrun_counter() {
         std::unique_lock<std::mutex> lock(queue_mutex_);
         return q_.overrun_counter();
     }
 
-    size_t size()
-    {
+    size_t discard_counter() { return discard_counter_.load(std::memory_order_relaxed); }
+
+    size_t size() {
         std::unique_lock<std::mutex> lock(queue_mutex_);
         return q_.size();
     }
 
-    void reset_overrun_counter()
-    {
+    void reset_overrun_counter() {
         std::unique_lock<std::mutex> lock(queue_mutex_);
         q_.reset_overrun_counter();
     }
 
+    void reset_discard_counter() { discard_counter_.store(0, std::memory_order_relaxed); }
+
 private:
     std::mutex queue_mutex_;
     std::condition_variable push_cv_;
     std::condition_variable pop_cv_;
     spdlog::details::circular_q<T> q_;
+    std::atomic<size_t> discard_counter_{0};
 };
-} // namespace details
-} // namespace spdlog
+}  // namespace details
+}  // namespace spdlog

include/spdlog/details/null_mutex.h

@@ -9,37 +9,27 @@
 
 namespace spdlog {
 namespace details {
-struct null_mutex
-{
+struct null_mutex {
     void lock() const {}
     void unlock() const {}
 };
 
-struct null_atomic_int
-{
+struct null_atomic_int {
     int value;
     null_atomic_int() = default;
 
     explicit null_atomic_int(int new_value)
-        : value(new_value)
-    {}
+        : value(new_value) {}
 
-    int load(std::memory_order = std::memory_order_relaxed) const
-    {
-        return value;
-    }
+    int load(std::memory_order = std::memory_order_relaxed) const { return value; }
 
-    void store(int new_value, std::memory_order = std::memory_order_relaxed)
-    {
-        value = new_value;
-    }
+    void store(int new_value, std::memory_order = std::memory_order_relaxed) { value = new_value; }
 
-    int exchange(int new_value, std::memory_order = std::memory_order_relaxed)
-    {
+    int exchange(int new_value, std::memory_order = std::memory_order_relaxed) {
         std::swap(new_value, value);
-        return new_value; // return value before the call
+        return new_value;  // return value before the call
     }
 };
 
-} // namespace details
-} // namespace spdlog
+}  // namespace details
+}  // namespace spdlog

include/spdlog/details/os-inl.h

@@ -4,86 +4,88 @@
 #pragma once
 
 #ifndef SPDLOG_HEADER_ONLY
-#    include <spdlog/details/os.h>
+    #include <spdlog/details/os.h>
 #endif
 
 #include <spdlog/common.h>
 
 #include <algorithm>
+#include <array>
 #include <chrono>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <ctime>
 #include <string>
-#include <thread>
-#include <array>
 #include <sys/stat.h>
 #include <sys/types.h>
+#include <thread>
 
 #ifdef _WIN32
+    #include <spdlog/details/windows_include.h>
+    #include <fileapi.h>  // for FlushFileBuffers
+    #include <io.h>       // for _get_osfhandle, _isatty, _fileno
+    #include <process.h>  // for _get_pid
 
-#    include <io.h>      // _get_osfhandle and _isatty support
-#    include <process.h> //  _get_pid support
-#    include <spdlog/details/windows_include.h>
+    #ifdef __MINGW32__
+        #include <share.h>
+    #endif
 
-#    ifdef __MINGW32__
-#        include <share.h>
-#    endif
+    #if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)
+        #include <cassert>
+        #include <limits>
+    #endif
 
-#    if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)
-#        include <limits>
-#    endif
+    #include <direct.h>  // for _mkdir/_wmkdir
 
-#    include <direct.h> // for _mkdir/_wmkdir
+#else  // unix
 
-#else // unix
+    #include <fcntl.h>
+    #include <unistd.h>
 
-#    include <fcntl.h>
-#    include <unistd.h>
+    #ifdef __linux__
+        #include <sys/syscall.h>  //Use gettid() syscall under linux to get thread id
 
-#    ifdef __linux__
-#        include <sys/syscall.h> //Use gettid() syscall under linux to get thread id
+    #elif defined(_AIX)
+        #include <pthread.h>  // for pthread_getthrds_np
 
-#    elif defined(_AIX)
-#        include <pthread.h> // for pthread_getthrds_np
+    #elif defined(__DragonFly__) || defined(__FreeBSD__)
+        #include <pthread_np.h>  // for pthread_getthreadid_np
 
-#    elif defined(__DragonFly__) || defined(__FreeBSD__)
-#        include <pthread_np.h> // for pthread_getthreadid_np
+    #elif defined(__NetBSD__)
+        #include <lwp.h>  // for _lwp_self
 
-#    elif defined(__NetBSD__)
-#        include <lwp.h> // for _lwp_self
+    #elif defined(__sun)
+        #include <thread.h>  // for thr_self
+    #endif
 
-#    elif defined(__sun)
-#        include <thread.h> // for thr_self
-#    endif
+#endif  // unix
 
-#endif // unix
+#if defined __APPLE__
+    #include <AvailabilityMacros.h>
+#endif
 
-#ifndef __has_feature          // Clang - feature checking macros.
-#    define __has_feature(x) 0 // Compatibility with non-clang compilers.
+#ifndef __has_feature           // Clang - feature checking macros.
+    #define __has_feature(x) 0  // Compatibility with non-clang compilers.
 #endif
 
 namespace spdlog {
 namespace details {
 namespace os {
 
-SPDLOG_INLINE spdlog::log_clock::time_point now() SPDLOG_NOEXCEPT
-{
-
+SPDLOG_INLINE spdlog::log_clock::time_point now() SPDLOG_NOEXCEPT {
 #if defined __linux__ && defined SPDLOG_CLOCK_COARSE
     timespec ts;
     ::clock_gettime(CLOCK_REALTIME_COARSE, &ts);
     return std::chrono::time_point<log_clock, typename log_clock::duration>(
-        std::chrono::duration_cast<typename log_clock::duration>(std::chrono::seconds(ts.tv_sec) + std::chrono::nanoseconds(ts.tv_nsec)));
+        std::chrono::duration_cast<typename log_clock::duration>(
+            std::chrono::seconds(ts.tv_sec) + std::chrono::nanoseconds(ts.tv_nsec)));
 
 #else
     return log_clock::now();
 #endif
 }
-SPDLOG_INLINE std::tm localtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT
-{
-
+SPDLOG_INLINE std::tm localtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT {
 #ifdef _WIN32
     std::tm tm;
     ::localtime_s(&tm, &time_tt);
@@ -94,15 +96,12 @@ SPDLOG_INLINE std::tm localtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT
     return tm;
 }
 
-SPDLOG_INLINE std::tm localtime() SPDLOG_NOEXCEPT
-{
+SPDLOG_INLINE std::tm localtime() SPDLOG_NOEXCEPT {
     std::time_t now_t = ::time(nullptr);
     return localtime(now_t);
 }
 
-SPDLOG_INLINE std::tm gmtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT
-{
-
+SPDLOG_INLINE std::tm gmtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT {
 #ifdef _WIN32
     std::tm tm;
     ::gmtime_s(&tm, &time_tt);
@@ -113,55 +112,49 @@ SPDLOG_INLINE std::tm gmtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT
     return tm;
 }
 
-SPDLOG_INLINE std::tm gmtime() SPDLOG_NOEXCEPT
-{
+SPDLOG_INLINE std::tm gmtime() SPDLOG_NOEXCEPT {
     std::time_t now_t = ::time(nullptr);
     return gmtime(now_t);
 }
 
 // fopen_s on non windows for writing
-SPDLOG_INLINE bool fopen_s(FILE **fp, const filename_t &filename, const filename_t &mode)
-{
+SPDLOG_INLINE bool fopen_s(FILE **fp, const filename_t &filename, const filename_t &mode) {
 #ifdef _WIN32
-#    ifdef SPDLOG_WCHAR_FILENAMES
+    #ifdef SPDLOG_WCHAR_FILENAMES
     *fp = ::_wfsopen((filename.c_str()), mode.c_str(), _SH_DENYNO);
-#    else
+    #else
     *fp = ::_fsopen((filename.c_str()), mode.c_str(), _SH_DENYNO);
-#    endif
-#    if defined(SPDLOG_PREVENT_CHILD_FD)
-    if (*fp != nullptr)
-    {
+    #endif
+    #if defined(SPDLOG_PREVENT_CHILD_FD)
+    if (*fp != nullptr) {
         auto file_handle = reinterpret_cast<HANDLE>(_get_osfhandle(::_fileno(*fp)));
-        if (!::SetHandleInformation(file_handle, HANDLE_FLAG_INHERIT, 0))
-        {
+        if (!::SetHandleInformation(file_handle, HANDLE_FLAG_INHERIT, 0)) {
             ::fclose(*fp);
             *fp = nullptr;
         }
     }
-#    endif
-#else // unix
-#    if defined(SPDLOG_PREVENT_CHILD_FD)
+    #endif
+#else  // unix
+    #if defined(SPDLOG_PREVENT_CHILD_FD)
     const int mode_flag = mode == SPDLOG_FILENAME_T("ab") ? O_APPEND : O_TRUNC;
-    const int fd = ::open((filename.c_str()), O_CREAT | O_WRONLY | O_CLOEXEC | mode_flag, mode_t(0644));
-    if (fd == -1)
-    {
+    const int fd =
+        ::open((filename.c_str()), O_CREAT | O_WRONLY | O_CLOEXEC | mode_flag, mode_t(0644));
+    if (fd == -1) {
         return true;
     }
     *fp = ::fdopen(fd, mode.c_str());
-    if (*fp == nullptr)
-    {
+    if (*fp == nullptr) {
         ::close(fd);
     }
-#    else
+    #else
     *fp = ::fopen((filename.c_str()), mode.c_str());
-#    endif
+    #endif
 #endif
 
     return *fp == nullptr;
 }
 
-SPDLOG_INLINE int remove(const filename_t &filename) SPDLOG_NOEXCEPT
-{
+SPDLOG_INLINE int remove(const filename_t &filename) SPDLOG_NOEXCEPT {
 #if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
     return ::_wremove(filename.c_str());
 #else
@@ -169,13 +162,11 @@ SPDLOG_INLINE int remove(const filename_t &filename) SPDLOG_NOEXCEPT
 #endif
 }
 
-SPDLOG_INLINE int remove_if_exists(const filename_t &filename) SPDLOG_NOEXCEPT
-{
+SPDLOG_INLINE int remove_if_exists(const filename_t &filename) SPDLOG_NOEXCEPT {
     return path_exists(filename) ? remove(filename) : 0;
 }
 
-SPDLOG_INLINE int rename(const filename_t &filename1, const filename_t &filename2) SPDLOG_NOEXCEPT
-{
+SPDLOG_INLINE int rename(const filename_t &filename1, const filename_t &filename2) SPDLOG_NOEXCEPT {
 #if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
     return ::_wrename(filename1.c_str(), filename2.c_str());
 #else
@@ -184,114 +175,103 @@ SPDLOG_INLINE int rename(const filename_t &filename1, const filename_t &filename
 }
 
 // Return true if path exists (file or directory)
-SPDLOG_INLINE bool path_exists(const filename_t &filename) SPDLOG_NOEXCEPT
-{
+SPDLOG_INLINE bool path_exists(const filename_t &filename) SPDLOG_NOEXCEPT {
 #ifdef _WIN32
-#    ifdef SPDLOG_WCHAR_FILENAMES
-    auto attribs = ::GetFileAttributesW(filename.c_str());
-#    else
-    auto attribs = ::GetFileAttributesA(filename.c_str());
-#    endif
-    return attribs != INVALID_FILE_ATTRIBUTES;
-#else // common linux/unix all have the stat system call
+    struct _stat buffer;
+    #ifdef SPDLOG_WCHAR_FILENAMES
+    return (::_wstat(filename.c_str(), &buffer) == 0);
+    #else
+    return (::_stat(filename.c_str(), &buffer) == 0);
+    #endif
+#else  // common linux/unix all have the stat system call
     struct stat buffer;
     return (::stat(filename.c_str(), &buffer) == 0);
 #endif
 }
 
 #ifdef _MSC_VER
-// avoid warning about unreachable statement at the end of filesize()
-#    pragma warning(push)
-#    pragma warning(disable : 4702)
+    // avoid warning about unreachable statement at the end of filesize()
+    #pragma warning(push)
+    #pragma warning(disable : 4702)
 #endif
 
 // Return file size according to open FILE* object
-SPDLOG_INLINE size_t filesize(FILE *f)
-{
-    if (f == nullptr)
-    {
+SPDLOG_INLINE size_t filesize(FILE *f) {
+    if (f == nullptr) {
         throw_spdlog_ex("Failed getting file size. fd is null");
     }
 #if defined(_WIN32) && !defined(__CYGWIN__)
     int fd = ::_fileno(f);
-#    if defined(_WIN64) // 64 bits
+    #if defined(_WIN64)  // 64 bits
     __int64 ret = ::_filelengthi64(fd);
-    if (ret >= 0)
-    {
+    if (ret >= 0) {
         return static_cast<size_t>(ret);
     }
 
-#    else // windows 32 bits
+    #else  // windows 32 bits
     long ret = ::_filelength(fd);
-    if (ret >= 0)
-    {
+    if (ret >= 0) {
         return static_cast<size_t>(ret);
     }
-#    endif
+    #endif
 
-#else // unix
-// OpenBSD and AIX doesn't compile with :: before the fileno(..)
-#    if defined(__OpenBSD__) || defined(_AIX)
+#else  // unix
+    // OpenBSD and AIX doesn't compile with :: before the fileno(..)
+    #if defined(__OpenBSD__) || defined(_AIX)
     int fd = fileno(f);
-#    else
+    #else
     int fd = ::fileno(f);
-#    endif
-// 64 bits(but not in osx or cygwin, where fstat64 is deprecated)
-#    if (defined(__linux__) || defined(__sun) || defined(_AIX)) && (defined(__LP64__) || defined(_LP64))
+    #endif
+    // 64 bits(but not in osx, linux/musl or cygwin, where fstat64 is deprecated)
+    #if ((defined(__linux__) && defined(__GLIBC__)) || defined(__sun) || defined(_AIX)) && \
+        (defined(__LP64__) || defined(_LP64))
     struct stat64 st;
-    if (::fstat64(fd, &st) == 0)
-    {
+    if (::fstat64(fd, &st) == 0) {
         return static_cast<size_t>(st.st_size);
     }
-#    else // other unix or linux 32 bits or cygwin
+    #else  // other unix or linux 32 bits or cygwin
     struct stat st;
-    if (::fstat(fd, &st) == 0)
-    {
+    if (::fstat(fd, &st) == 0) {
         return static_cast<size_t>(st.st_size);
     }
-#    endif
+    #endif
 #endif
     throw_spdlog_ex("Failed getting file size from fd", errno);
-    return 0; // will not be reached.
+    return 0;  // will not be reached.
 }
 
 #ifdef _MSC_VER
-#    pragma warning(pop)
+    #pragma warning(pop)
 #endif
 
 // Return utc offset in minutes or throw spdlog_ex on failure
-SPDLOG_INLINE int utc_minutes_offset(const std::tm &tm)
-{
-
+SPDLOG_INLINE int utc_minutes_offset(const std::tm &tm) {
 #ifdef _WIN32
-#    if _WIN32_WINNT < _WIN32_WINNT_WS08
+    #if _WIN32_WINNT < _WIN32_WINNT_WS08
     TIME_ZONE_INFORMATION tzinfo;
     auto rv = ::GetTimeZoneInformation(&tzinfo);
-#    else
+    #else
     DYNAMIC_TIME_ZONE_INFORMATION tzinfo;
     auto rv = ::GetDynamicTimeZoneInformation(&tzinfo);
-#    endif
-    if (rv == TIME_ZONE_ID_INVALID)
-        throw_spdlog_ex("Failed getting timezone info. ", errno);
+    #endif
+    if (rv == TIME_ZONE_ID_INVALID) throw_spdlog_ex("Failed getting timezone info. ", errno);
 
     int offset = -tzinfo.Bias;
-    if (tm.tm_isdst)
-    {
+    if (tm.tm_isdst) {
         offset -= tzinfo.DaylightBias;
-    }
-    else
-    {
+    } else {
         offset -= tzinfo.StandardBias;
     }
     return offset;
 #else
 
-#    if defined(sun) || defined(__sun) || defined(_AIX) || (!defined(_BSD_SOURCE) && !defined(_GNU_SOURCE))
+    #if defined(sun) || defined(__sun) || defined(_AIX) || \
+        (defined(__NEWLIB__) && !defined(__TM_GMTOFF)) ||  \
+        (!defined(_BSD_SOURCE) && !defined(_GNU_SOURCE))
     // 'tm_gmtoff' field is BSD extension and it's missing on SunOS/Solaris
-    struct helper
-    {
-        static long int calculate_gmt_offset(const std::tm &localtm = details::os::localtime(), const std::tm &gmtm = details::os::gmtime())
-        {
+    struct helper {
+        static long int calculate_gmt_offset(const std::tm &localtm = details::os::localtime(),
+                                             const std::tm &gmtm = details::os::gmtime()) {
             int local_year = localtm.tm_year + (1900 - 1);
             int gmt_year = gmtm.tm_year + (1900 - 1);
 
@@ -316,9 +296,9 @@ SPDLOG_INLINE int utc_minutes_offset(const std::tm &tm)
     };
 
     auto offset_seconds = helper::calculate_gmt_offset(tm);
-#    else
+    #else
     auto offset_seconds = tm.tm_gmtoff;
-#    endif
+    #endif
 
     return static_cast<int>(offset_seconds / 60);
 #endif
@@ -327,14 +307,13 @@ SPDLOG_INLINE int utc_minutes_offset(const std::tm &tm)
 // Return current thread id as size_t
 // It exists because the std::this_thread::get_id() is much slower(especially
 // under VS 2013)
-SPDLOG_INLINE size_t _thread_id() SPDLOG_NOEXCEPT
-{
+SPDLOG_INLINE size_t _thread_id() SPDLOG_NOEXCEPT {
 #ifdef _WIN32
     return static_cast<size_t>(::GetCurrentThreadId());
 #elif defined(__linux__)
-#    if defined(__ANDROID__) && defined(__ANDROID_API__) && (__ANDROID_API__ < 21)
-#        define SYS_gettid __NR_gettid
-#    endif
+    #if defined(__ANDROID__) && defined(__ANDROID_API__) && (__ANDROID_API__ < 21)
+        #define SYS_gettid __NR_gettid
+    #endif
     return static_cast<size_t>(::syscall(SYS_gettid));
 #elif defined(_AIX)
     struct __pthrdsinfo buf;
@@ -353,19 +332,36 @@ SPDLOG_INLINE size_t _thread_id() SPDLOG_NOEXCEPT
     return static_cast<size_t>(::thr_self());
 #elif __APPLE__
     uint64_t tid;
+    // There is no pthread_threadid_np prior to Mac OS X 10.6, and it is not supported on any PPC,
+    // including 10.6.8 Rosetta. __POWERPC__ is Apple-specific define encompassing ppc and ppc64.
+    #ifdef MAC_OS_X_VERSION_MAX_ALLOWED
+    {
+        #if (MAC_OS_X_VERSION_MAX_ALLOWED < 1060) || defined(__POWERPC__)
+        tid = pthread_mach_thread_np(pthread_self());
+        #elif MAC_OS_X_VERSION_MIN_REQUIRED < 1060
+        if (&pthread_threadid_np) {
+            pthread_threadid_np(nullptr, &tid);
+        } else {
+            tid = pthread_mach_thread_np(pthread_self());
+        }
+        #else
+        pthread_threadid_np(nullptr, &tid);
+        #endif
+    }
+    #else
     pthread_threadid_np(nullptr, &tid);
+    #endif
     return static_cast<size_t>(tid);
-#else // Default to standard C++11 (other Unix)
+#else  // Default to standard C++11 (other Unix)
     return static_cast<size_t>(std::hash<std::thread::id>()(std::this_thread::get_id()));
 #endif
 }
 
 // Return current thread id as size_t (from thread local storage)
-SPDLOG_INLINE size_t thread_id() SPDLOG_NOEXCEPT
-{
+SPDLOG_INLINE size_t thread_id() SPDLOG_NOEXCEPT {
 #if defined(SPDLOG_NO_TLS)
     return _thread_id();
-#else // cache thread id in tls
+#else  // cache thread id in tls
     static thread_local const size_t tid = _thread_id();
     return tid;
 #endif
@@ -373,8 +369,7 @@ SPDLOG_INLINE size_t thread_id() SPDLOG_NOEXCEPT
 
 // This is avoid msvc issue in sleep_for that happens if the clock changes.
 // See https://github.com/gabime/spdlog/issues/609
-SPDLOG_INLINE void sleep_for_millis(unsigned int milliseconds) SPDLOG_NOEXCEPT
-{
+SPDLOG_INLINE void sleep_for_millis(unsigned int milliseconds) SPDLOG_NOEXCEPT {
 #if defined(_WIN32)
     ::Sleep(milliseconds);
 #else
@@ -384,22 +379,16 @@ SPDLOG_INLINE void sleep_for_millis(unsigned int milliseconds) SPDLOG_NOEXCEPT
 
 // wchar support for windows file names (SPDLOG_WCHAR_FILENAMES must be defined)
 #if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
-SPDLOG_INLINE std::string filename_to_str(const filename_t &filename)
-{
+SPDLOG_INLINE std::string filename_to_str(const filename_t &filename) {
     memory_buf_t buf;
     wstr_to_utf8buf(filename, buf);
     return SPDLOG_BUF_TO_STRING(buf);
 }
 #else
-SPDLOG_INLINE std::string filename_to_str(const filename_t &filename)
-{
-    return filename;
-}
+SPDLOG_INLINE std::string filename_to_str(const filename_t &filename) { return filename; }
 #endif
 
-SPDLOG_INLINE int pid() SPDLOG_NOEXCEPT
-{
-
+SPDLOG_INLINE int pid() SPDLOG_NOEXCEPT {
 #ifdef _WIN32
     return conditional_static_cast<int>(::GetCurrentProcessId());
 #else
@@ -409,29 +398,29 @@ SPDLOG_INLINE int pid() SPDLOG_NOEXCEPT
 
 // Determine if the terminal supports colors
 // Based on: https://github.com/agauniyal/rang/
-SPDLOG_INLINE bool is_color_terminal() SPDLOG_NOEXCEPT
-{
+SPDLOG_INLINE bool is_color_terminal() SPDLOG_NOEXCEPT {
 #ifdef _WIN32
     return true;
 #else
 
     static const bool result = []() {
         const char *env_colorterm_p = std::getenv("COLORTERM");
-        if (env_colorterm_p != nullptr)
-        {
+        if (env_colorterm_p != nullptr) {
             return true;
         }
 
-        static constexpr std::array<const char *, 16> terms = {{"ansi", "color", "console", "cygwin", "gnome", "konsole", "kterm", "linux",
-            "msys", "putty", "rxvt", "screen", "vt100", "xterm", "alacritty", "vt102"}};
+        static constexpr std::array<const char *, 16> terms = {
+            {"ansi", "color", "console", "cygwin", "gnome", "konsole", "kterm", "linux", "msys",
+             "putty", "rxvt", "screen", "vt100", "xterm", "alacritty", "vt102"}};
 
         const char *env_term_p = std::getenv("TERM");
-        if (env_term_p == nullptr)
-        {
+        if (env_term_p == nullptr) {
             return false;
         }
 
-        return std::any_of(terms.begin(), terms.end(), [&](const char *term) { return std::strstr(env_term_p, term) != nullptr; });
+        return std::any_of(terms.begin(), terms.end(), [&](const char *term) {
+            return std::strstr(env_term_p, term) != nullptr;
+        });
     }();
 
     return result;
@@ -440,9 +429,7 @@ SPDLOG_INLINE bool is_color_terminal() SPDLOG_NOEXCEPT
 
 // Determine if the terminal attached
 // Source: https://github.com/agauniyal/rang/
-SPDLOG_INLINE bool in_terminal(FILE *file) SPDLOG_NOEXCEPT
-{
-
+SPDLOG_INLINE bool in_terminal(FILE *file) SPDLOG_NOEXCEPT {
 #ifdef _WIN32
     return ::_isatty(_fileno(file)) != 0;
 #else
@@ -451,86 +438,77 @@ SPDLOG_INLINE bool in_terminal(FILE *file) SPDLOG_NOEXCEPT
 }
 
 #if (defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)) && defined(_WIN32)
-SPDLOG_INLINE void wstr_to_utf8buf(wstring_view_t wstr, memory_buf_t &target)
-{
-    if (wstr.size() > static_cast<size_t>((std::numeric_limits<int>::max)()) / 2 - 1)
-    {
+SPDLOG_INLINE void wstr_to_utf8buf(wstring_view_t wstr, memory_buf_t &target) {
+    if (wstr.size() > static_cast<size_t>((std::numeric_limits<int>::max)()) / 4 - 1) {
         throw_spdlog_ex("UTF-16 string is too big to be converted to UTF-8");
     }
 
     int wstr_size = static_cast<int>(wstr.size());
-    if (wstr_size == 0)
-    {
+    if (wstr_size == 0) {
         target.resize(0);
         return;
     }
 
     int result_size = static_cast<int>(target.capacity());
-    if ((wstr_size + 1) * 2 > result_size)
-    {
-        result_size = ::WideCharToMultiByte(CP_UTF8, 0, wstr.data(), wstr_size, NULL, 0, NULL, NULL);
+    if ((wstr_size + 1) * 4 > result_size) {
+        result_size =
+            ::WideCharToMultiByte(CP_UTF8, 0, wstr.data(), wstr_size, NULL, 0, NULL, NULL);
     }
 
-    if (result_size > 0)
-    {
+    if (result_size > 0) {
         target.resize(result_size);
-        result_size = ::WideCharToMultiByte(CP_UTF8, 0, wstr.data(), wstr_size, target.data(), result_size, NULL, NULL);
+        result_size = ::WideCharToMultiByte(CP_UTF8, 0, wstr.data(), wstr_size, target.data(),
+                                            result_size, NULL, NULL);
 
-        if (result_size > 0)
-        {
+        if (result_size > 0) {
             target.resize(result_size);
             return;
         }
     }
 
-    throw_spdlog_ex(fmt_lib::format("WideCharToMultiByte failed. Last error: {}", ::GetLastError()));
+    throw_spdlog_ex(
+        fmt_lib::format("WideCharToMultiByte failed. Last error: {}", ::GetLastError()));
 }
 
-SPDLOG_INLINE void utf8_to_wstrbuf(string_view_t str, wmemory_buf_t &target)
-{
-    if (str.size() > static_cast<size_t>((std::numeric_limits<int>::max)()) - 1)
-    {
+SPDLOG_INLINE void utf8_to_wstrbuf(string_view_t str, wmemory_buf_t &target) {
+    if (str.size() > static_cast<size_t>((std::numeric_limits<int>::max)()) - 1) {
         throw_spdlog_ex("UTF-8 string is too big to be converted to UTF-16");
     }
 
     int str_size = static_cast<int>(str.size());
-    if (str_size == 0)
-    {
+    if (str_size == 0) {
         target.resize(0);
         return;
     }
 
-    int result_size = static_cast<int>(target.capacity());
-    if (str_size + 1 > result_size)
-    {
-        result_size = ::MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, str.data(), str_size, NULL, 0);
-    }
+    // find the size to allocate for the result buffer
+    int result_size =
+        ::MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, str.data(), str_size, NULL, 0);
 
-    if (result_size > 0)
-    {
+    if (result_size > 0) {
         target.resize(result_size);
-        result_size = ::MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, str.data(), str_size, target.data(), result_size);
-
-        if (result_size > 0)
-        {
-            target.resize(result_size);
+        result_size = ::MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, str.data(), str_size,
+                                            target.data(), result_size);
+        if (result_size > 0) {
+            assert(result_size == target.size());
             return;
         }
     }
 
-    throw_spdlog_ex(fmt_lib::format("MultiByteToWideChar failed. Last error: {}", ::GetLastError()));
+    throw_spdlog_ex(
+        fmt_lib::format("MultiByteToWideChar failed. Last error: {}", ::GetLastError()));
 }
-#endif // (defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)) && defined(_WIN32)
+#endif  // (defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)) &&
+        // defined(_WIN32)
 
 // return true on success
-static SPDLOG_INLINE bool mkdir_(const filename_t &path)
-{
+static SPDLOG_INLINE bool mkdir_(const filename_t &path) {
 #ifdef _WIN32
-#    ifdef SPDLOG_WCHAR_FILENAMES
+    #ifdef SPDLOG_WCHAR_FILENAMES
     return ::_wmkdir(path.c_str()) == 0;
-#    else
+    #else
     return ::_mkdir(path.c_str()) == 0;
-#    endif
+    #endif
 #else
     return ::mkdir(path.c_str(), mode_t(0755)) == 0;
 #endif
@@ -538,33 +516,36 @@ static SPDLOG_INLINE bool mkdir_(const filename_t &path)
 
 // create the given directory - and all directories leading to it
 // return true on success or if the directory already exists
-SPDLOG_INLINE bool create_dir(const filename_t &path)
-{
-    if (path_exists(path))
-    {
+SPDLOG_INLINE bool create_dir(const filename_t &path) {
+    if (path_exists(path)) {
         return true;
     }
 
-    if (path.empty())
-    {
+    if (path.empty()) {
         return false;
     }
 
     size_t search_offset = 0;
-    do
-    {
+    do {
         auto token_pos = path.find_first_of(folder_seps_filename, search_offset);
         // treat the entire path as a folder if no folder separator not found
-        if (token_pos == filename_t::npos)
-        {
+        if (token_pos == filename_t::npos) {
             token_pos = path.size();
         }
 
         auto subdir = path.substr(0, token_pos);
+#ifdef _WIN32
+        // if subdir is just a drive letter, add a slash e.g. "c:"=>"c:\",
+        // otherwise path_exists(subdir) returns false (issue #3079)
+        const bool is_drive = subdir.length() == 2 && subdir[1] == ':';
+        if (is_drive) {
+            subdir += '\\';
+            token_pos++;
+        }
+#endif
 
-        if (!subdir.empty() && !path_exists(subdir) && !mkdir_(subdir))
-        {
-            return false; // return error if failed creating dir
+        if (!subdir.empty() && !path_exists(subdir) && !mkdir_(subdir)) {
+            return false;  // return error if failed creating dir
         }
         search_offset = token_pos + 1;
     } while (search_offset < path.size());
@@ -577,30 +558,37 @@ SPDLOG_INLINE bool create_dir(const filename_t &path)
 // "abc/" => "abc"
 // "abc" => ""
 // "abc///" => "abc//"
-SPDLOG_INLINE filename_t dir_name(const filename_t &path)
-{
+SPDLOG_INLINE filename_t dir_name(const filename_t &path) {
     auto pos = path.find_last_of(folder_seps_filename);
     return pos != filename_t::npos ? path.substr(0, pos) : filename_t{};
 }
 
-std::string SPDLOG_INLINE getenv(const char *field)
-{
-
+std::string SPDLOG_INLINE getenv(const char *field) {
 #if defined(_MSC_VER)
-#    if defined(__cplusplus_winrt)
-    return std::string{}; // not supported under uwp
-#    else
+    #if defined(__cplusplus_winrt)
+    return std::string{};  // not supported under uwp
+    #else
     size_t len = 0;
     char buf[128];
     bool ok = ::getenv_s(&len, buf, sizeof(buf), field) == 0;
     return ok ? buf : std::string{};
-#    endif
-#else // revert to getenv
+    #endif
+#else  // revert to getenv
     char *buf = ::getenv(field);
     return buf ? buf : std::string{};
 #endif
 }
 
-} // namespace os
-} // namespace details
-} // namespace spdlog
+// Do fsync by FILE handlerpointer
+// Return true on success
+SPDLOG_INLINE bool fsync(FILE *fp) {
+#ifdef _WIN32
+    return FlushFileBuffers(reinterpret_cast<HANDLE>(_get_osfhandle(_fileno(fp)))) != 0;
+#else
+    return ::fsync(fileno(fp)) == 0;
+#endif
+}
+
+}  // namespace os
+}  // namespace details
+}  // namespace spdlog

include/spdlog/details/os.h

@@ -3,8 +3,8 @@
 
 #pragma once
 
+#include <ctime>  // std::time_t
 #include <spdlog/common.h>
-#include <ctime> // std::time_t
 
 namespace spdlog {
 namespace details {
@@ -22,26 +22,27 @@ SPDLOG_API std::tm gmtime() SPDLOG_NOEXCEPT;
 
 // eol definition
 #if !defined(SPDLOG_EOL)
-#    ifdef _WIN32
-#        define SPDLOG_EOL "\r\n"
-#    else
-#        define SPDLOG_EOL "\n"
-#    endif
+    #ifdef _WIN32
+        #define SPDLOG_EOL "\r\n"
+    #else
+        #define SPDLOG_EOL "\n"
+    #endif
 #endif
 
 SPDLOG_CONSTEXPR static const char *default_eol = SPDLOG_EOL;
 
 // folder separator
 #if !defined(SPDLOG_FOLDER_SEPS)
-#    ifdef _WIN32
-#        define SPDLOG_FOLDER_SEPS "\\/"
-#    else
-#        define SPDLOG_FOLDER_SEPS "/"
-#    endif
+    #ifdef _WIN32
+        #define SPDLOG_FOLDER_SEPS "\\/"
+    #else
+        #define SPDLOG_FOLDER_SEPS "/"
+    #endif
 #endif
 
 SPDLOG_CONSTEXPR static const char folder_seps[] = SPDLOG_FOLDER_SEPS;
-SPDLOG_CONSTEXPR static const filename_t::value_type folder_seps_filename[] = SPDLOG_FILENAME_T(SPDLOG_FOLDER_SEPS);
+SPDLOG_CONSTEXPR static const filename_t::value_type folder_seps_filename[] =
+    SPDLOG_FILENAME_T(SPDLOG_FOLDER_SEPS);
 
 // fopen_s on non windows for writing
 SPDLOG_API bool fopen_s(FILE **fp, const filename_t &filename, const filename_t &mode);
@@ -109,10 +110,14 @@ SPDLOG_API bool create_dir(const filename_t &path);
 // return empty string if field not found
 SPDLOG_API std::string getenv(const char *field);
 
-} // namespace os
-} // namespace details
-} // namespace spdlog
+// Do fsync by FILE objectpointer.
+// Return true on success.
+SPDLOG_API bool fsync(FILE *fp);
+
+}  // namespace os
+}  // namespace details
+}  // namespace spdlog
 
 #ifdef SPDLOG_HEADER_ONLY
-#    include "os-inl.h"
+    #include "os-inl.h"
 #endif

include/spdlog/details/periodic_worker-inl.h

@@ -4,17 +4,15 @@
 #pragma once
 
 #ifndef SPDLOG_HEADER_ONLY
-#    include <spdlog/details/periodic_worker.h>
+    #include <spdlog/details/periodic_worker.h>
 #endif
 
 namespace spdlog {
 namespace details {
 
 // stop the worker thread and join it
-SPDLOG_INLINE periodic_worker::~periodic_worker()
-{
-    if (worker_thread_.joinable())
-    {
+SPDLOG_INLINE periodic_worker::~periodic_worker() {
+    if (worker_thread_.joinable()) {
         {
             std::lock_guard<std::mutex> lock(mutex_);
             active_ = false;
@@ -24,5 +22,5 @@ SPDLOG_INLINE periodic_worker::~periodic_worker()
     }
 }
 
-} // namespace details
-} // namespace spdlog
+}  // namespace details
+}  // namespace spdlog

include/spdlog/details/periodic_worker.h

@@ -7,7 +7,8 @@
 //
 // RAII over the owned thread:
 //    creates the thread on construction.
-//    stops and joins the thread on destruction (if the thread is executing a callback, wait for it to finish first).
+//    stops and joins the thread on destruction (if the thread is executing a callback, wait for it
+//    to finish first).
 
 #include <chrono>
 #include <condition_variable>
@@ -17,30 +18,27 @@
 namespace spdlog {
 namespace details {
 
-class SPDLOG_API periodic_worker
-{
+class SPDLOG_API periodic_worker {
 public:
-    template<typename Rep, typename Period>
-    periodic_worker(const std::function<void()> &callback_fun, std::chrono::duration<Rep, Period> interval)
-    {
+    template <typename Rep, typename Period>
+    periodic_worker(const std::function<void()> &callback_fun,
+                    std::chrono::duration<Rep, Period> interval) {
         active_ = (interval > std::chrono::duration<Rep, Period>::zero());
-        if (!active_)
-        {
+        if (!active_) {
             return;
         }
 
         worker_thread_ = std::thread([this, callback_fun, interval]() {
-            for (;;)
-            {
+            for (;;) {
                 std::unique_lock<std::mutex> lock(this->mutex_);
-                if (this->cv_.wait_for(lock, interval, [this] { return !this->active_; }))
-                {
-                    return; // active_ == false, so exit this thread
+                if (this->cv_.wait_for(lock, interval, [this] { return !this->active_; })) {
+                    return;  // active_ == false, so exit this thread
                 }
                 callback_fun();
             }
         });
     }
+    std::thread &get_thread() { return worker_thread_; }
     periodic_worker(const periodic_worker &) = delete;
     periodic_worker &operator=(const periodic_worker &) = delete;
     // stop the worker thread and join it
@@ -52,9 +50,9 @@ private:
     std::mutex mutex_;
     std::condition_variable cv_;
 };
-} // namespace details
-} // namespace spdlog
+}  // namespace details
+}  // namespace spdlog
 
 #ifdef SPDLOG_HEADER_ONLY
-#    include "periodic_worker-inl.h"
+    #include "periodic_worker-inl.h"
 #endif

include/spdlog/details/registry-inl.h

@@ -4,7 +4,7 @@
 #pragma once
 
 #ifndef SPDLOG_HEADER_ONLY
-#    include <spdlog/details/registry.h>
+    #include <spdlog/details/registry.h>
 #endif
 
 #include <spdlog/common.h>
@@ -13,13 +13,13 @@
 #include <spdlog/pattern_formatter.h>
 
 #ifndef SPDLOG_DISABLE_DEFAULT_LOGGER
-// support for the default stdout color logger
-#    ifdef _WIN32
-#        include <spdlog/sinks/wincolor_sink.h>
-#    else
-#        include <spdlog/sinks/ansicolor_sink.h>
-#    endif
-#endif // SPDLOG_DISABLE_DEFAULT_LOGGER
+    // support for the default stdout color logger
+    #ifdef _WIN32
+        #include <spdlog/sinks/wincolor_sink.h>
+    #else
+        #include <spdlog/sinks/ansicolor_sink.h>
+    #endif
+#endif  // SPDLOG_DISABLE_DEFAULT_LOGGER
 
 #include <chrono>
 #include <functional>
@@ -31,39 +31,34 @@ namespace spdlog {
 namespace details {
 
 SPDLOG_INLINE registry::registry()
-    : formatter_(new pattern_formatter())
-{
-
+    : formatter_(new pattern_formatter()) {
 #ifndef SPDLOG_DISABLE_DEFAULT_LOGGER
     // create default logger (ansicolor_stdout_sink_mt or wincolor_stdout_sink_mt in windows).
-#    ifdef _WIN32
+    #ifdef _WIN32
     auto color_sink = std::make_shared<sinks::wincolor_stdout_sink_mt>();
-#    else
+    #else
     auto color_sink = std::make_shared<sinks::ansicolor_stdout_sink_mt>();
-#    endif
+    #endif
 
     const char *default_logger_name = "";
     default_logger_ = std::make_shared<spdlog::logger>(default_logger_name, std::move(color_sink));
     loggers_[default_logger_name] = default_logger_;
 
-#endif // SPDLOG_DISABLE_DEFAULT_LOGGER
+#endif  // SPDLOG_DISABLE_DEFAULT_LOGGER
 }
 
 SPDLOG_INLINE registry::~registry() = default;
 
-SPDLOG_INLINE void registry::register_logger(std::shared_ptr<logger> new_logger)
-{
+SPDLOG_INLINE void registry::register_logger(std::shared_ptr<logger> new_logger) {
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
     register_logger_(std::move(new_logger));
 }
 
-SPDLOG_INLINE void registry::initialize_logger(std::shared_ptr<logger> new_logger)
-{
+SPDLOG_INLINE void registry::initialize_logger(std::shared_ptr<logger> new_logger) {
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
     new_logger->set_formatter(formatter_->clone());
 
-    if (err_handler_)
-    {
+    if (err_handler_) {
         new_logger->set_error_handler(err_handler_);
     }
 
@@ -74,26 +69,22 @@ SPDLOG_INLINE void registry::initialize_logger(std::shared_ptr<logger> new_logge
 
     new_logger->flush_on(flush_level_);
 
-    if (backtrace_n_messages_ > 0)
-    {
+    if (backtrace_n_messages_ > 0) {
         new_logger->enable_backtrace(backtrace_n_messages_);
     }
 
-    if (automatic_registration_)
-    {
+    if (automatic_registration_) {
         register_logger_(std::move(new_logger));
     }
 }
 
-SPDLOG_INLINE std::shared_ptr<logger> registry::get(const std::string &logger_name)
-{
+SPDLOG_INLINE std::shared_ptr<logger> registry::get(const std::string &logger_name) {
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
     auto found = loggers_.find(logger_name);
     return found == loggers_.end() ? nullptr : found->second;
 }
 
-SPDLOG_INLINE std::shared_ptr<logger> registry::default_logger()
-{
+SPDLOG_INLINE std::shared_ptr<logger> registry::default_logger() {
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
     return default_logger_;
 }
@@ -102,140 +93,110 @@ SPDLOG_INLINE std::shared_ptr<logger> registry::default_logger()
 // To be used directly by the spdlog default api (e.g. spdlog::info)
 // This make the default API faster, but cannot be used concurrently with set_default_logger().
 // e.g do not call set_default_logger() from one thread while calling spdlog::info() from another.
-SPDLOG_INLINE logger *registry::get_default_raw()
-{
-    return default_logger_.get();
-}
+SPDLOG_INLINE logger *registry::get_default_raw() { return default_logger_.get(); }
 
 // set default logger.
 // default logger is stored in default_logger_ (for faster retrieval) and in the loggers_ map.
-SPDLOG_INLINE void registry::set_default_logger(std::shared_ptr<logger> new_default_logger)
-{
+SPDLOG_INLINE void registry::set_default_logger(std::shared_ptr<logger> new_default_logger) {
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
-    // remove previous default logger from the map
-    if (default_logger_ != nullptr)
-    {
-        loggers_.erase(default_logger_->name());
-    }
-    if (new_default_logger != nullptr)
-    {
+    if (new_default_logger != nullptr) {
         loggers_[new_default_logger->name()] = new_default_logger;
     }
     default_logger_ = std::move(new_default_logger);
 }
 
-SPDLOG_INLINE void registry::set_tp(std::shared_ptr<thread_pool> tp)
-{
+SPDLOG_INLINE void registry::set_tp(std::shared_ptr<thread_pool> tp) {
     std::lock_guard<std::recursive_mutex> lock(tp_mutex_);
     tp_ = std::move(tp);
 }
 
-SPDLOG_INLINE std::shared_ptr<thread_pool> registry::get_tp()
-{
+SPDLOG_INLINE std::shared_ptr<thread_pool> registry::get_tp() {
     std::lock_guard<std::recursive_mutex> lock(tp_mutex_);
     return tp_;
 }
 
 // Set global formatter. Each sink in each logger will get a clone of this object
-SPDLOG_INLINE void registry::set_formatter(std::unique_ptr<formatter> formatter)
-{
+SPDLOG_INLINE void registry::set_formatter(std::unique_ptr<formatter> formatter) {
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
     formatter_ = std::move(formatter);
-    for (auto &l : loggers_)
-    {
+    for (auto &l : loggers_) {
         l.second->set_formatter(formatter_->clone());
     }
 }
 
-SPDLOG_INLINE void registry::enable_backtrace(size_t n_messages)
-{
+SPDLOG_INLINE void registry::enable_backtrace(size_t n_messages) {
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
     backtrace_n_messages_ = n_messages;
 
-    for (auto &l : loggers_)
-    {
+    for (auto &l : loggers_) {
         l.second->enable_backtrace(n_messages);
     }
 }
 
-SPDLOG_INLINE void registry::disable_backtrace()
-{
+SPDLOG_INLINE void registry::disable_backtrace() {
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
     backtrace_n_messages_ = 0;
-    for (auto &l : loggers_)
-    {
+    for (auto &l : loggers_) {
         l.second->disable_backtrace();
     }
 }
 
-SPDLOG_INLINE void registry::set_level(level::level_enum log_level)
-{
+SPDLOG_INLINE void registry::set_level(level::level_enum log_level) {
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
-    for (auto &l : loggers_)
-    {
+    for (auto &l : loggers_) {
         l.second->set_level(log_level);
     }
     global_log_level_ = log_level;
 }
 
-SPDLOG_INLINE void registry::flush_on(level::level_enum log_level)
-{
+SPDLOG_INLINE void registry::flush_on(level::level_enum log_level) {
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
-    for (auto &l : loggers_)
-    {
+    for (auto &l : loggers_) {
         l.second->flush_on(log_level);
     }
     flush_level_ = log_level;
 }
 
-SPDLOG_INLINE void registry::set_error_handler(err_handler handler)
-{
+SPDLOG_INLINE void registry::set_error_handler(err_handler handler) {
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
-    for (auto &l : loggers_)
-    {
+    for (auto &l : loggers_) {
         l.second->set_error_handler(handler);
     }
     err_handler_ = std::move(handler);
 }
 
-SPDLOG_INLINE void registry::apply_all(const std::function<void(const std::shared_ptr<logger>)> &fun)
-{
+SPDLOG_INLINE void registry::apply_all(
+    const std::function<void(const std::shared_ptr<logger>)> &fun) {
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
-    for (auto &l : loggers_)
-    {
+    for (auto &l : loggers_) {
         fun(l.second);
     }
 }
 
-SPDLOG_INLINE void registry::flush_all()
-{
+SPDLOG_INLINE void registry::flush_all() {
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
-    for (auto &l : loggers_)
-    {
+    for (auto &l : loggers_) {
         l.second->flush();
     }
 }
 
-SPDLOG_INLINE void registry::drop(const std::string &logger_name)
-{
+SPDLOG_INLINE void registry::drop(const std::string &logger_name) {
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    auto is_default_logger = default_logger_ && default_logger_->name() == logger_name;
     loggers_.erase(logger_name);
-    if (default_logger_ && default_logger_->name() == logger_name)
-    {
+    if (is_default_logger) {
         default_logger_.reset();
     }
 }
 
-SPDLOG_INLINE void registry::drop_all()
-{
+SPDLOG_INLINE void registry::drop_all() {
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
     loggers_.clear();
     default_logger_.reset();
 }
 
 // clean all resources and threads started by the registry
-SPDLOG_INLINE void registry::shutdown()
-{
+SPDLOG_INLINE void registry::shutdown() {
     {
         std::lock_guard<std::mutex> lock(flusher_mutex_);
         periodic_flusher_.reset();
@@ -249,58 +210,52 @@ SPDLOG_INLINE void registry::shutdown()
     }
 }
 
-SPDLOG_INLINE std::recursive_mutex &registry::tp_mutex()
-{
-    return tp_mutex_;
-}
+SPDLOG_INLINE std::recursive_mutex &registry::tp_mutex() { return tp_mutex_; }
 
-SPDLOG_INLINE void registry::set_automatic_registration(bool automatic_registration)
-{
+SPDLOG_INLINE void registry::set_automatic_registration(bool automatic_registration) {
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
     automatic_registration_ = automatic_registration;
 }
 
-SPDLOG_INLINE void registry::set_levels(log_levels levels, level::level_enum *global_level)
-{
+SPDLOG_INLINE void registry::set_levels(log_levels levels, level::level_enum *global_level) {
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
     log_levels_ = std::move(levels);
     auto global_level_requested = global_level != nullptr;
     global_log_level_ = global_level_requested ? *global_level : global_log_level_;
 
-    for (auto &logger : loggers_)
-    {
+    for (auto &logger : loggers_) {
         auto logger_entry = log_levels_.find(logger.first);
-        if (logger_entry != log_levels_.end())
-        {
+        if (logger_entry != log_levels_.end()) {
             logger.second->set_level(logger_entry->second);
-        }
-        else if (global_level_requested)
-        {
+        } else if (global_level_requested) {
             logger.second->set_level(*global_level);
         }
     }
 }
 
-SPDLOG_INLINE registry &registry::instance()
-{
+SPDLOG_INLINE registry &registry::instance() {
     static registry s_instance;
     return s_instance;
 }
 
-SPDLOG_INLINE void registry::throw_if_exists_(const std::string &logger_name)
-{
-    if (loggers_.find(logger_name) != loggers_.end())
-    {
+SPDLOG_INLINE void registry::apply_logger_env_levels(std::shared_ptr<logger> new_logger) {
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    auto it = log_levels_.find(new_logger->name());
+    auto new_level = it != log_levels_.end() ? it->second : global_log_level_;
+    new_logger->set_level(new_level);
+}
+
+SPDLOG_INLINE void registry::throw_if_exists_(const std::string &logger_name) {
+    if (loggers_.find(logger_name) != loggers_.end()) {
         throw_spdlog_ex("logger with name '" + logger_name + "' already exists");
     }
 }
 
-SPDLOG_INLINE void registry::register_logger_(std::shared_ptr<logger> new_logger)
-{
+SPDLOG_INLINE void registry::register_logger_(std::shared_ptr<logger> new_logger) {
     auto logger_name = new_logger->name();
     throw_if_exists_(logger_name);
     loggers_[logger_name] = std::move(new_logger);
 }
 
-} // namespace details
-} // namespace spdlog
+}  // namespace details
+}  // namespace spdlog

include/spdlog/details/registry.h

@@ -14,9 +14,9 @@
 #include <chrono>
 #include <functional>
 #include <memory>
+#include <mutex>
 #include <string>
 #include <unordered_map>
-#include <mutex>
 
 namespace spdlog {
 class logger;
@@ -24,8 +24,7 @@ class logger;
 namespace details {
 class thread_pool;
 
-class SPDLOG_API registry
-{
+class SPDLOG_API registry {
 public:
     using log_levels = std::unordered_map<std::string, level::level_enum>;
     registry(const registry &) = delete;
@@ -39,11 +38,14 @@ public:
     // Return raw ptr to the default logger.
     // To be used directly by the spdlog default api (e.g. spdlog::info)
     // This make the default API faster, but cannot be used concurrently with set_default_logger().
-    // e.g do not call set_default_logger() from one thread while calling spdlog::info() from another.
+    // e.g do not call set_default_logger() from one thread while calling spdlog::info() from
+    // another.
     logger *get_default_raw();
 
-    // set default logger.
+    // set default logger and add it to the registry if not registered already.
     // default logger is stored in default_logger_ (for faster retrieval) and in the loggers_ map.
+    // Note: Make sure to unregister it when no longer needed or before calling again with a new
+    // logger.
     void set_default_logger(std::shared_ptr<logger> new_default_logger);
 
     void set_tp(std::shared_ptr<thread_pool> tp);
@@ -61,14 +63,18 @@ public:
 
     void flush_on(level::level_enum log_level);
 
-    template<typename Rep, typename Period>
-    void flush_every(std::chrono::duration<Rep, Period> interval)
-    {
+    template <typename Rep, typename Period>
+    void flush_every(std::chrono::duration<Rep, Period> interval) {
         std::lock_guard<std::mutex> lock(flusher_mutex_);
         auto clbk = [this]() { this->flush_all(); };
         periodic_flusher_ = details::make_unique<periodic_worker>(clbk, interval);
     }
 
+    std::unique_ptr<periodic_worker> &get_flusher() {
+        std::lock_guard<std::mutex> lock(flusher_mutex_);
+        return periodic_flusher_;
+    }
+
     void set_error_handler(err_handler handler);
 
     void apply_all(const std::function<void(const std::shared_ptr<logger>)> &fun);
@@ -91,6 +97,8 @@ public:
 
     static registry &instance();
 
+    void apply_logger_env_levels(std::shared_ptr<logger> new_logger);
+
 private:
     registry();
     ~registry();
@@ -113,9 +121,9 @@ private:
     size_t backtrace_n_messages_ = 0;
 };
 
-} // namespace details
-} // namespace spdlog
+}  // namespace details
+}  // namespace spdlog
 
 #ifdef SPDLOG_HEADER_ONLY
-#    include "registry-inl.h"
+    #include "registry-inl.h"
 #endif

include/spdlog/details/synchronous_factory.h

@@ -10,15 +10,13 @@ namespace spdlog {
 // Default logger factory-  creates synchronous loggers
 class logger;
 
-struct synchronous_factory
-{
-    template<typename Sink, typename... SinkArgs>
-    static std::shared_ptr<spdlog::logger> create(std::string logger_name, SinkArgs &&... args)
-    {
+struct synchronous_factory {
+    template <typename Sink, typename... SinkArgs>
+    static std::shared_ptr<spdlog::logger> create(std::string logger_name, SinkArgs &&...args) {
         auto sink = std::make_shared<Sink>(std::forward<SinkArgs>(args)...);
         auto new_logger = std::make_shared<spdlog::logger>(std::move(logger_name), std::move(sink));
         details::registry::instance().initialize_logger(new_logger);
         return new_logger;
     }
 };
-} // namespace spdlog
+}  // namespace spdlog

include/spdlog/details/tcp_client-windows.h

@@ -8,12 +8,12 @@
 #include <spdlog/common.h>
 #include <spdlog/details/os.h>
 
-#include <winsock2.h>
-#include <windows.h>
-#include <ws2tcpip.h>
-#include <stdlib.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <string>
+#include <windows.h>
+#include <winsock2.h>
+#include <ws2tcpip.h>
 
 #pragma comment(lib, "Ws2_32.lib")
 #pragma comment(lib, "Mswsock.lib")
@@ -21,79 +21,61 @@
 
 namespace spdlog {
 namespace details {
-class tcp_client
-{
+class tcp_client {
     SOCKET socket_ = INVALID_SOCKET;
 
-    static void init_winsock_()
-    {
+    static void init_winsock_() {
         WSADATA wsaData;
         auto rv = WSAStartup(MAKEWORD(2, 2), &wsaData);
-        if (rv != 0)
-        {
+        if (rv != 0) {
             throw_winsock_error_("WSAStartup failed", ::WSAGetLastError());
         }
     }
 
-    static void throw_winsock_error_(const std::string &msg, int last_error)
-    {
+    static void throw_winsock_error_(const std::string &msg, int last_error) {
         char buf[512];
-        ::FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, last_error,
-            MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), buf, (sizeof(buf) / sizeof(char)), NULL);
+        ::FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL,
+                         last_error, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), buf,
+                         (sizeof(buf) / sizeof(char)), NULL);
 
         throw_spdlog_ex(fmt_lib::format("tcp_sink - {}: {}", msg, buf));
     }
 
 public:
-    tcp_client()
-    {
-        init_winsock_();
-    }
+    tcp_client() { init_winsock_(); }
 
-    ~tcp_client()
-    {
+    ~tcp_client() {
         close();
         ::WSACleanup();
     }
 
-    bool is_connected() const
-    {
-        return socket_ != INVALID_SOCKET;
-    }
+    bool is_connected() const { return socket_ != INVALID_SOCKET; }
 
-    void close()
-    {
+    void close() {
         ::closesocket(socket_);
         socket_ = INVALID_SOCKET;
     }
 
-    SOCKET fd() const
-    {
-        return socket_;
-    }
+    SOCKET fd() const { return socket_; }
 
     // try to connect or throw on failure
-    void connect(const std::string &host, int port)
-    {
-        if (is_connected())
-        {
+    void connect(const std::string &host, int port) {
+        if (is_connected()) {
             close();
         }
-        struct addrinfo hints
-        {};
+        struct addrinfo hints {};
         ZeroMemory(&hints, sizeof(hints));
 
-        hints.ai_family = AF_INET;       // IPv4
-        hints.ai_socktype = SOCK_STREAM; // TCP
-        hints.ai_flags = AI_NUMERICSERV; // port passed as as numeric value
+        hints.ai_family = AF_UNSPEC;      // To work with IPv4, IPv6, and so on
+        hints.ai_socktype = SOCK_STREAM;  // TCP
+        hints.ai_flags = AI_NUMERICSERV;  // port passed as as numeric value
         hints.ai_protocol = 0;
 
         auto port_str = std::to_string(port);
         struct addrinfo *addrinfo_result;
         auto rv = ::getaddrinfo(host.c_str(), port_str.c_str(), &hints, &addrinfo_result);
         int last_error = 0;
-        if (rv != 0)
-        {
+        if (rv != 0) {
             last_error = ::WSAGetLastError();
             WSACleanup();
             throw_winsock_error_("getaddrinfo failed", last_error);
@@ -101,54 +83,47 @@ public:
 
         // Try each address until we successfully connect(2).
 
-        for (auto *rp = addrinfo_result; rp != nullptr; rp = rp->ai_next)
-        {
+        for (auto *rp = addrinfo_result; rp != nullptr; rp = rp->ai_next) {
             socket_ = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
-            if (socket_ == INVALID_SOCKET)
-            {
+            if (socket_ == INVALID_SOCKET) {
                 last_error = ::WSAGetLastError();
                 WSACleanup();
                 continue;
             }
-            if (::connect(socket_, rp->ai_addr, (int)rp->ai_addrlen) == 0)
-            {
+            if (::connect(socket_, rp->ai_addr, (int)rp->ai_addrlen) == 0) {
                 break;
-            }
-            else
-            {
+            } else {
                 last_error = ::WSAGetLastError();
                 close();
             }
         }
         ::freeaddrinfo(addrinfo_result);
-        if (socket_ == INVALID_SOCKET)
-        {
+        if (socket_ == INVALID_SOCKET) {
             WSACleanup();
             throw_winsock_error_("connect failed", last_error);
         }
 
         // set TCP_NODELAY
         int enable_flag = 1;
-        ::setsockopt(socket_, IPPROTO_TCP, TCP_NODELAY, reinterpret_cast<char *>(&enable_flag), sizeof(enable_flag));
+        ::setsockopt(socket_, IPPROTO_TCP, TCP_NODELAY, reinterpret_cast<char *>(&enable_flag),
+                     sizeof(enable_flag));
     }
 
     // Send exactly n_bytes of the given data.
     // On error close the connection and throw.
-    void send(const char *data, size_t n_bytes)
-    {
+    void send(const char *data, size_t n_bytes) {
         size_t bytes_sent = 0;
-        while (bytes_sent < n_bytes)
-        {
+        while (bytes_sent < n_bytes) {
             const int send_flags = 0;
-            auto write_result = ::send(socket_, data + bytes_sent, (int)(n_bytes - bytes_sent), send_flags);
-            if (write_result == SOCKET_ERROR)
-            {
+            auto write_result =
+                ::send(socket_, data + bytes_sent, (int)(n_bytes - bytes_sent), send_flags);
+            if (write_result == SOCKET_ERROR) {
                 int last_error = ::WSAGetLastError();
                 close();
                 throw_winsock_error_("send failed", last_error);
             }
 
-            if (write_result == 0) // (probably should not happen but in any case..)
+            if (write_result == 0)  // (probably should not happen but in any case..)
             {
                 break;
             }
@@ -156,5 +131,5 @@ public:
         }
     }
 };
-} // namespace details
-} // namespace spdlog
+}  // namespace details
+}  // namespace spdlog

include/spdlog/details/tcp_client.h

@@ -4,90 +4,73 @@
 #pragma once
 
 #ifdef _WIN32
-#    error include tcp_client-windows.h instead
+    #error include tcp_client-windows.h instead
 #endif
 
 // tcp client helper
 #include <spdlog/common.h>
 #include <spdlog/details/os.h>
 
-#include <sys/socket.h>
 #include <arpa/inet.h>
-#include <unistd.h>
 #include <netdb.h>
+#include <netinet/in.h>
 #include <netinet/tcp.h>
+#include <sys/socket.h>
+#include <unistd.h>
 
 #include <string>
 
 namespace spdlog {
 namespace details {
-class tcp_client
-{
+class tcp_client {
     int socket_ = -1;
 
 public:
-    bool is_connected() const
-    {
-        return socket_ != -1;
-    }
+    bool is_connected() const { return socket_ != -1; }
 
-    void close()
-    {
-        if (is_connected())
-        {
+    void close() {
+        if (is_connected()) {
             ::close(socket_);
             socket_ = -1;
         }
     }
 
-    int fd() const
-    {
-        return socket_;
-    }
+    int fd() const { return socket_; }
 
-    ~tcp_client()
-    {
-        close();
-    }
+    ~tcp_client() { close(); }
 
     // try to connect or throw on failure
-    void connect(const std::string &host, int port)
-    {
+    void connect(const std::string &host, int port) {
         close();
-        struct addrinfo hints
-        {};
+        struct addrinfo hints {};
         memset(&hints, 0, sizeof(struct addrinfo));
-        hints.ai_family = AF_INET;       // IPv4
-        hints.ai_socktype = SOCK_STREAM; // TCP
-        hints.ai_flags = AI_NUMERICSERV; // port passed as as numeric value
+        hints.ai_family = AF_UNSPEC;      // To work with IPv4, IPv6, and so on
+        hints.ai_socktype = SOCK_STREAM;  // TCP
+        hints.ai_flags = AI_NUMERICSERV;  // port passed as as numeric value
         hints.ai_protocol = 0;
 
         auto port_str = std::to_string(port);
         struct addrinfo *addrinfo_result;
         auto rv = ::getaddrinfo(host.c_str(), port_str.c_str(), &hints, &addrinfo_result);
-        if (rv != 0)
-        {
+        if (rv != 0) {
             throw_spdlog_ex(fmt_lib::format("::getaddrinfo failed: {}", gai_strerror(rv)));
         }
 
         // Try each address until we successfully connect(2).
         int last_errno = 0;
-        for (auto *rp = addrinfo_result; rp != nullptr; rp = rp->ai_next)
-        {
+        for (auto *rp = addrinfo_result; rp != nullptr; rp = rp->ai_next) {
 #if defined(SOCK_CLOEXEC)
             const int flags = SOCK_CLOEXEC;
 #else
             const int flags = 0;
 #endif
             socket_ = ::socket(rp->ai_family, rp->ai_socktype | flags, rp->ai_protocol);
-            if (socket_ == -1)
-            {
+            if (socket_ == -1) {
                 last_errno = errno;
                 continue;
             }
             rv = ::connect(socket_, rp->ai_addr, rp->ai_addrlen);
-            if (rv == 0)
-            {
+            if (rv == 0) {
                 break;
             }
             last_errno = errno;
@@ -95,45 +78,44 @@ public:
             socket_ = -1;
         }
         ::freeaddrinfo(addrinfo_result);
-        if (socket_ == -1)
-        {
+        if (socket_ == -1) {
             throw_spdlog_ex("::connect failed", last_errno);
         }
 
         // set TCP_NODELAY
         int enable_flag = 1;
-        ::setsockopt(socket_, IPPROTO_TCP, TCP_NODELAY, reinterpret_cast<char *>(&enable_flag), sizeof(enable_flag));
+        ::setsockopt(socket_, IPPROTO_TCP, TCP_NODELAY, reinterpret_cast<char *>(&enable_flag),
+                     sizeof(enable_flag));
 
         // prevent sigpipe on systems where MSG_NOSIGNAL is not available
 #if defined(SO_NOSIGPIPE) && !defined(MSG_NOSIGNAL)
-        ::setsockopt(socket_, SOL_SOCKET, SO_NOSIGPIPE, reinterpret_cast<char *>(&enable_flag), sizeof(enable_flag));
+        ::setsockopt(socket_, SOL_SOCKET, SO_NOSIGPIPE, reinterpret_cast<char *>(&enable_flag),
+                     sizeof(enable_flag));
 #endif
 
 #if !defined(SO_NOSIGPIPE) && !defined(MSG_NOSIGNAL)
-#    error "tcp_sink would raise SIGPIPE since niether SO_NOSIGPIPE nor MSG_NOSIGNAL are available"
+    #error "tcp_sink would raise SIGPIPE since neither SO_NOSIGPIPE nor MSG_NOSIGNAL are available"
 #endif
     }
 
     // Send exactly n_bytes of the given data.
     // On error close the connection and throw.
-    void send(const char *data, size_t n_bytes)
-    {
+    void send(const char *data, size_t n_bytes) {
         size_t bytes_sent = 0;
-        while (bytes_sent < n_bytes)
-        {
+        while (bytes_sent < n_bytes) {
 #if defined(MSG_NOSIGNAL)
             const int send_flags = MSG_NOSIGNAL;
 #else
             const int send_flags = 0;
 #endif
-            auto write_result = ::send(socket_, data + bytes_sent, n_bytes - bytes_sent, send_flags);
-            if (write_result < 0)
-            {
+            auto write_result =
+                ::send(socket_, data + bytes_sent, n_bytes - bytes_sent, send_flags);
+            if (write_result < 0) {
                 close();
                 throw_spdlog_ex("write(2) failed", errno);
             }
 
-            if (write_result == 0) // (probably should not happen but in any case..)
+            if (write_result == 0)  // (probably should not happen but in any case..)
             {
                 break;
             }
@@ -141,5 +123,5 @@ public:
         }
     }
 };
-} // namespace details
-} // namespace spdlog
+}  // namespace details
+}  // namespace spdlog

include/spdlog/details/thread_pool-inl.h

@@ -4,26 +4,26 @@
 #pragma once
 
 #ifndef SPDLOG_HEADER_ONLY
-#    include <spdlog/details/thread_pool.h>
+    #include <spdlog/details/thread_pool.h>
 #endif
 
-#include <spdlog/common.h>
 #include <cassert>
+#include <spdlog/common.h>
 
 namespace spdlog {
 namespace details {
 
-SPDLOG_INLINE thread_pool::thread_pool(
-    size_t q_max_items, size_t threads_n, std::function<void()> on_thread_start, std::function<void()> on_thread_stop)
-    : q_(q_max_items)
-{
-    if (threads_n == 0 || threads_n > 1000)
-    {
-        throw_spdlog_ex("spdlog::thread_pool(): invalid threads_n param (valid "
-                        "range is 1-1000)");
+SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items,
+                                       size_t threads_n,
+                                       std::function<void()> on_thread_start,
+                                       std::function<void()> on_thread_stop)
+    : q_(q_max_items) {
+    if (threads_n == 0 || threads_n > 1000) {
+        throw_spdlog_ex(
+            "spdlog::thread_pool(): invalid threads_n param (valid "
+            "range is 1-1000)");
     }
-    for (size_t i = 0; i < threads_n; i++)
-    {
+    for (size_t i = 0; i < threads_n; i++) {
         threads_.emplace_back([this, on_thread_start, on_thread_stop] {
             on_thread_start();
             this->thread_pool::worker_loop_();
@@ -32,110 +32,101 @@ SPDLOG_INLINE thread_pool::thread_pool(
     }
 }
 
-SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items, size_t threads_n, std::function<void()> on_thread_start)
-    : thread_pool(q_max_items, threads_n, on_thread_start, [] {})
-{}
+SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items,
+                                       size_t threads_n,
+                                       std::function<void()> on_thread_start)
+    : thread_pool(q_max_items, threads_n, on_thread_start, [] {}) {}
 
 SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items, size_t threads_n)
     : thread_pool(
-          q_max_items, threads_n, [] {}, [] {})
-{}
+          q_max_items, threads_n, [] {}, [] {}) {}
 
 // message all threads to terminate gracefully join them
-SPDLOG_INLINE thread_pool::~thread_pool()
-{
-    SPDLOG_TRY
-    {
-        for (size_t i = 0; i < threads_.size(); i++)
-        {
+SPDLOG_INLINE thread_pool::~thread_pool() {
+    SPDLOG_TRY {
+        for (size_t i = 0; i < threads_.size(); i++) {
             post_async_msg_(async_msg(async_msg_type::terminate), async_overflow_policy::block);
         }
 
-        for (auto &t : threads_)
-        {
+        for (auto &t : threads_) {
             t.join();
         }
     }
     SPDLOG_CATCH_STD
 }
 
-void SPDLOG_INLINE thread_pool::post_log(async_logger_ptr &&worker_ptr, const details::log_msg &msg, async_overflow_policy overflow_policy)
-{
+void SPDLOG_INLINE thread_pool::post_log(async_logger_ptr &&worker_ptr,
+                                         const details::log_msg &msg,
+                                         async_overflow_policy overflow_policy) {
     async_msg async_m(std::move(worker_ptr), async_msg_type::log, msg);
     post_async_msg_(std::move(async_m), overflow_policy);
 }
 
-void SPDLOG_INLINE thread_pool::post_flush(async_logger_ptr &&worker_ptr, async_overflow_policy overflow_policy)
-{
-    post_async_msg_(async_msg(std::move(worker_ptr), async_msg_type::flush), overflow_policy);
+std::future<void> SPDLOG_INLINE thread_pool::post_flush(async_logger_ptr &&worker_ptr,
+                                                        async_overflow_policy overflow_policy) {
+    std::promise<void> promise;
+    std::future<void> future = promise.get_future();
+    post_async_msg_(async_msg(std::move(worker_ptr), async_msg_type::flush, std::move(promise)),
+                    overflow_policy);
+    return future;
 }
 
-size_t SPDLOG_INLINE thread_pool::overrun_counter()
-{
-    return q_.overrun_counter();
-}
+size_t SPDLOG_INLINE thread_pool::overrun_counter() { return q_.overrun_counter(); }
 
-void SPDLOG_INLINE thread_pool::reset_overrun_counter()
-{
-    q_.reset_overrun_counter();
-}
+void SPDLOG_INLINE thread_pool::reset_overrun_counter() { q_.reset_overrun_counter(); }
 
-size_t SPDLOG_INLINE thread_pool::queue_size()
-{
-    return q_.size();
-}
+size_t SPDLOG_INLINE thread_pool::discard_counter() { return q_.discard_counter(); }
 
-void SPDLOG_INLINE thread_pool::post_async_msg_(async_msg &&new_msg, async_overflow_policy overflow_policy)
-{
-    if (overflow_policy == async_overflow_policy::block)
-    {
+void SPDLOG_INLINE thread_pool::reset_discard_counter() { q_.reset_discard_counter(); }
+
+size_t SPDLOG_INLINE thread_pool::queue_size() { return q_.size(); }
+
+void SPDLOG_INLINE thread_pool::post_async_msg_(async_msg &&new_msg,
+                                                async_overflow_policy overflow_policy) {
+    if (overflow_policy == async_overflow_policy::block) {
         q_.enqueue(std::move(new_msg));
-    }
-    else
-    {
+    } else if (overflow_policy == async_overflow_policy::overrun_oldest) {
         q_.enqueue_nowait(std::move(new_msg));
+    } else {
+        assert(overflow_policy == async_overflow_policy::discard_new);
+        q_.enqueue_if_have_room(std::move(new_msg));
     }
 }
 
-void SPDLOG_INLINE thread_pool::worker_loop_()
-{
-    while (process_next_msg_()) {}
+void SPDLOG_INLINE thread_pool::worker_loop_() {
+    while (process_next_msg_()) {
+    }
 }
 
 // process next message in the queue
 // return true if this thread should still be active (while no terminate msg
 // was received)
-bool SPDLOG_INLINE thread_pool::process_next_msg_()
-{
+bool SPDLOG_INLINE thread_pool::process_next_msg_() {
     async_msg incoming_async_msg;
-    bool dequeued = q_.dequeue_for(incoming_async_msg, std::chrono::seconds(10));
-    if (!dequeued)
-    {
-        return true;
-    }
+    q_.dequeue(incoming_async_msg);
 
-    switch (incoming_async_msg.msg_type)
-    {
-    case async_msg_type::log: {
-        incoming_async_msg.worker_ptr->backend_sink_it_(incoming_async_msg);
-        return true;
-    }
-    case async_msg_type::flush: {
-        incoming_async_msg.worker_ptr->backend_flush_();
-        return true;
-    }
+    switch (incoming_async_msg.msg_type) {
+        case async_msg_type::log: {
+            incoming_async_msg.worker_ptr->backend_sink_it_(incoming_async_msg);
+            return true;
+        }
+        case async_msg_type::flush: {
+            incoming_async_msg.worker_ptr->backend_flush_();
+            incoming_async_msg.flush_promise.set_value();
+            return true;
+        }
 
-    case async_msg_type::terminate: {
-        return false;
-    }
+        case async_msg_type::terminate: {
+            return false;
+        }
 
-    default: {
-        assert(false);
-    }
+        default: {
+            assert(false);
+        }
     }
 
     return true;
 }
 
-} // namespace details
-} // namespace spdlog
+}  // namespace details
+}  // namespace spdlog

include/spdlog/details/thread_pool.h

@@ -8,10 +8,11 @@
 #include <spdlog/details/os.h>
 
 #include <chrono>
+#include <functional>
+#include <future>
 #include <memory>
 #include <thread>
 #include <vector>
-#include <functional>
 
 namespace spdlog {
 class async_logger;
@@ -20,19 +21,14 @@ namespace details {
 
 using async_logger_ptr = std::shared_ptr<spdlog::async_logger>;
 
-enum class async_msg_type
-{
-    log,
-    flush,
-    terminate
-};
+enum class async_msg_type { log, flush, terminate };
 
 // Async msg to move to/from the queue
 // Movable only. should never be copied
-struct async_msg : log_msg_buffer
-{
+struct async_msg : log_msg_buffer {
     async_msg_type msg_type{async_msg_type::log};
     async_logger_ptr worker_ptr;
+    std::promise<void> flush_promise;
 
     async_msg() = default;
     ~async_msg() = default;
@@ -43,48 +39,53 @@ struct async_msg : log_msg_buffer
 // support for vs2013 move
 #if defined(_MSC_VER) && _MSC_VER <= 1800
     async_msg(async_msg &&other)
-        : log_msg_buffer(std::move(other))
-        , msg_type(other.msg_type)
-        , worker_ptr(std::move(other.worker_ptr))
-    {}
+        : log_msg_buffer(std::move(other)),
+          msg_type(other.msg_type),
+          worker_ptr(std::move(other.worker_ptr)) {}
 
-    async_msg &operator=(async_msg &&other)
-    {
+    async_msg &operator=(async_msg &&other) {
         *static_cast<log_msg_buffer *>(this) = std::move(other);
         msg_type = other.msg_type;
         worker_ptr = std::move(other.worker_ptr);
         return *this;
     }
-#else // (_MSC_VER) && _MSC_VER <= 1800
+#else  // (_MSC_VER) && _MSC_VER <= 1800
     async_msg(async_msg &&) = default;
     async_msg &operator=(async_msg &&) = default;
 #endif
 
     // construct from log_msg with given type
     async_msg(async_logger_ptr &&worker, async_msg_type the_type, const details::log_msg &m)
-        : log_msg_buffer{m}
-        , msg_type{the_type}
-        , worker_ptr{std::move(worker)}
-    {}
+        : log_msg_buffer{m},
+          msg_type{the_type},
+          worker_ptr{std::move(worker)},
+          flush_promise{} {}
 
     async_msg(async_logger_ptr &&worker, async_msg_type the_type)
-        : log_msg_buffer{}
-        , msg_type{the_type}
-        , worker_ptr{std::move(worker)}
-    {}
+        : log_msg_buffer{},
+          msg_type{the_type},
+          worker_ptr{std::move(worker)},
+          flush_promise{} {}
+
+    async_msg(async_logger_ptr &&worker, async_msg_type the_type, std::promise<void> &&promise)
+        : log_msg_buffer{},
+          msg_type{the_type},
+          worker_ptr{std::move(worker)},
+          flush_promise{std::move(promise)} {}
 
     explicit async_msg(async_msg_type the_type)
-        : async_msg{nullptr, the_type}
-    {}
+        : async_msg{nullptr, the_type} {}
 };
 
-class SPDLOG_API thread_pool
-{
+class SPDLOG_API thread_pool {
 public:
     using item_type = async_msg;
     using q_type = details::mpmc_blocking_queue<item_type>;
 
-    thread_pool(size_t q_max_items, size_t threads_n, std::function<void()> on_thread_start, std::function<void()> on_thread_stop);
+    thread_pool(size_t q_max_items,
+                size_t threads_n,
+                std::function<void()> on_thread_start,
+                std::function<void()> on_thread_stop);
     thread_pool(size_t q_max_items, size_t threads_n, std::function<void()> on_thread_start);
     thread_pool(size_t q_max_items, size_t threads_n);
 
@@ -94,10 +95,15 @@ public:
     thread_pool(const thread_pool &) = delete;
     thread_pool &operator=(thread_pool &&) = delete;
 
-    void post_log(async_logger_ptr &&worker_ptr, const details::log_msg &msg, async_overflow_policy overflow_policy);
-    void post_flush(async_logger_ptr &&worker_ptr, async_overflow_policy overflow_policy);
+    void post_log(async_logger_ptr &&worker_ptr,
+                  const details::log_msg &msg,
+                  async_overflow_policy overflow_policy);
+    std::future<void> post_flush(async_logger_ptr &&worker_ptr,
+                                 async_overflow_policy overflow_policy);
     size_t overrun_counter();
     void reset_overrun_counter();
+    size_t discard_counter();
+    void reset_discard_counter();
     size_t queue_size();
 
 private:
@@ -114,9 +120,9 @@ private:
     bool process_next_msg_();
 };
 
-} // namespace details
-} // namespace spdlog
+}  // namespace details
+}  // namespace spdlog
 
 #ifdef SPDLOG_HEADER_ONLY
-#    include "thread_pool-inl.h"
+    #include "thread_pool-inl.h"
 #endif

include/spdlog/details/udp_client-windows.h

@@ -9,47 +9,44 @@
 #include <spdlog/common.h>
 #include <spdlog/details/os.h>
 #include <spdlog/details/windows_include.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string>
 #include <winsock2.h>
 #include <ws2tcpip.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <string>
 
-#pragma comment(lib, "Ws2_32.lib")
-#pragma comment(lib, "Mswsock.lib")
-#pragma comment(lib, "AdvApi32.lib")
+#if defined(_MSC_VER)
+    #pragma comment(lib, "Ws2_32.lib")
+    #pragma comment(lib, "Mswsock.lib")
+    #pragma comment(lib, "AdvApi32.lib")
+#endif
 
 namespace spdlog {
 namespace details {
-class udp_client
-{
+class udp_client {
     static constexpr int TX_BUFFER_SIZE = 1024 * 10;
     SOCKET socket_ = INVALID_SOCKET;
-    sockaddr_in addr_ = {0};
+    sockaddr_in addr_ = {};
 
-    static void init_winsock_()
-    {
+    static void init_winsock_() {
         WSADATA wsaData;
         auto rv = ::WSAStartup(MAKEWORD(2, 2), &wsaData);
-        if (rv != 0)
-        {
+        if (rv != 0) {
             throw_winsock_error_("WSAStartup failed", ::WSAGetLastError());
         }
     }
 
-    static void throw_winsock_error_(const std::string &msg, int last_error)
-    {
+    static void throw_winsock_error_(const std::string &msg, int last_error) {
         char buf[512];
-        ::FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, last_error,
-            MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), buf, (sizeof(buf) / sizeof(char)), NULL);
+        ::FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL,
+                         last_error, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), buf,
+                         (sizeof(buf) / sizeof(char)), NULL);
 
         throw_spdlog_ex(fmt_lib::format("udp_sink - {}: {}", msg, buf));
     }
 
-    void cleanup_()
-    {
-        if (socket_ != INVALID_SOCKET)
-        {
+    void cleanup_() {
+        if (socket_ != INVALID_SOCKET) {
             ::closesocket(socket_);
         }
         socket_ = INVALID_SOCKET;
@@ -57,55 +54,45 @@ class udp_client
     }
 
 public:
-    udp_client(const std::string &host, uint16_t port)
-    {
+    udp_client(const std::string &host, uint16_t port) {
         init_winsock_();
 
         addr_.sin_family = PF_INET;
         addr_.sin_port = htons(port);
         addr_.sin_addr.s_addr = INADDR_ANY;
-        if (InetPtonA(PF_INET, host.c_str(), &addr_.sin_addr.s_addr) != 1)
-        {
+        if (InetPtonA(PF_INET, host.c_str(), &addr_.sin_addr.s_addr) != 1) {
             int last_error = ::WSAGetLastError();
             ::WSACleanup();
             throw_winsock_error_("error: Invalid address!", last_error);
         }
 
         socket_ = ::socket(PF_INET, SOCK_DGRAM, 0);
-        if (socket_ == INVALID_SOCKET)
-        {
+        if (socket_ == INVALID_SOCKET) {
             int last_error = ::WSAGetLastError();
             ::WSACleanup();
             throw_winsock_error_("error: Create Socket failed", last_error);
         }
 
         int option_value = TX_BUFFER_SIZE;
-        if (::setsockopt(socket_, SOL_SOCKET, SO_SNDBUF, reinterpret_cast<const char *>(&option_value), sizeof(option_value)) < 0)
-        {
+        if (::setsockopt(socket_, SOL_SOCKET, SO_SNDBUF,
+                         reinterpret_cast<const char *>(&option_value), sizeof(option_value)) < 0) {
             int last_error = ::WSAGetLastError();
             cleanup_();
             throw_winsock_error_("error: setsockopt(SO_SNDBUF) Failed!", last_error);
         }
     }
 
-    ~udp_client()
-    {
-        cleanup_();
-    }
+    ~udp_client() { cleanup_(); }
 
-    SOCKET fd() const
-    {
-        return socket_;
-    }
+    SOCKET fd() const { return socket_; }
 
-    void send(const char *data, size_t n_bytes)
-    {
+    void send(const char *data, size_t n_bytes) {
         socklen_t tolen = sizeof(struct sockaddr);
-        if (::sendto(socket_, data, static_cast<int>(n_bytes), 0, (struct sockaddr *)&addr_, tolen) == -1)
-        {
+        if (::sendto(socket_, data, static_cast<int>(n_bytes), 0, (struct sockaddr *)&addr_,
+                     tolen) == -1) {
             throw_spdlog_ex("sendto(2) failed", errno);
         }
     }
 };
-} // namespace details
-} // namespace spdlog
+}  // namespace details
+}  // namespace spdlog

include/spdlog/details/udp_client.h

@@ -7,51 +7,46 @@
 // Will throw on construction if the socket creation failed.
 
 #ifdef _WIN32
-#    error "include udp_client-windows.h instead"
+    #error "include udp_client-windows.h instead"
 #endif
 
+#include <arpa/inet.h>
+#include <cstring>
+#include <netdb.h>
+#include <netinet/in.h>
+#include <netinet/udp.h>
 #include <spdlog/common.h>
 #include <spdlog/details/os.h>
-
 #include <sys/socket.h>
-#include <netinet/in.h>
-#include <arpa/inet.h>
 #include <unistd.h>
-#include <netdb.h>
-#include <netinet/udp.h>
 
 #include <string>
 
 namespace spdlog {
 namespace details {
 
-class udp_client
-{
+class udp_client {
     static constexpr int TX_BUFFER_SIZE = 1024 * 10;
     int socket_ = -1;
     struct sockaddr_in sockAddr_;
 
-    void cleanup_()
-    {
-        if (socket_ != -1)
-        {
+    void cleanup_() {
+        if (socket_ != -1) {
             ::close(socket_);
             socket_ = -1;
         }
     }
 
 public:
-    udp_client(const std::string &host, uint16_t port)
-    {
+    udp_client(const std::string &host, uint16_t port) {
         socket_ = ::socket(PF_INET, SOCK_DGRAM, 0);
-        if (socket_ < 0)
-        {
+        if (socket_ < 0) {
             throw_spdlog_ex("error: Create Socket Failed!");
         }
 
         int option_value = TX_BUFFER_SIZE;
-        if (::setsockopt(socket_, SOL_SOCKET, SO_SNDBUF, reinterpret_cast<const char *>(&option_value), sizeof(option_value)) < 0)
-        {
+        if (::setsockopt(socket_, SOL_SOCKET, SO_SNDBUF,
+                         reinterpret_cast<const char *>(&option_value), sizeof(option_value)) < 0) {
             cleanup_();
             throw_spdlog_ex("error: setsockopt(SO_SNDBUF) Failed!");
         }
@@ -59,8 +54,7 @@ public:
         sockAddr_.sin_family = AF_INET;
         sockAddr_.sin_port = htons(port);
 
-        if (::inet_aton(host.c_str(), &sockAddr_.sin_addr) == 0)
-        {
+        if (::inet_aton(host.c_str(), &sockAddr_.sin_addr) == 0) {
             cleanup_();
             throw_spdlog_ex("error: Invalid address!");
         }
@@ -68,27 +62,20 @@ public:
         ::memset(sockAddr_.sin_zero, 0x00, sizeof(sockAddr_.sin_zero));
     }
 
-    ~udp_client()
-    {
-        cleanup_();
-    }
+    ~udp_client() { cleanup_(); }
 
-    int fd() const
-    {
-        return socket_;
-    }
+    int fd() const { return socket_; }
 
     // Send exactly n_bytes of the given data.
     // On error close the connection and throw.
-    void send(const char *data, size_t n_bytes)
-    {
+    void send(const char *data, size_t n_bytes) {
         ssize_t toslen = 0;
         socklen_t tolen = sizeof(struct sockaddr);
-        if ((toslen = ::sendto(socket_, data, n_bytes, 0, (struct sockaddr *)&sockAddr_, tolen)) == -1)
-        {
+        if ((toslen = ::sendto(socket_, data, n_bytes, 0, (struct sockaddr *)&sockAddr_, tolen)) ==
+            -1) {
             throw_spdlog_ex("sendto(2) failed", errno);
         }
     }
 };
-} // namespace details
-} // namespace spdlog
+}  // namespace details
+}  // namespace spdlog

include/spdlog/details/windows_include.h

@@ -1,11 +1,11 @@
 #pragma once
 
 #ifndef NOMINMAX
-#    define NOMINMAX // prevent windows redefining min/max
+    #define NOMINMAX  // prevent windows redefining min/max
 #endif
 
 #ifndef WIN32_LEAN_AND_MEAN
-#    define WIN32_LEAN_AND_MEAN
+    #define WIN32_LEAN_AND_MEAN
 #endif
 
 #include <windows.h>