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

SolidModules

NetworkManager-networkmanager.cpp

Go to the documentation of this file.
00001 /*  This file is part of the KDE project
00002     Copyright (C) 2007 Will Stephenson <wstephenson@kde.org>
00003     Copyright (C) 2008 Pino Toscano <pino@kde.org>
00004 
00005     This library is free software; you can redistribute it and/or
00006     modify it under the terms of the GNU Library General Public
00007     License version 2 as published by the Free Software Foundation.
00008 
00009     This library is distributed in the hope that it will be useful,
00010     but WITHOUT ANY WARRANTY; without even the implied warranty of
00011     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00012     Library General Public License for more details.
00013 
00014     You should have received a copy of the GNU Library General Public License
00015     along with this library; see the file COPYING.LIB.  If not, write to
00016     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
00017     Boston, MA 02110-1301, USA.
00018 
00019 */
00020 
00021 #include "NetworkManager-networkmanager.h"
00022 
00023 #include <NetworkManager/NetworkManager.h>
00024 
00025 #include <QtDBus/QDBusConnection>
00026 #include <QtDBus/QDBusConnectionInterface>
00027 #include <QtDBus/QDBusInterface>
00028 #include <QtDBus/QDBusMetaType>
00029 #include <QtDBus/QDBusReply>
00030 
00031 #include <kdebug.h>
00032 
00033 #include "NetworkManager-wirednetwork.h"
00034 #include "NetworkManager-wirelessnetwork.h"
00035 
00036 class NMNetworkManagerPrivate
00037 {
00038 public:
00039     NMNetworkManagerPrivate();
00040 
00041     void fillNetworkInterfacesList();
00042 
00043     QDBusInterface manager;
00044     QHash<QString, NMNetworkInterface *> interfaces;
00045     NMState cachedState;
00046     bool wirelessEnabled;
00047     bool wirelessHardwareEnabled;
00048 };
00049 
00050 NMNetworkManagerPrivate::NMNetworkManagerPrivate()
00051     : manager(NM_DBUS_SERVICE, NM_DBUS_PATH, NM_DBUS_INTERFACE, QDBusConnection::systemBus())
00052     , cachedState(NM_STATE_UNKNOWN)
00053     , wirelessEnabled(false)
00054     , wirelessHardwareEnabled(false)
00055 {
00056 }
00057 
00058 
00059 NMNetworkManager::NMNetworkManager(QObject * parent, const QVariantList  & /*args */)
00060  : NetworkManager(parent), d(new NMNetworkManagerPrivate)
00061 {
00062     #define connectNMToThis(signal, slot) \
00063     d->manager.connection().connect(NM_DBUS_SERVICE, NM_DBUS_PATH, NM_DBUS_INTERFACE, \
00064                                      signal, this, SLOT(slot));
00065     connectNMToThis(NM_DBUS_SIGNAL_STATE_CHANGE, stateChanged(uint));
00066     connectNMToThis("DeviceAdded", receivedDeviceAdded(QDBusObjectPath));
00067     connectNMToThis("DeviceRemoved", receivedDeviceRemoved(QDBusObjectPath));
00068     connectNMToThis("DeviceStrengthChanged", deviceStrengthChanged(QDBusObjectPath,int));
00069     connectNMToThis("WirelessNetworkStrengthChanged", networkStrengthChanged(QDBusObjectPath,QDBusObjectPath,int));
00070     connectNMToThis("WirelessNetworkAppeared", wirelessNetworkAppeared(QDBusObjectPath,QDBusObjectPath));
00071     connectNMToThis("WirelessNetworkDisappeared", wirelessNetworkDisappeared(QDBusObjectPath,QDBusObjectPath));
00072     connectNMToThis("DeviceActivationStage", deviceActivationStageChanged(QDBusObjectPath,uint));
00073 
00074     connectNMToThis("DeviceCarrierOn", carrierOn(QDBusObjectPath));
00075     connectNMToThis("DeviceCarrierOff", carrierOff(QDBusObjectPath));
00076     connectNMToThis("DeviceNowActive", nowActive(QDBusObjectPath));
00077     connectNMToThis("DeviceNoLongerActive", noLongerActive(QDBusObjectPath));
00078     connectNMToThis("DeviceActivating", activating(QDBusObjectPath));
00079     //TODO: find a way to connect to the wireless variant of this, incl essid
00080     connectNMToThis("DeviceActivationFailed", activationFailed(QDBusObjectPath));
00081     connectNMToThis("WirelessEnabled", wirelessEnabled(bool, bool));
00082 
00083     connect(QDBusConnection::systemBus().interface(), SIGNAL(serviceOwnerChanged(QString, QString, QString)),
00084             this, SLOT(nameOwnerChanged(QString,QString,QString)));
00085 
00086     qDBusRegisterMetaType<QList<QDBusObjectPath> >();
00087 
00088     d->fillNetworkInterfacesList();
00089 
00090     const QDBusMessage wirelessEnabledReply = d->manager.call("getWirelessEnabled");
00091     if (wirelessEnabledReply.type() == QDBusMessage::ReplyMessage)
00092     {
00093         const QList<QVariant> args = wirelessEnabledReply.arguments();
00094         if (args.size() > 0) d->wirelessEnabled = args[0].toBool();
00095         if (args.size() > 1) d->wirelessHardwareEnabled = args[1].toBool();
00096     }
00097 }
00098 
00099 NMNetworkManager::~NMNetworkManager()
00100 {
00101     delete d;
00102 }
00103 
00104 Solid::Networking::Status NMNetworkManager::status() const
00105 {
00106     if (NM_STATE_UNKNOWN == d->cachedState)
00107     {
00108         QDBusReply< uint > state = d->manager.call("state");
00109         if (state.isValid())
00110         {
00111             kDebug(1441) << "  got state: " << state.value();
00112             d->cachedState = static_cast<NMState>(state.value());
00113         }
00114     }
00115     switch ( d->cachedState ) {
00116         case NM_STATE_CONNECTING:
00117             return Solid::Networking::Connecting;
00118             break;
00119         case NM_STATE_CONNECTED:
00120             return Solid::Networking::Connected;
00121             break;
00122         case NM_STATE_DISCONNECTED:
00123             return Solid::Networking::Unconnected;
00124             break;
00125         default:
00126         case NM_STATE_UNKNOWN:
00127         case NM_STATE_ASLEEP:
00128             return Solid::Networking::Unknown;
00129             break;
00130     }
00131 }
00132 
00133 QStringList NMNetworkManager::networkInterfaces() const
00134 {
00135     kDebug(1441);
00136     return d->interfaces.keys();
00137 }
00138 
00139 void NMNetworkManagerPrivate::fillNetworkInterfacesList()
00140 {
00141     // wtf does this work when not called on org.freedesktop.NetworkManager.Devices?
00142     QDBusReply< QList <QDBusObjectPath> > deviceList = manager.call("getDevices");
00143     if (deviceList.isValid())
00144     {
00145         kDebug(1441) << "Got device list";
00146         QList <QDBusObjectPath> devices = deviceList.value();
00147         foreach (const QDBusObjectPath & op, devices)
00148         {
00149             QHash<QString, NMNetworkInterface *>::ConstIterator it = interfaces.find(op.path());
00150             if (it == interfaces.end())
00151             {
00152                 interfaces.insert(op.path(), 0);
00153                 kDebug(1441) << "  adding:" << op.path();
00154             }
00155         }
00156     }
00157     else
00158         kDebug(1441) << "Error getting device list: " << deviceList.error().name() << ": " << deviceList.error().message();
00159 }
00160 
00161 QObject * NMNetworkManager::createNetworkInterface(const QString  & uni)
00162 {
00163     kDebug(1441) << uni;
00164     NMNetworkInterface * netInterface = 0;
00165     QHash<QString, NMNetworkInterface *>::Iterator it = d->interfaces.find(uni);
00166     if (it == d->interfaces.end())
00167     {
00168         kDebug(1441) << "unknown interface:" << uni;
00169         return 0;
00170     }
00171     if (it.value())
00172     {
00173         netInterface = it.value();
00174     }
00175     else
00176     {
00177         QDBusInterface iface(NM_DBUS_SERVICE,
00178                              uni,
00179                              NM_DBUS_INTERFACE_DEVICES,
00180                              QDBusConnection::systemBus());
00181         QDBusReply<int> reply = iface.call("getType");
00182         if (!reply.isValid())
00183         {
00184             kDebug(1441) << "Invalid reply, most probably the specified device does not exists.";
00185             return 0;
00186         }
00187         const int type = reply.value();
00188         switch (type)
00189         {
00190         case DEVICE_TYPE_802_3_ETHERNET:
00191             netInterface = new NMWiredNetwork(uni);
00192             break;
00193         case DEVICE_TYPE_802_11_WIRELESS:
00194             netInterface = new NMWirelessNetwork(uni);
00195             break;
00196         case DEVICE_TYPE_UNKNOWN:
00197         default:
00198             ;
00199         }
00200 
00201         if (netInterface)
00202         {
00203             netInterface->setManagerInterface(&d->manager);
00204             it.value() = netInterface;
00205         }
00206     }
00207     return netInterface;
00208 }
00209 
00210 bool NMNetworkManager::isNetworkingEnabled() const
00211 {
00212     kDebug(1441);
00213     if (NM_STATE_UNKNOWN == d->cachedState)
00214     {
00215         QDBusReply< uint > state = d->manager.call("state");
00216         if (state.isValid())
00217         {
00218             kDebug(1441) << "  got state: " << state.value();
00219             d->cachedState = static_cast<NMState>(state.value());
00220         }
00221     }
00222     return NM_STATE_CONNECTING == d->cachedState || NM_STATE_CONNECTED == d->cachedState || NM_STATE_DISCONNECTED == d->cachedState;
00223 }
00224 
00225 bool NMNetworkManager::isWirelessEnabled() const
00226 {
00227     kDebug(1441);
00228     return d->wirelessEnabled;
00229 }
00230 
00231 bool NMNetworkManager::isWirelessHardwareEnabled() const
00232 {
00233     kDebug(1441);
00234     return d->wirelessHardwareEnabled;
00235 }
00236 
00237 void NMNetworkManager::activateConnection(const QString & interfaceUni, const QString & connectionUni, const QVariantMap & connectionParameters)
00238 {
00239     kDebug(1441) << interfaceUni << connectionUni << connectionParameters;
00240     QHash<QString, NMNetworkInterface *>::ConstIterator it = d->interfaces.find(interfaceUni);
00241     if (it != d->interfaces.end())
00242     {
00243         NMNetworkInterface * interface = it.value();
00244         if (!interface)
00245             interface = qobject_cast<NMNetworkInterface *>(createNetworkInterface(interfaceUni));
00246         if (interface)
00247         {
00248             bool activated = interface->activateConnection(connectionUni, connectionParameters);
00249             Q_UNUSED(activated)
00250         }
00251     }
00252 }
00253 
00254 void NMNetworkManager::deactivateConnection(const QString & activeConnection)
00255 {
00256     kDebug(1441) << activeConnection;
00257     QHash<QString, NMNetworkInterface *>::ConstIterator it = d->interfaces.find(activeConnection);
00258     if (it != d->interfaces.end() && it.value())
00259     {
00260         NMNetworkInterface * interface = it.value();
00261         bool deactivated = interface->deactivateConnection();
00262         Q_UNUSED(deactivated)
00263     }
00264 }
00265 
00266 void NMNetworkManager::setNetworkingEnabled(bool enabled)
00267 {
00268     kDebug(1441) << enabled;
00269     d->manager.call(enabled ? "wake" : "sleep"); //TODO Find out the semantics of the optional bool argument to 'sleep'
00270 }
00271 
00272 void NMNetworkManager::setWirelessEnabled(bool enabled)
00273 {
00274     kDebug(1441) << enabled;
00275     d->manager.call("setWirelessEnabled", enabled);
00276 }
00277 
00278 void NMNetworkManager::stateChanged(uint state)
00279 {
00280     d->cachedState = static_cast<NMState>(state);
00281     switch ( d->cachedState ) {
00282         case NM_STATE_CONNECTING:
00283             kDebug(1441) << "Connecting";
00284             emit statusChanged( Solid::Networking::Connecting );
00285             break;
00286         case NM_STATE_CONNECTED:
00287             kDebug(1441) << "CONNECTED";
00288             emit statusChanged( Solid::Networking::Connected );
00289             break;
00290         case NM_STATE_ASLEEP:
00291         case NM_STATE_DISCONNECTED:
00292             kDebug(1441) << "Unconnected";
00293             emit statusChanged( Solid::Networking::Unconnected );
00294             break;
00295         default:
00296         case NM_STATE_UNKNOWN:
00297             kDebug(1441) << "Unknown";
00298             emit statusChanged( Solid::Networking::Unknown );
00299             break;
00300     }
00301 }
00302 
00303 void NMNetworkManager::receivedDeviceAdded(const QDBusObjectPath & objpath)
00304 {
00305     kDebug(1441) << objpath.path();
00306     const QString path = objpath.path();
00307     QHash<QString, NMNetworkInterface *>::ConstIterator it = d->interfaces.find(path);
00308     if (it == d->interfaces.end())
00309     {
00310         d->interfaces.insert(path, 0);
00311         emit networkInterfaceAdded(path);
00312     }
00313 }
00314 
00315 void NMNetworkManager::receivedDeviceRemoved(const QDBusObjectPath & objpath)
00316 {
00317     kDebug(1441) << objpath.path();
00318     const QString path = objpath.path();
00319     QHash<QString, NMNetworkInterface *>::Iterator it = d->interfaces.find(path);
00320     if (it != d->interfaces.end())
00321     {
00322         NMNetworkInterface * iface = it.value();
00323         d->interfaces.erase(it);
00324         emit networkInterfaceRemoved(path);
00325         delete iface;
00326     }
00327 }
00328 
00329 void NMNetworkManager::deviceStrengthChanged(const QDBusObjectPath & devPath, int strength)
00330 {
00331     kDebug(1441) << devPath.path() << strength;
00332 }
00333 
00334 void NMNetworkManager::networkStrengthChanged(const QDBusObjectPath & devPath, const QDBusObjectPath & netPath, int strength)
00335 {
00336     kDebug(1441) << devPath.path() << "," << netPath.path() << "," << strength;
00337     QHash<QString, NMNetworkInterface *>::ConstIterator it = d->interfaces.find(devPath.path());
00338     if (it != d->interfaces.end() && it.value())
00339     {
00340         NMNetworkInterface * interface = it.value();
00341         NMWirelessNetwork * wifiNet = qobject_cast<NMWirelessNetwork *>(interface);
00342         if (wifiNet)
00343             wifiNet->setSignalStrength(netPath, strength);
00344     }
00345 }
00346 
00347 void NMNetworkManager::wirelessNetworkAppeared(const QDBusObjectPath & devPath, const QDBusObjectPath & netPath)
00348 {
00349     kDebug(1441) << devPath.path() << "," << netPath.path();
00350     QHash<QString, NMNetworkInterface *>::ConstIterator it = d->interfaces.find(devPath.path());
00351     if (it != d->interfaces.end() && it.value())
00352     {
00353         NMNetworkInterface * interface = it.value();
00354         interface->addNetwork(netPath);
00355     }
00356 }
00357 
00358 void NMNetworkManager::wirelessNetworkDisappeared(const QDBusObjectPath & devPath, const QDBusObjectPath & netPath)
00359 {
00360     kDebug(1441) << devPath.path() << "," << netPath.path();
00361     QHash<QString, NMNetworkInterface *>::ConstIterator it = d->interfaces.find(devPath.path());
00362     if (it != d->interfaces.end() && it.value())
00363     {
00364         NMNetworkInterface * interface = it.value();
00365         interface->removeNetwork(netPath);
00366     }
00367 }
00368 
00369 void NMNetworkManager::deviceActivationStageChanged(const QDBusObjectPath & devPath, uint stage)
00370 {
00371     kDebug(1441) << devPath.path() << "("<< stage << ")";
00372     QHash<QString, NMNetworkInterface *>::ConstIterator it = d->interfaces.find(devPath.path());
00373     if (it != d->interfaces.end() && it.value())
00374     {
00375         NMNetworkInterface * interface = it.value();
00376         interface->setActivationStage(stage);
00377     }
00378 }
00379 
00380 void NMNetworkManager::carrierOn(const QDBusObjectPath & devPath)
00381 {
00382     kDebug(1441) << devPath.path();
00383     QHash<QString, NMNetworkInterface *>::ConstIterator it = d->interfaces.find(devPath.path());
00384     if (it != d->interfaces.end() && it.value())
00385     {
00386         NMNetworkInterface * interface = it.value();
00387         NMWiredNetwork * wiredNet = qobject_cast<NMWiredNetwork *>(interface);
00388         if (wiredNet)
00389             wiredNet->setCarrier(true);
00390     }
00391 }
00392 
00393 void NMNetworkManager::carrierOff(const QDBusObjectPath & devPath)
00394 {
00395     kDebug(1441) << devPath.path();
00396     QHash<QString, NMNetworkInterface *>::ConstIterator it = d->interfaces.find(devPath.path());
00397     if (it != d->interfaces.end() && it.value())
00398     {
00399         NMNetworkInterface * interface = it.value();
00400         NMWiredNetwork * wiredNet = qobject_cast<NMWiredNetwork *>(interface);
00401         if (wiredNet)
00402             wiredNet->setCarrier(false);
00403     }
00404 }
00405 
00406 void NMNetworkManager::nowActive(const QDBusObjectPath & devPath)
00407 {
00408     kDebug(1441) << devPath.path();
00409     QHash<QString, NMNetworkInterface *>::ConstIterator it = d->interfaces.find(devPath.path());
00410     if (it != d->interfaces.end() && it.value())
00411     {
00412         NMNetworkInterface * interface = it.value();
00413         interface->setActive(true);
00414     }
00415 }
00416 
00417 void NMNetworkManager::noLongerActive(const QDBusObjectPath & devPath)
00418 {
00419     kDebug(1441) << devPath.path();
00420     QHash<QString, NMNetworkInterface *>::ConstIterator it = d->interfaces.find(devPath.path());
00421     if (it != d->interfaces.end() && it.value())
00422     {
00423         NMNetworkInterface * interface = it.value();
00424         interface->setActive(false);
00425     }
00426 }
00427 
00428 void NMNetworkManager::activating(const QDBusObjectPath & devPath)
00429 {
00430     kDebug(1441) << devPath.path();
00431     // We don't do anything with this signal as it is duplicated by connectionStateChanged
00432 }
00433 
00434 void NMNetworkManager::activationFailed(const QDBusObjectPath & devPath)
00435 {
00436     kDebug(1441) << devPath.path();
00437     QHash<QString, NMNetworkInterface *>::ConstIterator it = d->interfaces.find(devPath.path());
00438     if (it != d->interfaces.end() && it.value())
00439     {
00440         NMNetworkInterface * interface = it.value();
00441         interface->setActivationStage(NM_ACT_STAGE_FAILED);
00442     }
00443 }
00444 
00445 void NMNetworkManager::wirelessEnabled(bool wirelessEnabled, bool wirelessHardwareEnabled)
00446 {
00447     kDebug(1441) << wirelessEnabled << wirelessHardwareEnabled;
00448     if (wirelessEnabled != d->wirelessEnabled)
00449     {
00450         d->wirelessEnabled = wirelessEnabled;
00451         emit wirelessEnabledChanged(d->wirelessEnabled);
00452     }
00453     if (wirelessHardwareEnabled != d->wirelessHardwareEnabled)
00454     {
00455         d->wirelessHardwareEnabled = wirelessHardwareEnabled;
00456         emit wirelessHardwareEnabledChanged(d->wirelessHardwareEnabled);
00457     }
00458 }
00459 
00460 void NMNetworkManager::nameOwnerChanged(const QString & name, const QString & oldOwner, const QString & newOwner)
00461 {
00462     if (name == QLatin1String(NM_DBUS_SERVICE))
00463     {
00464         kDebug(1441) << "name: " << name << ", old owner: " << oldOwner << ", new owner: " << newOwner;
00465         if ( oldOwner.isEmpty() && !newOwner.isEmpty() ) {
00466             // NetworkManager started, but we are already listening to StateChanged so we should get
00467             // its status that way
00468             ;
00469         }
00470         if ( !oldOwner.isEmpty() && newOwner.isEmpty() ) {
00471             // NetworkManager stopped, set status Unknown for safety
00472             stateChanged(NM_STATE_UNKNOWN);
00473         }
00474     }
00475 }
00476 
00477 #include "NetworkManager-networkmanager.moc"

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