update: separated self-hosted dns settings

client/core/controllers/connectionController.cpp

@@ -73,7 +73,7 @@ ErrorCode ConnectionController::prepareConnection(const QString &serverId,
         if (!cfg.has_value()) return ErrorCode::InternalError;
         container = cfg->defaultContainer;
         containerConfigModel = cfg->containerConfig(container);
-        dns = cfg->getDnsPair(m_appSettingsRepository->useAmneziaDns(), primaryDns, secondaryDns);
+        dns = cfg->getDnsPair(primaryDns, secondaryDns);
         hostName = cfg->hostName;
         description = cfg->description;
         break;

client/core/controllers/selfhosted/exportController.cpp

@@ -65,13 +65,15 @@ ExportController::ExportResult ExportController::generateConnectionConfig(const
     }
     ContainerConfig containerConfig = adminConfig->containerConfig(container);
 
+    const QPair<QString, QString> dns = adminConfig->getDnsPair(m_appSettingsRepository->primaryDns(), m_appSettingsRepository->secondaryDns());
+
     if (ContainerUtils::containerService(container) != ServiceType::Other) {
         SshSession sshSession;
         Proto protocol = ContainerUtils::defaultProtocol(container);
 
         DnsSettings dnsSettings = {
-            m_appSettingsRepository->primaryDns(),
+            dns.first,
-            m_appSettingsRepository->secondaryDns()
+            dns.second
         };
 
         auto configurator = ConfiguratorBase::create(protocol, &sshSession);
@@ -88,10 +90,6 @@ ExportController::ExportResult ExportController::generateConnectionConfig(const
         }
     }
 
-    const QPair<QString, QString> dns = adminConfig->getDnsPair(m_appSettingsRepository->useAmneziaDns(),
-                                                               m_appSettingsRepository->primaryDns(),
-                                                               m_appSettingsRepository->secondaryDns());
-
     adminConfig->containers.clear();
     adminConfig->containers[container] = containerConfig;
     adminConfig->defaultContainer = container;
@@ -133,16 +131,14 @@ ExportController::NativeConfigResult ExportController::generateNativeConfig(cons
         result.errorCode = ErrorCode::InternalError;
         return result;
     }
-    const QPair<QString, QString> dns = adminConfig->getDnsPair(m_appSettingsRepository->useAmneziaDns(),
+    const QPair<QString, QString> dns = adminConfig->getDnsPair(m_appSettingsRepository->primaryDns(), m_appSettingsRepository->secondaryDns());
-                                                                m_appSettingsRepository->primaryDns(),
-                                                                m_appSettingsRepository->secondaryDns());
 
     ContainerConfig modifiedContainerConfig = containerConfig;
     modifiedContainerConfig.container = container;
 
     DnsSettings dnsSettings = {
-        m_appSettingsRepository->primaryDns(),
+        dns.first,
-        m_appSettingsRepository->secondaryDns()
+        dns.second
     };
 
     SshSession sshSession;

client/core/controllers/selfhosted/installController.cpp

@@ -211,7 +211,8 @@ ErrorCode InstallController::updateContainer(const QString &serverId, DockerCont
             newConfig.getXrayProtocolConfig() && newConfig.getXrayProtocolConfig()->serverConfig.isThirdPartyConfig;
 
     if (errorCode == ErrorCode::NoError && xrayServerSettingsChanged && !skipXrayInboundSync) {
-        DnsSettings dnsSettings = { m_appSettingsRepository->primaryDns(), m_appSettingsRepository->secondaryDns() };
+        const QPair<QString, QString> dns = adminConfig->getDnsPair(m_appSettingsRepository->primaryDns(), m_appSettingsRepository->secondaryDns());
+        DnsSettings dnsSettings = { dns.first, dns.second };
         XrayConfigurator xrayConfigurator(&sshSession);
         qDebug() << "InstallController::updateContainer applying Xray server inbound sync, reinstall="
                  << reinstallRequired;

client/core/controllers/serversController.cpp

@@ -83,6 +83,46 @@ bool ServersController::renameServer(const QString &serverId, const QString &nam
     }
 }
 
+bool ServersController::changeServerDns(const QString &serverId, const QString &primaryDns, const QString &secondaryDns, const int &dnsMode)
+{
+    const serverConfigUtils::ConfigType kind = m_serversRepository->serverKind(serverId);
+    if(kind == serverConfigUtils::ConfigType::SelfHostedAdmin) {
+        auto cfg = m_serversRepository->selfHostedAdminConfig(serverId);
+        if (!cfg.has_value()) return false;
+        cfg->dns1 = primaryDns;
+        cfg->dns2 = secondaryDns;
+        cfg->dnsMode = dnsMode;
+        m_serversRepository->editServer(serverId, cfg->toJson(), kind);
+        return true;
+    }else{
+        return false;
+    }
+}
+
+QPair<QString, QString> ServersController::getDnsPair(const QString &serverId) const
+{
+    const serverConfigUtils::ConfigType kind = m_serversRepository->serverKind(serverId);
+    if (kind == serverConfigUtils::ConfigType::SelfHostedAdmin) {
+        const auto cfg = m_serversRepository->selfHostedAdminConfig(serverId);
+        return cfg.has_value()
+                ? cfg->getDnsPair(m_appSettingsRepository->primaryDns(), m_appSettingsRepository->primaryDns())
+                : QPair<QString, QString>();
+    } else {
+        return QPair<QString, QString>();
+    }
+}
+
+int ServersController::getDnsMode(const QString &serverId) const
+{
+    const serverConfigUtils::ConfigType kind = m_serversRepository->serverKind(serverId);
+    if (kind == serverConfigUtils::ConfigType::SelfHostedAdmin) {
+        const auto cfg = m_serversRepository->selfHostedAdminConfig(serverId);
+        return cfg.has_value() ? cfg->dnsMode : int();
+    } else {
+        return int();
+    }
+}
+
 void ServersController::removeServer(const QString &serverId)
 {
     m_serversRepository->removeServer(serverId);

client/core/controllers/serversController.h

@@ -37,6 +37,7 @@ public:
 
     // Server management
     bool renameServer(const QString &serverId, const QString &name);
+    bool changeServerDns(const QString &serverId, const QString &primaryDns, const QString &secondaryDns, const int &dnsMode);
     void removeServer(const QString &serverId);
     void setDefaultServer(const QString &serverId);
 
@@ -57,6 +58,8 @@ public:
     QMap<DockerContainer, ContainerConfig> getServerContainersMap(const QString &serverId) const;
     DockerContainer getDefaultContainer(const QString &serverId) const;
     ContainerConfig getContainerConfig(const QString &serverId, DockerContainer container) const;
+    QPair<QString, QString> getDnsPair(const QString &serverId) const;
+    int getDnsMode(const QString &serverId) const;
 
     // Validation
     bool isServerFromApiAlreadyExists(const QString &userCountryCode, const QString &serviceType, const QString &serviceProtocol) const;

client/core/models/selfhosted/selfHostedAdminServerConfig.cpp

@@ -64,15 +64,14 @@ void SelfHostedAdminServerConfig::clearCachedClientProfile(DockerContainer conta
     containers[container] = cleared;
 }
 
-QPair<QString, QString> SelfHostedAdminServerConfig::getDnsPair(bool isAmneziaDnsEnabled, const QString &primaryDns,
+QPair<QString, QString> SelfHostedAdminServerConfig::getDnsPair(const QString &primaryDns, const QString &secondaryDns) const
-                                                                const QString &secondaryDns) const
 {
     QString d1 = dns1;
     QString d2 = dns2;
     const bool dnsOnServer = containers.contains(DockerContainer::Dns);
 
     if (d1.isEmpty() || !NetworkUtilities::checkIPv4Format(d1)) {
-        d1 = (isAmneziaDnsEnabled && dnsOnServer) ? protocols::dns::amneziaDnsIp : primaryDns;
+        d1 = ((dnsMode == 1) && dnsOnServer) ? protocols::dns::amneziaDnsIp : primaryDns;
     }
     if (d2.isEmpty() || !NetworkUtilities::checkIPv4Format(d2)) {
         d2 = secondaryDns;
@@ -110,6 +109,9 @@ QJsonObject SelfHostedAdminServerConfig::toJson() const
     if (!dns2.isEmpty()) {
         obj[configKey::dns2] = dns2;
     }
+    if (dnsMode > -1) {
+        obj[configKey::dnsMode] = dnsMode;
+    }
 
     if (!userName.isEmpty()) {
         obj[configKey::userName] = userName;
@@ -147,6 +149,11 @@ SelfHostedAdminServerConfig SelfHostedAdminServerConfig::fromJson(const QJsonObj
 
     config.dns1 = json.value(configKey::dns1).toString();
     config.dns2 = json.value(configKey::dns2).toString();
+    if (json.contains(configKey::dnsMode)) {
+        config.dnsMode = json.value(configKey::dnsMode).toInt();
+    } else {
+        config.dnsMode = 0;
+    }
 
     config.userName = json.value(configKey::userName).toString();
     config.password = json.value(configKey::password).toString();

client/core/models/selfhosted/selfHostedAdminServerConfig.h

@@ -26,6 +26,7 @@ struct SelfHostedAdminServerConfig {
     DockerContainer defaultContainer;
     QString dns1;
     QString dns2;
+    int dnsMode = 0;
 
     QString userName;
     QString password;
@@ -41,8 +42,7 @@ struct SelfHostedAdminServerConfig {
 
     void clearCachedClientProfile(DockerContainer container);
 
-    QPair<QString, QString> getDnsPair(bool isAmneziaDnsEnabled, const QString &primaryDns,
+    QPair<QString, QString> getDnsPair(const QString &primaryDns, const QString &secondaryDns) const;
-                                       const QString &secondaryDns) const;
 
     QJsonObject toJson() const;
     static SelfHostedAdminServerConfig fromJson(const QJsonObject &json);

client/core/models/serverDescription.cpp

@@ -80,8 +80,8 @@ QString getProtocolName(DockerContainer defaultContainer, const QMap<DockerConta
 namespace amnezia
 {
 
-ServerDescription buildServerDescription(const SelfHostedAdminServerConfig &server, bool isAmneziaDnsEnabled)
+ServerDescription buildServerDescription(const SelfHostedAdminServerConfig &server, bool /*isAmneziaDnsEnabled*/)
-{
+    {
     ServerDescription row = buildBaseDescription(server);
     row.selfHostedSshCredentials.hostName = server.hostName;
     row.selfHostedSshCredentials.userName = server.userName;
@@ -92,7 +92,7 @@ ServerDescription buildServerDescription(const SelfHostedAdminServerConfig &serv
                          && !row.selfHostedSshCredentials.secretData.isEmpty();
 
     row.serverName = server.displayName;
-    row.baseDescription = getBaseDescription(server.containers, isAmneziaDnsEnabled, row.hasWriteAccess, row.primaryDnsIsAmnezia);
+    row.baseDescription = getBaseDescription(server.containers, server.dnsMode == 1, row.hasWriteAccess, row.primaryDnsIsAmnezia);
 
     const QString protocolName = getProtocolName(server.defaultContainer, server.containers);
     row.expandedServerDescription = row.baseDescription + row.hostName;

client/core/utils/constants/configKeys.h

@@ -15,6 +15,7 @@ namespace amnezia
 
         constexpr QLatin1String dns1("dns1");
         constexpr QLatin1String dns2("dns2");
+        constexpr QLatin1String dnsMode("dnsMode");
 
         constexpr QLatin1String serverIndex("serverIndex");
         constexpr QLatin1String description("description");