• Skip to content
  • Skip to link menu
KDE 4.2 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 QStringList NMNetworkManager::activeConnections() const
00238 {
00239     kDebug(1441);
00240     QStringList activeConnections;
00241     QHash<QString, NMNetworkInterface *>::ConstIterator it = d->interfaces.constBegin(), itEnd = d->interfaces.constEnd();
00242     for ( ; it != itEnd; ++it)
00243     {
00244         NMNetworkInterface * interface = it.value();
00245         if (interface && interface->isActive())
00246         {
00247             activeConnections << it.key();
00248         }
00249     }
00250     return activeConnections;
00251 }
00252 
00253 void NMNetworkManager::activateConnection(const QString & interfaceUni, const QString & connectionUni, const QVariantMap & connectionParameters)
00254 {
00255     kDebug(1441) << interfaceUni << connectionUni << connectionParameters;
00256     QHash<QString, NMNetworkInterface *>::ConstIterator it = d->interfaces.find(interfaceUni);
00257     if (it != d->interfaces.end())
00258     {
00259         NMNetworkInterface * interface = it.value();
00260         if (!interface)
00261             interface = qobject_cast<NMNetworkInterface *>(createNetworkInterface(interfaceUni));
00262         if (interface)
00263         {
00264             bool activated = interface->activateConnection(connectionUni, connectionParameters);
00265             Q_UNUSED(activated)
00266         }
00267     }
00268 }
00269 
00270 void NMNetworkManager::deactivateConnection(const QString & activeConnection)
00271 {
00272     kDebug(1441) << activeConnection;
00273     QHash<QString, NMNetworkInterface *>::ConstIterator it = d->interfaces.find(activeConnection);
00274     if (it != d->interfaces.end() && it.value())
00275     {
00276         NMNetworkInterface * interface = it.value();
00277         bool deactivated = interface->deactivateConnection();
00278         Q_UNUSED(deactivated)
00279     }
00280 }
00281 
00282 void NMNetworkManager::setNetworkingEnabled(bool enabled)
00283 {
00284     kDebug(1441) << enabled;
00285     d->manager.call(enabled ? "wake" : "sleep"); //TODO Find out the semantics of the optional bool argument to 'sleep'
00286 }
00287 
00288 void NMNetworkManager::setWirelessEnabled(bool enabled)
00289 {
00290     kDebug(1441) << enabled;
00291     d->manager.call("setWirelessEnabled", enabled);
00292 }
00293 
00294 void NMNetworkManager::stateChanged(uint state)
00295 {
00296     d->cachedState = static_cast<NMState>(state);
00297     switch ( d->cachedState ) {
00298         case NM_STATE_CONNECTING:
00299             kDebug(1441) << "Connecting";
00300             emit statusChanged( Solid::Networking::Connecting );
00301             break;
00302         case NM_STATE_CONNECTED:
00303             kDebug(1441) << "CONNECTED";
00304             emit statusChanged( Solid::Networking::Connected );
00305             break;
00306         case NM_STATE_ASLEEP:
00307         case NM_STATE_DISCONNECTED:
00308             kDebug(1441) << "Unconnected";
00309             emit statusChanged( Solid::Networking::Unconnected );
00310             break;
00311         default:
00312         case NM_STATE_UNKNOWN:
00313             kDebug(1441) << "Unknown";
00314             emit statusChanged( Solid::Networking::Unknown );
00315             break;
00316     }
00317 }
00318 
00319 void NMNetworkManager::receivedDeviceAdded(const QDBusObjectPath & objpath)
00320 {
00321     kDebug(1441) << objpath.path();
00322     const QString path = objpath.path();
00323     QHash<QString, NMNetworkInterface *>::ConstIterator it = d->interfaces.find(path);
00324     if (it == d->interfaces.end())
00325     {
00326         d->interfaces.insert(path, 0);
00327         emit networkInterfaceAdded(path);
00328     }
00329 }
00330 
00331 void NMNetworkManager::receivedDeviceRemoved(const QDBusObjectPath & objpath)
00332 {
00333     kDebug(1441) << objpath.path();
00334     const QString path = objpath.path();
00335     QHash<QString, NMNetworkInterface *>::Iterator it = d->interfaces.find(path);
00336     if (it != d->interfaces.end())
00337     {
00338         NMNetworkInterface * iface = it.value();
00339         d->interfaces.erase(it);
00340         emit networkInterfaceRemoved(path);
00341         delete iface;
00342     }
00343 }
00344 
00345 void NMNetworkManager::deviceStrengthChanged(const QDBusObjectPath & devPath, int strength)
00346 {
00347     kDebug(1441) << devPath.path() << strength;
00348 }
00349 
00350 void NMNetworkManager::networkStrengthChanged(const QDBusObjectPath & devPath, const QDBusObjectPath & netPath, int strength)
00351 {
00352     kDebug(1441) << devPath.path() << "," << netPath.path() << "," << strength;
00353     QHash<QString, NMNetworkInterface *>::ConstIterator it = d->interfaces.find(devPath.path());
00354     if (it != d->interfaces.end() && it.value())
00355     {
00356         NMNetworkInterface * interface = it.value();
00357         NMWirelessNetwork * wifiNet = qobject_cast<NMWirelessNetwork *>(interface);
00358         if (wifiNet)
00359             wifiNet->setSignalStrength(netPath, strength);
00360     }
00361 }
00362 
00363 void NMNetworkManager::wirelessNetworkAppeared(const QDBusObjectPath & devPath, const QDBusObjectPath & netPath)
00364 {
00365     kDebug(1441) << devPath.path() << "," << netPath.path();
00366     QHash<QString, NMNetworkInterface *>::ConstIterator it = d->interfaces.find(devPath.path());
00367     if (it != d->interfaces.end() && it.value())
00368     {
00369         NMNetworkInterface * interface = it.value();
00370         interface->addNetwork(netPath);
00371     }
00372 }
00373 
00374 void NMNetworkManager::wirelessNetworkDisappeared(const QDBusObjectPath & devPath, const QDBusObjectPath & netPath)
00375 {
00376     kDebug(1441) << devPath.path() << "," << netPath.path();
00377     QHash<QString, NMNetworkInterface *>::ConstIterator it = d->interfaces.find(devPath.path());
00378     if (it != d->interfaces.end() && it.value())
00379     {
00380         NMNetworkInterface * interface = it.value();
00381         interface->removeNetwork(netPath);
00382     }
00383 }
00384 
00385 void NMNetworkManager::deviceActivationStageChanged(const QDBusObjectPath & devPath, uint stage)
00386 {
00387     kDebug(1441) << devPath.path() << "("<< stage << ")";
00388     QHash<QString, NMNetworkInterface *>::ConstIterator it = d->interfaces.find(devPath.path());
00389     if (it != d->interfaces.end() && it.value())
00390     {
00391         NMNetworkInterface * interface = it.value();
00392         interface->setActivationStage(stage);
00393     }
00394 }
00395 
00396 void NMNetworkManager::carrierOn(const QDBusObjectPath & devPath)
00397 {
00398     kDebug(1441) << devPath.path();
00399     QHash<QString, NMNetworkInterface *>::ConstIterator it = d->interfaces.find(devPath.path());
00400     if (it != d->interfaces.end() && it.value())
00401     {
00402         NMNetworkInterface * interface = it.value();
00403         NMWiredNetwork * wiredNet = qobject_cast<NMWiredNetwork *>(interface);
00404         if (wiredNet)
00405             wiredNet->setCarrier(true);
00406     }
00407 }
00408 
00409 void NMNetworkManager::carrierOff(const QDBusObjectPath & devPath)
00410 {
00411     kDebug(1441) << devPath.path();
00412     QHash<QString, NMNetworkInterface *>::ConstIterator it = d->interfaces.find(devPath.path());
00413     if (it != d->interfaces.end() && it.value())
00414     {
00415         NMNetworkInterface * interface = it.value();
00416         NMWiredNetwork * wiredNet = qobject_cast<NMWiredNetwork *>(interface);
00417         if (wiredNet)
00418             wiredNet->setCarrier(false);
00419     }
00420 }
00421 
00422 void NMNetworkManager::nowActive(const QDBusObjectPath & devPath)
00423 {
00424     kDebug(1441) << devPath.path();
00425     QHash<QString, NMNetworkInterface *>::ConstIterator it = d->interfaces.find(devPath.path());
00426     if (it != d->interfaces.end() && it.value())
00427     {
00428         NMNetworkInterface * interface = it.value();
00429         interface->setActive(true);
00430     }
00431 }
00432 
00433 void NMNetworkManager::noLongerActive(const QDBusObjectPath & devPath)
00434 {
00435     kDebug(1441) << devPath.path();
00436     QHash<QString, NMNetworkInterface *>::ConstIterator it = d->interfaces.find(devPath.path());
00437     if (it != d->interfaces.end() && it.value())
00438     {
00439         NMNetworkInterface * interface = it.value();
00440         interface->setActive(false);
00441     }
00442 }
00443 
00444 void NMNetworkManager::activating(const QDBusObjectPath & devPath)
00445 {
00446     kDebug(1441) << devPath.path();
00447     // We don't do anything with this signal as it is duplicated by connectionStateChanged
00448 }
00449 
00450 void NMNetworkManager::activationFailed(const QDBusObjectPath & devPath)
00451 {
00452     kDebug(1441) << devPath.path();
00453     QHash<QString, NMNetworkInterface *>::ConstIterator it = d->interfaces.find(devPath.path());
00454     if (it != d->interfaces.end() && it.value())
00455     {
00456         NMNetworkInterface * interface = it.value();
00457         interface->setActivationStage(NM_ACT_STAGE_FAILED);
00458     }
00459 }
00460 
00461 void NMNetworkManager::wirelessEnabled(bool wirelessEnabled, bool wirelessHardwareEnabled)
00462 {
00463     kDebug(1441) << wirelessEnabled << wirelessHardwareEnabled;
00464     if (wirelessEnabled != d->wirelessEnabled)
00465     {
00466         d->wirelessEnabled = wirelessEnabled;
00467         emit wirelessEnabledChanged(d->wirelessEnabled);
00468     }
00469     if (wirelessHardwareEnabled != d->wirelessHardwareEnabled)
00470     {
00471         d->wirelessHardwareEnabled = wirelessHardwareEnabled;
00472         emit wirelessHardwareEnabledChanged(d->wirelessHardwareEnabled);
00473     }
00474 }
00475 
00476 void NMNetworkManager::nameOwnerChanged(const QString & name, const QString & oldOwner, const QString & newOwner)
00477 {
00478     if (name == QLatin1String(NM_DBUS_SERVICE))
00479     {
00480         kDebug(1441) << "name: " << name << ", old owner: " << oldOwner << ", new owner: " << newOwner;
00481         if ( oldOwner.isEmpty() && !newOwner.isEmpty() ) {
00482             // NetworkManager started, but we are already listening to StateChanged so we should get
00483             // its status that way
00484             ;
00485         }
00486         if ( !oldOwner.isEmpty() && newOwner.isEmpty() ) {
00487             // NetworkManager stopped, set status Unknown for safety
00488             stateChanged(NM_STATE_UNKNOWN);
00489         }
00490     }
00491 }
00492 
00493 #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
  •   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