.gitignore

 # Prerequisites
 build/*
+cmake-build-*/
 build_stretch/*
 test/build
 *.txt.user
@@ -67,4 +68,9 @@ Makefile
 cmake_install.cmake
 
 # Editor's temp files
-*~
\ No newline at end of file
+*~
+.idea/
+
+# OS files
+.DS_Store
+

.gitlab-ci.yml

+variables:
+    GIT_SUBMODULE_STRATEGY: recursive
+
 stages:
-    - prepare
-    - analyze
     - build
-    - test
+    - deploy
 
-variables:
-    GIT_SUBMODULE_STRATEGY: normal
-
-cellframe-sdk-analyze:
-    stage: analyze
-    tags:
-    - cellframe-sdk
-    script: ~/production/integration/PVS-studio/analyze.sh 
-    artifacts:
-      paths:
-      - report/issues.txt
-      when: always
+.ci-polygon:
+  tags:
+     - ci-polygon
+  
+.tests:  
+  extends: .ci-polygon
+  stage: build
+  timeout: 3 hours 30 minutes
+  dependencies: []
+  
+  
+tests:amd64.gcc:
+    extends: .tests
+    image: demlabs/debian/amd64:qt5
+    before_script: /opt/buildtools/prepare_environment.sh amd64-linux
+    script:
+      - mkdir build
+      - cd build && cmake .. -DCMAKE_BUILD_TYPE=Release -DBUILD_CELLFRAME_SDK_TESTS=ON -DOFF_CORE_CELLFRAME_SDK_TESTS_OFF=network-monitor -DOFF_CRYPTO_CELLFRAME_SDK_TESTS_OFF="multisign" && make -j$(nproc) && ctest --verbose
+
+
+tests:amd64.clang:
+    extends: .tests
+    image: demlabs/debian/amd64:qt5
+    before_script: /opt/buildtools/prepare_environment.sh amd64-linux
+    script:
+      - mkdir build
+      - cd build && cmake .. -DCMAKE_C_COMPILER=clang -DCMAKE_BUILD_TYPE=Release -DBUILD_CELLFRAME_SDK_TESTS=ON -DOFF_CORE_CELLFRAME_SDK_TESTS_OFF=network-monitor -DOFF_CRYPTO_CELLFRAME_SDK_TESTS_OFF="multisign" && make -j$(nproc) && ctest --verbose
+
+
+tests:arm64.gcc:
+    extends: .tests
+    image: demlabs/debian/arm64:qt5
+    before_script: /opt/buildtools/prepare_environment.sh arm64-linux
+    script:
+      - mkdir build
+      - cd build && cmake .. -DCMAKE_BUILD_TYPE=Release -DBUILD_CELLFRAME_SDK_TESTS=ON -DOFF_CORE_CELLFRAME_SDK_TESTS_OFF=network-monitor -DOFF_CRYPTO_CELLFRAME_SDK_TESTS_OFF="multisign" && make -j$(nproc) && ctest --verbose
+
+tests:arm64.clang:
+    extends: .tests
+    image: demlabs/debian/arm64:qt5
+    before_script: /opt/buildtools/prepare_environment.sh arm64-linux
+    script:
+      - mkdir build
+      - cd build && cmake .. -DCMAKE_C_COMPILER=clang -DCMAKE_BUILD_TYPE=Release -DBUILD_CELLFRAME_SDK_TESTS=ON -DOFF_CORE_CELLFRAME_SDK_TESTS_OFF=network-monitor -DOFF_CRYPTO_CELLFRAME_SDK_TESTS_OFF="multisign" && make -j$(nproc) && ctest --verbose
+
+tests:arm32.gcc:
+    extends: .tests
+    image: demlabs/debian/arm32:qt5
+    before_script: /opt/buildtools/prepare_environment.sh arm32v7-linux
+    script:
+      - mkdir build
+      - cd build && cmake .. -DCMAKE_BUILD_TYPE=Release -DBUILD_CELLFRAME_SDK_TESTS=ON -DOFF_CORE_CELLFRAME_SDK_TESTS_OFF=network-monitor -DOFF_CRYPTO_CELLFRAME_SDK_TESTS_OFF="multisign" && make -j$(nproc) && ctest --verbose
+
+tests:arm32.clang:
+    extends: .tests
+    image: demlabs/debian/arm32:qt5
+    before_script: /opt/buildtools/prepare_environment.sh arm32v7-linux
+    script:
+      - mkdir build
+      - cd build && cmake .. -DCMAKE_C_COMPILER=clang -DCMAKE_BUILD_TYPE=Release -DBUILD_CELLFRAME_SDK_TESTS=ON -DOFF_CORE_CELLFRAME_SDK_TESTS_OFF=network-monitor -DOFF_CRYPTO_CELLFRAME_SDK_TESTS_OFF="multisign" && make -j$(nproc) && ctest --verbose
+
+build:windows:
+    extends: .tests
+    image: demlabs/windows/amd64:qt5
+    before_script: /opt/buildtools/prepare_environment.sh amd64-windows
+    script:
+      - mkdir build
+      - cd build && export PATH=${MXE_ROOT}/usr/bin:$PATH && x86_64-w64-mingw32.static-cmake .. -DCMAKE_BUILD_TYPE=Release && make -j$(nproc)
+    
+
+build:macos:
+    extends: .tests
+    image: demlabs/macos/amd64:qt5
+    before_script: /opt/buildtools/prepare_environment.sh amd64-windows
+    script:
+      - mkdir build
+      - cd build && $(${OSXCROSS_ROOT}/bin/osxcross-conf) && export OSXCROSS_NO_INCLUDE_PATH_WARNINGS=1 && export OSXCROSS_HOST=x86_64-apple-darwin20.4 && cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_TOOLCHAIN_FILE=${OSXCROSS_ROOT}/toolchain.cmake -DBoost_INCLUDE_DIR=$BOOST_INCLUDE_DIR .. && make -j$(nproc)
+
+
+build:android:
+    extends: .tests
+    image: demlabs/android/any:qt5
+    before_script: /opt/buildtools/prepare_environment.sh amd64-windows
+    script:
+      - ./prod_build/build.sh --target android

.gitmodules

+[submodule "dap-sdk"]
+	path = dap-sdk
+	url = ../../dap/dap-sdk.git
+	branch = develop

3rdparty/crc32c_adler/README

+
+Extended version of CRC32C implementation by Mark Adler, providing both hardware (SSE 4.2) and software algorithms with auto-detection.
+
+Source:
+https://stackoverflow.com/a/17646775
+
+According to Ferry Toth, Adler's implementation is 'highly optimized':
+https://stackoverflow.com/a/39862799
+https://github.com/htot/crc32c
+
+Revised software algorithm by Robert Važan:
+https://stackoverflow.com/a/21915223
+https://crc32c.machinezoo.com/
+https://bitbucket.org/robertvazan/crc32c-hw/src

3rdparty/crc32c_adler/crc32c_adler.c

+/*
+  CRC32C_ADLER -- Computes CRC32C Checksums
+  Version 1.2, Date 05/21/18
+  Copyright (C) 2013 Mark Adler <madler@alumni.caltech.edu>
+  Copyright (C) 2018 Fonic <https://github.com/fonic>
+
+  Provides both a hardware-accelerated algorithm (*) and a software algorithm.
+  Note that this computes CRC32C checksums, not CRC32 (without 'C') checksums
+  used by Ethernet, gzip, etc.
+
+  (*) CRC instruction on Intel SSE 4.2 processors.  SSE 4.2 was first supported
+      by Nehalem processors introduced in November, 2008.
+
+  Version history:
+  1.0  10 Feb 2013  First version
+  1.1   1 Aug 2013  Correct comments on why three crc instructions in parallel
+  1.2  21 May 2018  Add header file, revise hardware support check, eliminate
+                    pthreads, restructure code, revise comments and description
+
+  Version 1.1 by Mark Adler was originally published here:
+  https://stackoverflow.com/a/17646775
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the author be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software.  If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include "crc32c_adler.h"
+
+/* CRC32C (iSCSI) polynomial in reversed bit order. */
+#define POLY 0x82f63b78
+
+
+/******************************************************************************
+ *                                                                            *
+ *  Software Algorithm (1) - Table-driven, 8 Bytes / Iteration                *
+ *                                                                            *
+ ******************************************************************************/
+
+/* Table for software algorithm. */
+static uint32_t crc32c_table[8][256];
+
+/* Flag to indicate if crc32c_init_sw() has been called. */
+static int crc32c_sw_initialized = 0;
+
+/* Initialize table for software algorithm. */
+static void crc32c_init_sw(void)
+{
+    uint32_t n, crc, k;
+
+    for (n = 0; n < 256; n++) {
+        crc = n;
+        crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1;
+        crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1;
+        crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1;
+        crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1;
+        crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1;
+        crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1;
+        crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1;
+        crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1;
+        crc32c_table[0][n] = crc;
+    }
+    for (n = 0; n < 256; n++) {
+        crc = crc32c_table[0][n];
+        for (k = 1; k < 8; k++) {
+            crc = crc32c_table[0][crc & 0xff] ^ (crc >> 8);
+            crc32c_table[k][n] = crc;
+        }
+    }
+    crc32c_sw_initialized = 1;
+}
+
+/* Compute CRC32C checksum. */
+uint32_t crc32c_sw(uint32_t crci, const void *buf, size_t len)
+{
+    const unsigned char *next = buf;
+    uint64_t crc;
+
+    if (!crc32c_sw_initialized)
+        crc32c_init_sw();
+
+    crc = crci ^ 0xffffffff;
+    while (len && ((uintptr_t)next & 7) != 0) {
+        crc = crc32c_table[0][(crc ^ *next++) & 0xff] ^ (crc >> 8);
+        len--;
+    }
+    while (len >= 8) {
+        crc ^= *(uint64_t *)next;
+        crc = crc32c_table[7][crc & 0xff] ^
+              crc32c_table[6][(crc >> 8) & 0xff] ^
+              crc32c_table[5][(crc >> 16) & 0xff] ^
+              crc32c_table[4][(crc >> 24) & 0xff] ^
+              crc32c_table[3][(crc >> 32) & 0xff] ^
+              crc32c_table[2][(crc >> 40) & 0xff] ^
+              crc32c_table[1][(crc >> 48) & 0xff] ^
+              crc32c_table[0][crc >> 56];
+        next += 8;
+        len -= 8;
+    }
+    while (len) {
+        crc = crc32c_table[0][(crc ^ *next++) & 0xff] ^ (crc >> 8);
+        len--;
+    }
+    return (uint32_t)crc ^ 0xffffffff;
+}
+
+
+/******************************************************************************
+ *                                                                            *
+ *  Software Algorithm (2) - Table-driven, 16 Bytes / Iteration               *
+ *                                                                            *
+ ******************************************************************************/
+
+/* Table for software algorithm. */
+static uint32_t crc32c_table2[16][256];
+
+/* Flag to indicate if crc32c_init_sw2() has been called. */
+static int crc32c_table2_initialized = 0;
+
+/* Initialize table for software algorithm. */
+static void crc32c_init_sw2(void)
+{
+    for(int i = 0; i < 256; i++)
+    {
+        uint32_t res = (uint32_t)i;
+        for(int t = 0; t < 16; t++) {
+            for (int k = 0; k < 8; k++) res = (res & 1) == 1 ? POLY ^ (res >> 1) : (res >> 1);
+            crc32c_table2[t][i] = res;
+        }
+    }
+    crc32c_table2_initialized = 1;
+}
+
+/* Compute CRC32C checksum. */
+uint32_t crc32c_sw2(uint32_t crci, const void *buf, size_t len)
+{
+    const unsigned char *next = buf;
+#ifdef __x86_64__
+    uint64_t crc;
+#else
+    uint32_t crc;
+#endif
+
+    if(!crc32c_table2_initialized)
+        crc32c_init_sw2();
+
+    crc = crci ^ 0xffffffff;
+#ifdef __x86_64__
+    while (len && ((uintptr_t)next & 7) != 0)
+    {
+        crc = crc32c_table2[0][(crc ^ *next++) & 0xff] ^ (crc >> 8);
+        --len;
+    }
+    while (len >= 16)
+    {
+        crc ^= *(uint64_t *)next;
+        uint64_t high = *(uint64_t *)(next + 8);
+        crc = crc32c_table2[15][crc & 0xff]
+            ^ crc32c_table2[14][(crc >> 8) & 0xff]
+            ^ crc32c_table2[13][(crc >> 16) & 0xff]
+            ^ crc32c_table2[12][(crc >> 24) & 0xff]
+            ^ crc32c_table2[11][(crc >> 32) & 0xff]
+            ^ crc32c_table2[10][(crc >> 40) & 0xff]
+            ^ crc32c_table2[9][(crc >> 48) & 0xff]
+            ^ crc32c_table2[8][crc >> 56]
+            ^ crc32c_table2[7][high & 0xff]
+            ^ crc32c_table2[6][(high >> 8) & 0xff]
+            ^ crc32c_table2[5][(high >> 16) & 0xff]
+            ^ crc32c_table2[4][(high >> 24) & 0xff]
+            ^ crc32c_table2[3][(high >> 32) & 0xff]
+            ^ crc32c_table2[2][(high >> 40) & 0xff]
+            ^ crc32c_table2[1][(high >> 48) & 0xff]
+            ^ crc32c_table2[0][high >> 56];
+        next += 16;
+        len -= 16;
+    }
+#else
+    while (len && ((uintptr_t)next & 3) != 0)
+    {
+        crc = crc32c_table2[0][(crc ^ *next++) & 0xff] ^ (crc >> 8);
+        --len;
+    }
+    while (len >= 12)
+    {
+        crc ^= *(uint32_t *)next;
+        uint32_t high = *(uint32_t *)(next + 4);
+        uint32_t high2 = *(uint32_t *)(next + 8);
+        crc = crc32c_table2[11][crc & 0xff]
+            ^ crc32c_table2[10][(crc >> 8) & 0xff]
+            ^ crc32c_table2[9][(crc >> 16) & 0xff]
+            ^ crc32c_table2[8][crc >> 24]
+            ^ crc32c_table2[7][high & 0xff]
+            ^ crc32c_table2[6][(high >> 8) & 0xff]
+            ^ crc32c_table2[5][(high >> 16) & 0xff]
+            ^ crc32c_table2[4][high >> 24]
+            ^ crc32c_table2[3][high2 & 0xff]
+            ^ crc32c_table2[2][(high2 >> 8) & 0xff]
+            ^ crc32c_table2[1][(high2 >> 16) & 0xff]
+            ^ crc32c_table2[0][high2 >> 24];
+        next += 12;
+        len -= 12;
+    }
+#endif
+    while (len)
+    {
+        crc = crc32c_table2[0][(crc ^ *next++) & 0xff] ^ (crc >> 8);
+        --len;
+    }
+    return (uint32_t)crc ^ 0xffffffff;
+}
+
+
+/******************************************************************************
+ *                                                                            *
+ *  Hardware Algorithm - SSE 4.2                                              *
+ *                                                                            *
+ ******************************************************************************/
+
+/* Multiply a matrix times a vector over the Galois field of two elements,
+   GF(2).  Each element is a bit in an unsigned integer.  mat must have at
+   least as many entries as the power of two for most significant one bit in
+   vec. */
+static inline uint32_t gf2_matrix_times(uint32_t *mat, uint32_t vec)
+{
+    uint32_t sum;
+
+    sum = 0;
+    while (vec) {
+        if (vec & 1)
+            sum ^= *mat;
+        vec >>= 1;
+        mat++;
+    }
+    return sum;
+}
+
+/* Multiply a matrix by itself over GF(2).  Both mat and square must have 32
+   rows. */
+static inline void gf2_matrix_square(uint32_t *square, uint32_t *mat)
+{
+    int n;
+
+    for (n = 0; n < 32; n++)
+        square[n] = gf2_matrix_times(mat, mat[n]);
+}
+
+/* Construct an operator to apply len zeros to a crc.  len must be a power of
+   two.  If len is not a power of two, then the result is the same as for the
+   largest power of two less than len.  The result for len == 0 is the same as
+   for len == 1.  A variant of this routine could be easily written for any
+   len, but that is not needed for this application. */
+static void crc32c_zeros_op(uint32_t *even, size_t len)
+{
+    int n;
+    uint32_t row;
+    uint32_t odd[32];           /* odd-power-of-two zeros operator */
+
+    /* Put operator for one zero bit in odd. */
+    odd[0] = POLY;              /* CRC32C polynomial */
+    row = 1;
+    for (n = 1; n < 32; n++) {
+        odd[n] = row;
+        row <<= 1;
+    }
+
+    /* Put operator for two zero bits in even. */
+    gf2_matrix_square(even, odd);
+
+    /* Put operator for four zero bits in odd. */
+    gf2_matrix_square(odd, even);
+
+    /* First square will put the operator for one zero byte (eight zero bits),
+       in even -- next square puts operator for two zero bytes in odd, and so
+       on, until len has been rotated down to zero. */
+    do {
+        gf2_matrix_square(even, odd);
+        len >>= 1;
+        if (len == 0)
+            return;
+        gf2_matrix_square(odd, even);
+        len >>= 1;
+    } while (len);
+
+    /* Answer ended up in odd -- copy to even. */
+    for (n = 0; n < 32; n++)
+        even[n] = odd[n];
+}
+
+/* Take a length and build four lookup tables for applying the zeros operator
+   for that length, byte-by-byte on the operand. */
+static void crc32c_zeros(uint32_t zeros[][256], size_t len)
+{
+    uint32_t n;
+    uint32_t op[32];
+
+    crc32c_zeros_op(op, len);
+    for (n = 0; n < 256; n++) {
+        zeros[0][n] = gf2_matrix_times(op, n);
+        zeros[1][n] = gf2_matrix_times(op, n << 8);
+        zeros[2][n] = gf2_matrix_times(op, n << 16);
+        zeros[3][n] = gf2_matrix_times(op, n << 24);
+    }
+}
+
+/* Apply the zeros operator table to crc. */
+static inline uint32_t crc32c_shift(uint32_t zeros[][256], uint32_t crc)
+{
+    return zeros[0][crc & 0xff] ^ zeros[1][(crc >> 8) & 0xff] ^
+           zeros[2][(crc >> 16) & 0xff] ^ zeros[3][crc >> 24];
+}
+
+/* Block sizes for three-way parallel crc computation.  LONG and SHORT must
+   both be powers of two.  The associated string constants must be set
+   accordingly, for use in constructing the assembler instructions. */
+#define LONG 8192
+#define LONGx1 "8192"
+#define LONGx2 "16384"
+#define SHORT 256
+#define SHORTx1 "256"
+#define SHORTx2 "512"
+
+/* Tables for hardware algorithm that shift a crc by LONG and SHORT zeros. */
+static uint32_t crc32c_long[4][256];
+static uint32_t crc32c_short[4][256];
+
+/* Flag to indicate if crc32c_init_hw() has been called. */
+static int crc32c_hw_initialized = 0;
+
+
+
+
+#if defined(__x86_64__)                 /* @RRL: to compile for ARM */
+
+
+
+static void crc32c_init_hw(void)
+{
+    crc32c_zeros(crc32c_long, LONG);
+    crc32c_zeros(crc32c_short, SHORT);
+    crc32c_hw_initialized = 1;
+}
+
+/* Compute CRC32C checksum. */
+uint32_t crc32c_hw(uint32_t crc, const void *buf, size_t len)
+{
+    const unsigned char *next = buf;
+    const unsigned char *end;
+    uint64_t crc0, crc1, crc2;      /* need to be 64 bits for crc32q */
+
+    /* Populate shift tables the first time through. */
+    if (!crc32c_hw_initialized)
+        crc32c_init_hw();
+
+    /* Pre-process the crc. */
+    crc0 = crc ^ 0xffffffff;
+
+    /* Compute the crc for up to seven leading bytes to bring the data pointer
+       to an eight-byte boundary. */
+    while (len && ((uintptr_t)next & 7) != 0) {
+        __asm__("crc32b\t" "(%1), %0"
+                : "=r"(crc0)
+                : "r"(next), "0"(crc0));
+        next++;
+        len--;
+    }
+
+    /* Compute the crc on sets of LONG*3 bytes, executing three independent crc
+       instructions, each on LONG bytes -- this is optimized for the Nehalem,
+       Westmere, Sandy Bridge, and Ivy Bridge architectures, which have a
+       throughput of one crc per cycle, but a latency of three cycles. */
+    while (len >= LONG*3) {
+        crc1 = 0;
+        crc2 = 0;
+        end = next + LONG;
+        do {
+            __asm__("crc32q\t" "(%3), %0\n\t"
+                    "crc32q\t" LONGx1 "(%3), %1\n\t"
+                    "crc32q\t" LONGx2 "(%3), %2"
+                    : "=r"(crc0), "=r"(crc1), "=r"(crc2)
+                    : "r"(next), "0"(crc0), "1"(crc1), "2"(crc2));
+            next += 8;
+        } while (next < end);
+        crc0 = crc32c_shift(crc32c_long, crc0) ^ crc1;
+        crc0 = crc32c_shift(crc32c_long, crc0) ^ crc2;
+        next += LONG*2;
+        len -= LONG*3;
+    }
+
+    /* Do the same thing, but now on SHORT*3 blocks for the remaining data less
+       than a LONG*3 block. */
+    while (len >= SHORT*3) {
+        crc1 = 0;
+        crc2 = 0;
+        end = next + SHORT;
+        do {
+            __asm__("crc32q\t" "(%3), %0\n\t"
+                    "crc32q\t" SHORTx1 "(%3), %1\n\t"
+                    "crc32q\t" SHORTx2 "(%3), %2"
+                    : "=r"(crc0), "=r"(crc1), "=r"(crc2)
+                    : "r"(next), "0"(crc0), "1"(crc1), "2"(crc2));
+            next += 8;
+        } while (next < end);
+        crc0 = crc32c_shift(crc32c_short, crc0) ^ crc1;
+        crc0 = crc32c_shift(crc32c_short, crc0) ^ crc2;
+        next += SHORT*2;
+        len -= SHORT*3;
+    }
+
+    /* Compute the crc on the remaining eight-byte units less than a SHORT*3
+       block. */
+    end = next + (len - (len & 7));
+    while (next < end) {
+        __asm__("crc32q\t" "(%1), %0"
+                : "=r"(crc0)
+                : "r"(next), "0"(crc0));
+        next += 8;
+    }
+    len &= 7;
+
+    /* Compute the crc for up to seven trailing bytes. */
+    while (len) {
+        __asm__("crc32b\t" "(%1), %0"
+                : "=r"(crc0)
+                : "r"(next), "0"(crc0));
+        next++;
+        len--;
+    }
+
+    /* Return a post-processed crc. */
+    return (uint32_t)crc0 ^ 0xffffffff;
+}
+
+
+
+#endif /* @RRL: to compile for ARM */
+
+/******************************************************************************
+ *                                                                            *
+ *  Other Functions                                                           *
+ *                                                                            *
+ ******************************************************************************/
+
+/* Variables to store information on hardware support. */
+static int crc32c_hardware_support = 0;
+static int crc32c_hardware_checked = 0;
+
+/* Check for hardware support (SSE 4.2).  Note that this does not check for
+   the existence of the cpuid instruction itself, which was introduced on the
+   486SL in 1992, so this will fail on earlier x86 processors.  cpuid works
+   on all Pentium and later processors. */
+int crc32c_hw_support()
+{
+#if defined(__x86_64__)                 /* @RRL: to compile for ARM */
+    if (!crc32c_hardware_checked) {
+        do {
+            uint32_t eax, ecx;
+            eax = 1;
+            __asm__("cpuid"
+                    : "=c"(ecx)
+                    : "a"(eax)
+                    : "%ebx", "%edx");
+            (crc32c_hardware_support) = (ecx >> 20) & 1;
+        } while (0);
+        crc32c_hardware_checked = 1;
+    }
+    return crc32c_hardware_support;
+#else
+    return  0;
+#endif
+
+}
+
+/* Disable hardware algorithm even if supported by hardware. */
+void crc32c_hw_disable()
+{
+    crc32c_hardware_support = 0;
+    crc32c_hardware_checked = 1;
+}
+
+/* Compute CRC32C checksum. Use hardware algorithm if supported,
+   fall back on software algorithm otherwise. */
+uint32_t crc32c(uint32_t crc, const void *buf, size_t len)
+{
+#if defined(__x86_64__)                 /* @RRL: to compile for ARM */
+    return crc32c_hw_support() ? crc32c_hw(crc, buf, len) : crc32c_sw(crc, buf, len);
+#else
+    return crc32c_sw(crc, buf, len);
+#endif
+}

