Differential D20930 Diff 57983 libs/editor/settings/wireguardinterfacewidget.cpp

Changeset View

Standalone View

View Options

libs/editor/settings/wireguardinterfacewidget.cpp

  • This file was added.
1​/*
2​ Copyright 2019 Bruce Anderson <banderson19com@san.rr.com>
3​
4​ This library is free software; you can redistribute it and/or
5​ modify it under the terms of the GNU Lesser General Public
6​ License as published by the Free Software Foundation; either
7​ version 2.1 of the License, or (at your option) version 3, or any
8​ later version accepted by the membership of KDE e.V. (or its
9​ successor approved by the membership of KDE e.V.), which shall
10​ act as a proxy defined in Section 6 of version 3 of the license.
11​
12​ This library is distributed in the hope that it will be useful,
13​ but WITHOUT ANY WARRANTY; without even the implied warranty of
14​ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15​ Lesser General Public License for more details.
16​
17​ You should have received a copy of the GNU Lesser General Public
18​ License along with this library. If not, see <http://www.gnu.org/licenses/>.
19​*/
20​#include "debug.h"
21​#include "wireguardinterfacewidget.h"
22​#include "wireguardtabwidget.h"
23​#include "ui_wireguardinterfacewidget.h"
24​#include "uiutils.h"
25​#include "simpleipv4addressvalidator.h"
26​#include "simpleiplistvalidator.h"
27​#include "wireguardkeyvalidator.h"
28​
29​#include <QStandardItemModel>
30​
31​#include <NetworkManagerQt/Utils>
32​#include <NetworkManagerQt/WireguardSetting>
33​#include <NetworkManagerQt/Ipv4Setting>
34​#include <NetworkManagerQt/Ipv6Setting>
35​#include <KColorScheme>
36​#include <KConfig>
37​#include <KConfigGroup>
38​
39​// Tags used in a WireGuard .conf file - Used for importing
40​#define PNM_WG_CONF_TAG_INTERFACE "[Interface]"
41​#define PNM_WG_CONF_TAG_ADDRESS "Address"
42​#define PNM_WG_CONF_TAG_LISTEN_PORT "ListenPort"
43​#define PNM_WG_CONF_TAG_MTU "MTU"
44​#define PNM_WG_CONF_TAG_DNS "DNS"
45​#define PNM_WG_CONF_TAG_FWMARK "FwMark"
46​#define PNM_WG_CONF_TAG_PRIVATE_KEY "PrivateKey"
47​#define PNM_WG_CONF_TAG_PEER "[Peer]"
48​#define PNM_WG_CONF_TAG_PUBLIC_KEY "PublicKey"
49​#define PNM_WG_CONF_TAG_PRESHARED_KEY "PresharedKey"
50​#define PNM_WG_CONF_TAG_ALLOWED_IPS "AllowedIPs"
51​#define PNM_WG_CONF_TAG_ENDPOINT "Endpoint"
52​#define PNM_WG_CONF_TAG_PERSISTENT_KEEPALIVE "PersistentKeepalive"
53​#define PNM_WG_CONF_TAG_TABLE "Table"
54​#define PNM_WG_CONF_TAG_PRE_UP "PreUp"
55​#define PNM_WG_CONF_TAG_POST_UP "PostUp"
56​#define PNM_WG_CONF_TAG_PRE_DOWN "PreDown"
57​#define PNM_WG_CONF_TAG_POST_DOWN "PostDown"
58​
59​#define PNM_WG_KEY_PEERS "peers"
60​#define PNM_WG_KEY_MTU "mtu"
61​#define PNM_WG_KEY_PEER_ROUTES "peer-routes"
62​#define PNM_WG_PEER_KEY_ALLOWED_IPS "allowed-ips"
63​#define PNM_WG_PEER_KEY_ENDPOINT "endpoint"
64​#define PNM_WG_PEER_KEY_PERSISTENT_KEEPALIVE "persistent-keepalive"
65​#define PNM_WG_PEER_KEY_PRESHARED_KEY "preshared-key"
66​#define PNM_WG_PEER_KEY_PRESHARED_KEY_FLAGS "preshared-key-flags"
67​#define PNM_WG_PEER_KEY_PUBLIC_KEY "public-key"
68​
69​// Keys for the NetworkManager configuration
70​#define PNM_SETTING_WIREGUARD_SETTING_NAME "wireguard"
71​
72​#define PNM_WG_KEY_FWMARK "fwmark"
73​#define PNM_WG_KEY_LISTEN_PORT "listen-port"
74​#define PNM_WG_KEY_PRIVATE_KEY "private-key"
75​#define PNM_WG_KEY_PRIVATE_KEY_FLAGS "private-key-flags"
76​
77​class WireGuardInterfaceWidget::Private
78​{
79​public:
80​ Private();
81​ ~Private();
82​
83​ Ui_WireGuardInterfaceProp ui;
84​ NetworkManager::WireGuardSetting::Ptr setting;
85​ KSharedConfigPtr config;
86​ QPalette warningPalette;
87​ QPalette normalPalette;
88​ WireGuardKeyValidator *keyValidator;
89​ QRegularExpressionValidator *fwmarkValidator;
90​ QIntValidator *mtuValidator;
91​ QIntValidator *portValidator;
92​ bool privateKeyValid;
93​ bool fwmarkValid;
94​ bool listenPortValid;
95​ bool peersValid;
96​ NMVariantMapList peers;
97​};
98​
99​WireGuardInterfaceWidget::Private::Private(void)
100​ : privateKeyValid(false)
101​ , fwmarkValid(true)
102​ , listenPortValid(true)
103​ , peersValid(false)
104​{
105​}
106​
107​WireGuardInterfaceWidget::Private::~Private()
108​{
109​ delete keyValidator;
110​ delete fwmarkValidator;
111​ delete mtuValidator;
112​ delete portValidator;
113​}
114​
115​WireGuardInterfaceWidget::WireGuardInterfaceWidget(const NetworkManager::Setting::Ptr &setting, QWidget *parent, Qt::WindowFlags f)
jgrulichUnsubmitted
Done

