libopienet API cleanups

4 files changed, 39 insertions, 38 deletions

diff --git a/libopie2/opienet/onetutils.cpp b/libopie2/opienet/onetutils.cpp
index c8c494a..9c3e650 100644
--- a/libopie2/opienet/onetutils.cpp
+++ b/libopie2/opienet/onetutils.cpp
@@ -1,241 +1,254 @@
 /*
                              This file is part of the Opie Project
-
-                             (C) 2003 Michael 'Mickey' Lauer <mickey@Vanille.de>
-              =.
+              =.             (C) 2003-2005 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.
 
 */
 
 #include <opie2/onetutils.h>
 #include <opie2/onetwork.h>
 #include <opie2/omanufacturerdb.h>
 
 #include <net/if.h>
 #include <assert.h>
 #include <stdio.h>
 
 namespace Opie {
 namespace Net  {
 
 /*======================================================================================
  * OMacAddress
  *======================================================================================*/
 
 // static initializer for broadcast and unknown MAC Adresses
 const unsigned char __broadcast[6] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
 const OMacAddress& OMacAddress::broadcast = OMacAddress( __broadcast );
 const unsigned char __unknown[6] = { 0x44, 0x44, 0x44, 0x44, 0x44, 0x44 };
 const OMacAddress& OMacAddress::unknown = OMacAddress( __unknown );
 
 //TODO: Incorporate Ethernet Manufacturer database here! (inline or so)
 
 OMacAddress::OMacAddress()
 {
     memcpy( _bytes, __unknown, 6 );
 }
 
 
 OMacAddress::OMacAddress( unsigned char* p )
 {
     memcpy( _bytes, p, 6 );
 }
 
 
 OMacAddress::OMacAddress( const unsigned char* p )
 {
     memcpy( _bytes, p, 6 );
 }
 
 
 OMacAddress::OMacAddress( struct ifreq& ifr )
 {
     memcpy( _bytes, ifr.ifr_hwaddr.sa_data, 6 );
 }
 
 
 OMacAddress::~OMacAddress()
 {
 }
 
 
 //#ifdef QT_NO_DEBUG
 //inline
 //#endif
 const unsigned char* OMacAddress::native() const
 {
     return (const unsigned char*) &_bytes;
 }
 
 
 OMacAddress OMacAddress::fromString( const QString& str )
 {
     QString addr( str );
     unsigned char buf[6];
     bool ok = true;
     int index = 14;
     for ( int i = 5; i >= 0; --i )
     {
         buf[i] = addr.right( 2 ).toUShort( &ok, 16 );
         if ( !ok ) return OMacAddress::unknown;
         addr.truncate( index );
         index -= 3;
     }
     return (const unsigned char*) &buf;
 }
 
 
 QString OMacAddress::toString( bool substitute ) const
 {
     QString manu;
     manu.sprintf( "%.2X:%.2X:%.2X", _bytes[0]&0xff, _bytes[1]&0xff, _bytes[2]&0xff );
     QString serial;
     serial.sprintf( ":%.2X:%.2X:%.2X", _bytes[3]&0xff, _bytes[4]&0xff, _bytes[5]&0xff );
     if ( !substitute ) return manu+serial;
     // fallback - if no vendor is found, just use the number
     QString textmanu = OManufacturerDB::instance()->lookup( manu );
     return textmanu.isNull() ? manu+serial : textmanu+serial;
 }
 
 
 QString OMacAddress::manufacturer() const
 {
     return OManufacturerDB::instance()->lookupExt( toString() );
 }
 
 
 bool operator==( const OMacAddress &m1, const OMacAddress &m2 )
 {
     return memcmp( &m1._bytes, &m2._bytes, 6 ) == 0;
 }
 
 
 /*======================================================================================
  * OHostAddress
  *======================================================================================*/
 
+OHostAddress::OHostAddress()
+             :QHostAddress()
+{
+}
+
+
+OHostAddress::OHostAddress( Q_UINT32 ip4Addr )
+             :QHostAddress( ip4Addr )
+{
+}
+
+
+OHostAddress::~OHostAddress()
+{
+}
 
 /*======================================================================================
  * OPrivateIOCTL
  *======================================================================================*/
 
 OPrivateIOCTL::OPrivateIOCTL( QObject* parent, const char* name, int cmd, int getargs, int setargs )
               :QObject( parent, name ), _ioctl( cmd ), _getargs( getargs ), _setargs( setargs )
 {
 }
 
 
 OPrivateIOCTL::~OPrivateIOCTL()
 {
 }
 
 
 int OPrivateIOCTL::numberGetArgs() const
 {
     return _getargs & IW_PRIV_SIZE_MASK;
 }
 
 
 int OPrivateIOCTL::typeGetArgs() const
 {
     return _getargs & IW_PRIV_TYPE_MASK >> 12;
 }
 
 
 int OPrivateIOCTL::numberSetArgs() const
 {
     return _setargs & IW_PRIV_SIZE_MASK;
 }
 
 
 int OPrivateIOCTL::typeSetArgs() const
 {
     return _setargs & IW_PRIV_TYPE_MASK >> 12;
 }
 
 
 void OPrivateIOCTL::invoke() const
 {
     ( (OWirelessNetworkInterface*) parent() )->wioctl( _ioctl );
 }
 
 
 void OPrivateIOCTL::setParameter( int num, u_int32_t value )
 {
     u_int32_t* arglist = (u_int32_t*) &( (OWirelessNetworkInterface*) parent() )->_iwr.u.name;
     arglist[num] = value;
 }
 
 
 
 namespace Internal {
 /*======================================================================================
  * assorted functions
  *======================================================================================*/
 
 void dumpBytes( const unsigned char* data, int num )
 {
     printf( "Dumping %d bytes @ 0x%p", num, data );
     printf( "-------------------------------------------\n" );
 
     for ( int i = 0; i < num; ++i )
     {
         printf( "%02x ", data[i] );
         if ( !((i+1) % 32) ) printf( "\n" );
     }
     printf( "\n\n" );
 }
 
 
 int stringToMode( const QString& mode )
 {
     if ( mode == "auto" )            return IW_MODE_AUTO;
     else if ( mode == "adhoc" )      return IW_MODE_ADHOC;
     else if ( mode == "managed" )    return IW_MODE_INFRA;
     else if ( mode == "master" )     return IW_MODE_MASTER;
     else if ( mode == "repeater" )   return IW_MODE_REPEAT;
     else if ( mode == "secondary" )  return IW_MODE_SECOND;
     else if ( mode == "monitor" )    return IW_MODE_MONITOR;
     else assert( 0 );
 }
 
 
 QString modeToString( int mode )
 {
     switch ( mode )
     {
         case IW_MODE_AUTO:          return "auto";
         case IW_MODE_ADHOC:         return "adhoc";
         case IW_MODE_INFRA:         return "managed";
         case IW_MODE_MASTER:        return "master";
         case IW_MODE_REPEAT:        return "repeater";
         case IW_MODE_SECOND:        return "second";
         case IW_MODE_MONITOR:       return "monitor";
         default: assert( 0 );
     }
 }
 }
 }
 }
