workspace/solid/networkmanager-0.7/wirelessnetworkinterface.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
   6 published by the Free Software Foundation; either version 2 of
   7 the License or (at your option) version 3 or any later version
   8 accepted by the membership of KDE e.V. (or its successor approved
   9 by the membership of KDE e.V.), which shall act as a proxy
  10 defined in Section 14 of version 3 of the license.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 */
  20
  21 // Copied from wireless.h
  22 /* Modes of operation */
  23 #define IW_MODE_AUTO    0   /* Let the driver decides */
  24 #define IW_MODE_ADHOC   1   /* Single cell network */
  25 #define IW_MODE_INFRA   2   /* Multi cell network, roaming, ... */
  26 #define IW_MODE_MASTER  3   /* Synchronization master or Access Point */
  27 #define IW_MODE_REPEAT  4   /* Wireless Repeater (forwarder) */
  28 #define IW_MODE_SECOND  5   /* Secondary master/repeater (backup) */
  29 #define IW_MODE_MONITOR 6   /* Passive monitor (listen only) */
  30
  31 #include "wirelessnetworkinterface.h"
  32 #include "wirelessnetworkinterface_p.h"
  33
  34 #include <KDebug>
  35
  36 #include "accesspoint.h"
  37 #include "manager.h"
  38
  39 NMWirelessNetworkInterfacePrivate::NMWirelessNetworkInterfacePrivate(const QString & path, QObject * owner)
  40     : NMNetworkInterfacePrivate(path, owner), wirelessIface(NMNetworkManager::DBUS_SERVICE, path, QDBusConnection::systemBus())
  41       , bitRate(0)
  42 {
  43
  44 }
  45
  46 NMWirelessNetworkInterface::NMWirelessNetworkInterface(const QString & path, NMNetworkManager * manager, QObject * parent)
  47     : NMNetworkInterface(*new NMWirelessNetworkInterfacePrivate(path, this), manager, parent)
  48 {
  49     Q_D(NMWirelessNetworkInterface);
  50     d->hardwareAddress = d->wirelessIface.hwAddress();
  51     d->mode = convertOperationMode(d->wirelessIface.mode());
  52     d->bitRate = d->wirelessIface.bitrate();
  53     d->activeAccessPoint = d->wirelessIface.activeAccessPoint().path();
  54     d->wirelessCapabilities = convertCapabilities(d->wirelessIface.wirelessCapabilities());
  55
  56     connect( &d->wirelessIface, SIGNAL(PropertiesChanged(const QVariantMap &)),
  57                 this, SLOT(wirelessPropertiesChanged(const QVariantMap &)));
  58     connect( &d->wirelessIface, SIGNAL(AccessPointAdded(const QDBusObjectPath &)),
  59                 this, SLOT(accessPointAdded(const QDBusObjectPath &)));
  60     connect( &d->wirelessIface, SIGNAL(AccessPointRemoved(const QDBusObjectPath &)),
  61                 this, SLOT(accessPointRemoved(const QDBusObjectPath &)));
  62
  63
  64     qDBusRegisterMetaType<QList<QDBusObjectPath> >();
  65     QDBusReply< QList <QDBusObjectPath> > apPathList = d->wirelessIface.GetAccessPoints();
  66     if (apPathList.isValid())
  67     {
  68         kDebug(1441) << "Got device list";
  69         QList <QDBusObjectPath> aps = apPathList.value();
  70         foreach (QDBusObjectPath op, aps)
  71         {
  72             d->accessPoints.append(op.path());
  73             kDebug(1441) << "  " << op.path();
  74         }
  75     }
  76     else
  77         kDebug(1441) << "Error getting access point list: " << apPathList.error().name() << ": " << apPathList.error().message();
  78 }
  79
  80 NMWirelessNetworkInterface::~NMWirelessNetworkInterface()
  81 {
  82
  83 }
  84
  85 MacAddressList NMWirelessNetworkInterface::accessPoints() const
  86 {
  87     Q_D(const NMWirelessNetworkInterface);
  88     return d->accessPoints;
  89 }
  90
  91 QString NMWirelessNetworkInterface::activeAccessPoint() const
  92 {
  93     Q_D(const NMWirelessNetworkInterface);
  94     return d->activeAccessPoint;
  95 }
  96
  97 QString NMWirelessNetworkInterface::hardwareAddress() const
  98 {
  99     Q_D(const NMWirelessNetworkInterface);
 100     return d->hardwareAddress;
 101 }
 102
 103 Solid::Control::WirelessNetworkInterface::OperationMode NMWirelessNetworkInterface::mode() const
 104 {
 105     Q_D(const NMWirelessNetworkInterface);
 106     return d->mode;
 107 }
 108
 109 int NMWirelessNetworkInterface::bitRate() const
 110 {
 111     Q_D(const NMWirelessNetworkInterface);
 112     return d->bitRate;
 113 }
 114
 115 Solid::Control::WirelessNetworkInterface::Capabilities NMWirelessNetworkInterface::wirelessCapabilities() const
 116 {
 117     Q_D(const NMWirelessNetworkInterface);
 118     return d->wirelessCapabilities;
 119 }
 120
 121 QObject * NMWirelessNetworkInterface::createAccessPoint(const QString & uni)
 122 {
 123     return new NMAccessPoint(uni, 0);
 124 }
 125
 126 void NMWirelessNetworkInterface::wirelessPropertiesChanged(const QVariantMap & changedProperties)
 127 {
 128     kDebug(1441) << changedProperties.keys();
 129     QStringList propKeys = changedProperties.keys();
 130     Q_D(NMWirelessNetworkInterface);
 131     QLatin1String activeApKey("ActiveAccessPoint"),
 132                   hwAddrKey("HwAddress"),
 133                   bitRateKey("Bitrate"),
 134                   modeKey("Mode"),
 135                   wirelessCapsKey("WirelessCapabilities");
 136     QVariantMap::const_iterator it = changedProperties.find(activeApKey);
 137     if (it != changedProperties.end()) {
 138         d->activeAccessPoint = qdbus_cast<QDBusObjectPath>(*it).path();
 139         emit activeAccessPointChanged(d->activeAccessPoint);
 140         propKeys.removeOne(activeApKey);
 141     }
 142     it = changedProperties.find(hwAddrKey);
 143     if (it != changedProperties.end()) {
 144         d->hardwareAddress = it->toString();
 145         propKeys.removeOne(hwAddrKey);
 146     }
 147     it = changedProperties.find(bitRateKey);
 148     if (it != changedProperties.end()) {
 149         d->bitRate = it->toUInt();
 150         emit bitRateChanged(d->bitRate);
 151         propKeys.removeOne(bitRateKey);
 152     }
 153     it = changedProperties.find(modeKey);
 154     if (it != changedProperties.end()) {
 155         d->mode = convertOperationMode(it->toUInt());
 156         emit modeChanged(d->mode);
 157         propKeys.removeOne(modeKey);
 158     }
 159     it = changedProperties.find(wirelessCapsKey);
 160     if (it != changedProperties.end()) {
 161         d->wirelessCapabilities = convertCapabilities(it->toUInt());
 162         propKeys.removeOne(wirelessCapsKey);
 163     }
 164     if (propKeys.count()) {
 165         kDebug(1441) << "Unhandled properties: " << propKeys;
 166     }
 167 }
 168
 169 void NMWirelessNetworkInterface::accessPointAdded(const QDBusObjectPath &apPath)
 170 {
 171     kDebug(1441) << apPath.path();
 172     Q_D(NMWirelessNetworkInterface);
 173     if (!d->accessPoints.contains(apPath.path())) {
 174         d->accessPoints.append(apPath.path());
 175         emit accessPointAppeared(apPath.path());
 176     }
 177 }
 178
 179 void NMWirelessNetworkInterface::accessPointRemoved(const QDBusObjectPath &apPath)
 180 {
 181     kDebug(1441) << apPath.path();
 182     Q_D(NMWirelessNetworkInterface);
 183     if (!d->accessPoints.contains(apPath.path())) {
 184         kDebug(1441) << "Access point list lookup failed for " << apPath.path();
 185     }
 186     d->accessPoints.removeAll(apPath.path());
 187     emit accessPointDisappeared(apPath.path());
 188 }
 189
 190 Solid::Control::WirelessNetworkInterface::OperationMode NMWirelessNetworkInterface::convertOperationMode(uint theirMode)
 191 {
 192     Solid::Control::WirelessNetworkInterface::OperationMode ourMode;
 193     switch ( theirMode ) {
 194         case IW_MODE_AUTO:
 195             ourMode = Solid::Control::WirelessNetworkInterface::Managed;
 196             break;
 197         case IW_MODE_ADHOC:
 198             ourMode = Solid::Control::WirelessNetworkInterface::Adhoc;
 199             break;
 200         case IW_MODE_INFRA:
 201         case IW_MODE_MASTER:
 202             ourMode = Solid::Control::WirelessNetworkInterface::Master;
 203             break;
 204         case IW_MODE_REPEAT:
 205             ourMode = Solid::Control::WirelessNetworkInterface::Repeater;
 206             break;
 207         case IW_MODE_SECOND:
 208         case IW_MODE_MONITOR:
 209             ourMode = (Solid::Control::WirelessNetworkInterface::OperationMode)0;
 210             break;
 211     }
 212     return ourMode;
 213 }
 214
 215 Solid::Control::WirelessNetworkInterface::Capabilities NMWirelessNetworkInterface::convertCapabilities(uint caps)
 216 {
 217     return (Solid::Control::WirelessNetworkInterface::Capabilities)caps;
 218 }
 219