← Back to branch summary

~ubuntu-branches/ubuntu/utopic/kde-workspace/utopic-proposed

« back to all changes in this revision

Viewing changes to solid/networkmanager-0.7/networkinterface.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Michał Zając
  • Date: 2011-07-09 08:31:15 UTC
  • Revision ID: james.westby@ubuntu.com-20110709083115-ohyxn6z93mily9fc
Tags: upstream-4.6.90
Import upstream version 4.6.90

Show diffs side-by-side

added added

removed removed

Lines of Context:
solid/networkmanager-0.7/networkinterface.cpp
 
1
/*
 
2
Copyright 2008 Will Stephenson <wstephenson@kde.org>
 
3
 
 
4
This program is free software; you can redistribute it and/or
 
5
modify it under the terms of the GNU General Public License as
 
6
published by the Free Software Foundation; either version 2 of
 
7
the License or (at your option) version 3 or any later version
 
8
accepted by the membership of KDE e.V. (or its successor approved
 
9
by the membership of KDE e.V.), which shall act as a proxy 
 
10
defined in Section 14 of version 3 of the license.
 
11
 
 
12
This program 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
 
15
GNU General Public License for more details.
 
16
 
 
17
You should have received a copy of the GNU General Public License
 
18
along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
19
*/
 
20
 
 
21
#include "networkinterface.h"
 
22
#include "networkinterface_p.h"
 
23
 
 
24
#include <arpa/inet.h>
 
25
 
 
26
#include <KDebug>
 
27
 
 
28
#include "dbus/nm-ip4-configinterface.h"
 
29
#include "manager.h"
 
30
#include "networkmanagerdefinitions.h"
 
31
 
 
32
// lifted from libnm-glib/nm-device.h, remove when our NM packages have this version
 
33
#define NM_DEVICE_UDI "udi"
 
34
#define NM_DEVICE_INTERFACE "interface"
 
35
#define NM_DEVICE_DRIVER "driver"
 
36
#define NM_DEVICE_CAPABILITIES "capabilities"
 
37
#define NM_DEVICE_MANAGED "managed"
 
38
#define NM_DEVICE_IP4_CONFIG "ip4-config"
 
39
#define NM_DEVICE_STATE "state"
 
40
#define NM_DEVICE_VENDOR "vendor"
 
41
#define NM_DEVICE_PRODUCT "product"
 
42
 
 
43
NMNetworkInterfacePrivate::NMNetworkInterfacePrivate( const QString & path, QObject * owner ) : deviceIface(NMNetworkManager::DBUS_SERVICE, path, QDBusConnection::systemBus()), uni(path), designSpeed(0), manager(0)/*, propHelper(owner)*/
 
44
{
 
45
    Q_UNUSED(owner);
 
46
    //isLinkUp = deviceIface.isLinkUp();
 
47
    driver = deviceIface.driver();
 
48
    interfaceName = deviceIface.interface();
 
49
    ipV4Address = deviceIface.ip4Address();    
 
50
    managed = deviceIface.managed();
 
51
    udi = deviceIface.udi();
 
52
    firmwareMissing = deviceIface.firmwareMissing();
 
53
 
 
54
    //TODO set active connections based on active connection list on the manager; find out if
 
55
    //signal needed
 
56
    //activeConnection = deviceIface.activeConnection();
 
57
    //propHelper.registerProperty(NM_DEVICE_UDI, PropertySignalPair("uni",0));
 
58
}
 
59
 
 
60
NMNetworkInterfacePrivate::~NMNetworkInterfacePrivate()
 
61
{
 
62
 
 
63
}
 
64
 
 
65
NMNetworkInterface::NMNetworkInterface(const QString & path, NMNetworkManager * manager, QObject * parent) : QObject(parent), d_ptr(new NMNetworkInterfacePrivate(path, this))
 
66
{
 
67
    Q_D(NMNetworkInterface);
 
68
    init();
 
69
    d->manager = manager;
 
70
}
 
71
 
 
72
NMNetworkInterface::NMNetworkInterface(NMNetworkInterfacePrivate & dd, NMNetworkManager * manager, QObject * parent) : QObject(parent), d_ptr(&dd)
 