diff --git a/libopie2/opienet/onetutils.h b/libopie2/opienet/onetutils.h
index 25c9238..f08738c 100644
--- a/libopie2/opienet/onetutils.h
+++ b/libopie2/opienet/onetutils.h
@@ -1,241 +1,241 @@
 /*
                              This file is part of the Opie Project
-                             (C) 2003-2005 Michael 'Mickey' Lauer <mickey@Vanille.de>
-              =.
+              =.             (C) 2003-2005 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 ONETUTILS_H
 #define ONETUTILS_H
 
 #include <qdict.h>
 #include <qmap.h>
 #include <qstring.h>
 #include <qhostaddress.h>
 #include <qobject.h>
 
 #include <sys/types.h>
 
 struct ifreq;
 
 namespace Opie {
 namespace Net  {
 
 class OWirelessNetworkInterface;
 
 /*======================================================================================
  * OMacAddress
  *======================================================================================*/
 
 class OMacAddress
 {
   public:
     // QString c'tor? -zecke
     OMacAddress();
     OMacAddress( unsigned char* );
     OMacAddress( const unsigned char* );
     OMacAddress( struct ifreq& );
     ~OMacAddress();
 
     QString manufacturer() const;
     QString toString( bool substitute = false ) const;
     const unsigned char* native() const;
 
     // no c'tor but this one why not make it a c'tor. it could also replace the others or is this the problem?
     static OMacAddress fromString( const QString& );
 
   public:
     static const OMacAddress& broadcast; // ff:ff:ff:ff:ff:ff
     static const OMacAddress& unknown;   // 44:44:44:44:44:44
 
   private:
     unsigned char _bytes[6];
 
   friend bool operator==( const OMacAddress &m1, const OMacAddress &m2 );
   class Private;
   Private *d;
 
 };
 
 bool operator==( const OMacAddress &m1, const OMacAddress &m2 );
 
 
 /*======================================================================================
  * OHostAddress
  *======================================================================================*/
 
 class OHostAddress : public QHostAddress
 {
-  /*public:
+  public:
     OHostAddress();
+    OHostAddress( Q_UINT32 ip4Addr );
     ~OHostAddress();
-  */
+
   private:
   class Private;
   Private *d;
 };
 
 
 /*======================================================================================
  * ONetworkInterfaceDriverInfo
  *======================================================================================*/
 
 class ONetworkInterfaceDriverInfo
 {
   public:
     ONetworkInterfaceDriverInfo( const QString& name = "<unknown>",
                                  const QString& version = "<unknown>",
                                  const QString& firmware = "<unknown>",
                                  const QString& bus = "<unknown>" ) :
                                  _name( name ), _version( version ), _firmware( firmware ), _bus( bus ) { };
     ~ONetworkInterfaceDriverInfo() { };
 
     QString name() const { return _name; };
     QString version() const { return _version; };
     QString firmware() const { return _firmware; };
     QString bus() const { return _bus; };
 
   private:
     const QString _name;
     const QString _version;
     const QString _firmware;
     const QString _bus;
 };
 
 /*======================================================================================
  * OPrivateIOCTL
  *======================================================================================*/
 
 class OPrivateIOCTL : public QObject
 {
   public:
     OPrivateIOCTL( QObject* parent, const char* name, int cmd, int getargs, int setargs );
     ~OPrivateIOCTL();
 
     int numberGetArgs() const;
     int typeGetArgs() const;
     int numberSetArgs() const;
     int typeSetArgs() const;
 
     // FIXME return int? as ::ioctl does? -zecke
     void invoke() const;
     void setParameter( int, u_int32_t );
 
   private:
     u_int32_t _ioctl;
     u_int16_t _getargs;
     u_int16_t _setargs;
 
     class Private;
     Private *d;
 };
 
  /*======================================================================================
  * Miscellaneous
  *======================================================================================*/
 
 namespace Internal {
 void dumpBytes( const unsigned char* data, int num );
 QString modeToString( int );
 int stringToMode( const QString& );
 }
 }
 }
 
 #define IW_PRIV_TYPE_MASK       0x7000
 #define IW_PRIV_TYPE_NONE       0x0000
 #define IW_PRIV_TYPE_BYTE       0x1000
 #define IW_PRIV_TYPE_CHAR       0x2000
 #define IW_PRIV_TYPE_INT        0x4000
 #define IW_PRIV_TYPE_FLOAT      0x5000
 #define IW_PRIV_TYPE_ADDR       0x6000
 #define IW_PRIV_SIZE_FIXED      0x0800
 #define IW_PRIV_SIZE_MASK       0x07FF
 
 #define IW_HEADER_TYPE_NULL     0       /* Not available */
 #define IW_HEADER_TYPE_CHAR     2       /* char [IFNAMSIZ] */
 #define IW_HEADER_TYPE_UINT     4       /* __u32 */
 #define IW_HEADER_TYPE_FREQ     5       /* struct iw_freq */
 #define IW_HEADER_TYPE_ADDR     6       /* struct sockaddr */
 #define IW_HEADER_TYPE_POINT    8       /* struct iw_point */
 #define IW_HEADER_TYPE_PARAM    9       /* struct iw_param */
 #define IW_HEADER_TYPE_QUAL     10      /* struct iw_quality */
 
 #define IW_EV_POINT_OFF (((char *) &(((struct iw_point *) NULL)->length)) - \
                                   (char *) NULL)
 
 #ifndef ARPHRD_IEEE80211
 #define ARPHRD_IEEE80211 801
 #endif
 #ifndef ARPHRD_IEEE80211_PRISM
 #define ARPHRD_IEEE80211_PRISM 802
 #endif
 
 /* Wireless Extension Scanning Stuff */
 struct iw_stream_descr
 {
     char *        end;            /* End of the stream */
     char *        current;        /* Current event in stream of events */
     char *        value;          /* Current value in event */
 };
 
 
 /* Network to host order macros */
 
 #ifdef LBL_ALIGN
 #define EXTRACT_16BITS(p) \
         ((u_int16_t)((u_int16_t)*((const u_int8_t *)(p) + 0) << 8 | \
                      (u_int16_t)*((const u_int8_t *)(p) + 1)))
 #define EXTRACT_32BITS(p) \
         ((u_int32_t)((u_int32_t)*((const u_int8_t *)(p) + 0) << 24 | \
                      (u_int32_t)*((const u_int8_t *)(p) + 1) << 16 | \
                      (u_int32_t)*((const u_int8_t *)(p) + 2) << 8 | \
                      (u_int32_t)*((const u_int8_t *)(p) + 3)))
 #else
 #define EXTRACT_16BITS(p) \
         ((u_int16_t)ntohs(*(const u_int16_t *)(p)))
 #define EXTRACT_32BITS(p) \
         ((u_int32_t)ntohl(*(const u_int32_t *)(p)))
 #endif
 
 #define EXTRACT_24BITS(p) \
         ((u_int32_t)((u_int32_t)*((const u_int8_t *)(p) + 0) << 16 | \
                      (u_int32_t)*((const u_int8_t *)(p) + 1) << 8 | \
                      (u_int32_t)*((const u_int8_t *)(p) + 2)))
 
 /* Little endian protocol host order macros */
 #define EXTRACT_LE_8BITS(p) (*(p))
 #define EXTRACT_LE_16BITS(p) \
         ((u_int16_t)((u_int16_t)*((const u_int8_t *)(p) + 1) << 8 | \
                      (u_int16_t)*((const u_int8_t *)(p) + 0)))
 #define EXTRACT_LE_32BITS(p) \
         ((u_int32_t)((u_int32_t)*((const u_int8_t *)(p) + 3) << 24 | \
                      (u_int32_t)*((const u_int8_t *)(p) + 2) << 16 | \
                      (u_int32_t)*((const u_int8_t *)(p) + 1) << 8 | \
                      (u_int32_t)*((const u_int8_t *)(p) + 0)))
 
 #endif // ONETUTILS_H
 
