• Skip to content
  • Skip to link menu
KDE 4.1 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 #include <KDebug>
00024 
00025 #include "dbus/nm-ip4-configinterface.h"
00026 #include "manager.h"
00027 #include "networkmanagerdefinitions.h"
00028 
00029 // lifted from libnm-glib/nm-device.h, remove when our NM packages have this version
00030 #define NM_DEVICE_UDI "udi"
00031 #define NM_DEVICE_INTERFACE "interface"
00032 #define NM_DEVICE_DRIVER "driver"
00033 #define NM_DEVICE_CAPABILITIES "capabilities"
00034 #define NM_DEVICE_MANAGED "managed"
00035 #define NM_DEVICE_IP4_CONFIG "ip4-config"
00036 #define NM_DEVICE_STATE "state"
00037 #define NM_DEVICE_VENDOR "vendor"
00038 #define NM_DEVICE_PRODUCT "product"
00039 
00040 NMNetworkInterfacePrivate::NMNetworkInterfacePrivate( const QString & path, QObject * owner ) : deviceIface(NMNetworkManager::DBUS_SERVICE, path, QDBusConnection::systemBus()), uni(path), designSpeed(0), manager(0)/*, propHelper(owner)*/
00041 {
00042     Q_UNUSED(owner);
00043     //isLinkUp = deviceIface.isLinkUp();
00044     driver = deviceIface.driver();
00045     interfaceName = deviceIface.interface();
00046     ipV4Address = deviceIface.ip4Address();    
00047     managed = deviceIface.managed();
00048 
00049     //TODO set active connections based on active connection list on the manager; find out if
00050     //signal needed
00051     //activeConnection = deviceIface.activeConnection();
00052     //propHelper.registerProperty(NM_DEVICE_UDI, PropertySignalPair("uni",0));
00053 }
00054 
00055 NMNetworkInterface::NMNetworkInterface(const QString & path, NMNetworkManager * manager, QObject * parent) : QObject(parent), d_ptr(new NMNetworkInterfacePrivate(path, this))
00056 {
00057     Q_D(NMNetworkInterface);
00058     init();
00059     d->manager = manager;
00060 }
00061 
00062 NMNetworkInterface::NMNetworkInterface(NMNetworkInterfacePrivate & dd, NMNetworkManager * manager, QObject * parent) : QObject(parent), d_ptr(&dd)
00063 {
00064     Q_D(NMNetworkInterface);
00065     init();
00066     d->manager = manager;
00067 }
00068 
00069 void NMNetworkInterface::init()
00070 {
00071     Q_D(NMNetworkInterface);
00072     d->capabilities = convertCapabilities(d->deviceIface.capabilities());
00073     d->connectionState = convertState(d->deviceIface.state());
00074 
00075     connect(&d->deviceIface, SIGNAL(StateChanged(uint)), this, SLOT(stateChanged(uint)));
00076 }
00077 
00078 NMNetworkInterface::~NMNetworkInterface()
00079 {
00080 
00081 }
00082 
00083 QString NMNetworkInterface::uni() const
00084 {
00085     Q_D(const NMNetworkInterface);
00086     return d->uni;
00087 }
00088 
00089 void NMNetworkInterface::setUni(const QVariant & uni)
00090 {
00091     Q_D(NMNetworkInterface);
00092     d->uni = uni.toString();
00093 }
00094 
00095 QString NMNetworkInterface::interfaceName() const
00096 {
00097     Q_D(const NMNetworkInterface);
00098     return d->interfaceName;
00099 }
00100 
00101 void NMNetworkInterface::setInterfaceName(const QVariant & name)
00102 {
00103     Q_D(NMNetworkInterface);
00104     d->interfaceName = name.toString();
00105 }
00106 
00107 QString NMNetworkInterface::driver() const
00108 {
00109     Q_D(const NMNetworkInterface);
00110     return d->driver;
00111 }
00112 
00113 void NMNetworkInterface::setDriver(const QVariant & driver)
00114 {
00115     Q_D(NMNetworkInterface);
00116     d->driver = driver.toString();
00117 }
00118 
00119 int NMNetworkInterface::ipV4Address() const
00120 {
00121     Q_D(const NMNetworkInterface);
00122     return d->ipV4Address;
00123 }
00124 
00125 Solid::Control::IPv4Config NMNetworkInterface::ipV4Config() const
00126 {
00127     Q_D(const NMNetworkInterface);
00128     if (d->connectionState != Solid::Control::NetworkInterface::Activated) {
00129         return Solid::Control::IPv4Config();
00130     } else {
00131         // ask the daemon for the details
00132         QDBusObjectPath ipV4ConfigPath = d->deviceIface.ip4Config();
00133         OrgFreedesktopNetworkManagerIP4ConfigInterface iface(NMNetworkManager::DBUS_SERVICE, ipV4ConfigPath.path(), QDBusConnection::systemBus());
00134         if (iface.isValid()) {
00135             UIntListList addresses = iface.addresses();
00136             QList<Solid::Control::IPv4Address> addressObjects;
00137             foreach (UIntList addressList, addresses) {
00138                 if ( addressList.count() == 3 ) {
00139                     Solid::Control::IPv4Address addr(addressList[0], addressList[1], addressList[2]);
00140                     addressObjects.append(addr);
00141                 }
00142             }
00143             return Solid::Control::IPv4Config(addressObjects, 0 /*broadcast*/,
00144                     iface.hostname(), iface.nameservers(), iface.domains(),
00145                     iface.nisDomain(), iface.nisServers());
00146         } else {
00147             return Solid::Control::IPv4Config();
00148         }
00149     }
00150 }
00151 
00152 bool NMNetworkInterface::isActive() const
00153 {
00154     Q_D(const NMNetworkInterface);
00155     return !(d->connectionState == Solid::Control::NetworkInterface::Unavailable
00156             || d->connectionState == Solid::Control::NetworkInterface::Disconnected
00157             || d->connectionState == Solid::Control::NetworkInterface::Failed );
00158 }
00159 
00160 bool NMNetworkInterface::managed() const
00161 {
00162     Q_D(const NMNetworkInterface);
00163     return d->managed;
00164 }
00165 
00166 void NMNetworkInterface::setManaged(const QVariant & driver)
00167 {
00168     Q_D(NMNetworkInterface);
00169     d->driver = driver.toBool();
00170 }
00171 
00172 Solid::Control::NetworkInterface::ConnectionState NMNetworkInterface::connectionState() const
00173 {
00174     Q_D(const NMNetworkInterface);
00175     return d->connectionState;
00176 }
00177 
00178 void NMNetworkInterface::setConnectionState(const QVariant & state)
00179 {
00180     Q_D(NMNetworkInterface);
00181     d->connectionState = convertState(state.toUInt());
00182 }
00183 
00184 int NMNetworkInterface::designSpeed() const
00185 {
00186     Q_D(const NMNetworkInterface);
00187     return d->designSpeed;
00188 }
00189 /*
00190 bool NMNetworkInterface::isLinkUp() const
00191 {
00192     Q_D(const NMNetworkInterface);
00193     return d->isLinkUp;
00194 }
00195 */
00196 Solid::Control::NetworkInterface::Capabilities NMNetworkInterface::capabilities() const
00197 {
00198     Q_D(const NMNetworkInterface);
00199     return d->capabilities;
00200 }
00201 
00202 QVariant NMNetworkInterface::capabilitiesV() const
00203 {
00204     Q_D(const NMNetworkInterface);
00205     return QVariant(d->capabilities);
00206 }
00207 
00208 void NMNetworkInterface::setCapabilitiesV(const QVariant & caps)
00209 {
00210     Q_D(NMNetworkInterface);
00211     d->capabilities = convertCapabilities(caps.toUInt());
00212 }
00213 
00214 Solid::Control::NetworkInterface::Capabilities NMNetworkInterface::convertCapabilities(uint theirCaps)
00215 {
00216     Solid::Control::NetworkInterface::Capabilities ourCaps
00217         = (Solid::Control::NetworkInterface::Capabilities) theirCaps;
00218     return ourCaps;
00219 }
00220 
00221 Solid::Control::NetworkInterface::ConnectionState NMNetworkInterface::convertState(uint theirState)
00222 {
00223     Solid::Control::NetworkInterface::ConnectionState ourState = (Solid::Control::NetworkInterface::ConnectionState)theirState;
00224     return ourState;
00225 }
00226 
00227 void NMNetworkInterface::stateChanged(uint state)
00228 {
00229     Q_D(NMNetworkInterface);
00230     d->connectionState = convertState(state);
00231 }
00232 
00233 #include "networkinterface.moc"
00234 

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
  •   libplasma
  •   libsolidcontrol
  •   libtaskmanager
  • Plasma
  •   Animators
  •   Applets
  •   Engines
  • Solid Modules
Generated for API Reference by doxygen 1.5.4
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