Added function to set the associated AP address. Some improvements to scanNetwork(): read the signal quality, AP rates and fix channel reading when driver reports values < 1000.

3 files changed, 38 insertions, 5 deletions

diff --git a/libopie2/opienet/onetwork.cpp b/libopie2/opienet/onetwork.cpp
index 546be9e..0a74019 100644
--- a/libopie2/opienet/onetwork.cpp
+++ b/libopie2/opienet/onetwork.cpp
@@ -1,151 +1,153 @@
 /*
                              This file is part of the Opie Project
                              Copyright (C) 2003-2005 by Michael 'Mickey' Lauer <mickey@Vanille.de>
               =.
             .=l.
            .>+-=
  _;:,     .>    :=|.         This program is free software; you can
 .> <`_,   >  .   <=          redistribute it and/or  modify it under
 :`=1 )Y*s>-.--   :           the terms of the GNU Library General Public
 .="- .-=="i,     .._         License as published by the Free Software
  - .   .-<_>     .<>         Foundation; version 2 of the License.
      ._= =}       :
     .%`+i>       _;_.
     .i_,=:_.      -<s.       This program is distributed in the hope that
      +  .  -:.       =       it will be useful,  but WITHOUT ANY WARRANTY;
     : ..    .:,     . . .    without even the implied warranty of
     =_        +     =;=|`    MERCHANTABILITY or FITNESS FOR A
   _.=:.       :    :=>`:     PARTICULAR PURPOSE. See the GNU
 ..}^=.=       =       ;      Library General Public License for more
 ++=   -.     .`     .:       details.
  :     =  ...= . :.=-
  -.   .:....=;==+<;          You should have received a copy of the GNU
   -_. . .   )=.  =           Library General Public License along with
     --        :-=`           this library; see the file COPYING.LIB.
                              If not, write to the Free Software Foundation,
                              Inc., 59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 
 */
 
 /* OPIE */
 
 #include <opie2/onetwork.h>
 #include <opie2/ostation.h>
 #include <opie2/odebug.h>
 
 /* QT */
 
 #include <qfile.h>
 #include <qtextstream.h>
+#include <qapplication.h>
 
 /* UNIX */
 
 #include <assert.h>
 #include <arpa/inet.h>
 #include <errno.h>
 #include <string.h>
 #include <stdlib.h>
 #include <math.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
 #include <sys/types.h>
 #include <unistd.h>
 #include <linux/sockios.h>
 #include <net/if_arp.h>