diff --git a/libopie2/opienet/onetwork.cpp b/libopie2/opienet/onetwork.cpp
index 1deb051..0649ca2 100644
--- a/libopie2/opienet/onetwork.cpp
+++ b/libopie2/opienet/onetwork.cpp
@@ -1,1062 +1,1051 @@
 /*
                              This file is part of the Opie Project
-                             Copyright (C) 2003-2005 by Michael 'Mickey' Lauer <mickey@Vanille.de>
-              =.
+              =.             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>
 using namespace Opie::Core;
 
 /* QT */
 #include <qfile.h>
 #include <qtextstream.h>
 #include <qapplication.h>
 
 /* STD */
 #include <assert.h>
 #include <arpa/inet.h>
 #include <errno.h>
 #include <stdarg.h>
 #include <string.h>
 #include <stdlib.h>
 #include <math.h>
 #include <unistd.h>
 #include <net/if_arp.h>
 #include <net/ethernet.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
 #include <sys/types.h>
 #include <linux/types.h>
 #include <linux/sockios.h>
 #define u64 __u64
 #define u32 __u32
 #define u16 __u16
 #define u8 __u8
 #include <linux/ethtool.h>
 
 #ifndef NODEBUG
 #include <opie2/odebugmapper.h>
 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;
         if ( str.startsWith( "wifi" ) )
         {
             odebug << "ONetwork: ignoring hostap control interface" << oendl;
             s.readLine();
             continue;
         }
         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 );
 }
 
 
 bool ONetwork::isPresent( const char* name ) const
 {
     int sfd = socket( AF_INET, SOCK_STREAM, 0 );
     struct ifreq ifr;
     memset( &ifr, 0, sizeof( struct ifreq ) );
     strcpy( (char*) &ifr.ifr_name, name );
     int result = ::ioctl( sfd, SIOCGIFFLAGS, &ifr );
     return result != -1;
 }
 
 
 bool ONetwork::isWirelessInterface( const char* name ) const
 {
     int sfd = socket( AF_INET, SOCK_STREAM, 0 );
     struct iwreq iwr;
     memset( &iwr, 0, sizeof( struct iwreq ) );
     strcpy( (char*) &iwr.ifr_name, name );
     int result = ::ioctl( sfd, SIOCGIWNAME, &iwr );
     return result != -1;
 }
 
 /*======================================================================================
  * ONetworkInterface
  *======================================================================================*/
 
 ONetworkInterface::ONetworkInterface( QObject* parent, const char* name )
                  :QObject( parent, name ),
                  _sfd( socket( AF_INET, SOCK_DGRAM, 0 ) ), _mon( 0 )
 {
     odebug << "ONetworkInterface::ONetworkInterface()" << oendl;
     init();
 }
 
 
 struct ifreq& ONetworkInterface::ifr() const
 {
     return _ifr;
 }
 
 
 void ONetworkInterface::init()
 {
     odebug << "ONetworkInterface::init()" << oendl;
-
     memset( &_ifr, 0, sizeof( struct ifreq ) );
 
     if ( _sfd == -1 )
     {
         odebug << "ONetworkInterface::init(): Warning - can't get socket for device '" << name() << "'" << oendl;
         return;
     }
 }
 
 
 bool ONetworkInterface::ioctl( int call, struct ifreq& ifreq ) const
 {
     #ifndef NODEBUG
     int result = ::ioctl( _sfd, call, &ifreq );
     if ( result == -1 )
         odebug << "ONetworkInterface::ioctl (" << name() << ") call '" << debugmapper->map( call )
                << "' FAILED! " << result << " (" << strerror( errno ) << ")" << oendl;
     else
         odebug << "ONetworkInterface::ioctl (" << name() << ") call '" << debugmapper->map( call )
                << "' - Status: Ok." << oendl;
     return ( result != -1 );
     #else
     return ::ioctl( _sfd, call, &ifreq ) != -1;
     #endif
 }
 
 
 bool ONetworkInterface::ioctl( int call ) const
 {
     strcpy( _ifr.ifr_name, name() );
     return ioctl( call, _ifr );
 }
 
 
 bool ONetworkInterface::isLoopback() const
 {
     ioctl( SIOCGIFFLAGS );
     return _ifr.ifr_flags & IFF_LOOPBACK;
 }
 
 
 bool ONetworkInterface::setUp( bool b )
 {
     ioctl( SIOCGIFFLAGS );
     if ( b ) _ifr.ifr_flags |= IFF_UP;
     else   _ifr.ifr_flags &= (~IFF_UP);
     return ioctl( SIOCSIFFLAGS );
 }
 
 
 bool ONetworkInterface::isUp() const
 {
     ioctl( SIOCGIFFLAGS );
     return _ifr.ifr_flags & IFF_UP;
 }
 
 
 void ONetworkInterface::setIPV4Address( const QHostAddress& addr )
 {
     struct sockaddr_in *sa = (struct sockaddr_in *) &_ifr.ifr_addr;
     sa->sin_family = AF_INET;
     sa->sin_port = 0;
     sa->sin_addr.s_addr = htonl( addr.ip4Addr() );
     ioctl( SIOCSIFADDR );
 }
 
 
