added the ability to change awg parameters on the protocol settings page

client/configurators/awg_configurator.cpp

@@ -3,6 +3,8 @@
 #include <QJsonDocument>
 #include <QJsonObject>
 
+#include "core/servercontroller.h"
+
 AmneziaWireGuardConfigurator::AmneziaWireGuardConfigurator(std::shared_ptr<Settings> settings, QObject *parent)
     : WireguardConfigurator(settings, true, parent)
 {
@@ -15,46 +17,43 @@ QString AmneziaWireGuardConfigurator::genAmneziaWireGuardConfig(const ServerCred
     QString config = WireguardConfigurator::genWireguardConfig(credentials, container, containerConfig, errorCode);
 
     QJsonObject jsonConfig = QJsonDocument::fromJson(config.toUtf8()).object();
-    QJsonObject awgConfig = containerConfig.value(config_key::amneziaWireguard).toObject();
 
-    auto junkPacketCount =
+    ServerController serverController(m_settings);
-            awgConfig.value(config_key::junkPacketCount).toString(protocols::amneziawireguard::defaultJunkPacketCount);
+    QString serverConfig = serverController.getTextFileFromContainer(container, credentials, protocols::amneziawireguard::serverConfigPath, errorCode);
-    auto junkPacketMinSize =
-            awgConfig.value(config_key::junkPacketMinSize).toString(protocols::amneziawireguard::defaultJunkPacketMinSize);
-    auto junkPacketMaxSize =
-            awgConfig.value(config_key::junkPacketMaxSize).toString(protocols::amneziawireguard::defaultJunkPacketMaxSize);
-    auto initPacketJunkSize =
-            awgConfig.value(config_key::initPacketJunkSize).toString(protocols::amneziawireguard::defaultInitPacketJunkSize);
-    auto responsePacketJunkSize =
-            awgConfig.value(config_key::responsePacketJunkSize).toString(protocols::amneziawireguard::defaultResponsePacketJunkSize);
-    auto initPacketMagicHeader =
-            awgConfig.value(config_key::initPacketMagicHeader).toString(protocols::amneziawireguard::defaultInitPacketMagicHeader);
-    auto responsePacketMagicHeader =
-            awgConfig.value(config_key::responsePacketMagicHeader).toString(protocols::amneziawireguard::defaultResponsePacketMagicHeader);
-    auto underloadPacketMagicHeader =
-            awgConfig.value(config_key::underloadPacketMagicHeader).toString(protocols::amneziawireguard::defaultUnderloadPacketMagicHeader);
-    auto transportPacketMagicHeader =
-            awgConfig.value(config_key::transportPacketMagicHeader).toString(protocols::amneziawireguard::defaultTransportPacketMagicHeader);
 
-    config.replace("$JUNK_PACKET_COUNT", junkPacketCount);
+    QMap<QString, QString> serverConfigMap;
-    config.replace("$JUNK_PACKET_MIN_SIZE", junkPacketMinSize);
+    auto serverConfigLines = serverConfig.split("\n");
-    config.replace("$JUNK_PACKET_MAX_SIZE", junkPacketMaxSize);
+    for (auto &line : serverConfigLines) {
-    config.replace("$INIT_PACKET_JUNK_SIZE", initPacketJunkSize);
+        auto trimmedLine = line.trimmed();
-    config.replace("$RESPONSE_PACKET_JUNK_SIZE", responsePacketJunkSize);
+        if (trimmedLine.startsWith("[") && trimmedLine.endsWith("]")) {
-    config.replace("$INIT_PACKET_MAGIC_HEADER", initPacketMagicHeader);
+            continue;
-    config.replace("$RESPONSE_PACKET_MAGIC_HEADER", responsePacketMagicHeader);
+        } else {
-    config.replace("$UNDERLOAD_PACKET_MAGIC_HEADER", underloadPacketMagicHeader);
+            QStringList parts = trimmedLine.split(" = ");
-    config.replace("$TRANSPORT_PACKET_MAGIC_HEADER", transportPacketMagicHeader);
+            if (parts.count() == 2) {
+                serverConfigMap.insert(parts[0].trimmed(), parts[1].trimmed());
+            }
+        }
+    }
 
-    jsonConfig[config_key::junkPacketCount] = junkPacketCount;
+    config.replace("$JUNK_PACKET_COUNT", serverConfigMap.value(config_key::junkPacketCount));
-    jsonConfig[config_key::junkPacketMinSize] = junkPacketMinSize;
+    config.replace("$JUNK_PACKET_MIN_SIZE", serverConfigMap.value(config_key::junkPacketMinSize));
-    jsonConfig[config_key::junkPacketMaxSize] = junkPacketMaxSize;
+    config.replace("$JUNK_PACKET_MAX_SIZE", serverConfigMap.value(config_key::junkPacketMaxSize));
-    jsonConfig[config_key::initPacketJunkSize] = initPacketJunkSize;
+    config.replace("$INIT_PACKET_JUNK_SIZE", serverConfigMap.value(config_key::initPacketJunkSize));
-    jsonConfig[config_key::responsePacketJunkSize] = responsePacketJunkSize;
+    config.replace("$RESPONSE_PACKET_JUNK_SIZE", serverConfigMap.value(config_key::responsePacketJunkSize));
-    jsonConfig[config_key::initPacketMagicHeader] = initPacketMagicHeader;
+    config.replace("$INIT_PACKET_MAGIC_HEADER", serverConfigMap.value(config_key::initPacketMagicHeader));
-    jsonConfig[config_key::responsePacketMagicHeader] = responsePacketMagicHeader;
+    config.replace("$RESPONSE_PACKET_MAGIC_HEADER", serverConfigMap.value(config_key::responsePacketMagicHeader));
-    jsonConfig[config_key::underloadPacketMagicHeader] = underloadPacketMagicHeader;
+    config.replace("$UNDERLOAD_PACKET_MAGIC_HEADER", serverConfigMap.value(config_key::underloadPacketMagicHeader));
-    jsonConfig[config_key::transportPacketMagicHeader] = transportPacketMagicHeader;
+    config.replace("$TRANSPORT_PACKET_MAGIC_HEADER", serverConfigMap.value(config_key::transportPacketMagicHeader));
+
+    jsonConfig[config_key::junkPacketCount] = serverConfigMap.value(config_key::junkPacketCount);
+    jsonConfig[config_key::junkPacketMinSize] = serverConfigMap.value(config_key::junkPacketMinSize);
+    jsonConfig[config_key::junkPacketMaxSize] = serverConfigMap.value(config_key::junkPacketMaxSize);
+    jsonConfig[config_key::initPacketJunkSize] = serverConfigMap.value(config_key::initPacketJunkSize);
+    jsonConfig[config_key::responsePacketJunkSize] = serverConfigMap.value(config_key::responsePacketJunkSize);
+    jsonConfig[config_key::initPacketMagicHeader] = serverConfigMap.value(config_key::initPacketMagicHeader);
+    jsonConfig[config_key::responsePacketMagicHeader] = serverConfigMap.value(config_key::responsePacketMagicHeader);
+    jsonConfig[config_key::underloadPacketMagicHeader] = serverConfigMap.value(config_key::underloadPacketMagicHeader);
+    jsonConfig[config_key::transportPacketMagicHeader] = serverConfigMap.value(config_key::transportPacketMagicHeader);
 
     return QJsonDocument(jsonConfig).toJson();
 }

client/configurators/wireguard_configurator.cpp

@@ -30,6 +30,9 @@ WireguardConfigurator::WireguardConfigurator(std::shared_ptr<Settings> settings,
                                               : amnezia::protocols::wireguard::serverPskKeyPath;
     m_configTemplate = m_isAmneziaWireGuard ? ProtocolScriptType::amnezia_wireguard_template
                                             : ProtocolScriptType::wireguard_template;
+
+    m_protocolName = m_isAmneziaWireGuard ? config_key::amneziaWireguard : config_key::wireguard;
+    m_defaultPort = m_isAmneziaWireGuard ? protocols::wireguard::defaultPort : protocols::amneziawireguard::defaultPort;
 }
 
 WireguardConfigurator::ConnectionData WireguardConfigurator::genClientKeys()
@@ -70,10 +73,7 @@ WireguardConfigurator::ConnectionData WireguardConfigurator::prepareWireguardCon
 {
     WireguardConfigurator::ConnectionData connData = WireguardConfigurator::genClientKeys();
     connData.host = credentials.hostName;
-    connData.port = containerConfig.value(m_isAmneziaWireGuard ? config_key::amneziaWireguard : config_key::wireguard)
+    connData.port = containerConfig.value(m_protocolName).toObject().value(config_key::port).toString(m_defaultPort);
-                            .toObject()
-                            .value(config_key::port)
-                            .toString(protocols::wireguard::defaultPort);
 
     if (connData.clientPrivKey.isEmpty() || connData.clientPubKey.isEmpty()) {
         if (errorCode)

client/configurators/wireguard_configurator.h

@@ -42,6 +42,8 @@ private:
     QString m_serverPublicKeyPath;
     QString m_serverPskKeyPath;
     amnezia::ProtocolScriptType m_configTemplate;
+    QString m_protocolName;
+    QString m_defaultPort;
 };
 
 #endif // WIREGUARD_CONFIGURATOR_H

client/core/servercontroller.cpp

@@ -338,6 +338,10 @@ bool ServerController::isReinstallContainerRequired(DockerContainer container, c
             return true;
     }
 
+    if (container == DockerContainer::AmneziaWireGuard) {
+        return true;
+    }
+
     return false;
 }
 

client/ui/models/protocols/amneziaWireGuardConfigModel.cpp

@@ -1,5 +1,7 @@
 #include "amneziaWireGuardConfigModel.h"
 
+#include <QJsonDocument>
+
 #include "protocols/protocols_defs.h"
 
 AmneziaWireGuardConfigModel::AmneziaWireGuardConfigModel(QObject *parent) : QAbstractListModel(parent)
@@ -20,7 +22,27 @@ bool AmneziaWireGuardConfigModel::setData(const QModelIndex &index, const QVaria
 
     switch (role) {
     case Roles::PortRole: m_protocolConfig.insert(config_key::port, value.toString()); break;
-    case Roles::CipherRole: m_protocolConfig.insert(config_key::cipher, value.toString()); break;
+    case Roles::JunkPacketCountRole: m_protocolConfig.insert(config_key::junkPacketCount, value.toString()); break;
+    case Roles::JunkPacketMinSizeRole: m_protocolConfig.insert(config_key::junkPacketMinSize, value.toString()); break;
+    case Roles::JunkPacketMaxSizeRole: m_protocolConfig.insert(config_key::junkPacketMaxSize, value.toString()); break;
+    case Roles::InitPacketJunkSizeRole:
+        m_protocolConfig.insert(config_key::initPacketJunkSize, value.toString());
+        break;
+    case Roles::ResponsePacketJunkSizeRole:
+        m_protocolConfig.insert(config_key::responsePacketJunkSize, value.toString());
+        break;
+    case Roles::InitPacketMagicHeaderRole:
+        m_protocolConfig.insert(config_key::initPacketMagicHeader, value.toString());
+        break;
+    case Roles::ResponsePacketMagicHeaderRole:
+        m_protocolConfig.insert(config_key::responsePacketMagicHeader, value.toString());
+        break;
+    case Roles::UnderloadPacketMagicHeaderRole:
+        m_protocolConfig.insert(config_key::underloadPacketMagicHeader, value.toString());
+        break;
+    case Roles::TransportPacketMagicHeaderRole:
+        m_protocolConfig.insert(config_key::transportPacketMagicHeader, value.toString());
+        break;
     }
 
     emit dataChanged(index, index, QList { role });
@@ -34,9 +56,16 @@ QVariant AmneziaWireGuardConfigModel::data(const QModelIndex &index, int role) c
     }
 
     switch (role) {
-    case Roles::PortRole: return m_protocolConfig.value(config_key::port).toString(protocols::shadowsocks::defaultPort);
+    case Roles::PortRole: return m_protocolConfig.value(config_key::port).toString();
-    case Roles::CipherRole:
+    case Roles::JunkPacketCountRole: return m_protocolConfig.value(config_key::junkPacketCount);
-        return m_protocolConfig.value(config_key::cipher).toString(protocols::shadowsocks::defaultCipher);
+    case Roles::JunkPacketMinSizeRole: return m_protocolConfig.value(config_key::junkPacketMinSize);
+    case Roles::JunkPacketMaxSizeRole: return m_protocolConfig.value(config_key::junkPacketMaxSize);
+    case Roles::InitPacketJunkSizeRole: return m_protocolConfig.value(config_key::initPacketJunkSize);
+    case Roles::ResponsePacketJunkSizeRole: return m_protocolConfig.value(config_key::responsePacketJunkSize);
+    case Roles::InitPacketMagicHeaderRole: return m_protocolConfig.value(config_key::initPacketMagicHeader);
+    case Roles::ResponsePacketMagicHeaderRole: return m_protocolConfig.value(config_key::responsePacketMagicHeader);
+    case Roles::UnderloadPacketMagicHeaderRole: return m_protocolConfig.value(config_key::underloadPacketMagicHeader);
+    case Roles::TransportPacketMagicHeaderRole: return m_protocolConfig.value(config_key::transportPacketMagicHeader);
     }
 
     return QVariant();
@@ -48,14 +77,44 @@ void AmneziaWireGuardConfigModel::updateModel(const QJsonObject &config)
     m_container = ContainerProps::containerFromString(config.value(config_key::container).toString());
 
     m_fullConfig = config;
-    QJsonObject protocolConfig = config.value(config_key::wireguard).toObject();
+
+    QJsonObject protocolConfig = config.value(config_key::amneziaWireguard).toObject();
+
+    m_protocolConfig[config_key::port] =
+            protocolConfig.value(config_key::port).toString(protocols::amneziawireguard::defaultPort);
+    m_protocolConfig[config_key::junkPacketCount] =
+            protocolConfig.value(config_key::junkPacketCount).toString(protocols::amneziawireguard::defaultJunkPacketCount);
+    m_protocolConfig[config_key::junkPacketMinSize] =
+            protocolConfig.value(config_key::junkPacketMinSize)
+                    .toString(protocols::amneziawireguard::defaultJunkPacketMinSize);
+    m_protocolConfig[config_key::junkPacketMaxSize] =
+            protocolConfig.value(config_key::junkPacketMaxSize)
+                    .toString(protocols::amneziawireguard::defaultJunkPacketMaxSize);
+    m_protocolConfig[config_key::initPacketJunkSize] =
+            protocolConfig.value(config_key::initPacketJunkSize)
+                    .toString(protocols::amneziawireguard::defaultInitPacketJunkSize);
+    m_protocolConfig[config_key::responsePacketJunkSize] =
+            protocolConfig.value(config_key::responsePacketJunkSize)
+                    .toString(protocols::amneziawireguard::defaultResponsePacketJunkSize);
+    m_protocolConfig[config_key::initPacketMagicHeader] =
+            protocolConfig.value(config_key::initPacketMagicHeader)
+                    .toString(protocols::amneziawireguard::defaultInitPacketMagicHeader);
+    m_protocolConfig[config_key::responsePacketMagicHeader] =
+            protocolConfig.value(config_key::responsePacketMagicHeader)
+                    .toString(protocols::amneziawireguard::defaultResponsePacketMagicHeader);
+    m_protocolConfig[config_key::underloadPacketMagicHeader] =
+            protocolConfig.value(config_key::underloadPacketMagicHeader)
+                    .toString(protocols::amneziawireguard::defaultUnderloadPacketMagicHeader);
+    m_protocolConfig[config_key::transportPacketMagicHeader] =
+            protocolConfig.value(config_key::transportPacketMagicHeader)
+                    .toString(protocols::amneziawireguard::defaultTransportPacketMagicHeader);
 
     endResetModel();
 }
 
 QJsonObject AmneziaWireGuardConfigModel::getConfig()
 {
-    m_fullConfig.insert(config_key::wireguard, m_protocolConfig);
+    m_fullConfig.insert(config_key::amneziaWireguard, m_protocolConfig);
     return m_fullConfig;
 }
 
