Merge branch 'dev' of github.com:amnezia-vpn/amnezia-client into feature/download-native-wireguard-config-on-connect

connect

.github/workflows/deploy.yml

@@ -68,15 +68,6 @@ jobs:
       BUILD_ARCH: 64
 
     steps:
-    - name: 'Get sources'
-      uses: actions/checkout@v3
-      with:
-        submodules: 'true'
-        fetch-depth: 10
-
-    - name: 'Setup ccache'
-      uses: hendrikmuhs/ccache-action@v1.2
-
     - name: 'Install Qt'
       uses: jurplel/install-qt-action@v3
       with:
@@ -96,6 +87,15 @@ jobs:
       with:
         arch: 'x64'
 
+    - name: 'Get sources'
+      uses: actions/checkout@v3
+      with:
+        submodules: 'true'
+        fetch-depth: 10
+
+    - name: 'Setup ccache'
+      uses: hendrikmuhs/ccache-action@v1.2
+
     - name: 'Build project'
       shell: cmd
       run: |

client/CMakeLists.txt

@@ -31,7 +31,7 @@ set_property(GLOBAL PROPERTY PREDEFINED_TARGETS_FOLDER "Autogen")
 find_package(Qt6 REQUIRED COMPONENTS 
     Widgets Core Gui Network Xml 
     RemoteObjects Quick Svg QuickControls2 
-    Core5Compat Concurrent
+    Core5Compat Concurrent LinguistTools
 )
 set(LIBS ${LIBS} 
     Qt6::Widgets Qt6::Core Qt6::Gui
@@ -47,13 +47,11 @@ if(IOS)
         WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR})
 endif()
 
-set(IS_CI ${CI})
+find_program(CCACHE_FOUND ccache)
-if(IS_CI)
+if(CCACHE_FOUND)
-    message("Detected CI env")
+    message("found ccache")
-    find_program(CCACHE "ccache")
+    set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ccache)
-    if(CCACHE)
+    set_property(GLOBAL PROPERTY RULE_LAUNCH_LINK ccache)
-        set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE "${CCACHE}")
-    endif()
 endif()
 
 include(${CMAKE_CURRENT_LIST_DIR}/cmake/3rdparty.cmake)

client/cmake/3rdparty.cmake

@@ -100,6 +100,7 @@ add_subdirectory(${CLIENT_ROOT_DIR}/3rd/libssh)
 add_compile_definitions(_WINSOCKAPI_)
 set(LIBS ${LIBS} ssh)
 
+set(BUILD_TRANSLATIONS OFF CACHE BOOL "" FORCE)
 set(BUILD_SHARED_LIBS OFF CACHE BOOL "" FORCE)
 set(BUILD_WITH_QT6 ON)
 add_subdirectory(${CLIENT_ROOT_DIR}/3rd/qtkeychain)

client/configurators/cloak_configurator.cpp

@@ -13,22 +13,20 @@ CloakConfigurator::CloakConfigurator(std::shared_ptr<Settings> settings, QObject
 
 }
 
-QString CloakConfigurator::genCloakConfig(const ServerCredentials &credentials,
+QString CloakConfigurator::genCloakConfig(const ServerCredentials &credentials, DockerContainer container,
-    DockerContainer container, const QJsonObject &containerConfig, ErrorCode *errorCode)
+                                          const QJsonObject &containerConfig, ErrorCode &errorCode)
 {
-    ErrorCode e = ErrorCode::NoError;
     ServerController serverController(m_settings);
 
     QString cloakPublicKey = serverController.getTextFileFromContainer(container, credentials,
-        amnezia::protocols::cloak::ckPublicKeyPath, &e);
+        amnezia::protocols::cloak::ckPublicKeyPath, errorCode);
     cloakPublicKey.replace("\n", "");
 
     QString cloakBypassUid = serverController.getTextFileFromContainer(container, credentials,
-        amnezia::protocols::cloak::ckBypassUidKeyPath, &e);
+        amnezia::protocols::cloak::ckBypassUidKeyPath, errorCode);
     cloakBypassUid.replace("\n", "");
 
-    if (e) {
+    if (errorCode) {
-        if (errorCode) *errorCode = e;
         return "";
     }
 

client/configurators/cloak_configurator.h

@@ -14,7 +14,7 @@ public:
     CloakConfigurator(std::shared_ptr<Settings> settings, QObject *parent = nullptr);
 
     QString genCloakConfig(const ServerCredentials &credentials, DockerContainer container,
-        const QJsonObject &containerConfig, ErrorCode *errorCode = nullptr);
+                           const QJsonObject &containerConfig, ErrorCode &errorCode);
 };
 
 #endif // CLOAK_CONFIGURATOR_H

client/configurators/ikev2_configurator.cpp

@@ -22,7 +22,7 @@ Ikev2Configurator::Ikev2Configurator(std::shared_ptr<Settings> settings, QObject
 }
 
 Ikev2Configurator::ConnectionData Ikev2Configurator::prepareIkev2Config(const ServerCredentials &credentials,
-    DockerContainer container, ErrorCode *errorCode)
+                                                                        DockerContainer container, ErrorCode &errorCode)
 {
     Ikev2Configurator::ConnectionData connData;
     connData.host = credentials.hostName;
@@ -42,16 +42,16 @@ Ikev2Configurator::ConnectionData Ikev2Configurator::prepareIkev2Config(const Se
             .arg(connData.clientId);
 
     ServerController serverController(m_settings);
-    ErrorCode e = serverController.runContainerScript(credentials, container, scriptCreateCert);
+    errorCode = serverController.runContainerScript(credentials, container, scriptCreateCert);
 
     QString scriptExportCert = QString("pk12util -W \"%1\" -d sql:/etc/ipsec.d -n \"%2\" -o \"%3\"")
             .arg(connData.password)
             .arg(connData.clientId)
             .arg(certFileName);
-    e = serverController.runContainerScript(credentials, container, scriptExportCert);
+    errorCode = serverController.runContainerScript(credentials, container, scriptExportCert);
 
-    connData.clientCert = serverController.getTextFileFromContainer(container, credentials, certFileName, &e);
+    connData.clientCert = serverController.getTextFileFromContainer(container, credentials, certFileName, errorCode);
-    connData.caCert = serverController.getTextFileFromContainer(container, credentials, "/etc/ipsec.d/ca_cert_base64.p12", &e);
+    connData.caCert = serverController.getTextFileFromContainer(container, credentials, "/etc/ipsec.d/ca_cert_base64.p12", errorCode);
 
     qDebug() << "Ikev2Configurator::ConnectionData client cert size:" << connData.clientCert.size();
     qDebug() << "Ikev2Configurator::ConnectionData ca cert size:" << connData.caCert.size();
@@ -60,12 +60,12 @@ Ikev2Configurator::ConnectionData Ikev2Configurator::prepareIkev2Config(const Se
 }
 
 QString Ikev2Configurator::genIkev2Config(const ServerCredentials &credentials,
-    DockerContainer container, const QJsonObject &containerConfig, ErrorCode *errorCode)
+    DockerContainer container, const QJsonObject &containerConfig, ErrorCode &errorCode)
 {
     Q_UNUSED(containerConfig)
 
     ConnectionData connData = prepareIkev2Config(credentials, container, errorCode);
-    if (errorCode && *errorCode) {
+    if (errorCode) {
         return "";
     }
 

client/configurators/ikev2_configurator.h

@@ -22,14 +22,13 @@ public:
     };
 
     QString genIkev2Config(const ServerCredentials &credentials, DockerContainer container,
-        const QJsonObject &containerConfig, ErrorCode *errorCode = nullptr);
+                           const QJsonObject &containerConfig, ErrorCode &errorCode);
 
     QString genIkev2Config(const ConnectionData &connData);
     QString genMobileConfig(const ConnectionData &connData);
     QString genStrongSwanConfig(const ConnectionData &connData);
 
-    ConnectionData prepareIkev2Config(const ServerCredentials &credentials,
+    ConnectionData prepareIkev2Config(const ServerCredentials &credentials, DockerContainer container, ErrorCode &errorCode);
-        DockerContainer container, ErrorCode *errorCode = nullptr);
 };
 
 #endif // IKEV2_CONFIGURATOR_H

