introduce a more sophisticated channel hopping scheme

1 files changed, 32 insertions, 9 deletions

diff --git a/libopie2/opienet/onetwork.cpp b/libopie2/opienet/onetwork.cpp
index 50d67bb..ac2857a 100644
--- a/libopie2/opienet/onetwork.cpp
+++ b/libopie2/opienet/onetwork.cpp
@@ -115,407 +115,430 @@ ONetwork* ONetwork::instance()
 {
     if ( !_instance ) _instance = new ONetwork();
     return _instance;
 }
 
 
 ONetwork::InterfaceIterator ONetwork::iterator() const
 {
     return ONetwork::InterfaceIterator( _interfaces );
 }
 
 
 bool ONetwork::isWirelessInterface( const char* name ) const
 {
     int sfd = socket( AF_INET, SOCK_DGRAM, 0 );
     iwreqstruct iwr;
     memset( &iwr, 0, sizeof( iwreqstruct ) );
     strcpy( (char*) &iwr.ifr_name, name );
     int result = ::ioctl( sfd, SIOCGIWNAME, &iwr );
     if ( result == -1 )
         qDebug( "ONetwork::ioctl(): SIOCGIWNAME failed: %d (%s)", result, strerror( errno ) );
     else
         qDebug( "ONetwork::ioctl(): SIOCGIWNAME ok." );
     return ( result != -1 );
 }
 
 /*======================================================================================
  * ONetworkInterface
  *======================================================================================*/
 
 ONetworkInterface::ONetworkInterface( const QString& name )
                    :_name( name ), _sfd( socket( AF_INET, SOCK_DGRAM, 0 ) ), _mon( 0 )
 {
     qDebug( "ONetworkInterface::ONetworkInterface()" );
     init();
 }
 
 
 ifreqstruct& ONetworkInterface::ifr() const
 {
     return _ifr;
 }
 
 
 void ONetworkInterface::init()
 {
     qDebug( "ONetworkInterface::init()" );
 
     memset( &_ifr, 0, sizeof( struct ifreq ) );
 
     if ( _sfd == -1 )
     {
         qDebug( "ONetworkInterface::init(): Warning - can't get socket for device '%s'", (const char*) _name );
         return;
     }
 }
 
 
 bool ONetworkInterface::ioctl( int call, ifreqstruct& ifreq ) const
 {
     int result = ::ioctl( _sfd, call, &ifreq );
     if ( result == -1 )
         qDebug( "ONetworkInterface::ioctl(): Call %d - Status: Failed: %d (%s)", call, result, strerror( errno ) );
     else
         qDebug( "ONetworkInterface::ioctl(): Call %d - Status: Ok.", call );
     return ( result != -1 );
 }
 
 
 bool ONetworkInterface::ioctl( int call ) const
 {
     strcpy( _ifr.ifr_name, (const char*) _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;
 }
 
 
 QString 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>";
 }
 
 
 OMacAddress ONetworkInterface::macAddress() const
 {
     if ( ioctl( SIOCGIFHWADDR ) )
     {
         return OMacAddress( _ifr );
     }
     else
     {
         return OMacAddress::unknown;
     }
 }
 
 
 void ONetworkInterface::setMonitoring( OMonitoringInterface* m )
 {
     _mon = m;
-    qDebug( "ONetwork::setMonitoring(): Installed monitoring interface '%s'", (const char*) m->name() );
+    qDebug( "ONetwork::setMonitoring(): Installed monitoring driver '%s' on interface '%s'", (const char*) m->name(), (const char*) _name );
 }
 
 
 OMonitoringInterface* ONetworkInterface::monitoring() const
 {
     return _mon;
 }
 
 
 const QString& ONetworkInterface::name() const
 {
     return _name;
 }
 
 
 ONetworkInterface::~ONetworkInterface()
 {
     qDebug( "ONetworkInterface::~ONetworkInterface()" );
     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 );
 }
 
 
 /*======================================================================================
  * OChannelHopper
  *======================================================================================*/
 
 OChannelHopper::OChannelHopper( OWirelessNetworkInterface* iface )
                :QObject( 0, "Mickey's funky hopper" ),