3rdparty/crc32c_adler/crc32c_adler.h

+/*
+  CRC32C_ADLER -- Computes CRC32C Checksums
+  Version 1.2, Date 05/21/18
+  Copyright (C) 2013 Mark Adler <madler@alumni.caltech.edu>
+  Copyright (C) 2018 Fonic <https://github.com/fonic>
+
+  Provides both a hardware-accelerated algorithm (*) and a software algorithm.
+  Note that this computes CRC32C checksums, not CRC32 (without 'C') checksums
+  used by Ethernet, gzip, etc.
+
+  (*) CRC instruction on Intel SSE 4.2 processors.  SSE 4.2 was first supported
+      by Nehalem processors introduced in November, 2008.
+
+  Version history:
+  1.0  10 Feb 2013  First version
+  1.1   1 Aug 2013  Correct comments on why three crc instructions in parallel
+  1.2  21 May 2018  Add header file, revise hardware support check, eliminate
+                    pthreads, restructure code, revise comments and description
+
+  Version 1.1 by Mark Adler was originally published here:
+  https://stackoverflow.com/a/17646775
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the author be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software.  If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#ifndef CRC32C_ADLER_H
+#define CRC32C_ADLER_H
+
+#include <stdint.h>
+
+#define CRC32C_INIT 0xEDB88320
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+/* Compute CRC32C checksum using software algorithm (1). */
+uint32_t crc32c_sw(uint32_t crci, const void *buf, size_t len);
+
+/* Compute CRC32C checksum using software algorithm (2). */
+uint32_t crc32c_sw2(uint32_t crci, const void *buf, size_t len);
+
+/* Compute CRC32C checksum using hardware algorithm. */
+uint32_t crc32c_hw(uint32_t crc, const void *buf, size_t len);
+
+/* Check if hardware-support (i.e. SSE 4.2) is available. */
+int crc32c_hw_support();
+
+/* Disable hardware algorithm even if supported by hardware. */
+void crc32c_hw_disable();
+
+/* Compute CRC32C checksum. Use hardware algorithm if supported,
+   fall back on software algorithm otherwise. */
+uint32_t crc32c(uint32_t crc, const void *buf, size_t len);
+
+#if defined(__cplusplus)
+}
+#endif
+#endif // CRC32C_ADLER_H

