2 files changed, 2 insertions, 2 deletions

diff --git a/libopie2/examples/opienet/miniwellenreiter/miniwellenreiter.cpp b/libopie2/examples/opienet/miniwellenreiter/miniwellenreiter.cpp
index 34d32d2..c49daa0 100644
--- a/libopie2/examples/opienet/miniwellenreiter/miniwellenreiter.cpp
+++ b/libopie2/examples/opienet/miniwellenreiter/miniwellenreiter.cpp
@@ -1,217 +1,217 @@
 #include <qdict.h>
 #include <qsocketnotifier.h>
 #include <qstring.h>
 #include <opie2/onetwork.h>
 #include <qapplication.h>
 #include <opie2/opcap.h>
 #include <cerrno>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 
 //======================== Station help class ===============================
 
 class Station
 {
   public:
     Station( QString t, int c, bool w ) : type(t), channel(c), wep(w), beacons(1) {};
     ~Station() {};
 
     QString type;
     int channel;
     bool wep;
     int beacons;
 };
 
 QDict<Station> stations;
 
 //======================== Application class ===============================
 
 class Wellenreiter : public QApplication
 {
 Q_OBJECT
 public:
   Wellenreiter( int argc, char** argv ) : QApplication( argc, argv )
   {
 
     ONetwork* net = ONetwork::instance();
 
     if ( argc < 3 )
     {
         printf( "Usage: ./%s <interface> <driver> <interval>\n", argv[0] );
         printf( "\n" );
         printf( "Valid wireless interfaces (detected) are:\n" );
 
         ONetwork::InterfaceIterator it = net->iterator();
         while ( it.current() )
         {
             if ( it.current()->isWireless() )
             {
                 printf( " - '%s' (MAC=%s) (IPv4=%s)\n", (const char*) it.current()->name(),
                                                     (const char*) it.current()->macAddress().toString(),
                                                     (const char*) it.current()->ipV4Address() );
             }
             ++it;
         }
     exit( -1 );
     }
 
     printf( "****************************************************\n" );
     printf( "* Wellenreiter mini edition 1.0 (C) 2003 M-M-M *\n" );
     printf( "****************************************************\n" );
     printf( "\n\n" );
 
     QString interface( argv[1] );
     QString driver( argv[2] );
 
     printf( "Trying to use '%s' as %s-controlled device...\n", (const char*) interface, (const char*) driver );
 
     // sanity checks before downcasting
     ONetworkInterface* iface = net->interface( interface );
     if ( !iface )
     {
         printf( "Interface '%s' doesn't exist. Exiting.\n", (const char*) interface );
         exit( -1 );
     }
     if ( !iface->isWireless() )
     {
         printf( "Interface '%s' doesn't support wireless extensions. Exiting.\n", (const char*) interface );
         exit( -1 );
     }
 
     // downcast should be safe now
     wiface = (OWirelessNetworkInterface*) iface;
     printf( "Using wireless interface '%s' for scanning (current SSID is '%s')...\n", (const char*) interface, (const char*) wiface->SSID() );
 
     // ifconfig +promisc the interface to receive all packets
     if ( !wiface->promiscuousMode() )
     {
         printf( "Interface status is not promisc... switching to promisc... " );
         wiface->setPromiscuousMode( true );
         if ( !wiface->promiscuousMode() )
         {
             printf( "failed (%s). Exiting.\n", strerror( errno ) );
             exit( -1 );
         }
         else
         {
             printf( "ok.\n" );
         }
     }
     else
         printf( "Interface status is already promisc - good.\n" );
 
     // connect a monitoring strategy to the interface
     if ( driver == "orinoco" )
-        new OOrinocoMonitoringInterface( wiface );
+        new OOrinocoMonitoringInterface( wiface, false );
     else
     {
         printf( "Unknown driver. Exiting\n" );
         exit( -1 );
     }
 
     // enable monitoring mode
     printf( "Enabling monitor mode...\n" );
     //wiface->setMonitorMode( true );
 
     // open a packet capturer
     cap = new OPacketCapturer();
     cap->open( interface );
     if ( !cap->isOpen() )
     {
         printf( "Unable to open libpcap (%s). Exiting.\n", strerror( errno ) );
         exit( -1 );
     }
 
     // set capturer to non-blocking mode
     cap->setBlocking( false );
 
     // start channel hopper
     //wiface->setChannelHopping( 1000 );
 
     // connect
     connect( cap, SIGNAL( receivedPacket(OPacket*) ), this, SLOT( receivePacket(OPacket*) ) );
 
   }
 
   ~Wellenreiter() {};
 
 public slots:
   void receivePacket(OPacket* p)
   {
     if (!p)
     {
         printf( "(empty packet received)\n" );
         return;
     }
 
     OWaveLanManagementPacket* beacon = (OWaveLanManagementPacket*) p->child( "802.11 Management" );
     if ( beacon )
     {
         OWaveLanManagementSSID* ssid = static_cast<OWaveLanManagementSSID*>( p->child( "802.11 SSID" ) );
         QString essid = ssid ? ssid->ID() : "<unknown>";
 
         if ( stations.find( essid ) )
             stations[essid]->beacons++;
         else
         {
             printf( "found new network @ channel %d, SSID = '%s'\n", wiface->channel(), (const char*) essid );
             stations.insert( essid, new Station( "unknown", wiface->channel(),
             ((OWaveLanPacket*) beacon->parent())->usesWep() ) );
         }
         return;
     }
 
     OWaveLanDataPacket* data = (OWaveLanDataPacket*) p->child( "802.11 Data" );
     if ( data )
     {
         OWaveLanPacket* wlan = (OWaveLanPacket*) p->child( "802.11" );
         if ( wlan->fromDS() && !wlan->toDS() )
         {
             printf( "FromDS: '%s' -> '%s' via '%s'\n",
                 (const char*) wlan->macAddress3().toString(true),
                 (const char*) wlan->macAddress1().toString(true),
                 (const char*) wlan->macAddress2().toString(true) );
         }
         else
         if ( !wlan->fromDS() && wlan->toDS() )
         {
             printf( "ToDS: '%s' -> '%s' via '%s'\n",
                 (const char*) wlan->macAddress2().toString(true),
                 (const char*) wlan->macAddress3().toString(true),
                 (const char*) wlan->macAddress1().toString(true) );
         }
         else
         if ( wlan->fromDS() && wlan->toDS() )
         {
             printf( "WSD(bridge): '%s' -> '%s' via '%s' and '%s'\n",
                 (const char*) wlan->macAddress4().toString(true),
                 (const char*) wlan->macAddress3().toString(true),
                 (const char*) wlan->macAddress1().toString(true),
                 (const char*) wlan->macAddress2().toString(true) );
         }
         else
         {
             printf( "IBSS(AdHoc): '%s' -> '%s' (Cell: '%s')'\n",
                 (const char*) wlan->macAddress2().toString(true),
                 (const char*) wlan->macAddress1().toString(true),
                 (const char*) wlan->macAddress3().toString(true) );
         }
         return;
     }
   }
 private:
   OPacketCapturer* cap;
   OWirelessNetworkInterface* wiface;
 };
 
 
 int main( int argc, char** argv )
 {
     Wellenreiter w( argc, argv );
     w.exec();
     return 0;
 }
 
 #include "miniwellenreiter.moc"
 
