← Back to branch summary

~ubuntu-branches/ubuntu/saucy/plasma-nm/saucy-proposed

« back to all changes in this revision

Viewing changes to vpn/openswan/openswanwidget.cpp

  • Committer: Package Import Robot
  • Author(s): Jonathan Riddell
  • Date: 2013-08-16 19:07:09 UTC
  • Revision ID: package-import@ubuntu.com-20130816190709-ef9ydm9skigmg15l
Tags: upstream-0.0~git20130816
Import upstream version 0.0~git20130816

Show diffs side-by-side

added added

removed removed

Lines of Context:
vpn/openswan/openswanwidget.cpp
 
1
/*
 
2
    Copyright 2013 Jan Grulich <jgrulich@redhat.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
 
 
21
#include "openswanwidget.h"
 
22
#include "ui_openswan.h"
 
23
#include "nm-openswan-service.h"
 
24
 
 
25
#include <NetworkManagerQt/Setting>
 
26
 
 
27
#include <QDBusMetaType>
 
28
#include <QDebug>
 
29
 
 
30
OpenswanWidget::OpenswanWidget(const NetworkManager::VpnSetting::Ptr &setting, QWidget* parent, Qt::WindowFlags f):
 
31
    SettingWidget(setting, parent, f),
 
32
    m_ui(new Ui::OpenswanWidget),
 
33
    m_setting(setting)
 
34
{
 
35
    qDBusRegisterMetaType<NMStringMap>();
 
36
 
 
37
    m_ui->setupUi(this);
 
38
 
 
39
    connect(m_ui->cbUsernamePasswordMode, SIGNAL(currentIndexChanged(int)), SLOT(userPasswordTypeChanged(int)));
 
40
    connect(m_ui->cbGroupPasswordMode, SIGNAL(currentIndexChanged(int)), SLOT(groupPasswordTypeChanged(int)));
 
41
 
 
42
    connect(m_ui->ckShowPasswords, SIGNAL(toggled(bool)), SLOT(showPassword(bool)));
 
43
 
 
44
    connect(m_ui->gateway, SIGNAL(textChanged(QString)), SLOT(slotWidgetChanged()));
 
45
    connect(m_ui->groupname, SIGNAL(textChanged(QString)), SLOT(slotWidgetChanged()));
 
46
 
 
47
    KAcceleratorManager::manage(this);
 
48
 
 
49
    if (m_setting)
 
50
        loadConfig(setting);
 
51
}
 
52
 
 
53
OpenswanWidget::~OpenswanWidget()
 
54
{
 
55
    delete m_ui;
 
56
}
 
57
 
 
58
void OpenswanWidget::loadConfig(const NetworkManager::Setting::Ptr &setting)
 
59
{
 
60
    Q_UNUSED(setting);
 
61
 
 
62
    const NMStringMap data = m_setting->data();
 
63
    const NMStringMap secrets = m_setting->secrets();
 
64
 
 
65
    const QString gateway = data.value(NM_OPENSWAN_RIGHT);
 
66
    if (!gateway.isEmpty()) {
 
67
        m_ui->gateway->setText(gateway);
 
68
    }
 
69
 
 
70
    const QString groupName = data.value(NM_OPENSWAN_LEFTID);
 
71
    if (!groupName.isEmpty()) {
 
72
        m_ui->groupname->setText(groupName);
 
73
    }
 
74
 
 
75
    const QString userPassword = secrets.value(NM_OPENSWAN_XAUTH_PASSWORD);
 
76
    if (!userPassword.isEmpty()) {
 
77
        m_ui->userPassword->setText(userPassword);
 
78
    }
 
79
 
 
80
    const QString groupPassword = secrets.value(NM_OPENSWAN_PSK_VALUE);
 
81
    if (!groupPassword.isEmpty()) {
 
82
        m_ui->groupPassword->setText(groupPassword);
 
83
    }
 
84
 
 
85
    const QString userPasswordMode = data.value(NM_OPENSWAN_XAUTH_PASSWORD_INPUT_MODES);
 
86
    if (userPasswordMode == NM_OPENSWAN_PW_TYPE_SAVE) {
 
87
        m_ui->cbUsernamePasswordMode->setCurrentIndex(0);
 
88
    } else if (userPasswordMode == NM_OPENSWAN_PW_TYPE_ASK) {
 
89
        m_ui->cbUsernamePasswordMode->setCurrentIndex(1);
 
90
    } else if (userPasswordMode == NM_OPENSWAN_PW_TYPE_UNUSED) {
 
91
        m_ui->cbUsernamePasswordMode->setCurrentIndex(2);
 
92
    }
 
93
 
 
94
    const QString groupPasswordMode = data.value(NM_OPENSWAN_PSK_INPUT_MODES);
 
95
    if (groupPasswordMode == NM_OPENSWAN_PW_TYPE_SAVE) {
 
96
        m_ui->cbGroupPasswordMode->setCurrentIndex(0);
 
97
    } else if (groupPasswordMode == NM_OPENSWAN_PW_TYPE_ASK) {
 
98
        m_ui->cbGroupPasswordMode->setCurrentIndex(1);
 
99
    } else if (groupPasswordMode == NM_OPENSWAN_PW_TYPE_UNUSED) {
 
100
        m_ui->cbGroupPasswordMode->setCurrentIndex(2);
 
101
    }
 
102
 
 
103
    const QString username = data.value(NM_OPENSWAN_LEFTXAUTHUSER);
 
104
    if (!username.isEmpty()) {
 
105
        m_ui->username->setText(username);
 
106
    }
 
107
 
 
108
    const QString phase1 = data.value(NM_OPENSWAN_IKE);
 
109
    if (!phase1.isEmpty()) {
 
110
        m_ui->phase1->setText(phase1);
 
111
    }
 
112
 
 
113
    const QString phase2 = data.value(NM_OPENSWAN_ESP);
 
114
    if (!phase2.isEmpty()) {
 
115
        m_ui->phase2->setText(phase2);
 
116
    }
 
117
 
 
118
    const QString domain = data.value(NM_OPENSWAN_DOMAIN);
 
119
    if (!domain.isEmpty()) {
 
120
        m_ui->domain->setText(domain);
 
121
    }
 
122
}
 
123
 
 
124
QVariantMap OpenswanWidget::setting(bool agentOwned) const
 
125
{
 
126
    NetworkManager::VpnSetting setting;
 
127
    setting.setServiceType(QLatin1String(NM_DBUS_SERVICE_OPENSWAN));
 
128
    NMStringMap data;
 
129
    NMStringMap secrets;
 
130
 
 
131
    if (!m_ui->gateway->text().isEmpty()) {
 
132
        data.insert(NM_OPENSWAN_RIGHT, m_ui->gateway->text());
 
133
    }
 
134
 
 
135
    if (!m_ui->groupname->text().isEmpty()) {
 
136
        data.insert(NM_OPENSWAN_LEFTID, m_ui->groupname->text());
 
137
    }
 
138
 
 
139
    if (!m_ui->userPassword->text().isEmpty()) {
 
140
        secrets.insert(NM_OPENSWAN_XAUTH_PASSWORD, m_ui->userPassword->text());
 
141
    }
 
142
 
 
143
    const int usernamePasswordMode = m_ui->cbUsernamePasswordMode->currentIndex();
 
144
    if (usernamePasswordMode == 0) {
 
145
        data.insert(NM_OPENSWAN_XAUTH_PASSWORD_INPUT_MODES, NM_OPENSWAN_PW_TYPE_SAVE);
 
146
        if (agentOwned) {
 
147
            data.insert(NM_OPENSWAN_XAUTH_PASSWORD"-flags", QString::number(NetworkManager::Setting::AgentOwned));
 
148
        } else {
 
149
            data.insert(NM_OPENSWAN_XAUTH_PASSWORD"-flags", QString::number(NetworkManager::Setting::None));
 
150
        }
 
151
    } else if (usernamePasswordMode == 1) {
 
152
        data.insert(NM_OPENSWAN_XAUTH_PASSWORD_INPUT_MODES, NM_OPENSWAN_PW_TYPE_ASK);
 
153
        data.insert(NM_OPENSWAN_XAUTH_PASSWORD"-flags", QString::number(NetworkManager::Setting::NotSaved));
 
154
    } else {
 
155
        data.insert(NM_OPENSWAN_XAUTH_PASSWORD_INPUT_MODES, NM_OPENSWAN_PW_TYPE_UNUSED);
 
156
        data.insert(NM_OPENSWAN_XAUTH_PASSWORD"-flags", QString::number(NetworkManager::Setting::NotRequired));
 
157
    }
 
158
 
 
159
    if (!m_ui->groupPassword->text().isEmpty()) {
 
160
        secrets.insert(NM_OPENSWAN_PSK_VALUE, m_ui->groupPassword->text());
 
161
    }
 
162
 
 
163
    const int groupPasswordMode = m_ui->cbGroupPasswordMode->currentIndex();
 
164
    if (groupPasswordMode == 0) {
 
165
        data.insert(NM_OPENSWAN_PSK_INPUT_MODES, NM_OPENSWAN_PW_TYPE_SAVE);
 
166
        if (agentOwned) {
 
167
            data.insert(NM_OPENSWAN_PSK_VALUE"-flags", QString::number(NetworkManager::Setting::AgentOwned));
 
168
        } else {
 
169
            data.insert(NM_OPENSWAN_PSK_VALUE"-flags", QString::number(NetworkManager::Setting::None));
 
170
        }
 
171
    } else if (groupPasswordMode == 1) {
 
172
        data.insert(NM_OPENSWAN_PSK_INPUT_MODES, NM_OPENSWAN_PW_TYPE_ASK);
 
173
        data.insert(NM_OPENSWAN_PSK_VALUE"-flags", QString::number(NetworkManager::Setting::NotSaved));
 
174
    } else {
 
175
        data.insert(NM_OPENSWAN_PSK_INPUT_MODES, NM_OPENSWAN_PW_TYPE_UNUSED);
 
176
        data.insert(NM_OPENSWAN_PSK_VALUE"-flags", QString::number(NetworkManager::Setting::NotRequired));
 
177
    }
 
178
 
 
179
    if (!m_ui->username->text().isEmpty()) {
 
180
        data.insert(NM_OPENSWAN_LEFTXAUTHUSER, m_ui->username->text());
 
181
    }
 
182
 
 
183
    if (!m_ui->phase1->text().isEmpty()) {
 
184
        data.insert(NM_OPENSWAN_IKE, m_ui->phase1->text());
 
185
    }
 
186
 
 
187
    if (!m_ui->phase2->text().isEmpty()) {
 
188
        data.insert(NM_OPENSWAN_ESP, m_ui->phase2->text());
 
189
    }
 
190
 
 
191
    if (!m_ui->domain->text().isEmpty()) {
 
192
        data.insert(NM_OPENSWAN_DOMAIN, m_ui->domain->text());
 
193
    }
 
194
 
 
195
    setting.setData(data);
 
196
    setting.setSecrets(secrets);
 
197
    return setting.toMap();
 
198
}
 
199
 
 
200
void OpenswanWidget::userPasswordTypeChanged(int index)
 
201
{
 
202
    if (index == 1 || index == 2) {
 
203
        m_ui->userPassword->setEnabled(false);
 
204
    } else {
 
205
        m_ui->userPassword->setEnabled(true);
 
206
    }
 
207
}
 
208
 
 
209
void OpenswanWidget::groupPasswordTypeChanged(int index)
 
210
{
 
211
    if (index == 1 || index == 2) {
 
212
        m_ui->groupPassword->setEnabled(false);
 
213
    } else {
 
214
        m_ui->groupPassword->setEnabled(true);
 
215
    }
 
216
}
 
217
 
 
218
void OpenswanWidget::showPassword(bool show)
 
219
{
 
220
    m_ui->userPassword->setPasswordMode(!show);
 
221
    m_ui->groupPassword->setPasswordMode(!show);
 
222
}
 
223
 
 
224
bool OpenswanWidget::isValid() const
 
225
{
 
226
    return !m_ui->gateway->text().isEmpty() && !m_ui->groupname->text().isEmpty();
 
227
}