fix: control resetIpStack when destroy DnsUtilsLinux

- Validate IP/CIDR values from IPC before passing to Linux firewall
- Replace shell interpolation with direct execve in firewall update functions
- Block dangerous OpenVPN/WireGuard arguments in sanitizeArguments()
- Add programId bounds check in IpcServerProcess::setProgram()
- Add SO_PEERCRED peer authentication for IPC connections on Linux

.github/workflows/deploy.yml

@@ -88,7 +88,7 @@ jobs:
         host: 'linux'
         target: 'desktop'
         arch: 'linux_gcc_64'
-        modules: 'qtremoteobjects qt5compat qtshadertools qthttpserver qtwebsockets'
+        modules: 'qtremoteobjects qt5compat qtshadertools'
         dir: ${{ runner.temp }}
         setup-python: 'true'
         tools: 'tools_ifw'
@@ -157,7 +157,7 @@ jobs:
       run: pip install "conan==2.28.0"
 
     - name: 'Build dependencies'
-      run: cmake -S . -B build -G "Visual Studio 17 2022" -DPREBUILTS_ONLY=1
+      run: cmake -S . -B build -DPREBUILTS_ONLY=1
     
     - name: 'Authorize in remote'
       if: github.ref == 'refs/heads/dev'
@@ -201,7 +201,7 @@ jobs:
         host: 'windows'
         target: 'desktop'
         arch: 'win64_msvc2022_64'
-        modules: 'qtremoteobjects qt5compat qtshadertools qthttpserver qtwebsockets'
+        modules: 'qtremoteobjects qt5compat qtshadertools'
         dir: ${{ runner.temp }}
         setup-python: 'true'
         tools: 'tools_ifw'
@@ -365,7 +365,7 @@ jobs:
         version: ${{ env.QT_VERSION }}
         host: 'mac'
         target: 'desktop'
-        modules: 'qtremoteobjects qt5compat qtshadertools qtmultimedia qthttpserver qtwebsockets'
+        modules: 'qtremoteobjects qt5compat qtshadertools qtmultimedia'
         arch: 'clang_64'
         dir: ${{ runner.temp }}
         set-env: 'true'
@@ -377,7 +377,7 @@ jobs:
         version: ${{ env.QT_VERSION }}
         host: 'mac'
         target: 'ios'
-        modules: 'qtremoteobjects qt5compat qtshadertools qtmultimedia qthttpserver qtwebsockets'
+        modules: 'qtremoteobjects qt5compat qtshadertools qtmultimedia'
         dir: ${{ runner.temp }}
         setup-python: 'true'
         set-env: 'true'
@@ -506,7 +506,7 @@ jobs:
         host: 'mac'
         target: 'desktop'
         arch: 'clang_64'
-        modules: 'qtremoteobjects qt5compat qtshadertools qthttpserver qtwebsockets'
+        modules: 'qtremoteobjects qt5compat qtshadertools'
         dir: ${{ runner.temp }}
         setup-python: 'true'
         set-env: 'true'
@@ -739,7 +739,7 @@ jobs:
       ANDROID_PLATFORM: android-28
       NDK_VERSION: 27.0.11718014
       QT_VERSION: 6.10.3
-      QT_MODULES: 'qtremoteobjects qt5compat qtimageformats qtshadertools qthttpserver qtwebsockets'
+      QT_MODULES: 'qtremoteobjects qt5compat qtimageformats qtshadertools'
       PROD_AGW_PUBLIC_KEY: ${{ secrets.PROD_AGW_PUBLIC_KEY }}
       PROD_S3_ENDPOINT: ${{ secrets.PROD_S3_ENDPOINT }}
       FALLBACK_S3_ENDPOINT: ${{ secrets.FALLBACK_S3_ENDPOINT }}

.gitignore