3rdparty/crc32c_adler/example-dht.c

+/*
+  TODO describe example
+*/
+#define _GNU_SOURCE     /* random, srandom*/
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <unistd.h>
+#include <fcntl.h>      /* open, close etc. */
+#include <string.h>     /* memcpy */
+#include <netinet/in.h> /* AF_INET, INET_ADDRSTRLEN etc. */
+#include <arpa/inet.h>  /* inet_ntop */
+
+#include "crc32c_adler.h"
+
+/* Convert id to hex string of formate used in BEP 42. */
+char id_hex_str[20*2+2+1]; /* 20 bytes x 2 characters + 2 x ' ' + '\0' */
+const char*
+id_to_hex(const unsigned char *id)
+{
+    //const char* hex_chr = "0123456789ABCDEF";
+    const char* hex_chr = "0123456789abcdef";
+    for(int i=0,j=0; i < 20 && j < sizeof(id_hex_str)-2; i++) {
+        id_hex_str[j++] = hex_chr[ (id[i]>>4) & 0x0F ];
+        id_hex_str[j++] = hex_chr[  id[i]     & 0x0F ];
+        if (i == 2 || i == 18) {
+            id_hex_str[j++] = ' ';
+        }
+    }
+    id_hex_str[sizeof(id_hex_str)-1] = '\0';
+    return id_hex_str;
+}
+
+/* Generate node ID from IP address + predefined rand using example algorithm
+   provided in BEP 42.
+
+   Parameters:
+   ip       IPv4 or IPv6 address (network byte order)
+   iplen    number of octets to consider in ip (4 or 8)
+   id       resulting node ID
+   rand     predefined random value */
+void crc32c_id(const uint8_t* ip, int iplen, uint8_t id[20], uint32_t rand)
+{
+    uint8_t v4_mask[] = { 0x03, 0x0f, 0x3f, 0xff };
+    uint8_t v6_mask[] = { 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff };
+    uint8_t* mask = iplen == 4 ? v4_mask : v6_mask;
+
+    uint8_t ip_copy[8];
+    memcpy(ip_copy, ip, iplen);
+
+    for (int i = 0; i < iplen; ++i)
+            ip_copy[i] &= mask[i];
+
+    //uint32_t rand = random() & 0xff;
+    uint8_t r = rand & 0x7;
+    ip_copy[0] |= r << 5;
+
+    uint32_t crc = 0;
+    crc = crc32c(crc, ip_copy, iplen);
+
+    /* only take the top 21 bits from crc */
+    id[0] = (crc >> 24) & 0xff;
+    id[1] = (crc >> 16) & 0xff;
+    id[2] = ((crc >> 8) & 0xf8) | (random() & 0x7);
+    for (int i = 3; i < 19; ++i) id[i] = random();
+    id[19] = rand;
+}
+
+/* Find how many bits two ids have in common. */
+int common_bits(const unsigned char *id1, const unsigned char *id2)
+{
+    int i, j;
+    unsigned char xor;
+    for(i = 0; i < 20; i++) {
+        if(id1[i] != id2[i])
+            break;
+    }
+
+    if(i == 20)
+        return 160;
+
+    xor = id1[i] ^ id2[i];
+
+    j = 0;
+    while((xor & 0x80) == 0) {
+        xor <<= 1;
+        j++;
+    }
+
+    return 8 * i + j;
+}
+
+/* Check if a node ID is correct in the sense of BEP 42. */
+int check_id(const uint8_t id1[20], const uint8_t* ip, int iplen, uint32_t rand)
+{
+    /* Generate ID from IP + rand -> id2. */
+    uint8_t id2[20];
+    crc32c_id(ip, iplen, id2, rand);
+
+    /* Compare id1 with id2:
+       - the first 21 bits must match
+       - the last byte must match rand */
+    int cbits = common_bits(id1, id2);
+    if (cbits < 21) {
+        printf("Only the first %i bits match (expected: 21)\n", cbits);
+        return 0;
+    }
+    if (id1[19] != id2[19]) {
+        printf("Last byte does not match (expected: %u, got: %u)\n", id2[19], id1[19]);
+        return 0;
+    }
+    return 1;
+}
+
+/* Main. */
+int main(int argc, char **argv)
+{
+    (void)argc;
+    (void)argv;
+
+    /* Print which CRC32C algorithm is used. */
+    printf("\nUsing %s algorithm.\n\n", crc32c_hw_support() ? "hardware-accelerated (SSE 4.2)" : "software");
+
+    /* Seed random. */
+    int fd = open("/dev/urandom", O_RDONLY);
+    if(fd < 0) {
+        perror("open(random)");
+        exit(1);
+    }
+    unsigned seed;
+    read(fd, &seed, sizeof(seed));
+    srandom(seed);
+    close(fd);
+
+    /* Example IP/rand combinations as used in BEP 42. */
+    uint8_t ip[5][4] = {
+        { 124, 31, 75, 21 },
+        { 21, 75, 31, 124 },
+        { 65, 23, 51, 170 },
+        { 84, 124, 73, 14 },
+        { 43, 213, 53, 83 }
+    };
+    uint32_t rand[] = {
+        1,
+        86,
+        22,
+        65,
+        90
+    };
+    int iplen = 4;
+    uint8_t id[20];
+
+    printf("IP              rand  Node ID                                    Ok?\n");
+    printf("=============== ===== ========================================== ====\n");
+    for (int i = 0; i < 5; ++i) {
+        crc32c_id(ip[i], iplen, id, rand[i]);
+        char ipstr[INET_ADDRSTRLEN];
+        inet_ntop(AF_INET, ip[i], ipstr, sizeof(ipstr));
+        printf("%-15s  %2u   %s %s\n", ipstr, rand[i], id_to_hex(id), (check_id(id, ip[i], 4, rand[i]) ? "yes" : "no"));
+    }
+
+    return 0;
+}

