1 files changed, 31 insertions, 11 deletions

diff --git a/libopie2/opienet/opcap.cpp b/libopie2/opienet/opcap.cpp
index bef9182..1de7124 100644
--- a/libopie2/opienet/opcap.cpp
+++ b/libopie2/opienet/opcap.cpp
@@ -843,160 +843,180 @@ 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::closeDumpFile()
+{
+    if ( _pcd )
+    {
+        pcap_dump_close( _pcd );
+        _pcd = 0;
+    }
+    pcap_close( _pch );
+}
+
+
 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;
+        closeDumpFile();
+    _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 );
 }
 
 
+void OPacketCapturer::dump( OPacket* p )
+{
+    if ( !_pcd )
+    {
+        qWarning( "OPacketCapturer::dump() - cannot dump without open capture file!" );
+        return;
+    }
+    pcap_dump( (u_char*) _pcd, &p->_hdr, p->_data );
+}
+
+
 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 )
+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;
 
     // 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
+    return true;
+}
+
+
+bool OPacketCapturer::openDumpFile( const QString& filename )
+{
     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;
         }