@@ -10,9 +10,7 @@ deploy/build_64/*
 winbuild*.bat
 .cache/
 .vscode/
-.cursorignore
-.cursor/
-.venv/
+
 
 # Qt-es
 /.qmake.cache

CMakeLists.txt

@@ -4,7 +4,7 @@ set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 set(PROJECT AmneziaVPN)
-set(AMNEZIAVPN_VERSION 4.9.0.1)
+set(AMNEZIAVPN_VERSION 4.9.0.2)
 
 set(QT_CREATOR_SKIP_PACKAGE_MANAGER_SETUP ON CACHE BOOL "" FORCE)
 set(CMAKE_PROJECT_TOP_LEVEL_INCLUDES
@@ -28,7 +28,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 2122)
+set(APP_ANDROID_VERSION_CODE 2123)
 
 if(${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
     set(MZ_PLATFORM_NAME "linux")

client/CMakeLists.txt

@@ -14,10 +14,6 @@ set(PACKAGES
     Core5Compat Concurrent LinguistTools
 )
 
-if(NOT ANDROID AND NOT IOS)
-    list(APPEND PACKAGES HttpServer)
-endif()
-
 execute_process(
   WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
   COMMAND git rev-parse --short HEAD
@@ -51,10 +47,6 @@ set(LIBS ${LIBS}
     Qt6::Core5Compat Qt6::Concurrent
 )
 
-if(NOT ANDROID AND NOT IOS)
-    list(APPEND LIBS Qt6::HttpServer)
-endif()
-
 if(WIN32 OR (APPLE AND NOT IOS) OR (LINUX AND NOT ANDROID))
     set(LIBS ${LIBS} Qt6::Widgets)
 endif()

client/amneziaApplication.cpp

@@ -119,7 +119,13 @@ void AmneziaApplication::init()
                 win->setPersistentSceneGraph(true);
                 win->setPersistentGraphics(true);
 #endif
+#if defined(Q_OS_ANDROID) || defined(Q_OS_IOS)
                 win->show();
+#else
+                if (!m_coreController || !m_coreController->pageController()->shouldStartMinimized()) {
+                    win->show();
+                }
+#endif
             }
         },
         Qt::QueuedConnection);

client/android/res/drawable/ic_launcher_background.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android"
+    android:shape="rectangle">
+    <gradient
+        android:type="linear"
+        android:angle="135"
+        android:startColor="#2A2A2E"
+        android:centerColor="#17171A"
+        android:endColor="#0E0E11" />
+</shape>

client/android/res/drawable/ic_launcher_monochrome.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<inset xmlns:android="http://schemas.android.com/apk/res/android"
+    android:drawable="@drawable/ic_amnezia_round"
+    android:insetLeft="19.5%"
+    android:insetTop="19.5%"
+    android:insetRight="19.5%"
+    android:insetBottom="19.5%" />

client/android/res/mipmap-anydpi-v26/icon.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+    <background android:drawable="@drawable/ic_launcher_background" />
+    <foreground android:drawable="@mipmap/ic_launcher_foreground" />
+    <monochrome android:drawable="@drawable/ic_launcher_monochrome" />
+</adaptive-icon>

client/android/res/mipmap-anydpi-v26/icon_round.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+    <background android:drawable="@drawable/ic_launcher_background" />
+    <foreground android:drawable="@mipmap/ic_launcher_foreground" />
+    <monochrome android:drawable="@drawable/ic_launcher_monochrome" />
+</adaptive-icon>

client/android/res/values-v31/styles.xml

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <style name="NoActionBar">
+        <item name="android:windowBackground">@color/black</item>
+        <item name="android:colorBackground">@color/black</item>
+        <item name="android:windowActionBar">false</item>
+        <item name="android:windowNoTitle">true</item>
+        <item name="android:windowLayoutInDisplayCutoutMode">shortEdges</item>
+        <item name="android:enforceNavigationBarContrast">false</item>
+        <item name="android:enforceStatusBarContrast">false</item>
+
+        <item name="android:windowSplashScreenBackground">@color/ic_launcher_background</item>
+        <item name="android:windowSplashScreenIconBackgroundColor">@color/ic_launcher_background</item>
+        <item name="android:windowSplashScreenAnimatedIcon">@mipmap/icon</item>
+    </style>
+</resources>

client/android/res/values/colors.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <color name="ic_launcher_background">#0E0E11</color>
+</resources>

client/cmake/macos_ne.cmake

@@ -152,5 +152,5 @@ 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}
+    COMMAND ${QT_BIN_DIR_DETECTED}/macdeployqt $<TARGET_BUNDLE_DIR:AmneziaVPN> -appstore-compliant -qmldir=${CMAKE_CURRENT_SOURCE_DIR} -no-codesign
 )

client/cmake/sources.cmake

@@ -201,11 +201,6 @@ file(GLOB CONFIGURATORS_CPP CONFIGURE_DEPENDS ${CLIENT_ROOT_DIR}/core/configurat
 file(GLOB_RECURSE CORE_MODELS_H CONFIGURE_DEPENDS ${CLIENT_ROOT_DIR}/core/models/*.h)
 file(GLOB_RECURSE CORE_MODELS_CPP CONFIGURE_DEPENDS ${CLIENT_ROOT_DIR}/core/models/*.cpp)
 
-if(NOT ANDROID AND NOT IOS)
-    file(GLOB LOCAL_PROXY_H CONFIGURE_DEPENDS ${CLIENT_ROOT_DIR}/core/local-proxy/*.h)
-    file(GLOB LOCAL_PROXY_CPP CONFIGURE_DEPENDS ${CLIENT_ROOT_DIR}/core/local-proxy/*.cpp)
-endif()
-
 file(GLOB UI_MODELS_H CONFIGURE_DEPENDS
     ${CLIENT_ROOT_DIR}/ui/models/*.h
     ${CLIENT_ROOT_DIR}/ui/models/protocols/*.h
@@ -251,11 +246,6 @@ set(SOURCES ${SOURCES}
     ${UI_CONTROLLERS_CPP}
 )
 
-if(NOT ANDROID AND NOT IOS)
-    list(APPEND HEADERS ${LOCAL_PROXY_H})
-    list(APPEND SOURCES ${LOCAL_PROXY_CPP})
-endif()
-
 if(WIN32)
     set(HEADERS ${HEADERS}
         ${CLIENT_ROOT_DIR}/core/protocols/ikev2VpnProtocolWindows.h

client/core/configurators/xrayConfigurator.cpp

@@ -244,11 +244,7 @@ ErrorCode XrayConfigurator::applyServerSettingsToRemote(const ServerCredentials
                     << "container=" << static_cast<int>(container) << "host=" << credentials.hostName
                     << "transport=" << srv.transport << "security=" << srv.security << "port=" << srv.port
                     << "appendClient=" << appendNewClient;
-    QString flowValue = srv.flow;
-    if (flowValue.isEmpty() && srv.security == QLatin1String("reality")) {
-        flowValue = QStringLiteral("xtls-rprx-vision");
-    }
-
+    const QString flowValue = srv.flow;
     QString realityPublicKey;
     QString realityShortId;
     if (srv.security == QLatin1String("reality")) {
@@ -563,9 +559,12 @@ QJsonObject XrayConfigurator::buildStreamSettings(const XrayServerConfig &srv, c
         if (pad.obfsMode) {
             if (!pad.bytesMin.isEmpty() || !pad.bytesMax.isEmpty()) {
                 QJsonObject br;
-                br[QStringLiteral("from")] = pad.bytesMin.isEmpty() ? 1 : pad.bytesMin.toInt();
-                br[QStringLiteral("to")] = pad.bytesMax.isEmpty() ? (pad.bytesMin.isEmpty() ? 256 : pad.bytesMin.toInt())
-                                                                  : pad.bytesMax.toInt();
+                const int fromV = pad.bytesMin.isEmpty() ? 1 : pad.bytesMin.toInt();
+                int toV = pad.bytesMax.isEmpty() ? 256 : pad.bytesMax.toInt();
+                if (toV < fromV)
+                    toV = fromV;
+                br[QStringLiteral("from")] = fromV;
+                br[QStringLiteral("to")] = toV;
                 xo[QStringLiteral("xPaddingBytes")] = br;
             }
             xo[QStringLiteral("xPaddingKey")] = pad.key.isEmpty() ? QStringLiteral("x_padding") : pad.key;

client/core/controllers/connectionController.cpp

@@ -49,14 +49,96 @@ void ConnectionController::setConnectionState(Vpn::ConnectionState state)
     }
 }
 
-ErrorCode ConnectionController::prepareConnection(const QString &serverId,
-                                                 QJsonObject& vpnConfiguration,
-                                                 DockerContainer& container)
+ErrorCode ConnectionController::defaultContainerForServer(const QString &serverId, DockerContainer &container) const
 {
+    const auto kind = m_serversRepository->serverKind(serverId);
+    switch (kind) {
+    case serverConfigUtils::ConfigType::SelfHostedAdmin: {
+        const auto cfg = m_serversRepository->selfHostedAdminConfig(serverId);
+        if (!cfg.has_value()) {
+            return ErrorCode::InternalError;
+        }
+        container = cfg->defaultContainer;
+        return ErrorCode::NoError;
+    }
+    case serverConfigUtils::ConfigType::SelfHostedUser: {
+        const auto cfg = m_serversRepository->selfHostedUserConfig(serverId);
+        if (!cfg.has_value()) {
+            return ErrorCode::InternalError;
+        }
+        container = cfg->defaultContainer;
+        return ErrorCode::NoError;
+    }
+    case serverConfigUtils::ConfigType::Native: {
+        const auto cfg = m_serversRepository->nativeConfig(serverId);
+        if (!cfg.has_value()) {
+            return ErrorCode::InternalError;
+        }
+        container = cfg->defaultContainer;
+        return ErrorCode::NoError;
+    }
+    case serverConfigUtils::ConfigType::AmneziaPremiumV2:
+    case serverConfigUtils::ConfigType::AmneziaFreeV3:
+    case serverConfigUtils::ConfigType::ExternalPremium: {
+        const auto cfg = m_serversRepository->apiV2Config(serverId);
+        if (!cfg.has_value()) {
+            return ErrorCode::InternalError;
+        }
+        container = cfg->defaultContainer;
+        return ErrorCode::NoError;
+    }
+    case serverConfigUtils::ConfigType::AmneziaPremiumV1:
+    case serverConfigUtils::ConfigType::AmneziaFreeV2:
+        return ErrorCode::LegacyApiV1NotSupportedError;
+    case serverConfigUtils::ConfigType::Invalid:
+    default:
+        return ErrorCode::InternalError;
+    }
+}
+
+ErrorCode ConnectionController::isConnectionSupported(const QString &serverId) const
+{
+    if (serverId.isEmpty()) {
+        return ErrorCode::InternalError;
+    }
+
     if (!isServiceReady()) {
         return ErrorCode::AmneziaServiceNotRunning;
     }
 
+    const serverConfigUtils::ConfigType kind = m_serversRepository->serverKind(serverId);
+    if (serverConfigUtils::isLegacyApiSubscription(kind)) {
+        return ErrorCode::LegacyApiV1NotSupportedError;
+    }
+
+    DockerContainer container = DockerContainer::None;
+    const ErrorCode errorCode = defaultContainerForServer(serverId, container);
+    if (errorCode != ErrorCode::NoError) {
+        return errorCode;
+    }
+
+    if (container == DockerContainer::None) {
+        if (serverConfigUtils::isApiV2Subscription(kind)) {
+            return ErrorCode::NoError;
+        }
+        return ErrorCode::NoInstalledContainersError;
+    }
+
+    if (ContainerUtils::isUnsupportedContainer(container)) {
+        return ErrorCode::LegacyContainerNotSupportedError;
+    }
+
+    if (!isContainerSupported(container)) {
+        return ErrorCode::NotSupportedOnThisPlatform;
+    }
+
+    return ErrorCode::NoError;
+}
+
+ErrorCode ConnectionController::prepareConnection(const QString &serverId,
+                                                 QJsonObject& vpnConfiguration,
+                                                 DockerContainer& container)
+{
     ContainerConfig containerConfigModel;
     QPair<QString, QString> dns;
     QString hostName;
@@ -120,10 +202,6 @@ ErrorCode ConnectionController::prepareConnection(const QString &serverId,
         return ErrorCode::InternalError;
     }
 
-    if (!isContainerSupported(container)) {
-        return ErrorCode::NotSupportedOnThisPlatform;
-    }
-
     vpnConfiguration = createConnectionConfiguration(dns, isApiConfig, hostName, description, configVersion,
                                                      containerConfigModel, container);
 
@@ -140,13 +218,6 @@ ErrorCode ConnectionController::openConnection(const QString &serverId)
         return errorCode;
     }
 
-#if !defined(Q_OS_ANDROID) && !defined(Q_OS_IOS)
-    if (m_appSettingsRepository && m_appSettingsRepository->isLocalProxyHttpEnabled()) {
-        m_appSettingsRepository->setLocalProxyHttpEnabled(false);
-        emit localProxyStoppedBecauseVpnTurnedOn(tr("Local proxy stopped because VPN was turned on"));
-    }
-#endif
-
     emit openConnectionRequested(serverId, container, vpnConfiguration);
     return ErrorCode::NoError;
 }

client/core/controllers/connectionController.h

@@ -34,6 +34,8 @@ public:
                                QJsonObject& vpnConfiguration,
                                DockerContainer& container);
 
+    ErrorCode isConnectionSupported(const QString &serverId) const;
+
     ErrorCode openConnection(const QString &serverId);
 
     void closeConnection();
@@ -67,13 +69,14 @@ signals:
     void closeConnectionRequested();
     void setConnectionStateRequested(Vpn::ConnectionState state);
     void killSwitchModeChangedRequested(bool enabled);
-    void localProxyStoppedBecauseVpnTurnedOn(const QString &message);
 
 #ifdef Q_OS_ANDROID
     void restoreConnectionRequested();
 #endif
 
 private:
+    ErrorCode defaultContainerForServer(const QString &serverId, DockerContainer &container) const;
+
     SecureServersRepository* m_serversRepository;
     SecureAppSettingsRepository* m_appSettingsRepository;
     VpnConnection* m_vpnConnection;

client/core/controllers/coreController.cpp

@@ -1,10 +1,7 @@
 #include "coreController.h"
 
-#include <QCoreApplication>
 #include <QDirIterator>
-#include <QDebug>
 #include <QTranslator>
-#include <QStandardPaths>
 #include <QTimer>
 
 #include "core/utils/selfhosted/sshSession.h"
@@ -38,10 +35,6 @@ CoreController::CoreController(const QSharedPointer<VpnConnection> &vpnConnectio
     initAppleController();
     initLogging();
 
-#if !defined(Q_OS_ANDROID) && !defined(Q_OS_IOS)
-    initLocalProxy();
-#endif
-
     m_translator = new QTranslator(this);
     if (m_appSettingsRepository) {
         updateTranslator(m_appSettingsRepository->getAppLanguage());
@@ -55,69 +48,6 @@ void CoreController::setQmlContextProperty(const QString &name, QObject *value)
     }
 }
 
-#if !defined(Q_OS_ANDROID) && !defined(Q_OS_IOS)
-void CoreController::initLocalProxy()
-{
-    constexpr quint16 kLocalProxyApiPort = 49490;
-
-    m_proxyServer.reset(new ProxyServer(m_serversRepository, m_appSettingsRepository, this));
-
-    QObject::connect(QCoreApplication::instance(), &QCoreApplication::aboutToQuit, this, [this]() {
-        if (m_appSettingsRepository && m_appSettingsRepository->isLocalProxyHttpEnabled()) {
-            m_appSettingsRepository->setLocalProxyHttpEnabled(false);
-        }
-    });
-
-    auto syncLocalProxy = [this]() {
-        if (!m_proxyServer) {
-            return;
-        }
-
-        const bool httpEnabled = m_appSettingsRepository->isLocalProxyHttpEnabled();
-
-        if (!httpEnabled) {
-            qInfo() << "Local proxy: HTTP API disabled";
-            m_proxyServer->stop();
-            return;
-        }
-
-        if (!m_proxyServer->start(kLocalProxyApiPort)) {
-            qWarning() << "Local proxy: failed to start on port" << kLocalProxyApiPort;
-            m_appSettingsRepository->setLocalProxyHttpEnabled(false);
-            emit m_appSettingsRepository->localProxyStartFailed(tr("Local proxy failed to start. Check if the port is available."));
-            return;
-        }
-
-        if (!m_proxyServer->syncSettings()) {
-            qWarning() << "Local proxy: failed to start proxy core (Xray)";
-            m_appSettingsRepository->setLocalProxyHttpEnabled(false);
-            emit m_appSettingsRepository->localProxyStartFailed(tr("Couldn’t start the proxy due to an internal error. Try restarting the app."));
-            return;
-        }
-
-        qInfo() << "Local proxy: running on 127.0.0.1:" << kLocalProxyApiPort;
-    };
-
-    syncLocalProxy();
-
-    connect(m_appSettingsRepository, &SecureAppSettingsRepository::localProxySettingsChanged, this, syncLocalProxy);
-
-    connect(m_serversRepository, &SecureServersRepository::serverEdited, this, [this](const QString &serverId) {
-        if (m_appSettingsRepository && m_appSettingsRepository->isLocalProxyHttpEnabled()
-            && m_appSettingsRepository->localProxyOwnerId() == serverId) {
-            m_appSettingsRepository->bumpLocalProxyRestartToken();
-        }
-    });
-
-    connect(m_serversRepository, &SecureServersRepository::serverRemoved, this, [this](const QString &serverId, int) {
-        if (m_appSettingsRepository && m_appSettingsRepository->localProxyOwnerId() == serverId) {
-            m_appSettingsRepository->setLocalProxyOwnerId(QString());
-            m_appSettingsRepository->setLocalProxyHttpEnabled(false);
-        }
-    });
-}
-#endif
-
 void CoreController::initModels()
 {
     m_containersModel = new ContainersModel(this);
@@ -261,17 +191,12 @@ void CoreController::initControllers()
     m_languageUiController = new LanguageUiController(m_settingsController, m_languageModel, this);
     setQmlContextProperty("LanguageUiController", m_languageUiController);
 
-    m_settingsUiController = new SettingsUiController(m_settingsController, m_serversController, m_languageUiController, this);
+    m_settingsUiController = new SettingsUiController(m_settingsController, m_serversController, this);
     setQmlContextProperty("SettingsController", m_settingsUiController);
 
     m_pageController = new PageController(m_serversController, m_settingsController, this);
     setQmlContextProperty("PageController", m_pageController);
 
-#if !defined(Q_OS_ANDROID) && !defined(Q_OS_IOS)
-    connect(m_connectionController, &ConnectionController::localProxyStoppedBecauseVpnTurnedOn, m_pageController,
-            &PageController::showNotificationMessage);
-#endif
-
     m_serversUiController = new ServersUiController(m_serversController, m_settingsController, m_serversModel, m_containersModel, m_defaultServerContainersModel, this);
     setQmlContextProperty("ServersUiController", m_serversUiController);
 

client/core/controllers/coreController.h

@@ -78,7 +78,6 @@
 #include "ui/models/newsModel.h"
 
 #if !defined(Q_OS_ANDROID) && !defined(Q_OS_IOS)
-    #include "core/local-proxy/proxyserver.h"
     #include "ui/utils/notificationHandler.h"
 #endif
 
@@ -143,9 +142,6 @@ private:
     void initAppleController();
     void initLogging();
     void initSignalHandlers();
-#if !defined(Q_OS_ANDROID) && !defined(Q_OS_IOS)
-    void initLocalProxy();
-#endif
     void setQmlContextProperty(const QString &name, QObject *value);
 
     QQmlApplicationEngine *m_engine {}; // TODO use parent child system here?
@@ -231,10 +227,6 @@ private:
     TelemtConfigModel* m_telemtConfigModel;
 
     CoreSignalHandlers* m_signalHandlers;
-
-#if !defined(Q_OS_ANDROID) && !defined(Q_OS_IOS)
-    QScopedPointer<ProxyServer> m_proxyServer;
-#endif
 };
 
 #endif // CORECONTROLLER_H

client/core/controllers/coreSignalHandlers.cpp

@@ -1,6 +1,7 @@
 #include "coreSignalHandlers.h"
 
 #include <QTimer>
+#include <QtConcurrent>
 
 #include "core/utils/selfhosted/sshSession.h"
 #include "core/utils/errorCodes.h"
@@ -33,7 +34,6 @@
 #include "core/controllers/connectionController.h"
 #include "ui/models/clientManagementModel.h"
 #include "ui/controllers/api/apiNewsUiController.h"
-#include "ui/models/api/apiCountryModel.h"
 #include "ui/models/containersModel.h"
 #include "core/utils/containerEnum.h"
 
@@ -145,7 +145,9 @@ void CoreSignalHandlers::initExportControllerHandler()
             });
     connect(m_coreController->m_exportController, &ExportController::revokeClientRequested, this,
             [this](const QString &serverId, int row, DockerContainer container) {
-                m_coreController->m_usersController->revokeClient(serverId, row, container);
+                QtConcurrent::run([this, serverId, row, container]() {
+                    m_coreController->m_usersController->revokeClient(serverId, row, container);
+                });
             });
     connect(m_coreController->m_exportController, &ExportController::renameClientRequested, this,
             [this](const QString &serverId, int row, const QString &clientName, DockerContainer container) {
@@ -156,15 +158,17 @@ void CoreSignalHandlers::initExportControllerHandler()
 void CoreSignalHandlers::initImportControllerHandler()
 {
     connect(m_coreController->m_importCoreController, &ImportController::importFinished, this, [this]() {
-        if (!m_coreController->m_connectionController->isConnected()) {
-            int newServerIndex = m_coreController->m_serversController->getServersCount() - 1;
-            const QString serverId = m_coreController->m_serversController->getServerId(newServerIndex);
-            if (!serverId.isEmpty()) {
-                m_coreController->m_serversController->setDefaultServer(serverId);
-            }
-            if (m_coreController->m_serversUiController) {
-                m_coreController->m_serversUiController->setProcessedServerId(serverId);
-            }
+        if (m_coreController->m_connectionUiController->isConnected()) {
+            return;
+        }
+
+        const int newServerIndex = m_coreController->m_serversController->getServersCount() - 1;
+        const QString serverId = m_coreController->m_serversController->getServerId(newServerIndex);
+        if (!serverId.isEmpty()) {
+            m_coreController->m_serversController->setDefaultServer(serverId);
+        }
+        if (m_coreController->m_serversUiController) {
+            m_coreController->m_serversUiController->setProcessedServerId(serverId);
         }
     });
 }
@@ -176,17 +180,14 @@ void CoreSignalHandlers::initApiCountryModelUpdateHandler()
         if (processedServerId.isEmpty()) {
             return;
         }
-        
-        QJsonArray availableCountries;
-        QString serverCountryCode;
 
         const auto apiV2 = m_coreController->m_serversRepository->apiV2Config(processedServerId);
-        if (apiV2.has_value()) {
-            availableCountries = apiV2->apiConfig.availableCountries;
-            serverCountryCode = apiV2->apiConfig.serverCountryCode;
+        if (!apiV2.has_value()) {
+            return;
         }
-        
-        m_coreController->m_apiCountryModel->updateModel(availableCountries, serverCountryCode);
+
+        m_coreController->m_apiCountryModel->updateModel(apiV2->apiConfig.availableCountries,
+                                                           apiV2->apiConfig.serverCountryCode);
     });
 }
 
@@ -204,13 +205,15 @@ void CoreSignalHandlers::initAdminConfigRevokedHandler()
 {
     connect(m_coreController->m_installController, &InstallController::clientRevocationRequested, this,
             [this](const QString &serverId, const ContainerConfig &containerConfig, DockerContainer container) {
-                m_coreController->m_usersController->revokeClient(serverId, containerConfig, container);
+                QtConcurrent::run([this, serverId, containerConfig, container]() {
+                    m_coreController->m_usersController->revokeClient(serverId, containerConfig, container);
+                });
             });
 
     connect(m_coreController->m_installController, &InstallController::clientAppendRequested, this,
             [this](const QString &serverId, const QString &clientId, const QString &clientName, DockerContainer container) {
                 m_coreController->m_usersController->appendClient(serverId, clientId, clientName, container);
-            });
+            }, Qt::DirectConnection);
 
     connect(m_coreController->m_usersController, &UsersController::adminConfigRevoked, m_coreController->m_installController,
             &InstallController::clearCachedProfile);
@@ -237,13 +240,16 @@ void CoreSignalHandlers::initLanguageHandler()
     connect(m_coreController->m_settingsUiController, &SettingsUiController::resetLanguageToSystem, m_coreController->m_languageUiController, [this]() {
         m_coreController->m_languageUiController->changeLanguage(m_coreController->m_languageUiController->getSystemLanguageEnum());
     });
+    connect(m_coreController->m_settingsUiController, &SettingsUiController::appLanguageChanged, m_coreController->m_languageUiController, [this]() {
+        m_coreController->m_languageUiController->onAppLanguageChanged(m_coreController->m_settingsController->getAppLanguage());
+    });
 }
 
 void CoreSignalHandlers::initAutoConnectHandler()
 {
     if (m_coreController->m_settingsUiController->isAutoConnectEnabled()
         && !m_coreController->m_serversController->getDefaultServerId().isEmpty()) {
-        QTimer::singleShot(1000, this, [this]() { m_coreController->m_connectionUiController->openConnection(); });
+        QTimer::singleShot(1000, this, [this]() { m_coreController->m_connectionUiController->toggleConnection(); });
     }
 }
 
@@ -284,6 +290,8 @@ void CoreSignalHandlers::initClientManagementModelUpdateHandler()
             m_coreController->m_clientManagementModel, &ClientManagementModel::updateModel);
     connect(m_coreController->m_usersController, &UsersController::clientRenamed,
             m_coreController->m_clientManagementModel, &ClientManagementModel::updateClientName);
+    connect(m_coreController->m_usersController, &UsersController::revokeFinished,
+            m_coreController->m_exportController, &ExportController::revokeFinished);
 }
 
 void CoreSignalHandlers::initSitesModelUpdateHandler()
@@ -348,6 +356,9 @@ void CoreSignalHandlers::initUnsupportedConnectDrawerHandler()
 {
     connect(m_coreController->m_subscriptionUiController, &SubscriptionUiController::unsupportedConnectDrawerRequested,
             m_coreController->m_pageController, &PageController::unsupportedConnectDrawerRequested);
+
+    connect(m_coreController->m_connectionUiController, &ConnectionUiController::unsupportedConnectDrawerRequested,
+            m_coreController->m_pageController, &PageController::unsupportedConnectDrawerRequested);
 }
 
 void CoreSignalHandlers::initStrictKillSwitchHandler()

client/core/controllers/selfhosted/exportController.h

@@ -48,6 +48,7 @@ signals:
     void appendClientRequested(const QString &serverId, const QString &clientId, const QString &clientName, DockerContainer container);
     void updateClientsRequested(const QString &serverId, DockerContainer container);
     void revokeClientRequested(const QString &serverId, int row, DockerContainer container);
+    void revokeFinished(ErrorCode errorCode);
     void renameClientRequested(const QString &serverId, int row, const QString &clientName, DockerContainer container);
 
 public slots:

client/core/controllers/selfhosted/installController.cpp

@@ -72,6 +72,16 @@ namespace
         }
         return false;
     }
+
+    QString buildRemoveContainerScript(const amnezia::ScriptVars &vars, bool removeDataVolume)
+    {
+        QString script = SshSession::replaceVars(amnezia::scriptData(SharedScriptType::remove_container), vars);
+        if (removeDataVolume) {
+            script += QLatin1String("\nsudo docker volume rm -f $CONTAINER_NAME-data 2>/dev/null || true");
+            script = SshSession::replaceVars(script, vars);
+        }
+        return script;
+    }
 }
 
 InstallController::InstallController(SecureServersRepository *serversRepository,
@@ -120,14 +130,10 @@ ErrorCode InstallController::setupContainer(const ServerCredentials &credentials
         return e;
     qDebug().noquote() << "InstallController::setupContainer prepareHostWorker finished";
 
-    amnezia::ScriptVars removeContainerVars =
+    const amnezia::ScriptVars removeContainerVars =
             amnezia::genBaseVars(credentials, container, QString(), QString());
-    if (!isUpdate) {
-        removeContainerVars.append({ { "$REMOVE_CONTAINER_DATA", QStringLiteral("1") } });
-    }
-    sshSession.runScript(credentials,
-                         sshSession.replaceVars(amnezia::scriptData(SharedScriptType::remove_container),
-                                                removeContainerVars));
+    const bool removeDataVolume = !isUpdate && (container == DockerContainer::MtProxy || container == DockerContainer::Telemt);
+    sshSession.runScript(credentials, buildRemoveContainerScript(removeContainerVars, removeDataVolume));
     qDebug().noquote() << "InstallController::setupContainer removeContainer finished";
 
     qDebug().noquote() << "buildContainerWorker start";
@@ -152,8 +158,8 @@ ErrorCode InstallController::setupContainer(const ServerCredentials &credentials
     return startupContainerWorker(credentials, container, config, sshSession);
 }
 
-ErrorCode InstallController::updateContainer(const QString &serverId, DockerContainer container, const ContainerConfig &oldConfig,
-                                             ContainerConfig &newConfig)
+ErrorCode InstallController::updateServerConfig(const QString &serverId, DockerContainer container, const ContainerConfig &oldConfig,
+                                                ContainerConfig &newConfig)
 {
     if (!isUpdateDockerContainerRequired(container, oldConfig, newConfig)) {
         auto adminConfig = m_serversRepository->selfHostedAdminConfig(serverId);
@@ -185,7 +191,7 @@ ErrorCode InstallController::updateContainer(const QString &serverId, DockerCont
     SshSession sshSession(this);
 
     bool reinstallRequired = isReinstallContainerRequired(container, oldConfig, newConfig);
-    qDebug() << "InstallController::updateContainer for container" << container << "reinstall required is" << reinstallRequired;
+    qDebug() << "InstallController::updateServerConfig for container" << container << "reinstall required is" << reinstallRequired;
 
     bool xrayServerSettingsChanged = false;
     if (container == DockerContainer::Xray || container == DockerContainer::SSXray) {
@@ -213,11 +219,11 @@ ErrorCode InstallController::updateContainer(const QString &serverId, DockerCont
     if (errorCode == ErrorCode::NoError && xrayServerSettingsChanged && !skipXrayInboundSync) {
         DnsSettings dnsSettings = { m_appSettingsRepository->primaryDns(), m_appSettingsRepository->secondaryDns() };
         XrayConfigurator xrayConfigurator(&sshSession);
-        qDebug() << "InstallController::updateContainer applying Xray server inbound sync, reinstall="
+        qDebug() << "InstallController::updateServerConfig applying Xray server inbound sync, reinstall="
                  << reinstallRequired;
         errorCode = xrayConfigurator.applyServerSettingsToRemote(credentials, container, newConfig, dnsSettings, false);
         if (errorCode != ErrorCode::NoError) {
-            qDebug() << "InstallController::updateContainer Xray inbound sync failed, error="
+            qDebug() << "InstallController::updateServerConfig Xray inbound sync failed, error="
                      << static_cast<int>(errorCode);
         }
     }
@@ -228,7 +234,9 @@ ErrorCode InstallController::updateContainer(const QString &serverId, DockerCont
         } else if (container == DockerContainer::Telemt) {
             TelemtInstaller::uploadClientSettingsSnapshot(sshSession, credentials, container, newConfig);
         }
-        clearCachedProfile(serverId, container);
+        if (reinstallRequired) {
+            clearCachedProfile(serverId, container);
+        }
         adminConfig->updateContainerConfig(container, newConfig);
         m_serversRepository->editServer(serverId, adminConfig->toJson(), serverConfigUtils::ConfigType::SelfHostedAdmin);
     }
@@ -236,6 +244,41 @@ ErrorCode InstallController::updateContainer(const QString &serverId, DockerCont
     return errorCode;
 }
 
+ErrorCode InstallController::updateClientConfig(const QString &serverId, DockerContainer container, ContainerConfig &newConfig)
+{
+    switch (m_serversRepository->serverKind(serverId)) {
+    case serverConfigUtils::ConfigType::SelfHostedAdmin: {
+        auto config = m_serversRepository->selfHostedAdminConfig(serverId);
+        if (!config.has_value()) {
+            return ErrorCode::InternalError;
+        }
+        config->updateContainerConfig(container, newConfig);
+        m_serversRepository->editServer(serverId, config->toJson(), serverConfigUtils::ConfigType::SelfHostedAdmin);
+        return ErrorCode::NoError;
+    }
+    case serverConfigUtils::ConfigType::SelfHostedUser: {
+        auto config = m_serversRepository->selfHostedUserConfig(serverId);
+        if (!config.has_value()) {
+            return ErrorCode::InternalError;
+        }
+        config->updateContainerConfig(container, newConfig);
+        m_serversRepository->editServer(serverId, config->toJson(), serverConfigUtils::ConfigType::SelfHostedUser);
+        return ErrorCode::NoError;
+    }
+    case serverConfigUtils::ConfigType::Native: {
+        auto config = m_serversRepository->nativeConfig(serverId);
+        if (!config.has_value()) {
+            return ErrorCode::InternalError;
+        }
+        config->updateContainerConfig(container, newConfig);
+        m_serversRepository->editServer(serverId, config->toJson(), serverConfigUtils::ConfigType::Native);
+        return ErrorCode::NoError;
+    }
+    default:
+        return ErrorCode::InternalError;
+    }
+}
+
 void InstallController::clearCachedProfile(const QString &serverId, DockerContainer container)
 {
     if (ContainerUtils::containerService(container) == ServiceType::Other) {
@@ -795,8 +838,8 @@ ErrorCode InstallController::installDockerWorker(const ServerCredentials &creden
     qDebug().noquote() << "InstallController::installDockerWorker" << stdOut;
 
     if (container == DockerContainer::Awg2) {
-        QRegularExpression regex(R"(Linux\s+(\d+)\.(\d+)[^\d]*)");
-        QRegularExpressionMatch match = regex.match(stdOut);
+        QRegularExpression kernelVersionRegex(R"(Linux\s+(\d+)\.(\d+)[^\d]*)");
+        QRegularExpressionMatch match = kernelVersionRegex.match(stdOut);
         if (match.hasMatch()) {
             int majorVersion = match.captured(1).toInt();
             int minorVersion = match.captured(2).toInt();
@@ -809,8 +852,19 @@ ErrorCode InstallController::installDockerWorker(const ServerCredentials &creden
 
     if (stdOut.contains("lock"))
         return ErrorCode::ServerPacketManagerError;
-    if (stdOut.contains("command not found"))
+    if (stdOut.contains("Container runtime is not supported"))
+        return ErrorCode::ServerContainerRuntimeNotSupported;
+    
+    QRegularExpression notFoundRegex(
+        R"(^.*(?:sudo:|docker:).*not found.*$)",
+        QRegularExpression::MultilineOption);
+
+    if (notFoundRegex.match(stdOut).hasMatch()) {
         return ErrorCode::ServerDockerFailedError;
+    }
+    
+    if (stdOut.contains("Container runtime service not running"))
+        return ErrorCode::ContainerRuntimeServiceNotRunning;
 
     return error;
 }
@@ -847,7 +901,7 @@ ErrorCode InstallController::isUserInSudo(const ServerCredentials &credentials,
         return ErrorCode::ServerUserNotInSudo;
     if (stdOut.contains("can't cd to") || stdOut.contains("Permission denied") || stdOut.contains("No such file or directory"))
         return ErrorCode::ServerUserDirectoryNotAccessible;
-    if (stdOut.contains("sudoers") || stdOut.contains("is not allowed to run sudo on"))
+    if (stdOut.contains(QRegularExpression(R"(\bsudoers\b)")) || stdOut.contains("is not allowed to") || stdOut.contains("can't do that"))
         return ErrorCode::ServerUserNotAllowedInSudoers;
     if (stdOut.contains("password is required") || stdOut.contains("authentication is required"))
         return ErrorCode::ServerUserPasswordRequired;
@@ -980,12 +1034,11 @@ ErrorCode InstallController::removeContainer(const QString &serverId, DockerCont
         return ErrorCode::InternalError;
     }
     SshSession sshSession(this);
-    amnezia::ScriptVars removeContainerVars =
+    const amnezia::ScriptVars removeContainerVars =
             amnezia::genBaseVars(credentials, container, QString(), QString());
-    removeContainerVars.append({ { "$REMOVE_CONTAINER_DATA", QStringLiteral("1") } });
-    ErrorCode errorCode = sshSession.runScript(
-            credentials,
-            sshSession.replaceVars(amnezia::scriptData(SharedScriptType::remove_container), removeContainerVars));
+    const bool removeDataVolume = (container == DockerContainer::MtProxy || container == DockerContainer::Telemt);
+    ErrorCode errorCode =
+            sshSession.runScript(credentials, buildRemoveContainerScript(removeContainerVars, removeDataVolume));
 
     if (errorCode == ErrorCode::NoError) {
         QMap<DockerContainer, ContainerConfig> containers = adminConfig->containers;
@@ -1463,7 +1516,7 @@ ErrorCode InstallController::getAlreadyInstalledContainers(const ServerCredentia
             QString transportProtoStr = containerAndPortMatch.captured(3);
             DockerContainer container = ContainerUtils::containerFromString(name);
 
-            if (container == DockerContainer::None) {
+            if (container == DockerContainer::None || ContainerUtils::isUnsupportedContainer(container)) {
                 continue;
             }
 
@@ -1488,7 +1541,7 @@ ErrorCode InstallController::getAlreadyInstalledContainers(const ServerCredentia
             QString transportProtoStr = torOrDnsRegMatch.captured(3);
             DockerContainer container = ContainerUtils::containerFromString(name);
 
-            if (container == DockerContainer::None) {
+            if (container == DockerContainer::None || ContainerUtils::isUnsupportedContainer(container)) {
                 continue;
             }
 

client/core/controllers/selfhosted/installController.h

@@ -34,7 +34,12 @@ public:
     ~InstallController();
 
     ErrorCode setupContainer(const ServerCredentials &credentials, DockerContainer container, ContainerConfig &config, bool isUpdate = false);
-    ErrorCode updateContainer(const QString &serverId, DockerContainer container, const ContainerConfig &oldConfig, ContainerConfig &newConfig);
+
+    // Updates server-side container settings (admin self-hosted only): reconfigures the container over SSH.
+    ErrorCode updateServerConfig(const QString &serverId, DockerContainer container, const ContainerConfig &oldConfig, ContainerConfig &newConfig);
+
+    // Updates client-local settings only: rewrites the stored container config for any self-hosted/native server. No SSH.
+    ErrorCode updateClientConfig(const QString &serverId, DockerContainer container, ContainerConfig &newConfig);
 
     ErrorCode rebootServer(const QString &serverId);
     ErrorCode removeAllContainers(const QString &serverId);

client/core/controllers/selfhosted/usersController.cpp

@@ -698,7 +698,7 @@ ErrorCode UsersController::revokeXray(const int row,
 
     QString restartScript = QString("sudo docker restart $CONTAINER_NAME");
     error = sshSession->runScript(
-        credentials, 
+        credentials,
         sshSession->replaceVars(restartScript, amnezia::genBaseVars(credentials, container, QString(), QString()))
     );
     if (error != ErrorCode::NoError) {
@@ -758,14 +758,17 @@ ErrorCode UsersController::revokeClient(const QString &serverId, const int index
         ContainerConfig containerCfg = adminConfig->containerConfig(container);
         QString containerClientId = containerCfg.protocolConfig.clientId();
 
-        if (!clientId.isEmpty() && !containerClientId.isEmpty() && containerClientId.contains(clientId)) {
+        const bool isAdminMatch = !clientId.isEmpty() && !containerClientId.isEmpty() && containerClientId.contains(clientId);
+        if (isAdminMatch) {
             emit adminConfigRevoked(serverId, container);
         }
 
         emit clientRevoked(index);
-        emit clientsUpdated(m_clientsTable);
     }
 
+    emit clientsUpdated(m_clientsTable);
+    emit revokeFinished(errorCode);
+
     return errorCode;
 }
 

client/core/controllers/selfhosted/usersController.h

@@ -37,6 +37,7 @@ signals:
     void clientAdded(const QJsonObject &client);
     void clientRenamed(int row, const QString &newName);
     void clientRevoked(int row);
+    void revokeFinished(ErrorCode errorCode);
     void adminConfigRevoked(const QString &serverId, DockerContainer container);
 
 public slots:

client/core/controllers/settingsController.cpp

@@ -8,19 +8,10 @@
 #include "version.h"
 #include "ui/utils/qAutoStart.h"
 #include "logger.h"
-#if !defined(Q_OS_ANDROID) && !defined(Q_OS_IOS)
-    #include "core/local-proxy/portavailabilityhelper.h"
-#endif
 #ifdef Q_OS_ANDROID
     #include "platforms/android/android_controller.h"
 #endif
 
-namespace {
-constexpr int kDefaultProxyPort = 10808;
-constexpr int kLocalProxyPortMin = 1024;
-constexpr int kLocalProxyPortMax = 65535;
-}
-
 QString getPlatformName()
 {
 #if defined(Q_OS_WINDOWS)
@@ -47,11 +38,6 @@ SettingsController::SettingsController(SecureServersRepository* serversRepositor
 {
     m_appVersion = QString("%1 (%2, %3)").arg(QString(APP_VERSION), __DATE__, GIT_COMMIT_HASH);
     m_isDevModeEnabled = m_appSettingsRepository->isDevGatewayEnv();
-
-    connect(m_appSettingsRepository, &SecureAppSettingsRepository::localProxySettingsChanged, this,
-            &SettingsController::localProxySettingsUpdated);
-    connect(m_appSettingsRepository, &SecureAppSettingsRepository::localProxyStartFailed, this,
-            &SettingsController::localProxyStartFailed);
 }
 
 void SettingsController::toggleAmneziaDns(bool enable)
@@ -380,114 +366,3 @@ QString SettingsController::nextAvailableServerName() const
     return m_serversRepository->nextAvailableServerName();
 }
 
-bool SettingsController::isLocalProxySupported() const
-{
-#ifdef AMNEZIA_DESKTOP
-    return true;
-#else
-    return false;
-#endif
-}
-
-bool SettingsController::isLocalProxyHttpEnabled() const
-{
-    return m_appSettingsRepository->isLocalProxyHttpEnabled();
-}
-
-int SettingsController::localProxyPort() const
-{
-    return static_cast<int>(m_appSettingsRepository->localProxyPort());
-}
-
-QString SettingsController::localProxyOwnerId() const
-{
-    return m_appSettingsRepository->localProxyOwnerId();
-}
-
-bool SettingsController::isLocalProxyPortUserDefined() const
-{
-    return m_appSettingsRepository->isLocalProxyPortUserDefined();
-}
-
-bool SettingsController::setLocalProxyPort(int port)
-{
-    if (port < kLocalProxyPortMin || port > kLocalProxyPortMax) {
-        return false;
-    }
-
-    if (m_appSettingsRepository->localProxyPort() == static_cast<quint16>(port)) {
-        m_appSettingsRepository->setLocalProxyPortUserDefined(true);
-        return true;
-    }
-
-    m_appSettingsRepository->setLocalProxyPort(static_cast<quint16>(port));
-    m_appSettingsRepository->setLocalProxyPortUserDefined(true);
-    return true;
-}
-
-bool SettingsController::isLocalProxyPortBusy(int port) const
-{
-#if !defined(Q_OS_ANDROID) && !defined(Q_OS_IOS)
-    return !PortAvailabilityHelper::isPortAvailable(port);
-#else
-    Q_UNUSED(port);
-    return false;
-#endif
-}
-
-int SettingsController::findFirstAvailableLocalProxyPort(int startPort) const
-{
-#if !defined(Q_OS_ANDROID) && !defined(Q_OS_IOS)
-    const auto port = PortAvailabilityHelper::findFirstAvailablePort(startPort, kLocalProxyPortMax);
-    return port ? *port : -1;
-#else
-    Q_UNUSED(startPort);
-    return -1;
-#endif
-}
-
-bool SettingsController::enableLocalProxy(const QString &ownerId, int port)
-{
-#if defined(Q_OS_ANDROID) || defined(Q_OS_IOS)
-    Q_UNUSED(ownerId);
-    Q_UNUSED(port);
-    return false;
-#else
-    if (port < kLocalProxyPortMin || port > kLocalProxyPortMax || ownerId.isEmpty()) {
-        return false;
-    }
-
-    if (m_appSettingsRepository->isLocalProxyHttpEnabled() && m_appSettingsRepository->localProxyOwnerId() != ownerId) {
-        return false;
-    }
-
-    int selectedPort = port;
-
-    const bool isUserDefinedPort = m_appSettingsRepository->isLocalProxyPortUserDefined();
-    if (isUserDefinedPort) {
-        if (!PortAvailabilityHelper::isPortAvailable(selectedPort)) {
-            return false;
-        }
-    } else if (selectedPort != kDefaultProxyPort && !PortAvailabilityHelper::isPortAvailable(selectedPort)) {
-        return false;
-    }
-
-    if (m_appSettingsRepository->localProxyPort() != static_cast<quint16>(selectedPort)) {
-        m_appSettingsRepository->setLocalProxyPort(static_cast<quint16>(selectedPort));
-    }
-    m_appSettingsRepository->setLocalProxyPortUserDefined(isUserDefinedPort);
-
-    m_appSettingsRepository->setLocalProxyOwnerId(ownerId);
-    m_appSettingsRepository->setLocalProxyHttpEnabled(true);
-
-    return true;
-#endif
-}
-
-void SettingsController::disableLocalProxy()
-{
-    if (m_appSettingsRepository->isLocalProxyHttpEnabled()) {
-        m_appSettingsRepository->setLocalProxyHttpEnabled(false);
-    }
-}
-

client/core/controllers/settingsController.h

@@ -89,18 +89,6 @@ public:
     QLocale getAppLanguage() const;
     void setAppLanguage(const QLocale &locale);
 
-    // Local proxy
-    bool isLocalProxySupported() const;
-    bool isLocalProxyHttpEnabled() const;
-    int localProxyPort() const;
-    QString localProxyOwnerId() const;
-    bool isLocalProxyPortUserDefined() const;
-    bool setLocalProxyPort(int port);
-    bool isLocalProxyPortBusy(int port) const;
-    int findFirstAvailableLocalProxyPort(int startPort) const;
-    bool enableLocalProxy(const QString &ownerId, int port);
-    void disableLocalProxy();
-
 signals:
     void siteSplitTunnelingRouteModeChanged(RouteMode mode);
     void siteSplitTunnelingToggled(bool enabled);
@@ -108,9 +96,6 @@ signals:
     void appSplitTunnelingToggled(bool enabled);
     void appSplitTunnelingClearAppsList();
 
-    void localProxySettingsUpdated();
-    void localProxyStartFailed(const QString &message);
-
 private:
     QString getPlatform() const;
 

client/core/local-proxy/configmanager.cpp

@@ -1,444 +0,0 @@
-#include "configmanager.h"
-
-#include "core/controllers/gatewayController.h"
-#include "core/repositories/secureAppSettingsRepository.h"
-#include "core/repositories/secureServersRepository.h"
-#include "core/utils/api/apiUtils.h"
-#include "core/utils/constants/apiConstants.h"
-#include "core/utils/constants/apiKeys.h"
-#include "core/utils/constants/configKeys.h"
-#include "core/utils/containers/containerUtils.h"
-#include "portavailabilityhelper.h"
-#include "proxylogger.h"
-#include "version.h"
-
-#include <QDir>
-#include <QFile>
-#include <QJsonArray>
-#include <QJsonDocument>
-#include <QJsonParseError>
-#include <QSaveFile>
-#include <QSysInfo>
-#include <QStandardPaths>
-#include <QUuid>
-
-using namespace amnezia;
-
-ConfigManager::ConfigManager(SecureServersRepository *serversRepository, SecureAppSettingsRepository *appSettingsRepository)
-    : m_serversRepository(serversRepository), m_appSettingsRepository(appSettingsRepository)
-{
-    ProxyLogger::getInstance().debug("ConfigManager initialized (repository-backed)");
-}
-
-namespace {
-namespace gateway_key {
-constexpr char vless[] = "vless";
-} // namespace gateway_key
-
-constexpr quint16 kDefaultProxyPort = 10808;
-constexpr int kProxyPortMin = 1024;
-constexpr int kProxyPortMax = 65535;
-
-int resolveProxyPort(SecureAppSettingsRepository *appSettings)
-{
-    if (!appSettings) {
-        return kDefaultProxyPort;
-    }
-
-    const quint16 port = appSettings->localProxyPort();
-    if (port < kProxyPortMin || port > kProxyPortMax) {
-        return kDefaultProxyPort;
-    }
-
-    return static_cast<int>(port);
-}
-
-} // namespace
-
-bool ConfigManager::applyProxyPortToConfig(QJsonObject &config, int port) const
-{
-    if (!config.contains("inbounds") || !config.value("inbounds").isArray()) {
-        return false;
-    }
-
-    QJsonArray inbounds = config.value("inbounds").toArray();
-    if (inbounds.isEmpty() || !inbounds.at(0).isObject()) {
-        return false;
-    }
-
-    QJsonObject firstInbound = inbounds.at(0).toObject();
-    firstInbound.insert("port", port);
-    inbounds[0] = firstInbound;
-    config.insert("inbounds", inbounds);
-    return true;
-}
-
-QString ConfigManager::serializeConfig(const QJsonObject &config) const
-{
-    return QString::fromUtf8(QJsonDocument(config).toJson(QJsonDocument::Compact));
-}
-
-std::optional<ConfigManager::ConfigData> ConfigManager::buildConfig(QString &errorDescription) const
-{
-    errorDescription.clear();
-
-    if (!m_serversRepository || !m_appSettingsRepository) {
-        const QString message = QStringLiteral("Local proxy repositories are not available");
-        ProxyLogger::getInstance().error(message);
-        errorDescription = message;
-        return std::nullopt;
-    }
-
-    const QString ownerId = m_appSettingsRepository->localProxyOwnerId();
-    if (ownerId.isEmpty()) {
-        const QString message = QStringLiteral("Local proxy owner server id is not configured");
-        ProxyLogger::getInstance().warning(message);
-        errorDescription = message;
-        return std::nullopt;
-    }
-
-    const auto ownerServer = m_serversRepository->serverJsonById(ownerId);
-    if (!ownerServer) {
-        const QString message = QStringLiteral("Owner server with id %1 not found").arg(ownerId);
-        ProxyLogger::getInstance().error(message);
-        errorDescription = message;
-        return std::nullopt;
-    }
-
-    if (!apiUtils::isPremiumServer(*ownerServer)) {
-        const QString message = QStringLiteral("Server %1 is not premium, local proxy is unavailable")
-                                        .arg(ownerServer->value(configKey::name).toString());
-        ProxyLogger::getInstance().warning(message);
-        errorDescription = message;
-        return std::nullopt;
-    }
-
-    const auto serializedConfig = extractSerializedXrayConfig(*ownerServer);
-    if (!serializedConfig || serializedConfig->isEmpty()) {
-        const QString message = QStringLiteral("Server %1 lacks Xray last_config payload")
-                                        .arg(ownerServer->value(configKey::name).toString());
-        ProxyLogger::getInstance().error(message);
-        errorDescription = message;
-        return std::nullopt;
-    }
-
-    QJsonParseError parseError;
-    const QJsonDocument doc = QJsonDocument::fromJson(serializedConfig->toUtf8(), &parseError);
-    if (parseError.error != QJsonParseError::NoError || !doc.isObject()) {
-        const QString message = QStringLiteral("Failed to parse Xray config JSON: %1").arg(parseError.errorString());
-        ProxyLogger::getInstance().error(message);
-        errorDescription = message;
-        return std::nullopt;
-    }
-
-    ConfigData data;
-    data.ownerId = ownerId;
-    data.serverName = ownerServer->value(configKey::name).toString();
-    data.parsedConfig = doc.object();
-    const int proxyPort = resolveProxyPort(m_appSettingsRepository);
-    if (applyProxyPortToConfig(data.parsedConfig, proxyPort)) {
-        data.serializedConfig = serializeConfig(data.parsedConfig);
-    } else {
-        ProxyLogger::getInstance().warning(QStringLiteral("Failed to override local proxy inbound port; using original config"));
-        data.serializedConfig = *serializedConfig;
-    }
-
-    return data;
-}
-
-std::optional<ConfigManager::ConfigData> ConfigManager::buildConfigWithFetch(QString &errorDescription) const
-{
-    errorDescription.clear();
-
-    if (!m_serversRepository || !m_appSettingsRepository) {
-        const QString message = QStringLiteral("Local proxy repositories are not available");
-        ProxyLogger::getInstance().error(message);
-        errorDescription = message;
-        return std::nullopt;
-    }
-
-    const QString ownerId = m_appSettingsRepository->localProxyOwnerId();
-    if (ownerId.isEmpty()) {
-        const QString message = QStringLiteral("Local proxy owner server id is not configured");
-        ProxyLogger::getInstance().warning(message);
-        errorDescription = message;
-        return std::nullopt;
-    }
-
-    const auto ownerServer = m_serversRepository->serverJsonById(ownerId);
-    if (!ownerServer) {
-        const QString message = QStringLiteral("Owner server with id %1 not found").arg(ownerId);
-        ProxyLogger::getInstance().error(message);
-        errorDescription = message;
-        return std::nullopt;
-    }
-
-    if (!apiUtils::isPremiumServer(*ownerServer)) {
-        const QString message = QStringLiteral("Server %1 is not premium, local proxy is unavailable")
-                                        .arg(ownerServer->value(configKey::name).toString());
-        ProxyLogger::getInstance().warning(message);
-        errorDescription = message;
-        return std::nullopt;
-    }
-
-    auto serializedConfig = extractSerializedXrayConfig(*ownerServer);
-    if (!serializedConfig || serializedConfig->isEmpty()) {
-        auto fetchedConfig = fetchSerializedXrayConfigFromGateway(*ownerServer, errorDescription);
-        if (!fetchedConfig || fetchedConfig->isEmpty()) {
-            return std::nullopt;
-        }
-        serializedConfig = fetchedConfig;
-    }
-
-    QJsonParseError parseError;
-    const QJsonDocument doc = QJsonDocument::fromJson(serializedConfig->toUtf8(), &parseError);
-    if (parseError.error != QJsonParseError::NoError || !doc.isObject()) {
-        const QString message = QStringLiteral("Failed to parse Xray config JSON: %1").arg(parseError.errorString());
-        ProxyLogger::getInstance().error(message);
-        errorDescription = message;
-        return std::nullopt;
-    }
-
-    ConfigData data;
-    data.ownerId = ownerId;
-    data.serverName = ownerServer->value(configKey::name).toString();
-    data.parsedConfig = doc.object();
-
-    int selectedPort = resolveProxyPort(m_appSettingsRepository);
-    const bool isUserDefinedPort = m_appSettingsRepository->isLocalProxyPortUserDefined();
-
-    if (!PortAvailabilityHelper::isPortAvailable(selectedPort)) {
-        const bool canAutoSelect = !isUserDefinedPort && selectedPort == kDefaultProxyPort;
-        if (canAutoSelect) {
-            const auto freePort = PortAvailabilityHelper::findFirstAvailablePort(kDefaultProxyPort + 1, kProxyPortMax);
-            if (!freePort) {
-                errorDescription = QStringLiteral("No available local proxy port in range %1-%2")
-                                       .arg(kDefaultProxyPort + 1)
-                                       .arg(kProxyPortMax);
-                ProxyLogger::getInstance().error(errorDescription);
-                return std::nullopt;
-            }
-            selectedPort = *freePort;
-        } else {
-            errorDescription = QStringLiteral("Local proxy port %1 is already in use")
-                                   .arg(selectedPort);
-            ProxyLogger::getInstance().error(errorDescription);
-            return std::nullopt;
-        }
-    }
-
-    if (applyProxyPortToConfig(data.parsedConfig, selectedPort)) {
-        data.serializedConfig = serializeConfig(data.parsedConfig);
-    } else {
-        ProxyLogger::getInstance().warning(QStringLiteral("Failed to override local proxy inbound port; using original config"));
-        data.serializedConfig = *serializedConfig;
-    }
-
-    return data;
-}
-
-bool ConfigManager::writeTempConfig(const QString &serializedConfig, QString &configPath, QString &errorDescription) const
-{
-    errorDescription.clear();
-    configPath.clear();
-
-    const QString directory = tempDirectory();
-    if (!QDir().mkpath(directory)) {
-        const QString message = QStringLiteral("Failed to create temp config directory: %1").arg(directory);
-        ProxyLogger::getInstance().error(message);
-        errorDescription = message;
-        return false;
-    }
-
-    const QString path = tempConfigPath();
-    QSaveFile file(path);
-    if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
-        const QString message = QStringLiteral("Failed to open temp config file %1: %2").arg(path, file.errorString());
-        ProxyLogger::getInstance().error(message);
-        errorDescription = message;
-        return false;
-    }
-
-    if (file.write(serializedConfig.toUtf8()) == -1) {
-        const QString message = QStringLiteral("Failed to write temp config file %1: %2").arg(path, file.errorString());
-        ProxyLogger::getInstance().error(message);
-        errorDescription = message;
-        return false;
-    }
-
-    if (!file.commit()) {
-        const QString message = QStringLiteral("Failed to commit temp config file %1").arg(path);
-        ProxyLogger::getInstance().error(message);
-        errorDescription = message;
-        return false;
-    }
-
-    ProxyLogger::getInstance().info(QStringLiteral("Xray config saved to %1").arg(path));
-    configPath = path;
-    return true;
-}
-
-bool ConfigManager::removeTempConfig() const
-{
-    const QString path = tempConfigPath();
-    QFile file(path);
-    if (!file.exists()) {
-        return true;
-    }
-
-    if (!file.remove()) {
-        ProxyLogger::getInstance().warning(QStringLiteral("Failed to remove temp config file %1: %2").arg(path, file.errorString()));
-        return false;
-    }
-
-    ProxyLogger::getInstance().debug(QStringLiteral("Removed temp config file %1").arg(path));
-    return true;
-}
-
-QString ConfigManager::tempConfigPath() const
-{
-    return QDir(tempDirectory()).filePath(QStringLiteral("xray_active.json"));
-}
-
-std::optional<QString> ConfigManager::extractSerializedXrayConfig(const QJsonObject &server) const
-{
-    const QJsonArray containers = server.value(configKey::containers).toArray();
-    const QString targetContainer = ContainerUtils::containerToString(DockerContainer::Xray);
-    const QString protoKey = QString(configKey::xray);
-
-    for (const QJsonValue &value : containers) {
-        const QJsonObject container = value.toObject();
-        if (container.value(configKey::container).toString() != targetContainer) {
-            continue;
-        }
-
-        const QJsonObject proto = container.value(protoKey).toObject();
-        const QString serialized = proto.value(configKey::lastConfig).toString();
-        if (!serialized.isEmpty()) {
-            return serialized;
-        }
-    }
-
-    return std::nullopt;
-}
-
-std::optional<QString> ConfigManager::fetchSerializedXrayConfigFromGateway(const QJsonObject &server, QString &errorDescription) const
-{
-    errorDescription.clear();
-
-    if (!m_appSettingsRepository) {
-        const QString message = QStringLiteral("App settings repository is not available");
-        ProxyLogger::getInstance().error(message);
-        errorDescription = message;
-        return std::nullopt;
-    }
-
-    const QJsonObject apiConfig = server.value(apiDefs::key::apiConfig).toObject();
-    if (apiConfig.isEmpty()) {
-        const QString message = QStringLiteral("Server API config is missing");
-        ProxyLogger::getInstance().warning(message);
-        errorDescription = message;
-        return std::nullopt;
-    }
-
-    const QString userCountryCode = apiConfig.value(apiDefs::key::userCountryCode).toString();
-    const QString serviceType = apiConfig.value(apiDefs::key::serviceType).toString();
-    if (userCountryCode.isEmpty() || serviceType.isEmpty()) {
-        const QString message = QStringLiteral("Server API config lacks service identifiers");
-        ProxyLogger::getInstance().warning(message);
-        errorDescription = message;
-        return std::nullopt;
-    }
-
-    QJsonObject apiPayload;
-    apiPayload[apiDefs::key::osVersion] = QSysInfo::productType();
-    apiPayload[apiDefs::key::appVersion] = QString(APP_VERSION);
-
-    const QString appLanguage = m_appSettingsRepository->getAppLanguage().name().split("_").first();
-    if (!appLanguage.isEmpty()) {
-        apiPayload[apiDefs::key::appLanguage] = appLanguage;
-    }
-
-    apiPayload[apiDefs::key::uuid] = m_appSettingsRepository->getInstallationUuid(true);
-    apiPayload[apiDefs::key::userCountryCode] = userCountryCode;
-    apiPayload[apiDefs::key::serviceType] = serviceType;
-    apiPayload[apiDefs::key::serviceProtocol] = QString(gateway_key::vless);
-    apiPayload[apiDefs::key::publicKey] = QUuid::createUuid().toString(QUuid::WithoutBraces);
-
-    const QJsonObject authData = server.value(apiDefs::key::authData).toObject();
-    if (!authData.isEmpty()) {
-        apiPayload[apiDefs::key::authData] = authData;
-    }
-
-    GatewayController gatewayController(m_appSettingsRepository->getGatewayEndpoint(), m_appSettingsRepository->isDevGatewayEnv(),
-                                        apiDefs::requestTimeoutMsecs, m_appSettingsRepository->isStrictKillSwitchEnabled());
-
-    QByteArray responseBody;
-    const amnezia::ErrorCode errorCode = gatewayController.post(QString("%1v1/config"), apiPayload, responseBody);
-    if (errorCode != amnezia::ErrorCode::NoError) {
-        const QString message = QStringLiteral("Gateway request failed with error code %1").arg(static_cast<int>(errorCode));
-        ProxyLogger::getInstance().error(message);
-        errorDescription = message;
-        return std::nullopt;
-    }
-
-    QJsonParseError responseError;
-    const QJsonDocument responseDoc = QJsonDocument::fromJson(responseBody, &responseError);
-    if (responseError.error != QJsonParseError::NoError || !responseDoc.isObject()) {
-        const QString message = QStringLiteral("Failed to parse gateway response: %1").arg(responseError.errorString());
-        ProxyLogger::getInstance().error(message);
-        errorDescription = message;
-        return std::nullopt;
-    }
-
-    QString data = responseDoc.object().value(configKey::config).toString();
-    if (data.isEmpty()) {
-        const QString message = QStringLiteral("Gateway response lacks config payload");
-        ProxyLogger::getInstance().error(message);
-        errorDescription = message;
-        return std::nullopt;
-    }
-
-    data.replace("vpn://", "");
-    QByteArray decoded = QByteArray::fromBase64(data.toUtf8(), QByteArray::Base64UrlEncoding | QByteArray::OmitTrailingEquals);
-    if (decoded.isEmpty()) {
-        const QString message = QStringLiteral("Gateway config payload is empty");
-        ProxyLogger::getInstance().error(message);
-        errorDescription = message;
-        return std::nullopt;
-    }
-
-    const QByteArray uncompressed = qUncompress(decoded);
-    if (!uncompressed.isEmpty()) {
-        decoded = uncompressed;
-    }
-
-    QJsonParseError configError;
-    const QJsonDocument configDoc = QJsonDocument::fromJson(decoded, &configError);
-    if (configError.error != QJsonParseError::NoError || !configDoc.isObject()) {
-        const QString message = QStringLiteral("Failed to parse gateway config JSON: %1").arg(configError.errorString());
-        ProxyLogger::getInstance().error(message);
-        errorDescription = message;
-        return std::nullopt;
-    }
-
-    const auto serializedConfig = extractSerializedXrayConfig(configDoc.object());
-    if (!serializedConfig || serializedConfig->isEmpty()) {
-        const QString message = QStringLiteral("Gateway response lacks Xray last_config payload");
-        ProxyLogger::getInstance().error(message);
-        errorDescription = message;
-        return std::nullopt;
-    }
-
-    ProxyLogger::getInstance().info("Fetched Xray config from gateway");
-    return serializedConfig;
-}
-
-QString ConfigManager::tempDirectory() const
-{
-    const QString baseDir = QStandardPaths::writableLocation(QStandardPaths::AppConfigLocation);
-    if (baseDir.isEmpty()) {
-        return QDir::temp().filePath(QStringLiteral("amnezia_local_proxy"));
-    }
-    return QDir(baseDir).filePath(QStringLiteral("local_proxy"));
-}

client/core/local-proxy/configmanager.h

@@ -1,37 +0,0 @@
-#pragma once
-
-#include <optional>
-
-#include <QJsonObject>
-#include <QString>
-
-class SecureServersRepository;
-class SecureAppSettingsRepository;
-
-class ConfigManager {
-public:
-    struct ConfigData {
-        QString ownerId;
-        QString serverName;
-        QString serializedConfig;
-        QJsonObject parsedConfig;
-    };
-
-    ConfigManager(SecureServersRepository *serversRepository, SecureAppSettingsRepository *appSettingsRepository);
-
-    std::optional<ConfigData> buildConfig(QString &errorDescription) const;
-    std::optional<ConfigData> buildConfigWithFetch(QString &errorDescription) const;
-    bool writeTempConfig(const QString &serializedConfig, QString &configPath, QString &errorDescription) const;
-    bool removeTempConfig() const;
-    QString tempConfigPath() const;
-
-private:
-    std::optional<QString> extractSerializedXrayConfig(const QJsonObject &server) const;
-    std::optional<QString> fetchSerializedXrayConfigFromGateway(const QJsonObject &server, QString &errorDescription) const;
-    QString tempDirectory() const;
-    bool applyProxyPortToConfig(QJsonObject &config, int port) const;
-    QString serializeConfig(const QJsonObject &config) const;
-
-    SecureServersRepository *m_serversRepository;
-    SecureAppSettingsRepository *m_appSettingsRepository;
-};

client/core/local-proxy/httpapi.cpp

@@ -1,190 +0,0 @@
-#include "httpapi.h"
-#include "proxylogger.h"
-#include <QJsonObject>
-#include <QJsonArray>
-#include <QHostAddress>
-#include <optional>
-
-namespace {
-
-std::optional<int> extractInboundPort(const QJsonObject &config)
-{
-    if (!config.contains("inbounds") || !config["inbounds"].isArray()) {
-        return std::nullopt;
-    }
-
-    const QJsonArray inbounds = config["inbounds"].toArray();
-    if (inbounds.isEmpty() || !inbounds.at(0).isObject()) {
-        return std::nullopt;
-    }
-
-    const QJsonObject firstInbound = inbounds.at(0).toObject();
-    if (!firstInbound.contains("port")) {
-        return std::nullopt;
-    }
-
-    return firstInbound.value("port").toInt();
-}
-
-QJsonValue proxyPortValue(const std::optional<int> &port)
-{
-    if (port.has_value()) {
-        return QJsonValue(*port);
-    }
-    return QJsonValue::Null;
-}
-
-QHttpServerResponse makeServiceUnavailablePingResponse()
-{
-    QJsonObject payload{
-        {"status", "error"},
-        {"proxyPort", QJsonValue::Null}
-    };
-    return QHttpServerResponse(payload, QHttpServerResponse::StatusCode::ServiceUnavailable);
-}
-
-QHttpServerResponse makeServiceUnavailableStatusResponse()
-{
-    QJsonObject payload{
-        {"status", "error"}
-    };
-    return QHttpServerResponse(payload, QHttpServerResponse::StatusCode::ServiceUnavailable);
-}
-
-} // namespace
-
-HttpApi::HttpApi(QWeakPointer<IProxyService> service, QObject* parent)
-    : QObject(parent)
-    , m_tcpServer(new QTcpServer(this))
-    , m_service(service)
-{
-    ProxyLogger::getInstance().debug("HttpApi initialized");
-}
-
-HttpApi::~HttpApi()
-{
-    stop();
-}
-
-bool HttpApi::start(quint16 port)
-{
-    ProxyLogger::getInstance().info(QString("Starting HTTP API server on port %1").arg(port));
-    
-    if (!m_tcpServer->listen(QHostAddress::LocalHost, port)) {
-        ProxyLogger::getInstance().error(QString("Failed to start HTTP API server on port %1").arg(port));
-        return false;
-    }
-
-    setupRoutes();
-    m_server.bind(m_tcpServer.data());
-    
-    ProxyLogger::getInstance().info(QString("HTTP API server is running on localhost:%1").arg(m_tcpServer->serverPort()));
-    ProxyLogger::getInstance().debug("Available endpoints:\n"
-                              "  POST   /api/v1/up\n"
-                              "  POST   /api/v1/down\n"
-                              "  GET    /api/v1/ping");
-    return true;
-}
-
-void HttpApi::stop()
-{
-    ProxyLogger::getInstance().info("Stopping HTTP API server");
-    if (m_tcpServer) {
-        m_tcpServer->close();
-    }
-}
-
-void HttpApi::setupRoutes()
-{
-    ProxyLogger::getInstance().debug("Setting up HTTP API routes");
-
-    m_server.route("/api/v1/up", QHttpServerRequest::Method::Post,
-        [this] {
-            ProxyLogger::getInstance().debug("Handling POST /api/v1/up request");
-            return handlePostUp();
-        });
-
-    m_server.route("/api/v1/down", QHttpServerRequest::Method::Post,
-        [this] {
-            ProxyLogger::getInstance().debug("Handling POST /api/v1/down request");
-            return handlePostDown();
-        });
-
-    m_server.route("/api/v1/ping", QHttpServerRequest::Method::Get,
-        [this] {
-            ProxyLogger::getInstance().debug("Handling GET /api/v1/ping request");
-            return handleGetPing();
-        });
-}
-
-QHttpServerResponse HttpApi::handlePostUp()
-{
-    if (auto service = m_service.lock()) {
-        const bool started = service->startXray();
-        QJsonObject response;
-        response["status"] = started ? "ok" : "error";
-
-        const auto port = started ? extractInboundPort(service->getConfig()) : std::optional<int>{};
-        response["proxyPort"] = proxyPortValue(port);
-
-        if (started) {
-            if (port.has_value()) {
-                ProxyLogger::getInstance().info(QString("Xray process started on port %1").arg(*port));
-            } else {
-                ProxyLogger::getInstance().warning("Xray started but inbound port is unknown (local proxy owner may be missing)");
-            }
-        } else {
-            ProxyLogger::getInstance().warning("Failed to start Xray process via HTTP API");
-        }
-
-        return QHttpServerResponse(response);
-    }
-
-    ProxyLogger::getInstance().error("Service unavailable: proxy backend is not initialized");
-    return makeServiceUnavailablePingResponse();
-}
-
-QHttpServerResponse HttpApi::handlePostDown()
-{
-    if (auto service = m_service.lock()) {
-        const bool stopped = service->stopXray();
-        QJsonObject response;
-        response["status"] = stopped ? "ok" : "error";
-        if (!stopped) {
-            ProxyLogger::getInstance().warning("Failed to stop Xray process via HTTP API");
-        } else {
-            ProxyLogger::getInstance().info("Xray process stopped via HTTP API");
-        }
-
-        return QHttpServerResponse(response);
-    }
-
-    ProxyLogger::getInstance().error("Service unavailable: proxy backend is not initialized");
-    return makeServiceUnavailableStatusResponse();
-}
-
-QHttpServerResponse HttpApi::handleGetPing() const
-{
-    if (auto service = m_service.lock()) {
-        QJsonObject response;
-        response["status"] = "ok";
-        const bool isRunning = service->isXrayRunning();
-        if (isRunning) {
-            const auto port = extractInboundPort(service->getConfig());
-            response["proxyPort"] = proxyPortValue(port);
-            if (port.has_value()) {
-                ProxyLogger::getInstance().debug(QString("Xray port: %1").arg(*port));
-            } else {
-                ProxyLogger::getInstance().warning("Unable to detect inbound port while Xray is running");
-            }
-        } else {
-            response["proxyPort"] = QJsonValue::Null;
-            ProxyLogger::getInstance().debug("Xray is not running");
-        }
-
-        return QHttpServerResponse(response);
-    }
-
-    ProxyLogger::getInstance().error("Service unavailable: proxy backend is not initialized");
-    return makeServiceUnavailablePingResponse();
-}

client/core/local-proxy/httpapi.h

@@ -1,32 +0,0 @@
-#pragma once
-
-#include <QObject>
-#include <QScopedPointer>
-#include <QHttpServer>
-#include <QHttpServerRequest>
-#include <QHttpServerResponse>
-#include <QTcpServer>
-#include <QWeakPointer>
-#include "iproxyservice.h"
-
-class HttpApi : public QObject {
-    Q_OBJECT
-
-public:
-    explicit HttpApi(QWeakPointer<IProxyService> service, QObject* parent = nullptr);
-    ~HttpApi();
-
-    bool start(quint16 port);
-    void stop();
-
-private:
-    void setupRoutes();
-
-    QHttpServerResponse handlePostUp();
-    QHttpServerResponse handlePostDown();
-    QHttpServerResponse handleGetPing() const;
-
-    QHttpServer m_server;
-    QScopedPointer<QTcpServer> m_tcpServer;
-    QWeakPointer<IProxyService> m_service;
-}; 

client/core/local-proxy/iproxyservice.h

@@ -1,17 +0,0 @@
-#pragma once
-
-#include <QJsonObject>
-#include <QString>
-
-class IProxyService {
-public:
-    virtual ~IProxyService() = default;
-
-    virtual QJsonObject getConfig() = 0;
-
-    virtual bool startXray() = 0;
-    virtual bool stopXray() = 0;
-    virtual bool isXrayRunning() const = 0;
-    virtual qint64 getXrayProcessId() const = 0;
-    virtual QString getXrayError() const = 0;
-}; 

client/core/local-proxy/portavailabilityhelper.cpp

@@ -1,43 +0,0 @@
-#include "portavailabilityhelper.h"
-
-#include <QHostAddress>
-#include <QTcpServer>
-
-namespace {
-constexpr int kProxyPortMin = 1024;
-constexpr int kProxyPortMax = 65535;
-}
-
-bool PortAvailabilityHelper::isPortAvailable(int port)
-{
-    if (port < kProxyPortMin || port > kProxyPortMax) {
-        return false;
-    }
-
-    QTcpServer server;
-    const bool success = server.listen(QHostAddress::LocalHost, static_cast<quint16>(port));
-    server.close();
-    return success;
-}
-
-std::optional<int> PortAvailabilityHelper::findFirstAvailablePort(int startPort, int endPort)
-{
-    if (startPort < kProxyPortMin) {
-        startPort = kProxyPortMin;
-    }
-    if (endPort > kProxyPortMax) {
-        endPort = kProxyPortMax;
-    }
-    if (startPort > endPort) {
-        return std::nullopt;
-    }
-
-    for (int port = startPort; port <= endPort; ++port) {
-        if (isPortAvailable(port)) {
-            return port;
-        }
-    }
-
-    return std::nullopt;
-}
-

client/core/local-proxy/portavailabilityhelper.h

@@ -1,11 +0,0 @@
-#pragma once
-
-#include <optional>
-
-class PortAvailabilityHelper
-{
-public:
-    static bool isPortAvailable(int port);
-    static std::optional<int> findFirstAvailablePort(int startPort, int endPort);
-};
-

client/core/local-proxy/proxylogger.cpp

@@ -1,133 +0,0 @@
-#include "proxylogger.h"
-#include <QDir>
-#include <QTextStream>
-
-ProxyLogger::ProxyLogger() : m_maxFileSize(0), m_currentLevel(LogLevel::Info)
-{
-}
-
-ProxyLogger::~ProxyLogger()
-{
-}
-
-ProxyLogger& ProxyLogger::getInstance()
-{
-    static ProxyLogger instance;
-    return instance;
-}
-
-void ProxyLogger::init(const QString& logPath, qint64 maxFileSize)
-{
-    QMutexLocker locker(&m_mutex);
-    m_logPath = logPath;
-    m_maxFileSize = maxFileSize;
-    
-    // Create logs directory if it doesn't exist
-    QDir dir = QFileInfo(m_logPath).dir();
-    if (!dir.exists()) {
-        dir.mkpath(".");
-    }
-}
-
-void ProxyLogger::setLogLevel(LogLevel level)
-{
-    m_currentLevel = level;
-}
-
-void ProxyLogger::log(LogLevel level, const QString& message)
-{
-    logInternal(level, message);
-}
-
-void ProxyLogger::debug(const QString& message)
-{
-    logInternal(LogLevel::Debug, message);
-}
-
-void ProxyLogger::info(const QString& message)
-{
-    logInternal(LogLevel::Info, message);
-}
-
-void ProxyLogger::warning(const QString& message)
-{
-    logInternal(LogLevel::Warning, message);
-}
-
-void ProxyLogger::error(const QString& message)
-{
-    logInternal(LogLevel::Error, message);
-}
-
-void ProxyLogger::logInternal(LogLevel level, const QString& message)
-{
-    if (m_logPath.isEmpty()) {
-        return;
-    }
-    
-    if (level < m_currentLevel) {
-        return;
-    }
-
-    QMutexLocker locker(&m_mutex);
-    
-    checkRotation();
-
-    QFile file(m_logPath);
-    if (!openLogFile(file)) {
-        return;
-    }
-
-    QTextStream stream(&file);
-    QString timestamp = QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss.zzz");
-    stream << QString("[%1] [%2] %3\n").arg(timestamp, levelToString(level), message);
-    stream.flush();
-    file.close();
-}
-
-QString ProxyLogger::levelToString(LogLevel level)
-{
-    switch (level) {
-        case LogLevel::Debug:   return "DEBUG";
-        case LogLevel::Info:    return "INFO";
-        case LogLevel::Warning: return "WARNING";
-        case LogLevel::Error:   return "ERROR";
-        default:               return "UNKNOWN";
-    }
-}
-
-qint64 ProxyLogger::getCurrentFileSize() const
-{
-    QFile file(m_logPath);
-    if (file.exists()) {
-        return file.size();
-    }
-    return -1;
-}
-
-void ProxyLogger::checkRotation()
-{
-    if (m_maxFileSize > 0 && getCurrentFileSize() >= m_maxFileSize) {
-        // Delete the oldest file
-        QFile::remove(QString("%1.%2").arg(m_logPath).arg(MAX_BACKUP_FILES));
-
-        // Shift existing files
-        for (int i = MAX_BACKUP_FILES - 1; i >= 1; --i) {
-            QString oldName = QString("%1.%2").arg(m_logPath).arg(i);
-            QString newName = QString("%1.%2").arg(m_logPath).arg(i + 1);
-            QFile::rename(oldName, newName);
-        }
-
-        // Rename current file
-        QFile::rename(m_logPath, m_logPath + ".1");
-    }
-}
-
-bool ProxyLogger::openLogFile(QFile& file)
-{
-    if (!file.open(QIODevice::WriteOnly | QIODevice::Append | QIODevice::Text)) {
-        qDebug() << "Failed to open log file:" << m_logPath;
-        return false;
-    }
-    return true;
-} 

client/core/local-proxy/proxylogger.h

@@ -1,54 +0,0 @@
-#ifndef LOCAL_PROXY_LOGGER_H
-#define LOCAL_PROXY_LOGGER_H
-
-#include <QObject>
-#include <QFile>
-#include <QDateTime>
-#include <QMutex>
-#include <QString>
-
-class ProxyLogger
-{
-
-public:
-    enum class LogLevel {
-        Debug,
-        Info,
-        Warning,
-        Error
-    };
-
-    static ProxyLogger& getInstance();
-
-    void init(const QString& logPath, qint64 maxFileSize = 1024 * 1024 * 10); // 10MB by default
-    void setLogLevel(LogLevel level);
-
-    // Main logging method
-    void log(LogLevel level, const QString& message);
-
-    // Helper methods for convenience
-    void debug(const QString& message);
-    void info(const QString& message);
-    void warning(const QString& message);
-    void error(const QString& message);
-
-private:
-    ProxyLogger();
-    ~ProxyLogger();
-    ProxyLogger(const ProxyLogger&) = delete;
-    ProxyLogger& operator=(const ProxyLogger&) = delete;
-
-    void logInternal(LogLevel level, const QString& message);
-    void checkRotation();
-    QString levelToString(LogLevel level);
-    bool openLogFile(QFile& file);
-    qint64 getCurrentFileSize() const;
-
-    QString m_logPath;
-    qint64 m_maxFileSize;
-    LogLevel m_currentLevel;
-    QMutex m_mutex;
-    static const int MAX_BACKUP_FILES = 3;
-};
-
-#endif // LOCAL_PROXY_LOGGER_H 

client/core/local-proxy/proxyserver.cpp

@@ -1,114 +0,0 @@
-#include "proxyserver.h"
-
-#include "core/repositories/secureAppSettingsRepository.h"
-#include "core/repositories/secureServersRepository.h"
-
-#include <QDebug>
-
-ProxyServer::ProxyServer(SecureServersRepository *serversRepository, SecureAppSettingsRepository *appSettingsRepository,
-                         QObject *parent)
-    : QObject(parent)
-    , m_appSettingsRepository(appSettingsRepository)
-    , m_service(new ProxyService(serversRepository, appSettingsRepository, this))
-{
-    m_lastRestartToken = m_appSettingsRepository ? m_appSettingsRepository->localProxyRestartToken() : 0;
-}
-
-ProxyServer::~ProxyServer()
-{
-    stop();
-}
-
-bool ProxyServer::start(quint16 port)
-{
-    if (m_isRunning) {
-        if (m_currentApiPort == port) {
-            qInfo() << "Local proxy: already running on port" << port;
-            return true;
-        }
-
-        qInfo() << "Local proxy: restarting on new port" << port;
-        stop();
-    }
-
-    m_api.reset(new HttpApi(m_service.toWeakRef()));
-    const bool apiStarted = m_api->start(port);
-    if (!apiStarted) {
-        qWarning() << "Local proxy: port is busy:" << port;
-        m_api.reset();
-        m_isRunning = false;
-        m_currentApiPort = 0;
-        return false;
-    }
-
-    m_isRunning = true;
-    m_currentApiPort = port;
-
-    return true;
-}
-
-void ProxyServer::stop()
-{
-    stopXrayProcess();
-    if (m_api) {
-        m_api->stop();
-        m_api.reset();
-    }
-    m_isRunning = false;
-    m_currentApiPort = 0;
-    m_currentProxyPort = 0;
-}
-
-bool ProxyServer::startXrayProcess()
-{
-    return m_service->startXray();
-}
-
-void ProxyServer::stopXrayProcess()
-{
-    m_service->stopXray();
-}
-
-bool ProxyServer::syncSettings()
-{
-    if (!m_isRunning) {
-        qDebug() << "Local proxy: syncSettings called but server is not running";
-        return false;
-    }
-
-    const quint16 newProxyPort = m_appSettingsRepository ? m_appSettingsRepository->localProxyPort() : 0;
-    const int restartToken = m_appSettingsRepository ? m_appSettingsRepository->localProxyRestartToken() : 0;
-    const bool xrayRunning = m_service->isXrayRunning();
-
-    if (!xrayRunning) {
-        qInfo() << "Local proxy: starting Xray on port" << newProxyPort;
-        const bool started = startXrayProcess();
-        if (started) {
-            m_currentProxyPort = newProxyPort;
-            m_lastRestartToken = restartToken;
-        }
-        return started;
-    }
-
-    if (m_lastRestartToken != restartToken) {
-        qInfo() << "Local proxy: restarting Xray due to config change token";
-        const bool restarted = m_service->restartXray();
-        if (restarted) {
-            m_currentProxyPort = newProxyPort;
-            m_lastRestartToken = restartToken;
-        }
-        return restarted;
-    }
-
-    if (m_currentProxyPort != newProxyPort) {
-        qInfo() << "Local proxy: proxy port changed from" << m_currentProxyPort << "to" << newProxyPort;
-        const bool restarted = m_service->restartXray();
-        if (restarted) {
-            m_currentProxyPort = newProxyPort;
-            m_lastRestartToken = restartToken;
-        }
-        return restarted;
-    }
-
-    return true;
-}

client/core/local-proxy/proxyserver.h

@@ -1,37 +0,0 @@
-#pragma once
-
-#include <QObject>
-#include <QScopedPointer>
-#include <QSharedPointer>
-
-#include "httpapi.h"
-#include "proxyservice.h"
-
-class SecureServersRepository;
-class SecureAppSettingsRepository;
-
-class ProxyServer : public QObject
-{
-    Q_OBJECT
-
-public:
-    ProxyServer(SecureServersRepository *serversRepository, SecureAppSettingsRepository *appSettingsRepository,
-                QObject *parent = nullptr);
-    ~ProxyServer();
-
-    bool start(quint16 port = 49490);
-    void stop();
-    bool syncSettings();
-
-private:
-    bool startXrayProcess();
-    void stopXrayProcess();
-
-    SecureAppSettingsRepository *m_appSettingsRepository;
-    QScopedPointer<HttpApi> m_api;
-    QSharedPointer<ProxyService> m_service;
-    bool m_isRunning {false};
-    quint16 m_currentApiPort {0};
-    quint16 m_currentProxyPort {0};
-    int m_lastRestartToken {0};
-};

client/core/local-proxy/proxyservice.cpp

@@ -1,118 +0,0 @@
-#include "proxyservice.h"
-
-#include "proxylogger.h"
-
-namespace {
-
-void logConfigError(const QString &errorMessage)
-{
-    if (!errorMessage.isEmpty()) {
-        ProxyLogger::getInstance().error(errorMessage);
-    }
-}
-
-} // namespace
-
-ProxyService::ProxyService(SecureServersRepository *serversRepository, SecureAppSettingsRepository *appSettingsRepository,
-                           QObject *parent)
-    : QObject(parent)
-    , m_configManager(new ConfigManager(serversRepository, appSettingsRepository))
-    , m_xrayController(new XrayController())
-{
-    ProxyLogger::getInstance().debug("ProxyService initialized");
-}
-
-QJsonObject ProxyService::getConfig()
-{
-    if (!m_cachedConfig.isEmpty()) {
-        return m_cachedConfig;
-    }
-
-    QString error;
-    const auto configData = m_configManager->buildConfigWithFetch(error);
-    if (!configData) {
-        logConfigError(error);
-        return {};
-    }
-
-    m_cachedConfig = configData->parsedConfig;
-    return m_cachedConfig;
-}
-
-bool ProxyService::startXray()
-{
-    ProxyLogger::getInstance().info("Starting Xray");
-
-    if (m_xrayController->isXrayRunning()) {
-        ProxyLogger::getInstance().info("Xray is already running");
-        return true;
-    }
-
-    QString error;
-    const auto configData = m_configManager->buildConfigWithFetch(error);
-    if (!configData) {
-        logConfigError(error);
-        return false;
-    }
-
-    const bool success = m_xrayController->start(configData->serializedConfig);
-    if (success) {
-        m_cachedConfig = configData->parsedConfig;
-        ProxyLogger::getInstance().info("Xray started successfully");
-        emit xrayStatusChanged(true);
-        return true;
-    }
-
-    ProxyLogger::getInstance().error(QStringLiteral("Failed to start Xray: %1").arg(m_xrayController->getError()));
-    return false;
-}
-
-bool ProxyService::stopXray()
-{
-    ProxyLogger::getInstance().info("Stopping Xray");
-    const bool stopped = m_xrayController->stop();
-    if (stopped) {
-        ProxyLogger::getInstance().info("Xray stopped");
-        emit xrayStatusChanged(false);
-        return true;
-    }
-
-    ProxyLogger::getInstance().warning(QStringLiteral("Failed to stop Xray: %1").arg(m_xrayController->getError()));
-    return false;
-}
-
-bool ProxyService::isXrayRunning() const
-{
-    return m_xrayController->isXrayRunning();
-}
-
-qint64 ProxyService::getXrayProcessId() const
-{
-    return m_xrayController->getProcessId();
-}
-
-QString ProxyService::getXrayError() const
-{
-    return m_xrayController->getError();
-}
-
-void ProxyService::clearCache()
-{
-    m_cachedConfig = QJsonObject();
-    ProxyLogger::getInstance().debug("ProxyService cache cleared");
-}
-
-bool ProxyService::restartXray()
-{
-    ProxyLogger::getInstance().info("Restarting Xray with updated config");
-    clearCache();
-
-    if (m_xrayController->isXrayRunning()) {
-        if (!stopXray()) {
-            ProxyLogger::getInstance().error("Failed to stop Xray during restart, aborting");
-            return false;
-        }
-    }
-
-    return startXray();
-}

client/core/local-proxy/proxyservice.h

@@ -1,39 +0,0 @@
-#pragma once
-
-#include "configmanager.h"
-#include "iproxyservice.h"
-#include "xraycontroller.h"
-
-#include <QObject>
-#include <QScopedPointer>
-#include <QJsonObject>
-
-class SecureServersRepository;
-class SecureAppSettingsRepository;
-
-class ProxyService : public QObject, public IProxyService {
-    Q_OBJECT
-
-public:
-    ProxyService(SecureServersRepository *serversRepository, SecureAppSettingsRepository *appSettingsRepository,
-                 QObject *parent = nullptr);
-    ~ProxyService() = default;
-
-    QJsonObject getConfig() override;
-    bool startXray() override;
-    bool stopXray() override;
-    bool isXrayRunning() const override;
-    qint64 getXrayProcessId() const override;
-    QString getXrayError() const override;
-
-    void clearCache();
-    bool restartXray();
-
-signals:
-    void xrayStatusChanged(bool running);
-
-private:
-    QScopedPointer<ConfigManager> m_configManager;
-    QScopedPointer<XrayController> m_xrayController;
-    QJsonObject m_cachedConfig;
-}; 

client/core/local-proxy/xraycontroller.cpp

@@ -1,105 +0,0 @@
-#include "xraycontroller.h"
-
-#include "proxylogger.h"
-#include "core/utils/ipcClient.h"
-
-namespace {
-const QString kIpcUnavailableError = QStringLiteral("Failed to communicate with IPC service");
-}
-
-XrayController::XrayController(QObject *parent)
-    : QObject(parent)
-{
-    ProxyLogger::getInstance().debug("XrayController initialized");
-}
-
-XrayController::~XrayController()
-{
-    stop();
-}
-
-bool XrayController::start(const QString &configJson)
-{
-    if (m_isRunning) {
-        ProxyLogger::getInstance().info("Xray is already running");
-        return true;
-    }
-
-    ProxyLogger::getInstance().info("Request to start Xray via IPC");
-
-    m_lastError.clear();
-
-    if (configJson.trimmed().isEmpty()) {
-        m_lastError = QStringLiteral("Config content is empty");
-        ProxyLogger::getInstance().error(m_lastError);
-        return false;
-    }
-
-    const bool ipcResult = IpcClient::withInterface([&](QSharedPointer<IpcInterfaceReplica> iface) {
-        auto xrayStart = iface->xrayStart(configJson);
-        if (!xrayStart.waitForFinished() || !xrayStart.returnValue()) {
-            ProxyLogger::getInstance().warning("Failed to start Xray via IPC");
-            return false;
-        }
-
-        return true;
-    }, []() {
-        return false;
-    });
-
-    if (!ipcResult) {
-        m_lastError = kIpcUnavailableError;
-        ProxyLogger::getInstance().error(m_lastError);
-        return false;
-    }
-
-    ProxyLogger::getInstance().info("Xray start command sent to IPC service");
-    m_isRunning = true;
-    return true;
-}
-
-bool XrayController::stop()
-{
-    if (!m_isRunning) {
-        ProxyLogger::getInstance().debug("Skipping Xray stop via IPC: local proxy Xray is not running");
-        return true;
-    }
-
-    ProxyLogger::getInstance().info("Stopping Xray via IPC");
-
-    const bool ipcResult = IpcClient::withInterface([](QSharedPointer<IpcInterfaceReplica> iface) {
-        auto xrayStop = iface->xrayStop();
-        if (!xrayStop.waitForFinished() || !xrayStop.returnValue()) {
-            ProxyLogger::getInstance().warning("Failed to stop Xray via IPC");
-            return false;
-        }
-
-        return true;
-    }, []() {
-        return false;
-    });
-
-    if (!ipcResult) {
-        m_lastError = kIpcUnavailableError;
-        ProxyLogger::getInstance().warning(m_lastError);
-        return false;
-    }
-
-    m_isRunning = false;
-    return true;
-}
-
-bool XrayController::isXrayRunning() const
-{
-    return m_isRunning;
-}
-
-qint64 XrayController::getProcessId() const
-{
-    return -1;
-}
-
-QString XrayController::getError() const
-{
-    return m_lastError;
-}

client/core/local-proxy/xraycontroller.h

@@ -1,22 +0,0 @@
-#pragma once
-
-#include <QObject>
-#include <QString>
-
-class XrayController : public QObject {
-    Q_OBJECT
-
-public:
-    explicit XrayController(QObject* parent = nullptr);
-    ~XrayController();
-
-    bool start(const QString& configJson);
-    bool stop();
-    bool isXrayRunning() const;
-    qint64 getProcessId() const;
-    QString getError() const;
-
-private:
-    bool m_isRunning {false};
-    QString m_lastError;
-}; 

client/core/models/protocols/xrayProtocolConfig.cpp

@@ -32,7 +32,7 @@ XrayXPaddingConfig XrayXPaddingConfig::fromJson(const QJsonObject &json)
     c.bytesMin  = json.value(configKey::xPaddingBytesMin).toString();
     c.bytesMax  = json.value(configKey::xPaddingBytesMax).toString();
     c.obfsMode  = json.value(configKey::xPaddingObfsMode).toBool(true);
-    c.key       = json.value(configKey::xPaddingKey).toString(protocols::xray::defaultSite);
+    c.key       = json.value(configKey::xPaddingKey).toString();
     c.header    = json.value(configKey::xPaddingHeader).toString();
     c.placement = json.value(configKey::xPaddingPlacement).toString(protocols::xray::defaultXPaddingPlacement);
     c.method    = json.value(configKey::xPaddingMethod).toString(protocols::xray::defaultXPaddingMethod);
@@ -365,6 +365,8 @@ XrayServerConfig XrayServerConfig::fromJson(const QJsonObject &json)
 bool XrayServerConfig::hasEqualServerSettings(const XrayServerConfig &other) const
 {
     return port == other.port
+           && transportProto == other.transportProto
+           && subnetAddress == other.subnetAddress
            && site == other.site
            && security == other.security
            && flow == other.flow
@@ -466,6 +468,17 @@ XrayProtocolConfig XrayProtocolConfig::fromJson(const QJsonObject &json)
                         }
                     }
                 }
+                const QJsonArray outbounds = parsed.value(protocols::xray::outbounds).toArray();
+                if (!outbounds.isEmpty()) {
+                    const QJsonObject settings = outbounds[0].toObject().value(protocols::xray::settings).toObject();
+                    const QJsonArray vnext = settings.value(protocols::xray::vnext).toArray();
+                    if (!vnext.isEmpty()) {
+                        const QJsonArray users = vnext[0].toObject().value(protocols::xray::users).toArray();
+                        if (!users.isEmpty()) {
+                            clientCfg.id = users[0].toObject().value(protocols::xray::id).toString();
+                        }
+                    }
+                }
                 c.clientConfig = clientCfg;
             } else {
                 c.clientConfig = XrayClientConfig::fromJson(parsed);

client/core/models/selfhosted/nativeServerConfig.cpp

@@ -29,6 +29,11 @@ ContainerConfig NativeServerConfig::containerConfig(DockerContainer container) c
     return containers.value(container);
 }
 
+void NativeServerConfig::updateContainerConfig(DockerContainer container, const ContainerConfig &config)
+{
+    containers[container] = config;
+}
+
 QPair<QString, QString> NativeServerConfig::getDnsPair(const QString &primaryDns, const QString &secondaryDns) const
 {
     QString d1 = dns1;

client/core/models/selfhosted/nativeServerConfig.h

@@ -27,6 +27,8 @@ struct NativeServerConfig {
     bool hasContainers() const;
     ContainerConfig containerConfig(DockerContainer container) const;
 
+    void updateContainerConfig(DockerContainer container, const ContainerConfig &config);
+
     QPair<QString, QString> getDnsPair(const QString &primaryDns, const QString &secondaryDns) const;
 
     QJsonObject toJson() const;

client/core/models/selfhosted/selfHostedUserServerConfig.cpp

@@ -43,6 +43,11 @@ ContainerConfig SelfHostedUserServerConfig::containerConfig(DockerContainer cont
     return containers.value(container);
 }
 
+void SelfHostedUserServerConfig::updateContainerConfig(DockerContainer container, const ContainerConfig &config)
+{
+    containers[container] = config;
+}
+
 QPair<QString, QString> SelfHostedUserServerConfig::getDnsPair(const QString &primaryDns,
                                                                const QString &secondaryDns) const
 {

client/core/models/selfhosted/selfHostedUserServerConfig.h

@@ -32,6 +32,8 @@ struct SelfHostedUserServerConfig {
     bool hasContainers() const;
     ContainerConfig containerConfig(DockerContainer container) const;
 
+    void updateContainerConfig(DockerContainer container, const ContainerConfig &config);
+
     QPair<QString, QString> getDnsPair(const QString &primaryDns, const QString &secondaryDns) const;
 
     QJsonObject toJson() const;

client/core/protocols/openVpnProtocol.cpp

@@ -39,33 +39,44 @@ QString OpenVpnProtocol::defaultConfigPath()
     return p;
 }
 
-void OpenVpnProtocol::stop()
+void OpenVpnProtocol::cleanupResources()
 {
-    qDebug() << "OpenVpnProtocol::stop()";
-    setConnectionState(Vpn::ConnectionState::Disconnecting);
-
-    // TODO: need refactoring
-    // sendTermSignal() will even return true while server connected ???
-    if ((m_connectionState == Vpn::ConnectionState::Preparing) || (m_connectionState == Vpn::ConnectionState::Connecting)
-        || (m_connectionState == Vpn::ConnectionState::Connected)
-        || (m_connectionState == Vpn::ConnectionState::Reconnecting)) {
+    if (m_openVpnProcess || openVpnProcessIsRunning()) {
         if (!sendTermSignal()) {
             killOpenVpnProcess();
         }
         QThread::msleep(10);
-        m_managementServer.stop();
     }
+    m_managementServer.stop();
 
 #if defined(Q_OS_WIN) || defined(Q_OS_LINUX) || defined(Q_OS_MACOS)
     IpcClient::withInterface([](QSharedPointer<IpcInterfaceReplica> iface) {
         QRemoteObjectPendingReply<bool> reply = iface->disableKillSwitch();
         if (!reply.waitForFinished(1000) && !reply.returnValue()) {
-            qWarning() << "OpenVpnProtocol::stop(): Failed to disable killswitch";
+            qWarning() << "OpenVpnProtocol::cleanupResources(): Failed to disable killswitch";
         }
     });
 #endif
+}
 
-    setConnectionState(Vpn::ConnectionState::Disconnected);
+void OpenVpnProtocol::stop()
+{
+    qDebug() << "OpenVpnProtocol::stop()";
+
+    const bool wasActive = m_connectionState == Vpn::ConnectionState::Preparing
+            || m_connectionState == Vpn::ConnectionState::Connecting
+            || m_connectionState == Vpn::ConnectionState::Connected
+            || m_connectionState == Vpn::ConnectionState::Reconnecting;
+
+    if (wasActive) {
+        setConnectionState(Vpn::ConnectionState::Disconnecting);
+    }
+
+    cleanupResources();
+
+    if (wasActive || m_connectionState == Vpn::ConnectionState::Disconnecting) {
+        setConnectionState(Vpn::ConnectionState::Disconnected);
+    }
 }
 
 ErrorCode OpenVpnProtocol::prepare()
@@ -168,7 +179,7 @@ void OpenVpnProtocol::updateRouteGateway(QString line)
 
 ErrorCode OpenVpnProtocol::start()
 {
-    OpenVpnProtocol::stop();
+    cleanupResources();
 
     if (!QFileInfo::exists(configPath())) {
         setLastError(ErrorCode::OpenVpnConfigMissing);

client/core/protocols/openVpnProtocol.h

@@ -29,6 +29,7 @@ protected slots:
     void onReadyReadDataFromManagementServer();
 
 private:
+    void cleanupResources();
     QString configPath() const;
     bool openVpnProcessIsRunning() const;
     bool sendTermSignal();

client/core/repositories/secureAppSettingsRepository.cpp

@@ -5,8 +5,6 @@
 #include <QJsonObject>
 #include <QUuid>
 
-#include <limits>
-
 #include "core/utils/errorCodes.h"
 #include "core/utils/routeModes.h"
 #include "core/utils/commonStructs.h"
@@ -442,59 +440,3 @@ void SecureAppSettingsRepository::setXraySavedConfigs(const QByteArray &data)
 {
     setValue("Xray/savedConfigs", data);
 }
-
-QString SecureAppSettingsRepository::localProxyOwnerId() const
-{
-    return value("Conf/localProxyOwnerId", "").toString();
-}
-
-void SecureAppSettingsRepository::setLocalProxyOwnerId(const QString &serverId)
-{
-    setValue("Conf/localProxyOwnerId", serverId);
-    emit localProxySettingsChanged();
-}
-
-quint16 SecureAppSettingsRepository::localProxyPort() const
-{
-    return static_cast<quint16>(value("Conf/localProxyPort", 10808).toUInt());
-}
-
-void SecureAppSettingsRepository::setLocalProxyPort(quint16 port)
-{
-    setValue("Conf/localProxyPort", port);
-    emit localProxySettingsChanged();
-}
-
-bool SecureAppSettingsRepository::isLocalProxyPortUserDefined() const
-{
-    return value("Conf/localProxyPortUserDefined", false).toBool();
-}
-
-void SecureAppSettingsRepository::setLocalProxyPortUserDefined(bool userDefined)
-{
-    setValue("Conf/localProxyPortUserDefined", userDefined);
-}
-
-bool SecureAppSettingsRepository::isLocalProxyHttpEnabled() const
-{
-    return value("Conf/localProxyHttpEnabled", false).toBool();
-}
-
-void SecureAppSettingsRepository::setLocalProxyHttpEnabled(bool enabled)
-{
-    setValue("Conf/localProxyHttpEnabled", enabled);
-    emit localProxySettingsChanged();
-}
-
-int SecureAppSettingsRepository::localProxyRestartToken() const
-{
-    return value("Conf/localProxyRestartToken", 0).toInt();
-}
-
-void SecureAppSettingsRepository::bumpLocalProxyRestartToken()
-{
-    const int current = localProxyRestartToken();
-    const int next = (current == std::numeric_limits<int>::max()) ? 0 : (current + 1);
-    setValue("Conf/localProxyRestartToken", next);
-    emit localProxySettingsChanged();
-}

client/core/repositories/secureAppSettingsRepository.h

@@ -93,18 +93,6 @@ public:
     QByteArray xraySavedConfigs() const;
     void setXraySavedConfigs(const QByteArray &data);
 
-    // Local proxy
-    QString localProxyOwnerId() const;
-    void setLocalProxyOwnerId(const QString &serverId);
-    quint16 localProxyPort() const;
-    void setLocalProxyPort(quint16 port);
-    bool isLocalProxyPortUserDefined() const;
-    void setLocalProxyPortUserDefined(bool userDefined);
-    bool isLocalProxyHttpEnabled() const;
-    void setLocalProxyHttpEnabled(bool enabled);
-    int localProxyRestartToken() const;
-    void bumpLocalProxyRestartToken();
-
 signals:
     void appLanguageChanged(QLocale locale);
     void allowedDnsServersChanged(const QStringList &servers);
@@ -118,8 +106,6 @@ signals:
     void saveLogsChanged(bool enabled);
     void screenshotsEnabledChanged(bool enabled);
     void settingsCleared();
-    void localProxySettingsChanged();
-    void localProxyStartFailed(const QString &message);
 
 private:
     void setVpnSites(RouteMode mode, const QVariantMap &sites);

client/core/repositories/secureServersRepository.cpp

@@ -208,8 +208,8 @@ QString SecureServersRepository::nextAvailableServerName() const
     int i = 0;
     QString candidate;
     do {
-        i++;
-        candidate = QStringLiteral("Server %1").arg(i);
+        ++i;
+        candidate = tr("Server") + QLatin1Char(' ') + QString::number(i);
     } while (usedNames.contains(candidate));
 
     return candidate;
@@ -309,15 +309,6 @@ serverConfigUtils::ConfigType SecureServersRepository::serverKind(const QString
     return serverConfigUtils::configTypeFromJson(withoutStorageServerId(it.value()));
 }
 
-std::optional<QJsonObject> SecureServersRepository::serverJsonById(const QString &serverId) const
-{
-    const auto it = m_serverJsonById.constFind(serverId);
-    if (it == m_serverJsonById.constEnd()) {
-        return std::nullopt;
-    }
-    return it.value();
-}
-
 std::optional<SelfHostedAdminServerConfig> SecureServersRepository::selfHostedAdminConfig(const QString &serverId) const
 {
     const auto it = m_serverJsonById.constFind(serverId);

client/core/repositories/secureServersRepository.h

@@ -31,8 +31,6 @@ public:
     void removeServer(const QString &serverId);
     serverConfigUtils::ConfigType serverKind(const QString &serverId) const;
 
-    std::optional<QJsonObject> serverJsonById(const QString &serverId) const;
-
     std::optional<SelfHostedAdminServerConfig> selfHostedAdminConfig(const QString &serverId) const;
     std::optional<SelfHostedUserServerConfig> selfHostedUserConfig(const QString &serverId) const;
     std::optional<NativeServerConfig> nativeConfig(const QString &serverId) const;

client/core/utils/containerEnum.h

@@ -15,6 +15,8 @@ namespace amnezia
             Awg2,
             WireGuard,
             OpenVpn,
+            Cloak,
+            ShadowSocks,
             Ipsec,
             Xray,
             SSXray,

client/core/utils/containers/containerUtils.cpp

@@ -21,6 +21,8 @@ QString ContainerUtils::containerToString(DockerContainer c)
 {
     if (c == DockerContainer::None)
         return "none";
+    if (c == DockerContainer::Cloak)
+        return "amnezia-openvpn-cloak";
     if (c == DockerContainer::Awg)
         return "amnezia-awg";
     if (c == DockerContainer::Awg2)
@@ -62,6 +64,8 @@ QMap<DockerContainer, QString> ContainerUtils::containerHumanNames()
 {
     return { { DockerContainer::None, "Not installed" },
              { DockerContainer::OpenVpn, "OpenVPN" },
+             { DockerContainer::ShadowSocks, "OpenVPN over SS" },
+             { DockerContainer::Cloak, "OpenVPN over Cloak" },
              { DockerContainer::WireGuard, "WireGuard" },
              { DockerContainer::Awg, "AmneziaWG" },
              { DockerContainer::Awg2, "AmneziaWG" },
@@ -83,6 +87,10 @@ QMap<DockerContainer, QString> ContainerUtils::containerDescriptions()
     return {              { DockerContainer::OpenVpn,
                QObject::tr("OpenVPN is the most popular VPN protocol, with flexible configuration options. It uses its "
                            "own security protocol with SSL/TLS for key exchange.") },
+             { DockerContainer::ShadowSocks,
+               QObject::tr("This protocol is no longer supported.") },
+             { DockerContainer::Cloak,
+               QObject::tr("This protocol is no longer supported.") },
              { DockerContainer::WireGuard,
                QObject::tr("WireGuard - popular VPN protocol with high performance, high speed and low power "
                            "consumption.") },
@@ -194,6 +202,9 @@ QMap<DockerContainer, QString> ContainerUtils::containerDetailedDescriptions()
 
 ServiceType ContainerUtils::containerService(DockerContainer c)
 {
+    if (isUnsupportedContainer(c)) {
+        return ServiceType::Vpn;
+    }
     return ProtocolUtils::protocolService(defaultProtocol(c));
 }
 
@@ -202,6 +213,8 @@ Proto ContainerUtils::defaultProtocol(DockerContainer c)
     switch (c) {
     case DockerContainer::None: return Proto::Unknown;
     case DockerContainer::OpenVpn: return Proto::OpenVpn;
+    case DockerContainer::Cloak:
+    case DockerContainer::ShadowSocks: return Proto::Unknown;
     case DockerContainer::WireGuard: return Proto::WireGuard;
     case DockerContainer::Awg2: return Proto::Awg;
     case DockerContainer::Awg: return Proto::Awg;
@@ -252,6 +265,8 @@ bool ContainerUtils::isSupportedByCurrentPlatform(DockerContainer c)
     // macOS build using Network Extension – allow OpenVPN for parity with iOS.
     switch (c) {
     case DockerContainer::OpenVpn: return true;
+    case DockerContainer::Cloak: return false;
+    case DockerContainer::ShadowSocks: return false;
     case DockerContainer::WireGuard: return true;
     case DockerContainer::Awg2: return true;
     case DockerContainer::Awg: return true;
@@ -336,6 +351,10 @@ int ContainerUtils::easySetupOrder(DockerContainer container)
 
 bool ContainerUtils::isShareable(DockerContainer container)
 {
+    if (isUnsupportedContainer(container)) {
+        return false;
+    }
+
     switch (container) {
     case DockerContainer::TorWebSite: return false;
     case DockerContainer::Dns: return false;
@@ -352,6 +371,11 @@ bool ContainerUtils::isAwgContainer(DockerContainer container)
     return container == DockerContainer::Awg || container == DockerContainer::Awg2;
 }
 
+bool ContainerUtils::isUnsupportedContainer(DockerContainer container)
+{
+    return container == DockerContainer::Cloak || container == DockerContainer::ShadowSocks;
+}
+
 QJsonObject ContainerUtils::getProtocolConfigFromContainer(const Proto protocol, const QJsonObject &containerConfig)
 {
     QString protocolConfigString = containerConfig.value(ProtocolUtils::protoToString(protocol))

client/core/utils/containers/containerUtils.h

@@ -45,6 +45,8 @@ namespace amnezia
 
         bool isAwgContainer(DockerContainer container);
 
+        bool isUnsupportedContainer(DockerContainer container);
+
         QJsonObject getProtocolConfigFromContainer(const Proto protocol, const QJsonObject &containerConfig);
 
         int installPageOrder(DockerContainer container);

client/core/utils/errorCodes.h

@@ -38,6 +38,8 @@ namespace amnezia
         XrayServerConfigInvalid = 215,
         XrayServerNoVlessClients = 216,
         XrayRealityKeysReadFailed = 217,
+        ServerContainerRuntimeNotSupported = 218,
+        ContainerRuntimeServiceNotRunning = 219,
 
         // Ssh connection errors
         SshRequestDeniedError = 300,
@@ -79,6 +81,7 @@ namespace amnezia
         ImportBackupFileUseRestoreInstead = 903,
         RestoreBackupInvalidError = 904,
         LegacyApiV1NotSupportedError = 905,
+        LegacyContainerNotSupportedError = 906,
 
         // Android errors
         AndroidError = 1000,
@@ -123,5 +126,3 @@ namespace amnezia
 Q_DECLARE_METATYPE(amnezia::ErrorCode)
 
 #endif // ERRORCODES_H
-
-

client/core/utils/errorStrings.cpp

@@ -39,6 +39,8 @@ QString errorString(ErrorCode code) {
     case(ErrorCode::XrayRealityKeysReadFailed):
         errorMessage = QObject::tr("Server error: failed to read XRay Reality keys from the server");
         break;
+    case(ErrorCode::ServerContainerRuntimeNotSupported): errorMessage = QObject::tr("Server error: The default container runtime available for installation on this server is not supported.\n Install Docker Engine on the server manually and try again."); break;
+    case(ErrorCode::ContainerRuntimeServiceNotRunning): errorMessage = QObject::tr("Container runtime error: The container runtime service is not running.\n Check the container runtime service on the server, or wait about a minute and try again."); break;
 
     // Libssh errors
     case(ErrorCode::SshRequestDeniedError): errorMessage = QObject::tr("SSH request was denied"); break;
@@ -69,6 +71,7 @@ QString errorString(ErrorCode code) {
     case (ErrorCode::ImportBackupFileUseRestoreInstead): errorMessage = QObject::tr("Backup files cannot be imported here. Use 'Restore from backup' instead."); break;
     case (ErrorCode::RestoreBackupInvalidError): errorMessage = QObject::tr("Backup file is corrupted or has invalid format"); break;
     case (ErrorCode::LegacyApiV1NotSupportedError): errorMessage = QObject::tr("This legacy Amnezia subscription format is no longer supported"); break;
+    case (ErrorCode::LegacyContainerNotSupportedError): errorMessage = QObject::tr("This protocol is no longer supported. Please select another protocol or remove this container from the server settings."); break;
     case (ErrorCode::ImportOpenConfigError): errorMessage = QObject::tr("Unable to open config file"); break;
     case (ErrorCode::NoInstalledContainersError): errorMessage = QObject::tr("VPN Protocols is not installed.\n Please install VPN container at first"); break;
 

client/core/utils/networkUtilities.cpp

@@ -286,7 +286,7 @@ QPair<QString, QNetworkInterface> NetworkUtilities::getGatewayAndIface()
     return { resGateway, QNetworkInterface::interfaceFromIndex(resIndex) };
 #endif
 #ifdef Q_OS_LINUX
-    constexpr int BUFFER_SIZE = 100;
+    constexpr int BUFFER_SIZE = 8192;
     int     received_bytes = 0, msg_len = 0, route_attribute_len = 0;
     int     sock = -1, msgseq = 0;
     struct  nlmsghdr *nlh, *nlmsg;
@@ -294,7 +294,7 @@ QPair<QString, QNetworkInterface> NetworkUtilities::getGatewayAndIface()
     // This struct contain route attributes (route type)
     struct  rtattr *route_attribute;
     char    gateway_address[INET_ADDRSTRLEN], interface[IF_NAMESIZE];
-    char    msgbuf[BUFFER_SIZE], buffer[BUFFER_SIZE];
+    char    msgbuf[100], buffer[BUFFER_SIZE];
     char    *ptr = buffer;
     struct timeval tv;
 
@@ -339,8 +339,8 @@ QPair<QString, QNetworkInterface> NetworkUtilities::getGatewayAndIface()
         nlh = (struct nlmsghdr *) ptr;
 
         /* Check if the header is valid */