3rdparty/crc32c_adler/example-stdin.c

+/*
+  TODO describe example
+*/
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <unistd.h>
+
+#include "crc32c_adler.h"
+
+#define SIZE (262144*3)
+#define CHUNK SIZE
+
+int main(int argc, char **argv)
+{
+    char *buf;
+    ssize_t got;
+    size_t off, n;
+    uint32_t crc;
+
+    (void)argv;
+    crc = 0;
+    buf = malloc(SIZE);
+    if (buf == NULL) {
+        fputs("out of memory", stderr);
+        return 1;
+    }
+    while ((got = read(0, buf, SIZE)) > 0) {
+        off = 0;
+        do {
+            n = (size_t)got - off;
+            if (n > CHUNK)
+                n = CHUNK;
+            crc = argc > 1 ? crc32c_sw(crc, buf + off, n) :
+                             crc32c(crc, buf + off, n);
+            off += n;
+        } while (off < (size_t)got);
+    }
+    free(buf);
+    if (got == -1) {
+        fputs("read error\n", stderr);
+        return 1;
+    }
+    printf("%08x\n", crc);
+    return 0;
+}

3rdparty/curl/CMakeLists.txt

-cmake_minimum_required(VERSION 3.0 FATAL_ERROR)
-
-set(BUILD_CURL_EXE OFF CACHE BOOL "" FORCE)
-set(CMAKE_USE_OPENSSL OFF CACHE BOOL "" FORCE)
-set(CURL_CA_PATH_SET FALSE CACHE BOOL "" FORCE)
-set(CURL_DISABLE_COOKIES ON CACHE BOOL "" FORCE)
-set(CURL_DISABLE_CRYPTO_AUTH TRUE CACHE BOOL "" FORCE)
-set(ENABLE_MANUAL FALSE CACHE BOOL "" FORCE)
-set(CURL_DISABLE_PROXY ON CACHE BOOL "" FORCE)
-set(ENABLE_UNIX_SOCKETS OFF CACHE BOOL "" FORCE)
-set(CURL_DISABLE_VERBOSE_STRINGS ON CACHE BOOL "" FORCE)
-set(CURL_ZLIB OFF CACHE BOOL "" FORCE)
-set(CMAKE_USE_LIBSSH2 OFF CACHE BOOL "" FORCE)
-set(BUILD_TESTING OFF CACHE BOOL "" FORCE)
-
-set(BUILD_SHARED_LIBS OFF CACHE BOOL "" FORCE)
-
-add_subdirectory(libcurl)
-
-#target_include_directories(libcurl INTERFACE "libcurl/include/")
-
-target_include_directories(curl PUBLIC
-    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/libcurl/include>
-    $<INSTALL_INTERFACE:include/mylib>
-)

3rdparty/curl/libcurl/CHANGES

-See https://curl.haxx.se/changes.html for the edited and human readable online
-version of what has changed over the years in different curl releases.
-
-Generate a CHANGES file like the one present in every release like this:
-
-$ git log --pretty=fuller --no-color --date=short --decorate=full | \
-  ./scripts/log2changes.pl

3rdparty/curl/libcurl/CMake/CMakeConfigurableFile.in

-@CMAKE_CONFIGURABLE_FILE_CONTENT@

3rdparty/curl/libcurl/CMake/CurlSymbolHiding.cmake