-QString ONetworkInterface::ipV4Address() const
+OHostAddress ONetworkInterface::ipV4Address() const
 {
-    if ( ioctl( SIOCGIFADDR ) )
-    {
-        struct sockaddr_in* sa = (struct sockaddr_in *) &_ifr.ifr_addr;
-        //FIXME: Use QHostAddress here
-        return QString( inet_ntoa( sa->sin_addr ) );
-    }
-    else
-        return "<unknown>";
-
+    struct sockaddr_in* sa = (struct sockaddr_in *) &_ifr.ifr_addr;
+    return ioctl( SIOCGIFADDR ) ? OHostAddress( ntohl( sa->sin_addr.s_addr ) ) : OHostAddress();
 }
 
 
 void ONetworkInterface::setMacAddress( const OMacAddress& addr )
 {
     _ifr.ifr_hwaddr.sa_family = ARPHRD_ETHER;
     memcpy( &_ifr.ifr_hwaddr.sa_data, addr.native(), 6 );
     ioctl( SIOCSIFHWADDR );
 }
 
 
 OMacAddress ONetworkInterface::macAddress() const
 {
     if ( ioctl( SIOCGIFHWADDR ) )
     {
         return OMacAddress( _ifr );
     }
     else
     {
         return OMacAddress::unknown;
     }
 }
 
 
 void ONetworkInterface::setIPV4Netmask( const QHostAddress& addr )
 {
     struct sockaddr_in *sa = (struct sockaddr_in *) &_ifr.ifr_addr;
     sa->sin_family = AF_INET;
     sa->sin_port = 0;
     sa->sin_addr.s_addr = htonl( addr.ip4Addr() );
     ioctl( SIOCSIFNETMASK );
 }
 
 