73
{
 
74
    qDBusRegisterMetaType<UIntList>();
 
75
    qDBusRegisterMetaType<UIntListList>();
 
76
    Q_D(NMNetworkInterface);
 
77
    init();
 
78
    d->manager = manager;
 
79
}
 
80
 
 
81
void NMNetworkInterface::init()
 
82
{
 
83
    Q_D(NMNetworkInterface);
 
84
    d->capabilities = convertCapabilities(d->deviceIface.capabilities());
 
85
    d->connectionState = convertState(d->deviceIface.state());
 
86
 
 
87
    connect(&d->deviceIface, SIGNAL(StateChanged(uint,uint,uint)), this, SLOT(stateChanged(uint,uint,uint)));
 
88
}
 
89
 
 
90
NMNetworkInterface::~NMNetworkInterface()
 
91
{
 
92
    delete d_ptr;
 
93
}
 
94
 
 
95
QString NMNetworkInterface::uni() const
 
96
{
 
97
    Q_D(const NMNetworkInterface);
 
98
    return d->uni;
 
99
}
 
100
 
 
101
void NMNetworkInterface::setUni(const QVariant & uni)
 
102
{
 
103
    Q_D(NMNetworkInterface);
 
104
    d->uni = uni.toString();
 
105
}
 
106
 
 
107
QString NMNetworkInterface::interfaceName() const
 
108
{
 
109
    Q_D(const NMNetworkInterface);
 
110
    return d->interfaceName;
 
111
}
 
112
 
 
113
void NMNetworkInterface::setInterfaceName(const QVariant & name)
 
114
{
 
115
    Q_D(NMNetworkInterface);
 
116
    d->interfaceName = name.toString();
 
117
}
 
118
 
 
119
QString NMNetworkInterface::ipInterfaceName() const
 
120
{
 
121
    Q_D(const NMNetworkInterface);
 
122
    return d->deviceIface.ipInterface();
 
123
}
 
124
 
 
125
QString NMNetworkInterface::driver() const
 
126
{
 
127
    Q_D(const NMNetworkInterface);
 
128
    return d->driver;
 
129
}
 
130
 
 
131
bool NMNetworkInterface::firmwareMissing() const
 
132
{
 
133
    Q_D(const NMNetworkInterface);
 
134
    return d->firmwareMissing;
 
135
}
 
136
 
 
137
void NMNetworkInterface::setDriver(const QVariant & driver)
 
138
{
 
139
    Q_D(NMNetworkInterface);
 
140
    d->driver = driver.toString();
 
141
}
 
142
 
 
143
QString NMNetworkInterface::udi() const
 
144
{
 
145
    Q_D(const NMNetworkInterface);
 
146
    return d->udi;
 
147
}
 
148
 
 
149
int NMNetworkInterface::ipV4Address() const
 
150
{
 
151
    Q_D(const NMNetworkInterface);
 
152
    return d->ipV4Address;
 
153
}
 
154
 
 
155
Solid::Control::IPv4Config NMNetworkInterface::ipV4Config() const
 
156
{
 
157
    Q_D(const NMNetworkInterface);
 
158
    if (d->connectionState != Solid::Control::NetworkInterface::Activated) {
 
159
        return Solid::Control::IPv4Config();
 
160
    } else {
 
161
        // ask the daemon for the details
 
162
        QDBusObjectPath ipV4ConfigPath = d->deviceIface.ip4Config();
 
163
        OrgFreedesktopNetworkManagerIP4ConfigInterface iface(NMNetworkManager::DBUS_SERVICE, ipV4ConfigPath.path(), QDBusConnection::systemBus());
 
164
        if (iface.isValid()) {
 
165
            //convert ipaddresses into object
 
166
            UIntListList addresses = iface.addresses();
 
167
            QList<Solid::Control::IPv4Address> addressObjects;
 
168
            foreach (UIntList addressList, addresses) {
 
169
                if ( addressList.count() == 3 ) {
 
170
                    Solid::Control::IPv4Address addr(htonl(addressList[0]), addressList[1], htonl(addressList[2]));
 
171
                    addressObjects.append(addr);
 
172
                }
 
173
            }
 
174
            //convert routes into objects
 
175
            UIntListList routes = iface.routes();
 
176
            QList<Solid::Control::IPv4Route> routeObjects;
 
177
            foreach (UIntList routeList, routes) {
 
178
                if ( routeList.count() == 4 ) {
 
179
                    Solid::Control::IPv4Route addr(routeList[0], routeList[1], routeList[2], routeList[3]);
 
180
                    routeObjects.append(addr);
 
181
                }
 
182
            }
 
183
            // nameservers' IP addresses are always in network byte order
 
184
            return Solid::Control::IPv4Config(addressObjects,
 
185
                iface.nameservers(), iface.domains(),
 
186
                routeObjects);
 
187
        } else {
 
188
            return Solid::Control::IPv4Config();
 
189
        }
 
190
    }
 
191
}
 
