- add skeleton for the last missing parts in the 802.11 decoding framework

- fix huge memory leak in packet capturer
- add more fine granular 802.11 subtype handling

3 files changed, 104 insertions, 29 deletions

diff --git a/libopie2/opienet/802_11_user.h b/libopie2/opienet/802_11_user.h
index ffdcb93..f596bd8 100644
--- a/libopie2/opienet/802_11_user.h
+++ b/libopie2/opienet/802_11_user.h
@@ -210,96 +210,108 @@ struct ieee_802_11_frame_subtype_class {
 /* RESERVED 			0xF  */
 
 
 #define CTRL_PS_POLL	0xA
 #define CTRL_RTS	0xB
 #define CTRL_CTS	0xC
 #define CTRL_ACK	0xD
 #define CTRL_CF_END	0xE
 #define CTRL_END_ACK	0xF
 
 /*
  * Bits in the frame control field.
  */
 #define FC_VERSION(fc)		((fc) & 0x3)
 #define FC_TYPE(fc)		(((fc) >> 2) & 0x3)
 #define FC_SUBTYPE(fc)		(((fc) >> 4) & 0xF)
 #define FC_TO_DS(fc)		((fc) & 0x0100)
 #define FC_FROM_DS(fc)		((fc) & 0x0200)
 #define FC_MORE_FLAG(fc)	((fc) & 0x0400)
 #define FC_RETRY(fc)		((fc) & 0x0800)
 #define FC_POWER_MGMT(fc)	((fc) & 0x1000)
 #define FC_MORE_DATA(fc)	((fc) & 0x2000)
 #define FC_WEP(fc)		((fc) & 0x4000)
 #define FC_ORDER(fc)		((fc) & 0x8000)
 
 
 struct ieee_802_11_mgmt_header {
   u_int16_t fc;
   u_int16_t duration;
   u_int8_t  da[6];
   u_int8_t  sa[6];
   u_int8_t  bssid[6];
   u_int16_t seq_ctrl;
 };
 
 
 struct ieee_802_11_data_header {
 	u_int16_t	frame_control;
 	u_int16_t	duration;
 	u_int8_t	mac1[6];
 	u_int8_t	mac2[6];
 	u_int8_t	mac3[6];
 	u_int16_t	SeqCtl;
 	u_int8_t	mac4[6];
 //	u_int16_t	gapLen;
 //	u_int8_t	gap[8];
 };
 
+struct ieee_802_11_control_header {
+	u_int16_t	frame_control;
+	u_int16_t	duration;
+	u_int8_t	mac1[6];
+	u_int8_t	mac2[6];
+	u_int8_t	mac3[6];
+	u_int16_t	SeqCtl;
+	u_int8_t	mac4[6];
+//	u_int16_t	gapLen;
+//	u_int8_t	gap[8];
+};
+
 #define CAPABILITY_ESS(cap)     ((cap) & 0x0001)
 #define CAPABILITY_IBSS(cap)    ((cap) & 0x0002)
 #define CAPABILITY_CFP(cap)     ((cap) & 0x0004)
 #define CAPABILITY_CFP_REQ(cap) ((cap) & 0x0008)
 #define CAPABILITY_PRIVACY(cap) ((cap) & 0x0010)
 
 struct ssid_t {
   u_int8_t	element_id;
   u_int8_t	length;
   u_char		ssid[33];  /* 32 + 1 for null */
 };
 
 
 struct rates_t {
   u_int8_t	element_id;
   u_int8_t	length;
   u_int8_t	rate[8];
 };
 
 
 struct challenge_t {
   u_int8_t	element_id;
   u_int8_t	length;
   u_int8_t	text[254]; /* 1-253 + 1 for null */
 };
 
 
 struct fh_t {
   u_int8_t	element_id;
   u_int8_t	length;
   u_int16_t	dwell_time;
   u_int8_t	hop_set;
   u_int8_t 	hop_pattern;
   u_int8_t	hop_index;
 };
 
 
 struct ds_t {
   u_int8_t	element_id;
   u_int8_t	length;
   u_int8_t	channel;
 };
 
 
 struct cf_t {
   u_int8_t	element_id;
   u_int8_t	length;
   u_int8_t	count;
@@ -317,96 +329,100 @@ struct tim_t {
   u_int8_t	bitmap_control;
   u_int8_t	bitmap[251];
 };
 
 
 struct ibss_t {
   u_int8_t	element_id;
   u_int8_t	length;
   u_int16_t	atim_window;
 };
 
 
 #define E_SSID      0
 #define E_RATES     1
 #define E_FH        2
 #define E_DS        3
 #define E_CF        4
 #define E_TIM       5
 #define E_IBSS      6
 #define E_CHALLENGE 16
 #define E_CISCO     133
 
 
 struct ieee_802_11_mgmt_body {
   u_int8_t  timestamp[8];
   u_int16_t beacon_interval;
 //  u_int16_t 	listen_interval;
 //  u_int16_t 	status_code;
 //  u_int16_t 	aid;
 //  u_char		ap[6];
 //  u_int16_t	reason_code;
 //  u_int16_t	auth_alg;
 //  u_int16_t	auth_trans_seq_num;
 //  struct challenge_t  challenge;
   u_int16_t capability_info;
 //  struct ssid_t	ssid;
 //  struct rates_t 	rates;
 //  struct ds_t	ds;
 //  struct cf_t	cf;
 //  struct fh_t	fh;
 //  struct tim_t	tim;
 };
 
 
 struct ieee_802_11_data_body {
 //FIXME
 };
 
+struct ieee_802_11_control_body {
+//FIXME
+};
+
 struct ctrl_rts_t {
   u_int16_t	fc;
   u_int16_t	duration;
   u_int8_t	ra[6];
   u_int8_t	ta[6];
   u_int8_t	fcs[4];
 };
 
 #define CTRL_RTS_LEN	(2+2+6+6+4)
 
 struct ctrl_cts_t {
   u_int16_t	fc;
   u_int16_t	duration;
   u_int8_t	ra[6];
   u_int8_t	fcs[4];
 };
 
 #define CTRL_CTS_LEN	(2+2+6+4)
 
 struct ctrl_ack_t {
   u_int16_t	fc;
   u_int16_t	duration;
   u_int8_t	ra[6];
   u_int8_t	fcs[4];
 };
 
 #define CTRL_ACK_LEN	(2+2+6+4)
 
 struct ctrl_ps_poll_t {
   u_int16_t	fc;
   u_int16_t	aid;
   u_int8_t	bssid[6];
   u_int8_t	ta[6];
   u_int8_t	fcs[4];
 };
 
 #define CTRL_PS_POLL_LEN	(2+2+6+6+4)
 
 struct ctrl_end_t {
   u_int16_t	fc;
   u_int16_t	duration;
   u_int8_t	ra[6];
   u_int8_t	bssid[6];
   u_int8_t	fcs[4];
 };
 
 #define CTRL_END_LEN	(2+2+6+6+4)
 
diff --git a/libopie2/opienet/opcap.cpp b/libopie2/opienet/opcap.cpp
index 40aac2c..5c464cf 100644
--- a/libopie2/opienet/opcap.cpp
+++ b/libopie2/opienet/opcap.cpp
@@ -1,126 +1,125 @@
 /*
                              This file is part of the Opie Project
                              Copyright (C) 2003 by the Wellenreiter team:
                              Martin J. Muench <mjm@remote-exploit.org>
                              Max Moser <mmo@remote-exploit.org
                              Michael 'Mickey' Lauer <mickey@tm.informatik.uni-frankfurt.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; either version 2 of the License,
      ._= =}       :          or (at your option) any later version.
     .%`+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/opcap.h>
 
 /* QT */
 
 #include <qapplication.h> // don't use oapplication here (will decrease reusability in other projects)
 #include <qsocketnotifier.h>
 
 /*======================================================================================
  * OPacket
  *======================================================================================*/
 
-OPacket::OPacket( packetheaderstruct header, const unsigned char* data, QObject* parent )
+OPacket::OPacket( int datalink, packetheaderstruct header, const unsigned char* data, QObject* parent )
         :QObject( parent, "Generic" ), _hdr( header ), _data( data )
 {
-    qDebug( "OPacket::OPacket(): (Len %d, CapLen %d)" /*, ctime((const time_t*) header.ts.tv_sec)*/, header.len, header.caplen );
+    //qDebug( "OPacket::OPacket(): (Len %d, CapLen %d)" /*, ctime((const time_t*) header.ts.tv_sec)*/, header.len, header.caplen );
 
     _end = (unsigned char*) data + header.len;
-    qDebug( "OPacket::data @ %0x, end @ %0x", data, _end );
+    //qDebug( "OPacket::data @ %0x, end @ %0x", data, _end );
 
-    if ( packetCapturer()->dataLink() == DLT_EN10MB )
+    switch ( datalink )
     {
+        case DLT_EN10MB:
         qDebug( "OPacket::OPacket(): Received Packet. Datalink = ETHERNET" );
         new OEthernetPacket( _end, (const struct ether_header*) data, this );
-    }
-    else
-    {
+            break;
+
+        case DLT_IEEE802_11:
         qDebug( "OPacket::OPacket(): Received Packet. Datalink = IEEE802.11" );
         new OWaveLanPacket( _end, (const struct ieee_802_11_header*) data, this );
+            break;
+
+        default:
+            qWarning( "OPacket::OPacket(): Received Packet over unsupported datalink '%s'!", datalink );
     }
 }
 
 
 OPacket::~OPacket()
 {
 }
 
 
-OPacketCapturer* OPacket::packetCapturer() const
-{
-    return parent()->inherits( "OPacketCapturer" ) ? static_cast<OPacketCapturer*>( parent() ) : 0;
-}
-
-
 timevalstruct OPacket::timeval() const
 {
     return _hdr.ts;
 }
 
 
 int OPacket::caplen() const
 {
     return _hdr.caplen;
 }
 
 
 QString OPacket::dump( int bpl ) const
 {
     static int index = 0;
     index++;
     int len = _hdr.caplen;
     QString str;
     str.sprintf( "\n<----- Packet #%04d Len = 0x%X (%d) ----->\n\n", index, len, len );
     str.append( "0000: " );
     QString tmp;
     QString bytes;
     QString chars;
 
     for ( int i = 0; i < len; ++i )
     {
         tmp.sprintf( "%02X ", _data[i] ); bytes.append( tmp );
         if ( (_data[i] > 31) && (_data[i]<128) ) chars.append( _data[i] );
         else chars.append( '.' );
 
         if ( !((i+1) % bpl) )
         {
             str.append( bytes );
             str.append( ' ' );
             str.append( chars );
             str.append( '\n' );
             tmp.sprintf( "%04X: ", i+1 ); str.append( tmp );
             bytes = "";
             chars = "";
         }
 
     }
     if ( (len % bpl) )
     {
         str.append( bytes.leftJustify( 1 + 3*bpl ) );
         str.append( chars );
     }
     str.append( '\n' );
@@ -271,232 +270,247 @@ int OIPPacket::checksum() const
 /*======================================================================================
  * OUDPPacket
  *======================================================================================*/
 
 
 OUDPPacket::OUDPPacket( const unsigned char* end, const struct udphdr* data, QObject* parent )
            :QObject( parent, "UDP" ), _udphdr( data )
 
 {
     qDebug( "OUDPPacket::OUDPPacket(): decoding UDP header..." );
 }
 
 OUDPPacket::~OUDPPacket()
 {
 }
 
 
 /*======================================================================================
  * OTCPPacket
  *======================================================================================*/
 
 
 OTCPPacket::OTCPPacket( const unsigned char* end, const struct tcphdr* data, QObject* parent )
            :QObject( parent, "TCP" ), _tcphdr( data )
 
 {
     qDebug( "OTCPPacket::OTCPPacket(): decoding TCP header..." );
 }
 
 OTCPPacket::~OTCPPacket()
 {
 }
 
 
 /*======================================================================================
  * OWaveLanPacket
  *======================================================================================*/
 
 
 OWaveLanPacket::OWaveLanPacket( const unsigned char* end, const struct ieee_802_11_header* data, QObject* parent )
                 :QObject( parent, "802.11" ), _wlanhdr( data )
 
 {
     qDebug( "OWaveLanPacket::OWaveLanPacket(): decoding IEEE 802.11 header..." );
     qDebug( "type: %0X", type() );
     qDebug( "subType: %0X", subType() );
     qDebug( "duration: %d", duration() );
     qDebug( "powermanagement: %d", usesPowerManagement() );
-    qDebug( "wep: %d", usesWep() );
+    qDebug( "payload is encrypted: %s", usesWep() ? "yes" : "no" );
     qDebug( "MAC1: %s", (const char*) macAddress1().toString() );
     qDebug( "MAC2: %s", (const char*) macAddress2().toString() );
     qDebug( "MAC3: %s", (const char*) macAddress3().toString() );
     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_ctrl_header*) data, this ); break;
-        default: qDebug( "OWaveLanPacket::OWaveLanPacket(): Warning: Unknown type!" );
+        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..." );
-
-    switch ( ((OWaveLanPacket*) this->parent() )->subType() )
-    {
-        case ST_BEACON:
-        {
-            // nice, received a beacon...
-        }
-    }
+    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 )
@@ -637,196 +651,225 @@ OWaveLanManagementChallenge::~OWaveLanManagementChallenge()
  *======================================================================================*/
 
 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;
             default: qDebug( "OLLCPacket::OLLCPacket(): Unknown Encapsulation 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 )
+{
+    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 ), _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;
         }
         pcap_close( _pch );
         _open = false;
     }
 }
 
 
 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 ( header.len )
