← Back to branch summary

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

« back to all changes in this revision

Viewing changes to declarative-plugins/handler.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:
declarative-plugins/handler.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 "handler.h"
 
22
#include "uiutils.h"
 
23
#include "debug.h"
 
24
#include "lib/editor/connectiondetaileditor.h"
 
25
 
 
26
#include <NetworkManagerQt/Manager>
 
27
#include <NetworkManagerQt/AccessPoint>
 
28
#include <NetworkManagerQt/WiredDevice>
 
29
#include <NetworkManagerQt/WirelessDevice>
 
30
#include <NetworkManagerQt/Settings>
 
31
#include <NetworkManagerQt/Setting>
 
32
#include <NetworkManagerQt/Utils>
 
33
#include <NetworkManagerQt/ConnectionSettings>
 
34
#include <NetworkManagerQt/WiredSetting>
 
35
#include <NetworkManagerQt/WirelessSetting>
 
36
#include <NetworkManagerQt/ActiveConnection>
 
37
 
 
38
#include <QInputDialog>
 
39
 
 
40
#include <KUser>
 
41
#include <KProcess>
 
42
#include <KWindowSystem>
 
43
 
 
44
Handler::Handler(QObject* parent):
 
45
    QObject(parent)
 
46
{
 
47
}
 
48
 
 
49
Handler::~Handler()
 
50
{
 
51
}
 
52
 
 
53
void Handler::activateConnection(const QString& connection, const QString& device, const QString& specificObject)
 
54
{
 
55
    NetworkManager::Connection::Ptr con = NetworkManager::findConnection(connection);
 
56
 
 
57
    if (!con) {
 
58
        NMHandlerDebug() << "Not possible to activate this connection";
 
59
        return;
 
60
    }
 
61
        NMHandlerDebug() << "Activating " << con->name() << " connection";
 
62
 
 
63
    NetworkManager::activateConnection(connection, device, specificObject);
 
64
}
 
65
 
 
66
void Handler::addAndActivateConnection(const QString& device, const QString& specificObject, const QString& password, bool autoConnect)
 
67
{
 
68
    NetworkManager::AccessPoint::Ptr ap;
 
69
    NetworkManager::WirelessDevice::Ptr wifiDev;
 
70
    foreach (const NetworkManager::Device::Ptr & dev, NetworkManager::networkInterfaces()) {
 
71
        if (dev->type() == NetworkManager::Device::Wifi) {
 
72
            wifiDev = dev.objectCast<NetworkManager::WirelessDevice>();
 
73
            ap = wifiDev->findAccessPoint(specificObject);
 
74
            if (ap) {
 
75
                break;
 
76
            }
 
77
        }
 
78
    }
 
79
 
 
80
    if (!ap) {
 
81
        return;
 
82
    }
 
83
 
 
84
    NetworkManager::ConnectionSettings::Ptr settings = NetworkManager::ConnectionSettings::Ptr(new NetworkManager::ConnectionSettings(NetworkManager::ConnectionSettings::Wireless));
 
85
    settings->setId(ap->ssid());
 
86
    settings->setUuid(NetworkManager::ConnectionSettings::createNewUuid());
 
87
    settings->setAutoconnect(autoConnect);
 
88
    settings->addToPermissions(KUser().loginName(), QString());
 
89
 
 
90
    NetworkManager::WirelessSetting::Ptr wifiSetting = settings->setting(NetworkManager::Setting::Wireless).dynamicCast<NetworkManager::WirelessSetting>();
 
91
    wifiSetting->setInitialized(true);
 
92
    wifiSetting = settings->setting(NetworkManager::Setting::Wireless).dynamicCast<NetworkManager::WirelessSetting>();
 
93
    wifiSetting->setSsid(ap->ssid().toUtf8());
 
94
 
 
95
    NetworkManager::WirelessSecuritySetting::Ptr wifiSecurity = settings->setting(NetworkManager::Setting::WirelessSecurity).dynamicCast<NetworkManager::WirelessSecuritySetting>();
 
96
 
 
97
    NetworkManager::Utils::WirelessSecurityType securityType = NetworkManager::Utils::findBestWirelessSecurity(wifiDev->wirelessCapabilities(), true, (ap->mode() == NetworkManager::AccessPoint::Adhoc), ap->capabilities(), ap->wpaFlags(), ap->rsnFlags());
 
98
 
 
99
    if (securityType != NetworkManager::Utils::None) {
 
100
        wifiSecurity->setInitialized(true);
 
101
        wifiSetting->setSecurity("802-11-wireless-security");
 
102
    }
 
103
 
 
104
    if (securityType == NetworkManager::Utils::Leap ||
 
105
        securityType == NetworkManager::Utils::DynamicWep ||
 
106
        securityType == NetworkManager::Utils::Wpa2Eap ||
 
107
        securityType == NetworkManager::Utils::WpaEap) {
 
108
        if (securityType == NetworkManager::Utils::DynamicWep || securityType == NetworkManager::Utils::Leap) {
 
109
            wifiSecurity->setKeyMgmt(NetworkManager::WirelessSecuritySetting::Ieee8021x);
 
110
            if (securityType == NetworkManager::Utils::Leap) {
 
111
                wifiSecurity->setAuthAlg(NetworkManager::WirelessSecuritySetting::Leap);
 
112
            }
 
113
        } else {
 
114
            wifiSecurity->setKeyMgmt(NetworkManager::WirelessSecuritySetting::WpaEap);
 
115
        }
 
116
        m_tmpConnectionUuid = settings->uuid();
 
117
        m_tmpDevicePath = device;
 
118
        m_tmpSpecificPath = specificObject;
 
119
 
 
120
        QPointer<ConnectionDetailEditor> editor = new ConnectionDetailEditor(settings, 0, 0, true);
 
121
        editor->show();
 
122
        KWindowSystem::setState(editor->winId(), NET::KeepAbove);
 
123
        KWindowSystem::forceActiveWindow(editor->winId());
 
124
        connect(editor, SIGNAL(accepted()), SLOT(editDialogAccepted()));
 
125
    } else {
 
126
        if (securityType == NetworkManager::Utils::StaticWep) {
 
127
            wifiSecurity->setKeyMgmt(NetworkManager::WirelessSecuritySetting::Wep);
 
128
            wifiSecurity->setWepKey0(password);
 
129
            wifiSecurity->setWepKeyFlags(NetworkManager::Setting::AgentOwned);
 
130
        } else {
 
131
            wifiSecurity->setKeyMgmt(NetworkManager::WirelessSecuritySetting::WpaPsk);
 
132
            wifiSecurity->setPsk(password);
 
133
            wifiSecurity->setPskFlags(NetworkManager::Setting::AgentOwned);
 
134
        }
 
135
        NetworkManager::addAndActivateConnection(settings->toMap(), device, specificObject);
 
136
    }
 
137
 
 
138
    settings.clear();
 
139
}
 
