OPacketCapturer is now able to write captured packages in the standard tcpdump-compatible format

2 files changed, 34 insertions, 17 deletions

diff --git a/libopie2/opienet/opcap.cpp b/libopie2/opienet/opcap.cpp
index 30f6208..04b1bb1 100644
--- a/libopie2/opienet/opcap.cpp
+++ b/libopie2/opienet/opcap.cpp
@@ -725,25 +725,25 @@ OWaveLanControlPacket::OWaveLanControlPacket( const unsigned char* end, const st
 
 OWaveLanControlPacket::~OWaveLanControlPacket()
 {
 }
 
 
 /*======================================================================================
  * OPacketCapturer
  *======================================================================================*/
 
 OPacketCapturer::OPacketCapturer( QObject* parent, const char* name )
                  :QObject( parent, name ), _name( QString::null ), _open( false ),
-                 _pch( 0 ), _sn( 0 )
+                 _pch( 0 ), _pcd( 0 ), _sn( 0 )
 {
 }
 
 
 OPacketCapturer::~OPacketCapturer()
 {
     if ( _open )
     {
         qDebug( "OPacketCapturer::~OPacketCapturer(): pcap still open, autoclosing." );
         close();
     }
 }
@@ -774,24 +774,29 @@ bool OPacketCapturer::blocking() const
 }
 
 
 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( "--------------------------------------------------" );
 
 }
 
@@ -811,84 +816,94 @@ int OPacketCapturer::fileno() const
     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 ( 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
     {
         return 0;
     }
 }
 
 
-bool OPacketCapturer::open( const QString& name )
+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 )
+    if ( !handle )
     {
-        qDebug( "OPacketCapturer::open(): libpcap opened successfully." );
-        _pch = handle;
-        _open = true;
-        _stats.clear();
+        qWarning( "OPacketCapturer::open(): can't open libpcap with '%s': %s", (const char*) name, _errbuf );
+        return false;
+    }
 
-        // 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() ) );
-        }
+    qDebug( "OPacketCapturer::open(): libpcap [%s] opened successfully.", (const char*) name );
+    _pch = handle;
+    _open = true;
+    _stats.clear();
 
-        return true;
+    // 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() ) );
     }
-    else
+
+    // if requested, open a dump
+    pcap_dumper_t* dump = pcap_dump_open( _pch, const_cast<char*>( (const char*) filename ) );
+    if ( !dump )
     {
-        qDebug( "OPacketCapturer::open(): can't open libpcap with '%s': %s", (const char*) name, _errbuf );
+        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
         {
diff --git a/libopie2/opienet/opcap.h b/libopie2/opienet/opcap.h
index 6c3ac6d..99631ba 100644
--- a/libopie2/opienet/opcap.h
+++ b/libopie2/opienet/opcap.h
@@ -461,45 +461,47 @@ class OPacketCapturer : public QObject
     /**
      * @returns the filedescriptor of the packet capturer. This is only useful, if
      * not using the socket notifier, e.g. without an application object.
      */
     int fileno() const;
     /**
      * @returns the next @ref OPacket from the packet capturer.
      * @note If blocking mode is true then this call might block.
      */
     OPacket* next();
     /**
      * Open the packet capturer to capture packets in live-mode from @a interface.
+     * If a @a filename is given, all captured packets are output to a tcpdump-compatible capture file.
      */
-    bool open( const QString& interface );
+    bool open( const QString& interface, const QString& filename = QString::null );
     /**
      * Open the packet capturer to capture packets in offline-mode from @a file.
      */
     bool open( const QFile& file );
     /**
      * @returns true if the packet capturer is open
      */
     bool isOpen() const;
 
     const QMap<QString,int>& statistics() const;
 
   signals:
     /**
      * This signal is emitted, when a packet has been received.
      */
     void receivedPacket( OPacket* );
 
   protected slots:
     void readyToReceive();
 
   protected:
     QString _name;                                  // devicename
     bool _open;                                     // check this before doing pcap calls
     pcap_t* _pch;                                   // pcap library handle
+    pcap_dumper_t* _pcd;                            // pcap dumper handle
     QSocketNotifier* _sn;                           // socket notifier for main loop
     mutable char _errbuf[PCAP_ERRBUF_SIZE];         // holds error strings from libpcap
     QMap<QString, int> _stats;                      // statistics;
 };
 
 #endif // OPCAP_H