workspace/solid/networkmanager-0.7/manager.cpp

   1 /*
   2 Copyright 2008 Will Stephenson <wstephenson@kde.org>
   3
   4 This program is free software; you can redistribute it and/or
   5 modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of
   6 the License or (at your option) version 3 or any later version
   7 accepted by the membership of KDE e.V. (or its successor approved
   8 by the membership of KDE e.V.), which shall act as a proxy
   9 defined in Section 14 of version 3 of the license.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18 */
  19
  20 #include "manager.h"
  21 #include "manager_p.h"
  22
  23 #include <KDebug>
  24 #include <NetworkManager.h>
  25
  26 #include "dbus/nm-deviceinterface.h"
  27 #include "networkmanagerdefinitions.h"
  28 #include "wirednetworkinterface.h"
  29 #include "wirelessnetworkinterface.h"
  30 #include "networkgsminterface.h"
  31 #include "networkcdmainterface.h"
  32
  33 const QString NMNetworkManager::DBUS_SERVICE(QString::fromLatin1("org.freedesktop.NetworkManager"));
  34 const QString NMNetworkManager::DBUS_DAEMON_PATH(QString::fromLatin1("/org/freedesktop/NetworkManager"));
  35 const QString NMNetworkManager::DBUS_USER_SETTINGS_PATH(QString::fromLatin1("org.freedesktop.NetworkManagerUserSettings"));
  36 const QString NMNetworkManager::DBUS_SYSTEM_SETTINGS_PATH(QString::fromLatin1("org.freedesktop.NetworkManagerSystemSettings"));
  37
  38
  39 NMNetworkManagerPrivate::NMNetworkManagerPrivate() : iface(NMNetworkManager::DBUS_SERVICE, "/org/freedesktop/NetworkManager", QDBusConnection::systemBus())
  40 {
  41     kDebug(1441) << NMNetworkManager::DBUS_SERVICE;
  42 }
  43
  44 NMNetworkManager::NMNetworkManager(QObject * parent, const QStringList &)
  45 {
  46     qDBusRegisterMetaType<QList<QDBusObjectPath> >();
  47     d_ptr = new NMNetworkManagerPrivate;
  48     Q_D(NMNetworkManager);
  49     d->nmState = d->iface.state();
  50     d->isWirelessHardwareEnabled = d->iface.wirelessHardwareEnabled();
  51     d->isWirelessEnabled = d->iface.wirelessEnabled();
  52     connect( &d->iface, SIGNAL(DeviceAdded(const QDBusObjectPath &)),
  53                 this, SLOT(deviceAdded(const QDBusObjectPath &)));
  54     connect( &d->iface, SIGNAL(DeviceRemoved(const QDBusObjectPath &)),
  55                 this, SLOT(deviceRemoved(const QDBusObjectPath &)));
  56     connect( &d->iface, SIGNAL(PropertiesChanged(const QVariantMap &)),
  57                 this, SLOT(propertiesChanged(const QVariantMap &)));
  58     connect( &d->iface, SIGNAL(StateChanged(uint)),
  59                 this, SLOT(stateChanged(uint)));
  60
  61     d->iface.connection().connect(QLatin1String("org.freedesktop.DBus"),
  62             QLatin1String("/org/freedesktop/DBus"), QLatin1String("org.freedesktop.DBus"),
  63             QLatin1String("NameOwnerChanged"), QLatin1String("sss"),
  64             this, SLOT(nameOwnerChanged(QString,QString,QString)));
  65
  66     QDBusReply< QList <QDBusObjectPath> > deviceList = d->iface.GetDevices();
  67     if (deviceList.isValid())
  68     {
  69         kDebug(1441) << "Device list";
  70         QList <QDBusObjectPath> devices = deviceList.value();
  71         foreach (QDBusObjectPath op, devices)
  72         {
  73             d->networkInterfaces.append(op.path());
  74             kDebug(1441) << "  " << op.path();
  75         }
  76     }
  77     else
  78         kDebug(1441) << "Error getting device list: " << deviceList.error().name() << ": " << deviceList.error().message();
  79
  80     kDebug(1441) << "Active connections:";
  81     QList <QDBusObjectPath> activeConnections = d->iface.activeConnections();
  82     foreach (QDBusObjectPath ac, activeConnections)
  83     {
  84         d->activeConnections.append(ac.path());
  85         kDebug(1441) << "  " << ac.path();
  86     }
  87 }
  88
  89 NMNetworkManager::~NMNetworkManager()
  90 {
  91     delete d_ptr;
  92 }
  93
  94 Solid::Networking::Status NMNetworkManager::status() const
  95 {
  96     Q_D(const NMNetworkManager);
  97     return convertNMState(d->nmState);
  98 }
  99
 100 QStringList NMNetworkManager::networkInterfaces() const
 101 {
 102     Q_D(const NMNetworkManager);
 103     return d->networkInterfaces;
 104 }
 105
 106 QObject *NMNetworkManager::createNetworkInterface(const QString &uni)
 107 {
 108     kDebug(1441);
 109     OrgFreedesktopNetworkManagerDeviceInterface devIface(NMNetworkManager::DBUS_SERVICE, uni, QDBusConnection::systemBus());
 110     uint deviceType = devIface.deviceType();
 111     NMNetworkInterface * createdInterface = 0;
 112     switch ( deviceType ) {
 113         case DEVICE_TYPE_802_3_ETHERNET:
 114             createdInterface = new NMWiredNetworkInterface(uni, this, 0); // these are deleted by the frontend manager
 115             break;
 116         case DEVICE_TYPE_802_11_WIRELESS:
 117             createdInterface = new NMWirelessNetworkInterface(uni, this, 0);
 118             break;
 119         case DEVICE_TYPE_GSM:
 120             createdInterface = new NMGsmNetworkInterface(uni, this, 0);
 121             break;
 122         case DEVICE_TYPE_CDMA:
 123             createdInterface = new NMCdmaNetworkInterface(uni, this, 0);
 124             break;
 125             /*
 126         case DEVICE_TYPE_SERIAL:
 127             createdInterface = new NMSerialNetworkInterface(uni, this, 0);
 128             break;
 129             */
 130         default:
 131             kDebug(1441) << "Can't create object of type " << deviceType;
 132             break;
 133     }
 134
 135     return createdInterface;
 136 }
 137
 138 bool NMNetworkManager::isNetworkingEnabled() const
 139 {
 140     Q_D(const NMNetworkManager);
 141     return !(NM_STATE_UNKNOWN == d->nmState || NM_STATE_ASLEEP == d->nmState);
 142 }
 143
 144 bool NMNetworkManager::isWirelessEnabled() const
 145 {
 146     Q_D(const NMNetworkManager);
 147     return d->isWirelessEnabled;
 148 }
 149
 150 bool NMNetworkManager::isWirelessHardwareEnabled() const
 151 {
 152     Q_D(const NMNetworkManager);
 153     return d->isWirelessHardwareEnabled;
 154 }
 155
 156 void NMNetworkManager::activateConnection(const QString & interfaceUni, const QString & connectionUni, const QVariantMap & connectionParameters)
 157 {
 158     Q_D(NMNetworkManager);
 159     QString serviceName = connectionUni.section(' ', 0, 0);
 160     QString connectionPath = connectionUni.section(' ', 1, 1);
 161     // ### FIXME find a better name for the parameter needed for NM 0.7
 162     QString extra_connection_parameter = connectionParameters.value("extra_connection_parameter").toString();
 163     if (extra_connection_parameter.isEmpty()) {
 164         extra_connection_parameter = QLatin1String("/foo");
 165     }
 166     if ( serviceName.isEmpty() || connectionPath.isEmpty() ) {
 167         return;
 168     }
 169     // TODO store error code
 170     QDBusObjectPath connPath(connectionPath);
 171     QDBusObjectPath interfacePath(interfaceUni);
 172     kDebug(1441) << "Activating connection" << connPath.path() << "on service" << serviceName << "on interface" << interfacePath.path() << "with extra" << extra_connection_parameter;
 173     d->iface.ActivateConnection(serviceName, connPath, interfacePath, QDBusObjectPath(extra_connection_parameter));
 174 }
 175
 176 void NMNetworkManager::deactivateConnection( const QString & activeConnectionPath )
 177 {
 178     Q_D(NMNetworkManager);
 179     d->iface.DeactivateConnection(QDBusObjectPath(activeConnectionPath));
 180 }
 181
 182 void NMNetworkManager::setNetworkingEnabled(bool enabled)
 183 {
 184     Q_D(NMNetworkManager);
 185     d->iface.Sleep(!enabled);
 186 }
 187
 188 void NMNetworkManager::setWirelessEnabled(bool enabled)
 189 {
 190     Q_D(NMNetworkManager);
 191     d->iface.setWirelessEnabled(enabled);
 192 }
 193
 194 void NMNetworkManager::deviceAdded(const QDBusObjectPath & objpath)
 195 {
 196     kDebug(1441);
 197     Q_D(NMNetworkManager);
 198     d->networkInterfaces.append(objpath.path());
 199     emit networkInterfaceAdded(objpath.path());
 200 }
 201
 202 void NMNetworkManager::deviceRemoved(const QDBusObjectPath & objpath)
 203 {
 204     kDebug(1441);
 205     Q_D(NMNetworkManager);
 206     d->networkInterfaces.removeAll(objpath.path());
 207     emit networkInterfaceRemoved(objpath.path());
 208 }
 209
 210 void NMNetworkManager::stateChanged(uint state)
 211 {
 212     Q_D(NMNetworkManager);
 213     if ( d->nmState != state ) {
 214         d->nmState = state;
 215         emit statusChanged( convertNMState( state ) );
 216     }
 217 }
 218
 219 void NMNetworkManager::propertiesChanged(const QVariantMap &properties)
 220 {
 221     Q_D(NMNetworkManager);
 222     kDebug(1441) << properties.keys();
 223     QLatin1String activeConnKey("ActiveConnections");
 224     QLatin1String wifiHwKey("WirelessHardwareEnabled");
 225     QLatin1String wifiEnabledKey("WirelessEnabled");
 226     QVariantMap::const_iterator it = properties.find(activeConnKey);
 227     if ( it != properties.end()) {
 228         QList<QDBusObjectPath> activePaths = qdbus_cast< QList<QDBusObjectPath> >(*it);
 229         d->activeConnections.clear();
 230         if ( activePaths.count() ) {
 231             kDebug(1441) << activeConnKey;
 232         }
 233         foreach (QDBusObjectPath ac, activePaths)
 234         {
 235             d->activeConnections.append(ac.path());
 236             kDebug(1441) << "  " << ac.path();
 237         }
 238         emit activeConnectionsChanged();
 239     }
 240     it = properties.find(wifiHwKey);
 241     if ( it != properties.end()) {
 242         d->isWirelessHardwareEnabled = it->toBool();
 243         kDebug(1441) << wifiHwKey << d->isWirelessHardwareEnabled;
 244     }
 245     it = properties.find(wifiEnabledKey);
 246     if ( it != properties.end()) {
 247         d->isWirelessEnabled = it->toBool();
 248         kDebug(1441) << wifiEnabledKey << d->isWirelessEnabled;
 249         emit wirelessEnabledChanged(d->isWirelessEnabled);
 250     }
 251 }
 252
 253 Solid::Networking::Status NMNetworkManager::convertNMState(uint state)
 254 {
 255     Solid::Networking::Status status = Solid::Networking::Unknown;
 256     switch (state) {
 257         case NM_STATE_UNKNOWN:
 258         case NM_STATE_ASLEEP:
 259             break;
 260         case NM_STATE_CONNECTING:
 261             status = Solid::Networking::Connecting;
 262             break;
 263         case NM_STATE_CONNECTED:
 264             status = Solid::Networking::Connected;
 265             break;
 266         case NM_STATE_DISCONNECTED:
 267             status = Solid::Networking::Unconnected;
 268             break;
 269     }
 270     return status;
 271 }
 272
 273 void NMNetworkManager::nameOwnerChanged(QString name, QString oldOwner, QString newOwner)
 274 {
 275     if ( name == QLatin1String("org.freedesktop.NetworkManager") ) {
 276         kDebug(1441) << "name: " << name << ", old owner: " << oldOwner << ", new owner: " << newOwner;
 277         if ( oldOwner.isEmpty() && !newOwner.isEmpty() ) {
 278             // NetworkManager started, but we are already listening to StateChanged so we should get
 279             // its status that way
 280             ;
 281         }
 282         if ( !oldOwner.isEmpty() && newOwner.isEmpty() ) {
 283             // NetworkManager stopped, set status Unknown for safety
 284             stateChanged(NM_STATE_UNKNOWN);
 285         }
 286     }
 287 }
 288
 289 QStringList NMNetworkManager::activeConnections() const
 290 {
 291     Q_D(const NMNetworkManager);
 292     return d->activeConnections;
 293 }
 294
 295 #include "manager.moc"
 296