Coding style.

Should be:

WireGuardInterfaceWidget::WireGuardInterfaceWidget(const NetworkManager::Setting::Ptr &setting, QWidget* parent, Qt::WindowFlags f)
    : SettingWidget(setting, parent, f)
    , d(new Private)
jgrulich: Coding style. Should be: ``` WireGuardInterfaceWidget::WireGuardInterfaceWidget(const…
116​ : SettingWidget(setting, parent, f)
117​ , d(new Private)
118​{
119​ d->ui.setupUi(this);
120​ d->setting = setting.staticCast<NetworkManager::WireGuardSetting>();
121​ d->config = KSharedConfig::openConfig();
122​ d->warningPalette = KColorScheme::createApplicationPalette(d->config);
123​ d->normalPalette = KColorScheme::createApplicationPalette(d->config);
124​ KColorScheme::adjustBackground(d->warningPalette, KColorScheme::NegativeBackground, QPalette::Base,
125​ KColorScheme::ColorSet::View, d->config);
126​
127​ KColorScheme::adjustBackground(d->normalPalette, KColorScheme::NormalBackground, QPalette::Base,
128​ KColorScheme::ColorSet::View, d->config);
129​
130​ connect(d->ui.privateKeyLineEdit, &PasswordField::textChanged, this, &WireGuardInterfaceWidget::checkPrivateKeyValid);
131​ connect(d->ui.privateKeyLineEdit, &PasswordField::passwordOptionChanged, this, &WireGuardInterfaceWidget::checkPrivateKeyValid);
132​ connect(d->ui.fwmarkLineEdit, &QLineEdit::textChanged, this, &WireGuardInterfaceWidget::checkFwmarkValid);
133​ connect(d->ui.listenPortLineEdit, &QLineEdit::textChanged, this, &WireGuardInterfaceWidget::checkListenPortValid);
134​ connect(d->ui.btnPeers, &QPushButton::clicked, this, &WireGuardInterfaceWidget::showPeers);
135​
136​ d->ui.privateKeyLineEdit->setPasswordModeEnabled(true);
137​ d->ui.privateKeyLineEdit->setPasswordOptionsEnabled(true);
138​ d->ui.privateKeyLineEdit->setPasswordNotSavedEnabled(false);
139​
140​ // This is done as a private variable rather than a local variable so it can be
141​ // used both here and to validate the private key later
142​ d->keyValidator = new WireGuardKeyValidator(this);
143​
144​ // Create validator for listen port
145​ d->portValidator = new QIntValidator(nullptr);
146​ d->portValidator->setBottom(0);
147​ d->portValidator->setTop(65535);
148​
149​ // Create a validator for the fwmark input. Acceptable
150​ // inputs are: "off" and numbers in either decimal
151​ // or hex (with 0x prefix)
152​ d->fwmarkValidator = new QRegularExpressionValidator(QRegularExpression("(off)|([0-9]{0,10})|(0x[0-9a-fA-F]{1,8})"));
153​ d->ui.fwmarkLineEdit->setValidator(d->fwmarkValidator);
154​
155​ // Create a validator for the MTU field.
156​ d->mtuValidator = new QIntValidator(nullptr);
157​ d->mtuValidator->setBottom(0);
158​ d->ui.mtuLineEdit->setValidator(d->mtuValidator);
159​
160​ // Default Peer Routes to true
161​ d->ui.peerRouteCheckBox->setChecked(true);
162​
163​ // Connect for setting check
164​ watchChangedSetting();
165​
166​ KAcceleratorManager::manage(this);
167​
168​ if (setting && !setting->isNull()) {
169​ loadConfig(d->setting);
170​ }
171​
172​ // Set the initial backgrounds on all the widgets
173​ checkPrivateKeyValid();
174​}
175​
176​WireGuardInterfaceWidget::~WireGuardInterfaceWidget()
177​{
178​ delete d;
179​}
180​
181​void WireGuardInterfaceWidget::loadConfig(const NetworkManager::Setting::Ptr &setting)
182​{
183​ NetworkManager::WireGuardSetting::Ptr wireGuardSetting = setting.staticCast<NetworkManager::WireGuardSetting>();
jgrulichUnsubmitted
Done

I would preffer:

if (wireGuardSetting->listenPort() != 0)

It's more readable. Same for code below.

jgrulich: I would preffer: ``` if (wireGuardSetting->listenPort() != 0) ``` It's more readable. Same…
184​ d->ui.privateKeyLineEdit->setText(wireGuardSetting->privateKey());
185​
186​ if (wireGuardSetting->listenPort() != 0)
187​ d->ui.listenPortLineEdit->setText(QString::number(wireGuardSetting->listenPort()));
188​ else
189​ d->ui.listenPortLineEdit->clear();
190​
191​ if (wireGuardSetting->fwmark() != 0)
192​ d->ui.fwmarkLineEdit->setText(QString::number(wireGuardSetting->fwmark()));
193​ else
194​ d->ui.fwmarkLineEdit->clear();
195​
196​ if (wireGuardSetting->mtu() != 0)
197​ d->ui.mtuLineEdit->setText(QString::number(wireGuardSetting->mtu()));
198​ else
199​ d->ui.mtuLineEdit->clear();
200​
201​ d->ui.peerRouteCheckBox->setChecked(wireGuardSetting->peerRoutes());
202​
203​ NetworkManager::Setting::SecretFlags type = wireGuardSetting->privateKeyFlags();
204​ switch (type) {
205​ case NetworkManager::Setting::AgentOwned:
206​ d->ui.privateKeyLineEdit->setPasswordOption(PasswordField::StoreForUser);
207​ break;
208​ case NetworkManager::Setting::None:
209​ d->ui.privateKeyLineEdit->setPasswordOption(PasswordField::StoreForAllUsers);
210​ break;
211​ // Not saved is not a valid option for the private key so set it to StoreForUser instead
212​ case NetworkManager::Setting::NotSaved:
213​ d->ui.privateKeyLineEdit->setPasswordOption(PasswordField::StoreForUser);
214​ break;
215​ case NetworkManager::Setting::NotRequired:
216​ d->ui.privateKeyLineEdit->setPasswordOption(PasswordField::NotRequired);
217​ break;
218​ }
219​
220​ d->peers = wireGuardSetting->peers();
221​ loadSecrets(setting);
222​}
223​
224​void WireGuardInterfaceWidget::loadSecrets(const NetworkManager::Setting::Ptr &setting)
225​{
226​ NetworkManager::WireGuardSetting::Ptr wireGuardSetting = setting.staticCast<NetworkManager::WireGuardSetting>();
227​ if (wireGuardSetting) {
228​ const QString key = wireGuardSetting->privateKey();
229​ if (!key.isEmpty())
230​ d->ui.privateKeyLineEdit->setText(key);
231​
232​ const NMVariantMapList peers = wireGuardSetting->peers();
233​ if (!peers.isEmpty()) {
234​ // For each of the peers returned, see if it contains a preshared key
235​ for (QList<QVariantMap>::const_iterator i = peers.cbegin(); i != peers.cend(); i++) {
236​ if (i->contains(PNM_WG_PEER_KEY_PRESHARED_KEY)) {
237​ // We have a preshared key so find the matching public key in the local peer list
238​ QString currentPublicKey = (*i)[PNM_WG_PEER_KEY_PUBLIC_KEY].toString();
239​ if (!currentPublicKey.isEmpty()) {
240​ for (QList<QVariantMap>::iterator j = d->peers.begin(); j != d->peers.end(); j++) {
241​ if ((*j)[PNM_WG_PEER_KEY_PUBLIC_KEY].toString() == currentPublicKey) {
242​ (*j)[PNM_WG_PEER_KEY_PRESHARED_KEY] = (*i)[PNM_WG_PEER_KEY_PRESHARED_KEY].toString();
243​ break;
244​ }
245​ }
246​ }
247​ }
248​ }
249​ }
250​ }
251​ // On the assumption that a saved configuration is valid (because how could it be saved if it
jgrulichUnsubmitted
Done

Remove empty line

jgrulich: Remove empty line
252​ // wasn't valid) then the peers section is valid unless it didn't get a preshared key if one
253​ // is required, so a simple minded "validity" check is done here. Real validity checks are done
254​ // when the peers widget is open which is the only time changes which might be invalid are
255​ // possible.
256​ d->peersValid = true;
257​ for (QList<QVariantMap>::iterator j = d->peers.begin(); j != d->peers.end(); j++) {
258​ if ((*j).contains(PNM_WG_PEER_KEY_PRESHARED_KEY_FLAGS)
259​ && (*j)[PNM_WG_PEER_KEY_PRESHARED_KEY_FLAGS] != NetworkManager::Setting::NotRequired
260​ && (!(*j).contains(PNM_WG_PEER_KEY_PRESHARED_KEY)
261​ || (*j)[PNM_WG_PEER_KEY_PRESHARED_KEY].toString().isEmpty())) {
262​ d->peersValid = false;
263​ break;
264​ }
265​ }
266​}
267​
268​QVariantMap WireGuardInterfaceWidget::setting() const
269​{
270​ NetworkManager::WireGuardSetting wgSetting;
271​ QString val = d->ui.fwmarkLineEdit->displayText();
272​
273​ if (!val.isEmpty())
274​ wgSetting.setFwmark(val.toUInt());
275​
276​ val = d->ui.listenPortLineEdit->displayText();
277​ if (!val.isEmpty())
278​ wgSetting.setListenPort(val.toUInt());
279​
280​ val = d->ui.mtuLineEdit->displayText();
281​ if (!val.isEmpty())
282​ wgSetting.setMtu(val.toUInt());
283​
284​ val = d->ui.privateKeyLineEdit->text();
285​ if (!val.isEmpty())
286​ wgSetting.setPrivateKey(val);
287​
288​ wgSetting.setPeerRoutes(d->ui.peerRouteCheckBox->isChecked());
289​
290​ PasswordField::PasswordOption option = d->ui.privateKeyLineEdit->passwordOption();
291​ switch (option) {
292​ case PasswordField::StoreForUser:
293​ wgSetting.setPrivateKeyFlags(NetworkManager::Setting::AgentOwned);
294​ break;
295​ case PasswordField::StoreForAllUsers:
296​ wgSetting.setPrivateKeyFlags(NetworkManager::Setting::None);
297​ break;
298​ // Always Ask is not a valid option for the private key so set it to AgentOwned instead
299​ case PasswordField::AlwaysAsk:
300​ wgSetting.setPrivateKeyFlags(NetworkManager::Setting::AgentOwned);
301​ break;
302​ case PasswordField::NotRequired:
303​ wgSetting.setPrivateKeyFlags(NetworkManager::Setting::NotRequired);
304​ break;
305​ }
306​ wgSetting.setPeers(d->peers);
307​ return wgSetting.toMap();
308​}
309​
310​bool WireGuardInterfaceWidget::isValid() const
311​{
312​ return d->privateKeyValid
313​ && d->fwmarkValid
314​ && d->listenPortValid
315​ && d->peersValid;
316​}
317​
318​void WireGuardInterfaceWidget::checkPrivateKeyValid()
319​{
320​ int pos = 0;
321​ PasswordField *widget = d->ui.privateKeyLineEdit;
322​ QString value = widget->text();
323​ bool valid = (QValidator::Acceptable == d->keyValidator->validate(value, pos));
324​ d->privateKeyValid = valid;
325​ setBackground(widget, valid);
326​ slotWidgetChanged();
327​}
328​void WireGuardInterfaceWidget::checkFwmarkValid()
329​{
330​ int pos = 0;
331​ QLineEdit *widget = d->ui.fwmarkLineEdit;
332​ QString value = widget->displayText();
333​ d->fwmarkValid = QValidator::Acceptable == widget->validator()->validate(value, pos)
334​ || value.isEmpty();
335​ setBackground(widget, d->fwmarkValid);
336​ slotWidgetChanged();
337​}
338​
339​void WireGuardInterfaceWidget::checkListenPortValid()
340​{
341​ int pos = 0;
342​ QLineEdit *widget = d->ui.listenPortLineEdit;
343​ QString value = widget->displayText();
344​ d->listenPortValid = QValidator::Acceptable == d->portValidator->validate(value, pos)
345​ || value.isEmpty();
346​ setBackground(widget, d->listenPortValid);
347​ slotWidgetChanged();
348​}
349​
350​void WireGuardInterfaceWidget::setBackground(QWidget *w, bool result) const
351​{
352​ if (result)
353​ w->setPalette(d->normalPalette);
354​ else
355​ w->setPalette(d->warningPalette);
356​}
357​
358​QString WireGuardInterfaceWidget::supportedFileExtensions()
359​{
360​ return "*.conf";
361​}
362​
363​void WireGuardInterfaceWidget::showPeers()
364​{
365​ QPointer<WireGuardTabWidget> peers = new WireGuardTabWidget(d->peers, this);
366​
367​ connect(peers.data(), &WireGuardTabWidget::accepted,
368​ [peers, this] () {
369​ NMVariantMapList peersData = peers->setting();
370​ if (!peersData.isEmpty()) {
371​ d->peers = peersData;
372​ // The peers widget won't allow "OK" to be hit
373​ // unless all the peers are valid so no need to check
374​ d->peersValid = true;
375​ slotWidgetChanged();
376​ }
377​ });
378​ connect(peers.data(), &WireGuardTabWidget::finished,
379​ [peers] () {
380​ if (peers) {
381​ peers->deleteLater();
382​ }
383​ });
384​ peers->setModal(true);
385​ peers->show();
386​}
387​
388​NMVariantMapMap WireGuardInterfaceWidget::importConnectionSettings(const QString &fileName)
389​{
390​ NMVariantMapMap result;
391​
392​ QFile impFile(fileName);
393​ QList<NetworkManager::IpAddress> ipv4AddressList;
394​ QList<NetworkManager::IpAddress> ipv6AddressList;
395​
396​ if (!impFile.open(QFile::ReadOnly|QFile::Text)) {
397​ return result;
398​ }
399​
400​ const QString connectionName = QFileInfo(fileName).completeBaseName();
401​ NMStringMap dataMap;
402​ NMVariantMapList peers;
403​ QVariantMap ipv4Data;
404​ QVariantMap *currentPeer = nullptr;
405​ WireGuardKeyValidator keyValidator(nullptr);
406​ NetworkManager::Ipv4Setting ipv4Setting;
407​ NetworkManager::Ipv6Setting ipv6Setting;
408​ NetworkManager::WireGuardSetting wgSetting;
409​
410​ QString proxyType;
411​ QString proxyUser;
412​ QString proxyPasswd;
413​ bool havePrivateKey = false;
414​ bool haveIpv4Setting = false;
415​ bool haveIpv6Setting = false;
416​ // Set the "PEER" elements true because they
417​ // need to be true to allocate the
418​ // first [Peer] section below
419​ bool havePublicKey = true;
420​ bool haveAllowedIps = true;
421​ int pos = 0;
422​
423​ QTextStream in(&impFile);
424​ enum {IDLE, INTERFACE_SECTION, PEER_SECTION} currentState = IDLE;
425​
jgrulichUnsubmitted
Done

Coding style. The "else if" should be on the same line as the "}" bracket.

jgrulich: Coding style. The "else if" should be on the same line as the "}" bracket.
426​ ipv4Setting.setMethod(NetworkManager::Ipv4Setting::Disabled);
427​ ipv6Setting.setMethod(NetworkManager::Ipv6Setting::Ignored);
428​
429​ while (!in.atEnd()) {
430​ QStringList keyValue;
431​ QString line = in.readLine();
432​
433​ // Remove comments starting with '#'
434​ if (int index = line.indexOf('#') > 0)
435​ line.truncate(index);
436​
437​ // Ignore blank lines
438​ if (line.isEmpty())
439​ continue;
440​
441​ keyValue.clear();
442​ keyValue << line.split('=');
443​
444​ if (keyValue[0] == PNM_WG_CONF_TAG_INTERFACE) {
445​ currentState = INTERFACE_SECTION;
446​ continue;
447​ } else if (keyValue[0] == PNM_WG_CONF_TAG_PEER) {
448​ // Check to make sure the previous PEER section has
449​ // all the required elements. If not it's an error
450​ // so just return the empty result.
451​ if (!havePublicKey || !haveAllowedIps) {
452​ return result;
453​ } else {
454​ havePublicKey = false;
455​ haveAllowedIps = false;
456​ currentState = PEER_SECTION;
457​ peers.append(*(new QVariantMap));
458​ currentPeer = &peers[peers.size() - 1];
459​ continue;
460​ }
461​ }
462​
463​ // If we didn't get an '=' sign in the line, it's probably an error but
464​ // we're going to treat it as a comment and ignore it
465​ if (keyValue.length() < 2)
466​ continue;
467​
468​ QString key = keyValue[0].trimmed();
469​
470​ // If we are in the [Interface] section look for the possible tags
471​ if (currentState == INTERFACE_SECTION) {
472​ // Address
473​ if (key == PNM_WG_CONF_TAG_ADDRESS) {
474​ QStringList valueList = keyValue[1].split(',');
475​ if (valueList.isEmpty())
476​ return result;
477​
478​ for (const QString &address : valueList) {
479​ const QPair<QHostAddress, int> addressIn = QHostAddress::parseSubnet(address.trimmed());
480​ NetworkManager::IpAddress *addr = new NetworkManager::IpAddress;
481​ addr->setIp(addressIn.first);
482​ addr->setPrefixLength(addressIn.second);
483​ if (addressIn.first.protocol() == QAbstractSocket::NetworkLayerProtocol::IPv4Protocol) {
jgrulichUnsubmitted
Done

Same here and below.

jgrulich: Same here and below.
484​ ipv4AddressList.append(*addr);
485​ } else if (addressIn.first.protocol() == QAbstractSocket::NetworkLayerProtocol::IPv6Protocol) {
486​ ipv6AddressList.append(*addr);
487​ } else { // Error condition
488​ return result;
489​ }
490​ }
491​ if (!ipv4AddressList.isEmpty()) {
492​ ipv4Setting.setAddresses(ipv4AddressList);
493​ ipv4Setting.setMethod(NetworkManager::Ipv4Setting::Manual);
494​ haveIpv4Setting = true;
495​ }
496​ if (!ipv6AddressList.isEmpty()) {
497​ ipv6Setting.setAddresses(ipv6AddressList);
498​ ipv6Setting.setMethod(NetworkManager::Ipv6Setting::Manual);
499​ haveIpv6Setting = true;
500​ }
501​ }
502​
503​ // Listen Port
504​ else if (key == PNM_WG_CONF_TAG_LISTEN_PORT) {
505​ uint val = keyValue[1].toUInt();
506​ if (val <= 65535)
507​ wgSetting.setListenPort(val);
508​ } else if (key == PNM_WG_CONF_TAG_PRIVATE_KEY) {
509​ QString val = keyValue[1].trimmed();
510​ // WireGuard keys present a slight problem because they
511​ // must end in '=' which is removed during the 'split' above
512​ // so if there are 3 parts and the 3 is empty, there must
513​ // have been an '=' so add it back on
514​ if (keyValue.size() == 3 && keyValue[2].isEmpty())
515​ val += "=";
516​ if (QValidator::Acceptable == keyValidator.validate(val, pos)) {
517​ wgSetting.setPrivateKey(val);
518​ havePrivateKey = true;
519​ }
520​ } else if (key == PNM_WG_CONF_TAG_DNS) {
521​ QStringList addressList = keyValue[1].split(',');
522​ QList<QHostAddress> ipv4DnsList;
523​ QList<QHostAddress> ipv6DnsList;
524​ if (!addressList.isEmpty()) {
525​ for (const QString &address : addressList) {
526​ const QPair<QHostAddress, int> addressIn = QHostAddress::parseSubnet(address.trimmed());
527​ if (addressIn.first.protocol() == QAbstractSocket::NetworkLayerProtocol::IPv4Protocol) {
528​ ipv4DnsList.append(addressIn.first);
529​ } else if (addressIn.first.protocol() == QAbstractSocket::NetworkLayerProtocol::IPv6Protocol) {
530​ ipv6DnsList.append(addressIn.first);
531​ } else { // Error condition
532​ return result;
533​ }
534​ }
535​ }
536​
537​ // If there are any addresses put them on the correct tab and set the "method" to
538​ // "Automatic (Only addresses)" by setting "ignore-auto-dns=true"
539​ if (!ipv4DnsList.isEmpty()) {
540​ if (ipv4Setting.method() == NetworkManager::Ipv4Setting::Disabled)
541​ ipv4Setting.setMethod(NetworkManager::Ipv4Setting::Automatic);
542​ ipv4Setting.setIgnoreAutoDns(true);
543​ ipv4Setting.setDns(ipv4DnsList);
544​ haveIpv4Setting = true;
545​ }
546​
547​ if (!ipv6DnsList.isEmpty()) {
548​ ipv6Setting.setMethod(NetworkManager::Ipv6Setting::Automatic);
549​ ipv6Setting.setIgnoreAutoDns(true);
550​ ipv6Setting.setDns(ipv6DnsList);
551​ haveIpv6Setting = true;
552​ }
553​ } else if (key == PNM_WG_CONF_TAG_MTU) {
554​ uint val = keyValue[1].toUInt();
555​ if (val > 0)
556​ wgSetting.setMtu(val);
557​ } else if (key == PNM_WG_CONF_TAG_FWMARK) {
558​ uint val;
559​ if (keyValue[1].trimmed().toLower() == QLatin1String("off"))
560​ val = 0;
561​ else
562​ val = keyValue[1].toUInt();
563​ wgSetting.setFwmark(val);
564​ } else if (key == PNM_WG_CONF_TAG_TABLE
565​ || key == PNM_WG_CONF_TAG_PRE_UP
566​ || key == PNM_WG_CONF_TAG_POST_UP
567​ || key == PNM_WG_CONF_TAG_PRE_DOWN
568​ || key == PNM_WG_CONF_TAG_POST_DOWN) {
569​ // plasma-nm does not handle these items
jgrulichUnsubmitted
Done

The "{" bracket should be on the same line as the "else if". Same below.

jgrulich: The "{" bracket should be on the same line as the "else if". Same below.
570​ } else {
571​ // We got a wrong field in the Interface section so it
572​ // is an error
573​ break;
574​ }
575​ } else if (currentState == PEER_SECTION) {
576​ // Public Key
577​ if (key == PNM_WG_CONF_TAG_PUBLIC_KEY) {
578​ QString val = keyValue[1].trimmed();
579​ // WireGuard keys present a slight problem because they
580​ // must end in '=' which is removed during the 'split' above
581​ // so if there are 3 parts and the 3 is empty, there must
582​ // have been an '=' so add it back on
583​ if (keyValue.size() == 3 && keyValue[2].isEmpty())
584​ val += "=";
585​
586​ if (QValidator::Acceptable == keyValidator.validate(val, pos)) {
587​ currentPeer->insert(PNM_WG_PEER_KEY_PUBLIC_KEY, val);
588​ havePublicKey = true;
589​ }
590​ } else if (key == PNM_WG_CONF_TAG_ALLOWED_IPS) {
591​ SimpleIpListValidator validator(nullptr, SimpleIpListValidator::WithCidr, SimpleIpListValidator::Both);
592​ QString val = keyValue[1].trimmed();
593​ if (QValidator::Acceptable == validator.validate(val, pos))
594​ {
595​ QStringList valList = val.split(',');
596​ for (QString& str : valList)
597​ str = str.trimmed();
598​ currentPeer->insert(PNM_WG_PEER_KEY_ALLOWED_IPS, valList);
599​ haveAllowedIps = true;
600​ }
601​ } else if (key == PNM_WG_CONF_TAG_ENDPOINT) {
602​ if (keyValue[1].length() > 0)
603​ currentPeer->insert(PNM_WG_PEER_KEY_ENDPOINT, keyValue[1].trimmed());
604​ } else if (key == PNM_WG_CONF_TAG_PRESHARED_KEY) {
605​ QString val = keyValue[1].trimmed();
606​ // WireGuard keys present a slight problem because they
607​ // must end in '=' which is removed during the 'split' above
608​ // so if there are 3 parts and the 3 is empty, there must
609​ // have been an '=' so add it back on
610​ if (keyValue.size() == 3 && keyValue[2].isEmpty())
611​ val += "=";
612​
613​ if (QValidator::Acceptable == keyValidator.validate(val, pos)) {
614​ currentPeer->insert(PNM_WG_PEER_KEY_PRESHARED_KEY, val);
615​ }
616​ }
617​ } else {
618​ return result;
619​ }
620​ }
621​ if (!havePrivateKey || !haveAllowedIps || !havePublicKey || !haveAllowedIps)
jgrulichUnsubmitted
Done

The "{" bracket should be on the same line with the "if"

jgrulich: The "{" bracket should be on the same line with the "if"
622​ return result;
623​
624​ QVariantMap conn;
625​ wgSetting.setPeers(peers);
626​ conn.insert("id", connectionName);
627​ conn.insert("interface-name", connectionName);
628​ conn.insert("type", "wireguard");
629​ conn.insert("autoconnect", "false");
630​ result.insert("connection", conn);
631​ result.insert("wireguard", wgSetting.toMap());
632​ if (haveIpv4Setting)
633​ result.insert("ipv4", ipv4Setting.toMap());
634​ if (haveIpv6Setting)
jgrulichUnsubmitted
Done

Please remove

jgrulich: Please remove
635​ result.insert("ipv6", ipv6Setting.toMap());
636​
637​ impFile.close();
638​ return result;
639​}