00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
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 & )
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
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
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");
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
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
00483
00484 ;
00485 }
00486 if ( !oldOwner.isEmpty() && newOwner.isEmpty() ) {
00487
00488 stateChanged(NM_STATE_UNKNOWN);
00489 }
00490 }
00491 }
00492
00493 #include "NetworkManager-networkmanager.moc"