-include(CheckCSourceCompiles)
-
-option(CURL_HIDDEN_SYMBOLS "Set to ON to hide libcurl internal symbols (=hide all symbols that aren't officially external)." ON)
-mark_as_advanced(CURL_HIDDEN_SYMBOLS)
-
-if(CURL_HIDDEN_SYMBOLS)
-  set(SUPPORTS_SYMBOL_HIDING FALSE)
-
-  if(CMAKE_C_COMPILER_ID MATCHES "Clang")
-    set(SUPPORTS_SYMBOL_HIDING TRUE)
-    set(_SYMBOL_EXTERN "__attribute__ ((__visibility__ (\"default\")))")
-    set(_CFLAG_SYMBOLS_HIDE "-fvisibility=hidden")
-  elseif(CMAKE_COMPILER_IS_GNUCC)
-    if(NOT CMAKE_VERSION VERSION_LESS 2.8.10)
-      set(GCC_VERSION ${CMAKE_C_COMPILER_VERSION})
-    else()
-      execute_process(COMMAND ${CMAKE_C_COMPILER} -dumpversion
-                      OUTPUT_VARIABLE GCC_VERSION)
-    endif()
-    if(NOT GCC_VERSION VERSION_LESS 3.4)
-      # note: this is considered buggy prior to 4.0 but the autotools don't care, so let's ignore that fact
-      set(SUPPORTS_SYMBOL_HIDING TRUE)
-      set(_SYMBOL_EXTERN "__attribute__ ((__visibility__ (\"default\")))")
-      set(_CFLAG_SYMBOLS_HIDE "-fvisibility=hidden")
-    endif()
-  elseif(CMAKE_C_COMPILER_ID MATCHES "SunPro" AND NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 8.0)
-    set(SUPPORTS_SYMBOL_HIDING TRUE)
-    set(_SYMBOL_EXTERN "__global")
-    set(_CFLAG_SYMBOLS_HIDE "-xldscope=hidden")
-  elseif(CMAKE_C_COMPILER_ID MATCHES "Intel" AND NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 9.0)
-    # note: this should probably just check for version 9.1.045 but I'm not 100% sure
-    #       so let's do it the same way autotools do.
-    set(SUPPORTS_SYMBOL_HIDING TRUE)
-    set(_SYMBOL_EXTERN "__attribute__ ((__visibility__ (\"default\")))")
-    set(_CFLAG_SYMBOLS_HIDE "-fvisibility=hidden")
-    check_c_source_compiles("#include <stdio.h>
-        int main (void) { printf(\"icc fvisibility bug test\"); return 0; }" _no_bug)
-    if(NOT _no_bug)
-      set(SUPPORTS_SYMBOL_HIDING FALSE)
-      set(_SYMBOL_EXTERN "")
-      set(_CFLAG_SYMBOLS_HIDE "")
-    endif()
-  elseif(MSVC)
-    set(SUPPORTS_SYMBOL_HIDING TRUE)
-  endif()
-
-  set(HIDES_CURL_PRIVATE_SYMBOLS ${SUPPORTS_SYMBOL_HIDING})
-elseif(MSVC)
-  if(NOT CMAKE_VERSION VERSION_LESS 3.7)
-    set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS TRUE) #present since 3.4.3 but broken
-    set(HIDES_CURL_PRIVATE_SYMBOLS FALSE)
-  else()
-    message(WARNING "Hiding private symbols regardless CURL_HIDDEN_SYMBOLS being disabled.")
-    set(HIDES_CURL_PRIVATE_SYMBOLS TRUE)
-  endif()
-else()
-  set(HIDES_CURL_PRIVATE_SYMBOLS FALSE)
-endif()
-
-set(CURL_CFLAG_SYMBOLS_HIDE ${_CFLAG_SYMBOLS_HIDE})
-set(CURL_EXTERN_SYMBOL ${_SYMBOL_EXTERN})

3rdparty/curl/libcurl/CMake/CurlTests.c

-/***************************************************************************
- *                                  _   _ ____  _
- *  Project                     ___| | | |  _ \| |
- *                             / __| | | | |_) | |
- *                            | (__| |_| |  _ <| |___
- *                             \___|\___/|_| \_\_____|
- *
- * Copyright (C) 1998 - 2019, Daniel Stenberg, <daniel@haxx.se>, et al.
- *
- * This software is licensed as described in the file COPYING, which
- * you should have received as part of this distribution. The terms
- * are also available at https://curl.haxx.se/docs/copyright.html.
- *
- * You may opt to use, copy, modify, merge, publish, distribute and/or sell
- * copies of the Software, and permit persons to whom the Software is
- * furnished to do so, under the terms of the COPYING file.
- *
- * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
- * KIND, either express or implied.
- *
- ***************************************************************************/
-#ifdef TIME_WITH_SYS_TIME
-/* Time with sys/time test */
-
-#include <sys/types.h>
-#include <sys/time.h>
-#include <time.h>
-
-int
-main ()
-{
-if ((struct tm *) 0)
-return 0;
-  ;
-  return 0;
-}
-
-#endif
-
-#ifdef HAVE_FCNTL_O_NONBLOCK
-
-/* headers for FCNTL_O_NONBLOCK test */
-#include <sys/types.h>
-#include <unistd.h>
-#include <fcntl.h>
-/* */
-#if defined(sun) || defined(__sun__) || \
-    defined(__SUNPRO_C) || defined(__SUNPRO_CC)
-# if defined(__SVR4) || defined(__srv4__)
-#  define PLATFORM_SOLARIS
-# else
-#  define PLATFORM_SUNOS4
-# endif
-#endif
-#if (defined(_AIX) || defined(__xlC__)) && !defined(_AIX41)
-# define PLATFORM_AIX_V3
-#endif
-/* */
-#if defined(PLATFORM_SUNOS4) || defined(PLATFORM_AIX_V3) || defined(__BEOS__)
-#error "O_NONBLOCK does not work on this platform"
-#endif
-
-int
-main ()
-{
-      /* O_NONBLOCK source test */
-      int flags = 0;
-      if(0 != fcntl(0, F_SETFL, flags | O_NONBLOCK))
-          return 1;
-      return 0;
-}
-#endif
-
-/* tests for gethostbyaddr_r or gethostbyname_r */
-#if defined(HAVE_GETHOSTBYADDR_R_5_REENTRANT) || \
-    defined(HAVE_GETHOSTBYADDR_R_7_REENTRANT) || \
-    defined(HAVE_GETHOSTBYADDR_R_8_REENTRANT) || \
-    defined(HAVE_GETHOSTBYNAME_R_3_REENTRANT) || \
-    defined(HAVE_GETHOSTBYNAME_R_5_REENTRANT) || \
-    defined(HAVE_GETHOSTBYNAME_R_6_REENTRANT)
-#   define _REENTRANT
-    /* no idea whether _REENTRANT is always set, just invent a new flag */
-#   define TEST_GETHOSTBYFOO_REENTRANT
-#endif
-#if defined(HAVE_GETHOSTBYADDR_R_5) || \
-    defined(HAVE_GETHOSTBYADDR_R_7) || \
-    defined(HAVE_GETHOSTBYADDR_R_8) || \
-    defined(HAVE_GETHOSTBYNAME_R_3) || \
-    defined(HAVE_GETHOSTBYNAME_R_5) || \
-    defined(HAVE_GETHOSTBYNAME_R_6) || \
-    defined(TEST_GETHOSTBYFOO_REENTRANT)
-#include <sys/types.h>
-#include <netdb.h>
-int main(void)
-{
-  char *address = "example.com";
-  int length = 0;
-  int type = 0;
-  struct hostent h;
-  int rc = 0;
-#if defined(HAVE_GETHOSTBYADDR_R_5) || \
-    defined(HAVE_GETHOSTBYADDR_R_5_REENTRANT) || \
-    \
-    defined(HAVE_GETHOSTBYNAME_R_3) || \
-    defined(HAVE_GETHOSTBYNAME_R_3_REENTRANT)
-  struct hostent_data hdata;
-#elif defined(HAVE_GETHOSTBYADDR_R_7) || \
-      defined(HAVE_GETHOSTBYADDR_R_7_REENTRANT) || \
-      defined(HAVE_GETHOSTBYADDR_R_8) || \
-      defined(HAVE_GETHOSTBYADDR_R_8_REENTRANT) || \
-      \
-      defined(HAVE_GETHOSTBYNAME_R_5) || \
-      defined(HAVE_GETHOSTBYNAME_R_5_REENTRANT) || \
-      defined(HAVE_GETHOSTBYNAME_R_6) || \
-      defined(HAVE_GETHOSTBYNAME_R_6_REENTRANT)
-  char buffer[8192];
-  int h_errnop;
-  struct hostent *hp;
-#endif
-
-#ifndef gethostbyaddr_r
-  (void)gethostbyaddr_r;
-#endif
-
-#if   defined(HAVE_GETHOSTBYADDR_R_5) || \
-      defined(HAVE_GETHOSTBYADDR_R_5_REENTRANT)
-  rc = gethostbyaddr_r(address, length, type, &h, &hdata);
-  (void)rc;
-#elif defined(HAVE_GETHOSTBYADDR_R_7) || \
-      defined(HAVE_GETHOSTBYADDR_R_7_REENTRANT)
-  hp = gethostbyaddr_r(address, length, type, &h, buffer, 8192, &h_errnop);
-  (void)hp;
-#elif defined(HAVE_GETHOSTBYADDR_R_8) || \
-      defined(HAVE_GETHOSTBYADDR_R_8_REENTRANT)
-  rc = gethostbyaddr_r(address, length, type, &h, buffer, 8192, &hp, &h_errnop);
-  (void)rc;
-#endif
-
-#if   defined(HAVE_GETHOSTBYNAME_R_3) || \
-      defined(HAVE_GETHOSTBYNAME_R_3_REENTRANT)
-  rc = gethostbyname_r(address, &h, &hdata);
-#elif defined(HAVE_GETHOSTBYNAME_R_5) || \
-      defined(HAVE_GETHOSTBYNAME_R_5_REENTRANT)
-  rc = gethostbyname_r(address, &h, buffer, 8192, &h_errnop);
-  (void)hp; /* not used for test */
-#elif defined(HAVE_GETHOSTBYNAME_R_6) || \
-      defined(HAVE_GETHOSTBYNAME_R_6_REENTRANT)
-  rc = gethostbyname_r(address, &h, buffer, 8192, &hp, &h_errnop);
-#endif
-
-  (void)length;
-  (void)type;
-  (void)rc;
-  return 0;
-}
-#endif
-
-#ifdef HAVE_SOCKLEN_T
-#ifdef _WIN32
-#include <ws2tcpip.h>
-#else
-#include <sys/types.h>
-#include <sys/socket.h>
-#endif
-int
-main ()
-{
-if ((socklen_t *) 0)
-  return 0;
-if (sizeof (socklen_t))
-  return 0;
-  ;
-  return 0;
-}
-#endif
-#ifdef HAVE_IN_ADDR_T
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <arpa/inet.h>
-
-int
-main ()
-{
-if ((in_addr_t *) 0)
-  return 0;
-if (sizeof (in_addr_t))
-  return 0;
-  ;
-  return 0;
-}
-#endif
-
-#ifdef HAVE_BOOL_T
-#ifdef HAVE_SYS_TYPES_H
-#include <sys/types.h>
-#endif
-#ifdef HAVE_STDBOOL_H
-#include <stdbool.h>
-#endif
-int
-main ()
-{
-if (sizeof (bool *) )
-  return 0;
-  ;
-  return 0;
-}
-#endif
-
-#ifdef STDC_HEADERS
-#include <stdlib.h>
-#include <stdarg.h>
-#include <string.h>
-#include <float.h>
-int main() { return 0; }
-#endif
-#ifdef RETSIGTYPE_TEST
-#include <sys/types.h>
-#include <signal.h>
-#ifdef signal
-# undef signal
-#endif
-#ifdef __cplusplus
-extern "C" void (*signal (int, void (*)(int)))(int);
-#else
-void (*signal ()) ();
-#endif
-
-int
-main ()
-{
-  return 0;
-}
-#endif
-#ifdef HAVE_INET_NTOA_R_DECL
-#include <arpa/inet.h>
-
-typedef void (*func_type)();
-
-int main()
-{
-#ifndef inet_ntoa_r
-  func_type func;
-  func = (func_type)inet_ntoa_r;
-  (void)func;
-#endif
-  return 0;
-}
-#endif
-#ifdef HAVE_INET_NTOA_R_DECL_REENTRANT
-#define _REENTRANT
-#include <arpa/inet.h>
-
-typedef void (*func_type)();
-
-int main()
-{
-#ifndef inet_ntoa_r
-  func_type func;
-  func = (func_type)&inet_ntoa_r;
-  (void)func;
-#endif
-  return 0;
-}
-#endif
-#ifdef HAVE_GETADDRINFO
-#include <netdb.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-
-int main(void) {
-    struct addrinfo hints, *ai;
-    int error;
-
-    memset(&hints, 0, sizeof(hints));
-    hints.ai_family = AF_UNSPEC;
-    hints.ai_socktype = SOCK_STREAM;
-#ifndef getaddrinfo
-    (void)getaddrinfo;
-#endif
-    error = getaddrinfo("127.0.0.1", "8080", &hints, &ai);
-    if (error) {
-        return 1;
-    }
-    return 0;
-}
-#endif
-#ifdef HAVE_FILE_OFFSET_BITS
-#ifdef _FILE_OFFSET_BITS
-#undef _FILE_OFFSET_BITS
-#endif
-#define _FILE_OFFSET_BITS 64
-#include <sys/types.h>
- /* Check that off_t can represent 2**63 - 1 correctly.
-    We can't simply define LARGE_OFF_T to be 9223372036854775807,
-    since some C++ compilers masquerading as C compilers
-    incorrectly reject 9223372036854775807.  */
-#define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
-  int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
-                       && LARGE_OFF_T % 2147483647 == 1)
-                      ? 1 : -1];
-int main () { ; return 0; }
-#endif
-#ifdef HAVE_IOCTLSOCKET
-/* includes start */
-#ifdef HAVE_WINDOWS_H
-#  ifndef WIN32_LEAN_AND_MEAN
-#    define WIN32_LEAN_AND_MEAN
-#  endif
-#  include <windows.h>
-#  ifdef HAVE_WINSOCK2_H
-#    include <winsock2.h>
-#  else
-#    ifdef HAVE_WINSOCK_H
-#      include <winsock.h>
-#    endif
-#  endif
-#endif
-
-int
-main ()
-{
-
-/* ioctlsocket source code */
- int socket;
- unsigned long flags = ioctlsocket(socket, FIONBIO, &flags);
-
-  ;
-  return 0;
-}
-
-#endif
-#ifdef HAVE_IOCTLSOCKET_CAMEL
-/* includes start */
-#ifdef HAVE_WINDOWS_H
-#  ifndef WIN32_LEAN_AND_MEAN
-#    define WIN32_LEAN_AND_MEAN
-#  endif
-#  include <windows.h>
-#  ifdef HAVE_WINSOCK2_H
-#    include <winsock2.h>
-#  else
-#    ifdef HAVE_WINSOCK_H
-#      include <winsock.h>
-#    endif
-#  endif
-#endif
-
-int
-main ()
-{
-
-/* IoctlSocket source code */
-    if(0 != IoctlSocket(0, 0, 0))
-      return 1;
-  ;
-  return 0;
-}
-#endif
-#ifdef HAVE_IOCTLSOCKET_CAMEL_FIONBIO
-/* includes start */
-#ifdef HAVE_WINDOWS_H
-#  ifndef WIN32_LEAN_AND_MEAN
-#    define WIN32_LEAN_AND_MEAN
-#  endif
-#  include <windows.h>
-#  ifdef HAVE_WINSOCK2_H
-#    include <winsock2.h>
-#  else
-#    ifdef HAVE_WINSOCK_H
-#      include <winsock.h>
-#    endif
-#  endif
-#endif
-
-int
-main ()
-{
-
-/* IoctlSocket source code */
-        long flags = 0;
-        if(0 != ioctlsocket(0, FIONBIO, &flags))
-          return 1;
-  ;
-  return 0;
-}
-#endif
-#ifdef HAVE_IOCTLSOCKET_FIONBIO
-/* includes start */
-#ifdef HAVE_WINDOWS_H
-#  ifndef WIN32_LEAN_AND_MEAN
-#    define WIN32_LEAN_AND_MEAN
-#  endif
-#  include <windows.h>
-#  ifdef HAVE_WINSOCK2_H
-#    include <winsock2.h>
-#  else
-#    ifdef HAVE_WINSOCK_H
-#      include <winsock.h>
-#    endif
-#  endif
-#endif
-
-int
-main ()
-{
-
-        int flags = 0;
-        if(0 != ioctlsocket(0, FIONBIO, &flags))
-          return 1;
-
-  ;
-  return 0;
-}
-#endif
-#ifdef HAVE_IOCTL_FIONBIO
-/* headers for FIONBIO test */
-/* includes start */
-#ifdef HAVE_SYS_TYPES_H
-#  include <sys/types.h>
-#endif
-#ifdef HAVE_UNISTD_H
-#  include <unistd.h>
-#endif
-#ifdef HAVE_SYS_SOCKET_H
-#  include <sys/socket.h>
-#endif
-#ifdef HAVE_SYS_IOCTL_H
-#  include <sys/ioctl.h>
-#endif
-#ifdef HAVE_STROPTS_H
-#  include <stropts.h>
-#endif
-
-int
-main ()
-{
-
-        int flags = 0;
-        if(0 != ioctl(0, FIONBIO, &flags))
-          return 1;
-
-  ;
-  return 0;
-}
-#endif
-#ifdef HAVE_IOCTL_SIOCGIFADDR
-/* headers for FIONBIO test */
-/* includes start */
-#ifdef HAVE_SYS_TYPES_H
-#  include <sys/types.h>
-#endif
-#ifdef HAVE_UNISTD_H
-#  include <unistd.h>
-#endif
-#ifdef HAVE_SYS_SOCKET_H
-#  include <sys/socket.h>
-#endif
-#ifdef HAVE_SYS_IOCTL_H
-#  include <sys/ioctl.h>
-#endif
-#ifdef HAVE_STROPTS_H
-#  include <stropts.h>
-#endif
-#include <net/if.h>
-
-int
-main ()
-{
-        struct ifreq ifr;
-        if(0 != ioctl(0, SIOCGIFADDR, &ifr))
-          return 1;
-
-  ;
-  return 0;
-}
-#endif
-#ifdef HAVE_SETSOCKOPT_SO_NONBLOCK
-/* includes start */
-#ifdef HAVE_WINDOWS_H
-#  ifndef WIN32_LEAN_AND_MEAN
-#    define WIN32_LEAN_AND_MEAN
-#  endif
-#  include <windows.h>
-#  ifdef HAVE_WINSOCK2_H
-#    include <winsock2.h>
-#  else
-#    ifdef HAVE_WINSOCK_H
-#      include <winsock.h>
-#    endif
-#  endif
-#endif
-/* includes start */
-#ifdef HAVE_SYS_TYPES_H
-#  include <sys/types.h>
-#endif
-#ifdef HAVE_SYS_SOCKET_H
-#  include <sys/socket.h>
-#endif
-/* includes end */
-
-int
-main ()
-{
-        if(0 != setsockopt(0, SOL_SOCKET, SO_NONBLOCK, 0, 0))
-          return 1;
-  ;
-  return 0;
-}
-#endif
-#ifdef HAVE_GLIBC_STRERROR_R
-#include <string.h>
-#include <errno.h>
-
-void check(char c) {}
-
-int
-main () {
-  char buffer[1024];
-  /* This will not compile if strerror_r does not return a char* */
-  check(strerror_r(EACCES, buffer, sizeof(buffer))[0]);
-  return 0;
-}
-#endif
-#ifdef HAVE_POSIX_STRERROR_R
-#include <string.h>
-#include <errno.h>
-
-/* float, because a pointer can't be implicitly cast to float */
-void check(float f) {}
-
-int
-main () {
-  char buffer[1024];
-  /* This will not compile if strerror_r does not return an int */
-  check(strerror_r(EACCES, buffer, sizeof(buffer)));
-  return 0;
-}
-#endif
-#ifdef HAVE_FSETXATTR_6
-#include <sys/xattr.h> /* header from libc, not from libattr */
-int
-main() {
-  fsetxattr(0, 0, 0, 0, 0, 0);
-  return 0;
-}
-#endif
-#ifdef HAVE_FSETXATTR_5
-#include <sys/xattr.h> /* header from libc, not from libattr */
-int
-main() {
-  fsetxattr(0, 0, 0, 0, 0);
-  return 0;
-}
-#endif
-#ifdef HAVE_CLOCK_GETTIME_MONOTONIC
-#include <time.h>
-int
-main() {
-  struct timespec ts = {0, 0};
-  clock_gettime(CLOCK_MONOTONIC, &ts);
-  return 0;
-}
-#endif
-#ifdef HAVE_BUILTIN_AVAILABLE
-int
-main() {
-  if(__builtin_available(macOS 10.12, *)) {}
-  return 0;
-}
-#endif
-#ifdef HAVE_VARIADIC_MACROS_C99
-#define c99_vmacro3(first, ...) fun3(first, __VA_ARGS__)
-#define c99_vmacro2(first, ...) fun2(first, __VA_ARGS__)
-
-int fun3(int arg1, int arg2, int arg3);
-int fun2(int arg1, int arg2);
-
-int fun3(int arg1, int arg2, int arg3) {
-  return arg1 + arg2 + arg3;
-}
-int fun2(int arg1, int arg2) {
-  return arg1 + arg2;
-}
-
-int
-main() {
-  int res3 = c99_vmacro3(1, 2, 3);
-  int res2 = c99_vmacro2(1, 2);
-  (void)res3;
-  (void)res2;
-  return 0;
-}
-#endif
-#ifdef HAVE_VARIADIC_MACROS_GCC
-#define gcc_vmacro3(first, args...) fun3(first, args)
-#define gcc_vmacro2(first, args...) fun2(first, args)
-
-int fun3(int arg1, int arg2, int arg3);
-int fun2(int arg1, int arg2);
-
-int fun3(int arg1, int arg2, int arg3) {
-  return arg1 + arg2 + arg3;
-}
-int fun2(int arg1, int arg2) {
-  return arg1 + arg2;
-}
-
-int
-main() {
-  int res3 = gcc_vmacro3(1, 2, 3);
-  int res2 = gcc_vmacro2(1, 2);
-  (void)res3;
-  (void)res2;
-  return 0;
-}
-#endif

