• Skip to content
  • Skip to link menu
KDE 4.2 API Reference
  • KDE API Reference
  • API Reference
  • Sitemap
  • Contact Us
 

SolidModules

networkinterface.cpp

Go to the documentation of this file.
00001 /*
00002 Copyright 2008 Will Stephenson <wstephenson@kde.org>
00003 
00004 This program is free software; you can redistribute it and/or
00005 modify it under the terms of the GNU General Public License as
00006 published by the Free Software Foundation; either version 2 of
00007 the License or (at your option) version 3 or any later version
00008 accepted by the membership of KDE e.V. (or its successor approved
00009 by the membership of KDE e.V.), which shall act as a proxy 
00010 defined in Section 14 of version 3 of the license.
00011 
00012 This program is distributed in the hope that it will be useful,
00013 but WITHOUT ANY WARRANTY; without even the implied warranty of
00014 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00015 GNU General Public License for more details.
00016 
00017 You should have received a copy of the GNU General Public License
00018 along with this program.  If not, see <http://www.gnu.org/licenses/>.
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 // lifted from libnm-glib/nm-device.h, remove when our NM packages have this version
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)/*, propHelper(owner)*/
00044 {
00045     Q_UNUSED(owner);
00046     //isLinkUp = deviceIface.isLinkUp();
00047     driver = deviceIface.driver();
00048     interfaceName = deviceIface.interface();
00049     ipV4Address = deviceIface.ip4Address();    
00050     managed = deviceIface.managed();
00051 
00052     //TODO set active connections based on active connection list on the manager; find out if
00053     //signal needed
00054     //activeConnection = deviceIface.activeConnection();
00055     //propHelper.registerProperty(NM_DEVICE_UDI, PropertySignalPair("uni",0));
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         // ask the daemon for the details
00137         QDBusObjectPath ipV4ConfigPath = d->deviceIface.ip4Config();
00138         OrgFreedesktopNetworkManagerIP4ConfigInterface iface(NMNetworkManager::DBUS_SERVICE, ipV4ConfigPath.path(), QDBusConnection::systemBus());
00139         if (iface.isValid()) {
00140             //convert ipaddresses into object
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             //convert routes into objects
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 bool NMNetworkInterface::isLinkUp() const
00206 {
00207     Q_D(const NMNetworkInterface);
00208     return d->isLinkUp;
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 

SolidModules

Skip menu "SolidModules"
  • Main Page
  • Namespace List
  • Class Hierarchy
  • Alphabetical List
  • Class List
  • File List
  • Namespace Members
  • Class Members

API Reference

Skip menu "API Reference"
  • KWin
  •   KWin Libraries
  • Libraries
  •   libkworkspace
  •   libsolidcontrol
  •   libtaskmanager
  • Plasma
  •   Animators
  •   Applets
  •   Engines
  • Solid Modules
Generated for API Reference by doxygen 1.5.7
This website is maintained by Adriaan de Groot and Allen Winter.
KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V. | Legal