-        if((NLMSG_OK(nlmsg, received_bytes) == 0) ||
-            (nlmsg->nlmsg_type == NLMSG_ERROR))
+        if((NLMSG_OK(nlh, received_bytes) == 0) ||
+            (nlh->nlmsg_type == NLMSG_ERROR))
         {
             perror("Error in received packet");
             return {};
@@ -355,13 +355,15 @@ QPair<QString, QNetworkInterface> NetworkUtilities::getGatewayAndIface()
         }
 
         /* Break if its not a multi part message */
-        if ((nlmsg->nlmsg_flags & NLM_F_MULTI) == 0)
+        if ((nlh->nlmsg_flags & NLM_F_MULTI) == 0)
             break;
     }
-    while ((nlmsg->nlmsg_seq != msgseq) || (nlmsg->nlmsg_pid != getpid()));
+    while ((nlh->nlmsg_seq != msgseq) || (nlh->nlmsg_pid != getpid()));
 
     /* parse response */
-    for ( ; NLMSG_OK(nlh, received_bytes); nlh = NLMSG_NEXT(nlh, received_bytes))
+    int remaining = msg_len + received_bytes;
+    nlh = (struct nlmsghdr *) buffer;
+    for ( ; NLMSG_OK(nlh, remaining); nlh = NLMSG_NEXT(nlh, remaining))
     {
         /* Get the route data */
         route_entry = (struct rtmsg *) NLMSG_DATA(nlh);
@@ -370,6 +372,10 @@ QPair<QString, QNetworkInterface> NetworkUtilities::getGatewayAndIface()
         if (route_entry->rtm_table != RT_TABLE_MAIN)
             continue;
 
+        /* Reset per-route to avoid cross-route state pollution */
+        memset(gateway_address, 0, sizeof(gateway_address));
+        memset(interface, 0, sizeof(interface));
+
         route_attribute = (struct rtattr *) RTM_RTA(route_entry);
         route_attribute_len = RTM_PAYLOAD(nlh);
 
@@ -395,6 +401,8 @@ QPair<QString, QNetworkInterface> NetworkUtilities::getGatewayAndIface()
             break;
         }
     }
