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 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");
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
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
00467
00468 ;
00469 }
00470 if ( !oldOwner.isEmpty() && newOwner.isEmpty() ) {
00471
00472 stateChanged(NM_STATE_UNKNOWN);
00473 }
00474 }
00475 }
00476
00477 #include "NetworkManager-networkmanager.moc"