@@ -64,7 +123,15 @@ QHash<int, QByteArray> AmneziaWireGuardConfigModel::roleNames() const
     QHash<int, QByteArray> roles;
 
     roles[PortRole] = "port";
-    roles[CipherRole] = "cipher";
+    roles[JunkPacketCountRole] = "junkPacketCount";
+    roles[JunkPacketMinSizeRole] = "junkPacketMinSize";
+    roles[JunkPacketMaxSizeRole] = "junkPacketMaxSize";
+    roles[InitPacketJunkSizeRole] = "initPacketJunkSize";
+    roles[ResponsePacketJunkSizeRole] = "responsePacketJunkSize";
+    roles[InitPacketMagicHeaderRole] = "initPacketMagicHeader";
+    roles[ResponsePacketMagicHeaderRole] = "responsePacketMagicHeader";
+    roles[UnderloadPacketMagicHeaderRole] = "underloadPacketMagicHeader";
+    roles[TransportPacketMagicHeaderRole] = "transportPacketMagicHeader";
 
     return roles;
 }

client/ui/models/protocols/amneziaWireGuardConfigModel.h

@@ -13,7 +13,15 @@ class AmneziaWireGuardConfigModel : public QAbstractListModel
 public:
     enum Roles {
         PortRole = Qt::UserRole + 1,
-        CipherRole
+        JunkPacketCountRole,
+        JunkPacketMinSizeRole,
+        JunkPacketMaxSizeRole,
+        InitPacketJunkSizeRole,
+        ResponsePacketJunkSizeRole,
+        InitPacketMagicHeaderRole,
+        ResponsePacketMagicHeaderRole,
+        UnderloadPacketMagicHeaderRole,
+        TransportPacketMagicHeaderRole
     };
 
     explicit AmneziaWireGuardConfigModel(QObject *parent = nullptr);