diff --git a/libopie2/opienet/opcap.cpp b/libopie2/opienet/opcap.cpp
index f6d05ea..523be3e 100644
--- a/libopie2/opienet/opcap.cpp
+++ b/libopie2/opienet/opcap.cpp
@@ -425,633 +425,633 @@ OWaveLanPacket::OWaveLanPacket( const unsigned char* end, const struct ieee_802_
     qDebug( "MAC4: %s", (const char*) macAddress4().toString() );
 
     switch ( type() )
     {
         case T_MGMT: new OWaveLanManagementPacket( end, (const struct ieee_802_11_mgmt_header*) data, this ); break;
         case T_DATA: new OWaveLanDataPacket( end, (const struct ieee_802_11_data_header*) data, this ); break;
         case T_CTRL: new OWaveLanControlPacket( end, (const struct ieee_802_11_control_header*) data, this ); break;
         default: qDebug( "OWaveLanPacket::OWaveLanPacket(): Warning: Unknown major type '%d'!", type() );
     }
 }
 
 OWaveLanPacket::~OWaveLanPacket()
 {
 }
 
 
 int OWaveLanPacket::duration() const
 {
     return _wlanhdr->duration;
 }
 
 
 OMacAddress OWaveLanPacket::macAddress1() const
 {
     return OMacAddress( _wlanhdr->mac1 );
 }
 
 
 OMacAddress OWaveLanPacket::macAddress2() const
 {
     return OMacAddress( _wlanhdr->mac2 );
 }
 
 
 OMacAddress OWaveLanPacket::macAddress3() const
 {
     return OMacAddress( _wlanhdr->mac3 );
 }
 
 
 OMacAddress OWaveLanPacket::macAddress4() const
 {
     return OMacAddress( _wlanhdr->mac4 );
 }
 
 
 int OWaveLanPacket::subType() const
 {
     return FC_SUBTYPE( EXTRACT_LE_16BITS( &_wlanhdr->frame_control ) );
 }
 
 
 int OWaveLanPacket::type() const
 {
     return FC_TYPE( EXTRACT_LE_16BITS( &_wlanhdr->frame_control ) );
 }
 
 
 int OWaveLanPacket::version() const
 {
     return FC_VERSION( EXTRACT_LE_16BITS( &_wlanhdr->frame_control ) );
 }
 
 
 bool OWaveLanPacket::fromDS() const
 {
     return FC_FROM_DS( EXTRACT_LE_16BITS( &_wlanhdr->frame_control ) );
 }
 
 
 bool OWaveLanPacket::toDS() const
 {
     return FC_TO_DS( EXTRACT_LE_16BITS( &_wlanhdr->frame_control ) );
 }
 
 
 bool OWaveLanPacket::usesPowerManagement() const
 {
     return FC_POWER_MGMT( EXTRACT_LE_16BITS( &_wlanhdr->frame_control ) );
 }
 
 
 bool OWaveLanPacket::usesWep() const
 {
     return FC_WEP( EXTRACT_LE_16BITS( &_wlanhdr->frame_control ) );
 }
 
 
 /*======================================================================================
  * OWaveLanManagementPacket
  *======================================================================================*/
 
 OWaveLanManagementPacket::OWaveLanManagementPacket( const unsigned char* end, const struct ieee_802_11_mgmt_header* data, OWaveLanPacket* parent )
                 :QObject( parent, "802.11 Management" ), _header( data ),
                 _body( (const struct ieee_802_11_mgmt_body*) (data+1) )
 {
     qDebug( "OWaveLanManagementPacket::OWaveLanManagementPacket(): decoding frame..." );
     qDebug( "Detected subtype is '%s'", (const char*) managementType() );
 
     // grab tagged values
     const unsigned char* ptr = (const unsigned char*) (_body+1);
     while (ptr < end)
     {
         switch ( *ptr )
         {
             case E_SSID: new OWaveLanManagementSSID( end, (struct ssid_t*) ptr, this ); break;
             case E_FH: new OWaveLanManagementFH( end, (struct fh_t*) ptr, this ); break;
             case E_DS: new OWaveLanManagementDS( end, (struct ds_t*) ptr, this ); break;
             case E_RATES: new OWaveLanManagementRates( end, (struct rates_t*) ptr, this ); break;
             case E_CF: new OWaveLanManagementCF( end, (struct cf_t*) ptr, this ); break;
             case E_TIM: new OWaveLanManagementTim( end, (struct tim_t*) ptr, this ); break;
             case E_IBSS: new OWaveLanManagementIBSS( end, (struct ibss_t*) ptr, this ); break;
             case E_CHALLENGE: new OWaveLanManagementChallenge( end, (struct challenge_t*) ptr, this ); break;
         }
         ptr+= ( ( struct ssid_t* ) ptr )->length; // skip length of tagged value
         ptr+= 2; // skip tag ID and length
     }
 }
 
 
 OWaveLanManagementPacket::~OWaveLanManagementPacket()
 {
 }
 
 
 QString OWaveLanManagementPacket::managementType() const
 {
     switch ( FC_SUBTYPE( EXTRACT_LE_16BITS( &_header->fc ) ) )
     {
         case ST_ASSOC_REQUEST: return "AssociationRequest"; break;
         case ST_ASSOC_RESPONSE: return "AssociationResponse"; break;
         case ST_REASSOC_REQUEST: return "ReassociationRequest"; break;
         case ST_REASSOC_RESPONSE: return "ReassociationResponse"; break;
         case ST_PROBE_REQUEST: return "ProbeRequest"; break;
         case ST_PROBE_RESPONSE: return "ProbeResponse"; break;
         case ST_BEACON: return "Beacon"; break;
         case ST_ATIM: return "Atim"; break;
         case ST_DISASSOC: return "Disassociation"; break;
         case ST_AUTH: return "Authentication"; break;
         case ST_DEAUTH: return "Deathentication"; break;
         default:
             qWarning( "OWaveLanManagementPacket::managementType(): unhandled subtype %d", FC_SUBTYPE( EXTRACT_LE_16BITS( &_header->fc ) ) );
             return "Unknown";
     }
 }
 
 
 int OWaveLanManagementPacket::beaconInterval() const
 {
     return EXTRACT_LE_16BITS( &_body->beacon_interval );
 }
 
 
 int OWaveLanManagementPacket::capabilities() const
 {
     return EXTRACT_LE_16BITS( &_body->capability_info );
 }
 
 
 bool OWaveLanManagementPacket::canESS() const
 {
     return CAPABILITY_ESS( EXTRACT_LE_16BITS( &_body->capability_info ) );
 }
 
 
 bool OWaveLanManagementPacket::canIBSS() const
 {
     return CAPABILITY_IBSS( EXTRACT_LE_16BITS( &_body->capability_info ) );
 }
 
 
 bool OWaveLanManagementPacket::canCFP() const
 {
     return CAPABILITY_CFP( EXTRACT_LE_16BITS( &_body->capability_info ) );
 }
 
 
 bool OWaveLanManagementPacket::canCFP_REQ() const
 {
     return CAPABILITY_CFP_REQ( EXTRACT_LE_16BITS( &_body->capability_info ) );
 }
 
 
 bool OWaveLanManagementPacket::canPrivacy() const
 {
     return CAPABILITY_PRIVACY( EXTRACT_LE_16BITS( &_body->capability_info ) );
 }
 
 
 /*======================================================================================
  * OWaveLanManagementSSID
  *======================================================================================*/
 
 OWaveLanManagementSSID::OWaveLanManagementSSID( const unsigned char* end, const struct ssid_t* data, QObject* parent )
                 :QObject( parent, "802.11 SSID" ), _data( data )
 {
     qDebug( "OWaveLanManagementSSID()" );
 }
 
 
 OWaveLanManagementSSID::~OWaveLanManagementSSID()
 {
 }
 
 
 QString OWaveLanManagementSSID::ID() const
 {
     int length = _data->length;
     if ( length > 32 ) length = 32;
     char essid[length+1];
     memcpy( &essid, &_data->ssid, length );
     essid[length] = 0x0;
     return essid;
 }
 
 
 /*======================================================================================
  * OWaveLanManagementRates
  *======================================================================================*/
 
 OWaveLanManagementRates::OWaveLanManagementRates( const unsigned char* end, const struct rates_t* data, QObject* parent )
                 :QObject( parent, "802.11 Rates" ), _data( data )
 {
     qDebug( "OWaveLanManagementRates()" );
 }
 
 
 OWaveLanManagementRates::~OWaveLanManagementRates()
 {
 }
 
 /*======================================================================================
  * OWaveLanManagementCF
  *======================================================================================*/
 
 OWaveLanManagementCF::OWaveLanManagementCF( const unsigned char* end, const struct cf_t* data, QObject* parent )
                 :QObject( parent, "802.11 CF" ), _data( data )
 {
     qDebug( "OWaveLanManagementCF()" );
 }
 
 
 OWaveLanManagementCF::~OWaveLanManagementCF()
 {
 }
 
 /*======================================================================================
  * OWaveLanManagementFH
  *======================================================================================*/
 
 OWaveLanManagementFH::OWaveLanManagementFH( const unsigned char* end, const struct fh_t* data, QObject* parent )
                 :QObject( parent, "802.11 FH" ), _data( data )
 {
     qDebug( "OWaveLanManagementFH()" );
 }
 
 
 OWaveLanManagementFH::~OWaveLanManagementFH()
 {
 }
 
 /*======================================================================================
  * OWaveLanManagementDS
  *======================================================================================*/
 
 OWaveLanManagementDS::OWaveLanManagementDS( const unsigned char* end, const struct ds_t* data, QObject* parent )
                 :QObject( parent, "802.11 DS" ), _data( data )
 {
     qDebug( "OWaveLanManagementDS()" );
 }
 
 
 OWaveLanManagementDS::~OWaveLanManagementDS()
 {
 }
 
 
 int OWaveLanManagementDS::channel() const
 {
     return _data->channel;
 }
 
 /*======================================================================================
  * OWaveLanManagementTim
  *======================================================================================*/
 
 OWaveLanManagementTim::OWaveLanManagementTim( const unsigned char* end, const struct tim_t* data, QObject* parent )
                 :QObject( parent, "802.11 Tim" ), _data( data )
 {
     qDebug( "OWaveLanManagementTim()" );
 }
 
 
 OWaveLanManagementTim::~OWaveLanManagementTim()
 {
 }
 
 /*======================================================================================
  * OWaveLanManagementIBSS
  *======================================================================================*/
 
 OWaveLanManagementIBSS::OWaveLanManagementIBSS( const unsigned char* end, const struct ibss_t* data, QObject* parent )
                 :QObject( parent, "802.11 IBSS" ), _data( data )
 {
     qDebug( "OWaveLanManagementIBSS()" );
 }
 
 
 OWaveLanManagementIBSS::~OWaveLanManagementIBSS()
 {
 }
 
 /*======================================================================================
  * OWaveLanManagementChallenge
  *======================================================================================*/
 
 OWaveLanManagementChallenge::OWaveLanManagementChallenge( const unsigned char* end, const struct challenge_t* data, QObject* parent )
                 :QObject( parent, "802.11 Challenge" ), _data( data )
 {
     qDebug( "OWaveLanManagementChallenge()" );
 }
 
 
 OWaveLanManagementChallenge::~OWaveLanManagementChallenge()
 {
 }
 
 /*======================================================================================
  * OWaveLanDataPacket
  *======================================================================================*/
 
 OWaveLanDataPacket::OWaveLanDataPacket( const unsigned char* end, const struct ieee_802_11_data_header* data, OWaveLanPacket* parent )
                 :QObject( parent, "802.11 Data" ), _header( data )
 {
     qDebug( "OWaveLanDataPacket::OWaveLanDataPacket(): decoding frame..." );
 
     const unsigned char* payload = (const unsigned char*) data + sizeof( struct ieee_802_11_data_header );
 
     #warning The next line works for most cases, but can not be correct generally!
     if (!( ( (OWaveLanPacket*) this->parent())->duration() )) payload -= 6; // compensation for missing last address
 
     new OLLCPacket( end, (const struct ieee_802_11_802_2_header*) payload, this );
 }
 
 
 OWaveLanDataPacket::~OWaveLanDataPacket()
 {
 }
 
 
 /*======================================================================================
  * OLLCPacket
  *======================================================================================*/
 
 OLLCPacket::OLLCPacket( const unsigned char* end, const struct ieee_802_11_802_2_header* data, QObject* parent )
                 :QObject( parent, "802.11 LLC" ), _header( data )
 {
     qDebug( "OLLCPacket::OLLCPacket(): decoding frame..." );
 
     if ( !(_header->oui[0] || _header->oui[1] || _header->oui[2]) )
     {
         qDebug( "OLLCPacket::OLLCPacket(): contains an encapsulated Ethernet frame (type=%04X)", EXTRACT_16BITS( &_header->type ) );
 
         switch ( EXTRACT_16BITS( &_header->type ) ) // defined in linux/if_ether.h
         {
             case ETH_P_IP: new OIPPacket( end, (const struct iphdr*) (data+1), this ); break;
             case ETH_P_ARP: new OARPPacket( end, (const struct myarphdr*) (data+1), this ); break;
             default: qWarning( "OLLCPacket::OLLCPacket(): Unknown Encapsulation (type=%04X)", EXTRACT_16BITS( &_header->type ) );
         }
 
     }
 }
 
 
 OLLCPacket::~OLLCPacket()
 {
 }
 
 
 /*======================================================================================
  * OWaveLanControlPacket
  *======================================================================================*/
 
 OWaveLanControlPacket::OWaveLanControlPacket( const unsigned char* end, const struct ieee_802_11_control_header* data, OWaveLanPacket* parent )