+    if (!(*gateway_address) || !(*interface))
+        qDebug() << "getGatewayAndIface: no gateway found";
     close(sock);
     return { gateway_address, QNetworkInterface::interfaceFromName(interface) };
 #endif

client/daemon/daemon.cpp

@@ -613,7 +613,7 @@ void Daemon::checkHandshake() {
       pendingHandshakes++;
     }
   }
-
+  
   // Check again if there were connections that haven't completed a handshake.
   if (pendingHandshakes > 0) {
     m_handshakeTimer.start(HANDSHAKE_POLL_MSEC);

client/macos/networkextension/CMakeLists.txt

@@ -25,6 +25,8 @@ set_target_properties(AmneziaVPNNetworkExtension PROPERTIES
 
     XCODE_ATTRIBUTE_INFOPLIST_FILE ${CMAKE_CURRENT_SOURCE_DIR}/Info.plist.in
     XCODE_ATTRIBUTE_LD_RUNPATH_SEARCH_PATHS "@executable_path/../../../../Frameworks @loader_path/../../../../Frameworks"
+
+    XCODE_LINK_BUILD_PHASE_MODE KNOWN_LOCATION
 )
 
 if(DEPLOY)
@@ -118,10 +120,20 @@ target_include_directories(AmneziaVPNNetworkExtension PRIVATE ${CLIENT_ROOT_DIR}
 target_include_directories(AmneziaVPNNetworkExtension PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
 
 find_package(openvpnadapter REQUIRED)
+# FIXME(ygurov): https://github.com/conan-io/conan/issues/20034
+set_property(TARGET amnezia::openvpnadapter APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG)
+set_property(TARGET amnezia::openvpnadapter APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL)
+set_property(TARGET amnezia::openvpnadapter APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_property(TARGET amnezia::openvpnadapter APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO)
 target_link_libraries(AmneziaVPNNetworkExtension PRIVATE amnezia::openvpnadapter)
 
 find_package(awg-apple REQUIRED)
 target_link_libraries(AmneziaVPNNetworkExtension PRIVATE amnezia::awg-apple)
 
 find_package(hev-socks5-tunnel REQUIRED)
+# FIXME(ygurov): https://github.com/conan-io/conan/issues/20034
+set_property(TARGET heiher::hev-socks5-tunnel APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG)
+set_property(TARGET heiher::hev-socks5-tunnel APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL)
+set_property(TARGET heiher::hev-socks5-tunnel APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_property(TARGET heiher::hev-socks5-tunnel APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO)
 target_link_libraries(AmneziaVPNNetworkExtension PRIVATE heiher::hev-socks5-tunnel)

client/platforms/linux/daemon/dnsutilslinux.cpp

@@ -7,8 +7,11 @@
 #include <net/if.h>
 
 #include <QDBusVariant>
+#include <QNetworkInterface>
+#include <QTimer>
 #include <QtDBus/QtDBus>
 
+#include "core/networkUtilities.h"
 #include "leakdetector.h"
 #include "logger.h"
 
@@ -27,24 +30,56 @@ DnsUtilsLinux::DnsUtilsLinux(QObject* parent) : DnsUtils(parent) {
   logger.debug() << "DnsUtilsLinux created.";
 
   QDBusConnection conn = QDBusConnection::systemBus();
-  m_resolver = new QDBusInterface(DBUS_RESOLVE_SERVICE, DBUS_RESOLVE_PATH,
-                                  DBUS_RESOLVE_MANAGER, conn, this);
+  auto* watcher = new QDBusServiceWatcher(
+      DBUS_RESOLVE_SERVICE, conn,
+      QDBusServiceWatcher::WatchForRegistration |
+      QDBusServiceWatcher::WatchForUnregistration, this);
+
+  connect(watcher, &QDBusServiceWatcher::serviceRegistered,
+          this, &DnsUtilsLinux::onResolverRegistered);
+  connect(watcher, &QDBusServiceWatcher::serviceUnregistered,
+          this, &DnsUtilsLinux::onResolverUnregistered);
+
+  if (conn.interface()->isServiceRegistered(DBUS_RESOLVE_SERVICE)) {
+    onResolverRegistered();
+  }
+}
+
+void DnsUtilsLinux::onResolverRegistered() {
+  m_resolver.reset(new QDBusInterface(DBUS_RESOLVE_SERVICE, DBUS_RESOLVE_PATH,
+                                      DBUS_RESOLVE_MANAGER,
+                                      QDBusConnection::systemBus()));
+  logger.debug() << "systemd-resolved available, DNS resolver initialized";
+
+  if (!m_pendingIfname.isEmpty()) {
+    logger.debug() << "Re-applying DNS configuration for" << m_pendingIfname;
+    updateResolvers(m_pendingIfname, m_pendingResolvers);
+  }
+}
+
+void DnsUtilsLinux::onResolverUnregistered() {
+  logger.debug() << "systemd-resolved disappeared, dropping DNS resolver";
+  m_resolver.reset();
 }
 
 DnsUtilsLinux::~DnsUtilsLinux() {
   MZ_COUNT_DTOR(DnsUtilsLinux);
 
-  for (auto iterator = m_linkDomains.constBegin();
-       iterator != m_linkDomains.constEnd(); ++iterator) {
-    QList<QVariant> argumentList;
-    argumentList << QVariant::fromValue(iterator.key());
-    argumentList << QVariant::fromValue(iterator.value());
-    m_resolver->asyncCallWithArgumentList(QStringLiteral("SetLinkDomains"),
-                                          argumentList);
-  }
+  if (m_revertOnDestroy && m_resolver) {
+    if (m_gatewayIfindex > 0)
+      setLinkDefaultRoute(m_gatewayIfindex, true);
 
-  if (m_ifindex > 0) {
-    m_resolver->asyncCall(QStringLiteral("RevertLink"), m_ifindex);
+    for (auto iterator = m_linkDomains.constBegin();
+         iterator != m_linkDomains.constEnd(); ++iterator) {
+      QList<QVariant> argumentList;
+      argumentList << QVariant::fromValue(iterator.key());
+      argumentList << QVariant::fromValue(iterator.value());
+      m_resolver->asyncCallWithArgumentList(QStringLiteral("SetLinkDomains"),
+                                            argumentList);
+    }
+    if (m_ifindex > 0) {
+      m_resolver->asyncCall(QStringLiteral("RevertLink"), m_ifindex);
+    }
   }
 
   logger.debug() << "DnsUtilsLinux destroyed.";
@@ -52,12 +87,31 @@ DnsUtilsLinux::~DnsUtilsLinux() {
 
 bool DnsUtilsLinux::updateResolvers(const QString& ifname,
                                     const QList<QHostAddress>& resolvers) {
+  if (m_gatewayIfindex > 0) {
+    setLinkDefaultRoute(m_gatewayIfindex, true);
+    m_gatewayIfindex = 0;
+  }
+
   m_ifindex = if_nametoindex(qPrintable(ifname));
   if (m_ifindex <= 0) {
     logger.error() << "Unable to resolve ifindex for" << ifname;
     return false;
   }
 
+  m_pendingIfname = ifname;
+  m_pendingResolvers = resolvers;
+
+  if (!m_resolver) {
+    logger.debug() << "systemd-resolved not ready, queuing DNS configuration";
+    return true;
+  }
+
+  const int gwIdx = NetworkUtilities::getGatewayAndIface().second.index();
+  if (gwIdx > 0 && gwIdx != m_ifindex && gwIdx != m_gatewayIfindex) {
+    m_gatewayIfindex = gwIdx;
+    setLinkDefaultRoute(gwIdx, false);
+  }
+
   setLinkDNS(m_ifindex, resolvers);
   setLinkDefaultRoute(m_ifindex, true);
   updateLinkDomains();
@@ -65,6 +119,15 @@ bool DnsUtilsLinux::updateResolvers(const QString& ifname,
 }
 
 bool DnsUtilsLinux::restoreResolvers() {
+  m_revertOnDestroy = true;
+  m_pendingIfname.clear();
+  m_pendingResolvers.clear();
+
+  if (m_gatewayIfindex > 0) {
+    setLinkDefaultRoute(m_gatewayIfindex, true);
+    m_gatewayIfindex = 0;
+  }
+
   for (auto iterator = m_linkDomains.constBegin();
        iterator != m_linkDomains.constEnd(); ++iterator) {
     setLinkDomains(iterator.key(), iterator.value());
@@ -72,7 +135,7 @@ bool DnsUtilsLinux::restoreResolvers() {
   m_linkDomains.clear();
 
   /* Revert the VPN interface's DNS configuration */
-  if (m_ifindex > 0) {
+  if (m_ifindex > 0 && m_resolver) {
     QList<QVariant> argumentList = {QVariant::fromValue(m_ifindex)};
     QDBusPendingReply<> reply = m_resolver->asyncCallWithArgumentList(
         QStringLiteral("RevertLink"), argumentList);
@@ -90,13 +153,14 @@ bool DnsUtilsLinux::restoreResolvers() {
 void DnsUtilsLinux::dnsCallCompleted(QDBusPendingCallWatcher* call) {
   QDBusPendingReply<> reply = *call;
   if (reply.isError()) {
-    logger.error() << "Error received from the DBus service";
+    logger.debug() << "DBus call failed (may be transient after systemd-resolved restart)";
   }
   delete call;
 }
 
 void DnsUtilsLinux::setLinkDNS(int ifindex,
                                const QList<QHostAddress>& resolvers) {
+  if (!m_resolver) return;
   QList<DnsResolver> resolverList;
   char ifnamebuf[IF_NAMESIZE];
   const char* ifname = if_indextoname(ifindex, ifnamebuf);
@@ -121,6 +185,7 @@ void DnsUtilsLinux::setLinkDNS(int ifindex,
 
 void DnsUtilsLinux::setLinkDomains(int ifindex,
                                    const QList<DnsLinkDomain>& domains) {
+  if (!m_resolver) return;
   char ifnamebuf[IF_NAMESIZE];
   const char* ifname = if_indextoname(ifindex, ifnamebuf);
   if (ifname) {
@@ -144,6 +209,7 @@ void DnsUtilsLinux::setLinkDomains(int ifindex,
 }
 
 void DnsUtilsLinux::setLinkDefaultRoute(int ifindex, bool enable) {
+  if (!m_resolver) return;
   QList<QVariant> argumentList;
   argumentList << QVariant::fromValue(ifindex);
   argumentList << QVariant::fromValue(enable);
@@ -156,6 +222,7 @@ void DnsUtilsLinux::setLinkDefaultRoute(int ifindex, bool enable) {
 }
 
 void DnsUtilsLinux::updateLinkDomains() {
+  if (!m_resolver) return;
   /* Get the list of search domains, and remove any others that might conspire
    * to satisfy DNS resolution. Unfortunately, this is a pain because Qt doesn't
    * seem to be able to demarshall complex property types.
@@ -174,11 +241,20 @@ void DnsUtilsLinux::updateLinkDomains() {
 
 void DnsUtilsLinux::dnsDomainsReceived(QDBusPendingCallWatcher* call) {
   QDBusPendingReply<QVariant> reply = *call;
+  call->deleteLater();
   if (reply.isError()) {
-    logger.error() << "Error retrieving the DNS  domains from the DBus service";
-    delete call;
+    // systemd-resolved may still be starting up after a restart — retry a few times
+    if (m_ifindex > 0 && m_domainRetries++ < 5) {
+      logger.debug() << "systemd-resolved not ready yet, retrying DNS setup ("
+                     << m_domainRetries << "/5)";
+      QTimer::singleShot(500, this, &DnsUtilsLinux::updateLinkDomains);
+    } else {
+      logger.warning() << "Failed to configure DNS after 5 retries";
+      m_domainRetries = 0;
+    }
     return;
   }
+  m_domainRetries = 0;
 
   /* Update the state of the DNS domains */
   m_linkDomains.clear();
@@ -204,9 +280,17 @@ void DnsUtilsLinux::dnsDomainsReceived(QDBusPendingCallWatcher* call) {
   }
 
   /* Add a root search domain for the new interface. */
-  QList<DnsLinkDomain> newlist = {root};
-  setLinkDomains(m_ifindex, newlist);
-  delete call;
+  if (m_ifindex > 0) {
+    setLinkDomains(m_ifindex, {root});
+
+    /* Disable DefaultRoute on the physical gateway so systemd-resolved
+     * routes all DNS through the VPN interface. */
+    const int gwIdx = NetworkUtilities::getGatewayAndIface().second.index();
+    if (gwIdx > 0 && gwIdx != m_ifindex && gwIdx != m_gatewayIfindex) {
+      m_gatewayIfindex = gwIdx;
+      setLinkDefaultRoute(gwIdx, false);
+    }
+  }
 }
 
 static DnsMetatypeRegistrationProxy s_dnsMetatypeProxy;

client/platforms/linux/daemon/dnsutilslinux.h

@@ -6,7 +6,12 @@
 #define DNSUTILSLINUX_H
 
 #include <QDBusInterface>
+#include <QScopedPointer>
 #include <QDBusPendingCallWatcher>
+#include <QDBusServiceWatcher>
+#include <QHostAddress>
+#include <QList>
+#include <QString>
 
 #include "daemon/dnsutils.h"
 #include "dbustypeslinux.h"
@@ -29,13 +34,20 @@ class DnsUtilsLinux final : public DnsUtils {
   void updateLinkDomains();
 
  private slots:
+  void onResolverRegistered();
+  void onResolverUnregistered();
   void dnsCallCompleted(QDBusPendingCallWatcher*);
   void dnsDomainsReceived(QDBusPendingCallWatcher*);
 
  private:
   int m_ifindex = 0;
+  int m_gatewayIfindex = 0;
+  int m_domainRetries = 0;
+  bool m_revertOnDestroy = false;
   QMap<int, DnsLinkDomainList> m_linkDomains;
-  QDBusInterface* m_resolver = nullptr;
+  QScopedPointer<QDBusInterface> m_resolver;
+  QString m_pendingIfname;
+  QList<QHostAddress> m_pendingResolvers;
 };
 
 #endif  // DNSUTILSLINUX_H

client/platforms/linux/daemon/linuxfirewall.cpp

@@ -454,16 +454,33 @@ void LinuxFirewall::updateDNSServers(const QStringList& servers)
     static QStringList existingServers {};
 
     existingServers = servers;
-    execute(QStringLiteral("iptables -F %1.320.allowDNS").arg(kAnchorName));
-    for (const QString& rule : getDNSRules(servers))
-        execute(QStringLiteral("iptables -A %1.320.allowDNS %2").arg(kAnchorName, rule));
+    const QString chain = QStringLiteral("%1.320.allowDNS").arg(kAnchorName);
+    executeIptables(QStringLiteral("iptables"), {QStringLiteral("-F"), chain});
+    const QStringList ifaces = {
+        QStringLiteral("amn0+"), QStringLiteral("tun0+"), QStringLiteral("tun2+")
+    };
+    for (const QString& server : servers) {
+        for (const QString& iface : ifaces) {
+            executeIptables(QStringLiteral("iptables"),
+                {QStringLiteral("-A"), chain, QStringLiteral("-o"), iface,
+                 QStringLiteral("-d"), server, QStringLiteral("-p"), QStringLiteral("udp"),
+                 QStringLiteral("--dport"), QStringLiteral("53"), QStringLiteral("-j"), QStringLiteral("ACCEPT")});
+            executeIptables(QStringLiteral("iptables"),
+                {QStringLiteral("-A"), chain, QStringLiteral("-o"), iface,
+                 QStringLiteral("-d"), server, QStringLiteral("-p"), QStringLiteral("tcp"),
+                 QStringLiteral("--dport"), QStringLiteral("53"), QStringLiteral("-j"), QStringLiteral("ACCEPT")});
+        }
+    }
 }
 
 void LinuxFirewall::updateAllowNets(const QStringList& servers)
 {
-    execute(QStringLiteral("iptables -F %1.110.allowNets").arg(kAnchorName));
-    for (const QString& rule : getAllowRule(servers))
-        execute(QStringLiteral("iptables -A %1.110.allowNets %2").arg(kAnchorName, rule));
+    const QString chain = QStringLiteral("%1.110.allowNets").arg(kAnchorName);
+    executeIptables(QStringLiteral("iptables"), {QStringLiteral("-F"), chain});
+    for (const QString& server : servers)
+        executeIptables(QStringLiteral("iptables"),
+            {QStringLiteral("-A"), chain, QStringLiteral("-d"), server,
+             QStringLiteral("-j"), QStringLiteral("ACCEPT")});
 }
 
 void LinuxFirewall::updateBlockNets(const QStringList& servers)
@@ -471,9 +488,12 @@ void LinuxFirewall::updateBlockNets(const QStringList& servers)
     static QStringList existingServers {};
 
     existingServers = servers;
-    execute(QStringLiteral("iptables -F %1.120.blockNets").arg(kAnchorName));
-    for (const QString& rule : getBlockRule(servers))
-        execute(QStringLiteral("iptables -A %1.120.blockNets %2").arg(kAnchorName, rule));
+    const QString chain = QStringLiteral("%1.120.blockNets").arg(kAnchorName);
+    executeIptables(QStringLiteral("iptables"), {QStringLiteral("-F"), chain});
+    for (const QString& server : servers)
+        executeIptables(QStringLiteral("iptables"),
+            {QStringLiteral("-A"), chain, QStringLiteral("-d"), server,
+             QStringLiteral("-j"), QStringLiteral("REJECT")});
 }
 
 int waitForExitCode(QProcess& process)
@@ -506,6 +526,24 @@ int LinuxFirewall::execute(const QString &command, bool ignoreErrors)
     return exitCode;
 }
 
+int LinuxFirewall::executeIptables(const QString &program, const QStringList &args, bool ignoreErrors)
+{
+    QProcess p;
+    p.start(program, args, QProcess::ReadOnly);
+    p.closeWriteChannel();
+
+    int exitCode = waitForExitCode(p);
+    auto out = p.readAllStandardOutput().trimmed();
+    auto err = p.readAllStandardError().trimmed();
+    if ((exitCode != 0 || !err.isEmpty()) && !ignoreErrors)
+        logger.warning() << "(" << exitCode << ") $ " << program << args.join(QLatin1Char(' '));
+    if (!out.isEmpty())
+        logger.info() << out;
+    if (!err.isEmpty())
+        logger.warning() << err;
+    return exitCode;
+}
+
 void LinuxFirewall::setupTrafficSplitting()
 {
     auto cGroupDir = "/sys/fs/cgroup/net_cls/" BRAND_CODE "vpnexclusions/";

client/platforms/linux/daemon/linuxfirewall.h

@@ -85,6 +85,7 @@ private:
     static void setupTrafficSplitting();
     static void teardownTrafficSplitting();
     static int execute(const QString& command, bool ignoreErrors = false);
+    static int executeIptables(const QString& program, const QStringList& args, bool ignoreErrors = false);
 private:
     // Chain names
     static QString kOutputChain, kRootChain, kPostRoutingChain, kPreRoutingChain;

client/platforms/linux/daemon/wireguardutilslinux.cpp

@@ -237,7 +237,11 @@ bool WireguardUtilsLinux::updatePeer(const InterfaceConfig& config) {
     // Exclude the server address, except for multihop exit servers.
     if ((config.m_hopType != InterfaceConfig::MultiHopExit) &&
         (m_rtmonitor != nullptr)) {
-        m_rtmonitor->addExclusionRoute(IPAddress(config.m_serverIpv4AddrIn));
+        if (!config.m_serverIpv4AddrIn.isEmpty() &&
+            !m_rtmonitor->addExclusionRoute(IPAddress(config.m_serverIpv4AddrIn))) {
+            logger.error() << "No gateway — cannot add server exclusion route";
+            return false;
+        }
         m_rtmonitor->addExclusionRoute(IPAddress(config.m_serverIpv6AddrIn));
     }
 

client/server_scripts/check_server_is_busy.sh

@@ -1,7 +1,8 @@
-if which apt-get > /dev/null 2>&1; then LOCK_CMD="fuser"; LOCK_FILE="/var/lib/dpkg/lock-frontend";\
-elif which dnf > /dev/null 2>&1; then LOCK_CMD="fuser"; LOCK_FILE="/var/cache/dnf/* /var/run/dnf/* /var/lib/dnf/* /var/lib/rpm/*";\
-elif which yum > /dev/null 2>&1; then LOCK_CMD="cat"; LOCK_FILE="/var/run/yum.pid";\
-elif which zypper > /dev/null 2>&1; then LOCK_CMD="cat"; LOCK_FILE="/var/run/zypp.pid";\
-elif which pacman > /dev/null 2>&1; then LOCK_CMD="fuser"; LOCK_FILE="/var/lib/pacman/db.lck";\
-else echo "Packet manager not found"; echo "Internal error"; exit 1; fi;\
-if command -v $LOCK_CMD > /dev/null 2>&1; then sudo $LOCK_CMD $LOCK_FILE 2>/dev/null; else echo "$LOCK_CMD not installed"; fi
+if which apt-get > /dev/null 2>&1 || command -v apt-get > /dev/null 2>&1; then LOCK_CMD="fuser"; LOCK_FILE="/var/lib/dpkg/lock-frontend";\
+elif which dnf > /dev/null 2>&1 || command -v dnf > /dev/null 2>&1; then LOCK_CMD="fuser"; LOCK_FILE="/var/cache/dnf/* /var/run/dnf/* /var/lib/dnf/* /var/lib/rpm/*";\
+elif which yum > /dev/null 2>&1 || command -v yum > /dev/null 2>&1; then LOCK_CMD="cat"; LOCK_FILE="/var/run/yum.pid";\
+elif which zypper > /dev/null 2>&1 || command -v zypper > /dev/null 2>&1; then LOCK_CMD="cat"; LOCK_FILE="/var/run/zypp.pid";\
+elif which pacman > /dev/null 2>&1 || command -v pacman > /dev/null 2>&1; then LOCK_CMD="fuser"; LOCK_FILE="/var/lib/pacman/db.lck";\
+else echo "Packet manager not found"; echo "Internal error"; exit 1;\
+fi;\
+if sudo -n which $LOCK_CMD > /dev/null 2>&1 || command -v $LOCK_CMD > /dev/null 2>&1; then sudo -n $LOCK_CMD $LOCK_FILE 2>/dev/null; else echo "$LOCK_CMD not installed"; fi

client/server_scripts/check_user_in_sudo.sh

@@ -1,8 +1,8 @@
-if which apt-get > /dev/null 2>&1; then pm=$(which apt-get); opt="--version";\
-elif which dnf > /dev/null 2>&1; then pm=$(which dnf); opt="--version";\
-elif which yum > /dev/null 2>&1; then pm=$(which yum); opt="--version";\
-elif which zypper > /dev/null 2>&1; then pm=$(which zypper); opt="--version";\
-elif which pacman > /dev/null 2>&1; then pm=$(which pacman); opt="--version";\
+if pm=$(which apt-get 2>/dev/null || command -v apt-get 2>/dev/null); then opt="--version";\
+elif pm=$(which dnf 2>/dev/null || command -v dnf 2>/dev/null); then opt="--version";\
+elif pm=$(which yum 2>/dev/null || command -v yum 2>/dev/null); then opt="--version";\
+elif pm=$(which zypper 2>/dev/null || command -v zypper 2>/dev/null); then opt="--version";\
+elif pm=$(which pacman 2>/dev/null || command -v pacman 2>/dev/null); then opt="--version";\
 else pm="uname"; opt="-a";\
 fi;\
 CUR_USER=$(whoami 2>/dev/null || echo $HOME | sed 's/.*\///');\

client/server_scripts/install_docker.sh

@@ -1,25 +1,34 @@
-if which apt-get > /dev/null 2>&1; then pm=$(which apt-get); silent_inst="-yq install --install-recommends"; check_pkgs="-yq update"; docker_pkg="docker.io"; dist="debian";\
-elif which dnf > /dev/null 2>&1; then pm=$(which dnf); silent_inst="-yq install"; check_pkgs="-yq check-update"; docker_pkg="docker"; dist="fedora";\
-elif which yum > /dev/null 2>&1; then pm=$(which yum); silent_inst="-y -q install"; check_pkgs="-y -q check-update"; docker_pkg="docker"; dist="centos";\
-elif which zypper > /dev/null 2>&1; then pm=$(which zypper); silent_inst="-nq install"; check_pkgs="-nq refresh"; docker_pkg="docker"; dist="opensuse";\
-elif which pacman > /dev/null 2>&1; then pm=$(which pacman); silent_inst="-S --noconfirm --noprogressbar --quiet"; check_pkgs="-Sup"; docker_pkg="docker"; dist="archlinux";\
-else echo "Packet manager not found"; exit 1; fi;\
-echo "Dist: $dist, Packet manager: $pm, Install command: $silent_inst, Check pkgs command: $check_pkgs, Docker pkg: $docker_pkg";\
+if pm=$(which apt-get 2>/dev/null || command -v apt-get 2>/dev/null); then silent_inst="-yq install --install-recommends"; what_pkg="-s install"; check_pkgs="-yq update"; docker_pkg="docker.io"; dist="debian";\
+elif pm=$(which dnf 2>/dev/null || command -v dnf 2>/dev/null); then silent_inst="-yq install"; what_pkg="--assumeno install --setopt=tsflags=test"; check_pkgs="-yq check-update"; docker_pkg="docker"; dist="fedora";\
+elif pm=$(which yum 2>/dev/null || command -v yum 2>/dev/null); then silent_inst="-y -q install"; what_pkg="--assumeno install --setopt=tsflags=test"; check_pkgs="-y -q check-update"; docker_pkg="docker"; dist="centos";\
+elif pm=$(which zypper 2>/dev/null || command -v zypper 2>/dev/null); then silent_inst="-nq install"; what_pkg="--dry-run install"; check_pkgs="-nq refresh"; docker_pkg="docker"; dist="suse";\
+elif pm=$(which pacman 2>/dev/null || command -v pacman 2>/dev/null); then silent_inst="-S --noconfirm --noprogressbar --quiet"; what_pkg="-Sp"; check_pkgs="-Sup"; docker_pkg="docker"; dist="archlinux";\
+fi;\
+echo "Dist: $dist, Packet manager: $pm, Install command: $silent_inst, What pkg command: $what_pkg, Check pkgs command: $check_pkgs, Docker pkg: $docker_pkg, Language: $LANG";\
+echo $LANG | grep -qE '^(en_US.UTF-8|C.UTF-8|C)$' || export LC_ALL=C;\
 if [ "$dist" = "debian" ]; then export DEBIAN_FRONTEND=noninteractive; fi;\
 if ! command -v sudo > /dev/null 2>&1; then $pm $check_pkgs; $pm $silent_inst sudo; fi;\
-if ! command -v fuser > /dev/null 2>&1; then sudo $pm $check_pkgs; sudo $pm $silent_inst psmisc; fi;\
-if ! command -v lsof > /dev/null 2>&1; then sudo $pm $check_pkgs; sudo $pm $silent_inst lsof; fi;\
-if ! command -v docker > /dev/null 2>&1; then \
-  sudo $pm $check_pkgs; sudo $pm $silent_inst $docker_pkg;\
-  sleep 5; sudo systemctl enable --now docker; sleep 5;\
+if ! sudo -n sh -c 'command -v which > /dev/null 2>&1'; then sudo -n $pm $check_pkgs; sudo -n $pm $silent_inst which; fi;\
+if ! sudo -n sh -c 'command -v fuser > /dev/null 2>&1'; then sudo -n $pm $check_pkgs; sudo -n $pm $silent_inst psmisc; fi;\
+if ! sudo -n sh -c 'command -v lsof > /dev/null 2>&1'; then sudo -n $pm $check_pkgs; sudo -n $pm $silent_inst lsof; fi;\
+if ! sudo -n sh -c 'command -v docker > /dev/null 2>&1'; then \
+  sudo -n $pm $check_pkgs;\
+  if ! sudo -n $pm $what_pkg $docker_pkg 2>/dev/null | grep -qi podman; then \
+    sudo -n $pm $silent_inst $docker_pkg;\
+    sleep 5; sudo -n systemctl enable --now docker; sleep 5;\
+  else \
+    echo "Container runtime is not supported";\
+    exit 1;\
+  fi;\
 fi;\
-if [ "$(cat /sys/module/apparmor/parameters/enabled 2>/dev/null)" = "Y" ]; then \
-  if ! command -v apparmor_parser > /dev/null 2>&1; then sudo $pm $check_pkgs; sudo $pm $silent_inst apparmor; fi;\
+if [ "$(sudo -n cat /sys/module/apparmor/parameters/enabled 2>/dev/null)" = "Y" ]; then \
+  if ! sudo -n sh -c 'command -v apparmor_parser > /dev/null 2>&1'; then \
+    sudo -n $pm $check_pkgs; sudo -n $pm $silent_inst apparmor;\
+  fi;\
 fi;\
-if [ "$(systemctl is-active docker)" != "active" ]; then \
-  sudo $pm $check_pkgs; sudo $pm $silent_inst $docker_pkg;\
-  sleep 5; sudo systemctl start docker; sleep 5;\
+if [ "$(sudo -n systemctl is-active docker)" != "active" ]; then \
+  sleep 5; sudo -n systemctl start docker; sleep 5;\
+  if [ "$(sudo -n systemctl is-active docker)" != "active" ]; then echo "Container runtime service not running"; fi;\
 fi;\
-if ! command -v sudo > /dev/null 2>&1; then echo "Failed to install sudo, command not found"; exit 1; fi;\
-docker --version;\
+sudo -n docker --version || docker --version;\
 uname -sr

client/server_scripts/remove_all_containers.sh

@@ -1,5 +1,6 @@
 sudo docker ps -a | grep amnezia | awk '{print $1}' | xargs sudo docker stop;\
 sudo docker ps -a | grep amnezia | awk '{print $1}' | xargs sudo docker rm -fv;\
 sudo docker images -a --format table | grep amnezia | awk '{print $3, $1 ":" $2}' | xargs sudo docker rmi;\
+sudo docker volume ls --format '{{.Name}}' | grep '^amnezia-' | xargs -r sudo docker volume rm -f;\
 sudo docker network ls | grep amnezia-dns-net | awk '{print $1}' | xargs sudo docker network rm;\
 sudo rm -frd /opt/amnezia

client/server_scripts/remove_container.sh

@@ -1,4 +1,3 @@
 sudo docker stop $CONTAINER_NAME;\
 sudo docker rm -fv $CONTAINER_NAME;\
-sudo docker rmi $CONTAINER_NAME;\
-test "$REMOVE_CONTAINER_DATA" = "1" && sudo docker volume rm -f ${CONTAINER_NAME}-data 2>/dev/null || true
+sudo docker rmi $CONTAINER_NAME;

client/ui/controllers/api/subscriptionUiController.cpp

@@ -475,8 +475,7 @@ bool SubscriptionUiController::deactivateExternalDevice(const QString &serverId,
 void SubscriptionUiController::validateConfig()
 {
     const QString serverId = m_serversController->getDefaultServerId();
-    if (!serverId.isEmpty() && m_serversController->isLegacyApiV1Server(serverId)) {
-        emit unsupportedConnectDrawerRequested();
+    if (serverId.isEmpty()) {
         emit configValidated(false);
         return;
     }

client/ui/controllers/connectionUiController.cpp

@@ -8,6 +8,8 @@
 
 #include "amneziaApplication.h"
 #include "core/controllers/serversController.h"
+#include "core/models/containerConfig.h"
+#include "core/utils/containerEnum.h"
 
 ConnectionUiController::ConnectionUiController(ConnectionController* connectionController,
                                                 ServersController* serversController,
@@ -33,7 +35,7 @@ void ConnectionUiController::openConnection()
     ErrorCode errorCode = m_connectionController->openConnection(serverId);
 
     if (errorCode != ErrorCode::NoError) {
-        emit connectionErrorOccurred(errorCode);
+        notifyConnectionBlocked(errorCode);
         return;
     }
 }
@@ -130,10 +132,36 @@ void ConnectionUiController::toggleConnection()
     } else if (isConnected()) {
         closeConnection();
     } else {
+        const QString serverId = m_serversController->getDefaultServerId();
+        if (serverId.isEmpty()) {
+            return;
+        }
+
+        const ErrorCode errorCode = m_connectionController->isConnectionSupported(serverId);
+        if (errorCode != ErrorCode::NoError) {
+            notifyConnectionBlocked(errorCode);
+            return;
+        }
+
         emit prepareConfig();
     }
 }
 
+void ConnectionUiController::notifyConnectionBlocked(ErrorCode errorCode)
+{
+    if (errorCode == ErrorCode::LegacyApiV1NotSupportedError) {
+        emit unsupportedConnectDrawerRequested();
+        return;
+    }
+
+    if (errorCode == ErrorCode::NoInstalledContainersError) {
+        emit noInstalledContainers();
+        return;
+    }
+
+    emit connectionErrorOccurred(errorCode);
+}
+
 bool ConnectionUiController::isConnectionInProgress() const
 {
     return m_isConnectionInProgress;
@@ -143,3 +171,32 @@ bool ConnectionUiController::isConnected() const
 {
     return m_isConnected;
 }
+
+bool ConnectionUiController::isRevokeBlockedDuringActiveConnection(const QString &serverId, int containerIndex,
+                                                                   const QString &clientId) const
+{
+    if (clientId.isEmpty() || (!isConnected() && !isConnectionInProgress())) {
+        return false;
+    }
+
+    if (m_serversController->getDefaultServerId() != serverId) {
+        return false;
+    }
+
+    if (static_cast<int>(m_serversController->getDefaultContainer(serverId)) != containerIndex) {
+        return false;
+    }
+
+    const auto adminConfig = m_serversController->selfHostedAdminConfig(serverId);
+    if (!adminConfig.has_value()) {
+        return false;
+    }
+
+    const QString connectionClientId =
+            adminConfig->containerConfig(static_cast<DockerContainer>(containerIndex)).protocolConfig.clientId();
+    if (connectionClientId.isEmpty()) {
+        return false;
+    }
+
+    return connectionClientId == clientId || connectionClientId.contains(clientId);
+}

client/ui/controllers/connectionUiController.h

@@ -35,6 +35,8 @@ public slots:
     void openConnection();
     void closeConnection();
 
+    bool isRevokeBlockedDuringActiveConnection(const QString &serverId, int containerIndex, const QString &clientId) const;
+
     ErrorCode getLastConnectionError();
     void onConnectionStateChanged(Vpn::ConnectionState state);
 
@@ -48,9 +50,12 @@ signals:
     void connectButtonClicked();
     void preparingConfig();
     void prepareConfig();
+    void unsupportedConnectDrawerRequested();
+    void noInstalledContainers();
 
 private:
     Vpn::ConnectionState getCurrentConnectionState();
+    void notifyConnectionBlocked(ErrorCode errorCode);
 
     ConnectionController* m_connectionController;
     ServersController* m_serversController;

client/ui/controllers/qml/pageController.cpp

@@ -128,6 +128,11 @@ void PageController::showOnStartup()
     }
 }
 
+bool PageController::shouldStartMinimized() const
+{
+    return m_settingsController->isStartMinimizedEnabled();
+}
+
 bool PageController::isTriggeredByConnectButton()
 {
     return m_isTriggeredByConnectButton;

client/ui/controllers/qml/pageController.h

@@ -45,8 +45,6 @@ namespace PageLoader
         PageSettingsApiDevices,
         PageSettingsApiSubscriptionKey,
         PageSettingsKillSwitchExceptions,
-        PageSettingsConnectionType,
-        PageSettingsLocalProxy,
 
         PageServiceSftpSettings,
         PageServiceTorWebsiteSettings,
@@ -125,6 +123,7 @@ public slots:
     void updateNavigationBarColor(const int color);
 
     void showOnStartup();
+    bool shouldStartMinimized() const;
 
     bool isTriggeredByConnectButton();
     void setTriggeredByConnectButton(bool trigger);

client/ui/controllers/selfhosted/exportUiController.cpp

@@ -9,6 +9,13 @@ ExportUiController::ExportUiController(ExportController* exportController, QObje
     : QObject(parent),
       m_exportController(exportController)
 {
+    connect(m_exportController, &ExportController::revokeFinished, this, [this](ErrorCode errorCode) {
+        if (errorCode == ErrorCode::NoError) {
+            emit revokeConfigFinished();
+        } else {
+            emit exportErrorOccurred(errorCode);
+        }
+    });
 }
 
 void ExportUiController::generateFullAccessConfig(const QString &serverId)
@@ -92,7 +99,6 @@ void ExportUiController::updateClientManagementModel(const QString &serverId, in
 void ExportUiController::revokeConfig(int row, const QString &serverId, int containerIndex)
 {
     m_exportController->revokeConfig(row, serverId, containerIndex);
-    emit revokeConfigFinished();
 }
 
 void ExportUiController::renameClient(int row, const QString &clientName, const QString &serverId, int containerIndex)

client/ui/controllers/selfhosted/installUiController.cpp

@@ -75,13 +75,7 @@ InstallUiController::InstallUiController(InstallController *installController,
       m_connectionController(connectionController)
 {
     connect(m_installController, &InstallController::configValidated, this, &InstallUiController::configValidated);
-    connect(m_installController, &InstallController::validationErrorOccurred, this, [this](ErrorCode errorCode) {
-        if (errorCode == ErrorCode::NoInstalledContainersError) {
-            emit noInstalledContainers();
-        } else {
-            emit installationErrorOccurred(errorCode);
-        }
-    });
+    connect(m_installController, &InstallController::validationErrorOccurred, this, &InstallUiController::installationErrorOccurred);
 }
 
 InstallUiController::~InstallUiController()
@@ -217,15 +211,13 @@ void InstallUiController::scanServerForInstalledContainers(const QString &server
     emit installationErrorOccurred(errorCode);
 }
 
-void InstallUiController::updateContainer(const QString &serverId, int containerIndex, int protocolIndex, bool closePage)
+bool InstallUiController::buildContainerConfigFromModel(int containerIndex, int protocolIndex, ContainerConfig &containerConfig)
 {
     DockerContainer container = static_cast<DockerContainer>(containerIndex);
-    
     Proto protocolType = static_cast<Proto>(protocolIndex);
-    
-    ContainerConfig containerConfig;
+
     containerConfig.container = container;
-    
+
     switch (protocolType) {
     case Proto::Awg: {
         containerConfig.protocolConfig = m_awgConfigModel->getProtocolConfig();
@@ -271,6 +263,41 @@ void InstallUiController::updateContainer(const QString &serverId, int container
     }
 #endif
     default:
+        return false;
+    }
+    return true;
+}
+
+void InstallUiController::updateClientConfig(const QString &serverId, int containerIndex, int protocolIndex, bool closePage)
+{
+    DockerContainer container = static_cast<DockerContainer>(containerIndex);
+    Proto protocolType = static_cast<Proto>(protocolIndex);
+
+    ContainerConfig containerConfig;
+    if (!buildContainerConfigFromModel(containerIndex, protocolIndex, containerConfig)) {
+        return;
+    }
+
+    ErrorCode errorCode = m_installController->updateClientConfig(serverId, container, containerConfig);
+
+    if (errorCode == ErrorCode::NoError) {
+        ContainerConfig updatedConfig = m_serversController->getContainerConfig(serverId, container);
+        m_protocolModel->updateModel(updatedConfig);
+        updateProtocolConfigModel(serverId, static_cast<int>(container), static_cast<int>(protocolType));
+        emit updateContainerFinished(tr("Settings updated successfully"), closePage);
+        return;
+    }
+
+    emit installationErrorOccurred(errorCode);
+}
+
+void InstallUiController::updateServerConfig(const QString &serverId, int containerIndex, int protocolIndex, bool closePage)
+{
+    DockerContainer container = static_cast<DockerContainer>(containerIndex);
+    Proto protocolType = static_cast<Proto>(protocolIndex);
+
+    ContainerConfig containerConfig;
+    if (!buildContainerConfigFromModel(containerIndex, protocolIndex, containerConfig)) {
         return;
     }
     ContainerConfig oldContainerConfig = m_serversController->getContainerConfig(serverId, container);
@@ -279,14 +306,17 @@ void InstallUiController::updateContainer(const QString &serverId, int container
             || container == DockerContainer::Xray || container == DockerContainer::SSXray;
 
     if (asyncUpdate) {
-        emit serverIsBusy(true);
+        const bool emitBusy = container == DockerContainer::MtProxy || container == DockerContainer::Telemt;
+        if (emitBusy)
+            emit serverIsBusy(true);
         auto *watcher = new QFutureWatcher<ErrorCode>(this);
         const Proto protocolTypeCopy = protocolType;
         QObject::connect(watcher, &QFutureWatcher<ErrorCode>::finished, this,
-                         [this, watcher, serverId, container, closePage, protocolTypeCopy]() {
+                         [this, watcher, serverId, container, closePage, protocolTypeCopy, emitBusy]() {
                              const ErrorCode errorCode = watcher->result();
                              watcher->deleteLater();
-                             emit serverIsBusy(false);
+                             if (emitBusy)
+                                 emit serverIsBusy(false);
 
                              if (errorCode == ErrorCode::NoError) {
                                  const ContainerConfig updatedConfig =
@@ -305,13 +335,13 @@ void InstallUiController::updateContainer(const QString &serverId, int container
         QFuture<ErrorCode> future =
                 QtConcurrent::run([installController, serverId, container, oldConfigCopy,
                                    newConfigCopy]() mutable -> ErrorCode {
-                    return installController->updateContainer(serverId, container, oldConfigCopy, newConfigCopy);
+                    return installController->updateServerConfig(serverId, container, oldConfigCopy, newConfigCopy);
                 });
         watcher->setFuture(future);
         return;
     }
 
-    ErrorCode errorCode = m_installController->updateContainer(serverId, container, oldContainerConfig, containerConfig);
+    ErrorCode errorCode = m_installController->updateServerConfig(serverId, container, oldContainerConfig, containerConfig);
 
     if (errorCode == ErrorCode::NoError) {
         ContainerConfig updatedConfig = m_serversController->getContainerConfig(serverId, container);

client/ui/controllers/selfhosted/installUiController.h

@@ -64,7 +64,8 @@ public slots:
 
     void scanServerForInstalledContainers(const QString &serverId);
 
-    void updateContainer(const QString &serverId, int containerIndex, int protocolIndex, bool closePage = true);
+    void updateServerConfig(const QString &serverId, int containerIndex, int protocolIndex, bool closePage = true);
+    void updateClientConfig(const QString &serverId, int containerIndex, int protocolIndex, bool closePage = true);
 
     void removeServer(const QString &serverId);
     void rebootServer(const QString &serverId);
@@ -132,7 +133,6 @@ signals:
     void cachedProfileCleared(const QString &message);
     void apiConfigRemoved(const QString &message);
 
-    void noInstalledContainers();
     void configValidated(bool isValid);
 
 private:
@@ -162,6 +162,8 @@ private:
     QString m_privateKeyPassphrase;
     
     void updateProtocolConfigModel(const QString &serverId, int containerIndex, int protocolIndex);
+
+    bool buildContainerConfigFromModel(int containerIndex, int protocolIndex, ContainerConfig &containerConfig);
 };
 
 #endif // INSTALLUICONTROLLER_H

client/ui/controllers/serversUiController.cpp

@@ -156,7 +156,17 @@ void ServersUiController::updateModel()
 
     m_serversModel->updateModel(m_orderedServerDescriptions, defaultServerId);
 
-    updateContainersModel();
+    if (!m_processedServerId.isEmpty()) {
+        if (isServerFromApi(m_processedServerId)) {
+            const auto &description = serverDescriptionById(m_processedServerId);
+            if (description.isApiV2 && description.isCountrySelectionAvailable
+                && !description.apiAvailableCountries.isEmpty()) {
+                emit updateApiCountryModel();
+            }
+        } else {
+            updateContainersModel();
+        }
+    }
     updateDefaultServerContainersModel();
 
     if (hadServersFromGatewayBefore != hasServersFromGatewayNow) {
@@ -350,19 +360,14 @@ void ServersUiController::setProcessedServerId(const QString &serverId)
         m_processedServerId = normalizedServerId;
 
         if (newIndex >= 0) {
-            updateContainersModel();
-
-            for (const auto &description : m_orderedServerDescriptions) {
-                if (description.serverId != normalizedServerId) {
-                    continue;
+            if (isServerFromApi(m_processedServerId)) {
+                const auto &description = serverDescriptionById(m_processedServerId);
+                if (description.isApiV2 && description.isCountrySelectionAvailable
+                    && !description.apiAvailableCountries.isEmpty()) {
+                    emit updateApiCountryModel();
                 }
-                if (description.isApiV2) {
-                    if (description.isCountrySelectionAvailable && !description.apiAvailableCountries.isEmpty()) {
-                        emit updateApiCountryModel();
-                    }
-                    emit updateApiServicesModel();
-                }
-                break;
+            } else {
+                updateContainersModel();
             }
         }
 

client/ui/controllers/serversUiController.h

@@ -113,7 +113,6 @@ signals:
     void processedContainerIndexChanged(int index);
     void hasServersFromGatewayApiChanged();
     void updateApiCountryModel();
-    void updateApiServicesModel();
 
 public:
     void updateModel();

client/ui/controllers/settingsUiController.cpp

@@ -22,12 +22,10 @@
 
 SettingsUiController::SettingsUiController(SettingsController* settingsController,
                                          ServersController* serversController,
-                                         LanguageUiController* languageUiController,
                                          QObject *parent)
     : QObject(parent),
       m_settingsController(settingsController),
-      m_serversController(serversController),
-      m_languageUiController(languageUiController)
+      m_serversController(serversController)
 {
 #ifdef Q_OS_ANDROID
     connect(AndroidController::instance(), &AndroidController::notificationStateChanged, this, &SettingsUiController::onNotificationStateChanged);
@@ -39,11 +37,6 @@ SettingsUiController::SettingsUiController(SettingsController* settingsControlle
     if (m_settingsController->isDevGatewayEnv()) {
         m_settingsController->enableDevMode();
     }
-
-    connect(m_settingsController, &SettingsController::localProxySettingsUpdated, this,
-            &SettingsUiController::localProxySettingsUpdated);
-    connect(m_settingsController, &SettingsController::localProxyStartFailed, this,
-            &SettingsUiController::localProxyStartFailed);
 }
 
 void SettingsUiController::toggleAmneziaDns(bool enable)
@@ -162,13 +155,13 @@ void SettingsUiController::restoreAppConfigFromData(const QByteArray &data)
 {
     ErrorCode errorCode = m_settingsController->restoreAppConfigFromData(data);
     if (errorCode == ErrorCode::NoError) {
-        emit appLanguageChanged(
-                static_cast<LanguageSettings::AvailableLanguageEnum>(m_languageUiController->getCurrentLanguageIndex()));
+        emit appLanguageChanged();
 
         bool amneziaDnsEnabled = m_settingsController->isAmneziaDnsEnabled();
         emit amneziaDnsToggled(amneziaDnsEnabled);
 
         emit restoreBackupFinished();
+        emit autoStartChanged();
         emit startMinimizedChanged();
     } else {
         emit errorOccurred(errorCode);
@@ -183,6 +176,7 @@ QString SettingsUiController::getAppVersion()
 void SettingsUiController::clearSettings()
 {
     m_settingsController->clearSettings();
+    emit autoStartChanged();
     emit startMinimizedChanged();
     emit resetLanguageToSystem();
 
@@ -211,9 +205,8 @@ bool SettingsUiController::isAutoStartEnabled()
 void SettingsUiController::toggleAutoStart(bool enable)
 {
     m_settingsController->toggleAutoStart(enable);
-    if (!enable) {
-        emit startMinimizedChanged();
-    }
+    emit autoStartChanged();
+    emit startMinimizedChanged();
 }
 
 bool SettingsUiController::isStartMinimizedEnabled()
@@ -365,53 +358,3 @@ void SettingsUiController::disableHomeAdLabel()
     m_settingsController->disableHomeAdLabel();
     emit isHomeAdLabelVisibleChanged(false);
 }
-
-bool SettingsUiController::isLocalProxySupported() const
-{
-    return m_settingsController->isLocalProxySupported();
-}
-
-bool SettingsUiController::isLocalProxyHttpEnabled() const
-{
-    return m_settingsController->isLocalProxyHttpEnabled();
-}
-
-int SettingsUiController::localProxyPort() const
-{
-    return m_settingsController->localProxyPort();
-}
-
-QString SettingsUiController::localProxyOwnerId() const
-{
-    return m_settingsController->localProxyOwnerId();
-}
-
-bool SettingsUiController::setLocalProxyPort(int port)
-{
-    return m_settingsController->setLocalProxyPort(port);
-}
-
-bool SettingsUiController::isLocalProxyPortBusy(int port) const
-{
-    return m_settingsController->isLocalProxyPortBusy(port);
-}
-
-bool SettingsUiController::isLocalProxyPortUserDefined() const
-{
-    return m_settingsController->isLocalProxyPortUserDefined();
-}
-
-int SettingsUiController::findFirstAvailableLocalProxyPort(int startPort) const
-{
-    return m_settingsController->findFirstAvailableLocalProxyPort(startPort);
-}
-
-bool SettingsUiController::enableLocalProxy(const QString &ownerId, int port)
-{
-    return m_settingsController->enableLocalProxy(ownerId, port);
-}
-
-void SettingsUiController::disableLocalProxy()
-{
-    m_settingsController->disableLocalProxy();
-}

client/ui/controllers/settingsUiController.h

@@ -5,8 +5,6 @@
 
 #include "core/controllers/settingsController.h"
 #include "core/controllers/serversController.h"
-#include "ui/controllers/languageUiController.h"
-#include "ui/models/languageModel.h"
 #include "core/utils/errorCodes.h"
 #include "core/utils/routeModes.h"
 #include "core/utils/commonStructs.h"
@@ -17,7 +15,6 @@ class SettingsUiController : public QObject
 public:
     explicit SettingsUiController(SettingsController* settingsController,
                                  ServersController* serversController,
-                                 LanguageUiController* languageUiController,
                                  QObject *parent = nullptr);
 
     Q_PROPERTY(QString primaryDns READ getPrimaryDns WRITE setPrimaryDns NOTIFY primaryDnsChanged)
@@ -32,11 +29,8 @@ public:
     Q_PROPERTY(bool isDevGatewayEnv READ isDevGatewayEnv WRITE toggleDevGatewayEnv NOTIFY devGatewayEnvChanged)
 
     Q_PROPERTY(bool isHomeAdLabelVisible READ isHomeAdLabelVisible NOTIFY isHomeAdLabelVisibleChanged)
+    Q_PROPERTY(bool autoStartEnabled READ isAutoStartEnabled NOTIFY autoStartChanged)
     Q_PROPERTY(bool startMinimized READ isStartMinimizedEnabled NOTIFY startMinimizedChanged)
-    Q_PROPERTY(bool isLocalProxySupported READ isLocalProxySupported CONSTANT)
-    Q_PROPERTY(bool isLocalProxyHttpEnabled READ isLocalProxyHttpEnabled NOTIFY localProxySettingsUpdated)
-    Q_PROPERTY(int localProxyPort READ localProxyPort WRITE setLocalProxyPort NOTIFY localProxySettingsUpdated)
-    Q_PROPERTY(QString localProxyOwnerId READ localProxyOwnerId NOTIFY localProxySettingsUpdated)
 
 public slots:
     void toggleAmneziaDns(bool enable);
@@ -107,17 +101,6 @@ public slots:
     bool isHomeAdLabelVisible();
     void disableHomeAdLabel();
 
-    bool isLocalProxySupported() const;
-    bool isLocalProxyHttpEnabled() const;
-    int localProxyPort() const;
-    QString localProxyOwnerId() const;
-    bool setLocalProxyPort(int port);
-    bool isLocalProxyPortBusy(int port) const;
-    bool isLocalProxyPortUserDefined() const;
-    int findFirstAvailableLocalProxyPort(int startPort) const;
-    bool enableLocalProxy(const QString &ownerId, int port);
-    void disableLocalProxy();
-
 signals:
     void primaryDnsChanged();
     void secondaryDnsChanged();
@@ -137,7 +120,7 @@ signals:
 
     void loggingDisableByWatcher();
 
-    void appLanguageChanged(const LanguageSettings::AvailableLanguageEnum language);
+    void appLanguageChanged();
     void resetLanguageToSystem();
 
     void onNotificationStateChanged();
@@ -150,14 +133,12 @@ signals:
     void activityResumed();
 
     void isHomeAdLabelVisibleChanged(bool visible);
+    void autoStartChanged();
     void startMinimizedChanged();
-    void localProxySettingsUpdated();
-    void localProxyStartFailed(const QString &message);
 
 private:
     SettingsController* m_settingsController;
     ServersController* m_serversController;
-    LanguageUiController* m_languageUiController;
 };
 
 #endif

client/ui/models/api/apiAccountInfoModel.cpp

@@ -30,7 +30,7 @@ QVariant ApiAccountInfoModel::data(const QModelIndex &index, int role) const
     switch (role) {
     case SubscriptionStatusRole: {
         if (m_accountInfoData.configType == serverConfigUtils::ConfigType::AmneziaFreeV3) {
-            return tr("Active");
+            return QStringLiteral("<p><a style=\"color: #28c840;\">%1</a>").arg(tr("Active"));
         }
 
         return apiUtils::isSubscriptionExpired(m_accountInfoData.subscriptionEndDate)

client/ui/models/clientManagementModel.cpp

@@ -27,6 +27,7 @@ QVariant ClientManagementModel::data(const QModelIndex &index, int role) const
     auto userData = client.value(configKey::userData).toObject();
 
     switch (role) {
+    case ClientIdRole: return client.value(configKey::clientId).toString();
     case ClientNameRole: return userData.value(configKey::clientName).toString();
     case CreationDateRole: return userData.value(configKey::creationDate).toString();
     case LatestHandshakeRole: return userData.value(configKey::latestHandshake).toString();
@@ -62,6 +63,7 @@ void ClientManagementModel::updateClientName(int row, const QString &newName)
 QHash<int, QByteArray> ClientManagementModel::roleNames() const
 {
     QHash<int, QByteArray> roles;
+    roles[ClientIdRole] = "clientId";
     roles[ClientNameRole] = "clientName";
     roles[CreationDateRole] = "creationDate";
     roles[LatestHandshakeRole] = "latestHandshake";

client/ui/models/clientManagementModel.h

@@ -10,7 +10,8 @@ class ClientManagementModel : public QAbstractListModel
 
 public:
     enum Roles {
-        ClientNameRole = Qt::UserRole + 1,
+        ClientIdRole = Qt::UserRole + 1,
+        ClientNameRole,
         CreationDateRole,
         LatestHandshakeRole,
         DataReceivedRole,

client/ui/models/containerProps.h

@@ -23,6 +23,10 @@ public:
     Q_INVOKABLE int containerFromString(const QString &container) const {
         return static_cast<int>(amnezia::ContainerUtils::containerFromString(container));
     }
+
+    Q_INVOKABLE bool isUnsupportedContainer(int containerIndex) const {
+        return amnezia::ContainerUtils::isUnsupportedContainer(static_cast<amnezia::DockerContainer>(containerIndex));
+    }
 };
 
 #endif // CONTAINERPROPS_H

client/ui/models/containersModel.cpp

@@ -67,6 +67,7 @@ QVariant ContainersModel::data(const QModelIndex &index, int role) const
     case IsCurrentlyProcessedRole: return container == static_cast<DockerContainer>(m_processedContainerIndex);
     case IsSupportedRole: return ContainerUtils::isSupportedByCurrentPlatform(container);
     case IsShareableRole: return ContainerUtils::isShareable(container);
+    case IsUnsupportedContainerRole: return ContainerUtils::isUnsupportedContainer(container);
     case IsVpnContainerRole: return ContainerUtils::containerService(container) == ServiceType::Vpn;
     case IsServiceContainerRole: return ContainerUtils::containerService(container) == ServiceType::Other;
     case IsIpsecRole: return container == DockerContainer::Ipsec;
@@ -142,7 +143,8 @@ bool ContainersModel::hasInstalledProtocols()
 
 bool ContainersModel::isInstallationAllowed(DockerContainer container)
 {
-    return container != DockerContainer::Awg;
+    return container != DockerContainer::Awg
+           && !ContainerUtils::isUnsupportedContainer(container);
 }
 
 void ContainersModel::openContainerSettings(int containerIndex)
@@ -176,6 +178,7 @@ QHash<int, QByteArray> ContainersModel::roleNames() const
     roles[IsCurrentlyProcessedRole] = "isCurrentlyProcessed";
     roles[IsSupportedRole] = "isSupported";
     roles[IsShareableRole] = "isShareable";
+    roles[IsUnsupportedContainerRole] = "isUnsupportedContainer";
     roles[IsInstallationAllowedRole] = "isInstallationAllowed";
     roles[InstallPageOrderRole] = "installPageOrder";
     

client/ui/models/containersModel.h

@@ -39,6 +39,8 @@ public:
         IsSupportedRole,
         IsShareableRole,
 
+        IsUnsupportedContainerRole,
+
         InstallPageOrderRole,
         
         // Container type check roles

client/ui/models/protocols/xrayConfigModel.cpp

@@ -4,6 +4,10 @@
 #include "core/protocols/protocolUtils.h"
 #include "core/utils/constants/configKeys.h"
 #include "core/utils/constants/protocolConstants.h"
+#include "core/utils/networkUtilities.h"
+
+#include <QHostAddress>
+#include <QRegularExpression>
 
 using namespace amnezia;
 using namespace ProtocolUtils;
@@ -272,7 +276,7 @@ void XrayConfigModel::updateModel(amnezia::DockerContainer container, const amne
     }
 
     if (!m_protocolConfig.serverConfig.isThirdPartyConfig) {
-        applyDefaultsToServerConfig(m_protocolConfig.serverConfig);
+        applyDefaultsToServerConfig(m_protocolConfig.serverConfig, false);
     }
 
     m_originalProtocolConfig = m_protocolConfig;
@@ -283,7 +287,7 @@ void XrayConfigModel::updateModel(amnezia::DockerContainer container, const amne
     }
 }
 
-void XrayConfigModel::applyDefaultsToServerConfig(amnezia::XrayServerConfig &config)
+void XrayConfigModel::applyDefaultsToServerConfig(amnezia::XrayServerConfig &config, bool fillFlowDefault)
 {
     if (config.port.isEmpty()) {
         config.port = protocols::xray::defaultPort;
@@ -306,7 +310,7 @@ void XrayConfigModel::applyDefaultsToServerConfig(amnezia::XrayServerConfig &con
         config.security = protocols::xray::defaultSecurity;
     }
 
-    if (config.flow.isEmpty()) {
+    if (fillFlowDefault && config.flow.isEmpty()) {
         config.flow = protocols::xray::defaultFlow;
     }
 
@@ -585,3 +589,87 @@ QString XrayConfigModel::mkcpDefaultWriteBufferSize()
 {
     return QString::fromLatin1(protocols::xray::defaultMkcpWriteBufferSize);
 }
+
+namespace {
+    bool isValidSingleHost(const QString &t)
+    {
+        if (t.isEmpty() || t.length() > 253) {
+            return false;
+        }
+        QHostAddress a(t);
+        if (a.protocol() == QHostAddress::IPv4Protocol) {
+            return NetworkUtilities::checkIPv4Format(t);
+        }
+        if (a.protocol() == QHostAddress::IPv6Protocol) {
+            return true;
+        }
+        static const QRegularExpression onlyDigits(QStringLiteral(R"(^\d+$)"));
+        if (onlyDigits.match(t).hasMatch()) {
+            return false;
+        }
+        QRegExp re = NetworkUtilities::domainRegExp();
+        re.setCaseSensitivity(Qt::CaseInsensitive);
+        return re.exactMatch(t);
+    }
+}
+
+bool XrayConfigModel::isValidHost(const QString &host)
+{
+    const QString t = host.trimmed();
+    if (t.isEmpty()) {
+        return true;
+    }
+    return isValidSingleHost(t);
+}
+
+bool XrayConfigModel::isValidSni(const QString &sni)
+{
+    const QString t = sni.trimmed();
+    if (t.isEmpty()) {
+        return true;
+    }
+    if (t.startsWith(QLatin1String("*."))) {
+        return isValidSingleHost(t.mid(2));
+    }
+    return isValidSingleHost(t);
+}
+
+bool XrayConfigModel::isValidPath(const QString &path)
+{
+    const QString t = path.trimmed();
+    if (t.isEmpty()) {
+        return true;
+    }
+    return t.startsWith(QLatin1Char('/'));
+}
+
+QStringList XrayConfigModel::validationErrors() const
+{
+    QStringList errs;
+    const auto &srv = m_protocolConfig.serverConfig;
+
+    if (!srv.port.isEmpty()) {
+        bool ok = false;
+        const int p = srv.port.toInt(&ok);
+        if (!ok || p < 1 || p > 65535) {
+            errs << tr("Port must be in the range of 1 to 65535");
+        }
+    }
+
+    if (srv.security == QLatin1String("tls") || srv.security == QLatin1String("reality")) {
+        if (!isValidSni(srv.sni)) {
+            errs << tr("SNI: enter a valid IP address or domain name");
+        }
+    }
+
+    if (srv.transport == QLatin1String("xhttp")) {
+        if (!isValidHost(srv.xhttp.host)) {
+            errs << tr("Host: enter a valid IP address or domain name");
+        }
+        if (!isValidPath(srv.xhttp.path)) {
+            errs << tr("Path must start with \"/\"");
+        }
+    }
+
+    return errs;
+}

client/ui/models/protocols/xrayConfigModel.h

@@ -118,6 +118,11 @@ public:
     Q_INVOKABLE static QString mkcpDefaultReadBufferSize();
     Q_INVOKABLE static QString mkcpDefaultWriteBufferSize();
 
+    Q_INVOKABLE static bool isValidHost(const QString &host);
+    Q_INVOKABLE static bool isValidSni(const QString &sni);
+    Q_INVOKABLE static bool isValidPath(const QString &path);
+    Q_INVOKABLE QStringList validationErrors() const;
+
 public slots:
     void updateModel(amnezia::DockerContainer container, const amnezia::XrayProtocolConfig& protocolConfig);
     amnezia::XrayProtocolConfig getProtocolConfig();
@@ -137,7 +142,7 @@ private:
     amnezia::XrayProtocolConfig m_protocolConfig;
     amnezia::XrayProtocolConfig m_originalProtocolConfig;
 
-    void applyDefaultsToServerConfig(amnezia::XrayServerConfig& config);
+    void applyDefaultsToServerConfig(amnezia::XrayServerConfig& config, bool fillFlowDefault = true);
 };
 
 #endif // XRAYCONFIGMODEL_H

client/ui/models/serversModel.cpp

@@ -152,3 +152,4 @@ ServerCredentials ServersModel::serverCredentials(int index) const
     }
     return m_descriptions.at(index).selfHostedSshCredentials;
 }
+

client/ui/models/serversModel.h

@@ -10,7 +10,6 @@
 class ServersModel : public QAbstractListModel
 {
     Q_OBJECT
-
 public:
     enum Roles {
         NameRole = Qt::UserRole + 1,

client/ui/qml/Components/HomeContainersListView.qml

@@ -56,14 +56,17 @@ ListViewType {
                         return
                     }
 
-                    if (checked) {
-                        containersDropDown.closeTriggered()
-                        ServersUiController.setDefaultContainer(ServersUiController.defaultServerId, proxyDefaultServerContainersModel.mapToSource(index))
-                    } else {
-                        ServersUiController.processedContainerIndex = proxyDefaultServerContainersModel.mapToSource(index)
+                    var containerIndex = proxyDefaultServerContainersModel.mapToSource(index)
+
+                    if (!isInstalled) {
+                        ServersUiController.processedContainerIndex = containerIndex
                         PageController.goToPage(PageEnum.PageSetupWizardProtocolSettings)
                         containersDropDown.closeTriggered()
+                        return
                     }
+
+                    containersDropDown.closeTriggered()
+                    ServersUiController.setDefaultContainer(ServersUiController.defaultServerId, containerIndex)
                 }
 
                 MouseArea {

client/ui/qml/Components/SettingsContainersListView.qml

@@ -5,7 +5,6 @@ import QtQuick.Layouts
 import SortFilterProxyModel 0.2
 
 import PageEnum 1.0
-import ContainerProps 1.0
 
 import "../Controls2"
 import "../Controls2/TextTypes"

client/ui/qml/Controls2/BaseHeaderType.qml

@@ -12,7 +12,6 @@ Item {
     property int headerTextMaximumLineCount: 2
     property int headerTextElide: Qt.ElideRight
     property string descriptionText
-    property string descriptionColor: AmneziaStyle.color.mutedGray
     property string descriptionLinkText
     property string descriptionLinkUrl
     property alias headerRow: headerRow
@@ -43,7 +42,7 @@ Item {
             Layout.topMargin: 16
             Layout.fillWidth: true
             text: root.descriptionText
-            color: root.descriptionColor
+            color: AmneziaStyle.color.mutedGray
             visible: root.descriptionText !== ""
         }