3rdparty/curl/libcurl/CMake/FindBrotli.cmake

-include(FindPackageHandleStandardArgs)
-
-find_path(BROTLI_INCLUDE_DIR "brotli/decode.h")
-
-find_library(BROTLICOMMON_LIBRARY NAMES brotlicommon)
-find_library(BROTLIDEC_LIBRARY NAMES brotlidec)
-
-find_package_handle_standard_args(BROTLI
-    FOUND_VAR
-      BROTLI_FOUND
-    REQUIRED_VARS
-      BROTLIDEC_LIBRARY
-      BROTLICOMMON_LIBRARY
-      BROTLI_INCLUDE_DIR
-    FAIL_MESSAGE
-      "Could NOT find BROTLI"
-)
-
-set(BROTLI_INCLUDE_DIRS ${BROTLI_INCLUDE_DIR})
-set(BROTLI_LIBRARIES ${BROTLICOMMON_LIBRARY} ${BROTLIDEC_LIBRARY})

3rdparty/curl/libcurl/CMake/FindCARES.cmake

-# - Find c-ares
-# Find the c-ares includes and library
-# This module defines
-#  CARES_INCLUDE_DIR, where to find ares.h, etc.
-#  CARES_LIBRARIES, the libraries needed to use c-ares.
-#  CARES_FOUND, If false, do not try to use c-ares.
-# also defined, but not for general use are
-# CARES_LIBRARY, where to find the c-ares library.
-
-find_path(CARES_INCLUDE_DIR ares.h
-  /usr/local/include
-  /usr/include
-  )
-
-set(CARES_NAMES ${CARES_NAMES} cares)
-find_library(CARES_LIBRARY
-  NAMES ${CARES_NAMES}
-  PATHS /usr/lib /usr/local/lib
-  )
-
-if(CARES_LIBRARY AND CARES_INCLUDE_DIR)
-  set(CARES_LIBRARIES ${CARES_LIBRARY})
-  set(CARES_FOUND "YES")
-else()
-  set(CARES_FOUND "NO")
-endif()
-
-
-if(CARES_FOUND)
-  if(NOT CARES_FIND_QUIETLY)
-    message(STATUS "Found c-ares: ${CARES_LIBRARIES}")
-  endif()
-else()
-  if(CARES_FIND_REQUIRED)
-    message(FATAL_ERROR "Could not find c-ares library")
-  endif()
-endif()
-
-mark_as_advanced(
-  CARES_LIBRARY
-  CARES_INCLUDE_DIR
-  )

3rdparty/curl/libcurl/CMake/FindGSS.cmake

