SolidModules
networkinterface.cpp
Go to the documentation of this file.00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021 #include "networkinterface.h"
00022 #include "networkinterface_p.h"
00023
00024 #include <arpa/inet.h>
00025
00026 #include <KDebug>
00027
00028 #include "dbus/nm-ip4-configinterface.h"
00029 #include "manager.h"
00030 #include "networkmanagerdefinitions.h"
00031
00032
00033 #define NM_DEVICE_UDI "udi"
00034 #define NM_DEVICE_INTERFACE "interface"
00035 #define NM_DEVICE_DRIVER "driver"
00036 #define NM_DEVICE_CAPABILITIES "capabilities"
00037 #define NM_DEVICE_MANAGED "managed"
00038 #define NM_DEVICE_IP4_CONFIG "ip4-config"
00039 #define NM_DEVICE_STATE "state"
00040 #define NM_DEVICE_VENDOR "vendor"
00041 #define NM_DEVICE_PRODUCT "product"
00042
00043 NMNetworkInterfacePrivate::NMNetworkInterfacePrivate( const QString & path, QObject * owner ) : deviceIface(NMNetworkManager::DBUS_SERVICE, path, QDBusConnection::systemBus()), uni(path), designSpeed(0), manager(0)
00044 {
00045 Q_UNUSED(owner);
00046
00047 driver = deviceIface.driver();
00048 interfaceName = deviceIface.interface();
00049 ipV4Address = deviceIface.ip4Address();
00050 managed = deviceIface.managed();
00051
00052
00053
00054
00055
00056 }
00057
00058 NMNetworkInterface::NMNetworkInterface(const QString & path, NMNetworkManager * manager, QObject * parent) : QObject(parent), d_ptr(new NMNetworkInterfacePrivate(path, this))
00059 {
00060 Q_D(NMNetworkInterface);
00061 init();
00062 d->manager = manager;
00063 }
00064
00065 NMNetworkInterface::NMNetworkInterface(NMNetworkInterfacePrivate & dd, NMNetworkManager * manager, QObject * parent) : QObject(parent), d_ptr(&dd)
00066 {
00067 qDBusRegisterMetaType<UIntList>();
00068 qDBusRegisterMetaType<UIntListList>();
00069 Q_D(NMNetworkInterface);
00070 init();
00071 d->manager = manager;
00072 }
00073
00074 void NMNetworkInterface::init()
00075 {
00076 Q_D(NMNetworkInterface);
00077 d->capabilities = convertCapabilities(d->deviceIface.capabilities());
00078 d->connectionState = convertState(d->deviceIface.state());
00079
00080 connect(&d->deviceIface, SIGNAL(StateChanged(uint,uint,uint)), this, SLOT(stateChanged(uint,uint,uint)));
00081 }
00082
00083 NMNetworkInterface::~NMNetworkInterface()
00084 {
00085
00086 }
00087
00088 QString NMNetworkInterface::uni() const
00089 {
00090 Q_D(const NMNetworkInterface);
00091 return d->uni;
00092 }
00093
00094 void NMNetworkInterface::setUni(const QVariant & uni)
00095 {
00096 Q_D(NMNetworkInterface);
00097 d->uni = uni.toString();
00098 }
00099
00100 QString NMNetworkInterface::interfaceName() const
00101 {
00102 Q_D(const NMNetworkInterface);
00103 return d->interfaceName;
00104 }
00105
00106 void NMNetworkInterface::setInterfaceName(const QVariant & name)
00107 {
00108 Q_D(NMNetworkInterface);
00109 d->interfaceName = name.toString();
00110 }
00111
00112 QString NMNetworkInterface::driver() const
00113 {
00114 Q_D(const NMNetworkInterface);
00115 return d->driver;
00116 }
00117
00118 void NMNetworkInterface::setDriver(const QVariant & driver)
00119 {
00120 Q_D(NMNetworkInterface);
00121 d->driver = driver.toString();
00122 }
00123
00124 int NMNetworkInterface::ipV4Address() const
00125 {
00126 Q_D(const NMNetworkInterface);
00127 return d->ipV4Address;
00128 }
00129
00130 Solid::Control::IPv4Config NMNetworkInterface::ipV4Config() const
00131 {
00132 Q_D(const NMNetworkInterface);
00133 if (d->connectionState != Solid::Control::NetworkInterface::Activated) {
00134 return Solid::Control::IPv4Config();
00135 } else {
00136
00137 QDBusObjectPath ipV4ConfigPath = d->deviceIface.ip4Config();
00138 OrgFreedesktopNetworkManagerIP4ConfigInterface iface(NMNetworkManager::DBUS_SERVICE, ipV4ConfigPath.path(), QDBusConnection::systemBus());
00139 if (iface.isValid()) {
00140
00141 UIntListList addresses = iface.addresses();
00142 QList<Solid::Control::IPv4Address> addressObjects;
00143 foreach (UIntList addressList, addresses) {
00144 if ( addressList.count() == 3 ) {
00145 Solid::Control::IPv4Address addr(htonl(addressList[0]), htonl(addressList[1]), htonl(addressList[2]));
00146 addressObjects.append(addr);
00147 }
00148 }
00149
00150 UIntListList routes = iface.routes();
00151 QList<Solid::Control::IPv4Route> routeObjects;
00152 foreach (UIntList routeList, routes) {
00153 if ( routeList.count() == 4 ) {
00154 Solid::Control::IPv4Route addr(routeList[0], routeList[1], routeList[2], routeList[3]);
00155 routeObjects.append(addr);
00156 }
00157 }
00158 return Solid::Control::IPv4Config(addressObjects,
00159 iface.nameservers(), iface.domains(),
00160 routeObjects);
00161 } else {
00162 return Solid::Control::IPv4Config();
00163 }
00164 }
00165 }
00166
00167 bool NMNetworkInterface::isActive() const
00168 {
00169 Q_D(const NMNetworkInterface);
00170 return !(d->connectionState == Solid::Control::NetworkInterface::Unavailable
00171 || d->connectionState == Solid::Control::NetworkInterface::Disconnected
00172 || d->connectionState == Solid::Control::NetworkInterface::Failed );
00173 }
00174
00175 bool NMNetworkInterface::managed() const
00176 {
00177 Q_D(const NMNetworkInterface);
00178 return d->managed;
00179 }
00180
00181 void NMNetworkInterface::setManaged(const QVariant & driver)
00182 {
00183 Q_D(NMNetworkInterface);
00184 d->driver = driver.toBool();
00185 }
00186
00187 Solid::Control::NetworkInterface::ConnectionState NMNetworkInterface::connectionState() const
00188 {
00189 Q_D(const NMNetworkInterface);
00190 return d->connectionState;
00191 }
00192
00193 void NMNetworkInterface::setConnectionState(const QVariant & state)
00194 {
00195 Q_D(NMNetworkInterface);
00196 d->connectionState = convertState(state.toUInt());
00197 }
00198
00199 int NMNetworkInterface::designSpeed() const
00200 {
00201 Q_D(const NMNetworkInterface);
00202 return d->designSpeed;
00203 }
00204
00205
00206
00207
00208
00209
00210
00211 Solid::Control::NetworkInterface::Capabilities NMNetworkInterface::capabilities() const
00212 {
00213 Q_D(const NMNetworkInterface);
00214 return d->capabilities;
00215 }
00216
00217 QVariant NMNetworkInterface::capabilitiesV() const
00218 {
00219 Q_D(const NMNetworkInterface);
00220 return QVariant(d->capabilities);
00221 }
00222
00223 void NMNetworkInterface::setCapabilitiesV(const QVariant & caps)
00224 {
00225 Q_D(NMNetworkInterface);
00226 d->capabilities = convertCapabilities(caps.toUInt());
00227 }
00228
00229 Solid::Control::NetworkInterface::Capabilities NMNetworkInterface::convertCapabilities(uint theirCaps)
00230 {
00231 Solid::Control::NetworkInterface::Capabilities ourCaps
00232 = (Solid::Control::NetworkInterface::Capabilities) theirCaps;
00233 return ourCaps;
00234 }
00235
00236 Solid::Control::NetworkInterface::ConnectionState NMNetworkInterface::convertState(uint theirState)
00237 {
00238 Solid::Control::NetworkInterface::ConnectionState ourState = (Solid::Control::NetworkInterface::ConnectionState)theirState;
00239 return ourState;
00240 }
00241
00242 void NMNetworkInterface::stateChanged(uint new_state, uint old_state, uint reason)
00243 {
00244 Q_D(NMNetworkInterface);
00245 d->connectionState = convertState(new_state);
00246 emit connectionStateChanged(d->connectionState);
00247 }
00248
00249 #include "networkinterface.moc"
00250