-        return new OPacket( header, pdata, this );
+    {
+        return 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 ]
+    }
     else
+    {
         return 0;
 }
+}
 
 
 bool OPacketCapturer::open( const QString& name )
 {
     if ( _open )
     {
         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_live( const_cast<char*>( (const char*) name ), 1024, 0, 0, &_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: %s", _errbuf );
         return false;
     }
 
 }
 
 
 bool OPacketCapturer::isOpen() const
 {
     return _open;
 }
 
 
 void OPacketCapturer::readyToReceive()
 {
     qDebug( "OPacketCapturer::readyToReceive(): about to emit 'receivePacket(...)'" );
-    emit receivedPacket( next() );
+    OPacket* p = next();
+    emit receivedPacket( p );
+    // emit is synchronous - packet has been dealt with, now it's safe to delete
+    delete p;
 }
 
diff --git a/libopie2/opienet/opcap.h b/libopie2/opienet/opcap.h
index 04d22ff..ddef278 100644
--- a/libopie2/opienet/opcap.h
+++ b/libopie2/opienet/opcap.h
@@ -26,176 +26,176 @@
   -_. . .   )=.  =           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 OPCAP_H
 #define OPCAP_H
 
 /* LINUX */
 extern "C"  // work around a bpf/pcap conflict in recent headers
 {
     #include <pcap.h>
 }
 #include <netinet/ether.h>
 #include <netinet/ip.h>
 #include <netinet/udp.h>
 #include <netinet/tcp.h>
 #include <time.h>
 
 /* QT */
 #include <qhostaddress.h>
 #include <qobject.h>
 #include <qstring.h>
 
 /* OPIE */
 #include <opie2/onetutils.h>
 #include "802_11_user.h"
 
 /* TYPEDEFS */
 typedef struct timeval timevalstruct;
 typedef struct pcap_pkthdr packetheaderstruct;
 
 /* FORWARDS */
 class OPacketCapturer;
 class QSocketNotifier;
 
 /*======================================================================================
  * OPacket - A frame on the wire
  *======================================================================================*/
 
 class OPacket : public QObject
 {
   Q_OBJECT
 
   public:
-    OPacket( packetheaderstruct, const unsigned char*, QObject* parent );
+    OPacket( int datalink, packetheaderstruct, const unsigned char*, QObject* parent );
     virtual ~OPacket();
 
     timevalstruct timeval() const;
 
-    OPacketCapturer* packetCapturer() const;
-
     int caplen() const;
     int len() const;
     QString dump( int = 32 ) const;
 
   private:
     const packetheaderstruct _hdr;  // pcap packet header
     const unsigned char* _data;     // pcap packet data
     const unsigned char* _end;      // end of pcap packet data
 };
 
 /*======================================================================================
  * OEthernetPacket - DLT_EN10MB frame
  *======================================================================================*/
 
 class OEthernetPacket : public QObject
 {
   Q_OBJECT
 
   public:
     OEthernetPacket( const unsigned char*, const struct ether_header*, QObject* parent = 0 );
     virtual ~OEthernetPacket();
 
     OMacAddress sourceAddress() const;
     OMacAddress destinationAddress() const;
     int type() const;
 
   private:
     const struct ether_header* _ether;
 };
 
 
 /*======================================================================================
  * OWaveLanPacket - DLT_IEEE802_11 frame
  *======================================================================================*/
 
 class OWaveLanPacket : public QObject
 {
   Q_OBJECT
 
   public:
     OWaveLanPacket( const unsigned char*, const struct ieee_802_11_header*, QObject* parent = 0 );
     virtual ~OWaveLanPacket();
 
     int duration() const;
     bool fromDS() const;
     bool toDS() const;
     virtual OMacAddress macAddress1() const;
     virtual OMacAddress macAddress2() const;
     virtual OMacAddress macAddress3() const;
     virtual OMacAddress macAddress4() const;
     bool usesPowerManagement() const;
     int type() const;
     int subType() const;
     int version() const;
     bool usesWep() const;
 
   private:
     const struct ieee_802_11_header* _wlanhdr;
 };
 
 
 /*======================================================================================
  * OWaveLanManagementPacket - type: management (T_MGMT)
  *======================================================================================*/
 
 class OWaveLanManagementPacket : public QObject
 {
   Q_OBJECT
 
   public:
     OWaveLanManagementPacket( const unsigned char*, const struct ieee_802_11_mgmt_header*, OWaveLanPacket* parent = 0 );
     virtual ~OWaveLanManagementPacket();
 
+    QString managementType() const;
+
     int beaconInterval() const;
     int capabilities() const; // generic
 
     bool canESS() const;
     bool canIBSS() const;
     bool canCFP() const;
     bool canCFP_REQ() const;
     bool canPrivacy() const;
 
   private:
     const struct ieee_802_11_mgmt_header* _header;
     const struct ieee_802_11_mgmt_body* _body;
 };
 
 
 /*======================================================================================
  * OWaveLanManagementSSID
  *======================================================================================*/
 
 class OWaveLanManagementSSID : public QObject
 {
   Q_OBJECT
 
   public:
     OWaveLanManagementSSID( const unsigned char*, const struct ssid_t*, QObject* parent = 0 );
     virtual ~OWaveLanManagementSSID();
 
     QString ID() const;
 
   private:
     const struct ssid_t* _data;
 };
 
 /*======================================================================================
  * OWaveLanManagementRates
  *======================================================================================*/
 
 class OWaveLanManagementRates : public QObject
 {
   Q_OBJECT
 
   public:
     OWaveLanManagementRates( const unsigned char*, const struct rates_t*, QObject* parent = 0 );
     virtual ~OWaveLanManagementRates();
 
   private:
     const struct rates_t* _data;
 };