-# - Try to find the GSS Kerberos library
-# Once done this will define
-#
-#  GSS_ROOT_DIR - Set this variable to the root installation of GSS
-#
-# Read-Only variables:
-#  GSS_FOUND - system has the Heimdal library
-#  GSS_FLAVOUR - "MIT" or "Heimdal" if anything found.
-#  GSS_INCLUDE_DIR - the Heimdal include directory
-#  GSS_LIBRARIES - The libraries needed to use GSS
-#  GSS_LINK_DIRECTORIES - Directories to add to linker search path
-#  GSS_LINKER_FLAGS - Additional linker flags
-#  GSS_COMPILER_FLAGS - Additional compiler flags
-#  GSS_VERSION - This is set to version advertised by pkg-config or read from manifest.
-#                In case the library is found but no version info available it'll be set to "unknown"
-
-set(_MIT_MODNAME mit-krb5-gssapi)
-set(_HEIMDAL_MODNAME heimdal-gssapi)
-
-include(CheckIncludeFile)
-include(CheckIncludeFiles)
-include(CheckTypeSize)
-
-set(_GSS_ROOT_HINTS
-    "${GSS_ROOT_DIR}"
-    "$ENV{GSS_ROOT_DIR}"
-)
-
-# try to find library using system pkg-config if user didn't specify root dir
-if(NOT GSS_ROOT_DIR AND NOT "$ENV{GSS_ROOT_DIR}")
-  if(UNIX)
-    find_package(PkgConfig QUIET)
-    pkg_search_module(_GSS_PKG ${_MIT_MODNAME} ${_HEIMDAL_MODNAME})
-    list(APPEND _GSS_ROOT_HINTS "${_GSS_PKG_PREFIX}")
-  elseif(WIN32)
-    list(APPEND _GSS_ROOT_HINTS "[HKEY_LOCAL_MACHINE\\SOFTWARE\\MIT\\Kerberos;InstallDir]")
-  endif()
-endif()
-
-if(NOT _GSS_FOUND) #not found by pkg-config. Let's take more traditional approach.
-  find_file(_GSS_CONFIGURE_SCRIPT
-      NAMES
-          "krb5-config"
-      HINTS
-          ${_GSS_ROOT_HINTS}
-      PATH_SUFFIXES
-          bin
-      NO_CMAKE_PATH
-      NO_CMAKE_ENVIRONMENT_PATH
-  )
-
-  # if not found in user-supplied directories, maybe system knows better
-  find_file(_GSS_CONFIGURE_SCRIPT
-      NAMES
-          "krb5-config"
-      PATH_SUFFIXES
-          bin
-  )
-
-  if(_GSS_CONFIGURE_SCRIPT)
-    execute_process(
-          COMMAND ${_GSS_CONFIGURE_SCRIPT} "--cflags" "gssapi"
-          OUTPUT_VARIABLE _GSS_CFLAGS
-          RESULT_VARIABLE _GSS_CONFIGURE_FAILED
-          OUTPUT_STRIP_TRAILING_WHITESPACE
-      )
-    message(STATUS "CFLAGS: ${_GSS_CFLAGS}")
-    if(NOT _GSS_CONFIGURE_FAILED) # 0 means success
-      # should also work in an odd case when multiple directories are given
-      string(STRIP "${_GSS_CFLAGS}" _GSS_CFLAGS)
-      string(REGEX REPLACE " +-I" ";" _GSS_CFLAGS "${_GSS_CFLAGS}")
-      string(REGEX REPLACE " +-([^I][^ \\t;]*)" ";-\\1" _GSS_CFLAGS "${_GSS_CFLAGS}")
-
-      foreach(_flag ${_GSS_CFLAGS})
-        if(_flag MATCHES "^-I.*")
-          string(REGEX REPLACE "^-I" "" _val "${_flag}")
-          list(APPEND _GSS_INCLUDE_DIR "${_val}")
-        else()
-          list(APPEND _GSS_COMPILER_FLAGS "${_flag}")
-        endif()
-      endforeach()
-    endif()
-
-    execute_process(
-        COMMAND ${_GSS_CONFIGURE_SCRIPT} "--libs" "gssapi"
-        OUTPUT_VARIABLE _GSS_LIB_FLAGS
-        RESULT_VARIABLE _GSS_CONFIGURE_FAILED
-        OUTPUT_STRIP_TRAILING_WHITESPACE
-    )
-    message(STATUS "LDFLAGS: ${_GSS_LIB_FLAGS}")
-
-    if(NOT _GSS_CONFIGURE_FAILED) # 0 means success
-      # this script gives us libraries and link directories. Blah. We have to deal with it.
-      string(STRIP "${_GSS_LIB_FLAGS}" _GSS_LIB_FLAGS)
-      string(REGEX REPLACE " +-(L|l)" ";-\\1" _GSS_LIB_FLAGS "${_GSS_LIB_FLAGS}")
-      string(REGEX REPLACE " +-([^Ll][^ \\t;]*)" ";-\\1" _GSS_LIB_FLAGS "${_GSS_LIB_FLAGS}")
-
-      foreach(_flag ${_GSS_LIB_FLAGS})
-        if(_flag MATCHES "^-l.*")
-          string(REGEX REPLACE "^-l" "" _val "${_flag}")
-          list(APPEND _GSS_LIBRARIES "${_val}")
-        elseif(_flag MATCHES "^-L.*")
-          string(REGEX REPLACE "^-L" "" _val "${_flag}")
-          list(APPEND _GSS_LINK_DIRECTORIES "${_val}")
-        else()
-          list(APPEND _GSS_LINKER_FLAGS "${_flag}")
-        endif()
-      endforeach()
-    endif()
-
-    execute_process(
-        COMMAND ${_GSS_CONFIGURE_SCRIPT} "--version"
-        OUTPUT_VARIABLE _GSS_VERSION
-        RESULT_VARIABLE _GSS_CONFIGURE_FAILED
-        OUTPUT_STRIP_TRAILING_WHITESPACE
-    )
-
-    # older versions may not have the "--version" parameter. In this case we just don't care.
-    if(_GSS_CONFIGURE_FAILED)
-      set(_GSS_VERSION 0)
-    endif()
-
-    execute_process(
-        COMMAND ${_GSS_CONFIGURE_SCRIPT} "--vendor"
-        OUTPUT_VARIABLE _GSS_VENDOR
-        RESULT_VARIABLE _GSS_CONFIGURE_FAILED
-        OUTPUT_STRIP_TRAILING_WHITESPACE
-    )
-
-    # older versions may not have the "--vendor" parameter. In this case we just don't care.
-    if(_GSS_CONFIGURE_FAILED)
-      set(GSS_FLAVOUR "Heimdal") # most probably, shouldn't really matter
-    else()
-      if(_GSS_VENDOR MATCHES ".*H|heimdal.*")
-        set(GSS_FLAVOUR "Heimdal")
-      else()
-        set(GSS_FLAVOUR "MIT")
-      endif()
-    endif()
-
-  else() # either there is no config script or we are on a platform that doesn't provide one (Windows?)
-
-    find_path(_GSS_INCLUDE_DIR
-        NAMES
-            "gssapi/gssapi.h"
-        HINTS
-            ${_GSS_ROOT_HINTS}
-        PATH_SUFFIXES
-            include
-            inc
-    )
-
-    if(_GSS_INCLUDE_DIR) #jay, we've found something
-      set(CMAKE_REQUIRED_INCLUDES "${_GSS_INCLUDE_DIR}")
-      check_include_files( "gssapi/gssapi_generic.h;gssapi/gssapi_krb5.h" _GSS_HAVE_MIT_HEADERS)
-
-      if(_GSS_HAVE_MIT_HEADERS)
-        set(GSS_FLAVOUR "MIT")
-      else()
-        # prevent compiling the header - just check if we can include it
-        set(CMAKE_REQUIRED_DEFINITIONS "${CMAKE_REQUIRED_DEFINITIONS} -D__ROKEN_H__")
-        check_include_file( "roken.h" _GSS_HAVE_ROKEN_H)
-
-        check_include_file( "heimdal/roken.h" _GSS_HAVE_HEIMDAL_ROKEN_H)
-        if(_GSS_HAVE_ROKEN_H OR _GSS_HAVE_HEIMDAL_ROKEN_H)
-          set(GSS_FLAVOUR "Heimdal")
-        endif()
-        set(CMAKE_REQUIRED_DEFINITIONS "")
-      endif()
-    else()
-      # I'm not convinced if this is the right way but this is what autotools do at the moment
-      find_path(_GSS_INCLUDE_DIR
-          NAMES
-              "gssapi.h"
-          HINTS
-              ${_GSS_ROOT_HINTS}
-          PATH_SUFFIXES
-              include
-              inc
-      )
-
-      if(_GSS_INCLUDE_DIR)
-        set(GSS_FLAVOUR "Heimdal")
-      endif()
-    endif()
-
-    # if we have headers, check if we can link libraries
-    if(GSS_FLAVOUR)
-      set(_GSS_LIBDIR_SUFFIXES "")
-      set(_GSS_LIBDIR_HINTS ${_GSS_ROOT_HINTS})
-      get_filename_component(_GSS_CALCULATED_POTENTIAL_ROOT "${_GSS_INCLUDE_DIR}" PATH)
-      list(APPEND _GSS_LIBDIR_HINTS ${_GSS_CALCULATED_POTENTIAL_ROOT})
-
-      if(WIN32)
-        if(CMAKE_SIZEOF_VOID_P EQUAL 8)
-          list(APPEND _GSS_LIBDIR_SUFFIXES "lib/AMD64")
-          if(GSS_FLAVOUR STREQUAL "MIT")
-            set(_GSS_LIBNAME "gssapi64")
-          else()
-            set(_GSS_LIBNAME "libgssapi")
-          endif()
-        else()
-          list(APPEND _GSS_LIBDIR_SUFFIXES "lib/i386")
-          if(GSS_FLAVOUR STREQUAL "MIT")
-            set(_GSS_LIBNAME "gssapi32")
-          else()
-            set(_GSS_LIBNAME "libgssapi")
-          endif()
-        endif()
-      else()
-        list(APPEND _GSS_LIBDIR_SUFFIXES "lib;lib64") # those suffixes are not checked for HINTS
-        if(GSS_FLAVOUR STREQUAL "MIT")
-          set(_GSS_LIBNAME "gssapi_krb5")
-        else()
-          set(_GSS_LIBNAME "gssapi")
-        endif()
-      endif()
-
-      find_library(_GSS_LIBRARIES
-          NAMES
-              ${_GSS_LIBNAME}
-          HINTS
-              ${_GSS_LIBDIR_HINTS}
-          PATH_SUFFIXES
-              ${_GSS_LIBDIR_SUFFIXES}
-      )
-
-    endif()
-  endif()
-else()
-  if(_GSS_PKG_${_MIT_MODNAME}_VERSION)
-    set(GSS_FLAVOUR "MIT")
-    set(_GSS_VERSION _GSS_PKG_${_MIT_MODNAME}_VERSION)
-  else()
-    set(GSS_FLAVOUR "Heimdal")
-    set(_GSS_VERSION _GSS_PKG_${_MIT_HEIMDAL}_VERSION)
-  endif()
-endif()
-
-set(GSS_INCLUDE_DIR ${_GSS_INCLUDE_DIR})
-set(GSS_LIBRARIES ${_GSS_LIBRARIES})
-set(GSS_LINK_DIRECTORIES ${_GSS_LINK_DIRECTORIES})
-set(GSS_LINKER_FLAGS ${_GSS_LINKER_FLAGS})
-set(GSS_COMPILER_FLAGS ${_GSS_COMPILER_FLAGS})
-set(GSS_VERSION ${_GSS_VERSION})
-
-if(GSS_FLAVOUR)
-  if(NOT GSS_VERSION AND GSS_FLAVOUR STREQUAL "Heimdal")
-    if(CMAKE_SIZEOF_VOID_P EQUAL 8)
-      set(HEIMDAL_MANIFEST_FILE "Heimdal.Application.amd64.manifest")
-    else()
-      set(HEIMDAL_MANIFEST_FILE "Heimdal.Application.x86.manifest")
-    endif()
-
-    if(EXISTS "${GSS_INCLUDE_DIR}/${HEIMDAL_MANIFEST_FILE}")
-      file(STRINGS "${GSS_INCLUDE_DIR}/${HEIMDAL_MANIFEST_FILE}" heimdal_version_str
-           REGEX "^.*version=\"[0-9]\\.[^\"]+\".*$")
-
-      string(REGEX MATCH "[0-9]\\.[^\"]+"
-             GSS_VERSION "${heimdal_version_str}")
-    endif()
-
-    if(NOT GSS_VERSION)
-      set(GSS_VERSION "Heimdal Unknown")
-    endif()
-  elseif(NOT GSS_VERSION AND GSS_FLAVOUR STREQUAL "MIT")
-    get_filename_component(_MIT_VERSION "[HKEY_LOCAL_MACHINE\\SOFTWARE\\MIT\\Kerberos\\SDK\\CurrentVersion;VersionString]" NAME CACHE)
-    if(WIN32 AND _MIT_VERSION)
-      set(GSS_VERSION "${_MIT_VERSION}")
-    else()
-      set(GSS_VERSION "MIT Unknown")
-    endif()
-  endif()
-endif()
-
-include(FindPackageHandleStandardArgs)
-
-set(_GSS_REQUIRED_VARS GSS_LIBRARIES GSS_FLAVOUR)
-
-find_package_handle_standard_args(GSS
-    REQUIRED_VARS
-        ${_GSS_REQUIRED_VARS}
-    VERSION_VAR
-        GSS_VERSION
-    FAIL_MESSAGE
-        "Could NOT find GSS, try to set the path to GSS root folder in the system variable GSS_ROOT_DIR"
-)
-
-mark_as_advanced(GSS_INCLUDE_DIR GSS_LIBRARIES)