client/configurators/openvpn_configurator.cpp

@@ -26,13 +26,13 @@ OpenVpnConfigurator::OpenVpnConfigurator(std::shared_ptr<Settings> settings, QOb
 }
 
 OpenVpnConfigurator::ConnectionData OpenVpnConfigurator::prepareOpenVpnConfig(const ServerCredentials &credentials,
-    DockerContainer container, ErrorCode *errorCode)
+                                                                              DockerContainer container, ErrorCode &errorCode)
 {
     OpenVpnConfigurator::ConnectionData connData = OpenVpnConfigurator::createCertRequest();
     connData.host = credentials.hostName;
 
     if (connData.privKey.isEmpty() || connData.request.isEmpty()) {
-        if (errorCode) *errorCode = ErrorCode::OpenSslFailed;
+        errorCode = ErrorCode::OpenSslFailed;
         return connData;
     }
 
@@ -41,45 +41,44 @@ OpenVpnConfigurator::ConnectionData OpenVpnConfigurator::prepareOpenVpnConfig(co
             arg(connData.clientId);
 
     ServerController serverController(m_settings);
-    ErrorCode e = serverController.uploadTextFileToContainer(container, credentials, connData.request, reqFileName);
+    errorCode = serverController.uploadTextFileToContainer(container, credentials, connData.request, reqFileName);
-    if (e) {
+    if (errorCode) {
-        if (errorCode) *errorCode = e;
         return connData;
     }
 
-    e = signCert(container, credentials, connData.clientId);
+    errorCode = signCert(container, credentials, connData.clientId);
-    if (e) {
+    if (errorCode) {
-        if (errorCode) *errorCode = e;
         return connData;
     }
 
-    connData.caCert = serverController.getTextFileFromContainer(container, credentials, amnezia::protocols::openvpn::caCertPath, &e);
+    connData.caCert = serverController.getTextFileFromContainer(container, credentials,
+    															amnezia::protocols::openvpn::caCertPath, errorCode);
     connData.clientCert = serverController.getTextFileFromContainer(container, credentials,
-        QString("%1/%2.crt").arg(amnezia::protocols::openvpn::clientCertPath).arg(connData.clientId), &e);
+        QString("%1/%2.crt").arg(amnezia::protocols::openvpn::clientCertPath).arg(connData.clientId), errorCode);
 
-    if (e) {
+
-        if (errorCode) *errorCode = e;
+    if (errorCode) {
         return connData;
     }
 
-    connData.taKey = serverController.getTextFileFromContainer(container, credentials, amnezia::protocols::openvpn::taKeyPath, &e);
+    connData.taKey = serverController.getTextFileFromContainer(container, credentials, amnezia::protocols::openvpn::taKeyPath, errorCode);
 
     if (connData.caCert.isEmpty() || connData.clientCert.isEmpty() || connData.taKey.isEmpty()) {
-        if (errorCode) *errorCode = ErrorCode::SshSftpFailureError;
+        errorCode = ErrorCode::SshSftpFailureError;
     }
 
     return connData;
 }
 
 QString OpenVpnConfigurator::genOpenVpnConfig(const ServerCredentials &credentials,
-    DockerContainer container, const QJsonObject &containerConfig, ErrorCode *errorCode)
+    DockerContainer container, const QJsonObject &containerConfig, ErrorCode &errorCode)
 {
     ServerController serverController(m_settings);
     QString config = serverController.replaceVars(amnezia::scriptData(ProtocolScriptType::openvpn_template, container),
             serverController.genVarsForScript(credentials, container, containerConfig));
 
     ConnectionData connData = prepareOpenVpnConfig(credentials, container, errorCode);
-    if (errorCode && *errorCode) {
+    if (errorCode) {
         return "";
     }
 

client/configurators/openvpn_configurator.h

@@ -24,7 +24,7 @@ public:
     };
 
     QString genOpenVpnConfig(const ServerCredentials &credentials, DockerContainer container,
-        const QJsonObject &containerConfig, ErrorCode *errorCode = nullptr);
+        const QJsonObject &containerConfig, ErrorCode &errorCode);
 
     QString processConfigWithLocalSettings(QString jsonConfig);
     QString processConfigWithExportSettings(QString jsonConfig);
@@ -36,7 +36,7 @@ private:
     ConnectionData createCertRequest();
 
     ConnectionData prepareOpenVpnConfig(const ServerCredentials &credentials,
-        DockerContainer container, ErrorCode *errorCode = nullptr);
+        DockerContainer container, ErrorCode &errorCode);
 
 };
 

client/configurators/shadowsocks_configurator.cpp

@@ -13,18 +13,16 @@ ShadowSocksConfigurator::ShadowSocksConfigurator(std::shared_ptr<Settings> setti
 
 }
 
-QString ShadowSocksConfigurator::genShadowSocksConfig(const ServerCredentials &credentials,
+QString ShadowSocksConfigurator::genShadowSocksConfig(const ServerCredentials &credentials, DockerContainer container,
-    DockerContainer container, const QJsonObject &containerConfig, ErrorCode *errorCode)
+                                                      const QJsonObject &containerConfig, ErrorCode &errorCode)
 {
-    ErrorCode e = ErrorCode::NoError;
     ServerController serverController(m_settings);
 
     QString ssKey = serverController.getTextFileFromContainer(container, credentials,
-                                                              amnezia::protocols::shadowsocks::ssKeyPath, &e);
+                                                              amnezia::protocols::shadowsocks::ssKeyPath, errorCode);
     ssKey.replace("\n", "");
 
