added proxy endpoint and proxy storage endpoint into dev menu

CMakeLists.txt

@@ -1,36 +1,7 @@
 cmake_minimum_required(VERSION 3.25.0 FATAL_ERROR)
 
 set(PROJECT AmneziaVPN)
-set(AMNEZIAVPN_VERSION 4.8.13.1)
-
-include(cmake/conan_bootstrap.cmake)
-set(CMAKE_PROJECT_TOP_LEVEL_INCLUDES ${CMAKE_SOURCE_DIR}/cmake/conan_provider.cmake)
-
-if(APPLE)
-    get_property(generator_is_multi_config GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
-    if (generator_is_multi_config)
-        set(CONAN_INSTALL_BUILD_CONFIGURATIONS Release Debug MinSizeRel RelWithDebInfo)
-    endif()
-    if(CMAKE_SYSTEM_NAME STREQUAL "iOS")
-        set(CMAKE_OSX_DEPLOYMENT_TARGET "14.0" CACHE STRING "" FORCE)
-        set(CMAKE_OSX_ARCHITECTURES "arm64" CACHE STRING "" FORCE)
-    elseif(MACOS_NE)
-        set(CONAN_INSTALL_ARGS "--build=missing;-o=&:macos_ne=True" CACHE STRING "" FORCE)
-        set(CMAKE_OSX_DEPLOYMENT_TARGET "13.0" CACHE STRING "" FORCE)
-        set(CMAKE_OSX_ARCHITECTURES "arm64;x86_64" CACHE STRING "" FORCE)
-    else()
-        set(CMAKE_OSX_DEPLOYMENT_TARGET "13.0" CACHE STRING "" FORCE)
-        set(CMAKE_OSX_ARCHITECTURES "x86_64" CACHE STRING "" FORCE)
-    endif()
-endif()
-
-if(ANDROID)
-    set(CONAN_INSTALL_ARGS
-        "--build=missing"
-        "-o=*:page_16k=True"
-        "-e=*:LDFLAGS=-Wl,-z,max-page-size=16384"
-        CACHE STRING "" FORCE)
-endif()
+set(AMNEZIAVPN_VERSION 4.8.13.0)
 
 project(${PROJECT} VERSION ${AMNEZIAVPN_VERSION}
         DESCRIPTION "AmneziaVPN"
@@ -41,7 +12,7 @@ string(TIMESTAMP CURRENT_DATE "%Y-%m-%d")
 set(RELEASE_DATE "${CURRENT_DATE}")
 
 set(APP_MAJOR_VERSION ${CMAKE_PROJECT_VERSION_MAJOR}.${CMAKE_PROJECT_VERSION_MINOR}.${CMAKE_PROJECT_VERSION_PATCH})
-set(APP_ANDROID_VERSION_CODE 2107)
+set(APP_ANDROID_VERSION_CODE 2106)
 
 if(${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
     set(MZ_PLATFORM_NAME "linux")
@@ -61,6 +32,16 @@ set(QT_BUILD_TOOLS_WHEN_CROSS_COMPILING ON)
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
+if(APPLE)
+    if(IOS)
+        set(CMAKE_OSX_ARCHITECTURES "arm64")
+    elseif(MACOS_NE)
+        set(CMAKE_OSX_ARCHITECTURES "arm64;x86_64")
+    else()
+        set(CMAKE_OSX_ARCHITECTURES "x86_64")
+    endif()
+endif()
+
 add_subdirectory(client)
 
 if(NOT IOS AND NOT ANDROID AND NOT MACOS_NE)
@@ -80,7 +61,6 @@ if(WIN32 AND NOT IOS AND NOT ANDROID AND NOT MACOS_NE)
     set(CPACK_PACKAGE_VENDOR "AmneziaVPN")
     set(CPACK_PACKAGE_VERSION ${AMNEZIAVPN_VERSION})
     set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "AmneziaVPN client")
-    set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_SOURCE_DIR}/LICENSE")
     set(CPACK_PACKAGE_INSTALL_DIRECTORY "AmneziaVPN")
     set(CPACK_PACKAGE_DIRECTORY "${CMAKE_BINARY_DIR}")
     set(CPACK_PACKAGE_EXECUTABLES "AmneziaVPN" "AmneziaVPN")

client/CMakeLists.txt

@@ -51,13 +51,6 @@ if(WIN32 OR (APPLE AND NOT IOS) OR (LINUX AND NOT ANDROID))
 endif()
 
 qt_standard_project_setup()
-
-# 16KB page size support for Android 15+ / Google Play
-# Must be set before any targets are defined so it applies to all compiled-from-source libraries
-if(ANDROID)
-    add_link_options("-Wl,-z,max-page-size=16384")
-endif()
-
 qt_add_executable(${PROJECT} MANUAL_FINALIZATION)
 target_include_directories(${PROJECT} PUBLIC
     $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}>
@@ -224,6 +217,13 @@ if(NOT IOS AND NOT ANDROID AND NOT MACOS_NE)
         $<TARGET_FILE_DIR:${PROJECT}>
         COMMAND_EXPAND_LISTS
     )
+    add_custom_command(
+        TARGET ${PROJECT} POST_BUILD
+        COMMAND ${CMAKE_COMMAND} -E $<IF:$<CONFIG:Debug>,copy_directory,true>
+        ${CMAKE_SOURCE_DIR}/client/3rd-prebuilt/deploy-prebuilt/${DEPLOY_PLATFORM_PATH}
+        $<TARGET_FILE_DIR:${PROJECT}>
+        COMMAND_EXPAND_LISTS
+    )
 endif()
 
 target_sources(${PROJECT} PRIVATE ${SOURCES} ${HEADERS} ${RESOURCES} ${QRC} ${I18NQRC})

client/android/gradle/libs.versions.toml

@@ -1,11 +1,11 @@
 [versions]
-agp = "8.6.1"
+agp = "8.5.2"
 kotlin = "1.9.24"
 androidx-core = "1.13.1"
 androidx-activity = "1.9.1"
 androidx-annotation = "1.8.2"
 androidx-biometric = "1.2.0-alpha05"
-androidx-camera = "1.5.3"
+androidx-camera = "1.3.4"
 androidx-fragment = "1.8.2"
 androidx-security-crypto = "1.1.0-alpha06"
 androidx-datastore = "1.1.1"

client/android/src/org/amnezia/vpn/AmneziaActivity.kt

@@ -203,7 +203,10 @@ class AmneziaActivity : QtActivity() {
 
     private fun loadLibs() {
         listOf(
-            "rsapss"
+            "rsapss",
+            "crypto_3",
+            "ssl_3",
+            "ssh"
         ).forEach {
             loadSharedLibrary(this.applicationContext, it)
         }

client/cmake/3rdparty.cmake

@@ -8,6 +8,76 @@ include(${CLIENT_ROOT_DIR}/cmake/QSimpleCrypto.cmake)
 
 include(${CLIENT_ROOT_DIR}/3rd/qrcodegen/qrcodegen.cmake)
 
+set(LIBSSH_ROOT_DIR "${CLIENT_ROOT_DIR}/3rd-prebuilt/3rd-prebuilt/libssh/")
+set(OPENSSL_ROOT_DIR "${CLIENT_ROOT_DIR}/3rd-prebuilt/3rd-prebuilt/openssl/")
+
+set(OPENSSL_LIBRARIES_DIR "${OPENSSL_ROOT_DIR}/lib")
+
+if(WIN32)
+    set(OPENSSL_INCLUDE_DIR "${OPENSSL_ROOT_DIR}/windows/include")
+    if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "8")
+        set(LIBSSH_LIB_PATH "${LIBSSH_ROOT_DIR}/windows/x86_64/ssh.lib")
+        set(LIBSSH_INCLUDE_DIR "${LIBSSH_ROOT_DIR}/windows/x86_64")
+        set(OPENSSL_LIB_SSL_PATH "${OPENSSL_ROOT_DIR}/windows/win64/libssl.lib")
+        set(OPENSSL_LIB_CRYPTO_PATH "${OPENSSL_ROOT_DIR}/windows/win64/libcrypto.lib")
+    else()
+        set(LIBSSH_LIB_PATH "${LIBSSH_ROOT_DIR}/windows/x86/ssh.lib")
+        set(LIBSSH_INCLUDE_DIR "${LIBSSH_ROOT_DIR}/windows/x86")
+        set(OPENSSL_LIB_SSL_PATH "${OPENSSL_ROOT_DIR}/windows/win32/libssl.lib")
+        set(OPENSSL_LIB_CRYPTO_PATH "${OPENSSL_ROOT_DIR}/windows/win32/libcrypto.lib")
+    endif()
+elseif(APPLE AND NOT IOS)
+    if(MACOS_NE)
+        set(LIBSSH_LIB_PATH "${LIBSSH_ROOT_DIR}/macos/universal2/libssh.a")
+        set(ZLIB_LIB_PATH "${LIBSSH_ROOT_DIR}/macos/universal2/libz.a")
+        set(LIBSSH_INCLUDE_DIR "${LIBSSH_ROOT_DIR}/macos/universal2")
+    else()
+        set(LIBSSH_LIB_PATH "${LIBSSH_ROOT_DIR}/macos/x86_64/libssh.a")
+        set(ZLIB_LIB_PATH "${LIBSSH_ROOT_DIR}/macos/x86_64/libz.a")
+        set(LIBSSH_INCLUDE_DIR "${LIBSSH_ROOT_DIR}/macos/x86_64")
+    endif()
+    set(OPENSSL_INCLUDE_DIR "${OPENSSL_ROOT_DIR}/macos/include")
+    set(OPENSSL_LIB_SSL_PATH "${OPENSSL_ROOT_DIR}/macos/lib/libssl.a")
+    set(OPENSSL_LIB_CRYPTO_PATH "${OPENSSL_ROOT_DIR}/macos/lib/libcrypto.a")    
+elseif(IOS)
+    set(LIBSSH_INCLUDE_DIR "${LIBSSH_ROOT_DIR}/ios/arm64")
+    set(LIBSSH_LIB_PATH "${LIBSSH_ROOT_DIR}/ios/arm64/libssh.a")
+    set(ZLIB_LIB_PATH "${LIBSSH_ROOT_DIR}/ios/arm64/libz.a")
+    set(OPENSSL_INCLUDE_DIR "${OPENSSL_ROOT_DIR}/ios/iphone/include")
+    set(OPENSSL_LIB_SSL_PATH "${OPENSSL_ROOT_DIR}/ios/iphone/lib/libssl.a")
+    set(OPENSSL_LIB_CRYPTO_PATH "${OPENSSL_ROOT_DIR}/ios/iphone/lib/libcrypto.a")
+elseif(ANDROID)
+    set(abi ${CMAKE_ANDROID_ARCH_ABI})
+    set(LIBSSH_INCLUDE_DIR "${LIBSSH_ROOT_DIR}/android/${abi}")
+    set(LIBSSH_LIB_PATH "${LIBSSH_ROOT_DIR}/android/${abi}/libssh.so")
+    set(OPENSSL_INCLUDE_DIR "${OPENSSL_ROOT_DIR}/android/include")
+    set(OPENSSL_LIB_SSL_PATH "${OPENSSL_ROOT_DIR}/android/${abi}/libssl.a")
+    set(OPENSSL_LIB_CRYPTO_PATH "${OPENSSL_ROOT_DIR}/android/${abi}/libcrypto.a")
+    set(OPENSSL_LIBRARIES_DIR "${OPENSSL_ROOT_DIR}/android/${abi}")
+elseif(LINUX)
+    set(LIBSSH_INCLUDE_DIR "${LIBSSH_ROOT_DIR}/linux/x86_64")
+    set(ZLIB_LIB_PATH "${LIBSSH_ROOT_DIR}/linux/x86_64/libz.a")
+    set(LIBSSH_LIB_PATH "${LIBSSH_ROOT_DIR}/linux/x86_64/libssh.a")
+    set(OPENSSL_INCLUDE_DIR "${OPENSSL_ROOT_DIR}/linux/include")
+    set(OPENSSL_LIB_SSL_PATH "${OPENSSL_ROOT_DIR}/linux/x86_64/libssl.a")
+    set(OPENSSL_LIB_CRYPTO_PATH "${OPENSSL_ROOT_DIR}/linux/x86_64/libcrypto.a")
+endif()
+
+file(COPY ${OPENSSL_LIB_SSL_PATH} ${OPENSSL_LIB_CRYPTO_PATH}
+        DESTINATION ${OPENSSL_LIBRARIES_DIR})
+
+set(OPENSSL_USE_STATIC_LIBS TRUE)
+  
+set(LIBS ${LIBS} 
+    ${LIBSSH_LIB_PATH} 
+    ${ZLIB_LIB_PATH}
+)
+  
+set(LIBS ${LIBS}
+    ${OPENSSL_LIB_SSL_PATH}
+    ${OPENSSL_LIB_CRYPTO_PATH}
+)
+
 add_compile_definitions(_WINSOCKAPI_)
 
 set(BUILD_SHARED_LIBS OFF CACHE BOOL "" FORCE)
@@ -36,20 +106,12 @@ endif()
 set(LIBS ${LIBS} qt6keychain)
 
 include_directories(
+    ${OPENSSL_INCLUDE_DIR}
+    ${LIBSSH_INCLUDE_DIR}/include
+    ${LIBSSH_ROOT_DIR}/include
+    ${CLIENT_ROOT_DIR}/3rd/libssh/include
     ${CLIENT_ROOT_DIR}/3rd/QSimpleCrypto/src/include
     ${CLIENT_ROOT_DIR}/3rd/qtkeychain/qtkeychain
     ${CMAKE_CURRENT_BINARY_DIR}/3rd/qtkeychain
+    ${CMAKE_CURRENT_BINARY_DIR}/3rd/libssh/include
 )
-
-if(ANDROID)
-    find_package(android-openssl REQUIRED)
-    # CMakeConfigDeps doesn't propagate include dirs onto IMPORTED targets;
-    # use the legacy variable that IS correctly populated by the config file.
-    include_directories(${android-openssl_INCLUDE_DIRS})
-else()
-    find_package(openssl REQUIRED)
-endif()
-list(APPEND LIBS OpenSSL::SSL OpenSSL::Crypto)
-
-find_package(libssh REQUIRED)
-list(APPEND LIBS ssh::ssh)

client/cmake/android.cmake

@@ -42,14 +42,18 @@ set(SOURCES ${SOURCES}
     ${CMAKE_CURRENT_SOURCE_DIR}/core/installedAppsImageProvider.cpp
 )
 
+foreach(abi IN ITEMS ${QT_ANDROID_ABIS})
+    set_property(TARGET ${PROJECT} PROPERTY QT_ANDROID_EXTRA_LIBS
+        ${CMAKE_CURRENT_SOURCE_DIR}/3rd-prebuilt/3rd-prebuilt/amneziawg/android/${abi}/libwg-go.so
+        ${CMAKE_CURRENT_SOURCE_DIR}/3rd-prebuilt/3rd-prebuilt/openvpn/android/${abi}/libck-ovpn-plugin.so
+        ${CMAKE_CURRENT_SOURCE_DIR}/3rd-prebuilt/3rd-prebuilt/openvpn/android/${abi}/libovpn3.so
+        ${CMAKE_CURRENT_SOURCE_DIR}/3rd-prebuilt/3rd-prebuilt/openvpn/android/${abi}/libovpnutil.so
+        ${CMAKE_CURRENT_SOURCE_DIR}/3rd-prebuilt/3rd-prebuilt/openvpn/android/${abi}/librsapss.so
+        ${CMAKE_CURRENT_SOURCE_DIR}/3rd-prebuilt/3rd-prebuilt/openssl/android/${abi}/libcrypto_3.so
+        ${CMAKE_CURRENT_SOURCE_DIR}/3rd-prebuilt/3rd-prebuilt/openssl/android/${abi}/libssl_3.so
+        ${CMAKE_CURRENT_SOURCE_DIR}/3rd-prebuilt/3rd-prebuilt/libssh/android/${abi}/libssh.so
+    )
+endforeach()
 
-find_package(awg-android REQUIRED)
-set(LIBS ${LIBS} amnezia::awg-android)
-set_property(TARGET ${PROJECT} APPEND PROPERTY QT_ANDROID_EXTRA_LIBS ${AMNEZIA_ANDROID_LIBWG_PATH} ${AMNEZIA_ANDROID_LIBWG_QUICK_PATH})
-
-find_package(amnezia-libxray REQUIRED)
-file(COPY ${AMNEZIA_LIBXRAY_PATH} DESTINATION ${CMAKE_CURRENT_SOURCE_DIR}/android/xray/libXray)
-
-find_package(openvpn-pt-android REQUIRED)
-set(LIBS ${LIBS} amnezia::openvpn-pt-android)
-set_property(TARGET ${PROJECT} APPEND PROPERTY QT_ANDROID_EXTRA_LIBS ${OPENVPN_PT_ANDROID_LIBCK_OVPN_PLUGIN_PATH})
+file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/3rd-prebuilt/3rd-prebuilt/xray/android/libxray.aar
+        DESTINATION ${CMAKE_CURRENT_SOURCE_DIR}/android/xray/libXray)

client/cmake/ios.cmake

@@ -1,6 +1,8 @@
 message("Client iOS build")
+set(CMAKE_OSX_DEPLOYMENT_TARGET 13.0)
 set(APPLE_PROJECT_VERSION ${CMAKE_PROJECT_VERSION_MAJOR}.${CMAKE_PROJECT_VERSION_MINOR}.${CMAKE_PROJECT_VERSION_PATCH})
 
+
 enable_language(OBJC)
 enable_language(OBJCXX)
 enable_language(Swift)
@@ -135,3 +137,11 @@ set_property(TARGET ${PROJECT} APPEND PROPERTY RESOURCE
 
 add_subdirectory(ios/networkextension)
 add_dependencies(${PROJECT} networkextension)
+
+set_property(TARGET ${PROJECT} PROPERTY XCODE_EMBED_FRAMEWORKS
+    "${CMAKE_CURRENT_SOURCE_DIR}/3rd-prebuilt/3rd-prebuilt/openvpn/apple/OpenVPNAdapter-ios/OpenVPNAdapter.framework"
+)
+
+set(CMAKE_XCODE_ATTRIBUTE_FRAMEWORK_SEARCH_PATHS ${CMAKE_CURRENT_SOURCE_DIR}/3rd-prebuilt/3rd-prebuilt/openvpn/apple/OpenVPNAdapter-ios/)
+target_link_libraries("networkextension" PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/3rd-prebuilt/3rd-prebuilt/openvpn/apple/OpenVPNAdapter-ios/OpenVPNAdapter.framework")
+

client/cmake/macos.cmake

@@ -23,6 +23,9 @@ set_target_properties(${PROJECT} PROPERTIES
     MACOSX_BUNDLE_SHORT_VERSION_STRING "${CMAKE_PROJECT_VERSION_MAJOR}.${CMAKE_PROJECT_VERSION_MINOR}.${CMAKE_PROJECT_VERSION_PATCH}"
     MACOSX_BUNDLE_BUNDLE_VERSION "${CMAKE_PROJECT_VERSION_TWEAK}"
 )
+set(CMAKE_OSX_ARCHITECTURES "x86_64" CACHE INTERNAL "" FORCE)
+set(CMAKE_OSX_DEPLOYMENT_TARGET 10.15)
+
 
 set(HEADERS ${HEADERS}
     ${CMAKE_CURRENT_SOURCE_DIR}/ui/macos_util.h

client/cmake/macos_ne.cmake

@@ -1,6 +1,7 @@
 message("Client ==> MacOS NE build")
 
 set_target_properties(${PROJECT} PROPERTIES MACOSX_BUNDLE TRUE)
+set(CMAKE_OSX_DEPLOYMENT_TARGET 10.15)
 
 set(APPLE_PROJECT_VERSION ${CMAKE_PROJECT_VERSION_MAJOR}.${CMAKE_PROJECT_VERSION_MINOR}.${CMAKE_PROJECT_VERSION_PATCH})
 
@@ -151,6 +152,19 @@ message(${QtCore_location})
 
 get_filename_component(QT_BIN_DIR_DETECTED "${QtCore_location}/../../../../../bin" ABSOLUTE)
 
-add_custom_command(TARGET ${PROJECT} POST_BUILD
-    COMMAND ${QT_BIN_DIR_DETECTED}/macdeployqt $<TARGET_BUNDLE_DIR:AmneziaVPN> -appstore-compliant -qmldir=${CMAKE_CURRENT_SOURCE_DIR}
+set_property(TARGET ${PROJECT} PROPERTY XCODE_EMBED_FRAMEWORKS
+    "${CMAKE_CURRENT_SOURCE_DIR}/3rd-prebuilt/3rd-prebuilt/openvpn/apple/OpenVPNAdapter-macos/OpenVPNAdapter.framework"
+)
+
+set(CMAKE_XCODE_ATTRIBUTE_FRAMEWORK_SEARCH_PATHS ${CMAKE_CURRENT_SOURCE_DIR}/3rd-prebuilt/3rd-prebuilt/openvpn/apple/OpenVPNAdapter-macos)
+target_link_libraries("AmneziaVPNNetworkExtension" PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/3rd-prebuilt/3rd-prebuilt/openvpn/apple/OpenVPNAdapter-macos/OpenVPNAdapter.framework")
+
+add_custom_command(TARGET ${PROJECT} POST_BUILD
+    COMMAND ${CMAKE_COMMAND} -E make_directory
+            $<TARGET_BUNDLE_DIR:AmneziaVPN>/Contents/Frameworks
+    COMMAND /usr/bin/find "$<TARGET_BUNDLE_DIR:AmneziaVPN>/Contents/Frameworks/OpenVPNAdapter.framework" -name "*.sha256" -delete
+    COMMAND /usr/bin/codesign --force --sign "Apple Distribution"
+            "$<TARGET_BUNDLE_DIR:AmneziaVPN>/Contents/Frameworks/OpenVPNAdapter.framework/Versions/Current/OpenVPNAdapter"
+    COMMAND ${QT_BIN_DIR_DETECTED}/macdeployqt $<TARGET_BUNDLE_DIR:AmneziaVPN> -appstore-compliant -qmldir=${CMAKE_CURRENT_SOURCE_DIR}
+    COMMENT "Signing OpenVPNAdapter framework"
 )

client/core/controllers/gatewayController.cpp

@@ -46,12 +46,25 @@ namespace
     constexpr int httpStatusCodeConflict = 409;
 
     constexpr int httpStatusCodeNotImplemented = 501;
+
+    QStringList splitUrls(const QString &urls)
+    {
+        QStringList parsedUrls = urls.split(",", Qt::SkipEmptyParts);
+        for (QString &url : parsedUrls) {
+            url = url.trimmed();
+        }
+        parsedUrls.removeAll("");
+        return parsedUrls;
+    }
 }
 
 GatewayController::GatewayController(const QString &gatewayEndpoint, const bool isDevEnvironment, const int requestTimeoutMsecs,
-                                     const bool isStrictKillSwitchEnabled, QObject *parent)
+                                     const bool isStrictKillSwitchEnabled, const QString &proxyStorageOverride,
+                                     const QString &proxyUrlOverride, QObject *parent)
     : QObject(parent),
       m_gatewayEndpoint(gatewayEndpoint),
+      m_proxyStorageOverride(proxyStorageOverride),
+      m_proxyUrlOverride(proxyUrlOverride),
       m_isDevEnvironment(isDevEnvironment),
       m_requestTimeoutMsecs(requestTimeoutMsecs),
       m_isStrictKillSwitchEnabled(isStrictKillSwitchEnabled)
@@ -71,7 +84,8 @@ GatewayController::EncryptedRequestData GatewayController::prepareRequest(const
     encRequestData.request.setTransferTimeout(m_requestTimeoutMsecs);
     encRequestData.request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
     encRequestData.request.setRawHeader(QString("X-Client-Request-ID").toUtf8(), QUuid::createUuid().toString(QUuid::WithoutBraces).toUtf8());
-    encRequestData.request.setUrl(endpoint.arg(m_proxyUrl.isEmpty() ? m_gatewayEndpoint : m_proxyUrl));
+    QString selectedProxyUrl = m_proxyUrlOverride.isEmpty() ? m_proxyUrl : m_proxyUrlOverride;
+    encRequestData.request.setUrl(endpoint.arg(selectedProxyUrl.isEmpty() ? m_gatewayEndpoint : selectedProxyUrl));
 
     // bypass killSwitch exceptions for API-gateway
 #ifdef AMNEZIA_DESKTOP
@@ -283,9 +297,9 @@ QFuture<QPair<ErrorCode, QByteArray>> GatewayController::postAsync(const QString
 
             QStringList baseUrls;
             if (m_isDevEnvironment) {
-                baseUrls = QString(DEV_S3_ENDPOINT).split(", ");
+                baseUrls = m_proxyStorageOverride.isEmpty() ? splitUrls(DEV_S3_ENDPOINT) : splitUrls(m_proxyStorageOverride);
             } else {
-                baseUrls = QString(PROD_S3_ENDPOINT).split(", ");
+                baseUrls = splitUrls(PROD_S3_ENDPOINT);
             }
 
             QStringList proxyStorageUrls;
@@ -333,9 +347,9 @@ QStringList GatewayController::getProxyUrls(const QString &serviceType, const QS
 
     QStringList baseUrls;
     if (m_isDevEnvironment) {
-        baseUrls = QString(DEV_S3_ENDPOINT).split(", ");
+        baseUrls = m_proxyStorageOverride.isEmpty() ? splitUrls(DEV_S3_ENDPOINT) : splitUrls(m_proxyStorageOverride);
     } else {
-        baseUrls = QString(PROD_S3_ENDPOINT).split(", ");
+        baseUrls = splitUrls(PROD_S3_ENDPOINT);
     }
 
     QByteArray key = m_isDevEnvironment ? DEV_AGW_PUBLIC_KEY : PROD_AGW_PUBLIC_KEY;
@@ -484,7 +498,9 @@ void GatewayController::bypassProxy(const QString &endpoint, const QString &serv
         return result;
     };
 
-    if (m_proxyUrl.isEmpty()) {
+    QString selectedProxyUrl = m_proxyUrlOverride.isEmpty() ? m_proxyUrl : m_proxyUrlOverride;
+
+    if (selectedProxyUrl.isEmpty()) {
         QNetworkRequest request;
         request.setTransferTimeout(1000);
         request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
@@ -506,6 +522,7 @@ void GatewayController::bypassProxy(const QString &endpoint, const QString &serv
 
                 m_proxyUrl = proxyUrl;
                 if (!m_proxyUrl.isEmpty()) {
+                    selectedProxyUrl = m_proxyUrl;
                     break;
                 }
             } else {
@@ -514,8 +531,8 @@ void GatewayController::bypassProxy(const QString &endpoint, const QString &serv
         }
     }
 
-    if (!m_proxyUrl.isEmpty()) {
-        if (bypassFunction(endpoint, m_proxyUrl, requestFunction, replyProcessingFunction)) {
+    if (!selectedProxyUrl.isEmpty()) {
+        if (bypassFunction(endpoint, selectedProxyUrl, requestFunction, replyProcessingFunction)) {
             return;
         }
     }
@@ -601,6 +618,11 @@ void GatewayController::getProxyUrlsAsync(const QStringList proxyStorageUrls, co
 void GatewayController::getProxyUrlAsync(const QStringList proxyUrls, const int currentProxyIndex,
                                          std::function<void(const QString &)> onComplete)
 {
+    if (!m_proxyUrlOverride.isEmpty()) {
+        onComplete(m_proxyUrlOverride);
+        return;
+    }
+
     if (currentProxyIndex >= proxyUrls.size()) {
         onComplete("");
         return;

client/core/controllers/gatewayController.h

@@ -20,7 +20,8 @@ class GatewayController : public QObject
 
 public:
     explicit GatewayController(const QString &gatewayEndpoint, const bool isDevEnvironment, const int requestTimeoutMsecs,
-                               const bool isStrictKillSwitchEnabled, QObject *parent = nullptr);
+                               const bool isStrictKillSwitchEnabled, const QString &proxyStorageOverride = "",
+                               const QString &proxyUrlOverride = "", QObject *parent = nullptr);
 
     amnezia::ErrorCode post(const QString &endpoint, const QJsonObject apiPayload, QByteArray &responseBody);
     QFuture<QPair<amnezia::ErrorCode, QByteArray>> postAsync(const QString &endpoint, const QJsonObject apiPayload);
@@ -61,6 +62,8 @@ private:
 
     int m_requestTimeoutMsecs;
     QString m_gatewayEndpoint;
+    QString m_proxyStorageOverride;
+    QString m_proxyUrlOverride;
     bool m_isDevEnvironment = false;
     bool m_isStrictKillSwitchEnabled = false;
 

client/ios/networkextension/CMakeLists.txt

@@ -110,14 +110,21 @@ set_property(TARGET networkextension APPEND PROPERTY RESOURCE
     ${CMAKE_CURRENT_SOURCE_DIR}/PrivacyInfo.xcprivacy
 )
 
+## Build wireguard-go-version.h
+execute_process(
+    COMMAND go list -m golang.zx2c4.com/wireguard
+    WORKING_DIRECTORY ${CLIENT_ROOT_DIR}/3rd/wireguard-apple/Sources/WireGuardKitGo
+    OUTPUT_VARIABLE WG_VERSION_FULL
+)
+string(REGEX REPLACE ".*v\([0-9.]*\).*" "\\1" WG_VERSION_STRING 1.1.1)
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/wireguard-go-version.h.in
+               ${CMAKE_CURRENT_BINARY_DIR}/wireguard-go-version.h)
+target_sources(networkextension PRIVATE
+    ${CMAKE_CURRENT_BINARY_DIR}/wireguard-go-version.h)
+
 target_include_directories(networkextension PRIVATE ${CLIENT_ROOT_DIR})
 target_include_directories(networkextension PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
 
-find_package(openvpnadapter REQUIRED)
-target_link_libraries(networkextension PRIVATE amnezia::openvpnadapter)
+target_link_libraries(networkextension PRIVATE ${CLIENT_ROOT_DIR}/3rd-prebuilt/3rd-prebuilt/wireguard/ios/arm64/libwg-go.a)
 
-find_package(awg-apple REQUIRED)
-target_link_libraries(networkextension PRIVATE amnezia::awg-apple)
-
-find_package(hev-socks5-tunnel REQUIRED)
-target_link_libraries(networkextension PRIVATE heiher::hev-socks5-tunnel)
+target_link_libraries(networkextension PRIVATE ${CLIENT_ROOT_DIR}/3rd-prebuilt/3rd-prebuilt/xray/HevSocks5Tunnel.xcframework)

client/ios/networkextension/wireguard-go-version.h.in

@@ -0,0 +1,3 @@
+#ifndef WIREGUARD_GO_VERSION
+#define WIREGUARD_GO_VERSION "@WG_VERSION_STRING@"
+#endif // WIREGUARD_GO_VERSION

client/macos/networkextension/CMakeLists.txt

@@ -114,14 +114,25 @@ set_property(TARGET AmneziaVPNNetworkExtension APPEND PROPERTY RESOURCE
     ${CMAKE_CURRENT_SOURCE_DIR}/PrivacyInfo.xcprivacy
 )
 
+## Build wireguard-go-version.h
+execute_process(
+    COMMAND go list -m golang.zx2c4.com/wireguard
+    WORKING_DIRECTORY ${CLIENT_ROOT_DIR}/3rd/wireguard-apple/Sources/WireGuardKitGo
+    OUTPUT_VARIABLE WG_VERSION_FULL
+)
+string(REGEX REPLACE ".*v\([0-9.]*\).*" "\\1" WG_VERSION_STRING 1.1.1)
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/wireguard-go-version.h.in
+               ${CMAKE_CURRENT_BINARY_DIR}/wireguard-go-version.h)
+target_sources(AmneziaVPNNetworkExtension PRIVATE
+    ${CMAKE_CURRENT_BINARY_DIR}/wireguard-go-version.h)
+
 target_include_directories(AmneziaVPNNetworkExtension PRIVATE ${CLIENT_ROOT_DIR})
 target_include_directories(AmneziaVPNNetworkExtension PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
 
-find_package(openvpnadapter REQUIRED)
-target_link_libraries(AmneziaVPNNetworkExtension PRIVATE amnezia::openvpnadapter)
+target_link_libraries(AmneziaVPNNetworkExtension PRIVATE ${CLIENT_ROOT_DIR}/3rd-prebuilt/3rd-prebuilt/wireguard/macos/universal2/libwg-go.a)
 
-find_package(awg-apple REQUIRED)
-target_link_libraries(AmneziaVPNNetworkExtension PRIVATE amnezia::awg-apple)
+message(${CLIENT_ROOT_DIR})
+message(${CLIENT_ROOT_DIR}/3rd-prebuilt/3rd-prebuilt/xray/HevSocks5Tunnel.xcframework/macos-arm64_x86_64/libhev-socks5-tunnel.a)
+target_link_libraries(AmneziaVPNNetworkExtension PRIVATE ${CLIENT_ROOT_DIR}/3rd-prebuilt/3rd-prebuilt/xray/HevSocks5Tunnel.xcframework/macos-arm64_x86_64/libhev-socks5-tunnel.a)
 
-find_package(hev-socks5-tunnel REQUIRED)
-target_link_libraries(AmneziaVPNNetworkExtension PRIVATE heiher::hev-socks5-tunnel)
+target_include_directories(AmneziaVPNNetworkExtension PRIVATE ${CLIENT_ROOT_DIR}/3rd-prebuilt/3rd-prebuilt/xray/HevSocks5Tunnel.xcframework/macos-arm64_x86_64/Headers)

client/macos/networkextension/wireguard-go-version.h.in

@@ -0,0 +1,3 @@
+#ifndef WIREGUARD_GO_VERSION
+#define WIREGUARD_GO_VERSION "@WG_VERSION_STRING@"
+#endif // WIREGUARD_GO_VERSION

client/main.cpp

@@ -75,6 +75,7 @@ int main(int argc, char *argv[])
 
         qInfo().noquote() << QString("Started %1 version %2 %3").arg(APPLICATION_NAME, APP_VERSION, GIT_COMMIT_HASH);
         qInfo().noquote() << QString("%1 (%2)").arg(QSysInfo::prettyProductName(), QSysInfo::currentCpuArchitecture());
+        qInfo().noquote() << QString("SSL backend: %1").arg(QSslSocket::sslLibraryVersionString());
 
         return app.exec();
     }

client/mozilla/networkwatcher.cpp

@@ -72,9 +72,9 @@ void NetworkWatcher::initialize() {
   connect(m_impl, &NetworkWatcherImpl::unsecuredNetwork, this,
           &NetworkWatcher::unsecuredNetwork);
   connect(m_impl, &NetworkWatcherImpl::networkChanged, this,
-          &NetworkWatcher::networkChanged);
-  connect(m_impl, &NetworkWatcherImpl::wakeup, this,
-          &NetworkWatcher::wakeup);
+          &NetworkWatcher::networkChange);
+  connect(m_impl, &NetworkWatcherImpl::sleepMode, this,
+          &NetworkWatcher::onSleepMode);
   m_impl->initialize();
 
   // Enable sleep/wake monitoring for VPN auto-reconnection
@@ -97,6 +97,12 @@ void NetworkWatcher::settingsChanged() {
   logger.debug() << "NetworkWatcher settings changed - keeping sleep monitoring active";
 }
 
+void NetworkWatcher::onSleepMode()
+{
+  logger.debug() << "Resumed from sleep mode";
+  emit sleepMode();
+}
+
 void NetworkWatcher::unsecuredNetwork(const QString& networkName,
                                       const QString& networkId) {
   logger.debug() << "Unsecured network:" << logger.sensitive(networkName)

client/mozilla/networkwatcher.h

@@ -29,11 +29,13 @@ public:
     // false to restore.
     void simulateDisconnection(bool simulatedDisconnection);
 
+    void onSleepMode();
+
     QNetworkInformation::Reachability getReachability();
 
 signals:
-    void networkChanged();
-    void wakeup();
+    void networkChange();
+    void sleepMode();
 
 private:
     void settingsChanged();

client/mozilla/networkwatcherimpl.h

@@ -41,7 +41,7 @@ signals:
     // TODO: Only windows-networkwatcher has this, the other plattforms should
     // too.
     void networkChanged(QString newBSSID);
-    void wakeup();
+    void sleepMode();
 
 
 private:

client/platforms/linux/daemon/wireguardutilslinux.cpp

@@ -80,7 +80,7 @@ bool WireguardUtilsLinux::addInterface(const InterfaceConfig& config) {
 
     QDir appPath(QCoreApplication::applicationDirPath());
     QStringList wgArgs = {"-f", "amn0"};
-    m_tunnel.start(appPath.filePath("../../client/bin/amneziawg-go"), wgArgs);
+    m_tunnel.start(appPath.filePath("../../client/bin/wireguard-go"), wgArgs);
     if (!m_tunnel.waitForStarted(WG_TUN_PROC_TIMEOUT)) {
         logger.error() << "Unable to start tunnel process due to timeout";
         m_tunnel.kill();

client/platforms/linux/linuxnetworkwatcher.cpp

@@ -41,8 +41,8 @@ void LinuxNetworkWatcher::initialize() {
   connect(m_worker, &LinuxNetworkWatcherWorker::unsecuredNetwork, this,
           &LinuxNetworkWatcher::unsecuredNetwork);
 
-  connect(m_worker, &LinuxNetworkWatcherWorker::wakeup, this,
-          &NetworkWatcherImpl::wakeup);
+  connect(m_worker, &LinuxNetworkWatcherWorker::sleepMode, this,
+          &NetworkWatcherImpl::sleepMode);
 
   // Let's wait a few seconds to allow the UI to be fully loaded and shown.
   // This is not strictly needed, but it's better for user experience because

client/platforms/linux/linuxnetworkwatcherworker.cpp

@@ -200,7 +200,7 @@ void LinuxNetworkWatcherWorker::checkDevices() {
 void LinuxNetworkWatcherWorker::NMStateChanged(quint32 state)
 {
   if (state == NM_STATE_ASLEEP) {
-    emit wakeup();
+    emit sleepMode();
   }
 
   logger.debug() << "NMStateChanged " << state;

client/platforms/linux/linuxnetworkwatcherworker.h

@@ -23,7 +23,7 @@ class LinuxNetworkWatcherWorker final : public QObject {
 
  signals:
   void unsecuredNetwork(const QString& networkName, const QString& networkId);
-  void wakeup();
+  void sleepMode();
 
  public slots:
   void initialize();

client/platforms/macos/daemon/wireguardutilsmacos.cpp

@@ -79,7 +79,7 @@ bool WireguardUtilsMacos::addInterface(const InterfaceConfig& config) {
 
   QDir appPath(QCoreApplication::applicationDirPath());
   QStringList wgArgs = {"-f", "utun"};
-  m_tunnel.start(appPath.filePath("amneziawg-go"), wgArgs);
+  m_tunnel.start(appPath.filePath("wireguard-go"), wgArgs);
   if (!m_tunnel.waitForStarted(WG_TUN_PROC_TIMEOUT)) {
     logger.error() << "Unable to start tunnel process due to timeout";
     m_tunnel.kill();

client/platforms/macos/macosnetworkwatcher.mm

@@ -173,10 +173,10 @@ void PowerNotificationsListener::sleepWakeupCallBack(void *refParam, io_service_
 
     case kIOMessageSystemHasPoweredOn:
         /* Announces that the system and its devices have woken up. */
-        logger.debug() << "System has powered on - emitting wakeup signal from dedicated CFRunLoop thread";
+        logger.debug() << "System has powered on - emitting sleepMode signal from dedicated CFRunLoop thread";
         if (listener->m_watcher) {
             // Use QMetaObject::invokeMethod for thread-safe signal emission
-            QMetaObject::invokeMethod(listener->m_watcher, "wakeup", Qt::QueuedConnection);
+            QMetaObject::invokeMethod(listener->m_watcher, "sleepMode", Qt::QueuedConnection);
         }
         break;
 

client/platforms/windows/windowsnetworkwatcher.cpp

@@ -41,7 +41,7 @@ LRESULT WindowsNetworkWatcher::PowerWndProcCallback(HWND hwnd, UINT uMsg, WPARAM
   switch (uMsg) {
   case WM_POWERBROADCAST:
     if (wParam == PBT_APMRESUMESUSPEND) {
-        emit obj->wakeup();
+        emit obj->sleepMode();
     }
     break;
   default:

client/protocols/wireguardprotocol.cpp

@@ -15,7 +15,7 @@ WireguardProtocol::WireguardProtocol(const QJsonObject &configuration, QObject *
     m_impl.reset(new LocalSocketController());
     connect(m_impl.get(), &ControllerImpl::connected, this,
             [this](const QString &pubkey, const QDateTime &connectionTimestamp) {
-                setConnectionState(Vpn::ConnectionState::Connected);
+                emit connectionStateChanged(Vpn::ConnectionState::Connected);
             });
     connect(m_impl.get(), &ControllerImpl::statusUpdated, this,
             [this](const QString& serverIpv4Gateway,
@@ -38,7 +38,7 @@ WireguardProtocol::WireguardProtocol(const QJsonObject &configuration, QObject *
             });
 
     connect(m_impl.get(), &ControllerImpl::disconnected, this,
-            [this]() { setConnectionState(Vpn::ConnectionState::Disconnected); });
+            [this]() { emit connectionStateChanged(Vpn::ConnectionState::Disconnected); });
     m_impl->initialize(nullptr, nullptr);
 }
 

client/protocols/xrayprotocol.cpp

@@ -52,6 +52,7 @@ XrayProtocol::~XrayProtocol()
 ErrorCode XrayProtocol::start()
 {
     qDebug() << "XrayProtocol::start()";
+    setConnectionState(Vpn::ConnectionState::Connecting);
 
     return IpcClient::withInterface([&](QSharedPointer<IpcInterfaceReplica> iface) {
         auto xrayStart = iface->xrayStart(QJsonDocument(m_xrayConfig).toJson());
@@ -68,6 +69,7 @@ ErrorCode XrayProtocol::start()
 void XrayProtocol::stop()
 {
     qDebug() << "XrayProtocol::stop()";
+    setConnectionState(Vpn::ConnectionState::Disconnecting);
 
     IpcClient::withInterface([](QSharedPointer<IpcInterfaceReplica> iface) {
         auto disableKillSwitch = iface->disableKillSwitch();
@@ -124,14 +126,14 @@ ErrorCode XrayProtocol::startTun2Socks()
     m_tun2socksProcess->setProgram(PermittedProcess::Tun2Socks);
     m_tun2socksProcess->setArguments({"-device", QString("tun://%1").arg(tunName), "-proxy", "socks5://127.0.0.1:10808" });
 
-    connect(m_tun2socksProcess.data(), &IpcProcessInterfaceReplica::readyReadStandardError, this, [this]() {
-        auto readAllStandardError = m_tun2socksProcess->readAllStandardError();
-        if (!readAllStandardError.waitForFinished()) {
+    connect(m_tun2socksProcess.data(), &IpcProcessInterfaceReplica::readyReadStandardOutput, this, [this]() {
+        auto readAllStandardOutput = m_tun2socksProcess->readAllStandardOutput();
+        if (!readAllStandardOutput.waitForFinished()) {
             qWarning() << "Failed to read output from tun2socks";
             return;
         }
 
-        const QString line = readAllStandardError.returnValue();
+        const QString line = readAllStandardOutput.returnValue();
 
         if (!line.contains("[TCP]") && !line.contains("[UDP]"))
             qDebug() << "[tun2socks]:" << line;

client/settings.cpp

@@ -539,6 +539,26 @@ QString Settings::getGatewayEndpoint(bool isTestPurchase)
     return isTestPurchase ? DEV_AGW_ENDPOINT : m_gatewayEndpoint;
 }
 
+QString Settings::getDevProxyStorageEndpoint() const
+{
+    return value("Conf/devProxyStorageEndpoint", "").toString();
+}
+
+void Settings::setDevProxyStorageEndpoint(const QString &endpoint)
+{
+    setValue("Conf/devProxyStorageEndpoint", endpoint);
+}
+
+QString Settings::getDevProxyUrl() const
+{
+    return value("Conf/devProxyUrl", "").toString();
+}
+
+void Settings::setDevProxyUrl(const QString &url)
+{
+    setValue("Conf/devProxyUrl", url);
+}
+
 bool Settings::isDevGatewayEnv(bool isTestPurchase)
 {
     return isTestPurchase ? true : value("Conf/devGatewayEnv", false).toBool();

client/settings.h

@@ -233,6 +233,10 @@ public:
     void setGatewayEndpoint(const QString &endpoint);
     void setDevGatewayEndpoint();
     QString getGatewayEndpoint(bool isTestPurchase = false);
+    QString getDevProxyStorageEndpoint() const;
+    void setDevProxyStorageEndpoint(const QString &endpoint);
+    QString getDevProxyUrl() const;
+    void setDevProxyUrl(const QString &url);
     bool isDevGatewayEnv(bool isTestPurchase = false);
     void toggleDevGatewayEnv(bool enabled);
 

client/ui/controllers/api/apiConfigsController.cpp

@@ -769,7 +769,8 @@ bool ApiConfigsController::updateServiceFromTelegram(const int serverIndex)
 #endif
 
     GatewayController gatewayController(m_settings->getGatewayEndpoint(), m_settings->isDevGatewayEnv(), apiDefs::requestTimeoutMsecs,
-                                        m_settings->isStrictKillSwitchEnabled());
+                                        m_settings->isStrictKillSwitchEnabled(), m_settings->getDevProxyStorageEndpoint(),
+                                        m_settings->getDevProxyUrl());
 
     auto serverConfig = m_serversModel->getServerConfig(serverIndex);
     auto installationUuid = m_settings->getInstallationUuid(true);
@@ -994,6 +995,7 @@ ErrorCode ApiConfigsController::executeRequest(const QString &endpoint, const QJ
                                                bool isTestPurchase)
 {
     GatewayController gatewayController(m_settings->getGatewayEndpoint(isTestPurchase), m_settings->isDevGatewayEnv(isTestPurchase),
-                                        apiDefs::requestTimeoutMsecs, m_settings->isStrictKillSwitchEnabled());
+                                        apiDefs::requestTimeoutMsecs, m_settings->isStrictKillSwitchEnabled(),
+                                        m_settings->getDevProxyStorageEndpoint(), m_settings->getDevProxyUrl());
     return gatewayController.post(endpoint, apiPayload, responseBody);
 }

client/ui/controllers/api/apiNewsController.cpp

@@ -32,7 +32,10 @@ void ApiNewsController::fetchNews(bool showError)
     }
 
     auto gatewayController = QSharedPointer<GatewayController>::create(m_settings->getGatewayEndpoint(), m_settings->isDevGatewayEnv(),
-                                                                       apiDefs::requestTimeoutMsecs, m_settings->isStrictKillSwitchEnabled());
+                                                                       apiDefs::requestTimeoutMsecs,
+                                                                       m_settings->isStrictKillSwitchEnabled(),
+                                                                       m_settings->getDevProxyStorageEndpoint(),
+                                                                       m_settings->getDevProxyUrl());
     QJsonObject payload;
     payload.insert("locale", m_settings->getAppLanguage().name().split("_").first());
 

client/ui/controllers/api/apiSettingsController.cpp

@@ -57,7 +57,8 @@ bool ApiSettingsController::getAccountInfo(bool reload)
 
     bool isTestPurchase = apiConfig.value(apiDefs::key::isTestPurchase).toBool(false);
     GatewayController gatewayController(m_settings->getGatewayEndpoint(isTestPurchase), m_settings->isDevGatewayEnv(isTestPurchase),
-                                        requestTimeoutMsecs, m_settings->isStrictKillSwitchEnabled());
+                                        requestTimeoutMsecs, m_settings->isStrictKillSwitchEnabled(),
+                                        m_settings->getDevProxyStorageEndpoint(), m_settings->getDevProxyUrl());
 
     QJsonObject apiPayload;
     apiPayload[configKey::userCountryCode] = apiConfig.value(configKey::userCountryCode).toString();

client/ui/controllers/settingsController.cpp

@@ -158,6 +158,7 @@ void SettingsController::clearLogs()
 
     qInfo().noquote() << QString("Started %1 version %2 %3").arg(APPLICATION_NAME, APP_VERSION, GIT_COMMIT_HASH);
     qInfo().noquote() << QString("%1 (%2)").arg(QSysInfo::prettyProductName(), QSysInfo::currentCpuArchitecture());
+    qInfo().noquote() << QString("SSL backend: %1").arg(QSslSocket::sslLibraryVersionString());
 }
 
 void SettingsController::backupAppConfig(const QString &fileName)
@@ -425,6 +426,28 @@ QString SettingsController::getGatewayEndpoint()
     return m_settings->isDevGatewayEnv() ? "Dev endpoint" : m_settings->getGatewayEndpoint();
 }
 
+void SettingsController::setDevProxyStorageEndpoint(const QString &endpoint)
+{
+    m_settings->setDevProxyStorageEndpoint(endpoint);
+    emit devProxyStorageEndpointChanged(endpoint);
+}
+
+QString SettingsController::getDevProxyStorageEndpoint()
+{
+    return m_settings->getDevProxyStorageEndpoint();
+}
+
+void SettingsController::setDevProxyUrl(const QString &url)
+{
+    m_settings->setDevProxyUrl(url);
+    emit devProxyUrlChanged(url);
+}
+
+QString SettingsController::getDevProxyUrl()
+{
+    return m_settings->getDevProxyUrl();
+}
+
 bool SettingsController::isDevGatewayEnv()
 {
     return m_settings->isDevGatewayEnv();

client/ui/controllers/settingsController.h

@@ -30,6 +30,9 @@ public:
     Q_PROPERTY(bool isDevModeEnabled READ isDevModeEnabled NOTIFY devModeEnabled)
     Q_PROPERTY(QString gatewayEndpoint READ getGatewayEndpoint WRITE setGatewayEndpoint NOTIFY gatewayEndpointChanged)
     Q_PROPERTY(bool isDevGatewayEnv READ isDevGatewayEnv WRITE toggleDevGatewayEnv NOTIFY devGatewayEnvChanged)
+    Q_PROPERTY(QString devProxyStorageEndpoint READ getDevProxyStorageEndpoint WRITE setDevProxyStorageEndpoint NOTIFY
+                       devProxyStorageEndpointChanged)
+    Q_PROPERTY(QString devProxyUrl READ getDevProxyUrl WRITE setDevProxyUrl NOTIFY devProxyUrlChanged)
 
     Q_PROPERTY(bool isHomeAdLabelVisible READ isHomeAdLabelVisible NOTIFY isHomeAdLabelVisibleChanged)
     Q_PROPERTY(bool startMinimized READ isStartMinimizedEnabled NOTIFY startMinimizedChanged)
@@ -98,6 +101,10 @@ public slots:
     void resetGatewayEndpoint();
     void setGatewayEndpoint(const QString &endpoint);
     QString getGatewayEndpoint();
+    void setDevProxyStorageEndpoint(const QString &endpoint);
+    QString getDevProxyStorageEndpoint();
+    void setDevProxyUrl(const QString &url);
+    QString getDevProxyUrl();
     bool isDevGatewayEnv();
     void toggleDevGatewayEnv(bool enabled);
 
@@ -136,6 +143,8 @@ signals:
     void devModeEnabled();
     void gatewayEndpointChanged(const QString &endpoint);
     void devGatewayEnvChanged(bool enabled);
+    void devProxyStorageEndpointChanged(const QString &endpoint);
+    void devProxyUrlChanged(const QString &url);
     
     void imeHeightChanged(int height);
     void safeAreaTopMarginChanged();

client/ui/qml/Pages2/PageDevMenu.qml

@@ -73,6 +73,50 @@ PageType {
                     }
                 }
             }
+
+            TextFieldWithHeaderType {
+                Layout.fillWidth: true
+                Layout.rightMargin: 16
+                Layout.leftMargin: 16
+
+                headerText: qsTr("Proxy storage endpoint")
+                textField.text: SettingsController.devProxyStorageEndpoint
+
+                buttonImageSource: textField.text !== "" ? "qrc:/images/controls/refresh-cw.svg" : ""
+
+                clickedFunc: function() {
+                    SettingsController.devProxyStorageEndpoint = ""
+                }
+
+                textField.onEditingFinished: {
+                    textField.text = textField.text.replace(/^\s+|\s+$/g, '')
+                    if (textField.text !== SettingsController.devProxyStorageEndpoint) {
+                        SettingsController.devProxyStorageEndpoint = textField.text
+                    }
+                }
+            }
+
+            TextFieldWithHeaderType {
+                Layout.fillWidth: true
+                Layout.rightMargin: 16
+                Layout.leftMargin: 16
+
+                headerText: qsTr("Proxy endpoint")
+                textField.text: SettingsController.devProxyUrl
+
+                buttonImageSource: textField.text !== "" ? "qrc:/images/controls/refresh-cw.svg" : ""
+
+                clickedFunc: function() {
+                    SettingsController.devProxyUrl = ""
+                }
+
+                textField.onEditingFinished: {
+                    textField.text = textField.text.replace(/^\s+|\s+$/g, '')
+                    if (textField.text !== SettingsController.devProxyUrl) {
+                        SettingsController.devProxyUrl = textField.text
+                    }
+                }
+            }
         }
 
         footer: ColumnLayout {

client/ui/qml/Pages2/PageSettingsApiServerInfo.qml

@@ -396,7 +396,9 @@ PageType {
                             PageController.showNotificationMessage(qsTr("Cannot remove server during active connection"))
                         } else {
                             PageController.showBusyIndicator(true)
-                            InstallController.removeProcessedServer()
+                            if (ApiConfigsController.deactivateDevice(true)) {
+                                InstallController.removeProcessedServer()
+                            }
                             PageController.showBusyIndicator(false)
                         }
                     }

client/vpnconnection.cpp

@@ -41,6 +41,7 @@ VpnConnection::VpnConnection(std::shared_ptr<Settings> settings, QObject *parent
     m_checkTimer.setInterval(1000);
     connect(IosController::Instance(), &IosController::connectionStateChanged, this, &VpnConnection::onConnectionStateChanged);
     connect(IosController::Instance(), &IosController::bytesChanged, this, &VpnConnection::onBytesChanged);
+
 #endif
 }
 
@@ -58,7 +59,7 @@ void VpnConnection::onKillSwitchModeChanged(bool enabled)
 #ifdef AMNEZIA_DESKTOP
     IpcClient::withInterface([enabled](QSharedPointer<IpcInterfaceReplica> iface){
         QRemoteObjectPendingReply<bool> reply = iface->refreshKillSwitch(enabled);
-        if (reply.waitForFinished() && reply.returnValue())
+        if (reply.waitForFinished(1000) && reply.returnValue())
             qDebug() << "VpnConnection::onKillSwitchModeChanged: Killswitch refreshed";
         else
             qWarning() << "VpnConnection::onKillSwitchModeChanged: Failed to execute remote refreshKillSwitch call";
@@ -72,57 +73,40 @@ void VpnConnection::onConnectionStateChanged(Vpn::ConnectionState state)
     auto container = m_settings->defaultContainer(m_settings->defaultServerIndex());
 
     IpcClient::withInterface([&](QSharedPointer<IpcInterfaceReplica> iface) {
-        switch (state) {
-            case Vpn::ConnectionState::Connected: {
-                iface->resetIpStack();
+        if (state == Vpn::ConnectionState::Connected) {
+            iface->resetIpStack();
+            iface->flushDns();
 
-                auto flushDns = iface->flushDns();
-                if (flushDns.waitForFinished() && flushDns.returnValue())
-                    qDebug() << "VpnConnection::onConnectionStateChanged: Successfully flushed DNS";
-                else
-                    qWarning() << "VpnConnection::onConnectionStateChanged: Failed to clear saved routes";
+            if (!ContainerProps::isAwgContainer(container) && 
+                container != DockerContainer::WireGuard) {
+                QString dns1 = m_vpnConfiguration.value(config_key::dns1).toString();
+                QString dns2 = m_vpnConfiguration.value(config_key::dns2).toString();
 
+                iface->routeAddList(m_vpnProtocol->vpnGateway(), QStringList() << dns1 << dns2);
 
-                if (!ContainerProps::isAwgContainer(container) &&
-                    container != DockerContainer::WireGuard) {
-                    QString dns1 = m_vpnConfiguration.value(config_key::dns1).toString();
-                    QString dns2 = m_vpnConfiguration.value(config_key::dns2).toString();
+                if (m_settings->isSitesSplitTunnelingEnabled()) {
+                    iface->routeDeleteList(m_vpnProtocol->vpnGateway(), QStringList() << "0.0.0.0");
+                    // qDebug() << "VpnConnection::onConnectionStateChanged :: adding custom routes, count:" << forwardIps.size();
+                    if (m_settings->routeMode() == Settings::VpnOnlyForwardSites) {
+                        QTimer::singleShot(1000, m_vpnProtocol.data(),
+                                           [this]() { addSitesRoutes(m_vpnProtocol->vpnGateway(), m_settings->routeMode()); });
+                    } else if (m_settings->routeMode() == Settings::VpnAllExceptSites) {
+                        iface->routeAddList(m_vpnProtocol->vpnGateway(), QStringList() << "0.0.0.0/1");
+                        iface->routeAddList(m_vpnProtocol->vpnGateway(), QStringList() << "128.0.0.0/1");
 
-                    // TODO: add error code handling for all routeAddList (or rework the code below)
-                    iface->routeAddList(m_vpnProtocol->vpnGateway(), QStringList() << dns1 << dns2);
-
-                    if (m_settings->isSitesSplitTunnelingEnabled()) {
-                        iface->routeDeleteList(m_vpnProtocol->vpnGateway(), QStringList() << "0.0.0.0");
-                        // qDebug() << "VpnConnection::onConnectionStateChanged :: adding custom routes, count:" << forwardIps.size();
-                        if (m_settings->routeMode() == Settings::VpnOnlyForwardSites) {
-                            QTimer::singleShot(1000, m_vpnProtocol.data(),
-                                               [this]() { addSitesRoutes(m_vpnProtocol->vpnGateway(), m_settings->routeMode()); });
-                        } else if (m_settings->routeMode() == Settings::VpnAllExceptSites) {
-                            iface->routeAddList(m_vpnProtocol->vpnGateway(), QStringList() << "0.0.0.0/1");
-                            iface->routeAddList(m_vpnProtocol->vpnGateway(), QStringList() << "128.0.0.0/1");
-
-                            iface->routeAddList(m_vpnProtocol->routeGateway(), QStringList() << remoteAddress());
-                            addSitesRoutes(m_vpnProtocol->routeGateway(), m_settings->routeMode());
-                        }
+                        iface->routeAddList(m_vpnProtocol->routeGateway(), QStringList() << remoteAddress());
+                        addSitesRoutes(m_vpnProtocol->routeGateway(), m_settings->routeMode());
                     }
                 }
-            } break;
-            case Vpn::ConnectionState::Disconnected:
-            case Vpn::ConnectionState::Error: {
-                auto flushDns = iface->flushDns();
-                if (flushDns.waitForFinished() && flushDns.returnValue())
-                    qDebug() << "VpnConnection::onConnectionStateChanged: Successfully flushed DNS";
-                else
-                    qWarning() << "VpnConnection::onConnectionStateChanged: Failed to flush DNS";
+            }
+        } else if (state == Vpn::ConnectionState::Error) {
+            iface->flushDns();
 
-                auto clearSavedRoutes = iface->clearSavedRoutes();
-                if (clearSavedRoutes.waitForFinished() && clearSavedRoutes.returnValue())
-                    qDebug() << "VpnConnection::onConnectionStateChanged: Successfully cleared saved routes";
-                else
-                    qWarning() << "VpnConnection::onConnectionStateChanged: Failed to clear saved routes";
-            } break;
-            default:
-                break;
+            if (m_settings->isSitesSplitTunnelingEnabled()) {
+                if (m_settings->routeMode() == Settings::VpnOnlyForwardSites) {
+                    iface->clearSavedRoutes();
+                }
+            }
         }
     });
 #endif
@@ -136,6 +120,7 @@ void VpnConnection::onConnectionStateChanged(Vpn::ConnectionState state)
         m_checkTimer.stop();
     }
 #endif
+    emit connectionStateChanged(state);
 }
 
 const QString &VpnConnection::remoteAddress() const
@@ -180,11 +165,7 @@ void VpnConnection::addSitesRoutes(const QString &gw, Settings::RouteMode mode)
                         });
                         m_settings->addVpnSite(mode, site, ip);
                     }
-                    IpcClient::withInterface([](QSharedPointer<IpcInterfaceReplica> iface) {
-                        auto reply = iface->flushDns();
-                        if (reply.waitForFinished() || !reply.returnValue())
-                            qWarning() << "VpnConnection::addSitesRoutes: Failed to flush DNS";
-                    });
+                    flushDns();
                     break;
                 }
             }
@@ -199,6 +180,48 @@ QSharedPointer<VpnProtocol> VpnConnection::vpnProtocol() const
     return m_vpnProtocol;
 }
 
+void VpnConnection::addRoutes(const QStringList &ips)
+{
+#ifdef AMNEZIA_DESKTOP
+    IpcClient::withInterface([&](QSharedPointer<IpcInterfaceReplica> iface) {
+        if (connectionState() == Vpn::ConnectionState::Connected) {
+            if (m_settings->routeMode() == Settings::VpnOnlyForwardSites) {
+                iface->routeAddList(m_vpnProtocol->vpnGateway(), ips);
+            } else if (m_settings->routeMode() == Settings::VpnAllExceptSites) {
+                iface->routeAddList(m_vpnProtocol->routeGateway(), ips);
+            }
+        }
+    });
+#endif
+}
+
+void VpnConnection::deleteRoutes(const QStringList &ips)
+{
+#ifdef AMNEZIA_DESKTOP
+    IpcClient::withInterface([&](QSharedPointer<IpcInterfaceReplica> iface) {
+        if (connectionState() == Vpn::ConnectionState::Connected) {
+            if (m_settings->routeMode() == Settings::VpnOnlyForwardSites) {
+                iface->routeDeleteList(vpnProtocol()->vpnGateway(), ips);
+            } else if (m_settings->routeMode() == Settings::VpnAllExceptSites) {
+                iface->routeDeleteList(m_vpnProtocol->routeGateway(), ips);
+            }
+        }
+    });
+#endif
+}
+
+void VpnConnection::flushDns()
+{
+#ifdef AMNEZIA_DESKTOP
+    IpcClient::withInterface([](QSharedPointer<IpcInterfaceReplica> iface) {
+        auto reply = iface->flushDns();
+        if (reply.waitForFinished(1000) || !reply.returnValue()) {
+            qWarning() << "VpnConnection::flushDns(): Failed to flush DNS";
+        }
+    });
+#endif
+}
+
 void VpnConnection::disconnectSlots()
 {
     if (m_vpnProtocol) {
@@ -228,7 +251,7 @@ void VpnConnection::connectToVpn(int serverIndex, const ServerCredentials &crede
              << m_settings->routeMode();
 
     m_remoteAddress = NetworkUtilities::getIPAddress(credentials.hostName);
-    setConnectionState(Vpn::ConnectionState::Connecting);
+    emit connectionStateChanged(Vpn::ConnectionState::Connecting);
 
     m_vpnConfiguration = vpnConfiguration;
 
@@ -246,7 +269,7 @@ void VpnConnection::connectToVpn(int serverIndex, const ServerCredentials &crede
 #if !defined(Q_OS_ANDROID) && !defined(Q_OS_IOS) && !defined(MACOS_NE)
     m_vpnProtocol.reset(VpnProtocol::factory(container, m_vpnConfiguration));
     if (!m_vpnProtocol) {
-        setConnectionState(Vpn::ConnectionState::Error);
+        emit connectionStateChanged(Vpn::ConnectionState::Error);
         return;
     }
     m_vpnProtocol->prepare();
@@ -264,24 +287,17 @@ void VpnConnection::connectToVpn(int serverIndex, const ServerCredentials &crede
 
     createProtocolConnections();
 
-    if (ErrorCode err = m_vpnProtocol->start(); err != ErrorCode::NoError) {
-        setConnectionState(Vpn::ConnectionState::Error);
-        emit vpnProtocolError(err);
-    }
+    ErrorCode errorCode = m_vpnProtocol->start();
+    if (errorCode != ErrorCode::NoError)
+        emit connectionStateChanged(Vpn::ConnectionState::Error);
 }
 
 void VpnConnection::createProtocolConnections()
 {
     connect(m_vpnProtocol.data(), &VpnProtocol::protocolError, this, &VpnConnection::vpnProtocolError);
-    connect(m_vpnProtocol.data(), &VpnProtocol::connectionStateChanged, this, &VpnConnection::setConnectionState);
+    connect(m_vpnProtocol.data(), SIGNAL(connectionStateChanged(Vpn::ConnectionState)), this,
+            SLOT(onConnectionStateChanged(Vpn::ConnectionState)));
     connect(m_vpnProtocol.data(), SIGNAL(bytesChanged(quint64, quint64)), this, SLOT(onBytesChanged(quint64, quint64)));
-
-#ifdef AMNEZIA_DESKTOP
-    IpcClient::withInterface([this](QSharedPointer<IpcInterfaceReplica> rep) {
-        connect(rep.data(), &IpcInterfaceReplica::networkChanged, this, &VpnConnection::reconnectToVpn, Qt::QueuedConnection);
-        connect(rep.data(), &IpcInterfaceReplica::wakeup, this, &VpnConnection::reconnectToVpn, Qt::QueuedConnection);
-    });
-#endif
 }
 
 void VpnConnection::appendKillSwitchConfig()
@@ -423,27 +439,6 @@ QString VpnConnection::bytesPerSecToText(quint64 bytes)
     return QString("%1 %2").arg(QString::number(mbps, 'f', 2)).arg(tr("Mbps")); // Mbit/s
 }
 
-void VpnConnection::reconnectToVpn() {
-    if (m_vpnProtocol.isNull())
-        return;
-
-    if (m_connectionState != Vpn::ConnectionState::Connected) {
-        qWarning() << QString("Reconnect triggered on %1 during inappropriate state: %2; ignoring slot")
-                              .arg(QMetaEnum::fromType<Vpn::ConnectionState>().valueToKey(m_connectionState));
-        return;
-    }
-
-    qDebug() << "Reconnect triggered. Reconnecting to the server";
-
-    setConnectionState(Vpn::ConnectionState::Reconnecting);
-
-    m_vpnProtocol->stop();
-    if (ErrorCode err = m_vpnProtocol->start(); err != ErrorCode::NoError) {
-        setConnectionState(Vpn::ConnectionState::Error);
-        emit vpnProtocolError(err);
-    }
-}
-
 void VpnConnection::disconnectFromVpn()
 {
 #if defined(Q_OS_IOS) || defined(MACOS_NE)
@@ -453,11 +448,27 @@ void VpnConnection::disconnectFromVpn()
 #endif
 
     if (m_vpnProtocol.isNull()) {
-        setConnectionState(Vpn::ConnectionState::Disconnected);
+        emit connectionStateChanged(Vpn::ConnectionState::Disconnected);
         return;
     }
 
-    setConnectionState(Vpn::ConnectionState::Disconnecting);
+    m_vpnProtocol->stop();
+
+#ifdef AMNEZIA_DESKTOP
+    IpcClient::withInterface([](QSharedPointer<IpcInterfaceReplica> iface) {
+        QRemoteObjectPendingReply<bool> flushReply = iface->flushDns();
+        if (flushReply.waitForFinished(5000) && flushReply.returnValue())
+            qDebug() << "VpnConnection::disconnectFromVpn(): Successfully flushed DNS";
+        else
+            qWarning() << "VpnConnection::disconnectFromVpn(): Failed to flush DNS";
+
+        QRemoteObjectPendingReply<bool> clearSavedRoutesReply = iface->clearSavedRoutes();
+        if (clearSavedRoutesReply.waitForFinished(5000) && clearSavedRoutesReply.returnValue())
+            qDebug() << "VpnConnection::disconnectFromVpn(): Successfully cleared saved routes";
+        else
+            qWarning() << "VpnConnection::disconnectFromVpn(): Failed to clear saved routes";
+    });
+#endif
 
 #ifdef Q_OS_ANDROID
     auto *const connection = new QMetaObject::Connection;
@@ -469,9 +480,8 @@ void VpnConnection::disconnectFromVpn()
                                   delete connection;
                               }
                           });
-#endif
-
     m_vpnProtocol->stop();
+#endif
 
 #if !defined(Q_OS_ANDROID) && !defined(AMNEZIA_DESKTOP)
     m_vpnProtocol->deleteLater();
@@ -480,12 +490,27 @@ void VpnConnection::disconnectFromVpn()
     m_vpnProtocol = nullptr;
 }
 
-void VpnConnection::setConnectionState(Vpn::ConnectionState state) {
-    onConnectionStateChanged(state);
-
-    if (state == Vpn::Disconnected && m_connectionState == Vpn::Reconnecting)
-        return;
-
-    m_connectionState = state;
-    emit connectionStateChanged(state);
+Vpn::ConnectionState VpnConnection::connectionState()
+{
+    if (!m_vpnProtocol)
+        return Vpn::ConnectionState::Disconnected;
+    return m_vpnProtocol->connectionState();
+}
+
+bool VpnConnection::isConnected() const
+{
+    if (m_vpnProtocol.isNull()) {
+        return false;
+    }
+
+    return m_vpnProtocol->isConnected();
+}
+
+bool VpnConnection::isDisconnected() const
+{
+    if (m_vpnProtocol.isNull()) {
+        return true;
+    }
+
+    return m_vpnProtocol->isDisconnected();
 }

client/vpnconnection.h

@@ -34,6 +34,10 @@ public:
 
     ErrorCode lastError() const;
 
+    bool isConnected() const;
+    bool isDisconnected() const;
+
+    Vpn::ConnectionState connectionState();
     QSharedPointer<VpnProtocol> vpnProtocol() const;
 
     const QString &remoteAddress() const;
@@ -44,10 +48,14 @@ public:
 #endif
 
 public slots:
-    void connectToVpn(int serverIndex, const ServerCredentials &credentials, DockerContainer container, const QJsonObject &vpnConfiguration);
-    void reconnectToVpn();
+    void connectToVpn(int serverIndex,
+    const ServerCredentials &credentials, DockerContainer container, const QJsonObject &vpnConfiguration);
+
     void disconnectFromVpn();
 
+    void addRoutes(const QStringList &ips);
+    void deleteRoutes(const QStringList &ips);
+    void flushDns();
     void onKillSwitchModeChanged(bool enabled);
     void disconnectSlots();
 
@@ -62,8 +70,6 @@ protected slots:
     void onBytesChanged(quint64 receivedBytes, quint64 sentBytes);
     void onConnectionStateChanged(Vpn::ConnectionState state);
 
-    void setConnectionState(Vpn::ConnectionState state);
-
 protected:
     QSharedPointer<VpnProtocol> m_vpnProtocol;
 
@@ -83,8 +89,6 @@ private:
    void createAndroidConnections();
 #endif
 
-   Vpn::ConnectionState m_connectionState;
-
    void createProtocolConnections();
 
    void appendSplitTunnelingConfig();

cmake/conan_bootstrap.cmake

@@ -1,9 +0,0 @@
-find_program(CONAN_COMMAND "conan" REQUIRED HINTS /opt/homebrew/bin)
-
-file(GLOB_RECURSE LOCAL_RECIPES "${CMAKE_SOURCE_DIR}/recipes/*/conanfile.py")
-foreach(RECIPE ${LOCAL_RECIPES})
-    get_filename_component(RECIPE_DIR ${RECIPE} DIRECTORY)
-    execute_process(
-        COMMAND ${CONAN_COMMAND} export ${RECIPE_DIR}
-    )
-endforeach()

cmake/conan_provider.cmake

@@ -1,722 +0,0 @@
-# The MIT License (MIT)
-#
-# Copyright (c) 2024 JFrog
-#
-# 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.
-
-set(CONAN_MINIMUM_VERSION 2.0.5)
-
-# Create a new policy scope and set the minimum required cmake version so the
-# features behind a policy setting like if(... IN_LIST ...) behaves as expected
-# even if the parent project does not specify a minimum cmake version or a minimum
-# version less than this module requires (e.g. 3.0) before the first project() call.
-# (see: https://cmake.org/cmake/help/latest/variable/CMAKE_PROJECT_TOP_LEVEL_INCLUDES.html)
-#
-# The policy-affecting calls like cmake_policy(SET...) or `cmake_minimum_required` only
-# affects the current policy scope, i.e. between the PUSH and POP in this case.
-#
-# https://cmake.org/cmake/help/book/mastering-cmake/chapter/Policies.html#the-policy-stack
-cmake_policy(PUSH)
-cmake_minimum_required(VERSION 3.24)
-
-
-function(detect_os os os_api_level os_sdk os_subsystem os_version)
-    # it could be cross compilation
-    message(STATUS "CMake-Conan: cmake_system_name=${CMAKE_SYSTEM_NAME}")
-    if(CMAKE_SYSTEM_NAME AND NOT CMAKE_SYSTEM_NAME STREQUAL "Generic")
-        if(CMAKE_SYSTEM_NAME STREQUAL "Darwin")
-            set(${os} Macos PARENT_SCOPE)
-        elseif(CMAKE_SYSTEM_NAME STREQUAL "QNX")
-            set(${os} Neutrino PARENT_SCOPE)
-        elseif(CMAKE_SYSTEM_NAME STREQUAL "CYGWIN")
-            set(${os} Windows PARENT_SCOPE)
-            set(${os_subsystem} cygwin PARENT_SCOPE)
-        elseif(CMAKE_SYSTEM_NAME MATCHES "^MSYS")
-            set(${os} Windows PARENT_SCOPE)
-            set(${os_subsystem} msys2 PARENT_SCOPE)
-        elseif(CMAKE_SYSTEM_NAME STREQUAL "Emscripten")
-            # https://github.com/emscripten-core/emscripten/blob/4.0.6/cmake/Modules/Platform/Emscripten.cmake#L17C1-L17C34
-            set(${os} Emscripten PARENT_SCOPE)
-        else()
-            set(${os} ${CMAKE_SYSTEM_NAME} PARENT_SCOPE)
-        endif()
-        if(CMAKE_SYSTEM_NAME STREQUAL "Android")
-            if(DEFINED ANDROID_PLATFORM)
-                string(REGEX MATCH "[0-9]+" _os_api_level ${ANDROID_PLATFORM})
-            elseif(DEFINED CMAKE_SYSTEM_VERSION)
-                set(_os_api_level ${CMAKE_SYSTEM_VERSION})
-            endif()
-            message(STATUS "CMake-Conan: android api level=${_os_api_level}")
-            set(${os_api_level} ${_os_api_level} PARENT_SCOPE)
-        endif()
-        if(CMAKE_SYSTEM_NAME MATCHES "Darwin|iOS|tvOS|watchOS")
-            # CMAKE_OSX_SYSROOT contains the full path to the SDK for MakeFile/Ninja
-            # generators, but just has the original input string for Xcode.
-            if(NOT IS_DIRECTORY ${CMAKE_OSX_SYSROOT})
-                set(_os_sdk ${CMAKE_OSX_SYSROOT})
-            else()
-                if(CMAKE_OSX_SYSROOT MATCHES Simulator)
-                    set(apple_platform_suffix simulator)
-                else()
-                    set(apple_platform_suffix os)
-                endif()
-                if(CMAKE_OSX_SYSROOT MATCHES AppleTV)
-                    set(_os_sdk "appletv${apple_platform_suffix}")
-                elseif(CMAKE_OSX_SYSROOT MATCHES iPhone)
-                    set(_os_sdk "iphone${apple_platform_suffix}")
-                elseif(CMAKE_OSX_SYSROOT MATCHES Watch)
-                    set(_os_sdk "watch${apple_platform_suffix}")
-                endif()
-            endif()
-            if(DEFINED os_sdk)
-                message(STATUS "CMake-Conan: cmake_osx_sysroot=${CMAKE_OSX_SYSROOT}")
-                set(${os_sdk} ${_os_sdk} PARENT_SCOPE)
-            endif()
-            if(DEFINED CMAKE_OSX_DEPLOYMENT_TARGET)
-                message(STATUS "CMake-Conan: cmake_osx_deployment_target=${CMAKE_OSX_DEPLOYMENT_TARGET}")
-                set(${os_version} ${CMAKE_OSX_DEPLOYMENT_TARGET} PARENT_SCOPE)
-            endif()
-        endif()
-    endif()
-endfunction()
-
-
-function(detect_arch arch)
-    # CMAKE_OSX_ARCHITECTURES can contain multiple architectures, but Conan only supports one.
-    # Therefore this code only finds one. If the recipes support multiple architectures, the
-    # build will work. Otherwise, there will be a linker error for the missing architecture(s).
-    if(DEFINED CMAKE_OSX_ARCHITECTURES)
-        string(REPLACE " " ";" apple_arch_list "${CMAKE_OSX_ARCHITECTURES}")
-        list(LENGTH apple_arch_list apple_arch_count)
-        if(apple_arch_count GREATER 1)
-            message(WARNING "CMake-Conan: Multiple architectures detected, this will only work if Conan recipe(s) produce fat binaries.")
-        endif()
-    endif()
-    if(CMAKE_SYSTEM_NAME MATCHES "Darwin|iOS|tvOS|watchOS" AND NOT CMAKE_OSX_ARCHITECTURES STREQUAL "")
-        set(host_arch ${CMAKE_OSX_ARCHITECTURES})
-    elseif(MSVC)
-        set(host_arch ${CMAKE_CXX_COMPILER_ARCHITECTURE_ID})
-    else()
-        set(host_arch ${CMAKE_SYSTEM_PROCESSOR})
-    endif()
-    if(host_arch MATCHES "aarch64|arm64|ARM64")
-        list(APPEND _arch armv8)
-    endif()
-    if(host_arch MATCHES "armv7|armv7-a|armv7l|ARMV7")
-        list(APPEND _arch armv7)
-    endif()
-    if(host_arch MATCHES armv7s)
-        list(APPEND _arch armv7s)
-    endif()
-    if(host_arch MATCHES "i686|i386|X86")
-        list(APPEND _arch x86)
-    endif()
-    if(host_arch MATCHES "AMD64|amd64|x86_64|x64")
-        list(APPEND _arch x86_64)
-    endif()
-    if(EMSCRIPTEN)
-        # https://github.com/emscripten-core/emscripten/blob/4.0.6/cmake/Modules/Platform/Emscripten.cmake#L294C1-L294C80
-        list(APPEND _arch wasm)
-    endif()
-    message(STATUS "CMake-Conan: cmake_system_processor=${_arch}")
-    list(JOIN _arch "|" _arch)
-    set(${arch} ${_arch} PARENT_SCOPE)
-endfunction()
-
-
-function(detect_cxx_standard compiler cxx_standard)
-    set(${cxx_standard} ${CMAKE_CXX_STANDARD} PARENT_SCOPE)
-    if(CMAKE_CXX_EXTENSIONS)
-        if(compiler STREQUAL "msvc")
-            set(${cxx_standard} "${CMAKE_CXX_STANDARD}" PARENT_SCOPE)
-        else()
-            set(${cxx_standard} "gnu${CMAKE_CXX_STANDARD}" PARENT_SCOPE)
-        endif()
-    endif()
-endfunction()
-
-
-macro(detect_gnu_libstdcxx)
-    # _conan_is_gnu_libstdcxx true if GNU libstdc++
-    check_cxx_source_compiles("
-    #include <cstddef>
-    #if !defined(__GLIBCXX__) && !defined(__GLIBCPP__)
-    static_assert(false);
-    #endif
-    int main(){}" _conan_is_gnu_libstdcxx)
-
-    # _conan_gnu_libstdcxx_is_cxx11_abi true if C++11 ABI
-    check_cxx_source_compiles("
-    #include <string>
-    static_assert(sizeof(std::string) != sizeof(void*), \"using libstdc++\");
-    int main () {}" _conan_gnu_libstdcxx_is_cxx11_abi)
-
-    set(_conan_gnu_libstdcxx_suffix "")
-    if(_conan_gnu_libstdcxx_is_cxx11_abi)
-        set(_conan_gnu_libstdcxx_suffix "11")
-    endif()
-    unset (_conan_gnu_libstdcxx_is_cxx11_abi)
-endmacro()
-
-
-macro(detect_libcxx)
-    # _conan_is_libcxx true if LLVM libc++
-    check_cxx_source_compiles("
-    #include <cstddef>
-    #if !defined(_LIBCPP_VERSION)
-       static_assert(false);
-    #endif
-    int main(){}" _conan_is_libcxx)
-endmacro()
-
-
-function(detect_lib_cxx lib_cxx)
-    if(CMAKE_SYSTEM_NAME STREQUAL "Android")
-        message(STATUS "CMake-Conan: android_stl=${CMAKE_ANDROID_STL_TYPE}")
-        set(${lib_cxx} ${CMAKE_ANDROID_STL_TYPE} PARENT_SCOPE)
-        return()
-    endif()
-
-    include(CheckCXXSourceCompiles)
-
-    if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
-        detect_gnu_libstdcxx()
-        set(${lib_cxx} "libstdc++${_conan_gnu_libstdcxx_suffix}" PARENT_SCOPE)
-    elseif(CMAKE_CXX_COMPILER_ID MATCHES "AppleClang")
-        set(${lib_cxx} "libc++" PARENT_SCOPE)
-    elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND NOT CMAKE_SYSTEM_NAME MATCHES "Windows")
-        # Check for libc++
-        detect_libcxx()
-        if(_conan_is_libcxx)
-            set(${lib_cxx} "libc++" PARENT_SCOPE)
-            return()
-        endif()
-
-        # Check for libstdc++
-        detect_gnu_libstdcxx()
-        if(_conan_is_gnu_libstdcxx)
-            set(${lib_cxx} "libstdc++${_conan_gnu_libstdcxx_suffix}" PARENT_SCOPE)
-            return()
-        endif()
-
-        # TODO: it would be an error if we reach this point
-    elseif(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
-        # Do nothing - compiler.runtime and compiler.runtime_type
-        # should be handled separately: https://github.com/conan-io/cmake-conan/pull/516
-        return()
-    else()
-        # TODO: unable to determine, ask user to provide a full profile file instead
-    endif()
-endfunction()
-
-
-function(detect_compiler compiler compiler_version compiler_runtime compiler_runtime_type)
-    if(DEFINED CMAKE_CXX_COMPILER_ID)
-        set(_compiler ${CMAKE_CXX_COMPILER_ID})
-        set(_compiler_version ${CMAKE_CXX_COMPILER_VERSION})
-    else()
-        if(NOT DEFINED CMAKE_C_COMPILER_ID)
-            message(FATAL_ERROR "C or C++ compiler not defined")
-        endif()
-        set(_compiler ${CMAKE_C_COMPILER_ID})
-        set(_compiler_version ${CMAKE_C_COMPILER_VERSION})
-    endif()
-
-    message(STATUS "CMake-Conan: CMake compiler=${_compiler}")
-    message(STATUS "CMake-Conan: CMake compiler version=${_compiler_version}")
-
-    if(_compiler MATCHES MSVC)
-        set(_compiler "msvc")
-        string(SUBSTRING ${MSVC_VERSION} 0 3 _compiler_version)
-        # Configure compiler.runtime and compiler.runtime_type settings for MSVC
-        if(CMAKE_MSVC_RUNTIME_LIBRARY)
-            set(_msvc_runtime_library ${CMAKE_MSVC_RUNTIME_LIBRARY})
-        else()
-            set(_msvc_runtime_library MultiThreaded$<$<CONFIG:Debug>:Debug>DLL) # default value documented by CMake
-        endif()
-
-        set(_KNOWN_MSVC_RUNTIME_VALUES "")
-        list(APPEND _KNOWN_MSVC_RUNTIME_VALUES MultiThreaded MultiThreadedDLL)
-        list(APPEND _KNOWN_MSVC_RUNTIME_VALUES MultiThreadedDebug MultiThreadedDebugDLL)
-        list(APPEND _KNOWN_MSVC_RUNTIME_VALUES MultiThreaded$<$<CONFIG:Debug>:Debug> MultiThreaded$<$<CONFIG:Debug>:Debug>DLL)
-
-        # only accept the 6 possible values, otherwise we don't don't know to map this
-        if(NOT _msvc_runtime_library IN_LIST _KNOWN_MSVC_RUNTIME_VALUES)
-            message(FATAL_ERROR "CMake-Conan: unable to map MSVC runtime: ${_msvc_runtime_library} to Conan settings")
-        endif()
-
-        # Runtime is "dynamic" in all cases if it ends in DLL
-        if(_msvc_runtime_library MATCHES ".*DLL$")
-            set(_compiler_runtime "dynamic")
-        else()
-            set(_compiler_runtime "static")
-        endif()
-        message(STATUS "CMake-Conan: CMake compiler.runtime=${_compiler_runtime}")
-
-        # Only define compiler.runtime_type when explicitly requested
-        # If a generator expression is used, let Conan handle it conditional on build_type
-        if(NOT _msvc_runtime_library MATCHES "<CONFIG:Debug>:Debug>")
-            if(_msvc_runtime_library MATCHES "Debug")
-                set(_compiler_runtime_type "Debug")
-            else()
-                set(_compiler_runtime_type "Release")
-            endif()
-            message(STATUS "CMake-Conan: CMake compiler.runtime_type=${_compiler_runtime_type}")
-        endif()
-
-        unset(_KNOWN_MSVC_RUNTIME_VALUES)
-
-    elseif(_compiler MATCHES AppleClang)
-        set(_compiler "apple-clang")
-        string(REPLACE "." ";" VERSION_LIST ${_compiler_version})
-        list(GET VERSION_LIST 0 _compiler_version)
-    elseif(_compiler MATCHES Clang)
-        set(_compiler "clang")
-        string(REPLACE "." ";" VERSION_LIST ${_compiler_version})
-        list(GET VERSION_LIST 0 _compiler_version)
-    elseif(_compiler MATCHES GNU)
-        set(_compiler "gcc")
-        string(REPLACE "." ";" VERSION_LIST ${_compiler_version})
-        list(GET VERSION_LIST 0 _compiler_version)
-    endif()
-
-    message(STATUS "CMake-Conan: [settings] compiler=${_compiler}")
-    message(STATUS "CMake-Conan: [settings] compiler.version=${_compiler_version}")
-    if (_compiler_runtime)
-        message(STATUS "CMake-Conan: [settings] compiler.runtime=${_compiler_runtime}")
-    endif()
-    if (_compiler_runtime_type)
-        message(STATUS "CMake-Conan: [settings] compiler.runtime_type=${_compiler_runtime_type}")
-    endif()
-
-    set(${compiler} ${_compiler} PARENT_SCOPE)
-    set(${compiler_version} ${_compiler_version} PARENT_SCOPE)
-    set(${compiler_runtime} ${_compiler_runtime} PARENT_SCOPE)
-    set(${compiler_runtime_type} ${_compiler_runtime_type} PARENT_SCOPE)
-endfunction()
-
-
-function(detect_build_type build_type)
-    get_property(multiconfig_generator GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
-    if(NOT multiconfig_generator)
-        # Only set when we know we are in a single-configuration generator
-        # Note: we may want to fail early if `CMAKE_BUILD_TYPE` is not defined
-        set(${build_type} ${CMAKE_BUILD_TYPE} PARENT_SCOPE)
-    endif()
-endfunction()
-
-
-macro(set_conan_compiler_if_appleclang lang command output_variable)
-    if(CMAKE_${lang}_COMPILER_ID STREQUAL "AppleClang")
-        execute_process(COMMAND xcrun --find ${command}
-            OUTPUT_VARIABLE _xcrun_out OUTPUT_STRIP_TRAILING_WHITESPACE)
-        cmake_path(GET _xcrun_out PARENT_PATH _xcrun_toolchain_path)
-        cmake_path(GET CMAKE_${lang}_COMPILER PARENT_PATH _compiler_parent_path)
-        if ("${_xcrun_toolchain_path}" STREQUAL "${_compiler_parent_path}")
-            set(${output_variable} "")
-        endif()
-        unset(_xcrun_out)
-        unset(_xcrun_toolchain_path)
-        unset(_compiler_parent_path)
-    endif()
-endmacro()
-
-
-macro(append_compiler_executables_configuration)
-    set(_conan_c_compiler "")
-    set(_conan_cpp_compiler "")
-    set(_conan_rc_compiler "")
-    set(_conan_compilers_list "")
-    if(CMAKE_C_COMPILER)
-        set(_conan_c_compiler "\"c\":\"${CMAKE_C_COMPILER}\"")
-        set_conan_compiler_if_appleclang(C cc _conan_c_compiler)
-        list(APPEND _conan_compilers_list ${_conan_c_compiler})
-    else()
-        message(WARNING "CMake-Conan: The C compiler is not defined. "
-                        "Please define CMAKE_C_COMPILER or enable the C language.")
-    endif()
-    if(CMAKE_CXX_COMPILER)
-        set(_conan_cpp_compiler "\"cpp\":\"${CMAKE_CXX_COMPILER}\"")
-        set_conan_compiler_if_appleclang(CXX c++ _conan_cpp_compiler)
-        list(APPEND _conan_compilers_list ${_conan_cpp_compiler})
-    else()
-        message(WARNING "CMake-Conan: The C++ compiler is not defined. "
-                        "Please define CMAKE_CXX_COMPILER or enable the C++ language.")
-    endif()
-    if(CMAKE_RC_COMPILER)
-        set(_conan_rc_compiler "\"rc\":\"${CMAKE_RC_COMPILER}\"")
-        list(APPEND _conan_compilers_list ${_conan_rc_compiler})
-        # Not necessary to warn if RC not defined
-    endif()
-    if(NOT "x${_conan_compilers_list}" STREQUAL "x")
-        if (NOT CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
-            string(REPLACE ";" "," _conan_compilers_list "${_conan_compilers_list}")
-            string(APPEND profile "tools.build:compiler_executables={${_conan_compilers_list}}\n")
-        endif()
-    endif()
-    unset(_conan_c_compiler)
-    unset(_conan_cpp_compiler)
-    unset(_conan_rc_compiler)
-    unset(_conan_compilers_list)
-endmacro()
-
-
-function(detect_host_profile output_file)
-    detect_os(os os_api_level os_sdk os_subsystem os_version)
-    detect_arch(arch)
-    detect_compiler(compiler compiler_version compiler_runtime compiler_runtime_type)
-    detect_cxx_standard(${compiler} compiler_cppstd)
-    detect_lib_cxx(compiler_libcxx)
-    detect_build_type(build_type)
-
-    set(profile "")
-    string(APPEND profile "[settings]\n")
-    if(arch)
-        string(APPEND profile arch=${arch} "\n")
-    endif()
-    if(os)
-        string(APPEND profile os=${os} "\n")
-    endif()
-    if(os_api_level)
-        string(APPEND profile os.api_level=${os_api_level} "\n")
-    endif()
-    if(os_version)
-        string(APPEND profile os.version=${os_version} "\n")
-    endif()
-    if(os_sdk)
-        string(APPEND profile os.sdk=${os_sdk} "\n")
-    endif()
-    if(os_subsystem)
-        string(APPEND profile os.subsystem=${os_subsystem} "\n")
-    endif()
-    if(compiler)
-        string(APPEND profile compiler=${compiler} "\n")
-    endif()
-    if(compiler_version)
-        string(APPEND profile compiler.version=${compiler_version} "\n")
-    endif()
-    if(compiler_runtime)
-        string(APPEND profile compiler.runtime=${compiler_runtime} "\n")
-    endif()
-    if(compiler_runtime_type)
-        string(APPEND profile compiler.runtime_type=${compiler_runtime_type} "\n")
-    endif()
-    if(compiler_cppstd)
-        string(APPEND profile compiler.cppstd=${compiler_cppstd} "\n")
-    endif()
-    if(compiler_libcxx)
-        string(APPEND profile compiler.libcxx=${compiler_libcxx} "\n")
-    endif()
-    if(build_type)
-        string(APPEND profile "build_type=${build_type}\n")
-    endif()
-
-    if(NOT DEFINED output_file)
-        set(file_name "${CMAKE_BINARY_DIR}/profile")
-    else()
-        set(file_name ${output_file})
-    endif()
-
-    string(APPEND profile "[conf]\n")
-    string(APPEND profile "tools.cmake.cmaketoolchain:generator=${CMAKE_GENERATOR}\n")
-
-    # propagate compilers via profile
-    append_compiler_executables_configuration()
-
-    if(os STREQUAL "Android")
-        string(APPEND profile "tools.android:ndk_path=${CMAKE_ANDROID_NDK}\n")
-    endif()
-
-    message(STATUS "CMake-Conan: Creating profile ${file_name}")
-    file(WRITE ${file_name} ${profile})
-    message(STATUS "CMake-Conan: Profile: \n${profile}")
-endfunction()
-
-
-function(conan_profile_detect_default)
-    message(STATUS "CMake-Conan: Checking if a default profile exists")
-    execute_process(COMMAND ${CONAN_COMMAND} profile path default
-                    RESULT_VARIABLE return_code
-                    OUTPUT_VARIABLE conan_stdout
-                    ERROR_VARIABLE conan_stderr
-                    ECHO_ERROR_VARIABLE    # show the text output regardless
-                    ECHO_OUTPUT_VARIABLE
-                    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
-    if(NOT ${return_code} EQUAL "0")
-        message(STATUS "CMake-Conan: The default profile doesn't exist, detecting it.")
-        execute_process(COMMAND ${CONAN_COMMAND} profile detect
-            RESULT_VARIABLE return_code
-            OUTPUT_VARIABLE conan_stdout
-            ERROR_VARIABLE conan_stderr
-            ECHO_ERROR_VARIABLE    # show the text output regardless
-            ECHO_OUTPUT_VARIABLE
-            WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
-    endif()
-endfunction()
-
-
-function(conan_install)
-    set(conan_output_folder ${CMAKE_BINARY_DIR}/conan)
-    # Invoke "conan install" with the provided arguments
-    set(conan_args -of=${conan_output_folder})
-    message(STATUS "CMake-Conan: conan install ${CMAKE_SOURCE_DIR} ${conan_args} ${ARGN}")
-
-
-    # In case there was not a valid cmake executable in the PATH, we inject the
-    # same we used to invoke the provider to the PATH
-    if(DEFINED PATH_TO_CMAKE_BIN)
-        set(old_path $ENV{PATH})
-        set(ENV{PATH} "$ENV{PATH}:${PATH_TO_CMAKE_BIN}")
-    endif()
-
-    execute_process(COMMAND ${CONAN_COMMAND} install ${CMAKE_SOURCE_DIR} ${conan_args} ${ARGN} --format=json
-                    RESULT_VARIABLE return_code
-                    OUTPUT_VARIABLE conan_stdout
-                    ERROR_VARIABLE conan_stderr
-                    ECHO_ERROR_VARIABLE    # show the text output regardless
-                    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
-
-    if(DEFINED PATH_TO_CMAKE_BIN)
-        set(ENV{PATH} "${old_path}")
-    endif()
-
-    if(NOT "${return_code}" STREQUAL "0")
-        message(FATAL_ERROR "Conan install failed='${return_code}'")
-    endif()
-
-    # the files are generated in a folder that depends on the layout used, if
-    # one is specified, but we don't know a priori where this is.
-    # TODO: this can be made more robust if Conan can provide this in the json output
-    string(JSON conan_generators_folder GET "${conan_stdout}" graph nodes 0 generators_folder)
-    cmake_path(CONVERT ${conan_generators_folder} TO_CMAKE_PATH_LIST conan_generators_folder)
-
-    message(STATUS "CMake-Conan: CONAN_GENERATORS_FOLDER=${conan_generators_folder}")
-    set_property(GLOBAL PROPERTY CONAN_GENERATORS_FOLDER "${conan_generators_folder}")
-    # reconfigure on conanfile changes
-    string(JSON conanfile GET "${conan_stdout}" graph nodes 0 label)
-    message(STATUS "CMake-Conan: CONANFILE=${CMAKE_SOURCE_DIR}/${conanfile}")
-    set_property(DIRECTORY ${CMAKE_SOURCE_DIR} APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS "${CMAKE_SOURCE_DIR}/${conanfile}")
-    # success
-    set_property(GLOBAL PROPERTY CONAN_INSTALL_SUCCESS TRUE)
-
-endfunction()
-
-
-function(conan_get_version conan_command conan_current_version)
-    execute_process(
-        COMMAND ${conan_command} --version
-        OUTPUT_VARIABLE conan_output
-        RESULT_VARIABLE conan_result
-        OUTPUT_STRIP_TRAILING_WHITESPACE
-    )
-    if(conan_result)
-        message(FATAL_ERROR "CMake-Conan: Error when trying to run Conan")
-    endif()
-
-    string(REGEX MATCH "[0-9]+\\.[0-9]+\\.[0-9]+" conan_version ${conan_output})
-    set(${conan_current_version} ${conan_version} PARENT_SCOPE)
-endfunction()
-
-
-function(conan_version_check)
-    set(options )
-    set(one_value_args MINIMUM CURRENT)
-    set(multi_value_args )
-    cmake_parse_arguments(conan_version_check
-        "${options}" "${one_value_args}" "${multi_value_args}" ${ARGN})
-
-    if(NOT conan_version_check_MINIMUM)
-        message(FATAL_ERROR "CMake-Conan: Required parameter MINIMUM not set!")
-    endif()
-        if(NOT conan_version_check_CURRENT)
-        message(FATAL_ERROR "CMake-Conan: Required parameter CURRENT not set!")
-    endif()
-
-    if(conan_version_check_CURRENT VERSION_LESS conan_version_check_MINIMUM)
-        message(FATAL_ERROR "CMake-Conan: Conan version must be ${conan_version_check_MINIMUM} or later")
-    endif()
-endfunction()
-
-
-macro(construct_profile_argument argument_variable profile_list)
-    set(${argument_variable} "")
-    if("${profile_list}" STREQUAL "CONAN_HOST_PROFILE")
-        set(_arg_flag "--profile:host=")
-    elseif("${profile_list}" STREQUAL "CONAN_BUILD_PROFILE")
-        set(_arg_flag "--profile:build=")
-    endif()
-
-    set(_profile_list "${${profile_list}}")
-    list(TRANSFORM _profile_list REPLACE "auto-cmake" "${CMAKE_BINARY_DIR}/conan_host_profile")
-    list(TRANSFORM _profile_list PREPEND ${_arg_flag})
-    set(${argument_variable} ${_profile_list})
-
-    unset(_arg_flag)
-    unset(_profile_list)
-endmacro()
-
-
-macro(conan_provide_dependency method package_name)
-    set_property(GLOBAL PROPERTY CONAN_PROVIDE_DEPENDENCY_INVOKED TRUE)
-    get_property(_conan_install_success GLOBAL PROPERTY CONAN_INSTALL_SUCCESS)
-    if(NOT _conan_install_success)
-        find_program(CONAN_COMMAND "conan" REQUIRED)
-        conan_get_version(${CONAN_COMMAND} CONAN_CURRENT_VERSION)
-        conan_version_check(MINIMUM ${CONAN_MINIMUM_VERSION} CURRENT ${CONAN_CURRENT_VERSION})
-        message(STATUS "CMake-Conan: first find_package() found. Installing dependencies with Conan")
-        if("default" IN_LIST CONAN_HOST_PROFILE OR "default" IN_LIST CONAN_BUILD_PROFILE)
-            conan_profile_detect_default()
-        endif()
-        if("auto-cmake" IN_LIST CONAN_HOST_PROFILE)
-            detect_host_profile(${CMAKE_BINARY_DIR}/conan_host_profile)
-        endif()
-        construct_profile_argument(_host_profile_flags CONAN_HOST_PROFILE)
-        construct_profile_argument(_build_profile_flags CONAN_BUILD_PROFILE)
-        if(EXISTS "${CMAKE_SOURCE_DIR}/conanfile.py")
-            file(READ "${CMAKE_SOURCE_DIR}/conanfile.py" outfile)
-            if(NOT "${outfile}" MATCHES ".*CMakeConfigDeps.*")
-                message(WARNING "Cmake-conan: CMakeConfigDeps generator was not defined in the conanfile")
-            endif()
-        elseif (EXISTS "${CMAKE_SOURCE_DIR}/conanfile.txt")
-            file(READ "${CMAKE_SOURCE_DIR}/conanfile.txt" outfile)
-            if(NOT "${outfile}" MATCHES ".*CMakeConfigDeps.*")
-                message(WARNING "Cmake-conan: CMakeConfigDeps generator was not defined in the conanfile")
-            endif()
-        endif()
-
-        get_property(_multiconfig_generator GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
-        
-        if(DEFINED CONAN_INSTALL_BUILD_CONFIGURATIONS)
-            # Configurations are specified by the project or user
-            set(_build_configs "${CONAN_INSTALL_BUILD_CONFIGURATIONS}")
-            list(LENGTH _build_configs _build_configs_length)
-            if(NOT _multiconfig_generator AND _build_configs_length GREATER 1)
-                message(FATAL_ERROR "cmake-conan: when using a single-config CMake generator, "
-                        "please only specify a single configuration in CONAN_INSTALL_BUILD_CONFIGURATIONS")
-            endif()
-            unset(_build_configs_length)
-        else()
-            # No configuration overrides, provide sensible defaults            
-            if(_multiconfig_generator)
-                set(_build_configs Release Debug)
-            else()
-                set(_build_configs ${CMAKE_BUILD_TYPE})
-            endif()
-            
-        endif()
-
-        list(JOIN _build_configs ", " _build_configs_msg)
-        message(STATUS "CMake-Conan: Installing configuration(s): ${_build_configs_msg}")
-        foreach(_build_config IN LISTS _build_configs)
-            set(_self_build_config "")
-            if(NOT _multiconfig_generator AND NOT _build_config STREQUAL "${CMAKE_BUILD_TYPE}")
-                set(_self_build_config -s &:build_type=${CMAKE_BUILD_TYPE})
-            endif()
-            conan_install(${_host_profile_flags} ${_build_profile_flags} -s build_type=${_build_config} ${_self_build_config} ${CONAN_INSTALL_ARGS})
-        endforeach()
-
-        get_property(_conan_generators_folder GLOBAL PROPERTY CONAN_GENERATORS_FOLDER)
-        if(EXISTS "${_conan_generators_folder}/conan_cmakedeps_paths.cmake")
-            message(STATUS "CMake-Conan: Loading conan_cmakedeps_paths.cmake file")
-            include(${_conan_generators_folder}/conan_cmakedeps_paths.cmake)
-        endif()
-
-        unset(_self_build_config)
-        unset(_multiconfig_generator)
-        unset(_build_configs)
-        unset(_build_configs_msg)
-        unset(_host_profile_flags)
-        unset(_build_profile_flags)
-        unset(_conan_install_success)
-    else()
-        message(STATUS "CMake-Conan: find_package(${ARGV1}) found, 'conan install' already ran")
-        unset(_conan_install_success)
-    endif()
-
-    get_property(_conan_generators_folder GLOBAL PROPERTY CONAN_GENERATORS_FOLDER)
-
-    # Ensure that we consider Conan-provided packages ahead of any other,
-    # irrespective of other settings that modify the search order or search paths
-    # This follows the guidelines from the find_package documentation
-    #  (https://cmake.org/cmake/help/latest/command/find_package.html):
-    #       find_package (<PackageName> PATHS paths... NO_DEFAULT_PATH)
-    #       find_package (<PackageName>)
-
-    # Filter out `REQUIRED` from the argument list, as the first call may fail
-    set(_find_args_${package_name} "${ARGN}")
-    list(REMOVE_ITEM _find_args_${package_name} "REQUIRED")
-    if(NOT "MODULE" IN_LIST _find_args_${package_name})
-        find_package(${package_name} ${_find_args_${package_name}} BYPASS_PROVIDER PATHS "${_conan_generators_folder}" NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH)
-        unset(_find_args_${package_name})
-    endif()
-
-    # Invoke find_package a second time - if the first call succeeded,
-    # this will simply reuse the result. If not, fall back to CMake default search
-    # behaviour, also allowing modules to be searched.
-    if(NOT ${package_name}_FOUND)
-        list(FIND CMAKE_MODULE_PATH "${_conan_generators_folder}" _index)
-        if(_index EQUAL -1)
-            list(PREPEND CMAKE_MODULE_PATH "${_conan_generators_folder}")
-        endif()
-        unset(_index)
-        find_package(${package_name} ${ARGN} BYPASS_PROVIDER)
-        list(REMOVE_ITEM CMAKE_MODULE_PATH "${_conan_generators_folder}")
-    endif()
-endmacro()
-
-
-cmake_language(
-    SET_DEPENDENCY_PROVIDER conan_provide_dependency
-    SUPPORTED_METHODS FIND_PACKAGE
-)
-
-
-macro(conan_provide_dependency_check)
-    set(_conan_provide_dependency_invoked FALSE)
-    get_property(_conan_provide_dependency_invoked GLOBAL PROPERTY CONAN_PROVIDE_DEPENDENCY_INVOKED)
-    if(NOT _conan_provide_dependency_invoked)
-        message(WARNING "Conan is correctly configured as dependency provider, "
-                        "but Conan has not been invoked. Please add at least one "
-                        "call to `find_package()`.")
-        if(DEFINED CONAN_COMMAND)
-            # supress warning in case `CONAN_COMMAND` was specified but unused.
-            set(_conan_command ${CONAN_COMMAND})
-            unset(_conan_command)
-        endif()
-    endif()
-    unset(_conan_provide_dependency_invoked)
-endmacro()
-
-
-# Add a deferred call at the end of processing the top-level directory
-# to check if the dependency provider was invoked at all.
-cmake_language(DEFER DIRECTORY "${CMAKE_SOURCE_DIR}" CALL conan_provide_dependency_check)
-
-# Configurable variables for Conan profiles
-set(CONAN_HOST_PROFILE "default;auto-cmake" CACHE STRING "Conan host profile")
-set(CONAN_BUILD_PROFILE "default" CACHE STRING "Conan build profile")
-set(CONAN_INSTALL_ARGS "--build=missing" CACHE STRING "Command line arguments for conan install")
-
-find_program(_cmake_program NAMES cmake NO_PACKAGE_ROOT_PATH NO_CMAKE_PATH NO_CMAKE_ENVIRONMENT_PATH NO_CMAKE_SYSTEM_PATH NO_CMAKE_FIND_ROOT_PATH)
-if(NOT _cmake_program)
-    get_filename_component(PATH_TO_CMAKE_BIN "${CMAKE_COMMAND}" DIRECTORY)
-    set(PATH_TO_CMAKE_BIN "${PATH_TO_CMAKE_BIN}" CACHE INTERNAL "Path where the CMake executable is")
-endif()
-
-cmake_policy(POP)

conanfile.py

@@ -1,42 +0,0 @@
-from conan import ConanFile
-
-class AmneziaVPN(ConanFile):
-    settings = "os", "compiler", "build_type", "arch"
-    generators = "CMakeConfigDeps"
-
-    options = {
-        "macos_ne": [True, False]
-    }
-    default_options = {
-        "macos_ne": False
-    }
-
-    def requirements(self):
-        os = str(self.settings.os)
-
-        has_ne = os == "iOS" or (os == "Macos" and self.options.macos_ne)
-        has_service = os == "Windows" or os == "Linux" or (os == "Macos" and not has_ne)
-
-        if has_service:
-            if os == "Windows":
-                self.requires("awg-windows/1.0.0")
-            else:
-                self.requires("awg-go/0.2.16")
-
-            self.requires("amnezia-xray-bindings/1.1.0")
-            self.requires("tun2socks/2.6.0")
-            self.requires("openvpn/2.7.0")
-            self.requires("v2ray-rules-dat/[*]")
-
-        if has_ne:
-            self.requires("awg-apple/2.0.1")
-            self.requires("hev-socks5-tunnel/2.14.4", options={"as_framework": True})
-            self.requires("openvpnadapter/1.0.0")
-
-        if os == "Android":
-            self.requires("amnezia-libxray/1.0.0")
-            self.requires("awg-android/1.1.7")
-            self.requires("openvpn-pt-android/1.0.0")
-
-        self.requires("libssh/0.11.3@amnezia")
-        self.requires("openssl/3.5.5")

deploy/data/windows/x32/post_uninstall.cmd

@@ -14,8 +14,6 @@ sc stop AmneziaVPN-service
 sc delete AmneziaVPN-service
 sc stop AmneziaWGTunnel$AmneziaVPN
 sc delete AmneziaWGTunnel$AmneziaVPN
-sc stop AmneziaVPNSplitTunnel
-sc delete AmneziaVPNSplitTunnel
 taskkill /IM "AmneziaVPN-service.exe" /F
 taskkill /IM "AmneziaVPN.exe" /F
 

deploy/data/windows/x64/post_uninstall.cmd

@@ -14,8 +14,6 @@ sc stop AmneziaVPN-service
 sc delete AmneziaVPN-service
 sc stop AmneziaWGTunnel$AmneziaVPN
 sc delete AmneziaWGTunnel$AmneziaVPN
-sc stop AmneziaVPNSplitTunnel
-sc delete AmneziaVPNSplitTunnel
 taskkill /IM "AmneziaVPN-service.exe" /F
 taskkill /IM "AmneziaVPN.exe" /F
 

ipc/ipc_interface.rep

@@ -45,6 +45,5 @@ class IpcInterface
     SLOT( bool stopNetworkCheck() );
 
     SIGNAL( connectionLose() );
-    SIGNAL( wakeup() );
-    SIGNAL( networkChanged() );
+    SIGNAL( networkChange() );
 };

recipes/amnezia-libxray/conanfile.py

@@ -1,48 +0,0 @@
-from conan import ConanFile
-from conan.tools.files import get, copy
-from conan.tools.layout import basic_layout
-from conan.errors import ConanInvalidConfiguration
-
-import os
-import stat
-
-class AmneziaLibxray(ConanFile):
-    name = "amnezia-libxray"
-    version = "1.0.0"
-
-    settings = "os", "arch"
-    options = {"page_16k": [True, False]}
-    default_options = {"page_16k": True}
-
-    def layout(self):
-        basic_layout(self, build_folder=".")
-
-    def build_requirements(self):
-        self.tool_requires("go/1.26.0")
-    
-    def validate(self):
-        if self.settings.os != "Android":
-            raise ConanInvalidConfiguration(f"{self.name} v{self.version} does not support {self.settings.os}")
-
-    def source(self):
-        get(self, "https://github.com/amnezia-vpn/amnezia-libxray/archive/refs/tags/v1.0.0.zip",
-            sha256="0c50c5acd5063a9fc3cfbb5b3e11481d30cfa3762b3cb1d72130248ff498e9df", strip_root=True
-        )
-
-    def _patch_sources(self):
-        build_path = os.path.join(self.build_folder, "build.sh")
-        build_stat = os.stat(build_path)
-        os.chmod(build_path, build_stat.st_mode | stat.S_IEXEC)
-
-    def build(self):
-        self._patch_sources()
-        cgo_ldflags = 'CGO_LDFLAGS="-Wl,-z,max-page-size=16384" ' if self.options.page_16k else ""
-        self.run(f'{cgo_ldflags}./build.sh android')
-
-    def package(self):
-        copy(self, "libxray.aar", src=self.build_folder, dst=os.path.join(self.package_folder, "aar"))
-
-    def package_info(self):
-        self.cpp_info.set_property("cmake_extra_variables", {
-            "AMNEZIA_LIBXRAY_PATH": os.path.join(self.package_folder, "aar", "libxray.aar"),
-        })

recipes/amnezia-xray-bindings/conanfile.py

@@ -1,90 +0,0 @@
-# conanfile.py
-from conan import ConanFile
-from conan.tools.files import get, copy, collect_libs, chdir
-from conan.tools.layout import basic_layout
-from conan.errors import ConanInvalidConfiguration
-from conan.tools.gnu import Autotools, AutotoolsToolchain
-from conan.tools.env import Environment
-
-import os
-
-class AmneziaXrayBindings(ConanFile):
-    name = "amnezia-xray-bindings"
-    version = "1.1.0"
-
-    settings = "os", "arch"
-
-    @property
-    def _goos(self):
-        return {
-            "Linux": "linux",
-            "iOS": "ios",
-            "Macos": "darwin",
-            "Windows": "windows"
-        }.get(str(self.settings.os))
-    
-    @property
-    def _goarch(self):
-        return {
-            "x86": "386",
-            "x86_64": "amd64",
-            "armv8": "arm64"
-        }.get(str(self.settings.arch))
-    
-    @property
-    def _is_windows(self):
-        return str(self.settings.os).startswith("Windows")
-
-    def validate(self):
-        if not self._goos or not self._goarch:
-            raise ConanInvalidConfiguration(
-                f"{self.name} v{self.version} does not support {self.settings.os} {self.settings.arch}"
-            )
-
-    def layout(self):
-        basic_layout(self)
-
-    def build_requirements(self):
-        self.tool_requires("go/1.26.0")
-
-    def source(self):
-        get(self, "https://github.com/amnezia-vpn/amnezia-xray-bindings/archive/v1.1.0.zip",
-            sha256="6ea768ec7002cedd422a39aea17704b888acaf794432aa5937cfc92fb6d80eb5", strip_root=True)
-
-    def generate(self):
-        tc = AutotoolsToolchain(self)
-        env = Environment()
-        env.define("ARCH", self._goarch)
-        env.define("GOARCH", self._goarch)
-        env.define("GOOS", self._goos)
-        env.define("CGO_LDFLAGS", tc.ldflags)
-        env.define("CGO_CFLAGS", tc.cflags)
-        if self._is_windows:
-            env.define("OS", "windows")
-        tc.generate(env)
-
-    def build(self):
-        with chdir(self, self.source_folder):
-            autotools = Autotools(self)
-            autotools.make()
-
-    def _rename_libs(self):
-        # workaround of bad naming strategy in amnezia-xray-bindings
-        # TODO: change it and kick out the code below
-        lib_dir = os.path.join(self.package_folder, "lib")
-        for fname in os.listdir(lib_dir):
-            if not fname.startswith("lib"):
-                src = os.path.join(lib_dir, fname)
-                dst = os.path.join(lib_dir, "lib" + fname)
-                os.rename(src, dst)
-
-    def package(self):
-        copy(self, "*.h", src=self.build_folder, dst=os.path.join(self.package_folder, "include"))
-        copy(self, "*.a", src=self.build_folder, dst=os.path.join(self.package_folder, "lib"))
-        copy(self, "*.dll", src=self.build_folder, dst=os.path.join(self.package_folder, "lib"))
-        copy(self, "*.lib", src=self.build_folder, dst=os.path.join(self.package_folder, "lib"))
-        self._rename_libs()
-
-    def package_info(self):
-        self.cpp_info.set_property("cmake_target_name", "amnezia::xray-bindings")
-        self.cpp_info.libs = collect_libs(self)

recipes/android-openssl/conanfile.py

@@ -1,131 +0,0 @@
-import os
-import platform
-import re
-import shutil
-
-from conan import ConanFile
-from conan.tools.files import copy
-from conan.tools.scm import Git
-from conan.errors import ConanInvalidConfiguration, ConanException
-
-
-class AndroidOpenSSL(ConanFile):
-    name = "android-openssl"
-    version = "3.5.5"
-    settings = "os", "arch"
-    options = {"page_16k": [True, False]}
-    default_options = {"page_16k": True}
-
-    # Conan arch → OpenSSL Configure target
-    _arch_map = {
-        "armv8":   "android-arm64",
-        "armv7":   "android-arm",
-        "x86_64":  "android-x86_64",
-        "x86":     "android-x86",
-    }
-
-    def validate(self):
-        if self.settings.os != "Android":
-            raise ConanInvalidConfiguration(f"{self.name} only supports Android")
-        if str(self.settings.arch) not in self._arch_map:
-            raise ConanInvalidConfiguration(f"Unsupported arch: {self.settings.arch}")
-
-    def source(self):
-        git = Git(self)
-        git.clone(
-            url="https://github.com/openssl/openssl.git",
-            target=".",
-            args=["--branch", f"openssl-{self.version}", "--depth", "1"]
-        )
-
-    def _ndk(self):
-        ndk = self.conf.get("tools.android:ndk_path", check_type=str) or \
-              os.environ.get("ANDROID_NDK_ROOT", "")
-        if not ndk:
-            raise ConanException(
-                "Android NDK not found. Set tools.android:ndk_path conf or ANDROID_NDK_ROOT env."
-            )
-        return ndk
-
-    def _toolchain_bin(self):
-        host = "linux-x86_64" if platform.system() == "Linux" else "darwin-x86_64"
-        return os.path.join(self._ndk(), "toolchains", "llvm", "prebuilt", host, "bin")
-
-    def _patch_makefile(self, makefile_path, page_16k=False):
-        """Rename libcrypto.so → libcrypto_3.so and libssl.so → libssl_3.so
-        throughout the generated Makefile so the built files already carry the
-        correct names and sonames — no patchelf required.
-        Optionally append the 16KB page-size linker flag to LDFLAGS."""
-        with open(makefile_path, "r") as f:
-            content = f.read()
-
-        # Replace every standalone libcrypto.so / libssl.so reference.
-        # \b word-boundary keeps us from matching libcrypto.so.3 style names.
-        content = re.sub(r"\blibcrypto\.so\b", "libcrypto_3.so", content)
-        content = re.sub(r"\blibssl\.so\b",    "libssl_3.so",    content)
-
-        if page_16k:
-            page_flag = "-Wl,-z,max-page-size=16384"
-            content = re.sub(
-                r"^(LDFLAGS\s*=)(.*?)$",
-                lambda m: m.group(0) + " " + page_flag if page_flag not in m.group(0) else m.group(0),
-                content,
-                flags=re.MULTILINE,
-            )
-
-        with open(makefile_path, "w") as f:
-            f.write(content)
-
-    def build(self):
-        ndk = self._ndk()
-        toolchain_bin = self._toolchain_bin()
-        target = self._arch_map[str(self.settings.arch)]
-        api_level = str(self.settings.os.api_level)
-        jobs = os.cpu_count() or 4
-
-        env_prefix = f'PATH="{toolchain_bin}:$PATH" ANDROID_NDK_ROOT="{ndk}"'
-
-        configure_cmd = (
-            f"./Configure {target} shared no-tests"
-            f" -D__ANDROID_API__={api_level}"
-        )
-
-        self.run(f"{env_prefix} {configure_cmd}", cwd=self.source_folder)
-
-        self._patch_makefile(
-            os.path.join(self.source_folder, "Makefile"),
-            page_16k=bool(self.options.page_16k),
-        )
-
-        self.run(
-            f"{env_prefix} make -j{jobs} SHLIB_VERSION_NUMBER= build_libs",
-            cwd=self.source_folder
-        )
-
-    def package(self):
-        lib_dst = os.path.join(self.package_folder, "lib")
-        os.makedirs(lib_dst, exist_ok=True)
-
-        copy(self, "libcrypto_3.so", src=self.source_folder, dst=lib_dst, keep_path=False)
-        copy(self, "libssl_3.so",    src=self.source_folder, dst=lib_dst, keep_path=False)
-
-        # Static libs (still named without suffix)
-        copy(self, "libcrypto.a", src=self.source_folder, dst=lib_dst, keep_path=False)
-        copy(self, "libssl.a",    src=self.source_folder, dst=lib_dst, keep_path=False)
-
-        # Headers
-        copy(self, "include/openssl/*.h", src=self.source_folder, dst=self.package_folder)
-
-    def package_info(self):
-        # Expose the same CMake targets as the upstream openssl package so
-        # consumers (libssh, main app) need no changes to their target_link_libraries.
-        self.cpp_info.components["crypto"].set_property("cmake_target_name", "OpenSSL::Crypto")
-        self.cpp_info.components["crypto"].libs = ["crypto_3"]
-        self.cpp_info.components["crypto"].includedirs = ["include"]
-        self.cpp_info.components["crypto"].libdirs = ["lib"]
-
-        self.cpp_info.components["ssl"].set_property("cmake_target_name", "OpenSSL::SSL")
-        self.cpp_info.components["ssl"].libs = ["ssl_3"]
-        self.cpp_info.components["ssl"].includedirs = []
-        self.cpp_info.components["ssl"].libdirs = ["lib"]
-        self.cpp_info.components["ssl"].requires = ["crypto"]

recipes/awg-android/conanfile.py

@@ -1,94 +0,0 @@
-from conan import ConanFile
-from conan.tools.cmake import cmake_layout, CMake, CMakeToolchain
-from conan.tools.env import VirtualBuildEnv
-from conan.tools.files import copy, replace_in_file
-from conan.errors import ConanInvalidConfiguration
-from conan.tools.scm import Git
-
-import os
-import platform
-
-class AwgAndroid(ConanFile):
-    name = "awg-android"
-    version = "1.1.7"
-    settings = "os", "arch", "build_type", "compiler"
-    package_type = "shared-library"
-    options = {"page_16k": [True, False]}
-    default_options = {"page_16k": True}
-
-    def layout(self):
-        cmake_layout(self)
-
-    def build_requirements(self):
-        self.tool_requires("cmake/[>=3.4.1 <4]")
-
-    def validate(self):
-        if self.settings.os != "Android":
-            raise ConanInvalidConfiguration(f"{self.name} v{self.version} does not support {self.settings.os}")
-
-    def source(self):
-        git = Git(self)
-        git.clone(
-            url="https://github.com/amnezia-vpn/amneziawg-android.git",
-            target=".",
-            args=["--recurse-submodules", "--branch", f"v{self.version}"]
-        )
-
-    def generate(self):
-        tc = CMakeToolchain(self)
-        tc.variables["GRADLE_USER_HOME"] = os.path.join(self.build_folder, "gradle_user_home")
-        tc.variables["CMAKE_LIBRARY_OUTPUT_DIRECTORY"] = os.path.join(self.build_folder, "out")
-        if self.options.page_16k:
-            # Use cache_variables to override NDK toolchain defaults (extra_ldflags sets _INIT
-            # variants which the NDK toolchain can override). CMAKE_SHARED_LINKER_FLAGS is passed
-            # directly to the Go Makefile as LDFLAGS, which flows into CGO_LDFLAGS.
-            page_flag = "-Wl,-z,max-page-size=16384"
-            tc.cache_variables["CMAKE_EXE_LINKER_FLAGS"] = page_flag
-            tc.cache_variables["CMAKE_SHARED_LINKER_FLAGS"] = page_flag
-        tc.generate()
-
-        vbe = VirtualBuildEnv(self)
-        vbe.generate()
-
-    def _patch_sources(self):
-        if platform.system() == 'Darwin':
-            replace_in_file(self,
-                os.path.join(self.source_folder, "tunnel", "tools", "libwg-go", "Makefile"),
-                'flock "$@.lock" -c \' \\\n',
-                "",
-            )
-            replace_in_file(self,
-                os.path.join(self.source_folder, "tunnel", "tools", "libwg-go", "Makefile"),
-                'mv "$@.tmp" "$@"\'',
-                'mv "$@.tmp" "$@"',
-            )
-            replace_in_file(self,
-                os.path.join(self.source_folder, "tunnel", "tools", "libwg-go", "Makefile"),
-                'touch "$@"\'',
-                'touch "$@"',
-            )
-            replace_in_file(self,
-                os.path.join(self.source_folder, "tunnel", "tools", "libwg-go", "Makefile"),
-                'sha256sum -c',
-                'shasum -a 256 -c'
-            )
-
-    def build(self):
-        self._patch_sources()
-        cmake = CMake(self)
-        cmake.configure(build_script_folder=os.path.join(self.source_folder, "tunnel", "tools"))
-        cmake.build(target=["libwg-go.so", "libwg.so", "libwg-quick.so"])
-
-    def package(self):
-        copy(self, "libwg-go.h", src=os.path.join(self.build_folder, "out"), dst=os.path.join(self.package_folder, "include"))
-        copy(self, "libwg-go.so", src=os.path.join(self.build_folder, "out"), dst=os.path.join(self.package_folder, "lib"))
-        copy(self, "libwg.so", src=os.path.join(self.build_folder, "out"), dst=os.path.join(self.package_folder, "bin"))
-        copy(self, "libwg-quick.so", src=os.path.join(self.build_folder, "out"), dst=os.path.join(self.package_folder, "bin"))
-
-    def package_info(self):
-        self.cpp_info.set_property("cmake_target_name", "amnezia::awg-android")
-        self.cpp_info.libs = [ "wg-go" ]
-        self.cpp_info.set_property("cmake_extra_variables", {
-            "AMNEZIA_ANDROID_LIBWG_PATH": os.path.join(self.package_folder, "bin", "libwg.so"),
-            "AMNEZIA_ANDROID_LIBWG_QUICK_PATH": os.path.join(self.package_folder, "bin", "libwg-quick.so"),
-        })

recipes/awg-apple/conanfile.py

@@ -1,68 +0,0 @@
-from conan import ConanFile
-from conan.errors import ConanInvalidConfiguration
-from conan.tools.layout import basic_layout
-from conan.tools.files import get, copy, collect_libs, chdir
-from conan.tools.apple import is_apple_os
-from conan.tools.gnu import AutotoolsToolchain, Autotools
-
-import os
-
-class AwgApple(ConanFile):
-    name = "awg-apple"
-    version = "2.0.1"
-    settings = "os", "arch"
-    options = {
-        "as_framework": [True, False]
-    }
-    default_options = {
-        "as_framework": False
-    }
-
-    @property
-    def _goarch(self):
-        arch_map = {
-            "armv8": "arm64",
-            "x86_64": "x86_64",
-        }
-        archs = str(self.settings.arch).split("|")
-        return " ".join(arch_map.get(arch, arch) for arch in archs)
-
-    def build_requirements(self):
-        self.tool_requires("go/1.26.0")
-
-    def layout(self):
-        basic_layout(self, build_folder=os.path.join(self.folders.source, "Sources/WireGuardKitGo"))
-
-    def validate(self):
-        if not is_apple_os(self):
-            raise ConanInvalidConfiguration(
-                f"{self.name} v{self.version} does not support {self.settings.os}"
-            )
-
-    def source(self):
-        get(self, f"https://github.com/amnezia-vpn/amneziawg-apple/archive/refs/tags/v{self.version}.zip",
-            sha256="9fe4f8cfbb6a751558b54b7979db3a5ea46e49731912aae99f093e84a1433e97", strip_root=True
-        )
-
-    def generate(self):
-        tc = AutotoolsToolchain(self)
-        sdk = self.settings.get_safe("os.sdk", "macosx")
-        tc.make_args = [
-            f"ARCHS={self._goarch}",
-            f"PLATFORM_NAME={sdk}"
-        ]
-        tc.generate()
-
-    def build(self):
-        autotools = Autotools(self)
-        autotools.make()
-        autotools.make("version-header")
-
-    def package(self):
-        copy(self, "wireguard.h", src=self.build_folder, dst=os.path.join(self.package_folder, "include"))
-        copy(self, "*.h", src=os.path.join(self.build_folder, "out"), dst=os.path.join(self.package_folder, "include"))
-        copy(self, "*.a", src=os.path.join(self.build_folder, "out"), dst=os.path.join(self.package_folder, "lib"))
-
-    def package_info(self):
-        self.cpp_info.set_property("cmake_target_name", "amnezia::awg-apple")
-        self.cpp_info.libs = collect_libs(self)

recipes/awg-go/conanfile.py

@@ -1,66 +0,0 @@
-from conan import ConanFile
-from conan.errors import ConanInvalidConfiguration
-from conan.tools.layout import basic_layout
-from conan.tools.files import get, copy
-from conan.tools.gnu import Autotools, AutotoolsToolchain
-from conan.tools.env import Environment
-
-import os
-
-class AwgGo(ConanFile):
-    name = "awg-go"
-    version = "0.2.16"
-    package_type = "application"
-    settings = "os", "arch"
-
-    @property
-    def _goos(self):
-        return {
-            "Linux": "linux",
-            "Macos": "darwin",
-            "Windows": "windows"
-        }.get(str(self.settings.os))
-
-    @property
-    def _goarch(self):
-        return {
-            "x86": "386",
-            "x86_64": "amd64",
-            "armv8": "arm64"
-        }.get(str(self.settings.arch))
-
-    def build_requirements(self):
-        self.tool_requires("go/1.26.0")
-
-    def validate(self):
-        if not self._goos or not self._goarch:
-            raise ConanInvalidConfiguration(
-                f"{self.name} v{self.version} does not support {self.settings.os} {self.settings.arch}"
-            )
-
-    def source(self):
-        get(self, f"https://github.com/amnezia-vpn/amneziawg-go/archive/refs/tags/v{self.version}.zip",
-            sha256="34da7d4189f215f3930de441548bc2a0c89d54d347a4fb85cb9c715fce6413aa", strip_root=True
-        )
-
-    def layout(self):
-        basic_layout(self, build_folder=".")
-
-    def generate(self):
-        tc = AutotoolsToolchain(self)
-        env = Environment()
-        env.define("GOOS", self._goos)
-        env.define("GOARCH", self._goarch)
-        tc.generate(env)
-
-    def build(self):
-        at = Autotools(self)
-        at.make()
-
-    def package(self):
-        copy(self, "amneziawg-go", src=self.build_folder, dst=self.package_folder)
-
-    def package_info(self):
-        self.cpp_info.exe = True
-        self.cpp_info.location = os.path.join(self.package_folder, "amneziawg-go")
-        self.cpp_info.set_property("cmake_target_name", "amnezia::awg-go")

recipes/go/conandata.yml

@@ -1,26 +0,0 @@
-sources:
-  "1.26.0":
-    Macos:
-      x86_64:
-        url: "https://go.dev/dl/go1.26.0.darwin-amd64.tar.gz"
-        sha256: "1ca28b7703cbea05a65b2a1d92d6b308610ef92f8824578a0874f2e60c9d5a22"
-      armv8:
-        url: "https://go.dev/dl/go1.26.0.darwin-arm64.tar.gz"
-        sha256: "b1640525dfe68f066d56f200bef7bf4dce955a1a893bd061de6754c211431023"
-    Linux:
-      x86:
-        url: "https://go.dev/dl/go1.26.0.linux-386.tar.gz"
-        sha256: "35e2ec7a7ae6905a1fae5459197b70e3fcbc5e0a786a7d6ba8e49bcd38ad2e26"
-      x86_64:
-        url: "https://go.dev/dl/go1.26.0.linux-amd64.tar.gz"
-        sha256: "aac1b08a0fb0c4e0a7c1555beb7b59180b05dfc5a3d62e40e9de90cd42f88235"
-      armv8:
-        url: "https://go.dev/dl/go1.26.0.linux-arm64.tar.gz"
-        sha256: "bd03b743eb6eb4193ea3c3fd3956546bf0e3ca5b7076c8226334afe6b75704cd"
-    Windows:
-      x86:
-        url: "https://go.dev/dl/go1.26.0.windows-386.zip"
-        sha256: "50674f3d6a071fa1a4c1d76dc37fafa0330df87d84087a262fee020da5396b6b"
-      x86_64:
-        url: "https://go.dev/dl/go1.26.0.windows-amd64.zip"
-        sha256: "9bbe0fc64236b2b51f6255c05c4232532b8ecc0e6d2e00950bd3021d8a4d07d4"

recipes/go/conanfile.py

@@ -1,19 +0,0 @@
-from conan import ConanFile
-from conan.tools.files import get, copy
-
-import os
-
-class Golang(ConanFile):
-    name = "go"
-    version = "1.26.0"
-    
-    settings = "os", "arch"
-    
-    def build(self):
-        get(self, **self.conan_data["sources"][str(self.version)][str(self.settings.os)][str(self.settings.arch)])
-
-    def package(self):
-        copy(self, "*", src=os.path.join(self.source_folder, "go"), dst=self.package_folder)
-
-    def package_info(self):
-        self.cpp_info.bindirs = ["bin"]

recipes/hev-socks5-tunnel/conanfile.py

@@ -1,98 +0,0 @@
-from conan import ConanFile
-from conan.tools.layout import basic_layout
-from conan.tools.scm import Git
-from conan.tools.files import copy, collect_libs
-from conan.internal.model.pkg_type import PackageType
-from conan.tools.gnu import AutotoolsToolchain, Autotools
-from conan.tools.apple import is_apple_os
-
-import os
-import shutil
-
-
-required_conan_version = ">=2.26"
-
-
-class HevSocks5Tunnel(ConanFile):
-    name = "hev-socks5-tunnel"
-    version = "2.14.4"
-    settings = "os", "arch"
-    options = {
-        "shared": [True, False],
-        "as_framework": [True, False],
-    }
-    default_options = {
-        "shared": False,
-        "as_framework": False
-    }
-
-    def config_options(self):
-        if not is_apple_os(self):
-            del self.options.as_framework
-
-    def configure(self):
-        if self.options.get_safe("as_framework"):
-            self.options.shared = False
-
-    def layout(self):
-        basic_layout(self, build_folder=".")
-
-    def source(self):
-        git = Git(self)
-        git.clone(
-            url="https://github.com/heiher/hev-socks5-tunnel.git",
-            target=".",
-            args=["--recurse-submodules", "--branch", self.version]
-        )
-
-    def generate(self):
-        tc = AutotoolsToolchain(self)
-        tc.generate()
-
-    def build(self):
-        autotools = Autotools(self)
-        autotools.make("shared" if self.options.shared else "static")
-
-        if self.options.get_safe("as_framework"):
-            lib_path = os.path.join(self.build_folder, "bin", "libhev-socks5-tunnel.a")
-            self.run(
-                f"libtool -static -o {lib_path}"
-                f" {lib_path}"
-                f" {os.path.join(self.build_folder, "third-part", "lwip", "bin", "liblwip.a")}"
-                f" {os.path.join(self.build_folder, "third-part", "yaml", "bin", "libyaml.a")}"
-                f" {os.path.join(self.build_folder, "third-part", "hev-task-system", "bin", "libhev-task-system.a")}"
-            )
-
-            include_dir = os.path.join(self.build_folder, "framework_include")
-            copy(self, "hev-main.h", src=os.path.join(self.source_folder, "src"), dst=include_dir)
-            copy(self, "module.modulemap", src=os.path.join(self.source_folder), dst=include_dir)
-
-            self.run('xcodebuild -create-xcframework'
-                f' -library {lib_path}'
-                f' -headers {include_dir}'
-                f' -output {os.path.join(self.build_folder, "HevSocks5Tunnel.xcframework")}'
-            )
-
-    def package(self):
-        if self.options.get_safe("as_framework"):
-            shutil.copytree(src=os.path.join(self.build_folder, "HevSocks5Tunnel.xcframework"),
-                            dst=os.path.join(self.package_folder, "HevSocks5Tunnel.xcframework"))
-        else:
-            copy(self, "hev-main.h", src=os.path.join(self.source_folder, "src"), dst=os.path.join(self.package_folder, "include"))
-            copy(self, "*.a", src=os.path.join(self.build_folder, "bin"), dst=os.path.join(self.package_folder, "lib"))
-            copy(self, "*.so", src=os.path.join(self.build_folder, "bin"), dst=os.path.join(self.package_folder, "lib"))
-            copy(self, "*.a", src=os.path.join(self.build_folder, "bin", "third-part", "lwip"), dst=os.path.join(self.package_folder, "lib"))
-            copy(self, "*.so", src=os.path.join(self.build_folder, "bin", "third-part", "lwip"), dst=os.path.join(self.package_folder, "lib"))
-            copy(self, "*.a", src=os.path.join(self.build_folder, "bin", "third-part", "yaml"), dst=os.path.join(self.package_folder, "lib"))
-            copy(self, "*.so", src=os.path.join(self.build_folder, "bin", "third-part", "yaml"), dst=os.path.join(self.package_folder, "lib"))
-            copy(self, "*.a", src=os.path.join(self.build_folder, "bin", "third-part", "hev-task-system"), dst=os.path.join(self.package_folder, "lib"))
-            copy(self, "*.so", src=os.path.join(self.build_folder, "bin", "third-part", "hev-task-system"), dst=os.path.join(self.package_folder, "lib"))
-
-    def package_info(self):
-        self.cpp_info.set_property("cmake_target_name", "heiher::hev-socks5-tunnel")
-        if self.options.get_safe("as_framework"):
-            self.cpp_info.type = PackageType.STATIC
-            self.cpp_info.package_framework = True
-            self.cpp_info.location = os.path.join(self.package_folder, "HevSocks5Tunnel.xcframework")
-        else:
-            self.cpp_info.libraries = collect_libs(self)

recipes/libssh/conanfile.py

@@ -1,142 +0,0 @@
-from conan import ConanFile
-from conan.errors import ConanInvalidConfiguration
-from conan.tools.cmake import CMakeToolchain, CMake, cmake_layout, CMakeDeps
-from conan.tools.files import copy, get, rmdir
-from conan.tools.microsoft import is_msvc_static_runtime, is_msvc
-from conan.tools.scm import Version
-import os
-
-
-required_conan_version = ">=2.21"
-
-
-class LibSSHRecipe(ConanFile):
-    name = "libssh"
-    version = "0.11.3"
-    user = "amnezia"
-    license = "LGPL-2.1"
-    homepage = "https://www.libssh.org/"
-    description = "multiplatform C library implementing the SSHv2 protocol on client and server side"
-    topics = ("ssh", "shell", "ssh2", "connection")
-    package_type = "library"
-    settings = "os", "compiler", "build_type", "arch"
-    options = {
-        "shared": [True, False],
-        "fPIC": [True, False],
-        "with_zlib": [True, False],
-        "crypto_backend": ["openssl", "gcrypt", "mbedtls"],
-        "with_symbol_versioning": [True, False],
-        "page_16k": [True, False],
-    }
-    default_options = {
-        "shared": False,
-        "fPIC": True,
-        "with_zlib": True,
-        "crypto_backend": "openssl",
-        "with_symbol_versioning": True,
-        "page_16k": True,
-    }
-
-    def config_options(self):
-        if self.settings.os == "Windows":
-            del self.options.fPIC
-            del self.options.with_symbol_versioning
-
-    def configure(self):
-        if self.options.shared:
-            self.options.rm_safe("fPIC")
-        self.settings.rm_safe("compiler.libcxx")
-        self.settings.rm_safe("compiler.cppstd")
-
-    def layout(self):
-        cmake_layout(self, src_folder="src")
-
-    def requirements(self):
-        if self.options.with_zlib:
-            self.requires("zlib/[>=1.2.11 <2]")
-        if self.options.crypto_backend == "openssl":
-            if self.settings.os == "Android":
-                self.requires("android-openssl/3.5.5")
-            else:
-                self.requires("openssl/[>=1.1 <4]")
-        elif self.options.crypto_backend == "gcrypt":
-            self.requires("libgcrypt/[>=1.8.4 <2]")
-        elif self.options.crypto_backend == "mbedtls":
-            self.requires("mbedtls/3.6.0")
-
-    def validate(self):
-        if self.options.crypto_backend == "mbedtls" and not self.dependencies["mbedtls"].options.enable_threading:
-            raise ConanInvalidConfiguration(f"{self.ref} requires '-o mbedtls/*:enable_threading=True' when using '-o libssh/*:crypto_backend=mbedtls'")
-
-    def source(self):
-        get(self, "https://www.libssh.org/files/0.11/libssh-0.11.3.tar.xz",
-            sha256="7d8a1361bb094ec3f511964e78a5a4dba689b5986e112afabe4f4d0d6c6125c3", strip_root=True
-        )
-
-    def generate(self):
-        tc = CMakeToolchain(self)
-        tc.cache_variables["CLIENT_TESTING"] = False
-        tc.cache_variables["SERVER_TESTING"] = False
-        tc.cache_variables["WITH_EXAMPLES"] = False
-        tc.cache_variables["WITH_GCRYPT"] = self.options.crypto_backend == "gcrypt"
-        tc.cache_variables["WITH_GSSAPI"] = False
-        tc.cache_variables["WITH_MBEDTLS"] = self.options.crypto_backend == "mbedtls"
-        tc.cache_variables["WITH_NACL"] = False
-        tc.cache_variables["WITH_SYMBOL_VERSIONING"] = self.options.get_safe("with_symbol_versioning", True)
-        tc.variables["WITH_ZLIB"] = self.options.with_zlib
-        if is_msvc(self):
-            tc.cache_variables["USE_MSVC_RUNTIME_LIBRARY_DLL"] = not is_msvc_static_runtime(self)
-        tc.cache_variables["CMAKE_POLICY_DEFAULT_CMP0077"] = "NEW"
-        tc.cache_variables["CMAKE_TRY_COMPILE_CONFIGURATION"] = str(self.settings.build_type)
-        if self.settings.os == "Android":
-            if Version(self.settings.get_safe("os.api_level")) < 24:
-                tc.cache_variables["HAVE_IFADDRS_H"] = False
-            tc.cache_variables["HAVE_GLOB_H"] = False
-            tc.preprocessor_definitions["S_IWRITE"] = "S_IRUSR"
-            tc.preprocessor_definitions["S_IWRITE"] = "S_IWUSR"
-            tc.preprocessor_definitions["S_IEXEC"] = "S_IXUSR"
-            if self.options.page_16k:
-                tc.cache_variables["CMAKE_SHARED_LINKER_FLAGS"] = "-Wl,-z,max-page-size=16384"
-                tc.cache_variables["CMAKE_MODULE_LINKER_FLAGS"] = "-Wl,-z,max-page-size=16384"
-        tc.generate()
-
-        deps = CMakeDeps(self)
-        deps.set_property("libgcrypt", "cmake_file_name", "GCrypt")
-        deps.set_property("libgcrypt", "cmake_additional_variables_prefixes", ["GCRYPT"])
-        deps.set_property("libgcrypt", "cmake_extra_variables", {"GCRYPT_FOUND": "TRUE"})
-        deps.set_property("mbedtls", "cmake_additional_variables_prefixes", ["MBEDTLS"])
-        deps.set_property("mbedtls", "cmake_extra_variables", {"MBEDTLS_FOUND": "TRUE"})
-        deps.generate()
-
-    def build(self):
-        cmake = CMake(self)
-        cmake.configure()
-        cmake.build()
-
-    def package(self):
-        copy(self, pattern="COPYING", dst=os.path.join(self.package_folder, "licenses"), src=self.source_folder)
-        cmake = CMake(self)
-        cmake.install()
-        rmdir(self, os.path.join(self.package_folder, "lib", "cmake"))
-        rmdir(self, os.path.join(self.package_folder, "lib", "pkgconfig"))
-
-    def package_info(self):
-        self.cpp_info.libs = ["ssh"]
-        if not self.options.shared:
-            self.cpp_info.defines.append("LIBSSH_STATIC=ON")
-        if self.settings.os == "Windows":
-            self.cpp_info.system_libs.extend(["ws2_32", "iphlpapi"])
-
-        self.cpp_info.set_property("cmake_file_name", "libssh")
-        # target and alias names defined at:
-        # ssh         https://git.libssh.org/projects/libssh.git/tree/src/CMakeLists.txt?h=libssh-0.10.6#n351
-        # ssh::ssh    https://git.libssh.org/projects/libssh.git/tree/src/CMakeLists.txt?h=libssh-0.10.6#n371
-        # ssh-static  https://git.libssh.org/projects/libssh.git/tree/src/CMakeLists.txt?h=libssh-0.10.6#n413
-        # ssh::static https://git.libssh.org/projects/libssh.git/tree/src/CMakeLists.txt?h=libssh-0.10.6#n428
-        self.cpp_info.set_property("cmake_target_name", "ssh::ssh")
-        self.cpp_info.set_property(
-            "cmake_target_aliases",
-            ["ssh"] if self.options.shared else ["ssh", "ssh-static", "ssh::static"],
-        )
-        # pkg-config defined at https://git.libssh.org/projects/libssh.git/tree/CMakeLists.txt?h=libssh-0.10.6#n124
-        self.cpp_info.set_property("pkg_config_name", "libssh")

recipes/openvpn-pt-android/conanfile.py

@@ -1,67 +0,0 @@
-from conan import ConanFile
-from conan.tools.cmake import cmake_layout, CMake, CMakeToolchain
-from conan.tools.env import VirtualBuildEnv
-from conan.tools.files import copy
-from conan.tools.scm import Git
-from conan.errors import ConanInvalidConfiguration
-
-import os
-
-class OpenvpnPtAndroid(ConanFile):
-    name = "openvpn-pt-android"
-    version = "1.0.0"
-    package_type = "shared-library"
-    settings = "os", "arch", "build_type", "compiler"
-    options = {"page_16k": [True, False]}
-    default_options = {"page_16k": True}
-
-    def layout(self):
-        cmake_layout(self)
-
-    def build_requirements(self):
-        self.tool_requires("swig/4.1.1")
-        self.tool_requires("go/1.26.0")
-        self.tool_requires("cmake/[>=3.4.1 <4]")
-
-    def validate(self):
-        if self.settings.os != "Android":
-            raise ConanInvalidConfiguration(f"{self.name} only supports Android, got {self.settings.os}")
-
-    def source(self):
-        git = Git(self)
-        git.clone(
-            url="https://github.com/amnezia-vpn/openvpn-pt-android.git",
-            target=".",
-            args=["--recurse-submodules", "--branch", "update-ovpn3"]
-        )
-
-    def generate(self):
-        tc = CMakeToolchain(self)
-        tc.variables["ANDROID_PACKAGE_NAME"] = "org.amnezia.vpn"
-        tc.variables["ANDROID_PLATFORM"] = 24
-        if self.options.page_16k:
-            page_flag = "-Wl,-z,max-page-size=16384"
-            tc.cache_variables["CMAKE_SHARED_LINKER_FLAGS"] = page_flag
-            tc.cache_variables["CMAKE_EXE_LINKER_FLAGS"] = page_flag
-        tc.generate()
-
-        vbe = VirtualBuildEnv(self)
-        if self.options.page_16k:
-            vbe.environment().define("CGO_LDFLAGS", "-Wl,-z,max-page-size=16384")
-        vbe.generate()
-
-    def build(self):
-        cmake = CMake(self)
-        cmake.configure()
-        cmake.build(target=["ck_ovpn_plugin_go", "ovpn3", "ovpnutil", "rsapss"])
-
-    def package(self):
-        copy(self, "*.h", src=self.build_folder, dst=os.path.join(self.package_folder, "include"))
-        copy(self, "*.so", src=self.build_folder, dst=os.path.join(self.package_folder, "lib"))
-
-    def package_info(self):
-        self.cpp_info.set_property("cmake_target_name", "amnezia::openvpn-pt-android")
-        self.cpp_info.libs = ["ovpn3", "ovpnutil", "rsapss"]
-        self.cpp_info.set_property("cmake_extra_variables", {
-            "OPENVPN_PT_ANDROID_LIBCK_OVPN_PLUGIN_PATH": os.path.join(self.package_folder, "lib", "libck-ovpn-plugin.so"),
-        })

recipes/openvpn/conanfile.py

@@ -1,48 +0,0 @@
-from conan import ConanFile
-from conan.tools.files import get, copy
-from conan.tools.gnu import Autotools, AutotoolsToolchain, AutotoolsDeps
-from conan.tools.layout import basic_layout
-
-import os
-
-class Openvpn(ConanFile):
-    name = "openvpn"
-    version = "2.7.0"
-    package_type = "application"
-    settings = "os", "build_type", "arch"
-
-    def layout(self):
-        basic_layout(self)
-
-    def build_requirements(self):
-        self.tool_requires("libtool/2.4.7")
-        self.tool_requires("automake/1.16.5")
-
-    def requirements(self):
-        self.requires("openssl/[>=1.1.0]", visible=False)
-        self.requires("lz4/[>=1.7.1]", visible=False)
-        self.requires("lzo/2.10", visible=False)
-
-    def source(self):
-        get(self, f"https://github.com/OpenVPN/openvpn/archive/refs/tags/v{self.version}.zip",
-            sha256="1a65d8587f932c13d55b1f175ff2e1d61d795d9092788662e888054854d4ee3d", strip_root=True
-        )
-
-    def generate(self):
-        tc = AutotoolsToolchain(self)
-        tc.generate()
-        deps = AutotoolsDeps(self)
-        deps.generate()
-
-    def build(self):
-        at = Autotools(self)
-        at.autoreconf()
-        at.configure()
-        at.make()
-
-    def package(self):
-        copy(self, "openvpn", src=os.path.join(self.build_folder, "src", "openvpn"), dst=self.package_folder)
-
-    def package_info(self):
-        self.cpp_info.exe = True
-        self.cpp_info.location = os.path.join(self.package_folder, "openvpn")

recipes/openvpnadapter/conanfile.py

@@ -1,72 +0,0 @@
-from conan import ConanFile
-from conan.tools.layout import basic_layout
-from conan.tools.apple import is_apple_os
-from conan.errors import ConanInvalidConfiguration
-from conan.tools.scm import Git
-from conan.internal.model.pkg_type import PackageType
-from conan.tools.files import chdir
-
-import os
-import shutil
-
-class OpenVPNAdapter(ConanFile):
-    name = "openvpnadapter"
-    version = "1.0.0"
-    settings = "os", "build_type"
-
-    @property
-    def _sdk(self):
-        return str(self.settings.get_safe("os.sdk", "macosx"))
-
-    @property
-    def _platform(self):
-        return {
-            "macosx": "macOS",
-            "iphoneos": "iOS",
-            "iphonesimulator": "iOS Simulator"
-        }.get(self._sdk)
-    
-    @property
-    def _configuration(self):
-        return "Debug" if self.settings.get_safe("build_type") == "Debug" else "Release"
-
-    def layout(self):
-        basic_layout(self)
-
-    def validate(self):
-        if not is_apple_os(self):
-            raise ConanInvalidConfiguration(
-                f"There is absolutely no point building Apple framework for {self.settings.os}"
-            )
-
-    def source(self):
-        git = Git(self)
-        git.clone(
-            url="https://github.com/amnezia-vpn/OpenVPNAdapter.git",
-            target=".",
-            args=["--recurse-submodules", "--branch", "master-amnezia"]
-        )
-
-    def build(self):
-        with chdir(self, self.source_folder):
-            self.run("xcrun xcodebuild"
-                " -project OpenVPNAdapter.xcodeproj"
-                " -scheme OpenVPNAdapter"
-                " -configuration Release"
-                f" -destination 'generic/platform={self._platform}'"
-                f" -sdk {self._sdk}"
-                f' "CONFIGURATION_BUILD_DIR={self.build_folder}"'
-                f' "BUILT_PRODUCTS_DIR={self.build_folder}"'
-                " BUILD_LIBRARY_FOR_DISTRIBUTION=YES"
-                " CODE_SIGNING_ALLOWED=NO"
-            )
-
-    def package(self):
-        shutil.copytree(os.path.join(self.build_folder, "OpenVPNAdapter.framework"),
-                        os.path.join(self.package_folder, "OpenVPNAdapter.framework"))
-        
-    def package_info(self):
-        self.cpp_info.set_property("cmake_target_name", "amnezia::openvpnadapter")
-        self.cpp_info.type = PackageType.STATIC
-        self.cpp_info.package_framework = True
-        self.cpp_info.location = os.path.join(self.package_folder, "OpenVPNAdapter.framework")

recipes/tun2socks/conanfile.py

@@ -1,80 +0,0 @@
-from conan import ConanFile
-from conan.tools.layout import basic_layout
-from conan.tools.files import get, copy, chdir
-from conan.errors import ConanInvalidConfiguration
-from conan.tools.gnu import Autotools, AutotoolsToolchain
-from conan.tools.env import Environment
-
-import os
-
-class Tun2Socks(ConanFile):
-    name = "tun2socks"
-    version = "2.6.0"
-    package_type = "application"
-    settings = "os", "arch"
-
-    @property
-    def _goos(self):
-        return {
-            "Linux": "linux",
-            "Macos": "darwin",
-            "Windows": "windows"
-        }.get(str(self.settings.os))
-
-    @property
-    def _goarch(self):
-        return {
-            "x86": "386",
-            "x86_64": "amd64",
-            "armv8": "arm64"
-        }.get(str(self.settings.arch))
-    
-    @property
-    def _is_windows(self):
-        return str(self.settings.get_safe("os")).startswith("Windows")
-    
-    @property
-    def _ext(self):
-        return ".exe" if self._is_windows else ""
-
-    def layout(self):
-        basic_layout(self)
-
-    def validate(self):
-        if not self._goos or not self._goarch:
-            raise ConanInvalidConfiguration(
-                f"{self.name} v{self.version} does not support {self.settings.os} {self.settings.arch}"
-            )
-
-    def build_requirements(self):
-        self.tool_requires("go/1.26.0")
-
-    def source(self):
-        get(self, f"https://github.com/xjasonlyu/tun2socks/archive/refs/tags/v{self.version}.zip",
-            sha256="a7ef9cec1c30dfe9971af89a8aac767fd3d2a4df833e92b635642c2f0204c701", strip_root=True
-        )
-
-    def generate(self):
-        tc = AutotoolsToolchain(self)
-        env = Environment()
-        env.define("CGO_LDFLAGS", tc.ldflags)
-        env.define("CGO_CFLAGS", tc.cflags)
-        env.define("GOOS", self._goos)
-        env.define("GOARCH", self._goarch)
-        tc.generate(env)
-
-    def build(self):
-        with chdir(self, self.source_folder):
-            at = Autotools(self)
-            at.make("tun2socks")
-
-    def package(self):
-        copy(self, "tun2socks", src=self.build_folder, dst=self.package_folder)
-        if self._is_windows:
-            with chdir(self, self.package_folder):
-                os.rename(src="tun2socks", dst="tun2socks.exe")
-
-    def package_info(self):
-        self.cpp_info.exe = True
-        self.cpp_info.location = os.path.join(self.package_folder, f"tun2socks{self._ext}")
-        self.cpp_info.set_property("cmake_target_name", "xjasonlyu::tun2socks")

recipes/v2ray-rules-dat/conanfile.py

@@ -1,29 +0,0 @@
-from conan import ConanFile
-from conan.tools.layout import basic_layout
-from conan.tools.files import download, copy
-
-import os
-
-class V2rayRulesDat(ConanFile):
-    name = "v2ray-rules-dat"
-    version = "202603162227"
-
-    def layout(self):
-        basic_layout(self, build_folder=".")
-
-    def source(self):
-        # TODO(ygurov): build from source instead of plain copying
-        download(self, filename="geoip.dat", url=f"https://github.com/Loyalsoldier/v2ray-rules-dat/releases/download/{self.version}/geoip.dat",
-            sha256="e48b925d985d7bf33cfee76f309241af0f1779699963b69363dec2c4740041d1")
-        download(self, filename="geosite.dat", url=f"https://github.com/Loyalsoldier/v2ray-rules-dat/releases/download/{self.version}/geosite.dat",
-            sha256="a2f83e25b8be3f089cfdd9423fc7b6eda5a0d4060919917902711d65acac1e0c")
-
-    def package(self):
-        copy(self, "*.dat", src=self.build_folder, dst=self.package_folder)
-
-    def package_info(self):
-        self.cpp_info.set_property("cmake_target_name", "Loyalsoldier::v2ray-rules-dat")
-        self.cpp_info.set_property("cmake_extra_variables", {
-            "GEOSITE_DAT_PATH": os.path.join(self.package_folder, "geosite.dat"),
-            "GEOIP_DAT_PATH": os.path.join(self.package_folder, "geoip.dat")
-        })

recipes/wintun/conanfile.py

@@ -1,5 +0,0 @@
-from conan import ConanFile
-
-class PackageConan(ConanFile):
-    name = "wintun"
-    version = "1.0.0"

service/server/CMakeLists.txt

@@ -9,11 +9,62 @@ set(CMAKE_CXX_STANDARD_REQUIRED ON)
 find_package(Qt6 REQUIRED COMPONENTS DBus Core Network Widgets RemoteObjects Core5Compat Concurrent)
 qt_standard_project_setup()
 
+
 configure_file(${CMAKE_SOURCE_DIR}/version.h.in ${CMAKE_CURRENT_BINARY_DIR}/version.h)
 
+set(AMNEZIA_XRAY_ROOT_DIR "${CMAKE_CURRENT_LIST_DIR}/../../client/3rd-prebuilt/3rd-prebuilt/amnezia_xray")
+if(WIN32)
+    if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "8")
+        set(AMNEZIA_XRAY_LIB_PATH "${AMNEZIA_XRAY_ROOT_DIR}/windows/x86_64/amnezia_xray.lib")
+        set(AMNEZIA_XRAY_INCLUDE_DIR "${AMNEZIA_XRAY_ROOT_DIR}/windows/x86_64")
+    else()
+        set(AMNEZIA_XRAY_LIB_PATH "${AMNEZIA_XRAY_ROOT_DIR}/windows/x86/amnezia_xray.lib")
+        set(AMNEZIA_XRAY_INCLUDE_DIR "${AMNEZIA_XRAY_ROOT_DIR}/windows/x86")
+    endif()
+elseif(APPLE AND NOT IOS)
+    set(AMNEZIA_XRAY_LIB_PATH "${AMNEZIA_XRAY_ROOT_DIR}/macos/x86_64/amnezia_xray.a")
+    set(AMNEZIA_XRAY_INCLUDE_DIR "${AMNEZIA_XRAY_ROOT_DIR}/macos/x86_64")
+elseif(LINUX)
+    set(AMNEZIA_XRAY_LIB_PATH "${AMNEZIA_XRAY_ROOT_DIR}/linux/x86_64/amnezia_xray.a")
+    set(AMNEZIA_XRAY_INCLUDE_DIR "${AMNEZIA_XRAY_ROOT_DIR}/linux/x86_64")
+endif()
+
 set(QSIMPLECRYPTO_DIR ${CMAKE_CURRENT_LIST_DIR}/../../client/3rd/QSimpleCrypto/src)
 
+
+set(OPENSSL_ROOT_DIR "${CMAKE_CURRENT_LIST_DIR}/../../client/3rd-prebuilt/3rd-prebuilt/openssl/")
+set(OPENSSL_LIBRARIES_DIR "${OPENSSL_ROOT_DIR}/lib")
+
+set(OPENSSL_INCLUDE_DIR "${OPENSSL_ROOT_DIR}/windows/include")
+if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "8")
+    set(OPENSSL_LIB_SSL_PATH "${OPENSSL_ROOT_DIR}/windows/win64/libssl.lib")
+    set(OPENSSL_LIB_CRYPTO_PATH "${OPENSSL_ROOT_DIR}/windows/win64/libcrypto.lib")
+else()
+    set(OPENSSL_LIB_SSL_PATH "${OPENSSL_ROOT_DIR}/windows/win32/libssl.lib")
+    set(OPENSSL_LIB_CRYPTO_PATH "${OPENSSL_ROOT_DIR}/windows/win32/libcrypto.lib")
+endif()
+
+
+if(WIN32)
+    set(OPENSSL_INCLUDE_DIR "${OPENSSL_ROOT_DIR}/windows/include")
+    if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "8")
+        set(OPENSSL_LIB_CRYPTO_PATH "${OPENSSL_ROOT_DIR}/windows/win64/libcrypto.lib")
+    else()
+        set(OPENSSL_LIB_CRYPTO_PATH "${OPENSSL_ROOT_DIR}/windows/win32/libcrypto.lib")
+    endif()
+elseif(APPLE AND NOT IOS)
+    set(OPENSSL_INCLUDE_DIR "${OPENSSL_ROOT_DIR}/macos/include")
+    set(OPENSSL_LIB_CRYPTO_PATH "${OPENSSL_ROOT_DIR}/macos/lib/libcrypto.a")
+elseif(LINUX)
+    set(OPENSSL_INCLUDE_DIR "${OPENSSL_ROOT_DIR}/linux/include")
+    set(OPENSSL_LIB_CRYPTO_PATH "${OPENSSL_ROOT_DIR}/linux/x86_64/libcrypto.a")
+endif()
+
+set(OPENSSL_USE_STATIC_LIBS TRUE)
+
 include_directories(
+    ${AMNEZIA_XRAY_INCLUDE_DIR}
+    ${OPENSSL_INCLUDE_DIR}
     ${QSIMPLECRYPTO_DIR}
 )
 
@@ -189,6 +240,8 @@ if(WIN32)
         gdi32
         Advapi32
         Kernel32
+        ${AMNEZIA_XRAY_LIB_PATH}
+        ${OPENSSL_LIB_CRYPTO_PATH}
         qt6keychain
     )
 
@@ -237,6 +290,8 @@ if(APPLE)
 
     set(LIBS
         resolv
+        ${AMNEZIA_XRAY_LIB_PATH}
+        ${OPENSSL_LIB_CRYPTO_PATH}
         qt6keychain
     )
 
@@ -274,6 +329,7 @@ if(LINUX)
     )
 
     set(LIBS
+        ${AMNEZIA_XRAY_LIB_PATH}    
         ${OPENSSL_LIB_CRYPTO_PATH}
         qt6keychain
         -static-libstdc++
@@ -298,12 +354,6 @@ add_executable(${PROJECT} ${SOURCES} ${HEADERS} ${RESOURCES})
 target_link_libraries(${PROJECT} PRIVATE Qt6::Core Qt6::Widgets Qt6::Network Qt6::RemoteObjects Qt6::Core5Compat Qt6::DBus Qt6::Concurrent ${LIBS})
 target_compile_definitions(${PROJECT} PRIVATE "MZ_$<UPPER_CASE:${MZ_PLATFORM_NAME}>")
 
-find_package(amnezia-xray-bindings REQUIRED)
-target_link_libraries(${PROJECT} PRIVATE amnezia::xray-bindings)
-
-find_package(openssl REQUIRED)
-target_link_libraries(${PROJECT} PRIVATE OpenSSL::SSL OpenSSL::Crypto)
-
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
     target_compile_definitions(${PROJECT} PRIVATE "MZ_DEBUG")
 endif()
@@ -358,38 +408,10 @@ add_custom_command(
     $<TARGET_FILE_DIR:${PROJECT}>
     COMMAND_EXPAND_LISTS
 )
-
-if(NOT WIN32)
-    find_package(awg-go REQUIRED)
-    add_custom_command(TARGET ${PROJECT} POST_BUILD
-        COMMAND ${CMAKE_COMMAND} -E copy_if_different
-            $<TARGET_FILE:amnezia::awg-go>
-            $<TARGET_FILE_DIR:${PROJECT}>
-    )
-endif()
-
-find_package(openvpn REQUIRED)
-add_custom_command(TARGET ${PROJECT} POST_BUILD
-    COMMAND ${CMAKE_COMMAND} -E copy_if_different
-        $<TARGET_FILE:openvpn::openvpn>
-        $<TARGET_FILE_DIR:${PROJECT}>
-)
-
-find_package(tun2socks REQUIRED)
-add_custom_command(TARGET ${PROJECT} POST_BUILD
-    COMMAND ${CMAKE_COMMAND} -E copy_if_different
-        $<TARGET_FILE:xjasonlyu::tun2socks>
-        $<TARGET_FILE_DIR:${PROJECT}>
-)
-
-find_package(v2ray-rules-dat REQUIRED)
-add_custom_command(TARGET ${PROJECT} POST_BUILD
-    COMMAND ${CMAKE_COMMAND} -E copy_if_different
-        ${GEOSITE_DAT_PATH}
-        $<TARGET_FILE_DIR:${PROJECT}>
-)
-add_custom_command(TARGET ${PROJECT} POST_BUILD
-    COMMAND ${CMAKE_COMMAND} -E copy_if_different
-        ${GEOIP_DAT_PATH}
-        $<TARGET_FILE_DIR:${PROJECT}>
+add_custom_command(
+    TARGET ${PROJECT} POST_BUILD
+    COMMAND ${CMAKE_COMMAND} -E $<IF:$<CONFIG:Debug>,copy_directory,true>
+    ${CMAKE_SOURCE_DIR}/client/3rd-prebuilt/deploy-prebuilt/${DEPLOY_PLATFORM_PATH}
+    $<TARGET_FILE_DIR:${PROJECT}>
+    COMMAND_EXPAND_LISTS
 )

service/server/killswitch.cpp

@@ -33,10 +33,18 @@ KillSwitch* KillSwitch::instance()
 
 bool KillSwitch::init()
 {
-#if defined(Q_OS_LINUX) || defined(Q_OS_MACOS)
+#ifdef Q_OS_LINUX
+    if (!LinuxFirewall::isInstalled()) {
+        LinuxFirewall::install();
+    }
+    m_appSettigns = QSharedPointer<SecureQSettings>(new SecureQSettings(ORGANIZATION_NAME, APPLICATION_NAME, nullptr));
+#endif
+#ifdef Q_OS_MACOS
+    if (!MacOSFirewall::isInstalled()) {
+        MacOSFirewall::install();
+    }
     m_appSettigns = QSharedPointer<SecureQSettings>(new SecureQSettings(ORGANIZATION_NAME, APPLICATION_NAME, nullptr));
 #endif
-
     if (isStrictKillSwitchEnabled()) {
         return disableAllTraffic();
     }

service/server/localserver.cpp

@@ -50,8 +50,8 @@ LocalServer::LocalServer(QObject *parent) : QObject(parent),
     }
 
     m_networkWatcher.initialize();
-    connect(&m_networkWatcher, &NetworkWatcher::networkChanged, &m_ipcServer, &IpcServer::networkChanged);
-    connect(&m_networkWatcher, &NetworkWatcher::wakeup, &m_ipcServer, &IpcServer::wakeup);
+    connect(&m_networkWatcher, &NetworkWatcher::sleepMode, &m_ipcServer, &IpcServer::networkChange);
+    connect(&m_networkWatcher, &NetworkWatcher::networkChange, &m_ipcServer, &IpcServer::networkChange);
     KillSwitch::instance()->init();
 
 #ifdef Q_OS_LINUX