Initial community commit

Src/external_dependencies/cpr/cmake/FindMbedTLS.cmake

@@ -0,0 +1,14 @@
+# Source: https://github.com/curl/curl/blob/curl-7_82_0/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)

Src/external_dependencies/cpr/cmake/clang-tidy.cmake

@@ -0,0 +1,13 @@
+if (NOT ${CMAKE_SYSTEM_NAME} STREQUAL "Windows")
+    find_program(CLANG_TIDY_EXECUTABLE NAMES clang-tidy)
+    mark_as_advanced(CLANG_TIDY_EXECUTABLE)
+
+    if (${CLANG_TIDY_EXECUTABLE})
+        message(FATAL_ERROR "Clang-tidy not found")
+    else()
+        message(STATUS "Enabling clang-tidy")
+        set(CMAKE_CXX_CLANG_TIDY "${CLANG_TIDY_EXECUTABLE};-warnings-as-errors=*")
+    endif()
+else()
+    message(FATAL_ERROR "Clang-tidy is not supported when building for windows")
+endif()

Src/external_dependencies/cpr/cmake/clear_variable.cmake

@@ -0,0 +1,11 @@
+macro(clear_variable)
+    cmake_parse_arguments(CLEAR_VAR "" "DESTINATION;BACKUP;REPLACE" "" ${ARGN})
+    set(${CLEAR_VAR_BACKUP} ${${CLEAR_VAR_DESTINATION}})
+    set(${CLEAR_VAR_DESTINATION} ${CLEAR_VAR_REPLACE})
+endmacro()
+
+macro(restore_variable)
+    cmake_parse_arguments(CLEAR_VAR "" "DESTINATION;BACKUP" "" ${ARGN})
+    set(${CLEAR_VAR_DESTINATION} ${${CLEAR_VAR_BACKUP}})
+    unset(${CLEAR_VAR_BACKUP})
+endmacro()

Src/external_dependencies/cpr/cmake/code_coverage.cmake

