amnezia-client/client/core/protocols/wireGuardProtocol.cpp

#include <QCoreApplication>
#include <QFileInfo>
#include <QProcess>
#include <QTcpSocket>
#include <QThread>

#include "wireGuardProtocol.h"
#include "core/utils/networkUtilities.h"

#include "mozilla/localsocketcontroller.h"

WireguardProtocol::WireguardProtocol(const QJsonObject &configuration, QObject *parent)
    : VpnProtocol(configuration, parent)
{
    const QString ifname = configuration.value("ifname").toString();
    m_impl.reset(new LocalSocketController(ifname));
    connect(m_impl.get(), &ControllerImpl::connected, this,
            [this](const QString& pubkey, const QDateTime&) {
                Q_UNUSED(pubkey)
                setConnectionState(Vpn::ConnectionState::Connected);
            });
    connect(m_impl.get(), &ControllerImpl::statusUpdated, this,
            [this](const QString& serverIpv4Gateway,
                   const QString& deviceIpv4Address, uint64_t txBytes,
                   uint64_t rxBytes) {
                const QString previousGateway = m_vpnGateway;
                const QString previousLocal = m_vpnLocalAddress;

                if (!serverIpv4Gateway.isEmpty()) {
                    m_vpnGateway = serverIpv4Gateway;
                }
                if (!deviceIpv4Address.isEmpty()) {
                    m_vpnLocalAddress = deviceIpv4Address;
                }

                if ((!m_vpnGateway.isEmpty() && m_vpnGateway != previousGateway) ||
                    (!m_vpnLocalAddress.isEmpty() && m_vpnLocalAddress != previousLocal)) {
                        if (m_connectionState == Vpn::ConnectionState::Connected) {
                            emit tunnelAddressesUpdated(m_vpnGateway, m_vpnLocalAddress);
                        }
                    }
            });

    connect(m_impl.get(), &ControllerImpl::disconnected, this,
            [this]() { setConnectionState(Vpn::ConnectionState::Disconnected); });
    connect(m_impl.get(), &ControllerImpl::primaryReady,
            this, &WireguardProtocol::primaryReady);
    connect(m_impl.get(), &ControllerImpl::primaryFailed,
            this, &WireguardProtocol::primaryFailed);
    m_impl->initialize(nullptr, nullptr);
}

WireguardProtocol::~WireguardProtocol()
{
    WireguardProtocol::stop();
    QThread::msleep(200);
}

ErrorCode WireguardProtocol::start()
{
    QString protocolName = m_rawConfig.value("protocol").toString();
    QJsonObject vpnConfigData = m_rawConfig.value(protocolName + "_config_data").toObject();
    vpnConfigData[configKey::hostName] = NetworkUtilities::getIPAddress(vpnConfigData.value(configKey::hostName).toString());
    m_rawConfig.insert(protocolName + "_config_data", vpnConfigData);
    m_rawConfig[configKey::hostName] = NetworkUtilities::getIPAddress(m_rawConfig[configKey::hostName].toString());

    m_stopped = false;
    m_impl->activate(m_rawConfig);
    return ErrorCode::NoError;
}

void WireguardProtocol::stop()
{
    if (m_stopped) return;
    m_stopped = true;
    m_impl->deactivate();
}

void WireguardProtocol::setPrimary(const QJsonObject& config)
{
    m_impl->setPrimary(config);
}