3rdparty/curl/libcurl/CMake/FindLibSSH2.cmake

-# - Try to find the libssh2 library
-# Once done this will define
-#
-# LIBSSH2_FOUND - system has the libssh2 library
-# LIBSSH2_INCLUDE_DIR - the libssh2 include directory
-# LIBSSH2_LIBRARY - the libssh2 library name
-
-if(LIBSSH2_INCLUDE_DIR AND LIBSSH2_LIBRARY)
-  set(LibSSH2_FIND_QUIETLY TRUE)
-endif()
-
-find_path(LIBSSH2_INCLUDE_DIR libssh2.h
-)
-
-find_library(LIBSSH2_LIBRARY NAMES ssh2
-)
-
-if(LIBSSH2_INCLUDE_DIR)
-  file(STRINGS "${LIBSSH2_INCLUDE_DIR}/libssh2.h" libssh2_version_str REGEX "^#define[\t ]+LIBSSH2_VERSION_NUM[\t ]+0x[0-9][0-9][0-9][0-9][0-9][0-9].*")
-
-  string(REGEX REPLACE "^.*LIBSSH2_VERSION_NUM[\t ]+0x([0-9][0-9]).*$" "\\1" LIBSSH2_VERSION_MAJOR "${libssh2_version_str}")
-  string(REGEX REPLACE "^.*LIBSSH2_VERSION_NUM[\t ]+0x[0-9][0-9]([0-9][0-9]).*$" "\\1" LIBSSH2_VERSION_MINOR  "${libssh2_version_str}")
-  string(REGEX REPLACE "^.*LIBSSH2_VERSION_NUM[\t ]+0x[0-9][0-9][0-9][0-9]([0-9][0-9]).*$" "\\1" LIBSSH2_VERSION_PATCH "${libssh2_version_str}")
-
-  string(REGEX REPLACE "^0(.+)" "\\1" LIBSSH2_VERSION_MAJOR "${LIBSSH2_VERSION_MAJOR}")
-  string(REGEX REPLACE "^0(.+)" "\\1" LIBSSH2_VERSION_MINOR "${LIBSSH2_VERSION_MINOR}")
-  string(REGEX REPLACE "^0(.+)" "\\1" LIBSSH2_VERSION_PATCH "${LIBSSH2_VERSION_PATCH}")
-
-  set(LIBSSH2_VERSION "${LIBSSH2_VERSION_MAJOR}.${LIBSSH2_VERSION_MINOR}.${LIBSSH2_VERSION_PATCH}")
-endif()
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(LibSSH2 DEFAULT_MSG LIBSSH2_INCLUDE_DIR LIBSSH2_LIBRARY )
-
-mark_as_advanced(LIBSSH2_INCLUDE_DIR LIBSSH2_LIBRARY LIBSSH2_VERSION_MAJOR LIBSSH2_VERSION_MINOR LIBSSH2_VERSION_PATCH LIBSSH2_VERSION)

3rdparty/curl/libcurl/CMake/FindMbedTLS.cmake

-find_path(MBEDTLS_INCLUDE_DIRS mbedtls/ssl.h)
-
-find_library(MBEDTLS_LIBRARY mbedtls)
-find_library(MBEDX509_LIBRARY mbedx509)
-find_library(MBEDCRYPTO_LIBRARY mbedcrypto)
-
-set(MBEDTLS_LIBRARIES "${MBEDTLS_LIBRARY}" "${MBEDX509_LIBRARY}" "${MBEDCRYPTO_LIBRARY}")
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(MBEDTLS DEFAULT_MSG
-    MBEDTLS_INCLUDE_DIRS MBEDTLS_LIBRARY MBEDX509_LIBRARY MBEDCRYPTO_LIBRARY)
-
-mark_as_advanced(MBEDTLS_INCLUDE_DIRS MBEDTLS_LIBRARY MBEDX509_LIBRARY MBEDCRYPTO_LIBRARY)

3rdparty/curl/libcurl/CMake/FindNGHTTP2.cmake

-include(FindPackageHandleStandardArgs)
-
-find_path(NGHTTP2_INCLUDE_DIR "nghttp2/nghttp2.h")
-
-find_library(NGHTTP2_LIBRARY NAMES nghttp2)
-
-find_package_handle_standard_args(NGHTTP2
-    FOUND_VAR
-      NGHTTP2_FOUND
-    REQUIRED_VARS
-      NGHTTP2_LIBRARY
-      NGHTTP2_INCLUDE_DIR
-    FAIL_MESSAGE
-      "Could NOT find NGHTTP2"
-)
-
-set(NGHTTP2_INCLUDE_DIRS ${NGHTTP2_INCLUDE_DIR})
-set(NGHTTP2_LIBRARIES ${NGHTTP2_LIBRARY})

3rdparty/curl/libcurl/CMake/Macros.cmake

-#File defines convenience macros for available feature testing
-
-# This macro checks if the symbol exists in the library and if it
-# does, it prepends library to the list.  It is intended to be called
-# multiple times with a sequence of possibly dependent libraries in
-# order of least-to-most-dependent.  Some libraries depend on others
-# to link correctly.
-macro(check_library_exists_concat LIBRARY SYMBOL VARIABLE)
-  check_library_exists("${LIBRARY};${CURL_LIBS}" ${SYMBOL} "${CMAKE_LIBRARY_PATH}"
-    ${VARIABLE})
-  if(${VARIABLE})
-    set(CURL_LIBS ${LIBRARY} ${CURL_LIBS})
-  endif()
-endmacro()
-
-# Check if header file exists and add it to the list.
-# This macro is intended to be called multiple times with a sequence of
-# possibly dependent header files.  Some headers depend on others to be
-# compiled correctly.
-macro(check_include_file_concat FILE VARIABLE)
-  check_include_files("${CURL_INCLUDES};${FILE}" ${VARIABLE})
-  if(${VARIABLE})
-    set(CURL_INCLUDES ${CURL_INCLUDES} ${FILE})
-    set(CURL_TEST_DEFINES "${CURL_TEST_DEFINES} -D${VARIABLE}")
-  endif()
-endmacro()
-
-# For other curl specific tests, use this macro.
-macro(curl_internal_test CURL_TEST)
-  if(NOT DEFINED "${CURL_TEST}")
-    set(MACRO_CHECK_FUNCTION_DEFINITIONS
-      "-D${CURL_TEST} ${CURL_TEST_DEFINES} ${CMAKE_REQUIRED_FLAGS}")
-    if(CMAKE_REQUIRED_LIBRARIES)
-      set(CURL_TEST_ADD_LIBRARIES
-        "-DLINK_LIBRARIES:STRING=${CMAKE_REQUIRED_LIBRARIES}")
-    endif()
-
-    message(STATUS "Performing Curl Test ${CURL_TEST}")
-    try_compile(${CURL_TEST}
-      ${CMAKE_BINARY_DIR}
-      ${CMAKE_CURRENT_SOURCE_DIR}/CMake/CurlTests.c
-      CMAKE_FLAGS -DCOMPILE_DEFINITIONS:STRING=${MACRO_CHECK_FUNCTION_DEFINITIONS}
-      "${CURL_TEST_ADD_LIBRARIES}"
-      OUTPUT_VARIABLE OUTPUT)
-    if(${CURL_TEST})
-      set(${CURL_TEST} 1 CACHE INTERNAL "Curl test ${FUNCTION}")
-      message(STATUS "Performing Curl Test ${CURL_TEST} - Success")
-      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
-        "Performing Curl Test ${CURL_TEST} passed with the following output:\n"
-        "${OUTPUT}\n")
-    else()
-      message(STATUS "Performing Curl Test ${CURL_TEST} - Failed")
-      set(${CURL_TEST} "" CACHE INTERNAL "Curl test ${FUNCTION}")
-      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
-        "Performing Curl Test ${CURL_TEST} failed with the following output:\n"
-        "${OUTPUT}\n")
-    endif()
-  endif()
-endmacro()
-
-macro(curl_nroff_check)
-  find_program(NROFF NAMES gnroff nroff)
-  if(NROFF)
-    # Need a way to write to stdin, this will do
-    file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/nroff-input.txt" "test")
-    # Tests for a valid nroff option to generate a manpage
-    foreach(_MANOPT "-man" "-mandoc")
-      execute_process(COMMAND "${NROFF}" ${_MANOPT}
-        OUTPUT_VARIABLE NROFF_MANOPT_OUTPUT
-        INPUT_FILE "${CMAKE_CURRENT_BINARY_DIR}/nroff-input.txt"
-        ERROR_QUIET)
-      # Save the option if it was valid
-      if(NROFF_MANOPT_OUTPUT)
-        message("Found *nroff option: -- ${_MANOPT}")
-        set(NROFF_MANOPT ${_MANOPT})
-        set(NROFF_USEFUL ON)
-        break()
-      endif()
-    endforeach()
-    # No need for the temporary file
-    file(REMOVE "${CMAKE_CURRENT_BINARY_DIR}/nroff-input.txt")
-    if(NOT NROFF_USEFUL)
-      message(WARNING "Found no *nroff option to get plaintext from man pages")
-    endif()
-  else()
-    message(WARNING "Found no *nroff program")
-  endif()
-endmacro()