AZEN-SGG/amnezia-client
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

App refactoring finished

Browse source
This commit is contained in:
pokamest 2022-08-25 17:35:28 +03:00
parent 510a564797
commit 3ce1ec708d
46 changed files with 362 additions and 247 deletions
Download patch file Download diff file Expand all files Collapse all files

15
client/amnezia_application.cpp
View file

@ -7,12 +7,11 @@
#include "QZXing.h"
#include "core/servercontroller.h"
#include "debug.h"
#include "defines.h"
#include "platforms/ios/QRCodeReaderBase.h"
//#include "platforms/ios/MobileUtils.h"
#include "ui/pages.h"
@ -49,14 +48,8 @@ AmneziaApplication::AmneziaApplication(int &argc, char *argv[], bool allowSecond
{
setQuitOnLastWindowClosed(false);
m_settings = std::shared_ptr<Settings>(new Settings);
// QObject::connect(&app, &QCoreApplication::aboutToQuit, uiLogic, [&engine, uiLogic](){
// QObject::disconnect(engine, 0,0,0);
// delete engine;
// QObject::disconnect(uiLogic, 0,0,0);
// delete uiLogic;
// });
m_serverController = std::shared_ptr<ServerController>(new ServerController(m_settings, this));
m_configurator = std::shared_ptr<VpnConfigurator>(new VpnConfigurator(m_settings, m_serverController, this));
}
AmneziaApplication::~AmneziaApplication()
@ -71,7 +64,7 @@ AmneziaApplication::~AmneziaApplication()
void AmneziaApplication::init()
{
m_engine = new QQmlApplicationEngine;
m_uiLogic = new UiLogic(m_settings);
m_uiLogic = new UiLogic(m_settings, m_configurator, m_serverController);
const QUrl url(QStringLiteral("qrc:/ui/qml/main.qml"));
QObject::connect(m_engine, &QQmlApplicationEngine::objectCreated,

3
client/amnezia_application.h
View file

@ -11,6 +11,7 @@
#include "settings.h"
#include "ui/uilogic.h"
#include "configurators/vpn_configurator.h"
#if !defined(Q_OS_ANDROID) && !defined(Q_OS_IOS)
#define AMNEZIA_BASE_CLASS SingleApplication
@ -43,6 +44,8 @@ private:
QQmlApplicationEngine *m_engine;
UiLogic *m_uiLogic;
std::shared_ptr<Settings> m_settings;
std::shared_ptr<VpnConfigurator> m_configurator;
std::shared_ptr<ServerController> m_serverController;
QTranslator* m_translator;
QCommandLineParser m_parser;

2
client/client.pro
View file

@ -26,6 +26,7 @@ HEADERS += \
../ipc/ipc.h \
amnezia_application.h \
configurators/cloak_configurator.h \
configurators/configurator_base.h \
configurators/ikev2_configurator.h \
configurators/shadowsocks_configurator.h \
configurators/ssh_configurator.h \
@ -87,6 +88,7 @@ HEADERS += \
SOURCES += \
amnezia_application.cpp \
configurators/cloak_configurator.cpp \
configurators/configurator_base.cpp \
configurators/ikev2_configurator.cpp \
configurators/shadowsocks_configurator.cpp \
configurators/ssh_configurator.cpp \

15
client/configurators/cloak_configurator.cpp
View file

@ -4,18 +4,25 @@
#include <QJsonObject>
#include <QJsonDocument>
#include "core/servercontroller.h"
#include "containers/containers_defs.h"
CloakConfigurator::CloakConfigurator(std::shared_ptr<Settings> settings, std::shared_ptr<ServerController> serverController, QObject *parent):
ConfiguratorBase(settings, serverController, parent)
{
}
QString CloakConfigurator::genCloakConfig(const ServerCredentials &credentials,
DockerContainer container, const QJsonObject &containerConfig, ErrorCode *errorCode)
{
ErrorCode e = ErrorCode::NoError;
QString cloakPublicKey = ServerController::getTextFileFromContainer(container, credentials,
QString cloakPublicKey = m_serverController->getTextFileFromContainer(container, credentials,
amnezia::protocols::cloak::ckPublicKeyPath, &e);
cloakPublicKey.replace("\n", "");
QString cloakBypassUid = ServerController::getTextFileFromContainer(container, credentials,
QString cloakBypassUid = m_serverController->getTextFileFromContainer(container, credentials,
amnezia::protocols::cloak::ckBypassUidKeyPath, &e);
cloakBypassUid.replace("\n", "");
@ -40,8 +47,8 @@ QString CloakConfigurator::genCloakConfig(const ServerCredentials &credentials,
config.insert(config_key::remote, credentials.hostName);
config.insert(config_key::port, "$CLOAK_SERVER_PORT");
QString textCfg = ServerController::replaceVars(QJsonDocument(config).toJson(),
ServerController::genVarsForScript(credentials, container, containerConfig));
QString textCfg = m_serverController->replaceVars(QJsonDocument(config).toJson(),
m_serverController->genVarsForScript(credentials, container, containerConfig));
// qDebug().noquote() << textCfg;
return textCfg;

13
client/configurators/cloak_configurator.h
View file

@ -3,15 +3,18 @@
#include <QObject>
#include "core/defs.h"
#include "settings.h"
#include "core/servercontroller.h"
#include "configurator_base.h"
class CloakConfigurator
using namespace amnezia;
class CloakConfigurator : ConfiguratorBase
{
Q_OBJECT
public:
CloakConfigurator(std::shared_ptr<Settings> settings,
std::shared_ptr<ServerController> serverController, QObject *parent = nullptr);
static QString genCloakConfig(const ServerCredentials &credentials, DockerContainer container,
QString genCloakConfig(const ServerCredentials &credentials, DockerContainer container,
const QJsonObject &containerConfig, ErrorCode *errorCode = nullptr);
};

10
client/configurators/configurator_base.cpp Normal file
View file

@ -0,0 +1,10 @@
#include "configurator_base.h"
ConfiguratorBase::ConfiguratorBase(std::shared_ptr<Settings> settings,
std::shared_ptr<ServerController> serverController, QObject *parent)
: QObject{parent},
m_settings(settings),
m_serverController(serverController)
{
}

25
client/configurators/configurator_base.h Normal file
View file

@ -0,0 +1,25 @@
#ifndef CONFIGURATORBASE_H
#define CONFIGURATORBASE_H
#include <QObject>
class Settings;
class ServerController;
#include "containers/containers_defs.h"
#include "core/defs.h"
class ConfiguratorBase : public QObject
{
Q_OBJECT
public:
explicit ConfiguratorBase(std::shared_ptr<Settings> settings,
std::shared_ptr<ServerController> serverController, QObject *parent = nullptr);
protected:
std::shared_ptr<Settings> m_settings;
std::shared_ptr<ServerController> m_serverController;
};
#endif // CONFIGURATORBASE_H

19
client/configurators/ikev2_configurator.cpp
View file

@ -8,13 +8,18 @@
#include <QJsonDocument>
#include <QUuid>
#include "sftpdefs.h"
#include "core/server_defs.h"
#include "containers/containers_defs.h"
#include "core/server_defs.h"
#include "core/scripts_registry.h"
#include "core/servercontroller.h"
#include "utils.h"
Ikev2Configurator::Ikev2Configurator(std::shared_ptr<Settings> settings, std::shared_ptr<ServerController> serverController, QObject *parent):
ConfiguratorBase(settings, serverController, parent)
{
}
Ikev2Configurator::ConnectionData Ikev2Configurator::prepareIkev2Config(const ServerCredentials &credentials,
DockerContainer container, ErrorCode *errorCode)
{
@ -35,16 +40,16 @@ Ikev2Configurator::ConnectionData Ikev2Configurator::prepareIkev2Config(const Se
"--extKeyUsage serverAuth,clientAuth -8 \"%1\"")
.arg(connData.clientId);
ErrorCode e = ServerController::runContainerScript(credentials, container, scriptCreateCert);
ErrorCode e = m_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);
e = m_serverController->runContainerScript(credentials, container, scriptExportCert);
connData.clientCert = ServerController::getTextFileFromContainer(container, credentials, certFileName, &e);
connData.caCert = ServerController::getTextFileFromContainer(container, credentials, "/etc/ipsec.d/ca_cert_base64.p12", &e);
connData.clientCert = m_serverController->getTextFileFromContainer(container, credentials, certFileName, &e);
connData.caCert = m_serverController->getTextFileFromContainer(container, credentials, "/etc/ipsec.d/ca_cert_base64.p12", &e);
qDebug() << "Ikev2Configurator::ConnectionData client cert size:" << connData.clientCert.size();
qDebug() << "Ikev2Configurator::ConnectionData ca cert size:" << connData.caCert.size();

17
client/configurators/ikev2_configurator.h
View file

@ -4,12 +4,15 @@
#include <QObject>
#include <QProcessEnvironment>
#include "configurator_base.h"
#include "core/defs.h"
#include "core/servercontroller.h"
class Ikev2Configurator
class Ikev2Configurator : ConfiguratorBase
{
Q_OBJECT
public:
Ikev2Configurator(std::shared_ptr<Settings> settings,
std::shared_ptr<ServerController> serverController, QObject *parent = nullptr);
struct ConnectionData {
QByteArray clientCert; // p12 client cert
@ -19,14 +22,14 @@ public:
QString host; // host ip
};
static QString genIkev2Config(const ServerCredentials &credentials, DockerContainer container,
QString genIkev2Config(const ServerCredentials &credentials, DockerContainer container,
const QJsonObject &containerConfig, ErrorCode *errorCode = nullptr);
static QString genIkev2Config(const ConnectionData &connData);
static QString genMobileConfig(const ConnectionData &connData);
static QString genStrongSwanConfig(const ConnectionData &connData);
QString genIkev2Config(const ConnectionData &connData);
QString genMobileConfig(const ConnectionData &connData);
QString genStrongSwanConfig(const ConnectionData &connData);
static ConnectionData prepareIkev2Config(const ServerCredentials &credentials,
ConnectionData prepareIkev2Config(const ServerCredentials &credentials,
DockerContainer container, ErrorCode *errorCode = nullptr);
};

35
client/configurators/openvpn_configurator.cpp
View file

@ -6,16 +6,25 @@
#include <QDebug>
#include <QTemporaryFile>
#include <QJsonObject>
#include <QJsonDocument>
#include "core/server_defs.h"
#include "containers/containers_defs.h"
#include "core/server_defs.h"
#include "core/servercontroller.h"
#include "core/scripts_registry.h"
#include "settings.h"
#include "utils.h"
#include <openssl/rsa.h>
#include <openssl/x509.h>
#include <openssl/pem.h>
OpenVpnConfigurator::OpenVpnConfigurator(std::shared_ptr<Settings> settings, std::shared_ptr<ServerController> serverController, QObject *parent):
ConfiguratorBase(settings, serverController, parent)
{
}
OpenVpnConfigurator::ConnectionData OpenVpnConfigurator::prepareOpenVpnConfig(const ServerCredentials &credentials,
DockerContainer container, ErrorCode *errorCode)
{
@ -31,7 +40,7 @@ OpenVpnConfigurator::ConnectionData OpenVpnConfigurator::prepareOpenVpnConfig(co
arg(amnezia::protocols::openvpn::clientsDirPath).
arg(connData.clientId);
ErrorCode e = ServerController::uploadTextFileToContainer(container, credentials, connData.request, reqFileName);
ErrorCode e = m_serverController->uploadTextFileToContainer(container, credentials, connData.request, reqFileName);
if (e) {
if (errorCode) *errorCode = e;
return connData;
@ -43,8 +52,8 @@ OpenVpnConfigurator::ConnectionData OpenVpnConfigurator::prepareOpenVpnConfig(co
return connData;
}
connData.caCert = ServerController::getTextFileFromContainer(container, credentials, amnezia::protocols::openvpn::caCertPath, &e);
connData.clientCert = ServerController::getTextFileFromContainer(container, credentials,
connData.caCert = m_serverController->getTextFileFromContainer(container, credentials, amnezia::protocols::openvpn::caCertPath, &e);
connData.clientCert = m_serverController->getTextFileFromContainer(container, credentials,
QString("%1/%2.crt").arg(amnezia::protocols::openvpn::clientCertPath).arg(connData.clientId), &e);
if (e) {
@ -52,7 +61,7 @@ OpenVpnConfigurator::ConnectionData OpenVpnConfigurator::prepareOpenVpnConfig(co
return connData;
}
connData.taKey = ServerController::getTextFileFromContainer(container, credentials, amnezia::protocols::openvpn::taKeyPath, &e);
connData.taKey = m_serverController->getTextFileFromContainer(container, credentials, amnezia::protocols::openvpn::taKeyPath, &e);
if (connData.caCert.isEmpty() || connData.clientCert.isEmpty() || connData.taKey.isEmpty()) {
if (errorCode) *errorCode = ErrorCode::RemoteProcessCrashError;
@ -61,17 +70,11 @@ OpenVpnConfigurator::ConnectionData OpenVpnConfigurator::prepareOpenVpnConfig(co
return connData;
}
Settings &OpenVpnConfigurator::m_settings()
{
static Settings s;
return s;
}
QString OpenVpnConfigurator::genOpenVpnConfig(const ServerCredentials &credentials,
DockerContainer container, const QJsonObject &containerConfig, ErrorCode *errorCode)
{
QString config = ServerController::replaceVars(amnezia::scriptData(ProtocolScriptType::openvpn_template, container),
ServerController::genVarsForScript(credentials, container, containerConfig));
QString config = m_serverController->replaceVars(amnezia::scriptData(ProtocolScriptType::openvpn_template, container),
m_serverController->genVarsForScript(credentials, container, containerConfig));
ConnectionData connData = prepareOpenVpnConfig(credentials, container, errorCode);
if (errorCode && *errorCode) {
@ -105,7 +108,7 @@ QString OpenVpnConfigurator::processConfigWithLocalSettings(QString jsonConfig)
QJsonObject json = QJsonDocument::fromJson(jsonConfig.toUtf8()).object();
QString config = json[config_key::config].toString();
if (m_settings().routeMode() != Settings::VpnAllSites) {
if (m_settings->routeMode() != Settings::VpnAllSites) {
config.replace("redirect-gateway def1 bypass-dhcp", "");
}
else {
@ -161,9 +164,9 @@ ErrorCode OpenVpnConfigurator::signCert(DockerContainer container,
.arg(clientId);
QStringList scriptList {script_import, script_sign};
QString script = ServerController::replaceVars(scriptList.join("\n"), ServerController::genVarsForScript(credentials, container));
QString script = m_serverController->replaceVars(scriptList.join("\n"), m_serverController->genVarsForScript(credentials, container));
return ServerController::runScript(credentials, script);
return m_serverController->runScript(credentials, script);
}
OpenVpnConfigurator::ConnectionData OpenVpnConfigurator::createCertRequest()

21
client/configurators/openvpn_configurator.h
View file

@ -4,13 +4,15 @@
#include <QObject>
#include <QProcessEnvironment>
#include "configurator_base.h"
#include "core/defs.h"
#include "settings.h"
#include "core/servercontroller.h"
class OpenVpnConfigurator
class OpenVpnConfigurator : ConfiguratorBase
{
Q_OBJECT
public:
OpenVpnConfigurator(std::shared_ptr<Settings> settings,
std::shared_ptr<ServerController> serverController, QObject *parent = nullptr);
struct ConnectionData {
QString clientId;
@ -22,22 +24,21 @@ public:
QString host; // host ip
};
static QString genOpenVpnConfig(const ServerCredentials &credentials, DockerContainer container,
QString genOpenVpnConfig(const ServerCredentials &credentials, DockerContainer container,
const QJsonObject &containerConfig, ErrorCode *errorCode = nullptr);
static QString processConfigWithLocalSettings(QString jsonConfig);
static QString processConfigWithExportSettings(QString jsonConfig);
QString processConfigWithLocalSettings(QString jsonConfig);
QString processConfigWithExportSettings(QString jsonConfig);
static ErrorCode signCert(DockerContainer container,
ErrorCode signCert(DockerContainer container,
const ServerCredentials &credentials, QString clientId);
private:
static ConnectionData createCertRequest();
ConnectionData createCertRequest();
static ConnectionData prepareOpenVpnConfig(const ServerCredentials &credentials,
ConnectionData prepareOpenVpnConfig(const ServerCredentials &credentials,
DockerContainer container, ErrorCode *errorCode = nullptr);
static Settings &m_settings();
};
#endif // OPENVPN_CONFIGURATOR_H

13
client/configurators/shadowsocks_configurator.cpp
View file

@ -5,13 +5,20 @@
#include <QJsonDocument>
#include "containers/containers_defs.h"
#include "core/servercontroller.h"
ShadowSocksConfigurator::ShadowSocksConfigurator(std::shared_ptr<Settings> settings, std::shared_ptr<ServerController> serverController, QObject *parent):
ConfiguratorBase(settings, serverController, parent)
{
}
QString ShadowSocksConfigurator::genShadowSocksConfig(const ServerCredentials &credentials,
DockerContainer container, const QJsonObject &containerConfig, ErrorCode *errorCode)
{
ErrorCode e = ErrorCode::NoError;
QString ssKey = ServerController::getTextFileFromContainer(container, credentials,
QString ssKey = m_serverController->getTextFileFromContainer(container, credentials,
amnezia::protocols::shadowsocks::ssKeyPath, &e);
ssKey.replace("\n", "");
@ -29,8 +36,8 @@ QString ShadowSocksConfigurator::genShadowSocksConfig(const ServerCredentials &c
config.insert("method", "$SHADOWSOCKS_CIPHER");
QString textCfg = ServerController::replaceVars(QJsonDocument(config).toJson(),
ServerController::genVarsForScript(credentials, container, containerConfig));
QString textCfg = m_serverController->replaceVars(QJsonDocument(config).toJson(),
m_serverController->genVarsForScript(credentials, container, containerConfig));
//qDebug().noquote() << textCfg;
return textCfg;

10
client/configurators/shadowsocks_configurator.h
View file

@ -3,15 +3,17 @@
#include <QObject>
#include "configurator_base.h"
#include "core/defs.h"
#include "settings.h"
#include "core/servercontroller.h"
class ShadowSocksConfigurator
class ShadowSocksConfigurator : ConfiguratorBase
{
Q_OBJECT
public:
ShadowSocksConfigurator(std::shared_ptr<Settings> settings,
std::shared_ptr<ServerController> serverController, QObject *parent = nullptr);
static QString genShadowSocksConfig(const ServerCredentials &credentials, DockerContainer container,
QString genShadowSocksConfig(const ServerCredentials &credentials, DockerContainer container,
const QJsonObject &containerConfig, ErrorCode *errorCode = nullptr);
};

7
client/configurators/ssh_configurator.cpp
View file

@ -14,8 +14,15 @@
#include "core/server_defs.h"
#include "utils.h"
#include "sftpdefs.h"
using namespace QSsh;
SshConfigurator::SshConfigurator(std::shared_ptr<Settings> settings, std::shared_ptr<ServerController> serverController, QObject *parent):
ConfiguratorBase(settings, serverController, parent)
{
}
QString SshConfigurator::convertOpenSShKey(const QString &key)
{

15
client/configurators/ssh_configurator.h
View file

@ -4,16 +4,19 @@
#include <QObject>
#include <QProcessEnvironment>
#include "configurator_base.h"
#include "core/defs.h"
#include "settings.h"
#include "core/servercontroller.h"
class SshConfigurator
class SshConfigurator : ConfiguratorBase
{
Q_OBJECT
public:
static QProcessEnvironment prepareEnv();
static QString convertOpenSShKey(const QString &key);
static void openSshTerminal(const ServerCredentials &credentials);
SshConfigurator(std::shared_ptr<Settings> settings,
std::shared_ptr<ServerController> serverController, QObject *parent = nullptr);
QProcessEnvironment prepareEnv();
QString convertOpenSShKey(const QString &key);
void openSshTerminal(const ServerCredentials &credentials);
};

38
client/configurators/vpn_configurator.cpp
View file

@ -4,18 +4,26 @@
#include "shadowsocks_configurator.h"
#include "wireguard_configurator.h"
#include "ikev2_configurator.h"
#include "ssh_configurator.h"
#include <QFile>
#include <QJsonObject>
#include <QJsonDocument>
#include "containers/containers_defs.h"
#include "settings.h"
#include "utils.h"
Settings &VpnConfigurator::m_settings()
VpnConfigurator::VpnConfigurator(std::shared_ptr<Settings> settings,
std::shared_ptr<ServerController> serverController, QObject *parent):
ConfiguratorBase(settings, serverController, parent)
{
static Settings s;
return s;
openVpnConfigurator = std::shared_ptr<OpenVpnConfigurator>(new OpenVpnConfigurator(settings, serverController, this));
shadowSocksConfigurator = std::shared_ptr<ShadowSocksConfigurator>(new ShadowSocksConfigurator(settings, serverController, this));
cloakConfigurator = std::shared_ptr<CloakConfigurator>(new CloakConfigurator(settings, serverController, this));
wireguardConfigurator = std::shared_ptr<WireguardConfigurator>(new WireguardConfigurator(settings, serverController, this));
ikev2Configurator = std::shared_ptr<Ikev2Configurator>(new Ikev2Configurator(settings, serverController, this));
sshConfigurator = std::shared_ptr<SshConfigurator>(new SshConfigurator(settings, serverController, this));
}
QString VpnConfigurator::genVpnProtocolConfig(const ServerCredentials &credentials,
@ -23,19 +31,19 @@ QString VpnConfigurator::genVpnProtocolConfig(const ServerCredentials &credentia
{
switch (proto) {
case Proto::OpenVpn:
return OpenVpnConfigurator::genOpenVpnConfig(credentials, container, containerConfig, errorCode);
return openVpnConfigurator->genOpenVpnConfig(credentials, container, containerConfig, errorCode);
case Proto::ShadowSocks:
return ShadowSocksConfigurator::genShadowSocksConfig(credentials, container, containerConfig, errorCode);
return shadowSocksConfigurator->genShadowSocksConfig(credentials, container, containerConfig, errorCode);
case Proto::Cloak:
return CloakConfigurator::genCloakConfig(credentials, container, containerConfig, errorCode);
return cloakConfigurator->genCloakConfig(credentials, container, containerConfig, errorCode);
case Proto::WireGuard:
return WireguardConfigurator::genWireguardConfig(credentials, container, containerConfig, errorCode);
return wireguardConfigurator->genWireguardConfig(credentials, container, containerConfig, errorCode);
case Proto::Ikev2:
return Ikev2Configurator::genIkev2Config(credentials, container, containerConfig, errorCode);
return ikev2Configurator->genIkev2Config(credentials, container, containerConfig, errorCode);
default:
return "";
@ -46,20 +54,20 @@ QPair<QString, QString> VpnConfigurator::getDnsForConfig(int serverIndex)
{
QPair<QString, QString> dns;
bool useAmneziaDns = m_settings().useAmneziaDns();
const QJsonObject &server = m_settings().server(serverIndex);
bool useAmneziaDns = m_settings->useAmneziaDns();
const QJsonObject &server = m_settings->server(serverIndex);
dns.first = server.value(config_key::dns1).toString();
dns.second = server.value(config_key::dns2).toString();
if (dns.first.isEmpty() || !Utils::checkIPv4Format(dns.first)) {
if (useAmneziaDns && m_settings().containers(serverIndex).contains(DockerContainer::Dns)) {
if (useAmneziaDns && m_settings->containers(serverIndex).contains(DockerContainer::Dns)) {
dns.first = protocols::dns::amneziaDnsIp;
}
else dns.first = m_settings().primaryDns();
else dns.first = m_settings->primaryDns();
}
if (dns.second.isEmpty() || !Utils::checkIPv4Format(dns.second)) {
dns.second = m_settings().secondaryDns();
dns.second = m_settings->secondaryDns();
}
qDebug() << "VpnConfigurator::getDnsForConfig" << dns.first << dns.second;
@ -83,7 +91,7 @@ QString &VpnConfigurator::processConfigWithLocalSettings(int serverIndex, Docker
processConfigWithDnsSettings(serverIndex, container, proto, config);
if (proto == Proto::OpenVpn) {
config = OpenVpnConfigurator::processConfigWithLocalSettings(config);
config = openVpnConfigurator->processConfigWithLocalSettings(config);
}
return config;
}
@ -94,7 +102,7 @@ QString &VpnConfigurator::processConfigWithExportSettings(int serverIndex, Docke
processConfigWithDnsSettings(serverIndex, container, proto, config);
if (proto == Proto::OpenVpn) {
config = OpenVpnConfigurator::processConfigWithExportSettings(config);
config = openVpnConfigurator->processConfigWithExportSettings(config);
}
return config;
}

37
client/configurators/vpn_configurator.h
View file

@ -3,29 +3,46 @@
#include <QObject>
#include "configurator_base.h"
#include "core/defs.h"
#include "settings.h"
#include "core/servercontroller.h"
class OpenVpnConfigurator;
class ShadowSocksConfigurator;
class CloakConfigurator;
class WireguardConfigurator;
class Ikev2Configurator;
class SshConfigurator;
// Retrieve connection settings from server
class VpnConfigurator
class VpnConfigurator : ConfiguratorBase
{
Q_OBJECT
public:
VpnConfigurator(std::shared_ptr<Settings> settings,
std::shared_ptr<ServerController> serverController, QObject *parent = nullptr);
static QString genVpnProtocolConfig(const ServerCredentials &credentials, DockerContainer container,
QString genVpnProtocolConfig(const ServerCredentials &credentials, DockerContainer container,
const QJsonObject &containerConfig, Proto proto, ErrorCode *errorCode = nullptr);
static QPair<QString, QString> getDnsForConfig(int serverIndex);
static QString &processConfigWithDnsSettings(int serverIndex, DockerContainer container, Proto proto, QString &config);
QPair<QString, QString> getDnsForConfig(int serverIndex);
QString &processConfigWithDnsSettings(int serverIndex, DockerContainer container, Proto proto, QString &config);
static QString &processConfigWithLocalSettings(int serverIndex, DockerContainer container, Proto proto, QString &config);
static QString &processConfigWithExportSettings(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);
// workaround for containers which is not support normal configaration
static void updateContainerConfigAfterInstallation(DockerContainer container,
void updateContainerConfigAfterInstallation(DockerContainer container,
QJsonObject &containerConfig, const QString &stdOut);
static Settings &m_settings();
std::shared_ptr<ServerController> m_serverController;
std::shared_ptr<OpenVpnConfigurator> openVpnConfigurator;
std::shared_ptr<ShadowSocksConfigurator> shadowSocksConfigurator;
std::shared_ptr<CloakConfigurator> cloakConfigurator;
std::shared_ptr<WireguardConfigurator> wireguardConfigurator;
std::shared_ptr<Ikev2Configurator> ikev2Configurator;
std::shared_ptr<SshConfigurator> sshConfigurator;
};
#endif // VPN_CONFIGURATOR_H

45
client/configurators/wireguard_configurator.cpp
View file

@ -5,19 +5,28 @@
#include <QTemporaryDir>
#include <QDebug>
#include <QTemporaryFile>
#include <QJsonDocument>
#include <openssl/rand.h>
#include <openssl/rsa.h>
#include <openssl/x509.h>
#include <openssl/pem.h>
#include "sftpdefs.h"
#include "core/server_defs.h"
#include "containers/containers_defs.h"
#include "core/server_defs.h"
#include "core/scripts_registry.h"
#include "core/servercontroller.h"
#include "settings.h"
#include "utils.h"
WireguardConfigurator::WireguardConfigurator(std::shared_ptr<Settings> settings, std::shared_ptr<ServerController> serverController, QObject *parent):
ConfiguratorBase(settings, serverController, parent)
{
}
WireguardConfigurator::ConnectionData WireguardConfigurator::genClientKeys()
{
// TODO review
@ -71,7 +80,7 @@ WireguardConfigurator::ConnectionData WireguardConfigurator::prepareWireguardCon
stdOut += data + "\n";
};
ServerController::runContainerScript(credentials, container, script, cbReadStdOut);
m_serverController->runContainerScript(credentials, container, script, cbReadStdOut);
stdOut.replace("AllowedIPs = ", "");
stdOut.replace("/32", "");
QStringList ips = stdOut.split("\n", Qt::SkipEmptyParts);
@ -104,14 +113,14 @@ WireguardConfigurator::ConnectionData WireguardConfigurator::prepareWireguardCon
}
// Get keys
connData.serverPubKey = ServerController::getTextFileFromContainer(container, credentials, amnezia::protocols::wireguard::serverPublicKeyPath, &e);
connData.serverPubKey = m_serverController->getTextFileFromContainer(container, credentials, amnezia::protocols::wireguard::serverPublicKeyPath, &e);
connData.serverPubKey.replace("\n", "");
if (e) {
if (errorCode) *errorCode = e;
return connData;
}
connData.pskKey = ServerController::getTextFileFromContainer(container, credentials, amnezia::protocols::wireguard::serverPskKeyPath, &e);
connData.pskKey = m_serverController->getTextFileFromContainer(container, credentials, amnezia::protocols::wireguard::serverPskKeyPath, &e);
connData.pskKey.replace("\n", "");
if (e) {
@ -129,7 +138,7 @@ WireguardConfigurator::ConnectionData WireguardConfigurator::prepareWireguardCon
arg(connData.pskKey).
arg(connData.clientIP);
e = ServerController::uploadTextFileToContainer(container, credentials, configPart,
e = m_serverController->uploadTextFileToContainer(container, credentials, configPart,
protocols::wireguard::serverConfigPath, QSsh::SftpOverwriteMode::SftpAppendToExisting);
if (e) {
@ -137,24 +146,18 @@ WireguardConfigurator::ConnectionData WireguardConfigurator::prepareWireguardCon
return connData;
}
e = 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)));
e = m_serverController->runScript(credentials,
m_serverController->replaceVars("sudo docker exec -i $CONTAINER_NAME bash -c 'wg syncconf wg0 <(wg-quick strip /opt/amnezia/wireguard/wg0.conf)'",
m_serverController->genVarsForScript(credentials, container)));
return connData;
}
Settings &WireguardConfigurator::m_settings()
{
static Settings s;
return s;
}
QString WireguardConfigurator::genWireguardConfig(const ServerCredentials &credentials,
DockerContainer container, const QJsonObject &containerConfig, ErrorCode *errorCode)
{
QString config = ServerController::replaceVars(amnezia::scriptData(ProtocolScriptType::wireguard_template, container),
ServerController::genVarsForScript(credentials, container, containerConfig));
QString config = m_serverController->replaceVars(amnezia::scriptData(ProtocolScriptType::wireguard_template, container),
m_serverController->genVarsForScript(credentials, container, containerConfig));
ConnectionData connData = prepareWireguardConfig(credentials, container, containerConfig, errorCode);
if (errorCode && *errorCode) {
@ -182,8 +185,8 @@ QString WireguardConfigurator::genWireguardConfig(const ServerCredentials &crede
QString WireguardConfigurator::processConfigWithLocalSettings(QString config)
{
// TODO replace DNS if it already set
config.replace("$PRIMARY_DNS", m_settings().primaryDns());
config.replace("$SECONDARY_DNS", m_settings().secondaryDns());
config.replace("$PRIMARY_DNS", m_settings->primaryDns());
config.replace("$SECONDARY_DNS", m_settings->secondaryDns());
QJsonObject jConfig;
jConfig[config_key::config] = config;
@ -193,8 +196,8 @@ QString WireguardConfigurator::processConfigWithLocalSettings(QString config)
QString WireguardConfigurator::processConfigWithExportSettings(QString config)
{
config.replace("$PRIMARY_DNS", m_settings().primaryDns());
config.replace("$SECONDARY_DNS", m_settings().secondaryDns());
config.replace("$PRIMARY_DNS", m_settings->primaryDns());
config.replace("$SECONDARY_DNS", m_settings->secondaryDns());
return config;
}

20
client/configurators/wireguard_configurator.h
View file

@ -4,13 +4,15 @@
#include <QObject>
#include <QProcessEnvironment>
#include "configurator_base.h"
#include "core/defs.h"
#include "settings.h"
#include "core/servercontroller.h"
class WireguardConfigurator
class WireguardConfigurator : ConfiguratorBase
{
Q_OBJECT
public:
WireguardConfigurator(std::shared_ptr<Settings> settings,
std::shared_ptr<ServerController> serverController, QObject *parent = nullptr);
struct ConnectionData {
QString clientPrivKey; // client private key
@ -21,20 +23,18 @@ public:
QString host; // host ip
};
static QString genWireguardConfig(const ServerCredentials &credentials, DockerContainer container,
QString genWireguardConfig(const ServerCredentials &credentials, DockerContainer container,
const QJsonObject &containerConfig, ErrorCode *errorCode = nullptr);
static QString processConfigWithLocalSettings(QString config);
static QString processConfigWithExportSettings(QString config);
QString processConfigWithLocalSettings(QString config);
QString processConfigWithExportSettings(QString config);
private:
static ConnectionData prepareWireguardConfig(const ServerCredentials &credentials,
ConnectionData prepareWireguardConfig(const ServerCredentials &credentials,
DockerContainer container, const QJsonObject &containerConfig, ErrorCode *errorCode = nullptr);
static ConnectionData genClientKeys();
static Settings &m_settings();
ConnectionData genClientKeys();
};
#endif // WIREGUARD_CONFIGURATOR_H

14
client/core/servercontroller.cpp
View file

@ -18,18 +18,18 @@
#include "containers/containers_defs.h"
#include "server_defs.h"
#include "settings.h"
#include "scripts_registry.h"
#include "utils.h"
#include <configurators/vpn_configurator.h>
using namespace QSsh;
Settings &ServerController::m_settings()
ServerController::ServerController(std::shared_ptr<Settings> settings, QObject *parent) :
m_settings(settings)
{
static Settings s;
return s;
}
ErrorCode ServerController::runScript(const ServerCredentials &credentials, QString script,
@ -605,7 +605,7 @@ ErrorCode ServerController::configureContainerWorker(const ServerCredentials &cr
cbReadStdOut, cbReadStdErr);
VpnConfigurator::updateContainerConfigAfterInstallation(container, config, stdOut);
m_configurator->updateContainerConfigAfterInstallation(container, config, stdOut);
return e;
}
@ -698,8 +698,8 @@ ServerController::Vars ServerController::genVarsForScript(const ServerCredential
vars.append({{"$IPSEC_VPN_C2C_TRAFFIC", "no"}});
vars.append({{"$PRIMARY_SERVER_DNS", m_settings().primaryDns()}});
vars.append({{"$SECONDARY_SERVER_DNS", m_settings().secondaryDns()}});
vars.append({{"$PRIMARY_SERVER_DNS", m_settings->primaryDns()}});
vars.append({{"$SECONDARY_SERVER_DNS", m_settings->secondaryDns()}});
// Sftp vars

63
client/core/servercontroller.h
View file

@ -7,78 +7,83 @@
#include "sshremoteprocess.h"
#include "debug.h"
#include "defs.h"
#include "settings.h"
#include "containers/containers_defs.h"
#include "sftpdefs.h"
class Settings;
class VpnConfigurator;
using namespace amnezia;
class ServerController : public QObject
{
Q_OBJECT
public:
ServerController(std::shared_ptr<Settings> settings, QObject *parent = nullptr);
typedef QList<QPair<QString, QString>> Vars;
static ErrorCode fromSshConnectionErrorCode(QSsh::SshError error);
ErrorCode fromSshConnectionErrorCode(QSsh::SshError error);
// QSsh exitCode and exitStatus are different things
static ErrorCode fromSshProcessExitStatus(int exitStatus);
ErrorCode fromSshProcessExitStatus(int exitStatus);
static QSsh::SshConnectionParameters sshParams(const ServerCredentials &credentials);
static void disconnectFromHost(const ServerCredentials &credentials);
QSsh::SshConnectionParameters sshParams(const ServerCredentials &credentials);
void disconnectFromHost(const ServerCredentials &credentials);
static ErrorCode removeAllContainers(const ServerCredentials &credentials);
static ErrorCode removeContainer(const ServerCredentials &credentials, DockerContainer container);
static ErrorCode setupContainer(const ServerCredentials &credentials, DockerContainer container, QJsonObject &config);
static ErrorCode updateContainer(const ServerCredentials &credentials, DockerContainer container,
ErrorCode removeAllContainers(const ServerCredentials &credentials);
ErrorCode removeContainer(const ServerCredentials &credentials, DockerContainer container);
ErrorCode setupContainer(const ServerCredentials &credentials, DockerContainer container, QJsonObject &config);
ErrorCode updateContainer(const ServerCredentials &credentials, DockerContainer container,
const QJsonObject &oldConfig, QJsonObject &newConfig);
// create initial config - generate passwords, etc
static QJsonObject createContainerInitialConfig(DockerContainer container, int port, TransportProto tp);
QJsonObject createContainerInitialConfig(DockerContainer container, int port, TransportProto tp);
static bool isReinstallContainerRequred(DockerContainer container, const QJsonObject &oldConfig, const QJsonObject &newConfig);
bool isReinstallContainerRequred(DockerContainer container, const QJsonObject &oldConfig, const QJsonObject &newConfig);
static ErrorCode checkOpenVpnServer(DockerContainer container, const ServerCredentials &credentials);
ErrorCode checkOpenVpnServer(DockerContainer container, const ServerCredentials &credentials);
static ErrorCode uploadFileToHost(const ServerCredentials &credentials, const QByteArray &data,
ErrorCode uploadFileToHost(const ServerCredentials &credentials, const QByteArray &data,
const QString &remotePath, QSsh::SftpOverwriteMode overwriteMode = QSsh::SftpOverwriteMode::SftpOverwriteExisting);
static ErrorCode uploadTextFileToContainer(DockerContainer container,
ErrorCode uploadTextFileToContainer(DockerContainer container,
const ServerCredentials &credentials, const QString &file, const QString &path,
QSsh::SftpOverwriteMode overwriteMode = QSsh::SftpOverwriteMode::SftpOverwriteExisting);
static QByteArray getTextFileFromContainer(DockerContainer container,
QByteArray getTextFileFromContainer(DockerContainer container,
const ServerCredentials &credentials, const QString &path, ErrorCode *errorCode = nullptr);
static ErrorCode setupServerFirewall(const ServerCredentials &credentials);
ErrorCode setupServerFirewall(const ServerCredentials &credentials);
static QString replaceVars(const QString &script, const Vars &vars);
QString replaceVars(const QString &script, const Vars &vars);
static ErrorCode runScript(const ServerCredentials &credentials, QString script,
ErrorCode runScript(const ServerCredentials &credentials, QString script,
const std::function<void(const QString &, QSharedPointer<QSsh::SshRemoteProcess>)> &cbReadStdOut = nullptr,
const std::function<void(const QString &, QSharedPointer<QSsh::SshRemoteProcess>)> &cbReadStdErr = nullptr);
static ErrorCode runContainerScript(const ServerCredentials &credentials, DockerContainer container, QString script,
ErrorCode runContainerScript(const ServerCredentials &credentials, DockerContainer container, QString script,
const std::function<void(const QString &, QSharedPointer<QSsh::SshRemoteProcess>)> &cbReadStdOut = nullptr,
const std::function<void(const QString &, QSharedPointer<QSsh::SshRemoteProcess>)> &cbReadStdErr = nullptr);
static Vars genVarsForScript(const ServerCredentials &credentials, DockerContainer container = DockerContainer::None, const QJsonObject &config = QJsonObject());
Vars genVarsForScript(const ServerCredentials &credentials, DockerContainer container = DockerContainer::None, const QJsonObject &config = QJsonObject());
static QString checkSshConnection(const ServerCredentials &credentials, ErrorCode *errorCode = nullptr);
static QSsh::SshConnection *connectToHost(const QSsh::SshConnectionParameters &sshParams);
QString checkSshConnection(const ServerCredentials &credentials, ErrorCode *errorCode = nullptr);
QSsh::SshConnection *connectToHost(const QSsh::SshConnectionParameters &sshParams);
private:
static ErrorCode installDockerWorker(const ServerCredentials &credentials, DockerContainer container);
static ErrorCode prepareHostWorker(const ServerCredentials &credentials, DockerContainer container, const QJsonObject &config = QJsonObject());
static ErrorCode buildContainerWorker(const ServerCredentials &credentials, DockerContainer container, const QJsonObject &config = QJsonObject());
static ErrorCode runContainerWorker(const ServerCredentials &credentials, DockerContainer container, QJsonObject &config);
static ErrorCode configureContainerWorker(const ServerCredentials &credentials, DockerContainer container, QJsonObject &config);
static ErrorCode startupContainerWorker(const ServerCredentials &credentials, DockerContainer container, const QJsonObject &config = QJsonObject());
ErrorCode installDockerWorker(const ServerCredentials &credentials, DockerContainer container);
ErrorCode prepareHostWorker(const ServerCredentials &credentials, DockerContainer container, const QJsonObject &config = QJsonObject());
ErrorCode buildContainerWorker(const ServerCredentials &credentials, DockerContainer container, const QJsonObject &config = QJsonObject());
ErrorCode runContainerWorker(const ServerCredentials &credentials, DockerContainer container, QJsonObject &config);
ErrorCode configureContainerWorker(const ServerCredentials &credentials, DockerContainer container, QJsonObject &config);
ErrorCode startupContainerWorker(const ServerCredentials &credentials, DockerContainer container, const QJsonObject &config = QJsonObject());
static Settings &m_settings();
std::shared_ptr<Settings> m_settings;
std::shared_ptr<VpnConfigurator> m_configurator;
};
#endif // SERVERCONTROLLER_H

1
client/protocols/openvpnovercloakprotocol.cpp
View file

@ -1,5 +1,4 @@
#include "openvpnovercloakprotocol.h"
#include "core/servercontroller.h"
#include "utils.h"
#include "containers/containers_defs.h"

1
client/protocols/shadowsocksvpnprotocol.cpp
View file

@ -1,5 +1,4 @@
#include "shadowsocksvpnprotocol.h"
#include "core/servercontroller.h"
#include "debug.h"
#include "utils.h"

1
client/ui/pages_logic/NetworkSettingsLogic.cpp
View file

@ -1,6 +1,7 @@
#include "NetworkSettingsLogic.h"
#include "defines.h"
#include "settings.h"
#include "utils.h"
NetworkSettingsLogic::NetworkSettingsLogic(UiLogic *logic, QObject *parent):

1
client/ui/pages_logic/NewServerProtocolsLogic.h
View file

@ -2,6 +2,7 @@
#define NEW_SERVER_PROTOCOLS_LOGIC_H
#include "PageLogicBase.h"
#include "containers/containers_defs.h"
class UiLogic;

6
client/ui/pages_logic/PageLogicBase.cpp
View file

@ -1,6 +1,8 @@
#include "PageLogicBase.h"
#include "ui/uilogic.h"
#include "ui/uilogic.h"
#include "settings.h"
#include "configurators/vpn_configurator.h"
PageLogicBase::PageLogicBase(UiLogic *logic, QObject *parent):
QObject(parent),
@ -8,6 +10,8 @@ PageLogicBase::PageLogicBase(UiLogic *logic, QObject *parent):
m_uiLogic(logic)
{
m_settings = logic->m_settings;
m_configurator = logic->m_configurator;
m_serverController = logic->m_serverController;
}

13
client/ui/pages_logic/PageLogicBase.h
View file

@ -1,14 +1,15 @@
#ifndef PAGE_LOGIC_BASE_H
#define PAGE_LOGIC_BASE_H
#include "settings.h"
#include "../pages.h"
#include "../property_helper.h"
using namespace amnezia;
using namespace PageEnumNS;
class UiLogic;
class Settings;
class VpnConfigurator;
class ServerController;
class PageLogicBase : public QObject
{
@ -22,10 +23,12 @@ public:
Q_INVOKABLE virtual void onUpdatePage() {}
protected:
UiLogic *uiLogic() const { return m_uiLogic; }
std::shared_ptr<Settings> m_settings;
UiLogic *m_uiLogic;
UiLogic *uiLogic() const { return m_uiLogic; }
std::shared_ptr<Settings> m_settings;
std::shared_ptr<VpnConfigurator> m_configurator;
std::shared_ptr<ServerController> m_serverController;
signals:
void updatePage();

3
client/ui/pages_logic/ServerConfiguringProgressLogic.h
View file

@ -3,6 +3,9 @@
#include <functional>
#include "PageLogicBase.h"
#include "core/defs.h"
using namespace amnezia;
class UiLogic;

6
client/ui/pages_logic/ServerContainersLogic.cpp
View file

@ -67,7 +67,7 @@ void ServerContainersLogic::onPushButtonShareClicked(DockerContainer c)
void ServerContainersLogic::onPushButtonRemoveClicked(DockerContainer container)
{
//buttonSetEnabledFunc(false);
ErrorCode e = ServerController::removeContainer(m_settings->serverCredentials(uiLogic()->selectedServerIndex), container);
ErrorCode e = m_serverController->removeContainer(m_settings->serverCredentials(uiLogic()->selectedServerIndex), container);
m_settings->removeContainerConfig(uiLogic()->selectedServerIndex, container);
//buttonSetEnabledFunc(true);
@ -81,13 +81,13 @@ void ServerContainersLogic::onPushButtonRemoveClicked(DockerContainer container)
void ServerContainersLogic::onPushButtonContinueClicked(DockerContainer c, int port, TransportProto tp)
{
QJsonObject config = ServerController::createContainerInitialConfig(c, port, tp);
QJsonObject config = m_serverController->createContainerInitialConfig(c, port, tp);
emit uiLogic()->goToPage(Page::ServerConfiguringProgress);
qApp->processEvents();
ErrorCode e = uiLogic()->serverConfiguringProgressLogic()->doInstallAction([this, c, &config](){
return ServerController::setupContainer(m_settings->serverCredentials(uiLogic()->selectedServerIndex), c, config);
return m_serverController->setupContainer(m_settings->serverCredentials(uiLogic()->selectedServerIndex), c, config);
});
if (!e) {

1
client/ui/pages_logic/ServerContainersLogic.h
View file

@ -2,6 +2,7 @@
#define SERVER_CONTAINERS_LOGIC_H
#include "PageLogicBase.h"
#include "containers/containers_defs.h"
class UiLogic;

6
client/ui/pages_logic/ServerSettingsLogic.cpp
View file

@ -52,10 +52,10 @@ void ServerSettingsLogic::onPushButtonClearServer()
uiLogic()->vpnLogic()->onDisconnect();
}
ErrorCode e = ServerController::removeAllContainers(m_settings->serverCredentials(uiLogic()->selectedServerIndex));
ServerController::disconnectFromHost(m_settings->serverCredentials(uiLogic()->selectedServerIndex));
ErrorCode e = m_serverController->removeAllContainers(m_settings->serverCredentials(uiLogic()->selectedServerIndex));
m_serverController->disconnectFromHost(m_settings->serverCredentials(uiLogic()->selectedServerIndex));
if (e) {
uiLogic()->setDialogConnectErrorText(
uiLogic()->set_dialogConnectErrorText(
tr("Error occurred while configuring server.") + "\n" +
errorString(e) + "\n" +
tr("See logs for details."));

27
client/ui/pages_logic/ShareConnectionLogic.cpp
View file

@ -21,6 +21,7 @@
#include "defines.h"
#include "core/defs.h"
#include "core/errorstrings.h"
#include "core/servercontroller.h"
#include <functional>
#include "../uilogic.h"
@ -85,7 +86,7 @@ void ShareConnectionLogic::onPushButtonShareAmneziaGenerateClicked()
for (Proto p: ContainerProps::protocolsForContainer(container)) {
QJsonObject protoConfig = m_settings->protocolConfig(serverIndex, container, p);
QString cfg = VpnConfigurator::genVpnProtocolConfig(credentials, container, containerConfig, p, &e);
QString cfg = m_configurator->genVpnProtocolConfig(credentials, container, containerConfig, p, &e);
if (e) {
cfg = "Error generating config";
break;
@ -103,7 +104,7 @@ void ShareConnectionLogic::onPushButtonShareAmneziaGenerateClicked()
serverConfig.insert(config_key::containers, QJsonArray {containerConfig});
serverConfig.insert(config_key::defaultContainer, ContainerProps::containerToString(container));
auto dns = VpnConfigurator::getDnsForConfig(serverIndex);
auto dns = m_configurator->getDnsForConfig(serverIndex);
serverConfig.insert(config_key::dns1, dns.first);
serverConfig.insert(config_key::dns2, dns.second);
@ -134,8 +135,8 @@ void ShareConnectionLogic::onPushButtonShareOpenVpnGenerateClicked()
const QJsonObject &containerConfig = m_settings->containerConfig(serverIndex, container);
ErrorCode e = ErrorCode::NoError;
QString cfg = OpenVpnConfigurator::genOpenVpnConfig(credentials, container, containerConfig, &e);
cfg = VpnConfigurator::processConfigWithExportSettings(serverIndex, container, Proto::OpenVpn, cfg);
QString cfg = m_configurator->openVpnConfigurator->genOpenVpnConfig(credentials, container, containerConfig, &e);
cfg = m_configurator->processConfigWithExportSettings(serverIndex, container, Proto::OpenVpn, cfg);
set_textEditShareOpenVpnCodeText(QJsonDocument::fromJson(cfg.toUtf8()).object()[config_key::config].toString());
}
@ -153,7 +154,7 @@ void ShareConnectionLogic::onPushButtonShareShadowSocksGenerateClicked()
const QJsonObject &containerConfig = m_settings->containerConfig(serverIndex, container);
ErrorCode e = ErrorCode::NoError;
cfg = ShadowSocksConfigurator::genShadowSocksConfig(credentials, container, containerConfig, &e);
cfg = m_configurator->shadowSocksConfigurator->genShadowSocksConfig(credentials, container, containerConfig, &e);
}
QJsonObject ssConfig = QJsonDocument::fromJson(cfg.toUtf8()).object();
@ -195,7 +196,7 @@ void ShareConnectionLogic::onPushButtonShareCloakGenerateClicked()
const QJsonObject &containerConfig = m_settings->containerConfig(serverIndex, container);
ErrorCode e = ErrorCode::NoError;
cfg = CloakConfigurator::genCloakConfig(credentials, container, containerConfig, &e);
cfg = m_configurator->cloakConfigurator->genCloakConfig(credentials, container, containerConfig, &e);
}
QJsonObject cloakConfig = QJsonDocument::fromJson(cfg.toUtf8()).object();
@ -214,14 +215,14 @@ void ShareConnectionLogic::onPushButtonShareWireGuardGenerateClicked()
const QJsonObject &containerConfig = m_settings->containerConfig(serverIndex, container);
ErrorCode e = ErrorCode::NoError;
QString cfg = WireguardConfigurator::genWireguardConfig(credentials, container, containerConfig, &e);
QString cfg = m_configurator->wireguardConfigurator->genWireguardConfig(credentials, container, containerConfig, &e);
if (e) {
QMessageBox::warning(nullptr, APPLICATION_NAME,
tr("Error occurred while configuring server.") + "\n" +
errorString(e));
return;
}
cfg = VpnConfigurator::processConfigWithExportSettings(serverIndex, container, Proto::WireGuard, cfg);
cfg = m_configurator->processConfigWithExportSettings(serverIndex, container, Proto::WireGuard, cfg);
cfg = QJsonDocument::fromJson(cfg.toUtf8()).object()[config_key::config].toString();
set_textEditShareWireGuardCodeText(cfg);
@ -239,18 +240,18 @@ void ShareConnectionLogic::onPushButtonShareIkev2GenerateClicked()
//const QJsonObject &containerConfig = m_settings->containerConfig(serverIndex, container);
Ikev2Configurator::ConnectionData connData = Ikev2Configurator::prepareIkev2Config(credentials, container);
Ikev2Configurator::ConnectionData connData = m_configurator->ikev2Configurator->prepareIkev2Config(credentials, container);
QString cfg = Ikev2Configurator::genIkev2Config(connData);
cfg = VpnConfigurator::processConfigWithExportSettings(serverIndex, container, Proto::Ikev2, cfg);
QString cfg = m_configurator->ikev2Configurator->genIkev2Config(connData);
cfg = m_configurator->processConfigWithExportSettings(serverIndex, container, Proto::Ikev2, cfg);
cfg = QJsonDocument::fromJson(cfg.toUtf8()).object()[config_key::cert].toString();
set_textEditShareIkev2CertText(cfg);
QString mobileCfg = Ikev2Configurator::genMobileConfig(connData);
QString mobileCfg = m_configurator->ikev2Configurator->genMobileConfig(connData);
set_textEditShareIkev2MobileConfigText(mobileCfg);
QString strongSwanCfg = Ikev2Configurator::genStrongSwanConfig(connData);
QString strongSwanCfg = m_configurator->ikev2Configurator->genStrongSwanConfig(connData);
set_textEditShareIkev2StrongSwanConfigText(strongSwanCfg);
}

1
client/ui/pages_logic/ShareConnectionLogic.h
View file

@ -2,6 +2,7 @@
#define SHARE_CONNECTION_LOGIC_H
#include "PageLogicBase.h"
#include "containers/containers_defs.h"
class UiLogic;

1
client/ui/pages_logic/SitesLogic.h
View file

@ -2,6 +2,7 @@
#define SITES_LOGIC_H
#include "PageLogicBase.h"
#include "settings.h"
class UiLogic;
class SitesModel;

5
client/ui/pages_logic/StartPageLogic.cpp
View file

@ -1,6 +1,7 @@
#include "StartPageLogic.h"
#include "core/errorstrings.h"
#include "configurators/ssh_configurator.h"
#include "configurators/vpn_configurator.h"
#include "../uilogic.h"
#include "utils.h"
@ -83,7 +84,7 @@ void StartPageLogic::onPushButtonConnect()
}
if (key.contains("OPENSSH") && key.contains("BEGIN") && key.contains("PRIVATE KEY")) {
key = SshConfigurator::convertOpenSShKey(key);
key = m_configurator->sshConfigurator->convertOpenSShKey(key);
}
serverCredentials.password = key;
@ -97,7 +98,7 @@ void StartPageLogic::onPushButtonConnect()
ErrorCode e = ErrorCode::NoError;
#ifdef Q_DEBUG
//QString output = ServerController::checkSshConnection(serverCredentials, &e);
//QString output = m_serverController->checkSshConnection(serverCredentials, &e);
#else
QString output;
#endif

10
client/ui/pages_logic/VpnLogic.cpp
View file

@ -69,7 +69,7 @@ void VpnLogic::onUpdatePage()
QString selectedContainerName = ContainerProps::containerHumanNames().value(selectedContainer);
set_labelCurrentService(selectedContainerName);
auto dns = VpnConfigurator::getDnsForConfig(m_settings->defaultServerIndex());
auto dns = m_configurator->getDnsForConfig(m_settings->defaultServerIndex());
set_amneziaDnsEnabled(dns.first == protocols::dns::amneziaDnsIp);
if (dns.first == protocols::dns::amneziaDnsIp) {
set_labelCurrentDns("On your server");
@ -233,14 +233,6 @@ void VpnLogic::onConnectWorker(int serverIndex, const ServerCredentials &credent
qApp->processEvents();
emit connectToVpn(serverIndex, credentials, container, containerConfig);
// if (errorCode) {
// //ui->pushButton_connect->setChecked(false);
// uiLogic()->setDialogConnectErrorText(errorString(errorCode));
// emit uiLogic()->showConnectErrorDialog();
// return;
// }
}
void VpnLogic::onDisconnect()

1
client/ui/pages_logic/WizardLogic.h
View file

@ -2,6 +2,7 @@
#define WIZARD_LOGIC_H
#include "PageLogicBase.h"
#include "containers/containers_defs.h"
class UiLogic;

2
client/ui/pages_logic/protocols/CloakLogic.cpp
View file

@ -89,7 +89,7 @@ void CloakLogic::onPushButtonSaveClicked()
};
ErrorCode e = uiLogic()->doInstallAction([this, containerConfig, &newContainerConfig](){
return ServerController::updateContainer(m_settings->serverCredentials(uiLogic()->selectedServerIndex), uiLogic()->selectedDockerContainer, containerConfig, newContainerConfig);
return m_serverController->updateContainer(m_settings->serverCredentials(uiLogic()->selectedServerIndex), uiLogic()->selectedDockerContainer, containerConfig, newContainerConfig);
},
page_func, progressBar_reset,
pushButton_save_func, label_info_func);

2
client/ui/pages_logic/protocols/OpenVpnLogic.cpp
View file

@ -118,7 +118,7 @@ void OpenVpnLogic::onPushButtonProtoOpenVpnSaveClicked()
};
ErrorCode e = uiLogic()->doInstallAction([this, containerConfig, &newContainerConfig](){
return ServerController::updateContainer(m_settings->serverCredentials(uiLogic()->selectedServerIndex), uiLogic()->selectedDockerContainer, containerConfig, newContainerConfig);
return m_serverController->updateContainer(m_settings->serverCredentials(uiLogic()->selectedServerIndex), uiLogic()->selectedDockerContainer, containerConfig, newContainerConfig);
},
page_proto_openvpn, progressBar_proto_openvpn_reset,
pushButton_proto_openvpn_save, label_proto_openvpn_info);

1
client/ui/pages_logic/protocols/OtherProtocolsLogic.cpp
View file

@ -5,7 +5,6 @@
#include <QStandardPaths>
#include "OtherProtocolsLogic.h"
#include "core/servercontroller.h"
#include <functional>
#include "../../uilogic.h"
#include "utils.h"

2
client/ui/pages_logic/protocols/ShadowSocksLogic.cpp
View file

@ -82,7 +82,7 @@ void ShadowSocksLogic::onPushButtonSaveClicked()
};
ErrorCode e = uiLogic()->doInstallAction([this, containerConfig, &newContainerConfig](){
return ServerController::updateContainer(m_settings->serverCredentials(uiLogic()->selectedServerIndex), uiLogic()->selectedDockerContainer, containerConfig, newContainerConfig);
return m_serverController->updateContainer(m_settings->serverCredentials(uiLogic()->selectedServerIndex), uiLogic()->selectedDockerContainer, containerConfig, newContainerConfig);
},
page_proto_shadowsocks, progressBar_reset,
pushButton_proto_shadowsocks_save, label_proto_shadowsocks_info);

4
client/ui/property_helper.h
View file

@ -14,7 +14,7 @@
} \
Q_SIGNAL void NAME ## Changed(TYPE value);\
private: \
TYPE m_ ## NAME;
TYPE m_ ## NAME{};
#define READONLY_PROPERTY(TYPE, NAME) \
Q_PROPERTY(TYPE NAME READ NAME CONSTANT ) \
@ -22,6 +22,6 @@
TYPE NAME() const { return m_ ## NAME ; } \
private: \
void NAME(TYPE value) {m_ ## NAME = value; } \
TYPE m_ ## NAME;
TYPE m_ ## NAME{};
#endif // PROPERTY_HELPER_H

28
client/ui/uilogic.cpp
View file

@ -74,14 +74,17 @@
using namespace amnezia;
using namespace PageEnumNS;
UiLogic::UiLogic(std::shared_ptr<Settings> settings, QObject *parent) :
UiLogic::UiLogic(std::shared_ptr<Settings> settings, std::shared_ptr<VpnConfigurator> configurator,
std::shared_ptr<ServerController> serverController,
QObject *parent) :
QObject(parent),
m_settings(settings),
m_dialogConnectErrorText{}
m_configurator(configurator),
m_serverController(serverController)
{
m_containersModel = new ContainersModel(settings, this);
m_protocolsModel = new ProtocolsModel(settings, this);
m_vpnConnection = new VpnConnection(settings);
m_vpnConnection = new VpnConnection(settings, configurator, serverController);
m_vpnConnection->moveToThread(&m_vpnConnectionThread);
m_vpnConnectionThread.start();
@ -173,19 +176,6 @@ void UiLogic::initalizeUiLogic()
qInfo().noquote() << QString("%1 (%2)").arg(QSysInfo::prettyProductName()).arg(QSysInfo::currentCpuArchitecture());
}
QString UiLogic::getDialogConnectErrorText() const
{
return m_dialogConnectErrorText;
}
void UiLogic::setDialogConnectErrorText(const QString &dialogConnectErrorText)
{
if (m_dialogConnectErrorText != dialogConnectErrorText) {
m_dialogConnectErrorText = dialogConnectErrorText;
emit dialogConnectErrorTextChanged();
}
}
void UiLogic::showOnStartup()
{
if (! m_settings->isStartMinimized()) {
@ -259,7 +249,7 @@ void UiLogic::keyPressEvent(Qt::Key key)
onGotoCurrentProtocolsPage();
break;
case Qt::Key_T:
SshConfigurator::openSshTerminal(m_settings->serverCredentials(m_settings->defaultServerIndex()));
m_configurator->sshConfigurator->openSshTerminal(m_settings->serverCredentials(m_settings->defaultServerIndex()));
break;
case Qt::Key_Escape:
case Qt::Key_Back:
@ -443,9 +433,9 @@ bool UiLogic::installContainers(ServerCredentials credentials,
progress.setTextVisibleFunc(true);
progress.setTextFunc(QString("Installing %1 %2 %3").arg(cnt+1).arg(tr("of")).arg(containers.size()));
ErrorCode e = ServerController::setupContainer(credentials, i.key(), i.value());
ErrorCode e = m_serverController->setupContainer(credentials, i.key(), i.value());
qDebug() << "Setup server finished with code" << e;
ServerController::disconnectFromHost(credentials);
m_serverController->disconnectFromHost(credentials);
if (e) {
if (page.setEnabledFunc) {

21
client/ui/uilogic.h
View file

@ -16,7 +16,10 @@
#include "models/protocols_model.h"
#include "notificationhandler.h"
#include "settings.h"
class Settings;
class VpnConfigurator;
class ServerController;
class AppSettingsLogic;
class GeneralSettingsLogic;
@ -50,15 +53,14 @@ class UiLogic : public QObject
AUTO_PROPERTY(bool, pageEnabled)
AUTO_PROPERTY(int, pagesStackDepth)
AUTO_PROPERTY(int, currentPageValue)
AUTO_PROPERTY(QString, dialogConnectErrorText)
READONLY_PROPERTY(QObject *, containersModel)
READONLY_PROPERTY(QObject *, protocolsModel)
// TODO: review
Q_PROPERTY(QString dialogConnectErrorText READ getDialogConnectErrorText WRITE setDialogConnectErrorText NOTIFY dialogConnectErrorTextChanged)
public:
explicit UiLogic(std::shared_ptr<Settings> settings, QObject *parent = nullptr);
explicit UiLogic(std::shared_ptr<Settings> settings, std::shared_ptr<VpnConfigurator> configurator,
std::shared_ptr<ServerController> serverController, QObject *parent = nullptr);
~UiLogic();
void showOnStartup();
@ -108,9 +110,6 @@ public:
void shareTempFile(const QString &suggestedName, QString ext, const QString& data);
QString getDialogConnectErrorText() const;
void setDialogConnectErrorText(const QString &dialogConnectErrorText);
signals:
void dialogConnectErrorTextChanged();
@ -127,9 +126,6 @@ signals:
void raise();
void toggleLogPanel();
private:
QString m_dialogConnectErrorText;
private slots:
// containers - INOUT arg
void installServer(QMap<DockerContainer, QJsonObject> &containers);
@ -214,7 +210,10 @@ private:
VpnConnection* m_vpnConnection;
QThread m_vpnConnectionThread;
std::shared_ptr<Settings> m_settings;
std::shared_ptr<VpnConfigurator> m_configurator;
std::shared_ptr<ServerController> m_serverController;
NotificationHandler* m_notificationHandler;

18
client/vpnconnection.cpp
View file

@ -29,8 +29,12 @@
#include "utils.h"
#include "vpnconnection.h"
VpnConnection::VpnConnection(std::shared_ptr<Settings> settings, QObject* parent) : QObject(parent),
m_settings(settings)
VpnConnection::VpnConnection(std::shared_ptr<Settings> settings,
std::shared_ptr<VpnConfigurator> configurator,
std::shared_ptr<ServerController> serverController, QObject* parent) : QObject(parent),
m_settings(settings),
m_configurator(configurator),
m_serverController(serverController)
{
}
@ -214,18 +218,18 @@ QString VpnConnection::createVpnConfigurationForProto(int serverIndex,
QString configData;
if (lastVpnConfig.contains(proto)) {
configData = lastVpnConfig.value(proto);
configData = VpnConfigurator::processConfigWithLocalSettings(serverIndex, container, proto, configData);
configData = m_configurator->processConfigWithLocalSettings(serverIndex, container, proto, configData);
qDebug() << "VpnConnection::createVpnConfiguration: using saved config for" << ProtocolProps::protoToString(proto);
}
else {
qDebug() << "VpnConnection::createVpnConfiguration: gen new config for" << ProtocolProps::protoToString(proto);
configData = VpnConfigurator::genVpnProtocolConfig(credentials,
configData = m_configurator->genVpnProtocolConfig(credentials,
container, containerConfig, proto, &e);
QString configDataBeforeLocalProcessing = configData;
configData = VpnConfigurator::processConfigWithLocalSettings(serverIndex, container, proto, configData);
configData = m_configurator->processConfigWithLocalSettings(serverIndex, container, proto, configData);
if (errorCode && e) {
@ -271,7 +275,7 @@ QJsonObject VpnConnection::createVpnConfiguration(int serverIndex,
Proto proto = ContainerProps::defaultProtocol(container);
vpnConfiguration[config_key::vpnproto] = ProtocolProps::protoToString(proto);
auto dns = VpnConfigurator::getDnsForConfig(serverIndex);
auto dns = m_configurator->getDnsForConfig(serverIndex);
vpnConfiguration[config_key::dns1] = dns.first;
vpnConfiguration[config_key::dns2] = dns.second;
@ -345,7 +349,7 @@ void VpnConnection::connectToVpn(int serverIndex,
connect(m_vpnProtocol.data(), SIGNAL(connectionStateChanged(VpnProtocol::VpnConnectionState)), this, SLOT(onConnectionStateChanged(VpnProtocol::VpnConnectionState)));
connect(m_vpnProtocol.data(), SIGNAL(bytesChanged(quint64, quint64)), this, SLOT(onBytesChanged(quint64, quint64)));
ServerController::disconnectFromHost(credentials);
m_serverController->disconnectFromHost(credentials);
e = m_vpnProtocol.data()->start();
if (e) emit VpnProtocol::Error;

10
client/vpnconnection.h
View file

@ -14,6 +14,9 @@
#include "core/ipcclient.h"
#endif
class VpnConfigurator;
class ServerController;
using namespace amnezia;
class VpnConnection : public QObject
@ -21,7 +24,9 @@ class VpnConnection : public QObject
Q_OBJECT
public:
explicit VpnConnection(std::shared_ptr<Settings> settings, QObject* parent = nullptr);
explicit VpnConnection(std::shared_ptr<Settings> settings,
std::shared_ptr<VpnConfigurator> configurator,
std::shared_ptr<ServerController> serverController, QObject* parent = nullptr);
~VpnConnection() override;
static QString bytesPerSecToText(quint64 bytes);
@ -74,6 +79,9 @@ protected:
private:
std::shared_ptr<Settings> m_settings;
std::shared_ptr<VpnConfigurator> m_configurator;
std::shared_ptr<ServerController> m_serverController;
QJsonObject m_vpnConfiguration;
QJsonObject m_routeMode;
QString m_remoteAddress;