-QString ONetworkInterface::ipV4Netmask() const
+OHostAddress ONetworkInterface::ipV4Netmask() const
 {
-    if ( ioctl( SIOCGIFNETMASK ) )
-    {
-        struct sockaddr_in* sa = (struct sockaddr_in *) &_ifr.ifr_addr;
-        //FIXME: Use QHostAddress here
-        return QString( inet_ntoa( sa->sin_addr ) );
-    }
-    else
-        return "<unknown>";
+    struct sockaddr_in* sa = (struct sockaddr_in *) &_ifr.ifr_addr;
+    return ioctl( SIOCGIFNETMASK ) ? OHostAddress( ntohl( sa->sin_addr.s_addr ) ) : OHostAddress();
 }
 
 
 int ONetworkInterface::dataLinkType() const
 {
     if ( ioctl( SIOCGIFHWADDR ) )
     {
         return _ifr.ifr_hwaddr.sa_family;
     }
     else
     {
         return -1;
     }
 }
 
 
 void ONetworkInterface::setMonitoring( OMonitoringInterface* m )
 {
     _mon = m;
     odebug << "ONetwork::setMonitoring(): Installed monitoring driver '" << m->name() << "' on interface '" << name() << "'" << oendl;
 }
 
 
 OMonitoringInterface* ONetworkInterface::monitoring() const
 {
     return _mon;
 }
 
 
 ONetworkInterface::~ONetworkInterface()
 {
     odebug << "ONetworkInterface::~ONetworkInterface()" << oendl;
     if ( _sfd != -1 ) ::close( _sfd );
 }
 
 
 bool ONetworkInterface::setPromiscuousMode( bool b )
 {
     ioctl( SIOCGIFFLAGS );
     if ( b ) _ifr.ifr_flags |= IFF_PROMISC;
     else   _ifr.ifr_flags &= (~IFF_PROMISC);
     return ioctl( SIOCSIFFLAGS );
 }
 
 
 bool ONetworkInterface::promiscuousMode() const
 {
     ioctl( SIOCGIFFLAGS );
     return _ifr.ifr_flags & IFF_PROMISC;
 }
 
 
 bool ONetworkInterface::isWireless() const
 {
     return ioctl( SIOCGIWNAME );
 }
 
 
 ONetworkInterfaceDriverInfo ONetworkInterface::driverInfo() const
 {
         struct ethtool_drvinfo info;
         info.cmd = ETHTOOL_GDRVINFO;
         _ifr.ifr_data = (caddr_t) &info;
         return ioctl( SIOCETHTOOL ) ? ONetworkInterfaceDriverInfo( info.driver, info.version, info.fw_version, info.bus_info) : ONetworkInterfaceDriverInfo();
 }
 
 /*======================================================================================
  * OChannelHopper
  *======================================================================================*/
 
 OChannelHopper::OChannelHopper( OWirelessNetworkInterface* iface )
                :QObject( 0, "Mickey's funky hopper" ),
                _iface( iface ), _interval( 0 ), _tid( 0 )
 {
     int _maxChannel = iface->channels();
     // generate fancy hopping sequence honoring the device capabilities
     if ( _maxChannel >=  1 ) _channels.append(  1 );
     if ( _maxChannel >=  7 ) _channels.append(  7 );
     if ( _maxChannel >= 13 ) _channels.append( 13 );
     if ( _maxChannel >=  2 ) _channels.append(  2 );
     if ( _maxChannel >=  8 ) _channels.append(  8 );
     if ( _maxChannel >=  3 ) _channels.append(  3 );
     if ( _maxChannel >= 14 ) _channels.append( 14 );
     if ( _maxChannel >=  9 ) _channels.append(  9 );
     if ( _maxChannel >=  4 ) _channels.append(  4 );
     if ( _maxChannel >= 10 ) _channels.append( 10 );
     if ( _maxChannel >=  5 ) _channels.append(  5 );
     if ( _maxChannel >= 11 ) _channels.append( 11 );
     if ( _maxChannel >=  6 ) _channels.append(  6 );
     if ( _maxChannel >= 12 ) _channels.append( 12 );
     //FIXME: Add 802.11a/g channels
     _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[len];
     memset( buffer, 0, len );
     memcpy( wrq.ifr_name, name(), IFNAMSIZ);
     wrq.u.data.pointer = (caddr_t) buffer;
     wrq.u.data.length = sizeof buffer;
     wrq.u.data.flags = 0;
 
-    if ( ::ioctl( _sfd, SIOCGIWRANGE, &wrq ) == -1 )
+    int result = ::ioctl( _sfd, SIOCGIWRANGE, &wrq );
+    if ( result == -1 )
+    {
+        owarn << "OWirelessNetworkInterface::buildInformation(): SIOCGIWRANGE failed (" << strerror( errno ) << ") - retrying with smaller buffer..." << oendl;
+        wrq.u.data.length = sizeof( struct iw_range );
+        result = ::ioctl( _sfd, SIOCGIWRANGE, &wrq );
+    }
+
+    if ( result == -1 )
     {
         owarn << "OWirelessNetworkInterface::buildInformation(): Can't get driver information (" << strerror( errno ) << ") - 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;
 }
 
 
 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 ) )
     {
         owarn << "OWirelessNetworkInterface::buildPrivateList(): Can't get private ioctl information (" << strerror( errno ) << ")." << oendl;
         return;
     }
 
     for ( int i = 0; i < _iwr.u.data.length; ++i )
     {
         new OPrivateIOCTL( this, priv[i].name, priv[i].cmd, priv[i].get_args, priv[i].set_args );
     }
     odebug << "OWirelessNetworkInterface::buildPrivateList(): Private ioctl list constructed." << oendl;
 }
 
 
 void OWirelessNetworkInterface::dumpInformation() const
 {
     odebug << "OWirelessNetworkInterface::() -------------- dumping information block ----------------" << oendl;
 
     odebug << " - driver's idea of maximum throughput is " << _range.throughput
            << " bps = " << ( _range.throughput / 8 ) << " byte/s = " << ( _range.throughput / 8 / 1024 )
            << " Kb/s = " << QString().sprintf("%f.2", float( _range.throughput ) / 8.0 / 1024.0 / 1024.0 )
            << " Mb/s" << oendl;
 
     odebug << " - driver for '" << name() << "' (V" << _range.we_version_source
            << ") has been compiled against WE V" << _range.we_version_compiled << oendl;
 
     if ( _range.we_version_compiled != WIRELESS_EXT )
     {
         owarn << "Version mismatch! WE_DRIVER = " << _range.we_version_compiled << " and WE_OPIENET = " << WIRELESS_EXT << oendl;
     }
 
     odebug << "OWirelessNetworkInterface::() ---------------------------------------------------------" << oendl;
 }
 
 
 int OWirelessNetworkInterface::channel() const
 {
     //FIXME: When monitoring enabled, then use it
     //FIXME: to gather the current RF channel
     //FIXME: Until then, get active channel from hopper.
     if ( _hopper && _hopper->isActive() )
         return _hopper->channel();
 
     if ( !wioctl( SIOCGIWFREQ ) )
     {
         return -1;
     }
     else
     {
         return _channels[ static_cast<int>(double( _iwr.u.freq.m ) * pow( 10.0, _iwr.u.freq.e ) / 1000000) ];
     }
 }
 
 
 void OWirelessNetworkInterface::setChannel( int c ) const
 {
     if ( !c )
     {
         oerr << "OWirelessNetworkInterface::setChannel( 0 ) called - fix your application!" << oendl;
         return;
     }
 
     if ( !_mon )
     {
         memset( &_iwr, 0, sizeof( struct iwreq ) );
         _iwr.u.freq.m = c;
         _iwr.u.freq.e = 0;
         wioctl( SIOCSIWFREQ );
     }
     else
     {
         _mon->setChannel( c );
     }
 }
 
 
 double OWirelessNetworkInterface::frequency() const
 {
     if ( !wioctl( SIOCGIWFREQ ) )
     {
         return -1.0;
     }
     else
     {
         return double( _iwr.u.freq.m ) * pow( 10.0, _iwr.u.freq.e ) / 1000000000.0;
     }
 }
 
 
 int OWirelessNetworkInterface::channels() const
 {
     return _channels.count();
 }
 
 
 void OWirelessNetworkInterface::setChannelHopping( int interval )
 {
     if ( !_hopper ) _hopper = new OChannelHopper( this );
     _hopper->setInterval( interval );
     //FIXME: When and by whom will the channel hopper be deleted?
     //TODO: rely on QObject hierarchy
 }
 
 
 int OWirelessNetworkInterface::channelHopping() const
 {
     return _hopper->interval();
 }
 
 
 OChannelHopper* OWirelessNetworkInterface::channelHopper() const
 {
     return _hopper;
 }
 
 
 void OWirelessNetworkInterface::commit() const
 {
     wioctl( SIOCSIWCOMMIT );
 }
 
 
 void OWirelessNetworkInterface::setMode( const QString& newMode )
 {
     #ifdef FINALIZE
     QString currentMode = mode();
     if ( currentMode == newMode ) return;
     #endif
 
     odebug << "OWirelessNetworkInterface::setMode(): trying to set mode " << newMode << oendl;
 
     _iwr.u.mode = stringToMode( newMode );
 
     if ( _iwr.u.mode != IW_MODE_MONITOR )
     {
         // IWR.U.MODE WIRD DURCH ABFRAGE DES MODE HIER PLATTGEMACHT!!!!!!!!!!!!!!!!!!!!! DEPP!
         _iwr.u.mode = stringToMode( newMode );
         wioctl( SIOCSIWMODE );
 
         // special iwpriv fallback for monitor mode (check if we're really out of monitor mode now)
 
         if ( mode() == "monitor" )
         {
             odebug << "OWirelessNetworkInterface::setMode(): SIOCSIWMODE not sufficient - trying fallback to iwpriv..." << oendl;
             if ( _mon )
                 _mon->setEnabled( false );
             else
                 odebug << "ONetwork(): can't switch monitor mode without installed monitoring interface" << oendl;
         }
 
     }
     else    // special iwpriv fallback for monitor mode
     {
         if ( wioctl( SIOCSIWMODE ) )
         {
             odebug << "OWirelessNetworkInterface::setMode(): IW_MODE_MONITOR ok" << oendl;
         }
         else
         {
             odebug << "OWirelessNetworkInterface::setMode(): SIOCSIWMODE not working - trying fallback to iwpriv..." << oendl;
 
             if ( _mon )
                 _mon->setEnabled( true );
             else
                 odebug << "ONetwork(): can't switch monitor mode without installed monitoring interface" << oendl;
         }
     }
 }
 
 
 QString OWirelessNetworkInterface::mode() const
 {
     memset( &_iwr, 0, sizeof( struct iwreq ) );
 
     if ( !wioctl( SIOCGIWMODE ) )
     {
         return "<unknown>";
     }
 
     odebug << "OWirelessNetworkInterface::setMode(): WE's idea of current mode seems to be " << modeToString( _iwr.u.mode ) << oendl;
 
     // legacy compatible monitor mode check
 
     if ( dataLinkType() == ARPHRD_IEEE80211 || dataLinkType() == 802 )
     {
         return "monitor";
     }
     else
     {
         return modeToString( _iwr.u.mode );
     }
 }
 
 void OWirelessNetworkInterface::setNickName( const QString& nickname )
 {
     _iwr.u.essid.pointer = const_cast<char*>( (const char*) nickname );
     _iwr.u.essid.length = nickname.length();
     wioctl( SIOCSIWNICKN );
 }
 
 
 QString OWirelessNetworkInterface::nickName() const
 {
     char str[IW_ESSID_MAX_SIZE];
     _iwr.u.data.pointer = &str[0];
     _iwr.u.data.length = IW_ESSID_MAX_SIZE;
     if ( !wioctl( SIOCGIWNICKN ) )
     {
         return "<unknown>";
     }
     else
     {
         str[_iwr.u.data.length] = '\0'; // some drivers don't zero-terminate the string
         return str;
     }
 }
 
 
 void OWirelessNetworkInterface::setPrivate( const QString& call, int numargs, ... )
 {
     OPrivateIOCTL* priv = static_cast<OPrivateIOCTL*>( child( (const char*) call ) );
     if ( !priv )
     {
         owarn << "OWirelessNetworkInterface::setPrivate(): interface '" << name()
               << "' 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
     {
         str[_iwr.u.essid.length] = '\0'; // some drivers don't zero-terminate the string
         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 ( qApp )
             {
                 qApp->processEvents( 100 );
                 continue;
             }
             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 */
                 IW_EV_ADDR_LEN,         /* IW_HEADER_TYPE_ADDR */
                 0,
                 IW_EV_POINT_LEN,        /* Without variable payload */
                 IW_EV_PARAM_LEN,        /* IW_HEADER_TYPE_PARAM */
                 IW_EV_QUAL_LEN,         /* IW_HEADER_TYPE_QUAL */
         };
 
 
         //Initialize the stream
         memset( &stream, 0, sizeof(struct iw_stream_descr) );
         stream.current = buffer;
         stream.end = buffer + _iwr.u.data.length;
 
         do
         {
             if ((stream.current + IW_EV_LCP_LEN) > stream.end)
                 break;
             memcpy((char *) &iwe, stream.current, IW_EV_LCP_LEN);
 
             if (iwe.len <= IW_EV_LCP_LEN) //If yes, it is an invalid event
                 break;
             if (iwe.cmd <= SIOCIWLAST) {
                 cmd_index = iwe.cmd - SIOCIWFIRST;
 
                 if(cmd_index < sizeof(standard_ioctl_hdr))
                     event_type = standard_ioctl_hdr[cmd_index];
             }
diff --git a/libopie2/opienet/onetwork.h b/libopie2/opienet/onetwork.h
index f0c4450..b13c7a3 100644
--- a/libopie2/opienet/onetwork.h
+++ b/libopie2/opienet/onetwork.h
@@ -1,598 +1,597 @@
 /*
                              This file is part of the Opie Project
-                             Copyright (C) 2003-2005 by Michael 'Mickey' Lauer <mickey@Vanille.de>
-              =.
+              =.             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 ONETWORK_H
 #define ONETWORK_H
 
 /* OPIE */
 #include <opie2/onetutils.h>
 #include <opie2/ostation.h>
 
 /* QT */
 #include <qvaluelist.h>
 #include <qdict.h>
 #include <qmap.h>
 #include <qobject.h>
 #include <qhostaddress.h>
 
 /* STD */
 // hacky workarounds until we have a true user space wireless.h
 #include <net/if.h>
 #define _LINUX_IF_H
 #include <linux/wireless.h>
 #ifndef IW_MAX_PRIV_DEF
 #define IW_MAX_PRIV_DEF        128
 #endif
 
 namespace Opie {
 namespace Net  {
 class ONetworkInterface;
 class OWirelessNetworkInterface;
 class OChannelHopper;
 class OMonitoringInterface;
 
 /*======================================================================================
  * ONetwork
  *======================================================================================*/
 
 /**
  * @brief A container class for all network interfaces
  *
  * This class provides access to all available network interfaces of your computer.
  *
  * @author Michael 'Mickey' Lauer <mickey@vanille.de>
  */
 class ONetwork : public QObject
 {
   Q_OBJECT
 
   public:
     typedef QDict<ONetworkInterface> InterfaceMap;
     typedef QDictIterator<ONetworkInterface> InterfaceIterator;
 
   public:
     /**
      * @returns the number of available interfaces
      */
     int count() const;
     /**
      * @returns a pointer to the (one and only) @ref ONetwork instance.
      */
     static ONetwork* instance();
     /**
      * @returns an iterator usable for iterating through all network interfaces.
      */
     InterfaceIterator iterator() const;
     /**
      * @returns true, if the @a interface is present.
      */
     bool isPresent( const char* interface ) const;
     /**
      * @returns true, if the @a interface supports the wireless extension protocol.
      */
     bool isWirelessInterface( const char* interface ) const;
     /**
      * @returns a pointer to the @ref ONetworkInterface object for the specified @a interface or 0, if not found.
      * @see ONetworkInterface
      */
     ONetworkInterface* interface( const QString& interface ) const;
     /**
      * @internal Rebuild the internal interface database
      * @note Sometimes it might be useful to call this from client code,
      * e.g. after issuing a cardctl insert
      */
     void synchronize();
     /**
      * @returns the wireless extension version used at compile time.
      **/
     static short wirelessExtensionCompileVersion();
 
   protected:
     ONetwork();
 
   private:
     static ONetwork* _instance;
     InterfaceMap _interfaces;
     class Private;
     Private *d;
 };
 
 
 /*======================================================================================
  * ONetworkInterface
  *======================================================================================*/
 
 /**
  * @brief A network interface wrapper.
  *
  * This class provides a wrapper for a network interface. All the cumbersume details of
  * Linux ioctls are hidden under a convenient high-level interface.
  * @warning Most of the setting methods contained in this class require the appropriate
  * process permissions to work.
  *
  * @author Michael 'Mickey' Lauer <mickey@vanille.de>
  */
 class ONetworkInterface : public QObject
 {
     friend class OMonitoringInterface;
     friend class OCiscoMonitoringInterface;
     friend class OWlanNGMonitoringInterface;
     friend class OHostAPMonitoringInterface;
     friend class OOrinocoMonitoringInterface;
 
   public:
     /**
      * Constructor. Normally you don't create @ref ONetworkInterface objects yourself,
      * but access them via @ref ONetwork::interface().
      */
     ONetworkInterface( QObject* parent, const char* name );
     /**
      * Destructor.
      */
     virtual ~ONetworkInterface();
     /**
      * Associates a @a monitoring interface with this network interface.
      * @note This is currently only useful with @ref OWirelessNetworkInterface objects.
      */
     void setMonitoring( OMonitoringInterface* monitoring );
     /**
      * @returns the currently associated monitoring interface or 0, if no monitoring is associated.
      */
     OMonitoringInterface* monitoring() const;
     /**
      * Setting an interface to promiscuous mode enables the device to receive
      * all packets on the shared medium - as opposed to packets which are addressed to this interface.
      */
     bool setPromiscuousMode( bool );
     /**
      * @returns true if the interface is set to promiscuous mode.
      */
     bool promiscuousMode() const;
     /**
      * Setting an interface to up enables it to receive packets.
      */
     bool setUp( bool );
     /**
      * @returns true if the interface is up.
      */
     bool isUp() const;
     /**
      * @returns true if the interface is a loopback interface.
      */
     bool isLoopback() const;
     /**
      * @returns true if the interface is featuring supports the wireless extension protocol.
      */
     bool isWireless() const;
     /**
      * Associate the IP address @ addr with the interface.
      */
     void setIPV4Address( const QHostAddress& addr );
     /**
      * @returns the IPv4 address associated with the interface.
      */
-    QString ipV4Address() const; //TODO: make this return an OHostAddress
+    OHostAddress ipV4Address() const;
     /**
      * Associate the MAC address @a addr with the interface.
      * @note It can be necessary to shut down the interface prior to calling this method.
      * @note This operation needs root privileges
      * @warning This is not supported by all drivers.
      */
     void setMacAddress( const OMacAddress& addr );
     /**
      * @returns the MAC address associated with the interface.
      */
     OMacAddress macAddress() const;
     /**
      * Associate the IPv4 @a netmask with the interface.
      */
     void setIPV4Netmask( const QHostAddress& netmask );
     /**
      * @returns the IPv4 netmask associated with the interface.
      */
-    QString ipV4Netmask() const; //TODO: make this return an OHostAddress
+    OHostAddress ipV4Netmask() const;
     /**
      * @returns the data link type currently associated with the interface.
      * @see #include <net/if_arp.h> for possible values.
      */
     int dataLinkType() const;
     /**
      * @returns a ONetworkInterfaceDriverInfo driver information block
      * @note This operation needs root privileges
      * @warning This is not supported by all drivers
      */
     ONetworkInterfaceDriverInfo driverInfo() const;
 
   protected:
     const int _sfd;
     mutable ifreq _ifr;
     OMonitoringInterface* _mon;
 
   protected:
     struct ifreq& ifr() const;
     virtual void init();
     bool ioctl( int call ) const;
     bool ioctl( int call, struct ifreq& ) const;
   private:
     class Private;
     Private *d;
 };
 
 /*======================================================================================
  * OChannelHopper
  *======================================================================================*/
 
 /**
  * @brief A radio frequency channel hopper.
  *
  * This class provides a channel hopper for radio frequencies. A channel hopper frequently
  * changes the radio frequency channel of its associated @ref OWirelessNetworkInterface.
  * This is necessary when in monitoring mode and scanning for other devices, because
  * the radio frequency hardware can only detect packets sent on the same frequency.
  *
  * @author Michael 'Mickey' Lauer <mickey@vanille.de>
  */
 class OChannelHopper : public QObject
 {
   Q_OBJECT
 
   public:
     /**
      * Constructor.
      */
     OChannelHopper( OWirelessNetworkInterface* );
     /**
      * Destructor.
      */
     virtual ~OChannelHopper();
     /**
      * @returns true, if the channel hopper is hopping channels
      */
     bool isActive() const;
     /**
      * @returns the last hopped channel
      */
     int channel() const;
     /**
      * Set the channel hopping @a interval.
      * An interval of 0 deactivates the channel hopper.
      */
     void setInterval( int interval );
     /**
      * @returns the channel hopping interval
      */
     int interval() const;
 
   signals:
     /**
      * This signal is emitted right after the channel hopper performed a hop
      */
     void hopped( int );
 
   protected:
     virtual void timerEvent( QTimerEvent* );
 
   private:
     OWirelessNetworkInterface* _iface;
     int _interval;
     int _tid;
     QValueList<int> _channels;
     QValueList<int>::Iterator _channel;
     class Private;
     Private *d;
 };
 
 
 /*======================================================================================
  * OWirelessNetworkInterface
  *======================================================================================*/
 
 /**
  * @brief A network interface wrapper for interfaces supporting the wireless extensions protocol.
  *
  * This class provides a high-level encapsulation of the Linux wireless extension API.
  *
  * @author Michael 'Mickey' Lauer <mickey@vanille.de>
  */
 class OWirelessNetworkInterface : public ONetworkInterface
 {
     friend class OMonitoringInterface;
     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;
     virtual void setChannel( int );
   private:
     class Private;
     Private *d;
 
 };
 
 
 /*======================================================================================
  * OWlanNGMonitoringInterface
  *======================================================================================*/
 
 
 class OWlanNGMonitoringInterface : public OMonitoringInterface
 {
   public:
     OWlanNGMonitoringInterface( ONetworkInterface*, bool _prismHeader );
     virtual ~OWlanNGMonitoringInterface();
 
   public:
     virtual void setEnabled( bool );
     virtual QString name() const;
     virtual void setChannel( int );
   private:
     class Private;
     Private *d;
 
 };
 
 
 /*======================================================================================
  * OHostAPMonitoringInterface
  *======================================================================================*/
 
 
 class OHostAPMonitoringInterface : public OMonitoringInterface
 {
   public:
     OHostAPMonitoringInterface( ONetworkInterface*, bool _prismHeader );
     virtual ~OHostAPMonitoringInterface();
 
   public:
     virtual void setEnabled( bool );
     virtual QString name() const;
 
   private:
     class Private;
     Private *d;
  };
 
 
 /*======================================================================================
  * OOrinocoMonitoringInterface
  *======================================================================================*/
 
 
 class OOrinocoMonitoringInterface : public OMonitoringInterface
 {
   public:
     OOrinocoMonitoringInterface( ONetworkInterface*, bool _prismHeader );
     virtual ~OOrinocoMonitoringInterface();
 
    public:
     virtual void setChannel( int );
     virtual void setEnabled( bool );
     virtual QString name() const;
 
    private:
     class Private;
     Private *d;
 };
 
 }
 }
 
 #endif // ONETWORK_H