-               _iface( iface ), _interval( 0 ), _channel( 1 ), _tid( 0 ),
-               _maxChannel( iface->channels()+1 )
+               _iface( iface ), _interval( 0 ), _tid( 0 )
 {
+    int _maxChannel = iface->channels()+1;
+    // 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 );
+    _channel = _channels.begin();
+
 }
 
 
 OChannelHopper::~OChannelHopper()
 {
 }
 
 
 bool OChannelHopper::isActive() const
 {
     return _tid;
 }
 
 
 int OChannelHopper::channel() const
 {
-    return _channel;
+    return *_channel;
 }
 
 
 void OChannelHopper::timerEvent( QTimerEvent* )
 {
-    if ( !--_channel ) _channel = _maxChannel;
-    _iface->setChannel( _channel );
+    _iface->setChannel( *_channel );
     qDebug( "OChannelHopper::timerEvent(): set channel %d on interface '%s'",
-            _channel, (const char*) _iface->name() );
+            *_channel, (const char*) _iface->name() );
+    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( const QString& name )
                            :ONetworkInterface( name ), _hopper( 0 )
 {
     qDebug( "OWirelessNetworkInterface::OWirelessNetworkInterface()" );
     init();
 }
 
 
 OWirelessNetworkInterface::~OWirelessNetworkInterface()
 {
 }
 
 
 iwreqstruct& OWirelessNetworkInterface::iwr() const
 {
     return _iwr;
 }
 
 
 void OWirelessNetworkInterface::init()
 {
     qDebug( "OWirelessNetworkInterface::init()" );
 
     memset( &_iwr, 0, sizeof( struct iwreq ) );
 
     // IEEE802.11(b) radio frequency channels
 
     iwrangestruct range;
     //ML: work around an ugly HostAP bug, which needs
     //ML: extra space or will complain with "invalid argument length"... :-(
-    char __extraBufferForBuggyDrivers[sizeof range];
+    //ML: But don't allocate too much or prism2_usb will segfault *sigh*
+    char __extraBufferForBuggyDrivers[20];
+
+    qDebug( "sizeof(iwrangestruct)=%d, sizeof range=%d, sizeof range*2=%d", sizeof(iwrangestruct), sizeof range, (sizeof range)*2 );
+
     _iwr.u.data.pointer = (char*) &range;
-    _iwr.u.data.length = (sizeof range) * 2;
+    _iwr.u.data.length =  sizeof(iwrangestruct)+20;
     _iwr.u.data.flags = 0;
     if ( !wioctl( SIOCGIWRANGE ) )
     {
         qDebug( "OWirelessNetworkInterface::init(): SIOCGIWRANGE failed (%s)", strerror( errno ) );
         return;
     }
 
+    qDebug( "OWirelessNetworkInterface::init(): Interface %s reported to have %d channels.", (const char*) _name, range.num_frequency );
+
     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 );
         _channels.insert( freq, i+1 );
     }
 }
 
 
 QString OWirelessNetworkInterface::associatedAP() const
 {
     //FIXME: use OMacAddress
     QString mac;
 
     if ( ioctl( SIOCGIWAP ) )
     {
         mac.sprintf( "%.2X:%.2X:%.2X:%.2X:%.2X:%.2X",
         _ifr.ifr_hwaddr.sa_data[0]&0xff,
         _ifr.ifr_hwaddr.sa_data[1]&0xff,
         _ifr.ifr_hwaddr.sa_data[2]&0xff,
         _ifr.ifr_hwaddr.sa_data[3]&0xff,
         _ifr.ifr_hwaddr.sa_data[4]&0xff,
         _ifr.ifr_hwaddr.sa_data[5]&0xff );
     }
     else
     {
         mac = "<Unknown>";
     }
     return mac;
 }
 
 
 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 ( !_mon )
     {
         memset( &_iwr, 0, sizeof( iwreqstruct ) );
         _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?
 }
 
 
 int OWirelessNetworkInterface::channelHopping() const
 {
     return _hopper->interval();
 }
 
 
 void OWirelessNetworkInterface::setMonitorMode( bool b )
 {
     if ( _mon )
         _mon->setEnabled( b );
     else
         qDebug( "ONetwork(): can't switch monitor mode without installed monitoring interface" );
 }
 
 
 bool OWirelessNetworkInterface::monitorMode() const
 {
     return _mon ? _mon->enabled() : false;
 }
 
 
 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] = 0x0; // some drivers (e.g. wlan-ng) don't zero-terminate the string
         return str;
     }