@@ -270,96 +270,112 @@ class OWaveLanManagementTim : public QObject
  * OWaveLanManagementIBSS
  *======================================================================================*/
 
 class OWaveLanManagementIBSS : public QObject
 {
   Q_OBJECT
 
   public:
     OWaveLanManagementIBSS( const unsigned char*, const struct ibss_t*, QObject* parent = 0 );
     virtual ~OWaveLanManagementIBSS();
 
   private:
     const struct ibss_t* _data;
 };
 
 /*======================================================================================
  * OWaveLanManagementChallenge
  *======================================================================================*/
 
 class OWaveLanManagementChallenge : public QObject
 {
   Q_OBJECT
 
   public:
     OWaveLanManagementChallenge( const unsigned char*, const struct challenge_t*, QObject* parent = 0 );
     virtual ~OWaveLanManagementChallenge();
 
   private:
     const struct challenge_t* _data;
 };
 
 /*======================================================================================
  * OWaveLanDataPacket - type: data (T_DATA)
  *======================================================================================*/
 
 class OWaveLanDataPacket : public QObject
 {
   Q_OBJECT
 
   public:
     OWaveLanDataPacket( const unsigned char*, const struct ieee_802_11_data_header*, OWaveLanPacket* parent = 0 );
     virtual ~OWaveLanDataPacket();
 
   private:
     const struct ieee_802_11_data_header* _header;
 };
 
 /*======================================================================================
+ * OWaveLanControlPacket - type: control (T_CTRL)
+ *======================================================================================*/
+
+class OWaveLanControlPacket : public QObject
+{
+  Q_OBJECT
+
+  public:
+    OWaveLanControlPacket( const unsigned char*, const struct ieee_802_11_control_header*, OWaveLanPacket* parent = 0 );
+    virtual ~OWaveLanControlPacket();
+
+  private:
+    const struct ieee_802_11_control_header* _header;
+};
+
+/*======================================================================================
  * OLLCPacket - IEEE 802.2 Link Level Control
  *======================================================================================*/
 
 class OLLCPacket : public QObject
 {
   Q_OBJECT
 
   public:
     OLLCPacket( const unsigned char*, const struct ieee_802_11_802_2_header* data, QObject* parent = 0 );
     virtual ~OLLCPacket();
 
   private:
     const struct ieee_802_11_802_2_header* _header;
 };
 
 /*======================================================================================
  * OIPPacket
  *======================================================================================*/
 
 class OIPPacket : public QObject
 {
   Q_OBJECT
 
   public:
     OIPPacket( const unsigned char*, const struct iphdr*, QObject* parent = 0 );
     virtual ~OIPPacket();
 
     QHostAddress fromIPAddress() const;
     QHostAddress toIPAddress() const;
 
     int tos() const;
     int len() const;
     int id() const;
     int offset() const;
     int ttl() const;
     int protocol() const;
     int checksum() const;
 
   private:
     const struct iphdr* _iphdr;
 };
 
 /*======================================================================================
  * OUDPPacket
  *======================================================================================*/
 
 class OUDPPacket : public QObject
 {