-    if (e) {
+    if (errorCode) {
-        if (errorCode) *errorCode = e;
         return "";
     }
 

client/configurators/shadowsocks_configurator.h

@@ -13,7 +13,7 @@ public:
     ShadowSocksConfigurator(std::shared_ptr<Settings> settings, QObject *parent = nullptr);
 
     QString genShadowSocksConfig(const ServerCredentials &credentials, DockerContainer container,
-        const QJsonObject &containerConfig, ErrorCode *errorCode = nullptr);
+                                 const QJsonObject &containerConfig, ErrorCode &errorCode);
 };
 
 #endif // SHADOWSOCKS_CONFIGURATOR_H

client/configurators/vpn_configurator.cpp

@@ -25,8 +25,8 @@ VpnConfigurator::VpnConfigurator(std::shared_ptr<Settings> settings, QObject *pa
     sshConfigurator = std::shared_ptr<SshConfigurator>(new SshConfigurator(settings, this));
 }
 
-QString VpnConfigurator::genVpnProtocolConfig(const ServerCredentials &credentials,
+QString VpnConfigurator::genVpnProtocolConfig(const ServerCredentials &credentials, DockerContainer container,
-    DockerContainer container, const QJsonObject &containerConfig, Proto proto, ErrorCode *errorCode)
+                                              const QJsonObject &containerConfig, Proto proto, ErrorCode &errorCode)
 {
     switch (proto) {
     case Proto::OpenVpn:
@@ -49,6 +49,25 @@ QString VpnConfigurator::genVpnProtocolConfig(const ServerCredentials &credentia
     }
 }
 
+ErrorCode VpnConfigurator::processLastConfigWithRemoteSettings(QMap<Proto, QString> &lastVpnConfigs,
+                                                               const int serverIndex, const Proto proto)
+{
+    switch (proto) {
+    case Proto::OpenVpn:
+        return ErrorCode::NotImplementedError;
+    case Proto::ShadowSocks:
+        return ErrorCode::NotImplementedError;
+    case Proto::Cloak:
+        return ErrorCode::NotImplementedError;
+    case Proto::WireGuard:
+        return wireguardConfigurator->processLastConfigWithRemoteSettings(lastVpnConfigs, serverIndex);
+    case Proto::Ikev2:
+        return ErrorCode::NotImplementedError;
+    default:
+        return ErrorCode::ConfigMissing;
+    }
+}
+
 QPair<QString, QString> VpnConfigurator::getDnsForConfig(int serverIndex)
 {
     QPair<QString, QString> dns;

client/configurators/vpn_configurator.h

@@ -22,17 +22,17 @@ public:
     VpnConfigurator(std::shared_ptr<Settings> settings, QObject *parent = nullptr);
 
     QString genVpnProtocolConfig(const ServerCredentials &credentials, DockerContainer container,
-        const QJsonObject &containerConfig, Proto proto, ErrorCode *errorCode = nullptr);
+                                 const QJsonObject &containerConfig, Proto proto, ErrorCode &errorCode);
 
     QPair<QString, QString> getDnsForConfig(int serverIndex);
     QString &processConfigWithDnsSettings(int serverIndex, DockerContainer container, Proto proto, QString &config);
 
     QString &processConfigWithLocalSettings(int serverIndex, DockerContainer container, Proto proto, QString &config);
     QString &processConfigWithExportSettings(int serverIndex, DockerContainer container, Proto proto, QString &config);
+    ErrorCode processLastConfigWithRemoteSettings(QMap<Proto, QString> &lastVpnConfigs, const int serverIndex, const Proto proto);
 
     // workaround for containers which is not support normal configaration
-    void updateContainerConfigAfterInstallation(DockerContainer container,
+    void updateContainerConfigAfterInstallation(DockerContainer container, QJsonObject &containerConfig, const QString &stdOut);
-        QJsonObject &containerConfig, const QString &stdOut);
 
     std::shared_ptr<OpenVpnConfigurator> openVpnConfigurator;
     std::shared_ptr<ShadowSocksConfigurator> shadowSocksConfigurator;

client/configurators/wireguard_configurator.cpp

@@ -6,7 +6,8 @@
 #include <QDebug>
 #include <QTemporaryFile>
 #include <QJsonDocument>
-
+#include <QNetworkAccessManager>
+#include <QNetworkReply>
 
 #include <openssl/rand.h>
 #include <openssl/rsa.h>
@@ -59,17 +60,16 @@ WireguardConfigurator::ConnectionData WireguardConfigurator::genClientKeys()
 }
 
 WireguardConfigurator::ConnectionData WireguardConfigurator::prepareWireguardConfig(const ServerCredentials &credentials,
-    DockerContainer container, const QJsonObject &containerConfig, ErrorCode *errorCode)
+    DockerContainer container, const QJsonObject &containerConfig, ErrorCode &errorCode)
 {
     WireguardConfigurator::ConnectionData connData = WireguardConfigurator::genClientKeys();
     connData.host = credentials.hostName;
 
     if (connData.clientPrivKey.isEmpty() || connData.clientPubKey.isEmpty()) {
-        if (errorCode) *errorCode = ErrorCode::InternalError;
+        errorCode = ErrorCode::InternalError;
         return connData;
     }
 
-    ErrorCode e = ErrorCode::NoError;
     ServerController serverController(m_settings);
 
     // Get list of already created clients (only IP addreses)
@@ -82,9 +82,8 @@ WireguardConfigurator::ConnectionData WireguardConfigurator::prepareWireguardCon
             return ErrorCode::NoError;
         };
 
