1 files changed, 16 insertions, 12 deletions

diff --git a/noncore/applets/wirelessapplet/networkinfo.cpp b/noncore/applets/wirelessapplet/networkinfo.cpp
index dc5c3be..22d7d83 100644
--- a/noncore/applets/wirelessapplet/networkinfo.cpp
+++ b/noncore/applets/wirelessapplet/networkinfo.cpp
@@ -151,117 +151,121 @@ void MWirelessNetworkInterface::updateStatistics()
 
         result = ioctl( fd, SIOCGIWNICKN, &iwr );
         if ( result == 0 )
         {
             iwr.u.data.pointer[(unsigned int) iwr.u.data.length-1] = '\0';
             nick = iwr.u.data.pointer;
         } else nick = "*** Unknown ***";
 
         result = ioctl( fd, SIOCGIWMODE, &iwr );
         if ( result == 0 )
             mode = ( iwr.u.mode == IW_MODE_ADHOC ) ? "Ad-Hoc" : "Managed";
         else mode = "*** Unknown ***";
 
         result = ioctl( fd, SIOCGIWFREQ, &iwr );
         if ( result == 0 )
             freq = double( iwr.u.freq.m ) * pow( 10, iwr.u.freq.e ) / 1000000000;
         else freq = 0;
 
     // gather link quality from /proc/net/wireless
 
     char c;
     QString status;
     QString name;
     QFile wfile( PROCNETWIRELESS );
-    wfile.open( IO_ReadOnly );
+    bool hasFile = wfile.open( IO_ReadOnly );
     QTextStream wstream( &wfile );
-    wstream.readLine();  // skip the first two lines
-    wstream.readLine();  // because they only contain headers
-
-    if ( wstream.atEnd() )
+    if ( hasFile )
+    {
+        wstream.readLine();  // skip the first two lines
+        wstream.readLine();  // because they only contain headers
+    }
+    if ( ( !hasFile ) || ( wstream.atEnd() ) )
     {
         qDebug( "WIFIAPPLET: D'oh! Someone removed the card..." );
         quality = -1;
         signal = IW_LOWER;
         noise = IW_LOWER;
         return;
     }
 
     wstream >> name >> status >> quality >> c >> signal >> c >> noise;
 
     if ( quality > 92 )
         qDebug( "WIFIAPPLET: D'oh! Quality %d > estimated max!\n", quality );
     if ( ( signal > IW_UPPER ) || ( signal < IW_LOWER ) )
         qDebug( "WIFIAPPLET: Doh! Strength %d > estimated max!\n", signal );
     if ( ( noise > IW_UPPER ) || ( noise < IW_LOWER ) )
         qDebug( "WIFIAPPLET: Doh! Noise %d > estimated max!\n", noise );
 }
 
 //---------------------------------------------------------------------------
 // class Network
 //
 
 MNetwork::MNetwork()
 {
-    qDebug( "MNetwork::MNetwork()" );
-    procfile = "/proc/net/dev";
+    //qDebug( "MNetwork::MNetwork()" );
+    procfile = PROCNETDEV;
 }
 
 MNetwork::~MNetwork()
 {
-    qDebug( "MNetwork::~MNetwork()" );
+    //qDebug( "MNetwork::~MNetwork()" );
 }
 
 //---------------------------------------------------------------------------
 // class WirelessNetwork
 //
 
 MWirelessNetwork::MWirelessNetwork()
 {
-    qDebug( "MWirelessNetwork::MWirelessNetwork()" );
-    procfile = "/proc/net/wireless";
+    //qDebug( "MWirelessNetwork::MWirelessNetwork()" );
+    procfile = PROCNETWIRELESS;
 }
 
 MWirelessNetwork::~MWirelessNetwork()
 {
-    qDebug( "MWirelessNetwork::~MWirelessNetwork()" );
+    //qDebug( "MWirelessNetwork::~MWirelessNetwork()" );
 }
 
 MNetworkInterface* MWirelessNetwork::createInterface( const char* n ) const
 {
     return new MWirelessNetworkInterface( n );
 }
 
 //---------------------------------------------------------------------------
 // class NetworkInterface
 //
 
 MNetworkInterface* MNetwork::getFirstInterface()
 {
     enumerateInterfaces();
     InterfaceMapIterator it( interfaces );
     return ( it.count() > 0 ) ? it.toFirst() : 0;
 }
 
 void MNetwork::enumerateInterfaces()
 {   
     interfaces.clear();
     QString str;
     QFile f( procfile );
-    f.open( IO_ReadOnly );
+    bool hasFile = f.open( IO_ReadOnly );
+    if ( !hasFile )
+        return;
     QTextStream s( &f );
     s.readLine();
     s.readLine();
     while ( !s.atEnd() )
     {
         s >> str;
         str.truncate( str.find( ':' ) );
         qDebug( "WIFIAPPLET: found interface '%s'", (const char*) str );
         interfaces.insert( str, createInterface( str ) );
         s.readLine();
     }
 }
 
 MNetworkInterface* MNetwork::createInterface( const char* n ) const
 {
     return new MNetworkInterface( n );
 }