add some more documentation

4 files changed, 30 insertions, 9 deletions

diff --git a/libopie2/examples/opienet/miniwellenreiter/miniwellenreiter.cpp b/libopie2/examples/opienet/miniwellenreiter/miniwellenreiter.cpp
index f800336..34d32d2 100644
--- a/libopie2/examples/opienet/miniwellenreiter/miniwellenreiter.cpp
+++ b/libopie2/examples/opienet/miniwellenreiter/miniwellenreiter.cpp
@@ -19,199 +19,199 @@ class 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 );
     else
     {
         printf( "Unknown driver. Exiting\n" );
         exit( -1 );
     }
 
     // enable monitoring mode
     printf( "Enabling monitor mode...\n" );
-    wiface->setMonitorMode( true );
+    //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 );
+    //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/onetwork.h b/libopie2/opienet/onetwork.h
index 2348bbc..f052317 100644
--- a/libopie2/opienet/onetwork.h
+++ b/libopie2/opienet/onetwork.h
@@ -20,343 +20,367 @@
     =_        +     =;=|`    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
 
 /* QT */
 
 #include <qvaluelist.h>
 #include <qdict.h>
 #include <qmap.h>
 #include <qobject.h>
 #include <qhostaddress.h>
 
 /* OPIE */
 
 #include <opie2/onetutils.h>
 
 #ifndef IFNAMSIZ
 #define IFNAMSIZ 16
 #endif
 #ifndef IW_MAX_PRIV_DEF
 #define IW_MAX_PRIV_DEF        128
 #endif
 
 // ML: Yeah, I hate to include kernel headers, but it's necessary here
 // ML: Here comes an ugly hack to prevent <linux/wireless.h> including <linux/if.h>
 // ML: which conflicts with the user header <net/if.h>
 // ML: We really need a user header for the Wireless Extensions, something like <net/wireless.h>
 // ML: I will drop Jean a mail on that subject
 
 #include <net/if.h>
 #define _LINUX_IF_H
 #include <linux/wireless.h>
 
 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@tm.informatik.uni-frankfurt.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 @p interface supports the wireless extension protocol.
      */
      // FIXME QString? -zecke
     bool isWirelessInterface( const char* interface ) const;
     /**
      * @returns a pointer to the @ref ONetworkInterface object for the specified @p interface or 0, if not found
      * @see ONetworkInterface
      */
      // FIXME: const QString& is prefered over QString!!! -zecke
     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 cardctl insert
+     * e.g. after issuing a cardctl insert
      */
     void synchronize();
 
   protected:
     ONetwork();
 
   private:
     static ONetwork* _instance;
     InterfaceMap _interfaces;
 };
 
 
 /*======================================================================================
  * 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@tm.informatik.uni-frankfurt.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;
     /**
      * Associate the MAC address @a addr with the interface.
      * @note It can be necessary to shut down the interface prior to calling this method.
      * @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;
     /**
      * @returns the data link type currently associated with the interface.
      * @see #include <net/if_arp.h> for possible values.
      */
     int dataLinkType() 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;
 };
 
 /*======================================================================================
  * 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@tm.informatik.uni-frankfurt.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;
-    virtual void timerEvent( QTimerEvent* );
-    void setInterval( int );
+    /**
+     * 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;
 };
 
 
 /*======================================================================================
  * 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.
  */
 class OWirelessNetworkInterface : public ONetworkInterface
 {
     friend class OMonitoringInterface;
     friend class OCiscoMonitoringInterface;
     friend class OWlanNGMonitoringInterface;
     friend class OHostAPMonitoringInterface;
     friend class OOrinocoMonitoringInterface;
 
     friend class OPrivateIOCTL;
 
   public:
     enum Mode { AdHoc, Managed, Monitor };
 
     /**
      * 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.
      */
     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;
     //virtual double frequency(int) const;
 
     virtual void setMode( Mode ) {}; //FIXME: Implement and document this
     virtual bool mode() const {}; //FIXME: Implement and document this
 
     /**
      * 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 void setMonitorMode( bool );
     /**
      * @returns true if the device is listening in IEEE 802.11 monitor mode
      */
     virtual bool monitorMode() 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 ) {}; //FIXME: Implement this
diff --git a/libopie2/opienet/opcap.h b/libopie2/opienet/opcap.h
index 83f7115..bee0ca0 100644
--- a/libopie2/opienet/opcap.h
+++ b/libopie2/opienet/opcap.h
@@ -60,408 +60,405 @@ extern "C"  // work around a bpf/pcap conflict in recent headers
 /* TYPEDEFS */
 typedef struct timeval timevalstruct;
 typedef struct pcap_pkthdr packetheaderstruct;
 
 /* FORWARDS */
 class OPacketCapturer;
 class QSocketNotifier;
 
 /*======================================================================================
  * OPacket - A frame on the wire
  *======================================================================================*/
 
 /** @brief A class representing a data frame on the wire.
  *
  * The whole family of the packet classes are used when capturing frames from a network.
  * Most standard network protocols in use share a common architecture, which mostly is
  * a packet header and then the packet payload. In layered architectures, each lower layer
  * encapsulates data from its upper layer - that is it
  * treats the data from its upper layer as payload and prepends an own header to the packet,
  * which - again - is treated as the payload for the layer below. The figure below is an
  * example for how such a data frame is composed out of packets, e.g. when sending a mail.
  *
  * <pre>
  *                                                       | User Data |     == Mail Data
  *                                         | SMTP Header | User Data |     == SMTP
  *                           | TCP Header  | SMTP Header | User Data |     == TCP
  *               | IP Header | TCP Header  | SMTP Header | User Data |     == IP
  *  | MAC Header | IP Header | TCP Header  | SMTP Header | User Data |     == MAC
  *
  * </pre>
  *
  * The example is trimmed for simplicity, because the MAC (Medium Access Control) layer
  * also contains a few more levels of encapsulation.
  * Since the type of the payload is more or less independent from the encapsulating protocol,
  * the header must be inspected before attempting to decode the payload. Hence, the
  * encapsulation level varies and can't be deduced without actually looking into the packets.
  *
  * For actually working with captured frames, it's useful to identify the packets via names and
  * insert them into a parent/child - relationship based on the encapsulation. This is why
  * all packet classes derive from QObject. The amount of overhead caused by the QObject is
  * not a problem in this case, because we're talking about a theoratical maximum of about
  * 10 packets per captured frame. We need to stuff them into a searchable list anyway and the
  * QObject also cares about destroying the sub-, (child-) packets.
  *
  * This enables us to perform a simple look for packets of a certain type:
  * @code
  * OPacketCapturer* pcap = new OPacketCapturer();
  * pcap->open( "eth0" );
  * OPacket* p = pcap->next();
  * OIPPacket* ip = (OIPPacket*) p->child( "IP" ); // returns 0, if no such child exists
  * odebug << "got ip packet from " << ip->fromIPAddress().toString() << " to " << ip->toIPAddress().toString() << oendl;
  *
  */
 
 class OPacket : public QObject
 {
   Q_OBJECT
 
   public:
     OPacket( int datalink, packetheaderstruct, const unsigned char*, QObject* parent );
     virtual ~OPacket();
 
     timevalstruct timeval() const;
 
     int caplen() const;
     int len() const;
     QString dump( int = 32 ) const;
 
     void updateStats( QMap<QString,int>&, QObjectList* );
 
   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;
 };
 
-
 /*======================================================================================
  * OPrismHeaderPacket - DLT_PRISM_HEADER frame
  *======================================================================================*/
 
 class OPrismHeaderPacket : public QObject
 {
   Q_OBJECT
 
   public:
     OPrismHeaderPacket( const unsigned char*, const struct prism_hdr*, QObject* parent = 0 );
     virtual ~OPrismHeaderPacket();
 
     unsigned int signalStrength() const;
 
   private:
     const struct prism_hdr* _header;
 };
 
-
 /*======================================================================================
  * 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;
 };
 
 /*======================================================================================
  * OWaveLanManagementCF
  *======================================================================================*/
 
 class OWaveLanManagementCF : public QObject
 {
   Q_OBJECT
 
   public:
     OWaveLanManagementCF( const unsigned char*, const struct cf_t*, QObject* parent = 0 );
     virtual ~OWaveLanManagementCF();
 
   private:
     const struct cf_t* _data;
 };
 
 /*======================================================================================
  * OWaveLanManagementFH
  *======================================================================================*/
 
 class OWaveLanManagementFH : public QObject
 {
   Q_OBJECT
 
   public:
     OWaveLanManagementFH( const unsigned char*, const struct fh_t*, QObject* parent = 0 );
     virtual ~OWaveLanManagementFH();
 
   private:
     const struct fh_t* _data;
 };
 
 /*======================================================================================
  * OWaveLanManagementDS
  *======================================================================================*/
 
 class OWaveLanManagementDS : public QObject
 {
   Q_OBJECT
 
   public:
     OWaveLanManagementDS( const unsigned char*, const struct ds_t*, QObject* parent = 0 );
     virtual ~OWaveLanManagementDS();
 
     int channel() const;
 
   private:
     const struct ds_t* _data;
 };
 
 /*======================================================================================
  * OWaveLanManagementTim
  *======================================================================================*/
 
 class OWaveLanManagementTim : public QObject
 {
   Q_OBJECT
 
   public:
     OWaveLanManagementTim( const unsigned char*, const struct tim_t*, QObject* parent = 0 );
     virtual ~OWaveLanManagementTim();
 
   private:
     const struct tim_t* _data;
 };
 
 /*======================================================================================
  * 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
  *======================================================================================*/
 
-// Qobject do we need that??
 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)
  *======================================================================================*/
-// Qobject?
+
 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
 {
   Q_OBJECT
 
   public:
     OUDPPacket( const unsigned char*, const struct udphdr*, QObject* parent = 0 );
     virtual ~OUDPPacket();
 
     int fromPort() const;
     int toPort() const;
 
   private:
     const struct udphdr* _udphdr;
 };
 
 /*======================================================================================
  * OTCPPacket
  *======================================================================================*/
 
 class OTCPPacket : public QObject
 {
diff --git a/libopie2/opieui/opieui.pro b/libopie2/opieui/opieui.pro
index 996e1a0..aa85955 100644
--- a/libopie2/opieui/opieui.pro
+++ b/libopie2/opieui/opieui.pro