-        e = serverController.runContainerScript(credentials, container, script, cbReadStdOut);
+        errorCode = serverController.runContainerScript(credentials, container, script, cbReadStdOut);
-        if (errorCode && e) {
+        if (errorCode) {
-            *errorCode = e;
             return connData;
         }
 
@@ -99,7 +98,7 @@ WireguardConfigurator::ConnectionData WireguardConfigurator::prepareWireguardCon
         else {
             int next = ips.last().split(".").last().toInt() + 1;
             if (next > 254) {
-                if (errorCode) *errorCode = ErrorCode::AddressPoolError;
+                errorCode = ErrorCode::AddressPoolError;
                 return connData;
             }
             nextIpNumber = QString::number(next);
@@ -110,7 +109,7 @@ WireguardConfigurator::ConnectionData WireguardConfigurator::prepareWireguardCon
     {
         QStringList l = subnetIp.split(".", Qt::SkipEmptyParts);
         if (l.isEmpty()) {
-            if (errorCode) *errorCode = ErrorCode::AddressPoolError;
+            errorCode = ErrorCode::AddressPoolError;
             return connData;
         }
         l.removeLast();
@@ -120,18 +119,16 @@ WireguardConfigurator::ConnectionData WireguardConfigurator::prepareWireguardCon
     }
 
     // Get keys
-    connData.serverPubKey = serverController.getTextFileFromContainer(container, credentials, amnezia::protocols::wireguard::serverPublicKeyPath, &e);
+    connData.serverPubKey = serverController.getTextFileFromContainer(container, credentials, amnezia::protocols::wireguard::serverPublicKeyPath, errorCode);
     connData.serverPubKey.replace("\n", "");
-    if (e) {
+    if (errorCode) {
-        if (errorCode) *errorCode = e;
         return connData;
     }
 
-    connData.pskKey = serverController.getTextFileFromContainer(container, credentials, amnezia::protocols::wireguard::serverPskKeyPath, &e);
+    connData.pskKey = serverController.getTextFileFromContainer(container, credentials, amnezia::protocols::wireguard::serverPskKeyPath, errorCode);
     connData.pskKey.replace("\n", "");
 
-    if (e) {
+    if (errorCode) {
-        if (errorCode) *errorCode = e;
         return connData;
     }
 
@@ -145,15 +142,15 @@ WireguardConfigurator::ConnectionData WireguardConfigurator::prepareWireguardCon
             arg(connData.pskKey).
             arg(connData.clientIP);
 
-    e = serverController.uploadTextFileToContainer(container, credentials, configPart,
+    errorCode = serverController.uploadTextFileToContainer(container, credentials, configPart,
         protocols::wireguard::serverConfigPath, libssh::SftpOverwriteMode::SftpAppendToExisting);
 
-    if (e) {
+
-        if (errorCode) *errorCode = e;
+    if (errorCode) {
         return connData;
     }
 
-    e = serverController.runScript(credentials,
+    errorCode = serverController.runScript(credentials,
         serverController.replaceVars("sudo docker exec -i $CONTAINER_NAME bash -c 'wg syncconf wg0 <(wg-quick strip /opt/amnezia/wireguard/wg0.conf)'",
             serverController.genVarsForScript(credentials, container)));
 
@@ -161,14 +158,14 @@ WireguardConfigurator::ConnectionData WireguardConfigurator::prepareWireguardCon
 }
 
 QString WireguardConfigurator::genWireguardConfig(const ServerCredentials &credentials,
-    DockerContainer container, const QJsonObject &containerConfig, ErrorCode *errorCode)
+    DockerContainer container, const QJsonObject &containerConfig, ErrorCode &errorCode)
 {
     ServerController serverController(m_settings);
     QString config = serverController.replaceVars(amnezia::scriptData(ProtocolScriptType::wireguard_template, container),
                                                   serverController.genVarsForScript(credentials, container, containerConfig));
 
     ConnectionData connData = prepareWireguardConfig(credentials, container, containerConfig, errorCode);
-    if (errorCode && *errorCode) {
+    if (errorCode) {
         return "";
     }
 
@@ -209,3 +206,49 @@ QString WireguardConfigurator::processConfigWithExportSettings(QString config)
 
     return config;
 }
+
+ErrorCode WireguardConfigurator::processLastConfigWithRemoteSettings(QMap<Proto, QString> &lastVpnConfigs, const int serverIndex)
+{
+    QString allowedIps;
+    ErrorCode errorCode = ErrorCode::NoError;
+    QNetworkAccessManager manager;
+    QObject::connect(&manager, &QNetworkAccessManager::finished, this, [this, &allowedIps, &errorCode](QNetworkReply *reply) {
+        if (reply->error()) {
+            qDebug() << reply->errorString();
+            errorCode = ErrorCode::InternalError;
+            emit remoteProcessingFinished();
+            return;
+        }
+
+        allowedIps = reply->readAll();
+        emit remoteProcessingFinished();
+    });
+    QNetworkRequest request;
+    const QJsonObject serverSettings = m_settings->server(serverIndex);
+    request.setUrl(serverSettings.value(config_key::nativeConfigParametrsStorage).toString());
+    manager.get(request);
+
+    QEventLoop wait;
+    QObject::connect(this, &WireguardConfigurator::remoteProcessingFinished, &wait, &QEventLoop::quit);
+    wait.exec();
+
+    if (errorCode == ErrorCode::NoError) {
+        allowedIps = allowedIps.trimmed();
+        QString config = lastVpnConfigs.value(Proto::WireGuard);
+        QJsonObject lastConfigJson = QJsonDocument::fromJson(config.toUtf8()).object();
+        QStringList configLines = lastConfigJson.value(config_key::config).toString().split("\n");
+
+        for (auto &line : configLines) {
+            if (line.contains("AllowedIPs")) {
+                line = allowedIps;
+            }
+        }
+
+        QJsonObject newConfigJson;
+        newConfigJson[config_key::config] = configLines.join("\n");
+        lastVpnConfigs[Proto::WireGuard] = QString(QJsonDocument(newConfigJson).toJson());;
+
+        return ErrorCode::NoError;
+    }
+    return errorCode;
+}

client/configurators/wireguard_configurator.h

@@ -7,7 +7,7 @@
 #include "configurator_base.h"
 #include "core/defs.h"
 
-class WireguardConfigurator : ConfiguratorBase
+class WireguardConfigurator : public ConfiguratorBase
 {
     Q_OBJECT
 public:
@@ -23,17 +23,22 @@ public:
     };
 
     QString genWireguardConfig(const ServerCredentials &credentials, DockerContainer container,
-        const QJsonObject &containerConfig, ErrorCode *errorCode = nullptr);
+                               const QJsonObject &containerConfig, ErrorCode &errorCode);
 
     QString processConfigWithLocalSettings(QString config);
     QString processConfigWithExportSettings(QString config);
+    ErrorCode processLastConfigWithRemoteSettings(QMap<Proto, QString> &lastVpnConfigs, const int serverIndex);
 
 
 private:
     ConnectionData prepareWireguardConfig(const ServerCredentials &credentials,
-        DockerContainer container, const QJsonObject &containerConfig, ErrorCode *errorCode = nullptr);
+                                          DockerContainer container, const QJsonObject &containerConfig,
+                                          ErrorCode &errorCode);
 
     ConnectionData genClientKeys();
+
+signals:
+    void remoteProcessingFinished();
 };
 
 #endif // WIREGUARD_CONFIGURATOR_H

client/core/servercontroller.cpp

@@ -178,10 +178,9 @@ ErrorCode ServerController::uploadTextFileToContainer(DockerContainer container,
 }
 
 QByteArray ServerController::getTextFileFromContainer(DockerContainer container,
-    const ServerCredentials &credentials, const QString &path, ErrorCode *errorCode)
+    const ServerCredentials &credentials, const QString &path, ErrorCode &errorCode)
 {
-
+    errorCode = ErrorCode::NoError;
-    if (errorCode) *errorCode = ErrorCode::NoError;
 
     QString script = QString("sudo docker exec -i %1 sh -c \"xxd -p \'%2\'\"").
             arg(ContainerProps::containerToString(container)).arg(path);
@@ -193,7 +192,7 @@ QByteArray ServerController::getTextFileFromContainer(DockerContainer container,
         return ErrorCode::NoError;
     };
 
-    *errorCode = runScript(credentials, script, cbReadStdOut);
+    errorCode = runScript(credentials, script, cbReadStdOut);
 
     qDebug().noquote() << "Copy file from container stdout : \n" << stdOut;
 
@@ -580,7 +579,7 @@ ServerController::Vars ServerController::genVarsForScript(const ServerCredential
     return vars;
 }
 
-QString ServerController::checkSshConnection(const ServerCredentials &credentials, ErrorCode *errorCode)
+QString ServerController::checkSshConnection(const ServerCredentials &credentials, ErrorCode &errorCode)
 {
     QString stdOut;
     auto cbReadStdOut = [&](const QString &data, libssh::Client &) {
@@ -592,10 +591,7 @@ QString ServerController::checkSshConnection(const ServerCredentials &credential
         return ErrorCode::NoError;
     };
 
-    ErrorCode e = runScript(credentials,
+    errorCode = runScript(credentials, amnezia::scriptData(SharedScriptType::check_connection), cbReadStdOut, cbReadStdErr);
-        amnezia::scriptData(SharedScriptType::check_connection), cbReadStdOut, cbReadStdErr);
-
-    if (errorCode) *errorCode = e;
 
     return stdOut;
 }

client/core/servercontroller.h

@@ -38,7 +38,7 @@ public:
                                         libssh::SftpOverwriteMode overwriteMode = libssh::SftpOverwriteMode::SftpOverwriteExisting);
 
     QByteArray getTextFileFromContainer(DockerContainer container, const ServerCredentials &credentials,
-                                        const QString &path, ErrorCode *errorCode = nullptr);
+                                        const QString &path, ErrorCode &errorCode);
 
     QString replaceVars(const QString &script, const Vars &vars);
     Vars genVarsForScript(const ServerCredentials &credentials, DockerContainer container = DockerContainer::None, const QJsonObject &config = QJsonObject());
@@ -51,7 +51,7 @@ public:
         const std::function<ErrorCode (const QString &, libssh::Client &)> &cbReadStdOut = nullptr,
         const std::function<ErrorCode (const QString &, libssh::Client &)> &cbReadStdErr = nullptr);
 
-    QString checkSshConnection(const ServerCredentials &credentials, ErrorCode *errorCode = nullptr);
+    QString checkSshConnection(const ServerCredentials &credentials, ErrorCode &errorCode);
 
     void setCancelInstallation(const bool cancel);
 

client/protocols/protocols_defs.h

@@ -64,6 +64,8 @@ constexpr char isThirdPartyConfig[] = "isThirdPartyConfig";
 constexpr char openvpn[] = "openvpn";
 constexpr char wireguard[] = "wireguard";
 
+constexpr char nativeConfigParametrsStorage[] = "nativeConfigParametrsStorage";
+
 }
 
 namespace protocols {

client/ui/pages_logic/ShareConnectionLogic.cpp

@@ -80,12 +80,12 @@ void ShareConnectionLogic::onPushButtonShareAmneziaGenerateClicked()
         QJsonObject containerConfig = m_settings->containerConfig(serverIndex, container);
         containerConfig.insert(config_key::container, ContainerProps::containerToString(container));
 
-        ErrorCode e = ErrorCode::NoError;
+        ErrorCode errorCode = ErrorCode::NoError;
         for (Proto p: ContainerProps::protocolsForContainer(container)) {
             QJsonObject protoConfig = m_settings->protocolConfig(serverIndex, container, p);
 
-            QString cfg = m_configurator->genVpnProtocolConfig(credentials, container, containerConfig, p, &e);
+            QString cfg = m_configurator->genVpnProtocolConfig(credentials, container, containerConfig, p, errorCode);
-            if (e) {
+            if (errorCode) {
                 cfg = "Error generating config";
                 break;
             }
@@ -94,7 +94,7 @@ void ShareConnectionLogic::onPushButtonShareAmneziaGenerateClicked()
         }
 
         QByteArray ba;
-        if (!e) {
+        if (!errorCode) {
             serverConfig = m_settings->server(serverIndex);
             serverConfig.remove(config_key::userName);
             serverConfig.remove(config_key::password);
@@ -132,8 +132,8 @@ void ShareConnectionLogic::onPushButtonShareOpenVpnGenerateClicked()
 
     const QJsonObject &containerConfig = m_settings->containerConfig(serverIndex, container);
 
-    ErrorCode e = ErrorCode::NoError;
+    ErrorCode errorCode = ErrorCode::NoError;
-    QString cfg = m_configurator->openVpnConfigurator->genOpenVpnConfig(credentials, container, containerConfig, &e);
+    QString cfg = m_configurator->openVpnConfigurator->genOpenVpnConfig(credentials, container, containerConfig, errorCode);
     cfg = m_configurator->processConfigWithExportSettings(serverIndex, container, Proto::OpenVpn, cfg);
 
     set_textEditShareOpenVpnCodeText(QJsonDocument::fromJson(cfg.toUtf8()).object()[config_key::config].toString());
@@ -151,8 +151,8 @@ void ShareConnectionLogic::onPushButtonShareShadowSocksGenerateClicked()
     if (cfg.isEmpty()) {
         const QJsonObject &containerConfig = m_settings->containerConfig(serverIndex, container);
 
-        ErrorCode e = ErrorCode::NoError;
+        ErrorCode errorCode = ErrorCode::NoError;
-        cfg = m_configurator->shadowSocksConfigurator->genShadowSocksConfig(credentials, container, containerConfig, &e);
+        cfg = m_configurator->shadowSocksConfigurator->genShadowSocksConfig(credentials, container, containerConfig, errorCode);
     }
 
     QJsonObject ssConfig = QJsonDocument::fromJson(cfg.toUtf8()).object();
@@ -195,8 +195,8 @@ void ShareConnectionLogic::onPushButtonShareCloakGenerateClicked()
     if (cfg.isEmpty()) {
         const QJsonObject &containerConfig = m_settings->containerConfig(serverIndex, container);
 
-        ErrorCode e = ErrorCode::NoError;
+        ErrorCode errorCode = ErrorCode::NoError;
-        cfg = m_configurator->cloakConfigurator->genCloakConfig(credentials, container, containerConfig, &e);
+        cfg = m_configurator->cloakConfigurator->genCloakConfig(credentials, container, containerConfig, errorCode);
     }
 
     QJsonObject cloakConfig = QJsonDocument::fromJson(cfg.toUtf8()).object();
@@ -215,7 +215,7 @@ void ShareConnectionLogic::onPushButtonShareWireGuardGenerateClicked()
     const QJsonObject &containerConfig = m_settings->containerConfig(serverIndex, container);
 
     ErrorCode e = ErrorCode::NoError;
-    QString cfg = m_configurator->wireguardConfigurator->genWireguardConfig(credentials, container, containerConfig, &e);
+    QString cfg = m_configurator->wireguardConfigurator->genWireguardConfig(credentials, container, containerConfig, e);
     if (e) {
         emit uiLogic()->showWarningMessage(tr("Error occurred while generating the config.") + "\n" +
                                            tr("Error message: ") + errorString(e) + "\n" +
@@ -239,7 +239,8 @@ void ShareConnectionLogic::onPushButtonShareIkev2GenerateClicked()
     DockerContainer container = uiLogic()->m_selectedDockerContainer;
     ServerCredentials credentials = m_settings->serverCredentials(serverIndex);
 
-    Ikev2Configurator::ConnectionData connData = m_configurator->ikev2Configurator->prepareIkev2Config(credentials, container);
+    ErrorCode errorCode = ErrorCode::NoError;
+    Ikev2Configurator::ConnectionData connData = m_configurator->ikev2Configurator->prepareIkev2Config(credentials, container, errorCode);
 
     QString cfg = m_configurator->ikev2Configurator->genIkev2Config(connData);
     cfg = m_configurator->processConfigWithExportSettings(serverIndex, container, Proto::Ikev2, cfg);

client/ui/pages_logic/StartPageLogic.cpp

@@ -153,7 +153,7 @@ void StartPageLogic::onPushButtonConnect()
 
     QString output;
     if (errorCode == ErrorCode::NoError) {
-        output = serverController.checkSshConnection(serverCredentials, &errorCode);
+        output = serverController.checkSshConnection(serverCredentials, errorCode);
     }
 
     bool ok = true;

client/vpnconnection.cpp

@@ -232,61 +232,69 @@ QMap<Proto, QString> VpnConnection::getLastVpnConfig(const QJsonObject &containe
     return configs;
 }
 
-QString VpnConnection::createVpnConfigurationForProto(int serverIndex,
+QString VpnConnection::createVpnConfigurationForProto(int serverIndex, const ServerCredentials &credentials,
-    const ServerCredentials &credentials, DockerContainer container, const QJsonObject &containerConfig, Proto proto,
+                                                      DockerContainer container, const QJsonObject &containerConfig,
-    ErrorCode *errorCode)
+                                                      Proto proto, ErrorCode &errorCode)
 {
-    ErrorCode e = ErrorCode::NoError;
     QMap<Proto, QString> lastVpnConfig = getLastVpnConfig(containerConfig);
 
     QString configData;
-    if (lastVpnConfig.contains(proto)) {
+
+    if (shouldProcessLastConfigWithRemoteSettings(serverIndex, proto)) {
+        errorCode = m_configurator->processLastConfigWithRemoteSettings(lastVpnConfig, serverIndex, proto);
+
+        if (errorCode) {
+            return "";
+        }
+
+        configData = lastVpnConfig.value(proto);
+
+        if (serverIndex >= 0) {
+            QJsonObject protoObject = m_settings->protocolConfig(serverIndex, container, proto);
+            protoObject.insert(config_key::last_config, configData);
+            m_settings->setProtocolConfig(serverIndex, container, proto, protoObject);
+        }
+        configData = m_configurator->processConfigWithLocalSettings(serverIndex, container, proto, configData);
+    } else if (lastVpnConfig.contains(proto)) {
         configData = lastVpnConfig.value(proto);
         configData = m_configurator->processConfigWithLocalSettings(serverIndex, container, proto, configData);
-    }
+    } else if (credentials.isValid()) {
-    else {
+        configData = m_configurator->genVpnProtocolConfig(credentials, container, containerConfig, proto, errorCode);
-        configData = m_configurator->genVpnProtocolConfig(credentials,
-            container, containerConfig, proto, &e);
 
         QString configDataBeforeLocalProcessing = configData;
 
         configData = m_configurator->processConfigWithLocalSettings(serverIndex, container, proto, configData);
 
-
+        if (errorCode) {
-        if (errorCode && e) {
-            *errorCode = e;
             return "";
         }
 
-
         if (serverIndex >= 0) {
             qDebug() << "VpnConnection::createVpnConfiguration: saving config for server #" << serverIndex << container << proto;
             QJsonObject protoObject = m_settings->protocolConfig(serverIndex, container, proto);
             protoObject.insert(config_key::last_config, configDataBeforeLocalProcessing);
             m_settings->setProtocolConfig(serverIndex, container, proto, protoObject);
         }
+    } else {
+        errorCode = ErrorCode::InternalError;
+        return "";
     }
 
-    if (errorCode) *errorCode = e;
     return configData;
 }
 
 QJsonObject VpnConnection::createVpnConfiguration(int serverIndex,
                                                   const ServerCredentials &credentials, DockerContainer container,
-    const QJsonObject &containerConfig, ErrorCode *errorCode)
+                                                  const QJsonObject &containerConfig, ErrorCode &errorCode)
 {
-    ErrorCode e = ErrorCode::NoError;
     QJsonObject vpnConfiguration;
 
-
     for (ProtocolEnumNS::Proto proto : ContainerProps::protocolsForContainer(container)) {
         QJsonObject vpnConfigData = QJsonDocument::fromJson(
-            createVpnConfigurationForProto(
+                                            createVpnConfigurationForProto(serverIndex, credentials,
-                serverIndex, credentials, container, containerConfig, proto, &e).toUtf8()).
+                                                                           container, containerConfig,
-                    object();
+                                                                           proto, errorCode).toUtf8()).object();
-
+        if (errorCode) {
-        if (e) {
-            if (errorCode) *errorCode = e;
             return {};
         }
 
@@ -334,10 +342,10 @@ void VpnConnection::connectToVpn(int serverIndex,
         m_vpnProtocol.reset();
     }
 
-    ErrorCode e = ErrorCode::NoError;
+    ErrorCode errorCode = ErrorCode::NoError;
 
-    m_vpnConfiguration = createVpnConfiguration(serverIndex, credentials, container, containerConfig);
+    m_vpnConfiguration = createVpnConfiguration(serverIndex, credentials, container, containerConfig, errorCode);
-    if (e) {
+    if (errorCode) {
         emit connectionStateChanged(VpnProtocol::Error);
         return;
     }
@@ -370,8 +378,8 @@ void VpnConnection::connectToVpn(int serverIndex,
 
     createProtocolConnections();
 
-    e = m_vpnProtocol.data()->start();
+    errorCode = m_vpnProtocol.data()->start();
-    if (e) emit VpnProtocol::Error;
+    if (errorCode) emit VpnProtocol::Error;
 }
 
 void VpnConnection::createProtocolConnections() {
@@ -469,3 +477,14 @@ bool VpnConnection::isDisconnected() const
 
     return m_vpnProtocol.data()->isDisconnected();
 }
+
+bool VpnConnection::shouldProcessLastConfigWithRemoteSettings(const int serverIndex, const Proto proto)
+{
+    const QJsonObject serverSettings = m_settings->server(serverIndex);
+    if (serverSettings.contains(config_key::nativeConfigParametrsStorage)) {
+        if (proto == Proto::WireGuard) {
+            return true;
+        }
+    }
+    return false;
+}

client/vpnconnection.h

@@ -41,15 +41,12 @@ public:
     ErrorCode lastError() const;
 
     static QMap<Proto, QString> getLastVpnConfig(const QJsonObject &containerConfig);
-    QString createVpnConfigurationForProto(int serverIndex,
+    QString createVpnConfigurationForProto(int serverIndex, const ServerCredentials &credentials,
-        const ServerCredentials &credentials, DockerContainer container, const QJsonObject &containerConfig, Proto proto,
+                                           DockerContainer container, const QJsonObject &containerConfig,
-        ErrorCode *errorCode = nullptr);
+                                           Proto proto, ErrorCode &errorCode);
-
-    QJsonObject createVpnConfiguration(int serverIndex,
-        const ServerCredentials &credentials, DockerContainer container,
-        const QJsonObject &containerConfig, ErrorCode *errorCode = nullptr);
-
 
+    QJsonObject createVpnConfiguration(int serverIndex, const ServerCredentials &credentials, DockerContainer container,
+                                       const QJsonObject &containerConfig, ErrorCode &errorCode);
 
     bool isConnected() const;
     bool isDisconnected() const;
@@ -93,6 +90,8 @@ protected:
     QSharedPointer<VpnProtocol> m_vpnProtocol;
 
 private:
+    bool shouldProcessLastConfigWithRemoteSettings(const int serverIndex, const Proto proto);
+
     std::shared_ptr<Settings> m_settings;
     std::shared_ptr<VpnConfigurator> m_configurator;
 

docs/README.md

@@ -0,0 +1,3 @@
+To convert the text description of the chart into an image, you can use:
+* Any online service, just google plantuml online
+* Install plugin for vscode - PlantUML

docs/configs/containerConfig/wireguard/wireguardContainerConfig.plantuml

@@ -0,0 +1,11 @@
+@startjson wireguardContainerConfig
+{
+    "container : string": "amnezia-wireguard",
+    "wireguard : array": 
+        {
+            "last_config : string": "native wireguard config",
+            "port : string": "port number",
+            "transport_proto : string": "udp"
+        }
+}
+@endjson

docs/configs/serverConfigImportProcess.plantuml

@@ -0,0 +1,23 @@
+@startuml serverConfigImportProcess
+start
+
+:import server config in any format;
+:decode server config into json;
+
+if (server config contains valid server credentials || containers) then (yes)
+    :show json server config to user;
+    if (user clicked continue import) then (yes)
+        :append server config to app internal settings;
+    else (no)
+        :remove imported config;
+    endif
+else (no)
+    :show error;
+    note right
+        now only output to the log
+    end note
+    stop
+endif
+
+stop
+@enduml

docs/configs/serverConfigProcessingOnConnection.plantuml

@@ -0,0 +1,21 @@
+@startuml serverConfigProcessingOnConnection
+start
+
+:connect button clicked;
+:createVpnConfiguration();
+:createVpnConfigurationForProto();
+
+if (serverConfig.contains(nativeConfigParametrsStorage)) then (yes)
+    :update last_config with data from nativeConfigParametrsStorage;
+else if (serverConfig.contains(last_config)) then (yes)
+    :do nothing special;
+else if (serverConfig.contains(admin credentials)) then (yes)
+    :generate new native config;
+    :save config in last_config;
+else 
+    :return empty config and error;
+    stop
+endif
+:continue connect process;
+stop
+@enduml

docs/configs/serverConfigWithWriteAccess.plantuml

@@ -0,0 +1,31 @@
+@startjson serverConfigWithWriteAccess
+{
+   "containers : array": 
+   [
+        {
+            "container : string": "amnezia-openvpn",
+            "openvpn : array": "<color:blue>openvpn container config"
+        },
+        {
+            "container : string": "amnezia-openvpn-cloak",
+            "openvpn : array": "<color:blue>openvpn container config",
+            "cloak : array": "<color:blue>cloak container config"
+        },
+        {
+            "container : string": "amnezia-shadowsocks",
+            "openvpn : array": "<color:blue>openvpn container config",
+            "shadowsocks : array": "<color:blue>shadowsocks container config"
+        },
+        {
+            "container : string": "amnezia-wireguard",
+            "wireguard : array": "<color:blue>wireguard container config"
+        }
+   ],
+    "defaultContainer : string": "container name",
+    "description : string": "server name alias",
+    "hostName : string": "server address",
+    "password : string": "password for user",
+    "port : string": "port number",
+    "userName : string": "user for ssh connection"
+}
+@endjson

docs/configs/serverConfigWithoutWriteAccessV1.plantuml

@@ -0,0 +1,30 @@
+@startjson serverConfigWithoutWriteAccessV1
+{
+   "containers : array": 
+   [
+        {
+            "container : string": "amnezia-openvpn",
+            "openvpn : array": "<color:blue>openvpn container config"
+        },
+        {
+            "container : string": "amnezia-openvpn-cloak",
+            "openvpn : array": "<color:blue>openvpn container config",
+            "cloak : array": "<color:blue>cloak container config"
+        },
+        {
+            "container : string": "amnezia-shadowsocks",
+            "openvpn : array": "<color:blue>openvpn container config",
+            "shadowsocks : array": "<color:blue>shadowsocks container config"
+        },
+        {
+            "container : string": "amnezia-wireguard",
+            "wireguard : array": "<color:blue>wireguard container config"
+        }
+   ],
+    "defaultContainer : string": "container name",
+    "description : string": "server name alias",
+    "dns1 : string": "dns address",
+    "dns2 : string": "dns address",
+    "hostName : string": "server address"
+}
+@endjson

docs/configs/serverConfigWithoutWriteAccessV2.plantuml

@@ -0,0 +1,32 @@
+@startjson serverConfigWithoutWriteAccessV2
+{
+   "containers : array": 
+   [
+        {
+            "container : string": "amnezia-openvpn",
+            "openvpn : array": "<color:blue>openvpn container config"
+        },
+        {
+            "container : string": "amnezia-openvpn-cloak",
+            "openvpn : array": "<color:blue>openvpn container config",
+            "cloak : array": "<color:blue>cloak container config"
+        },
+        {
+            "container : string": "amnezia-shadowsocks",
+            "openvpn : array": "<color:blue>openvpn container config",
+            "shadowsocks : array": "<color:blue>shadowsocks container config"
+        },
+        {
+            "container : string": "amnezia-wireguard",
+            "wireguard : array": "<color:blue>wireguard container config"
+        }
+   ],
+    "defaultContainer : string": "container name",
+    "description : string": "server name alias",
+    "dns1 : string": "dns address",
+    "dns2 : string": "dns address",
+    "hostName : string": "server address",
+    "version : number": "2",
+    "nativeConfigParametrsStorage : string": "storage address"
+}
+@endjson

service/CMakeLists.txt

@@ -7,10 +7,6 @@ set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 if(NOT IOS AND NOT ANDROID)
-    #include(common.cmake)
-#if (qtservice-uselib)
-#    add_subdirectory(buildlib)
-#endif()
     add_subdirectory(server)
 endif()
 

service/common.cmake

@@ -1,18 +0,0 @@
-set(QTSERVICE_LIBNAME QtSolutions_Service-head)
-if(CMAKE_BUILD_TYPE STREQUAL "Debug")
-    if(APPLE)
-        set(QTSERVICE_LIBNAME ${QTSERVICE_LIBNAME}_debug)
-    elseif(WIN32)
-        set(QTSERVICE_LIBNAME ${QTSERVICE_LIBNAME}_d)
-    endif()
-endif()
-
-set(QTSERVICE_LIBDIR ${CMAKE_CURRENT_LIST_DIR}/lib)
-
-if(UNIX)
-    if(qtservice-uselib)
-        if(NOT qtservice-buildlib)
-            set(CMAKE_INSTALL_RPATH ${CMAKE_INSTALL_RPATH} ${QTSERVICE_LIBDIR})
-        endif()
-    endif()
-endif()

service/server/CMakeLists.txt

@@ -6,10 +6,20 @@ project(${PROJECT})
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
-find_package(Qt6 REQUIRED COMPONENTS Core Network RemoteObjects Core5Compat)
 qt_standard_project_setup()
 
-set(HEADERS
+add_executable(${PROJECT})
+
+find_package(Qt6 REQUIRED COMPONENTS Core
+    Network RemoteObjects Core5Compat
+)
+
+target_link_libraries(${PROJECT} PRIVATE
+    Qt6::Core Qt6::Network
+    Qt6::RemoteObjects Qt6::Core5Compat
+)
+
+target_sources(${PROJECT} PRIVATE
         ${CMAKE_CURRENT_LIST_DIR}/../../client/utilities.h
         ${CMAKE_CURRENT_LIST_DIR}/../../ipc/ipc.h
         ${CMAKE_CURRENT_LIST_DIR}/../../ipc/ipcserver.h
@@ -18,9 +28,7 @@ set(HEADERS
         ${CMAKE_CURRENT_LIST_DIR}/logger.h
         ${CMAKE_CURRENT_LIST_DIR}/router.h
         ${CMAKE_CURRENT_LIST_DIR}/systemservice.h
-)
 
-set(SOURCES
         ${CMAKE_CURRENT_LIST_DIR}/../../client/utilities.cpp
         ${CMAKE_CURRENT_LIST_DIR}/../../ipc/ipcserver.cpp
         ${CMAKE_CURRENT_LIST_DIR}/../../ipc/ipcserverprocess.cpp
@@ -32,17 +40,15 @@ set(SOURCES
 )
 
 if(WIN32)
-    set(HEADERS ${HEADERS}
+    target_sources(${PROJECT} PRIVATE
         ${CMAKE_CURRENT_LIST_DIR}/tapcontroller_win.h
         ${CMAKE_CURRENT_LIST_DIR}/router_win.h
-    )
 
-    set(SOURCES ${SOURCES}
         ${CMAKE_CURRENT_LIST_DIR}/tapcontroller_win.cpp
         ${CMAKE_CURRENT_LIST_DIR}/router_win.cpp
     )
 
-    set(LIBS
+    target_link_libraries(${PROJECT} PRIVATE
         user32
         rasapi32
         shlwapi
@@ -54,43 +60,36 @@ if(WIN32)
         Kernel32
     )
 
-    add_compile_definitions(_WINSOCKAPI_)
+    target_compile_definitions(${PROJECT} PRIVATE _WINSOCKAPI_)
 endif()
 
 if(APPLE)
-    set(HEADERS ${HEADERS}
+    target_sources(${PROJECT} PRIVATE
         ${CMAKE_CURRENT_LIST_DIR}/helper_route_mac.h
         ${CMAKE_CURRENT_LIST_DIR}/router_mac.h
-    )
 
-    set(SOURCES ${SOURCES}
         ${CMAKE_CURRENT_LIST_DIR}/helper_route_mac.c
         ${CMAKE_CURRENT_LIST_DIR}/router_mac.cpp
     )
 endif()
 
 if(LINUX)
-    set(HEADERS ${HEADERS}
+    target_sources(${PROJECT} PRIVATE
         ${CMAKE_CURRENT_LIST_DIR}/router_linux.h
-    )
 
-    set(SOURCES ${SOURCES}
         ${CMAKE_CURRENT_LIST_DIR}/router_linux.cpp
     )
 endif()
 
 include(${CMAKE_CURRENT_LIST_DIR}/../src/qtservice.cmake)
 
-include_directories(
+target_include_directories(${PROJECT} PRIVATE
 	${CMAKE_CURRENT_LIST_DIR}
     ${CMAKE_CURRENT_LIST_DIR}/../../client
     ${CMAKE_CURRENT_LIST_DIR}/../../ipc
     ${CMAKE_CURRENT_BINARY_DIR}
 )
 
-add_executable(${PROJECT} ${SOURCES} ${HEADERS})
-target_link_libraries(${PROJECT} PRIVATE Qt6::Core Qt6::Network Qt6::RemoteObjects Qt6::Core5Compat ${LIBS})
-
 qt_add_repc_sources(${PROJECT} ${CMAKE_CURRENT_LIST_DIR}/../../ipc/ipc_interface.rep)
 if(NOT IOS)
     qt_add_repc_sources(${PROJECT} ${CMAKE_CURRENT_LIST_DIR}/../../ipc/ipc_process_interface.rep)

service/src/qtservice.cmake

@@ -1,29 +1,27 @@
-include_directories(${CMAKE_CURRENT_LIST_DIR})
+if(${PROJECT} STREQUAL "")
-
+   message(FATAL_ERROR "You must set PROJECT variable")
-#include(${CMAKE_CURRENT_LIST_DIR}/../common.cmake)
-
-if(NOT WIN32)
-    set(LIBS ${LIBS} Qt6::Network)
-elseif(WIN32)
-    set(LIBS ${LIBS} user32)
 endif()
 
-set(HEADERS ${HEADERS} 
+target_include_directories(${PROJECT} PRIVATE ${CMAKE_CURRENT_LIST_DIR})
+
+if(NOT WIN32)
+    target_include_directories(${PROJECT} PRIVATE Qt6::Network)
+elseif(WIN32)
+    target_include_directories(${PROJECT} PRIVATE user32)
+endif()
+
+target_sources(${PROJECT} PRIVATE
     ${CMAKE_CURRENT_LIST_DIR}/qtservice.h
     ${CMAKE_CURRENT_LIST_DIR}/qtservice_p.h
-)
 
-set(SOURCES ${SOURCES} 
     ${CMAKE_CURRENT_LIST_DIR}/qtservice.cpp
 )
 
 if(UNIX)
-    set(HEADERS ${HEADERS} 
+    target_sources(${PROJECT} PRIVATE
         ${CMAKE_CURRENT_LIST_DIR}/qtunixsocket.h
         ${CMAKE_CURRENT_LIST_DIR}/qtunixserversocket.h
-    )
 
-    set(SOURCES ${SOURCES} 
         ${CMAKE_CURRENT_LIST_DIR}/qtservice_unix.cpp
         ${CMAKE_CURRENT_LIST_DIR}/qtunixsocket.cpp
         ${CMAKE_CURRENT_LIST_DIR}/qtunixserversocket.cpp
@@ -31,7 +29,7 @@ if(UNIX)
 endif()
 
 if(WIN32)
-    set(SOURCES ${SOURCES} 
+    target_sources(${PROJECT} PRIVATE
         ${CMAKE_CURRENT_LIST_DIR}/qtservice_win.cpp
     )
 endif()