+#include <net/ethernet.h>
 #include <stdarg.h>
 
 #ifndef NODEBUG
 #include <opie2/odebugmapper.h>
 
 using namespace Opie::Core;
 using namespace Opie::Net::Internal;
 DebugMapper* debugmapper = new DebugMapper();
 #endif
 
 /*======================================================================================
  * ONetwork
  *======================================================================================*/
 
 namespace Opie {
 namespace Net  {
 ONetwork* ONetwork::_instance = 0;
 
 ONetwork::ONetwork()
 {
     odebug << "ONetwork::ONetwork()" << oendl;
     odebug << "ONetwork: This code has been compiled against Wireless Extensions V" << WIRELESS_EXT << oendl;
     synchronize();
 }
 
 void ONetwork::synchronize()
 {
     // gather available interfaces by inspecting /proc/net/dev
     //FIXME: we could use SIOCGIFCONF here, but we aren't interested in virtual (e.g. eth0:0) devices
     //FIXME: Use SIOCGIFCONF anway, because we can disable listing of aliased devices
     //FIXME: Best is use SIOCGIFCONF and if this doesn't work (result=-1), then fallback to parsing /proc/net/dev
 
     _interfaces.clear();
     QString str;
     QFile f( "/proc/net/dev" );
     bool hasFile = f.open( IO_ReadOnly );
     if ( !hasFile )
     {
         odebug << "ONetwork: /proc/net/dev not existing. No network devices available" << oendl;
         return;
     }
     QTextStream s( &f );
     s.readLine();
     s.readLine();
     while ( !s.atEnd() )
     {
         s >> str;
         str.truncate( str.find( ':' ) );
         odebug << "ONetwork: found interface '" << str << "'" << oendl;
         ONetworkInterface* iface = 0;
         if ( isWirelessInterface( str ) )
         {
             iface = new OWirelessNetworkInterface( this, (const char*) str );
             odebug << "ONetwork: interface '" << str << "' has Wireless Extensions" << oendl;
         }
         else
         {
             iface = new ONetworkInterface( this, (const char*) str );
         }
         _interfaces.insert( str, iface );
         s.readLine();
     }
 }
 
 
 short ONetwork::wirelessExtensionCompileVersion()
 {
     return WIRELESS_EXT;
 }
 
 
 int ONetwork::count() const
 {
     return _interfaces.count();
 }
 
 
 ONetworkInterface* ONetwork::interface( const QString& iface ) const
 {
     return _interfaces[iface];
 }
 
 
 ONetwork* ONetwork::instance()
 {
     if ( !_instance ) _instance = new ONetwork();
     return _instance;
 }
 
 
 ONetwork::InterfaceIterator ONetwork::iterator() const
 {
     return ONetwork::InterfaceIterator( _interfaces );
 }
 
 
@@ -398,192 +400,200 @@ OChannelHopper::OChannelHopper( OWirelessNetworkInterface* iface )
     if ( _maxChannel >=  6 ) _channels.append(  6 );
     if ( _maxChannel >= 12 ) _channels.append( 12 );
     _channel = _channels.begin();
 }
 
 
 OChannelHopper::~OChannelHopper()
 {
 }
 
 
 bool OChannelHopper::isActive() const
 {
     return _tid;
 }
 
 
 int OChannelHopper::channel() const
 {
     return *_channel;
 }
 
 
 void OChannelHopper::timerEvent( QTimerEvent* )
 {
     _iface->setChannel( *_channel );
     emit( hopped( *_channel ) );
     odebug << "OChannelHopper::timerEvent(): set channel " << *_channel << " on interface '" << _iface->name() << "'" << oendl;
     if ( ++_channel == _channels.end() ) _channel = _channels.begin();
 }
 
 
 void OChannelHopper::setInterval( int interval )
 {
     if ( interval == _interval )
         return;
 
     if ( _interval )
         killTimer( _tid );
 
     _tid = 0;
     _interval = interval;
 
     if ( _interval )
     {
         _tid = startTimer( interval );
     }
 }
 
 
 int OChannelHopper::interval() const
 {
     return _interval;
 }
 
 
 /*======================================================================================
  * OWirelessNetworkInterface
  *======================================================================================*/
 
 OWirelessNetworkInterface::OWirelessNetworkInterface( QObject* parent, const char* name )
                          :ONetworkInterface( parent, name ), _hopper( 0 )
 {
     odebug << "OWirelessNetworkInterface::OWirelessNetworkInterface()" << oendl;
     init();
 }
 
 
 OWirelessNetworkInterface::~OWirelessNetworkInterface()
 {
 }
 
 
 struct iwreq& OWirelessNetworkInterface::iwr() const
 {
     return _iwr;
 }
 
 
 void OWirelessNetworkInterface::init()
 {
     odebug << "OWirelessNetworkInterface::init()" << oendl;
     memset( &_iwr, 0, sizeof( struct iwreq ) );
     buildInformation();
     buildPrivateList();
     dumpInformation();
 }
 
 
 bool OWirelessNetworkInterface::isAssociated() const
 {
     //FIXME: handle different modes
     return !(associatedAP() == OMacAddress::unknown);
 }
 
 
+void OWirelessNetworkInterface::setAssociatedAP( const OMacAddress& mac ) const
+{
+    _iwr.u.ap_addr.sa_family = ARPHRD_ETHER;
+    ::memcpy(_iwr.u.ap_addr.sa_data, mac.native(), ETH_ALEN);
+    wioctl( SIOCSIWAP );
+}
+
+
 OMacAddress OWirelessNetworkInterface::associatedAP() const
 {
     if ( ioctl( SIOCGIWAP ) )
         return (const unsigned char*) &_ifr.ifr_hwaddr.sa_data[0];
     else
         return OMacAddress::unknown;
 }
 
 
 void OWirelessNetworkInterface::buildInformation()
 {
     //ML: If you listen carefully enough, you can hear lots of WLAN drivers suck
     //ML: The HostAP drivers need more than sizeof struct_iw range to complete
     //ML: SIOCGIWRANGE otherwise they fail with "Invalid Argument Length".
     //ML: The Wlan-NG drivers on the otherside fail (segfault!) if you allocate
     //ML: _too much_ space. This is damn shitty crap *sigh*
     //ML: We allocate a large memory region in RAM and check whether the
     //ML: driver pollutes this extra space. The complaint will be made on stdout,
     //ML: so please forward this...
 
     struct iwreq wrq;
     int len = sizeof( struct iw_range )*2;
     char *buffer = (char*) malloc( len );
     //FIXME: Validate if we actually got the memory block
     memset( buffer, 0, len );
     memcpy( wrq.ifr_name, name(), IFNAMSIZ);
     wrq.u.data.pointer = (caddr_t) buffer;
     wrq.u.data.length = sizeof( struct iw_range );
     wrq.u.data.flags = 0;
 
     if ( ::ioctl( _sfd, SIOCGIWRANGE, &wrq ) == -1 )
     {
         owarn << "OWirelessNetworkInterface::buildInformation(): Can't get channel information - using default values." << oendl;
         _channels.insert( 2412,  1 ); // 2.412 GHz
         _channels.insert( 2417,  2 ); // 2.417 GHz
         _channels.insert( 2422,  3 ); // 2.422 GHz
         _channels.insert( 2427,  4 ); // 2.427 GHz
         _channels.insert( 2432,  5 ); // 2.432 GHz
         _channels.insert( 2437,  6 ); // 2.437 GHz
         _channels.insert( 2442,  7 ); // 2.442 GHz
         _channels.insert( 2447,  8 ); // 2.447 GHz
         _channels.insert( 2452,  9 ); // 2.452 GHz
         _channels.insert( 2457, 10 ); // 2.457 GHz
         _channels.insert( 2462, 11 ); // 2.462 GHz
 
         memset( &_range, 0, sizeof( struct iw_range ) );
     }
     else
     {
         // <check if the driver overwrites stuff>
         int max = 0;
         for ( int r = sizeof( struct iw_range ); r < len; r++ )
             if (buffer[r] != 0)
                 max = r;
         if (max > 0)
         {
             owarn << "OWirelessNetworkInterface::buildInformation(): Driver for wireless interface '" << name()
                   << "' sucks! It overwrote the buffer end with at least " << max - sizeof( struct iw_range ) << " bytes!" << oendl;
         }
         // </check if the driver overwrites stuff>
 
         struct iw_range range;
         memcpy( &range, buffer, sizeof range );
 
         odebug << "OWirelessNetworkInterface::buildInformation(): Interface reported to have " << (int) range.num_frequency << " channels." << oendl;
         for ( int i = 0; i < range.num_frequency; ++i )
         {
             int freq = (int) ( double( range.freq[i].m ) * pow( 10.0, range.freq[i].e ) / 1000000.0 );
             odebug << "OWirelessNetworkInterface::buildInformation: Adding frequency " << freq << " as channel " << i+1 << oendl;
             _channels.insert( freq, i+1 );
         }
     }
 
     memcpy( &_range, buffer, sizeof( struct iw_range ) );
     odebug << "OWirelessNetworkInterface::buildInformation(): Information block constructed." << oendl;
     free(buffer);
 }
 
 
 short OWirelessNetworkInterface::wirelessExtensionDriverVersion() const
 {
     return _range.we_version_compiled;
 }
 
 
 void OWirelessNetworkInterface::buildPrivateList()
 {
     odebug << "OWirelessNetworkInterface::buildPrivateList()" << oendl;
 
     struct iw_priv_args priv[IW_MAX_PRIV_DEF];
 
     _iwr.u.data.pointer = (char*) &priv;
     _iwr.u.data.length = IW_MAX_PRIV_DEF; // length in terms of number of (sizeof iw_priv_args), not (sizeof iw_priv_args) itself
     _iwr.u.data.flags = 0;
 
     if ( !wioctl( SIOCGIWPRIV ) )
@@ -813,199 +823,197 @@ void OWirelessNetworkInterface::setPrivate( const QString& call, int numargs, ..
               << "' does not support private ioctl '" << call << "'" << oendl;
         return;
     }
     if ( priv->numberSetArgs() != numargs )
     {
         owarn << "OWirelessNetworkInterface::setPrivate(): parameter count not matching. '"
               << call << "' expects " << priv->numberSetArgs() << ", but got " << numargs << oendl;
         return;
     }
 
     odebug << "OWirelessNetworkInterface::setPrivate(): about to call '" << call << "' on interface '" << name() << "'" << oendl;
     memset( &_iwr, 0, sizeof _iwr );
     va_list argp;
     va_start( argp, numargs );
     for ( int i = 0; i < numargs; ++i )
     {
         priv->setParameter( i, va_arg( argp, int ) );
     }
     va_end( argp );
     priv->invoke();
 }
 
 
 void OWirelessNetworkInterface::getPrivate( const QString&  )
 {
     oerr << "OWirelessNetworkInterface::getPrivate() is not implemented yet." << oendl;
 }
 
 
 bool OWirelessNetworkInterface::hasPrivate( const QString& call )
 {
     return child( call.local8Bit() );
 }
 
 
 QString OWirelessNetworkInterface::SSID() const
 {
     char str[IW_ESSID_MAX_SIZE];
     _iwr.u.essid.pointer = &str[0];
     _iwr.u.essid.length = IW_ESSID_MAX_SIZE;
     if ( !wioctl( SIOCGIWESSID ) )
     {
         return "<unknown>";
     }
     else
     {
         return str;
     }
 }
 
 
 void OWirelessNetworkInterface::setSSID( const QString& ssid )
 {
     _iwr.u.essid.pointer = const_cast<char*>( (const char*) ssid );
     _iwr.u.essid.length = ssid.length()+1; // zero byte
     wioctl( SIOCSIWESSID );
 }
 
 
 OStationList* OWirelessNetworkInterface::scanNetwork()
 {
     _iwr.u.param.flags = IW_SCAN_DEFAULT;
     _iwr.u.param.value = 0;
     if ( !wioctl( SIOCSIWSCAN ) )
     {
         return 0;
     }
 
     OStationList* stations = new OStationList();
 
     int timeout = 10000000;
 
     odebug << "ONetworkInterface::scanNetwork() - scan started." << oendl;
 
     bool results = false;
     struct timeval tv;
     tv.tv_sec = 0;
     tv.tv_usec = 250000; // initial timeout ~ 250ms
     char buffer[IW_SCAN_MAX_DATA];
 
     while ( !results && timeout > 0 )
     {
         timeout -= tv.tv_usec;
         select( 0, 0, 0, 0, &tv );
 
         _iwr.u.data.pointer = &buffer[0];
         _iwr.u.data.flags = 0;
         _iwr.u.data.length = sizeof buffer;
         if ( wioctl( SIOCGIWSCAN ) )
         {
             results = true;
             continue;
         }
         else if ( errno == EAGAIN)
         {
             odebug << "ONetworkInterface::scanNetwork() - scan in progress..." << oendl;
-            #if 0
             if ( qApp )
             {
                 qApp->processEvents( 100 );
                 continue;
             }
-            #endif
             tv.tv_sec = 0;
             tv.tv_usec = 100000;
             continue;
         }
     }
 
     odebug << "ONetworkInterface::scanNetwork() - scan finished." << oendl;
 
     if ( results )
     {
         odebug << " - result length = " << _iwr.u.data.length << oendl;
         if ( !_iwr.u.data.length )
         {
             odebug << " - no results (empty neighbourhood)" << oendl;
             return stations;
         }
 
         odebug << " - results are in!" << oendl;
         dumpBytes( (const unsigned char*) &buffer[0], _iwr.u.data.length );
 
         // parse results
         struct iw_event iwe;
         struct iw_stream_descr stream;
         unsigned int cmd_index, event_type, event_len;
         char *pointer;
 
         const char standard_ioctl_hdr[] = {
                 IW_HEADER_TYPE_NULL,    /* SIOCSIWCOMMIT */
                 IW_HEADER_TYPE_CHAR,    /* SIOCGIWNAME */
                 IW_HEADER_TYPE_PARAM,   /* SIOCSIWNWID */
                 IW_HEADER_TYPE_PARAM,   /* SIOCGIWNWID */
                 IW_HEADER_TYPE_FREQ,    /* SIOCSIWFREQ */
                 IW_HEADER_TYPE_FREQ,    /* SIOCGIWFREQ */
                 IW_HEADER_TYPE_UINT,    /* SIOCSIWMODE */
                 IW_HEADER_TYPE_UINT,    /* SIOCGIWMODE */
                 IW_HEADER_TYPE_PARAM,   /* SIOCSIWSENS */
                 IW_HEADER_TYPE_PARAM,   /* SIOCGIWSENS */
                 IW_HEADER_TYPE_NULL,    /* SIOCSIWRANGE */
                 IW_HEADER_TYPE_POINT,   /* SIOCGIWRANGE */
                 IW_HEADER_TYPE_NULL,    /* SIOCSIWPRIV */
                 IW_HEADER_TYPE_POINT,   /* SIOCGIWPRIV */
                 IW_HEADER_TYPE_NULL,    /* SIOCSIWSTATS */
                 IW_HEADER_TYPE_POINT,   /* SIOCGIWSTATS */
                 IW_HEADER_TYPE_POINT,   /* SIOCSIWSPY */
                 IW_HEADER_TYPE_POINT,   /* SIOCGIWSPY */
                 IW_HEADER_TYPE_POINT,   /* SIOCSIWTHRSPY */
                 IW_HEADER_TYPE_POINT,   /* SIOCGIWTHRSPY */
                 IW_HEADER_TYPE_ADDR,    /* SIOCSIWAP */
                 IW_HEADER_TYPE_ADDR,    /* SIOCGIWAP */
                 IW_HEADER_TYPE_NULL,    /* -- hole -- */
                 IW_HEADER_TYPE_POINT,   /* SIOCGIWAPLIST */
                 IW_HEADER_TYPE_PARAM,   /* SIOCSIWSCAN */
                 IW_HEADER_TYPE_POINT,   /* SIOCGIWSCAN */
                 IW_HEADER_TYPE_POINT,   /* SIOCSIWESSID */
                 IW_HEADER_TYPE_POINT,   /* SIOCGIWESSID */
                 IW_HEADER_TYPE_POINT,   /* SIOCSIWNICKN */
                 IW_HEADER_TYPE_POINT,   /* SIOCGIWNICKN */
                 IW_HEADER_TYPE_NULL,    /* -- hole -- */
                 IW_HEADER_TYPE_NULL,    /* -- hole -- */
                 IW_HEADER_TYPE_PARAM,   /* SIOCSIWRATE */
                 IW_HEADER_TYPE_PARAM,   /* SIOCGIWRATE */
                 IW_HEADER_TYPE_PARAM,   /* SIOCSIWRTS */
                 IW_HEADER_TYPE_PARAM,   /* SIOCGIWRTS */
                 IW_HEADER_TYPE_PARAM,   /* SIOCSIWFRAG */
                 IW_HEADER_TYPE_PARAM,   /* SIOCGIWFRAG */
                 IW_HEADER_TYPE_PARAM,   /* SIOCSIWTXPOW */
                 IW_HEADER_TYPE_PARAM,   /* SIOCGIWTXPOW */
                 IW_HEADER_TYPE_PARAM,   /* SIOCSIWRETRY */
                 IW_HEADER_TYPE_PARAM,   /* SIOCGIWRETRY */
                 IW_HEADER_TYPE_POINT,   /* SIOCSIWENCODE */
                 IW_HEADER_TYPE_POINT,   /* SIOCGIWENCODE */
                 IW_HEADER_TYPE_PARAM,   /* SIOCSIWPOWER */
                 IW_HEADER_TYPE_PARAM,   /* SIOCGIWPOWER */
         };
 
         const char standard_event_hdr[] = {
                 IW_HEADER_TYPE_ADDR,    /* IWEVTXDROP */
                 IW_HEADER_TYPE_QUAL,    /* IWEVQUAL */
                 IW_HEADER_TYPE_POINT,   /* IWEVCUSTOM */
                 IW_HEADER_TYPE_ADDR,    /* IWEVREGISTERED */
                 IW_HEADER_TYPE_ADDR,    /* IWEVEXPIRED */
                 IW_HEADER_TYPE_POINT,   /* IWEVGENIE */
                 IW_HEADER_TYPE_POINT,   /* IWEVMICHAELMICFAILURE */
                 IW_HEADER_TYPE_POINT,   /* IWEVASSOCREQIE */
                 IW_HEADER_TYPE_POINT,   /* IWEVASSOCRESPIE */
                 IW_HEADER_TYPE_POINT,   /* IWEVPMKIDCAND */
         };
 
 
         const int event_type_size[] = {
                 IW_EV_LCP_LEN,          /* IW_HEADER_TYPE_NULL */
                 0,
                 IW_EV_CHAR_LEN,         /* IW_HEADER_TYPE_CHAR */
                 0,
                 IW_EV_UINT_LEN,         /* IW_HEADER_TYPE_UINT */
                 IW_EV_FREQ_LEN,         /* IW_HEADER_TYPE_FREQ */
@@ -1034,207 +1042,227 @@ OStationList* OWirelessNetworkInterface::scanNetwork()
                 cmd_index = iwe.cmd - SIOCIWFIRST;
 
                 if(cmd_index < sizeof(standard_ioctl_hdr))
                     event_type = standard_ioctl_hdr[cmd_index];
             }
             else {
                 cmd_index = iwe.cmd - IWEVFIRST;
 
                 if(cmd_index < sizeof(standard_event_hdr))
                     event_type = standard_event_hdr[cmd_index];
             }
 
             /* Unknown events -> event_type=0 => IW_EV_LCP_LEN */
             event_len = event_type_size[event_type];
 
             /* Fixup for later version of WE */
             if((_range.we_version_compiled > 18) && (event_type == IW_HEADER_TYPE_POINT))
                 event_len -= IW_EV_POINT_OFF;
 
             /* Check if we know about this event */
             if(event_len <= IW_EV_LCP_LEN) {
                 /* Skip to next event */
                 stream.current += iwe.len;
                 continue;
             }
 
             event_len -= IW_EV_LCP_LEN;
 
             /* Set pointer on data */
             if(stream.value != NULL)
                 pointer = stream.value;                    /* Next value in event */
             else
                 pointer = stream.current + IW_EV_LCP_LEN;  /* First value in event */
 
             if((pointer + event_len) > stream.end) {
                 /* Go to next event */
                 stream.current += iwe.len;
                 break;
             }
 
             /* Fixup for later version of WE */
             if((_range.we_version_compiled > 18) && (event_type == IW_HEADER_TYPE_POINT))
                 memcpy((char *) &iwe + IW_EV_LCP_LEN + IW_EV_POINT_OFF, pointer, event_len);
             else
                 memcpy((char *) &iwe + IW_EV_LCP_LEN, pointer, event_len);
 
             /* Skip event in the stream */
             pointer += event_len;
 
             /* Special processing for iw_point events */
             if(event_type == IW_HEADER_TYPE_POINT) {
             /* Check the length of the payload */
 
                 if((iwe.len - (event_len + IW_EV_LCP_LEN)) > 0)
                     /* Set pointer on variable part (warning : non aligned) */
                     iwe.u.data.pointer = pointer;
                 else
                     /* No data */
                     iwe.u.data.pointer = NULL;
                     /* Go to next event */
                     stream.current += iwe.len;
             }
 
             else {
                 /* Is there more value in the event ? */
                 if((pointer + event_len) <= (stream.current + iwe.len))
                     /* Go to next value */
                      stream.value = pointer;
                 else {
                     /* Go to next event */
                     stream.value = NULL;
                     stream.current += iwe.len;
                 }
             }
 
             struct iw_event *we = &iwe;
             //------
             odebug << " - reading next event... cmd=" << we->cmd << ", len=" << we->len << oendl;
             switch (we->cmd)
             {
                 case SIOCGIWAP:
                 {
                     odebug << "SIOCGIWAP" << oendl;
                     stations->append( new OStation() );
                     stations->last()->macAddress = (const unsigned char*) &we->u.ap_addr.sa_data[0];
                     break;
                 }
                 case SIOCGIWMODE:
                 {
                     odebug << "SIOCGIWMODE" << oendl;
                     stations->last()->type = modeToString( we->u.mode );
                     break;
                 }
                 case SIOCGIWFREQ:
                 {
                     odebug << "SIOCGIWFREQ" << oendl;
-                    stations->last()->channel = _channels[ static_cast<int>(double( we->u.freq.m ) * pow( 10.0, we->u.freq.e ) / 1000000) ];
+                    if ( we->u.freq.m > 1000 )
+                        stations->last()->channel = _channels[ static_cast<int>(double( we->u.freq.m ) * pow( 10.0, we->u.freq.e ) / 1000000) ];
+                    else
+                        stations->last()->channel = static_cast<int>(((double) we->u.freq.m) * pow( 10.0, we->u.freq.e ));
                     break;
                 }
                 case SIOCGIWESSID:
                 {
                     odebug << "SIOCGIWESSID" << oendl;
                     we->u.essid.length = '\0'; // make sure it is zero terminated
                     stations->last()->ssid = static_cast<const char*> (we->u.essid.pointer);
                     odebug << "ESSID: " << stations->last()->ssid << oendl;
                     break;
                 }
+                case IWEVQUAL:
+                {
+                    odebug << "IWEVQUAL" << oendl; 
+                    stations->last()->level = static_cast<int>(we->u.qual.level);
+                    break;             /* Quality part of statistics (scan) */
+                }
+                case SIOCGIWENCODE:
+                {
+                    odebug << "SIOCGIWENCODE" << oendl; 
+                    stations->last()->encrypted = !(we->u.data.flags & IW_ENCODE_DISABLED);
+                    break;
+                }
+
+                case SIOCGIWRATE:
+                {
+                    odebug << "SIOCGIWRATE" << oendl;
+                    stations->last()->rates.append(we->u.bitrate.value);
+                    break;
+                }
                 case SIOCGIWSENS: odebug << "SIOCGIWSENS" << oendl; break;
-                case SIOCGIWENCODE: odebug << "SIOCGIWENCODE" << oendl; break;
                 case IWEVTXDROP: odebug << "IWEVTXDROP" << oendl; break;         /* Packet dropped to excessive retry */
-                case IWEVQUAL: odebug << "IWEVQUAL" << oendl; break;             /* Quality part of statistics (scan) */
                 case IWEVCUSTOM: odebug << "IWEVCUSTOM" << oendl; break;         /* Driver specific ascii string */
                 case IWEVREGISTERED: odebug << "IWEVREGISTERED" << oendl; break; /* Discovered a new node (AP mode) */
                 case IWEVEXPIRED: odebug << "IWEVEXPIRED" << oendl; break;       /* Expired a node (AP mode) */
                 default: odebug << "unhandled event" << oendl;
             }
 
         } while (true);
     }
     else
     {
         odebug << " - no results (timeout) :(" << oendl;
     }
     return stations;
 }
 
 
 int OWirelessNetworkInterface::signalStrength() const
 {
     iw_statistics stat;
     ::memset( &stat, 0, sizeof stat );
     _iwr.u.data.pointer = (char*) &stat;
     _iwr.u.data.flags = 0;
     _iwr.u.data.length = sizeof stat;
 
     if ( !wioctl( SIOCGIWSTATS ) )
     {
         return -1;
     }
 
     int max = _range.max_qual.qual;
     int cur = stat.qual.qual;
 //    int lev = stat.qual.level; //FIXME: Do something with them?
 //    int noi = stat.qual.noise; //FIXME: Do something with them?
 
 
     return max != 0 ? cur*100/max: -1;
 }
 
 
 bool OWirelessNetworkInterface::wioctl( int call, struct iwreq& iwreq ) const
 {
     #ifndef NODEBUG
     int result = ::ioctl( _sfd, call, &iwreq );
 
     if ( result == -1 )
         odebug << "ONetworkInterface::wioctl (" << name() << ") call '"
                << debugmapper->map( call ) << "' FAILED! " << result << " (" << strerror( errno ) << ")" << oendl;
     else
         odebug << "ONetworkInterface::wioctl (" << name() << ") call '"
                << debugmapper->map( call ) << "' - Status: Ok." << oendl;
 
     return ( result != -1 );
     #else
     return ::ioctl( _sfd, call, &iwreq ) != -1;
     #endif
 }
 
 
 bool OWirelessNetworkInterface::wioctl( int call ) const
 {
     strcpy( _iwr.ifr_name, name() );
     return wioctl( call, _iwr );
 }
 
 
 /*======================================================================================
  * OMonitoringInterface
  *======================================================================================*/
 
 OMonitoringInterface::OMonitoringInterface( ONetworkInterface* iface, bool prismHeader )
                       :_if( static_cast<OWirelessNetworkInterface*>( iface ) ), _prismHeader( prismHeader )
 {
 }
 
 
 OMonitoringInterface::~OMonitoringInterface()
 {
 }
 
 
 void OMonitoringInterface::setChannel( int c )
 {
     // use standard WE channel switching protocol
     memset( &_if->_iwr, 0, sizeof( struct iwreq ) );
     _if->_iwr.u.freq.m = c;
     _if->_iwr.u.freq.e = 0;
     _if->wioctl( SIOCSIWFREQ );
 }
 
 
 void OMonitoringInterface::setEnabled( bool  )
 {
 }
 
 
 /*======================================================================================
diff --git a/libopie2/opienet/onetwork.h b/libopie2/opienet/onetwork.h
index 4d9912d..fa9f39f 100644
--- a/libopie2/opienet/onetwork.h
+++ b/libopie2/opienet/onetwork.h
@@ -320,192 +320,195 @@ class OWirelessNetworkInterface : public ONetworkInterface
     friend class OCiscoMonitoringInterface;
     friend class OWlanNGMonitoringInterface;
     friend class OHostAPMonitoringInterface;
     friend class OOrinocoMonitoringInterface;
 
     friend class OPrivateIOCTL;
 
   public:
     /**
      * Constructor.
      */
     OWirelessNetworkInterface( QObject* parent, const char* name );
     /**
      * Destructor.
      */
     virtual ~OWirelessNetworkInterface();
     /**
      * Setting the @a channel of the interface changes the radio frequency (RF)
      * of the corresponding wireless network device.
      * @note Common channel range is within [1-14]. A value of 0 is not allowed.
      * @see channels()
      */
     virtual void setChannel( int channel ) const;
     /**
      * @returns the channel index of the current radio frequency.
      */
     virtual int channel() const;
     /**
      * @returns the current radio frequency (in MHz).
      */
     virtual double frequency() const;
     /**
      * @returns the number of radio frequency channels for the
      * corresponding wireless network device.
      * @note European devices usually have 14 channels, while American typically feature 11 channels.
      */
     virtual int channels() const;
     /**
      * Set the IEEE 802.11 operation @a mode.
      * Valid values are <ul><li>adhoc<li>managed<li>monitor<li>master
      * @warning Not all drivers support the all modes.
      * @note You might have to change the SSID to get the operation mode change into effect.
      */
     virtual void setMode( const QString& mode );
     /**
      * @returns the current IEEE 802.11 operation mode.
      * Possible values are <ul><li>adhoc<li>managed<li>monitor<li>master or <li>unknown
      *
      * @note: Important note concerning the 'monitor' mode:
      * Setting the monitor mode on a wireless network interface enables
      * listening to IEEE 802.11 data and management frames which normally
      * are handled by the device firmware. This can be used to detect
      * other wireless network devices, e.g. Access Points or Ad-hoc stations.
      * @warning Standard wireless network drives don't support the monitor mode.
      * @warning You need a patched driver for this to work.
      * @note Enabling the monitor mode is highly driver dependent and requires
      * the proper @ref OMonitoringInterface to be associated with the interface.
      * @see OMonitoringInterface
      */
     virtual QString mode() const;
     /**
      * Set the channel hopping @a interval. An @a interval of 0 disables channel hopping.
      * @see OChannelHopper
      */
     virtual void setChannelHopping( int interval = 0 );
     /**
      * @returns the channel hopping interval or 0, if channel hopping is disabled.
      */
     virtual int channelHopping() const;
     /**
      * @returns the @ref OChannelHopper of this interface or 0, if channel hopping has not been activated before
      */
     virtual OChannelHopper* channelHopper() const;
     /**
      * Set the station @a nickname.
      */
     virtual void setNickName( const QString& nickname );
     /**
      * @returns the current station nickname.
      */
     virtual QString nickName() const;
     /**
      * Invoke the private IOCTL @a command with a @number of parameters on the network interface.
      * @see OPrivateIOCTL
      */
     virtual void setPrivate( const QString& command, int number, ... );
     /**
      * @returns true if the interface is featuring the private IOCTL @command.
      */
     virtual bool hasPrivate( const QString& command );
     virtual void getPrivate( const QString& command ); //FIXME: Implement and document this
     /**
      * @returns true if the interface is associated to an access point
      * @note: This information is only valid if the interface is in managed mode.
      */
     virtual bool isAssociated() const;