@@ -0,0 +1,29 @@
+# Code coverage
+if(CPR_BUILD_TESTS AND CPR_GENERATE_COVERAGE)
+    set(CMAKE_BUILD_TYPE COVERAGE CACHE INTERNAL "Coverage enabled build")
+    message(STATUS "Enabling gcov support")
+    if(NOT "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+        set(COVERAGE_FLAG "--coverage")
+    endif()
+    set(CMAKE_CXX_FLAGS_COVERAGE
+        "-g -O0 ${COVERAGE_FLAG} -fprofile-arcs -ftest-coverage"
+        CACHE STRING "Flags used by the C++ compiler during coverage builds."
+        FORCE)
+    set(CMAKE_C_FLAGS_COVERAGE
+        "-g -O0 ${COVERAGE_FLAG} -fprofile-arcs -ftest-coverage"
+        CACHE STRING "Flags used by the C compiler during coverage builds."
+        FORCE)
+    set(CMAKE_EXE_LINKER_FLAGS_COVERAGE
+        ""
+        CACHE STRING "Flags used for linking binaries during coverage builds."
+        FORCE)
+    set(CMAKE_SHARED_LINKER_FLAGS_COVERAGE
+        ""
+        CACHE STRING "Flags used by the shared libraries linker during coverage builds."
+        FORCE)
+    mark_as_advanced(
+        CMAKE_CXX_FLAGS_COVERAGE
+        CMAKE_C_FLAGS_COVERAGE
+        CMAKE_EXE_LINKER_FLAGS_COVERAGE
+        CMAKE_SHARED_LINKER_FLAGS_COVERAGE)
+endif()

Src/external_dependencies/cpr/cmake/cppcheck.cmake

@@ -0,0 +1,10 @@
+find_program(CMAKE_CXX_CPPCHECK NAMES cppcheck)
+if(CMAKE_CXX_CPPCHECK)
+    list(APPEND CMAKE_CXX_CPPCHECK 
+        "--error-exitcode=1"
+        "--enable=warning,style"
+        "--force" 
+        "--inline-suppr"
+        "--std=c++${CMAKE_CXX_STANDARD}"
+        "--suppressions-list=${CMAKE_SOURCE_DIR}/CppCheckSuppressions.txt")
+endif()

Src/external_dependencies/cpr/cmake/cprConfig.cmake.in

@@ -0,0 +1,8 @@
+include(CMakeFindDependencyMacro)
+@PACKAGE_INIT@
+
+find_dependency(CURL REQUIRED)
+
+include(${CMAKE_CURRENT_LIST_DIR}/cprTargets.cmake)
+
+check_required_components(cpr)

Src/external_dependencies/cpr/cmake/cprver.h.in

@@ -0,0 +1,30 @@
+#ifndef CPR_CPRVER_H
+#define CPR_CPRVER_H
+
+/**
+ * CPR version as a string.
+ **/
+#define CPR_VERSION "${cpr_VERSION}"
+
+/**
+ * CPR version split up into parts.
+ **/
+#define CPR_VERSION_MAJOR ${cpr_VERSION_MAJOR}
+#define CPR_VERSION_MINOR ${cpr_VERSION_MINOR}
+#define CPR_VERSION_PATCH ${cpr_VERSION_PATCH}
+
+/**
+ * CPR version as a single hex digit.
+ * it can be split up into three parts:
+ * 0xAABBCC
+ * AA: The current CPR major version number in a hex format.
+ * BB: The current CPR minor version number in a hex format.
+ * CC: The current CPR patch version number in a hex format.
+ *
+ * Examples:
+ * '0x010702' -> 01.07.02 -> CPR_VERSION: 1.7.2
+ * '0xA13722' -> A1.37.22 -> CPR_VERSION: 161.55.34
+ **/
+#define CPR_VERSION_NUM ${cpr_VERSION_NUM}
+
+#endif

Src/external_dependencies/cpr/cmake/mongoose.CMakeLists.txt

@@ -0,0 +1,12 @@
+cmake_minimum_required(VERSION 3.15)
+project(mongoose C)
+
+
+add_library(mongoose STATIC mongoose.c)
+target_include_directories(mongoose PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
+
+if(ENABLE_SSL_TESTS)
+    # Enable mongoose SSL
+    target_compile_definitions(mongoose PUBLIC MG_ENABLE_OPENSSL)
+    target_link_libraries(mongoose PRIVATE OpenSSL::SSL)
+endif()

Src/external_dependencies/cpr/cmake/sanitizer.cmake

@@ -0,0 +1,73 @@
+include(CheckCXXCompilerFlag)
+include(CheckCXXSourceRuns)
+
+set(ALLOWED_BUILD_TYPES Debug Release RelWithDebInfo MinSizeRel)
+set(ALL_SAN_FLAGS "")
+
+ # No sanitizers when cross compiling to prevent stuff like this: https://github.com/whoshuu/cpr/issues/582
+if(NOT CMAKE_CROSSCOMPILING)
+    # Thread sanitizer
+    set(THREAD_SAN_FLAGS "-fsanitize=thread")
+    set(PREV_FLAG ${CMAKE_REQUIRED_FLAGS})
+    set(CMAKE_REQUIRED_FLAGS "${THREAD_SAN_FLAGS}")
+    check_cxx_source_runs("int main() { return 0; }" THREAD_SANITIZER_AVAILABLE)
+    set(CMAKE_REQUIRED_FLAGS ${PREV_FLAG})
+    if(THREAD_SANITIZER_AVAILABLE)
+        list(APPEND ALLOWED_BUILD_TYPES ThreadSan)
+        # Do not add Thread sanitizer to all sanitizer because it is incompatible with other sanitizer
+    endif()
+    set(CMAKE_C_FLAGS_THREADSAN "${CMAKE_C_FLAGS_DEBUG} ${THREAD_SAN_FLAGS}" CACHE INTERNAL "Flags used by the C compiler during thread sanitizer builds." FORCE)
+    set(CMAKE_CXX_FLAGS_THREADSAN "${CMAKE_CXX_FLAGS_DEBUG} ${THREAD_SAN_FLAGS}" CACHE INTERNAL "Flags used by the C++ compiler during thread sanitizer builds." FORCE)
+    set(CMAKE_SHARED_LINKER_FLAGS_THREADSAN "${CMAKE_SHARED_LINKER_FLAGS_DEBUG}" CACHE INTERNAL "Flags used for the linker during thread sanitizer builds" FORCE)
+
+    # Address sanitizer
+    set(ADDR_SAN_FLAGS "-fsanitize=address")
+    set(PREV_FLAG ${CMAKE_REQUIRED_FLAGS})
+    set(CMAKE_REQUIRED_FLAGS "${ADDR_SAN_FLAGS}")
+    check_cxx_source_runs("int main() { return 0; }" ADDRESS_SANITIZER_AVAILABLE)
+    set(CMAKE_REQUIRED_FLAGS ${PREV_FLAG})
+    if(ADDRESS_SANITIZER_AVAILABLE)
+        list(APPEND ALLOWED_BUILD_TYPES AddrSan)
+        set(ALL_SAN_FLAGS "${ALL_SAN_FLAGS} ${ADDR_SAN_FLAGS}")
+    endif()
+    set(CMAKE_C_FLAGS_ADDRSAN "${CMAKE_C_FLAGS_DEBUG} ${ADDR_SAN_FLAGS} -fno-omit-frame-pointer -fno-optimize-sibling-calls" CACHE INTERNAL "Flags used by the C compiler during address sanitizer builds." FORCE)
+    set(CMAKE_CXX_FLAGS_ADDRSAN "${CMAKE_CXX_FLAGS_DEBUG} ${ADDR_SAN_FLAGS} -fno-omit-frame-pointer -fno-optimize-sibling-calls" CACHE INTERNAL "Flags used by the C++ compiler during address sanitizer builds." FORCE)
+    set(CMAKE_SHARED_LINKER_FLAGS_ADDRSAN "${CMAKE_SHARED_LINKER_FLAGS_DEBUG}" CACHE INTERNAL "Flags used for the linker during address sanitizer builds" FORCE)
+
+    # Leak sanitizer
+    set(LEAK_SAN_FLAGS "-fsanitize=leak")
+    check_cxx_compiler_flag(${LEAK_SAN_FLAGS} LEAK_SANITIZER_AVAILABLE)
+    if(LEAK_SANITIZER_AVAILABLE)
+        list(APPEND ALLOWED_BUILD_TYPES LeakSan)
+        set(ALL_SAN_FLAGS "${ALL_SAN_FLAGS} ${LEAK_SAN_FLAGS}")
+    endif()
+    set(CMAKE_C_FLAGS_LEAKSAN "${CMAKE_C_FLAGS_DEBUG} ${LEAK_SAN_FLAGS} -fno-omit-frame-pointer" CACHE INTERNAL "Flags used by the C compiler during leak sanitizer builds." FORCE)
+    set(CMAKE_CXX_FLAGS_LEAKSAN "${CMAKE_CXX_FLAGS_DEBUG} ${LEAK_SAN_FLAGS} -fno-omit-frame-pointer" CACHE INTERNAL "Flags used by the C++ compiler during leak sanitizer builds." FORCE)
+    set(CMAKE_SHARED_LINKER_FLAGS_LEAKSAN "${CMAKE_SHARED_LINKER_FLAGS_DEBUG}" CACHE INTERNAL "Flags used for the linker during leak sanitizer builds" FORCE)
+
+    # Undefined behavior sanitizer
+    set(UDEF_SAN_FLAGS "-fsanitize=undefined")
+    check_cxx_compiler_flag(${UDEF_SAN_FLAGS} UNDEFINED_BEHAVIOUR_SANITIZER_AVAILABLE)
+    if(UNDEFINED_BEHAVIOUR_SANITIZER_AVAILABLE)
+        list(APPEND ALLOWED_BUILD_TYPES UdefSan)
+        set(ALL_SAN_FLAGS "${ALL_SAN_FLAGS} ${UDEF_SAN_FLAGS}")
+    endif()
+    set(CMAKE_C_FLAGS_UDEFSAN "${CMAKE_C_FLAGS_DEBUG} ${UDEF_SAN_FLAGS}" CACHE INTERNAL "Flags used by the C compiler during undefined behaviour sanitizer builds." FORCE)
+    set(CMAKE_CXX_FLAGS_UDEFSAN "${CMAKE_CXX_FLAGS_DEBUG} ${UDEF_SAN_FLAGS}" CACHE INTERNAL "Flags used by the C++ compiler during undefined behaviour sanitizer builds." FORCE)
+    set(CMAKE_SHARED_LINKER_FLAGS_UDEFSAN "${CMAKE_SHARED_LINKER_FLAGS_DEBUG}" CACHE INTERNAL "Flags used for the linker during undefined behaviour sanitizer builds" FORCE)
+
+    # All sanitizer (without thread sanitizer)
+    if(NOT ALL_SAN_FLAGS STREQUAL "")
+        set(PREV_FLAG ${CMAKE_REQUIRED_FLAGS})
+        set(CMAKE_REQUIRED_FLAGS "${ALL_SAN_FLAGS}")
+        check_cxx_source_runs("int main() { return 0; }" ALL_SANITIZERS_AVAILABLE)
+        set(CMAKE_REQUIRED_FLAGS ${PREV_FLAG})
+        if(ALL_SANITIZERS_AVAILABLE)
+            list(APPEND ALLOWED_BUILD_TYPES AllSan)
+        endif()
+    endif()
+
+    set(CMAKE_C_FLAGS_ALLSAN "${CMAKE_C_FLAGS_DEBUG} ${ALL_SAN_FLAGS} -fno-omit-frame-pointer -fno-optimize-sibling-calls" CACHE INTERNAL "Flags used by the C compiler during most possible sanitizer builds." FORCE)
+    set(CMAKE_CXX_FLAGS_ALLSAN "${CMAKE_CXX_FLAGS_DEBUG} ${ALL_SAN_FLAGS} -fno-omit-frame-pointer -fno-optimize-sibling-calls" CACHE INTERNAL "Flags used by the C++ compiler during most possible sanitizer builds." FORCE)
+    set(CMAKE_SHARED_LINKER_FLAGS_ALLSAN "${CMAKE_SHARED_LINKER_FLAGS_DEBUG}" CACHE INTERNAL "Flags used for the linker during most possible sanitizer builds" FORCE)
+endif()

Src/external_dependencies/cpr/cmake/zlib_external.cmake

@@ -0,0 +1,22 @@
+# ZLIB
+
+# Fix Windows missing "zlib.dll":
+if(WIN32 AND (${CMAKE_PROJECT_NAME} STREQUAL ${PROJECT_NAME}))
+    set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${EXECUTABLE_OUTPUT_PATH}/$<CONFIG> CACHE INTERNAL "" FORCE)
+endif()
+
+set(ZLIB_COMPAT ON CACHE INTERNAL "" FORCE)
+set(ZLIB_ENABLE_TESTS OFF CACHE INTERNAL "" FORCE)
+
+FetchContent_Declare(zlib
+                    GIT_REPOSITORY https://github.com/zlib-ng/zlib-ng
+                    GIT_TAG 2.0.6
+                    USES_TERMINAL_DOWNLOAD TRUE)
+FetchContent_MakeAvailable(zlib)
+
+# Fix Windows zlib dll names from "zlibd1.dll" to "zlib.dll":
+if(WIN32)
+    set_target_properties(zlib PROPERTIES OUTPUT_NAME "zlib")
+    set_target_properties(zlib PROPERTIES DEBUG_POSTFIX "")
+    set_target_properties(zlib PROPERTIES SUFFIX ".dll")
+endif()