client/ui/qml/Components/SettingsContainersListView.qml

@@ -65,7 +65,7 @@ ListView {
                             break
                         }
                         case ContainerEnum.AmneziaWireGuard: {
-                            WireGuardConfigModel.updateModel(config)
+                            AmneziaWireGuardConfigModel.updateModel(config)
                             PageController.goToPage(PageEnum.PageProtocolAmneziaWireGuardSettings)
                             break
                         }

client/ui/qml/Controls2/TextFieldWithHeaderType.qml

@@ -12,6 +12,7 @@ Item {
     property string headerTextColor: "#878b91"
 
     property alias errorText: errorField.text
+    property bool checkEmptyText: false
 
     property string buttonText
     property string buttonImageSource
@@ -98,6 +99,12 @@ Item {
                             root.errorText = ""
                         }
 
+                        onActiveFocusChanged: {
+                            if (checkEmptyText && textFieldText === "") {
+                                errorText = qsTr("The field can't be empty")
+                            }
+                        }
+
                         MouseArea {
                             anchors.fill: parent
                             acceptedButtons: Qt.RightButton

client/ui/qml/Pages2/PageProtocolAmneziaWireGuardSettings.qml

@@ -4,6 +4,8 @@ import QtQuick.Layouts
 
 import SortFilterProxyModel 0.2
 
+import PageEnum 1.0
+
 import "./"
 import "../Controls2"
 import "../Controls2/TextTypes"
@@ -75,6 +77,7 @@ PageType {
                         }
 
                         TextFieldWithHeaderType {
+                            id: portTextField
                             Layout.fillWidth: true
                             Layout.topMargin: 40
 
@@ -88,132 +91,175 @@ PageType {
                                     port = textFieldText
                                 }
                             }
+
+                            checkEmptyText: true
                         }
 
                         TextFieldWithHeaderType {
+                            id: junkPacketCountTextField
                             Layout.fillWidth: true
                             Layout.topMargin: 16
 
                             headerText: qsTr("Junk packet count")
-                            textFieldText: port
+                            textFieldText: junkPacketCount
+                            textField.validator: IntValidator { bottom: 0 }
 
                             textField.onEditingFinished: {
-                                if (textFieldText !== port) {
+                                console.log("1")
-                                    port = textFieldText
+                                if (textFieldText === "") {
+                                    textFieldText = "0"
+                                }
+
+                                if (textFieldText !== junkPacketCount) {
+                                    junkPacketCount = textFieldText
                                 }
                             }
+
+                            checkEmptyText: true
                         }
 
                         TextFieldWithHeaderType {
+                            id: junkPacketMinSizeTextField
                             Layout.fillWidth: true
                             Layout.topMargin: 16
 
                             headerText: qsTr("Junk packet minimum size")
-                            textFieldText: port
+                            textFieldText: junkPacketMinSize
+                            textField.validator: IntValidator { bottom: 0 }
 
                             textField.onEditingFinished: {
-                                if (textFieldText !== port) {
+                                if (textFieldText !== junkPacketMinSize) {
-                                    port = textFieldText
+                                    junkPacketMinSize = textFieldText
                                 }
                             }
+
+                            checkEmptyText: true
                         }
 
                         TextFieldWithHeaderType {
+                            id: junkPacketMaxSizeTextField
                             Layout.fillWidth: true
                             Layout.topMargin: 16
 
                             headerText: qsTr("Junk packet maximum size")
-                            textFieldText: port
+                            textFieldText: junkPacketMaxSize
+                            textField.validator: IntValidator { bottom: 0 }
 
                             textField.onEditingFinished: {
-                                if (textFieldText !== port) {
+                                if (textFieldText !== junkPacketMaxSize) {
-                                    port = textFieldText
+                                    junkPacketMaxSize = textFieldText
                                 }
                             }
+
+                            checkEmptyText: true
                         }
 
                         TextFieldWithHeaderType {
+                            id: initPacketJunkSizeTextField
                             Layout.fillWidth: true
                             Layout.topMargin: 16
 
                             headerText: qsTr("Init packet junk size")
-                            textFieldText: port
+                            textFieldText: initPacketJunkSize
+                            textField.validator: IntValidator { bottom: 0 }
 
                             textField.onEditingFinished: {
-                                if (textFieldText !== port) {
+                                if (textFieldText !== initPacketJunkSize) {
-                                    port = textFieldText
+                                    initPacketJunkSize = textFieldText
                                 }
                             }
+
+                            checkEmptyText: true
                         }
 
                         TextFieldWithHeaderType {
+                            id: responsePacketJunkSizeTextField
                             Layout.fillWidth: true
                             Layout.topMargin: 16
 
                             headerText: qsTr("Response packet junk size")
-                            textFieldText: port
+                            textFieldText: responsePacketJunkSize
+                            textField.validator: IntValidator { bottom: 0 }
 
                             textField.onEditingFinished: {
-                                if (textFieldText !== port) {
+                                if (textFieldText !== responsePacketJunkSize) {
-                                    port = textFieldText
+                                    responsePacketJunkSize = textFieldText
                                 }
                             }
+
+                            checkEmptyText: true
                         }
 
                         TextFieldWithHeaderType {
+                            id: initPacketMagicHeaderTextField
                             Layout.fillWidth: true
                             Layout.topMargin: 16
 
                             headerText: qsTr("Init packet magic header")
-                            textFieldText: port
+                            textFieldText: initPacketMagicHeader
+                            textField.validator: IntValidator { bottom: 0 }
 
                             textField.onEditingFinished: {
-                                if (textFieldText !== port) {
+                                if (textFieldText !== initPacketMagicHeader) {
-                                    port = textFieldText
+                                    initPacketMagicHeader = textFieldText
                                 }
                             }
+
+                            checkEmptyText: true
                         }
 
                         TextFieldWithHeaderType {
+                            id: responsePacketMagicHeaderTextField
                             Layout.fillWidth: true
                             Layout.topMargin: 16
 
                             headerText: qsTr("Response packet magic header")
-                            textFieldText: port
+                            textFieldText: responsePacketMagicHeader
+                            textField.validator: IntValidator { bottom: 0 }
 
                             textField.onEditingFinished: {
-                                if (textFieldText !== port) {
+                                if (textFieldText !== responsePacketMagicHeader) {
-                                    port = textFieldText
+                                    responsePacketMagicHeader = textFieldText
                                 }
                             }
+
+                            checkEmptyText: true
                         }
 
                         TextFieldWithHeaderType {
+                            id: transportPacketMagicHeaderTextField
                             Layout.fillWidth: true
                             Layout.topMargin: 16
 
                             headerText: qsTr("Transport packet magic header")
-                            textFieldText: port
+                            textFieldText: transportPacketMagicHeader
+                            textField.validator: IntValidator { bottom: 0 }
 
                             textField.onEditingFinished: {
-                                if (textFieldText !== port) {
+                                if (textFieldText !== transportPacketMagicHeader) {
-                                    port = textFieldText
+                                    transportPacketMagicHeader = textFieldText
                                 }
                             }
+
+                            checkEmptyText: true
                         }
 
                         TextFieldWithHeaderType {
+                            id: underloadPacketMagicHeaderTextField
                             Layout.fillWidth: true
                             Layout.topMargin: 16
 
                             headerText: qsTr("Underload packet magic header")
-                            textFieldText: port
+                            textFieldText: underloadPacketMagicHeader
+                            textField.validator: IntValidator { bottom: 0 }
 
                             textField.onEditingFinished: {
-                                if (textFieldText !== port) {
+                                if (textFieldText !== underloadPacketMagicHeader) {
-                                    port = textFieldText
+                                    underloadPacketMagicHeader = textFieldText
                                 }
                             }
+
+                            checkEmptyText: true
                         }
 
                         BasicButtonType {
@@ -251,13 +297,24 @@ PageType {
                             Layout.topMargin: 24
                             Layout.bottomMargin: 24
 
+                            enabled: underloadPacketMagicHeaderTextField.errorText === "" &&
+                                     transportPacketMagicHeaderTextField.errorText === "" &&
+                                     responsePacketMagicHeaderTextField.errorText === "" &&
+                                     initPacketMagicHeaderTextField.errorText === "" &&
+                                     responsePacketJunkSizeTextField.errorText === "" &&
+                                     initPacketJunkSizeTextField.errorText === "" &&
+                                     junkPacketMaxSizeTextField.errorText === "" &&
+                                     junkPacketMinSizeTextField.errorText === "" &&
+                                     junkPacketCountTextField.errorText === "" &&
+                                     portTextField.errorText === ""
+
                             text: qsTr("Save and Restart Amnezia")
 
                             onClicked: {
                                 forceActiveFocus()
-//                                PageController.showBusyIndicator(true)
+                                PageController.showBusyIndicator(true)
-//                                InstallController.updateContainer(ShadowSocksConfigModel.getConfig())
+                                InstallController.updateContainer(AmneziaWireGuardConfigModel.getConfig())
-//                                PageController.showBusyIndicator(false)
+                                PageController.showBusyIndicator(false)
                             }
                         }
                     }