+    /** Set the @a mac associated AP address.
+    */
+    virtual void setAssociatedAP( const OMacAddress& mac ) const;
     /**
      * @returns the MAC address of the Access Point if the device is in infrastructure mode.
      * @returns a (more or less random) cell ID address if the device is in adhoc mode.
      */
     virtual OMacAddress associatedAP() const;
     /**
      * Set the @a ssid (Service Set ID) string. This is used to decide
      * which network to associate with (use "any" to let the driver decide).
      */
     virtual void setSSID( const QString& ssid );
     /**
      * @returns the current SSID (Service Set ID).
      */
     virtual QString SSID() const;
     /**
      * Perform scanning the wireless network neighbourhood.
      * @note: UNSTABLE API - UNDER CONSTRUCTION - DON'T USE!
      */
     virtual OStationList* scanNetwork();
     /**
      * @return signal strength to associated neighbour (in percent).
      * In infrastructure mode, this is the signal strength of the Access Point.
      * In other modes the result is driver dependent.
      */
     virtual int signalStrength() const;
     /**
      * @returns the wireless extension version used by the interface driver.
      **/
     short wirelessExtensionDriverVersion() const;
     /**
      * @internal commit pending changes to the driver
      */
     void commit() const;
 
   protected:
     void buildInformation();
     void buildPrivateList();
     void dumpInformation() const;
     virtual void init();
     struct iwreq& iwr() const;
     bool wioctl( int call ) const;
     bool wioctl( int call, struct iwreq& ) const;
 
   protected:
     mutable struct iwreq _iwr;
     QMap<int,int> _channels;
     struct iw_range _range;
 
   private:
     OChannelHopper* _hopper;
     class Private;
     Private *d;
 };
 
 
 /*======================================================================================
  * OMonitoringInterface
  *======================================================================================*/
 
 
 class OMonitoringInterface
 {
   public:
     OMonitoringInterface();
     OMonitoringInterface( ONetworkInterface*, bool _prismHeader );
     virtual ~OMonitoringInterface();
 
   public:
     virtual void setEnabled( bool );
     virtual void setChannel( int );
 
     virtual QString name() const = 0;
 
   protected:
     OWirelessNetworkInterface* _if;
     bool _prismHeader;
   private:
     class Private;
     Private *d;
 
 };
 
 
 /*======================================================================================
  * OCiscoMonitoring
  *======================================================================================*/
 
 
 class OCiscoMonitoringInterface : public OMonitoringInterface
 {
   public:
     OCiscoMonitoringInterface( ONetworkInterface*, bool _prismHeader );
     virtual ~OCiscoMonitoringInterface();
 
     virtual void setEnabled( bool );
     virtual QString name() const;
diff --git a/libopie2/opienet/ostation.h b/libopie2/opienet/ostation.h
index 5219d92..86c9a52 100644
--- a/libopie2/opienet/ostation.h
+++ b/libopie2/opienet/ostation.h
@@ -1,83 +1,85 @@
 /*
                              This file is part of the Opie Project
                              Copyright (C) 2003-2005 by Michael 'Mickey' Lauer <mickey@Vanille.de>
               =.
             .=l.
            .>+-=
  _;:,     .>    :=|.         This program is free software; you can
 .> <`_,   >  .   <=          redistribute it and/or  modify it under
 :`=1 )Y*s>-.--   :           the terms of the GNU Library General Public
 .="- .-=="i,     .._         License as published by the Free Software
  - .   .-<_>     .<>         Foundation; version 2 of the License.
      ._= =}       :
     .%`+i>       _;_.
     .i_,=:_.      -<s.       This program is distributed in the hope that
      +  .  -:.       =       it will be useful,  but WITHOUT ANY WARRANTY;
     : ..    .:,     . . .    without even the implied warranty of
     =_        +     =;=|`    MERCHANTABILITY or FITNESS FOR A
   _.=:.       :    :=>`:     PARTICULAR PURPOSE. See the GNU
 ..}^=.=       =       ;      Library General Public License for more
 ++=   -.     .`     .:       details.
  :     =  ...= . :.=-
  -.   .:....=;==+<;          You should have received a copy of the GNU
   -_. . .   )=.  =           Library General Public License along with
     --        :-=`           this library; see the file COPYING.LIB.
                              If not, write to the Free Software Foundation,
                              Inc., 59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 
 */
 
 #ifndef OSTATION_H
 #define OSTATION_H
 
 #include <opie2/onetutils.h>
 
 #include <qlist.h>
 #include <qstring.h>
 #include <qhostaddress.h>
 #include <qobject.h>
+#include <qvaluelist.h>
 
 #include <sys/types.h>
 
 namespace Opie {
 namespace Net  {
 
 class OStation;
 
 
 typedef QList<OStation> OStationList;
 
 /*======================================================================================
  * OStation
  *======================================================================================*/
 
 class OStation
 {
   public:
     OStation();
     ~OStation();
 
     void dump();
 
     /* Ethernet */
     QString type;
     OMacAddress macAddress;
     QHostAddress ipAddress;
 
     /* WaveLan */
     QString ssid;
     OMacAddress apAddress;
     int channel;
     int level;
     bool encrypted;
+    QValueList <int> rates;
   private:
     class Private;
     Private *d;
 };
 
 }
 }
 
 #endif // OSTATION_H