192
 
 
193
bool NMNetworkInterface::isActive() const
 
194
{
 
195
    Q_D(const NMNetworkInterface);
 
196
    return !(d->connectionState == Solid::Control::NetworkInterface::Unavailable
 
197
            || d->connectionState == Solid::Control::NetworkInterface::Disconnected
 
198
            || d->connectionState == Solid::Control::NetworkInterface::Failed );
 
199
}
 
200
 
 
201
bool NMNetworkInterface::managed() const
 
202
{
 
203
    Q_D(const NMNetworkInterface);
 
204
    return d->managed;
 
205
}
 
206
 
 
207
void NMNetworkInterface::disconnectInterface()
 
208
{
 
209
    Q_D(NMNetworkInterface);
 
210
    d->deviceIface.Disconnect();
 
211
}
 
212
 
 
213
void NMNetworkInterface::setManaged(const QVariant & driver)
 
214
{
 
215
    Q_D(NMNetworkInterface);
 
216
    d->driver = driver.toBool();
 
217
}
 
218
 
 
219
Solid::Control::NetworkInterface::ConnectionState NMNetworkInterface::connectionState() const
 
220
{
 
221
    Q_D(const NMNetworkInterface);
 
222
    return d->connectionState;
 
223
}
 
224
 
 
225
void NMNetworkInterface::setConnectionState(const QVariant & state)
 
226
{
 
227
    Q_D(NMNetworkInterface);
 
228
    d->connectionState = convertState(state.toUInt());
 
229
}
 
230
 
 
231
int NMNetworkInterface::designSpeed() const
 
232
{
 
233
    Q_D(const NMNetworkInterface);
 
234
    return d->designSpeed;
 
235
}
 
236
/*
 
237
bool NMNetworkInterface::isLinkUp() const
 
238
{
 
239
    Q_D(const NMNetworkInterface);
 
240
    return d->isLinkUp;
 
241
}
 
242
*/
 
243
Solid::Control::NetworkInterface::Capabilities NMNetworkInterface::capabilities() const
 
244
{
 
245
    Q_D(const NMNetworkInterface);
 
246
    return d->capabilities;
 
247
}
 
248
 
 
249
QVariant NMNetworkInterface::capabilitiesV() const
 
250
{
 
251
    Q_D(const NMNetworkInterface);
 
252
    return QVariant(d->capabilities);
 
253
}
 
254
 
 
255
void NMNetworkInterface::setCapabilitiesV(const QVariant & caps)
 
256
{
 
257
    Q_D(NMNetworkInterface);
 
258
    d->capabilities = convertCapabilities(caps.toUInt());
 
259
}
 
260
 
 
261
Solid::Control::NetworkInterface::Capabilities NMNetworkInterface::convertCapabilities(uint theirCaps)
 
262
{
 
263
    Solid::Control::NetworkInterface::Capabilities ourCaps
 
264
        = (Solid::Control::NetworkInterface::Capabilities) theirCaps;
 
265
    return ourCaps;
 
266
}
 
267
 
 
268
Solid::Control::NetworkInterface::ConnectionState NMNetworkInterface::convertState(uint theirState)
 
269
{
 
270
    Solid::Control::NetworkInterface::ConnectionState ourState = (Solid::Control::NetworkInterface::ConnectionState)theirState;
 
271
    return ourState;
 
272
}
 
273
 
 
274
void NMNetworkInterface::stateChanged(uint new_state, uint old_state, uint reason)
 
275
{
 
276
    Q_D(NMNetworkInterface);
 
277
    d->connectionState = convertState(new_state);
 
278
    emit connectionStateChanged(d->connectionState, convertState(old_state), reason);
 
279
}
 
280
 
 
281
#include "networkinterface.moc"
 
282