-                :QObject( parent, "802.11 Data" ), _header( data )
+                :QObject( parent, "802.11 Control" ), _header( data )
 {
     qDebug( "OWaveLanControlPacket::OWaveLanDataControl(): decoding frame..." );
     //TODO: Implement this
 }
 
 
 OWaveLanControlPacket::~OWaveLanControlPacket()
 {
 }
 
 
 /*======================================================================================
  * OPacketCapturer
  *======================================================================================*/
 
 OPacketCapturer::OPacketCapturer( QObject* parent, const char* name )
                  :QObject( parent, name ), _name( QString::null ), _open( false ),
                  _pch( 0 ), _pcd( 0 ), _sn( 0 )
 {
 }
 
 
 OPacketCapturer::~OPacketCapturer()
 {
     if ( _open )
     {
         qDebug( "OPacketCapturer::~OPacketCapturer(): pcap still open, autoclosing." );
         close();
     }
 }
 
 
 void OPacketCapturer::setBlocking( bool b )
 {
     if ( pcap_setnonblock( _pch, 1-b, _errbuf ) != -1 )
     {
         qDebug( "OPacketCapturer::setBlocking(): blocking mode changed successfully." );
     }
     else
     {
         qDebug( "OPacketCapturer::setBlocking(): can't change blocking mode: %s", _errbuf );
     }
 }
 
 
 bool OPacketCapturer::blocking() const
 {
     int b = pcap_getnonblock( _pch, _errbuf );
     if ( b == -1 )
     {
         qDebug( "OPacketCapturer::blocking(): can't get blocking mode: %s", _errbuf );
         return -1;
     }
     return !b;
 }
 
 
 void OPacketCapturer::close()
 {
     if ( _open )
     {
         if ( _sn )
         {
             _sn->disconnect( SIGNAL( activated(int) ), this, SLOT( readyToReceive() ) );
             delete _sn;
         }
         if ( _pcd )
         {
             pcap_dump_close( _pcd );
             _pcd = 0;
         }
         pcap_close( _pch );
         _open = false;
     }
 
     qDebug( "OPacketCapturer::close() --- dumping capturing statistics..." );
     qDebug( "--------------------------------------------------" );
     for( QMap<QString,int>::Iterator it = _stats.begin(); it != _stats.end(); ++it )
         qDebug( "%s : %d", (const char*) it.key(), it.data() );
     qDebug( "--------------------------------------------------" );
 
 }
 
 
 int OPacketCapturer::dataLink() const
 {
     return pcap_datalink( _pch );
 }
 
 
 int OPacketCapturer::fileno() const
 {
     if ( _open )
     {
         return pcap_fileno( _pch );
     }
     else
     {
         return -1;
     }
 }
 
 OPacket* OPacketCapturer::next()
 {
     packetheaderstruct header;
     qDebug( "==> OPacketCapturer::next()" );
     const unsigned char* pdata = pcap_next( _pch, &header );
     qDebug( "<== OPacketCapturer::next()" );
     if ( _pcd )
         pcap_dump( (u_char*) _pcd, &header, pdata );
 
     if ( pdata && header.len )
     {
         OPacket* p = new OPacket( dataLink(), header, pdata, 0 );
         // packets shouldn't be inserted in the QObject child-parent hierarchy,
         // because due to memory constraints they will be deleted as soon
         // as possible - that is right after they have been processed
         // by emit() [ see below ]
         //TODO: make gathering statistics optional, because it takes time
         p->updateStats( _stats, const_cast<QObjectList*>( p->children() ) );
 
         return p;
     }
     else
     {
         qWarning( "OPacketCapturer::next() - no packet received!" );
         return 0;
     }
 }
 
 
 bool OPacketCapturer::open( const QString& name, const QString& filename )
 {
     if ( _open )
     {
         if ( name == _name )    // ignore opening an already openend device
         {
             return true;
         }
         else                    // close the last opened device
         {
             close();
         }
     }
 
     _name = name;
 
     // open libpcap
     pcap_t* handle = pcap_open_live( const_cast<char*>( (const char*) name ), 1024, 0, 0, &_errbuf[0] );
 
     if ( !handle )
     {
         qWarning( "OPacketCapturer::open(): can't open libpcap with '%s': %s", (const char*) name, _errbuf );
         return false;
     }
 
     qDebug( "OPacketCapturer::open(): libpcap [%s] opened successfully.", (const char*) name );
     _pch = handle;
     _open = true;
     _stats.clear();
 
     // in case we have an application object, create a socket notifier
     if ( qApp ) //TODO: I don't like this here...
     {
         _sn = new QSocketNotifier( fileno(), QSocketNotifier::Read );
         connect( _sn, SIGNAL( activated(int) ), this, SLOT( readyToReceive() ) );
     }
 
     // if requested, open a dump
     pcap_dumper_t* dump = pcap_dump_open( _pch, const_cast<char*>( (const char*) filename ) );
     if ( !dump )
     {
         qWarning( "OPacketCapturer::open(): can't open dump with '%s': %s", (const char*) filename, _errbuf );
         return false;
     }
     qDebug( "OPacketCapturer::open(): dump [%s] opened successfully.", (const char*) filename );
     _pcd = dump;
 
     return true;
 }
 
 
 bool OPacketCapturer::open( const QFile& file )
 {
     QString name = file.name();
 
     if ( _open )
     {
         close();
         if ( name == _name )    // ignore opening an already openend device
         {
             return true;
         }
         else                    // close the last opened device
         {
             close();
         }
     }
 
     _name = name;
 
     pcap_t* handle = pcap_open_offline( const_cast<char*>( (const char*) name ), &_errbuf[0] );
 
     if ( handle )
     {
         qDebug( "OPacketCapturer::open(): libpcap opened successfully." );
         _pch = handle;
         _open = true;
 
         // in case we have an application object, create a socket notifier
         if ( qApp )
         {
             _sn = new QSocketNotifier( fileno(), QSocketNotifier::Read );
             connect( _sn, SIGNAL( activated(int) ), this, SLOT( readyToReceive() ) );
         }
 
         return true;
     }
     else
     {
         qDebug( "OPacketCapturer::open(): can't open libpcap with '%s': %s", (const char*) name, _errbuf );
         return false;
     }
 
 }
 
 
 bool OPacketCapturer::isOpen() const
 {
     return _open;
 }
 
 
 void OPacketCapturer::readyToReceive()
 {
     qDebug( "OPacketCapturer::readyToReceive(): about to emit 'receivePacket(p)'" );
     OPacket* p = next();
     emit receivedPacket( p );
     // emit is synchronous - packet has been dealt with, now it's safe to delete
     delete p;
 }
 
 
 const QMap<QString,int>& OPacketCapturer::statistics() const
 {
     return _stats;
 }