140
 
 
141
void Handler::deactivateConnection(const QString& connection)
 
142
{
 
143
    NetworkManager::Connection::Ptr con = NetworkManager::findConnection(connection);
 
144
 
 
145
    if (!con) {
 
146
        NMHandlerDebug() << "Not possible to deactivate this connection";
 
147
        return;
 
148
    }
 
149
 
 
150
    foreach (const NetworkManager::ActiveConnection::Ptr & active, NetworkManager::activeConnections()) {
 
151
        if (active->uuid() == con->uuid()) {
 
152
            if (active->vpn()) {
 
153
                NetworkManager::deactivateConnection(active->path());
 
154
            } else {
 
155
                if (active->devices().isEmpty()) {
 
156
                    NetworkManager::deactivateConnection(connection);
 
157
                }
 
158
                NetworkManager::Device::Ptr device = NetworkManager::findNetworkInterface(active->devices().first());
 
159
                if (device) {
 
160
                    device->disconnectInterface();
 
161
                }
 
162
            }
 
163
        }
 
164
    }
 
165
 
 
166
    NMHandlerDebug() << "Deactivating " << con->name() << " connection";
 
167
}
 
168
 
 
169
void Handler::disconnectAll()
 
170
{
 
171
    foreach (const NetworkManager::Device::Ptr & device, NetworkManager::networkInterfaces()) {
 
172
        device->disconnectInterface();
 
173
    }
 
174
}
 
175
 
 
176
void Handler::enableNetworking(bool enable)
 
177
{
 
178
    NMHandlerDebug() << "Networking enabled: " << enable;
 
179
    NetworkManager::setNetworkingEnabled(enable);
 
180
}
 
181
 
 
182
void Handler::enableWireless(bool enable)
 
183
{
 
184
    NMHandlerDebug() << "Wireless enabled: " << enable;
 
185
    NetworkManager::setWirelessEnabled(enable);
 
186
}
 
187
 
 
188
void Handler::enableWimax(bool enable)
 
189
{
 
190
    NMHandlerDebug() << "Wimax enabled: " << enable;
 
191
    NetworkManager::setWimaxEnabled(enable);
 
192
}
 
193
 
 
194
void Handler::enableWwan(bool enable)
 
195
{
 
196
    NMHandlerDebug() << "Wwan enabled: " << enable;
 
197
    NetworkManager::setWwanEnabled(enable);
 
198
}
 
199
 
 
200
void Handler::editConnection(const QString& uuid)
 
201
{
 
202
    QStringList args;
 
203
    args << uuid;
 
204
    KProcess::startDetached("kde-nm-connection-editor", args);
 
205
}
 
206
 
 
207
void Handler::removeConnection(const QString& connection)
 
208
{
 
209
    NetworkManager::Connection::Ptr con = NetworkManager::findConnection(connection);
 
210
 
 
211
    if (!con || con->uuid().isEmpty()) {
 
212
        NMHandlerDebug() << "Not possible to remove this connection";
 
213
        return;
 
214
    }
 
215
 
 
216
    foreach (const NetworkManager::Connection::Ptr &masterConnection, NetworkManager::listConnections()) {
 
217
        NetworkManager::ConnectionSettings::Ptr settings = masterConnection->settings();
 
218
        if (settings->master() == con->uuid()) {
 
219
            masterConnection->remove();
 
220
        }
 
221
    }
 
222
 
 
223
    con->remove();
 
224
}
 
225
 
 
226
void Handler::openEditor()
 
227
{
 
228
    KProcess::startDetached("kde-nm-connection-editor");
 
229
}
 
230
 
 
231
 
 
232
void Handler::editDialogAccepted()
 
233
{
 
234
    NetworkManager::Connection::Ptr newConnection = NetworkManager::findConnectionByUuid(m_tmpConnectionUuid);
 
235
    if (newConnection) {
 
236
        activateConnection(newConnection->path(), m_tmpDevicePath, m_tmpSpecificPath);
 
237
    }
 
238
}