5 files changed, 77 insertions, 58 deletions

diff --git a/noncore/settings/networksettings2/main.cpp b/noncore/settings/networksettings2/main.cpp
index 200e31b..9004d19 100644
--- a/noncore/settings/networksettings2/main.cpp
+++ b/noncore/settings/networksettings2/main.cpp
@@ -1,147 +1,151 @@
 #include "nsdata.h"
 #include "activateprofile.h"
 #include "activatevpn.h"
 #include "networksettings.h"
 
 #include <qpe/qpeapplication.h>
 
 #include <opie2/oapplicationfactory.h>
 using namespace Opie::Core;
 
 #ifdef GONE
 
 OPIE_EXPORT_APP( OApplicationFactory<NetworkSettings> )
 
 #else
 
 // just standard GUI
 #define ACT_GUI         0
 // used by interfaces to request for allow of up/down
 #define ACT_REQUEST     1
 // regenerate config files
 #define ACT_REGEN       2
 // used by interfaces to request user prompt 
 #define ACT_PROMPT      3
 // used by interfaces to trigger VPN
 #define ACT_VPN         4
 
 int main( int argc, char * argv[] ) {
         int rv = 0;
         int Action = ACT_GUI;
         // could be overruled by -qws
         QApplication::Type GuiType = QApplication::GuiClient; 
 
 #ifdef _WS_QWS_
         QPEApplication * TheApp;
 #else
         QApplication * TheApp;
 #endif
 
         for ( int i = 1; i < argc; i ++ ) {
           int rmv;
           rmv = 0;
           if( strcmp( argv[i], "--regen" ) == 0 ) {
             Action = ACT_REGEN;
             GuiType = QApplication::Tty;
             rmv = 1;
           } else if( strcmp( argv[i], "--prompt" ) == 0 ) {
             Action = ACT_PROMPT;
             rmv = 1;
           } else if( strcmp( argv[i], "--triggervpn" ) == 0 ) {
             Action = ACT_VPN;
             rmv = 1;
           }
           if( rmv ) {
             memmove( argv+i, argv+i+rmv, 
                 sizeof( char * ) * (argc-i-rmv) );
             i --;
             argc -= rmv;
           }
         }
 
         if( strstr( argv[0], "-request" ) ) {
           // called from system to request something
           GuiType = QApplication::Tty;
           Action = ACT_REQUEST;
           Log(("Request : %s\n", argv[1] ));
         }
 
         // Start Qt
 #ifdef _WS_QWS_
         // because QPEApplication does not handle GuiType well
         if( GuiType == QApplication::Tty ) {
           // this cast is NOT correct but we do not use
           // TheApp anymore ...
           TheApp = (QPEApplication *)new QApplication( argc, argv, GuiType );
         } else {
           TheApp = new QPEApplication( argc, argv, GuiType );
         }
 #else
         TheApp = new QApplication( argc, argv, GuiType );
 #endif
 
         // init qt with app widget
 
         switch( Action ) {
           case ACT_REQUEST :
             { NetworkSettingsData NS;
               if( NS.canStart( argv[1] ) ) {
                 QString S;
                 S.sprintf( QPEApplication::qpeDir()+
                            "/bin/networksettings2" );
                 char * MyArgv[4];
                 MyArgv[0] = "networksettings2";
                 MyArgv[1] = "--prompt";
                 MyArgv[2] = argv[1];
                 MyArgv[3] = NULL;
                 NSResources->system().execAsUser( S, MyArgv );
+                Log(("FAILED %s-cNN-allowed\n", argv[1] ));
                 // if we come here , failed
                 printf( "%s-cNN-disallowed", argv[1] );
               }
             }
             break;
           case ACT_REGEN :
             { NetworkSettingsData NS;
               // regen returns 0 if OK
               rv = (NS.regenerate()) ? 1 : 0;
             }
             break;
           case ACT_PROMPT :
             { ActivateProfile AP(argv[1]);
               if( AP.exec() == QDialog::Accepted ) {
+                Log(("%s-c%ld-allowed\n", 
+                    argv[1], AP.selectedProfile() ));
                 printf( "%s-c%ld-allowed", argv[1], AP.selectedProfile() );
               } else {
+                Log(("%s-c%NN-disallowed\n", argv[1] ));
                 printf( "%s-cNN-disallowed", argv[1] );
               }
             }
             break;
           case ACT_VPN :
             { ActivateVPN AVPN;
               AVPN.exec();
             }
             break;
           case ACT_GUI :
             { QWidget * W = new NetworkSettings(0);
               TheApp->setMainWidget( W ); 
               W->show();
 #ifdef _WS_QWS_
               W->showMaximized();
 #else
               W->resize( W->sizeHint() );
 #endif
               rv = TheApp->exec();
               delete W;
             }
             break;
         }
 
         LogClose();
 
         return rv;
 }
 
 #endif
 
 
 // main.cpp
 
diff --git a/noncore/settings/networksettings2/network/network_NN.cpp b/noncore/settings/networksettings2/network/network_NN.cpp
index 1feffdb..b5c41bf 100644
--- a/noncore/settings/networksettings2/network/network_NN.cpp
+++ b/noncore/settings/networksettings2/network/network_NN.cpp
@@ -1,82 +1,85 @@
+#include <qpe/qpeapplication.h>
 #include <asdevice.h>
 #include "network_NN.h"
 #include "network_NNI.h"
 
 static const char * NetworkNeeds[] = 
     { "device", 
       0
     };
 
 /**
  * Constructor, find all of the possible interfaces
  */
 NetworkNetNode::NetworkNetNode() : ANetNode(tr("IP Configuration")) {
 }
 
 /**
  * Delete any interfaces that we own.
  */
 NetworkNetNode::~NetworkNetNode(){
 }
 
 const QString NetworkNetNode::nodeDescription(){
       return tr("\
 <p>Sets up TCP/IP options.</p>\
 <p>Use this to configure the TCP/IP protocol</p>\
 "
 );
 }
 
 ANetNodeInstance * NetworkNetNode::createInstance( void ) {
       return new ANetwork( this );
 }
 
 bool NetworkNetNode::hasDataForFile( const QString & S ) {
       return S == "interfaces";
 }
 
 short NetworkNetNode::generateFile( const QString & ID,
                                    const QString & ,
                                    QTextStream & TS, 
                                    ANetNodeInstance * NNI,
                                    long DevNr ) {
                                    
       QString NIC = NNI->runtime()->device()->netNode()->nodeClass()->genNic( DevNr );
 
       if( ID == "interfaces" ) {
         Log(("Generate entry for %s in %s\n", NIC.latin1(), ID.latin1() ));
         // generate mapping stanza for this interface
         TS << "# check if " 
            << NIC 
            << " can be brought UP" 
            << endl;
         TS << "mapping " 
            << NIC 
            << endl;
-        TS << "  script networksettings2-request" 
+        TS << "  script "
+           << QPEApplication::qpeDir()
+           << "/bin/networksettings2-request" 
            << endl 
            << endl;
         return 0;
       }
       return 1;
 }
 
 const char ** NetworkNetNode::needs( void ) {
       return NetworkNeeds;
 }
 
 const char * NetworkNetNode::provides( void ) {
       return "connection";
 }
 
 void NetworkNetNode::setSpecificAttribute( QString & , QString & ) {
 }
 
 void NetworkNetNode::saveSpecificAttribute( QTextStream & ) {
 }
 
 extern "C" {
 void create_plugin( QList<ANetNode> & PNN ) {
       PNN.append( new NetworkNetNode() );
 }
 }
diff --git a/noncore/settings/networksettings2/networksettings2/resources.cpp b/noncore/settings/networksettings2/networksettings2/resources.cpp
index 7ece817..2f17693 100644
--- a/noncore/settings/networksettings2/networksettings2/resources.cpp
+++ b/noncore/settings/networksettings2/networksettings2/resources.cpp
@@ -1,453 +1,450 @@
 #include <unistd.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <pwd.h>
 #include <qpixmap.h>
 #include <qdir.h>
 #include <qpe/qlibrary.h>
 #include <qpe/qpeapplication.h>
 #include <opie2/odebug.h>
 #include <qtopia/resource.h>
 
 #include "netnode.h"
 #include "resources.h"
 
 #define PLUGINDIR "plugins/networksettings2"
 #define ICONDIR "/pics/networksettings2/"
 
 // single resources instance
 TheNSResources * _NSResources = 0;
 
 TheNSResources::TheNSResources( void ) : NodeTypeNameMap(),
         ConnectionsMap() {
 
     _NSResources = this;
 
     detectCurrentUser();
 
     // load available netnodes
     findAvailableNetNodes(QPEApplication::qpeDir() + PLUGINDIR );
 
     // compile provides and needs lists
     { const char ** NeedsRun;
       QDictIterator<NetNode_t> OuterIt( AllNodeTypes );
       bool Done;
 
       for ( ; OuterIt.current(); ++OuterIt ) {
         // find needs list
         ANetNode::NetNodeList * NNLP = new ANetNode::NetNodeList;
         ANetNode::NetNodeList & NNL = *(NNLP);
 
         // must iterate this way to avoid duplication pointers
         for ( QDictIterator<NetNode_t> InnerIt( AllNodeTypes );
               InnerIt.current(); ++InnerIt ) {
           if( InnerIt.current() == OuterIt.current() )
             // avoid recursive 
             continue;
 
           const char * Provides = InnerIt.current()->NetNode->provides();
           NeedsRun = OuterIt.current()->NetNode->needs();
           for( ; *NeedsRun; NeedsRun ++ ) {
             if( strcmp( Provides, *NeedsRun ) == 0 ) {
               // inner provides what outer needs
               NNL.resize( NNL.size() + 1 );
               NNL[NNL.size()-1] = InnerIt.current()->NetNode;
               Done = 1; // break from 2 loops
               break;
             }
           }
         }
         OuterIt.current()->NetNode->setAlternatives( NNLP );
       }
     }
 
     // define Node types to Description map
     NodeTypeNameMap.insert( "device", tr( "Network Device" ) );
     NodeTypeNameMap.insert( "line", tr( "Character device" ) );
     NodeTypeNameMap.insert( "connection", tr( "IP Connection" ) );
     NodeTypeNameMap.insert( "fullsetup", tr( "Connection Profile" ) );
 
     NodeTypeDescriptionMap.insert( "device", 
         tr( "<p>Devices that can handle IP packets</p>" ) );
     NodeTypeDescriptionMap.insert( "line", 
         tr( "<p>Devices that can handle single bytes</p>" ) );
     NodeTypeDescriptionMap.insert( "connection", 
         tr( "<p>Nodes that provide working IP connections</p>" ) );
     NodeTypeDescriptionMap.insert( "fullsetup", 
         tr( "<p>Fully configured connection profile</p>" ) );
 
     // define system files
     addSystemFile( "interfaces", "/tmp/interfaces", 1 );
 
     // get access to the system
     TheSystem = new System();
 
 }
 
 TheNSResources::~TheNSResources( void ) {
     delete TheSystem;
 }
 
 void TheNSResources::addSystemFile( const QString & ID, 
                                     const QString & P,
                                     bool KDI ) {
     if( ! SystemFiles.find( ID ) ) {
       // new system file
       SystemFiles.insert( ID, new SystemFile( ID, P, KDI ) ); 
     } // else existed
 }
 
 void TheNSResources::busy( bool ) {
 /*
       if( B ) {
         ShowWait->show();
         qApp->process
       } else {
         ShowWait->hide();
       }
 */
 }
 
 /**
  * Load all modules that are found in the path
  * @param path a directory that is scaned for any plugins that can be loaded
  *  and attempts to load them
  */
 void TheNSResources::findAvailableNetNodes(const QString &path){
 
     Log(("Locate plugins in %s\n", path.latin1() ));
     QDir d(path);
     if(!d.exists())
       return;
 
     QString lang = ::getenv("LANG");
     
     // Don't want sym links
     d.setFilter( QDir::Files | QDir::NoSymLinks );
     const QFileInfoList *list = d.entryInfoList();
     QFileInfoListIterator it( *list );
     QFileInfo *fi;
 
     while ( (fi=it.current()) ) {
 
       if( fi->fileName().contains(".so")){
         /* if loaded install translation */
         if( loadNetNode(path + "/" + fi->fileName()) ) {
           QTranslator *trans = new QTranslator(qApp);
           QString fn = QPEApplication::qpeDir()+
                     "/i18n/"+lang+"/"+ 
                     fi->fileName().left( fi->fileName().find(".") )+
                     ".qm";
 
           if( trans->load( fn ) )
               qApp->installTranslator( trans );
           else
               delete trans;
         }
       }
       ++it;
     }
 }
 
 // used to find unique connection number
 int TheNSResources::assignConnectionNumber( void ) {
       bool found = 1;
       for( int trial = 0; ; trial ++ ) {
         found = 1; 
         for( QDictIterator<NodeCollection> it(ConnectionsMap);
              it.current();
              ++it ) {
           if( it.current()->number() == trial ) {
             found = 0;
             break;
           }
         }
 
         if( found ) {
           Log(("Assign profile number %d\n", trial ));
           return trial;
         }
       }
 }
 
 /**
  * Attempt to load a function and resolve a function.
  * @param pluginFileName - the name of the file in which to attempt to load
  * @param resolveString - function pointer to resolve
  * @return true of loading is successful
  */
 bool TheNSResources::loadNetNode(
       const QString &pluginFileName, const QString &resolveString){
 
     QLibrary *lib = new QLibrary(pluginFileName);
     void * res = lib->resolve(resolveString);
     if( ! res ){
       delete lib;
       return 0;
     }
 
     GetNetNodeListFt_t getNetNodeList = (GetNetNodeListFt_t)res;
     
     // Try to get an object.
     QList<ANetNode> PNN;
 
     getNetNodeList( PNN );
     if( PNN.isEmpty() ) {
       delete lib;
       return 0;
     }
 
     ANetNode * NNP;
     for( QListIterator<ANetNode> it(PNN);
          it.current();
          ++it ) {
       NetNode_t * NN;
 
       NNP = it.current();
       NN = new NetNode_t;
       NN->NetNode = NNP;
       NN->TheLibrary = lib;
       NN->NodeCountInLib = PNN.count();
 
       // store mapping
       AllNodeTypes.insert( NN->NetNode->name(), NN );
     }
 
     return 1;
 }
 
 QPixmap TheNSResources::getPixmap( const QString & QS ) {
     QPixmap P;
     QString S("networksettings2/");
     S += QS;
     Log(("%s\n", S.latin1() ));
     P = Resource::loadPixmap( S );
     return ( P.isNull() ) ? QPixmap() : P;
 }
 
 QString TheNSResources::tr( const char * s ) {
     return qApp->translate( "resource", s );
 }
 
 const QString & TheNSResources::netNode2Name( const char * s ) {
     return NodeTypeNameMap[s];
 }
 
 const QString & TheNSResources::netNode2Description( const char * s ) {
     return NodeTypeDescriptionMap[s];
 }
 
 void TheNSResources::addConnection( NodeCollection * NC ) {
       ANetNodeInstance * NNI;
       ConnectionsMap.insert( NC->name(), NC );
       // add (new) nodes to NodeList
       for( QListIterator<ANetNodeInstance> it(*NC);
            it.current();
            ++it ) {
         NNI = it.current();
         if( findNodeInstance( NNI->name() ) == 0 ) {
           // new item
           addNodeInstance( NNI );
         }
       }
 }
 
 void TheNSResources::removeConnection( const QString & N ) {
       NodeCollection * NC = findConnection( N );
       if( ! NC )
         return;
 
       // delete netnodes in this connection
       ANetNodeInstance * NNI;
       for( NNI = NC->first(); NNI != 0; NNI = NC->next() ) {
         removeNodeInstance( NNI->name() );
       }
       ConnectionsMap.remove( N ); 
 }
 
 NodeCollection * TheNSResources::findConnection( const QString & S ) {
       return ConnectionsMap[ S ];
 }
 
 /*
 void TheNSResources::renumberConnections( void ) {
       Name2Connection_t & M = NSResources->connections();
       NodeCollection * NC;
 
       // for all connections
       NodeCollection::resetMaxNr();
       for( QDictIterator<NodeCollection> it(M);
            it.current();
            ++it ) {
         NC = it.current();
         NC->setNumber( NC->maxConnectionNumber()+1 );
         NC->setModified( 1 );
       }
 }
 */
 
 typedef struct EnvVars {
       char * Name;
       int Len;
 } EnvVar_t;
 
 #define AnEV(x) x, sizeof(x)-1
 
 static EnvVar_t EV[] = {
-    // AnEV( "HOME=" ), -> SPECIAL
-    // AnEV( "LOGNAME=" ), -> SPECIAL
-    AnEV( "USER=" ),
-    AnEV( "LD_LIBRARY_PATH=" ),
-    AnEV( "PATH=" ),
-    AnEV( "QTDIR=" ),
-    AnEV( "OPIEDIR=" ),
-    AnEV( "SHELL=" ),
+    AnEV( "HOME" ),
+    AnEV( "LOGNAME" ),
+    AnEV( "USER" ),
+    AnEV( "LD_LIBRARY_PATH" ),
+    AnEV( "PATH" ),
+    AnEV( "QTDIR" ),
+    AnEV( "OPIEDIR" ),
+    AnEV( "SHELL" ),
     { NULL, 0 }
 };
 
 void TheNSResources::detectCurrentUser( void ) {
     // find current running qpe
     QString QPEEnvFile = "";
 
+    CurrentUser.UserName = "";
+    CurrentUser.HomeDir = "";
+
     if( getenv( "OPIEDIR" ) == 0 ) {
       // nothing known 
       { // open proc dir and find all dirs in it
         QRegExp R("[0-9]+");
         QDir ProcDir( "/proc" );
         QFileInfo FI;
         QStringList EL = ProcDir.entryList( QDir::Dirs );
 
         // print it out
         for ( QStringList::Iterator it = EL.begin(); 
               it != EL.end(); 
               ++it ) {
           if( R.match( (*it) ) >= 0 ) {
             QString S = ProcDir.path()+"/"+ (*it);
             S.append( "/exe" );
             FI.setFile( S );
             // get the link
             S = FI.readLink();
             if( S.right( 8 ) == "/bin/qpe" ) {
               // found running qpe
               QPEEnvFile.sprintf( ProcDir.path()+ "/" + (*it) + "/environ" );
               break;
             }
           }
         }
       }
 
       if( QPEEnvFile.isEmpty() ) {
         // could not find qpe
         Log(("Could not find qpe\n" ));
         return;
       }
 
       // FI now contains path ProcDir to the cmd dir
       { char * Buf = 0;
         char TB[1024];
         long BufSize = 0;
         int fd;
         int rd;
 
         fd = open( QPEEnvFile.latin1(), O_RDONLY );
         if( fd < 0 ) {
           Log(("Could not open %s : %d\n", 
               QPEEnvFile.latin1(), errno ));
           return;
         }
 
         while( (rd = read( fd, TB, sizeof(TB) ) ) > 0 ) {
           Buf = (char *)realloc( Buf, BufSize+rd );
           memcpy( Buf+BufSize, TB, rd );
           BufSize += rd;
         }
 
         char * Data = Buf;
         char * DataEnd = Data+BufSize-1;
 
         // get env items out of list
         while( Data < DataEnd ) {
-          if( strncmp( Data, "LOGNAME=", 8 ) == 0 ) {
-            CurrentUser.UserName = Data+8;
-            CurrentUser.EnvList.resize( CurrentUser.EnvList.size()+1 );
-            CurrentUser.EnvList[CurrentUser.EnvList.size()-1] = 
-                strdup( Data );
-          } else if( strncmp( Data, "HOME=", 5 ) == 0 ) {
-            CurrentUser.HomeDir = Data+5;
-            CurrentUser.EnvList.resize( CurrentUser.EnvList.size()+1 );
-            CurrentUser.EnvList[CurrentUser.EnvList.size()-1] = 
-                strdup( Data );
-          } else {
-            EnvVar_t * Run = EV;
-            while( Run->Name ) {
-              if( strncmp( Data, Run->Name, Run->Len ) == 0 ) {
-                CurrentUser.EnvList.resize( CurrentUser.EnvList.size()+1 );
-                CurrentUser.EnvList[CurrentUser.EnvList.size()-1] = 
-                    strdup( Data );
-                // put OPIEDIR in env
-                if( strcmp( Run->Name, "OPIEDIR=" ) == 0 ) {
-                  putenv( CurrentUser.EnvList[CurrentUser.EnvList.size()-1] );
 
-                }
-                break;
+          EnvVar_t * Run = EV;
+          while( Run->Name ) {
+            if( strncmp( Data, Run->Name, Run->Len ) == 0 &&
+                Data[Run->Len] == '=' 
+              ) {
+              CurrentUser.EnvList.resize( CurrentUser.EnvList.size()+1 );
+              CurrentUser.EnvList[CurrentUser.EnvList.size()-1] = 
+                  strdup( Data );
+
+              if( strcmp( Run->Name, "OPIEDIR" ) == 0 ) {
+                // put OPIEDIR in env
+                putenv( CurrentUser.EnvList[CurrentUser.EnvList.size()-1] );
+              } else if( strcmp( Run->Name, "HOME" ) == 0 ) {
+                CurrentUser.HomeDir = Data+5;
+              } else if( strcmp( Run->Name, "LOGNAME" ) == 0 ) {
+                CurrentUser.UserName = Data+8;
               }
-              Run ++;
+              break;
             }
+            Run ++;
           }
 
           Data += strlen( Data )+1;
         }
 
         free( Buf );
 
         if( ! CurrentUser.UserName.isEmpty() ) {
           // find user info
           struct passwd pwd;
           struct passwd * pwdres;
 
           if( getpwnam_r( CurrentUser.UserName.latin1(), 
                           &pwd, TB, sizeof(TB), &pwdres ) ||
               pwdres == 0 ) {
             Log(("Could not determine user %s : %d\n", 
                 CurrentUser.UserName.latin1(), errno ));
             return;
           }
           CurrentUser.Uid = pwd.pw_uid;
           CurrentUser.Gid = pwd.pw_gid;
         } else{
           CurrentUser.Uid = 
             CurrentUser.Gid = -1;
         }
       }
 
     } else {
-      CurrentUser.UserName = getenv( "LOGNAME" );
-      CurrentUser.EnvList.resize( CurrentUser.EnvList.size()+1 );
-      CurrentUser.EnvList[CurrentUser.EnvList.size()-1] = 
-          strdup( CurrentUser.UserName );
-
-      CurrentUser.HomeDir = getenv( "HOME" );
-      CurrentUser.EnvList.resize( CurrentUser.EnvList.size()+1 );
-      CurrentUser.EnvList[CurrentUser.EnvList.size()-1] = 
-          strdup( CurrentUser.HomeDir );
-
-      CurrentUser.EnvList.resize( CurrentUser.EnvList.size()+1 );
-      CurrentUser.EnvList[CurrentUser.EnvList.size()-1] = getenv("USER");
-      CurrentUser.EnvList.resize( CurrentUser.EnvList.size()+1 );
-      CurrentUser.EnvList[CurrentUser.EnvList.size()-1] = getenv("LD_LIBRARY_PATH");
-
-      CurrentUser.EnvList.resize( CurrentUser.EnvList.size()+1 );
-      CurrentUser.EnvList[CurrentUser.EnvList.size()-1] = getenv("PATH");
-
-      CurrentUser.EnvList.resize( CurrentUser.EnvList.size()+1 );
-      CurrentUser.EnvList[CurrentUser.EnvList.size()-1] = getenv("QTDIR");
-
-      CurrentUser.EnvList.resize( CurrentUser.EnvList.size()+1 );
-      CurrentUser.EnvList[CurrentUser.EnvList.size()-1] = getenv("OPIEDIR");
-      CurrentUser.EnvList.resize( CurrentUser.EnvList.size()+1 );
-      CurrentUser.EnvList[CurrentUser.EnvList.size()-1] = getenv("SHELL");
+      char * X;
+      QString S;
+
+      EnvVar_t * Run = EV;
+      while( Run->Name ) {
+
+        if( ( X = getenv( Run->Name ) ) ) {
+          Log(( "Env : %s = %s\n", Run->Name, X ));
+
+          S.sprintf( "%s=%s", Run->Name, X );
+          CurrentUser.EnvList.resize( CurrentUser.EnvList.size()+1 );
+          CurrentUser.EnvList[CurrentUser.EnvList.size()-1] = 
+                strdup( S.latin1() );
+
+          if( strcmp( Run->Name, "LOGNAME" ) == 0 ) {
+            CurrentUser.UserName = X;
+          } else if( strcmp( Run->Name, "HOME" ) == 0 ) {
+            CurrentUser.HomeDir = X;
+          } // regulare env var
+        } else {
+          Log(("Could not determine %s\n", Run->Name ));
+        }
+        Run ++;
+      }
 
       CurrentUser.Uid = getuid();
       CurrentUser.Gid = getgid();
     }
 }
diff --git a/noncore/settings/networksettings2/networksettings2/resources.h b/noncore/settings/networksettings2/networksettings2/resources.h
index 16355ba..23b120e 100644
--- a/noncore/settings/networksettings2/networksettings2/resources.h
+++ b/noncore/settings/networksettings2/networksettings2/resources.h
@@ -1,132 +1,137 @@
 #ifndef __RESOURCES__H
 #define __RESOURCES__H
 
 #include <qstring.h>
 #include <qdict.h>
 #include <qmap.h>
 #include <qlist.h>
 #include "netnode.h"
 #include "systemfile.h"
 #include "system.h"
 
 class QLibrary;
 class QPixmap;
 class ANetNode;
 class ANetNodeInstance;
 
 typedef void (*GetNetNodeListFt_t)(QList<ANetNode>& PNN );
 
 typedef struct NetNode_S {
         ANetNode * NetNode;
         QLibrary * TheLibrary;
         long NodeCountInLib;
 } NetNode_t;
 
 class CurrentQPEUser {
 
 public :
         CurrentQPEUser() : UserName(), HomeDir(), EnvList() {}
 
+        inline bool known( void )
+          { return ! HomeDir.isEmpty() && ! UserName.isEmpty(); }
+
         QString        UserName;
         QString        HomeDir;
         int            Uid;
         int            Gid;
         QArray<char *> EnvList;
 };
 
 typedef QDict<NetNode_t> Name2NetNode_t;
 typedef QDict<ANetNodeInstance > Name2Instance_t;
 typedef QDict<NodeCollection> Name2Connection_t;
 typedef QDict<SystemFile> Name2SystemFile_t;
 
 class TheNSResources {
 
 public :
 
     TheNSResources( void );
     ~TheNSResources( );
 
     // give busy feedback
     void busy( bool B );
 
     System & system()
       { return *TheSystem; }
 
     int assignConnectionNumber(void);
     QPixmap getPixmap( const QString & Name );
 
     Name2NetNode_t & netNodes( void ) 
       { return AllNodeTypes; }
     bool netNodeExists( const QString & X )
       { return AllNodeTypes.find(X)!=0; }
     ANetNode * findNetNode( const QString & N )
       { NetNode_t * NNT = AllNodeTypes.find(N);
         return (NNT) ? NNT->NetNode : 0;
       }
 
     Name2SystemFile_t & systemFiles( void )
       { return SystemFiles; }
     void addSystemFile( const QString & ID, 
                         const QString & P,
                         bool KDI );
 
     ANetNodeInstance * createNodeInstance( const QString & S )
       { ANetNodeInstance * NNI = 0;
         NetNode_t * NNT = AllNodeTypes[S];
         if( ! NNT ) {
           return 0;
         }
         NNI = NNT->NetNode->createInstance();
         NNI->initialize();
         return NNI;
       }
 
     Name2Instance_t & netNodeInstances( void ) 
       { return AllNodes; }
     void addNodeInstance( ANetNodeInstance * I )
       { AllNodes.insert( I->name(), I ); }
     void removeNodeInstance( const QString & N )
       { AllNodes.remove( N );}
     ANetNodeInstance * findNodeInstance( const QString & S )
       { return (AllNodes.find(S)!=0) ? AllNodes[S] : 0; }
 
     const QString & netNode2Name( const char * Type );
     const QString & netNode2Description( const char * Type );
 
     void addConnection( NodeCollection * NC );
     void removeConnection( const QString & N );
     NodeCollection * findConnection( const QString & N );
     Name2Connection_t & connections( void )
       { return ConnectionsMap; }
 
+    inline bool userKnown( void )
+      { return CurrentUser.known(); }
     CurrentQPEUser & currentUser( void )
       { return CurrentUser; }
 
 private :
 
     void detectCurrentUser( void );
     QString tr( const char * path );
     void findAvailableNetNodes( const QString &path );
     bool loadNetNode(
          const QString &pluginFileName,
          const QString &resolveString = "create_plugin");
 
     QMap< QString, QString>   NodeTypeNameMap;
     QMap< QString, QString>   NodeTypeDescriptionMap;
     Name2Connection_t ConnectionsMap;
     System * TheSystem;
     Name2SystemFile_t SystemFiles;
 
     // all node type classes 
     Name2NetNode_t      AllNodeTypes;
 
     // all nodes
     Name2Instance_t     AllNodes;
 
     CurrentQPEUser      CurrentUser;
 };
 
 extern TheNSResources * _NSResources;
 #define NSResources _NSResources
 
 #endif
diff --git a/noncore/settings/networksettings2/nsdata.cpp b/noncore/settings/networksettings2/nsdata.cpp
index d709c0a..e2dd5b5 100644
--- a/noncore/settings/networksettings2/nsdata.cpp
+++ b/noncore/settings/networksettings2/nsdata.cpp
@@ -1,593 +1,603 @@
 #include <stdlib.h>
 #include <qpe/qpeapplication.h>
 #include <qtextstream.h>
 #include <qdir.h>
 #include <qfile.h>
 #include <qfileinfo.h>
 
 #include "nsdata.h"
 #include <asdevice.h>
 #include <resources.h>
 
 static QString CfgFile;
 
 NetworkSettingsData::NetworkSettingsData( void ) {
     // init global resources structure
     new TheNSResources();
 
+    if( ! NSResources->userKnown() ) {
+      Log(( "Cannot detect qpe user HOME=\"%s\" USER=\"%s\"\n",
+          NSResources->currentUser().HomeDir.latin1(),
+          NSResources->currentUser().UserName.latin1() ));
+      return;
+    }
+
     CfgFile.sprintf( "%s/Settings/NS2.conf", 
           NSResources->currentUser().HomeDir.latin1() );
     Log(( "Cfg from %s\n", CfgFile.latin1() ));
 
     // load settings
     IsModified = 0;
     loadSettings();
 }
 
 // saving is done by caller
 NetworkSettingsData::~NetworkSettingsData( void ) {
     delete NSResources;
 }
 
 void NetworkSettingsData::loadSettings( void ) {
     QString Line, S;
     QString Attr, Value;
     long idx;
 
     QFile F( CfgFile );
     QTextStream TS( &F );
 
     do {
 
       if( ! F.open(IO_ReadOnly) )
         break;
 
       /* load the file ->
 
          FORMAT :
 
            [NETNODETYPE] 
            Entries ...
            <EMPTYLINE>
            [connection] 
            Name=Name
            Node=Name
            <EMPTYLINE>
       */
       while( ! TS.atEnd() ) {
         S = Line = TS.readLine();
 
         if ( S.isEmpty() || S[0] != '[' )
           continue;
 
         S = S.mid( 1, S.length()-2 );
 
         if( ! NSResources ) {
           continue;
         }
 
         if( S == "connection" ) {
           // load connections -> collections of nodes
           NodeCollection * NC = new NodeCollection( TS );
           NSResources->addConnection( NC );
         } else {
           ANetNode * NN = 0;
           ANetNodeInstance* NNI = 0;
           if( S.startsWith( "nodetype " ) ) {
             S = S.mid( 9, S.length()-9 );
             S = deQuote(S);
             // try to find netnode
             NN = NSResources->findNetNode( S );
             Log( ( "Node %s : %p\n", S.latin1(), NN ) );
           } else {
             // try to find instance
             NNI = NSResources->createNodeInstance( S );
             Log( ( "NodeInstance %s : %p\n", S.latin1(), NNI  ));
           }
 
           if( NN == 0 && NNI == 0 ) {
             LeftOvers.append( Line );
           }
 
           do {
             S = Line = TS.readLine();
 
             if( NN || NNI ) {
               if( S.isEmpty() ) {
                 // empty line
                 break;
               }
               idx = S.find( '=' );
               if( idx > 0 ) {
                 Attr = S.left( idx );
                 Value = S.mid( idx+1, S.length() );
               } else {
                 Value="";
                 Attr = S;
               }
 
               Value.stripWhiteSpace();
               Attr.stripWhiteSpace();
               Attr.lower();
               // dequote Attr
               Value = deQuote(Value);
 
               if( NN ) {
                 // set the attribute
                 NN->setAttribute( Attr, Value );
               } else {
                 // set the attribute
                 NNI->setAttribute( Attr, Value );
               }
             } else {
               LeftOvers.append( Line );
               // add empty line too as delimiter
               if( S.isEmpty() ) {
                 // empty line
                 break;
               }
             }
           } while( 1 );
 
           if( NNI ) {
             // loading from file -> exists
             NNI->setNew( FALSE );
             NSResources->addNodeInstance( NNI );
           }
         }
       }
 
     } while( 0 );
 
 }
 
 QString NetworkSettingsData::saveSettings( void ) {
     QString ErrS = "";
 
     if( ! isModified() )
       return ErrS;
 
     QString S;
     QFile F( CfgFile + ".bup" );
 
     Log( ( "Saving settings to %s\n", CfgFile.latin1()  ));
     if( ! F.open( IO_WriteOnly | IO_Truncate ) ) {
       ErrS = qApp->translate( "NetworkSettings", 
               "<p>Could not save setup to \"%1\" !</p>" ).
         arg(CfgFile);
       // problem
       return ErrS;
     }
 
     QTextStream TS( &F );
 
     // save leftovers
     for ( QStringList::Iterator it = LeftOvers.begin(); 
           it != LeftOvers.end(); ++it ) {
       TS << (*it) << endl;
     }
 
     // save global configs
     for( QDictIterator<NetNode_t> it( NSResources->netNodes() );
         it.current();
         ++it ) {
         TS << "[nodetype "
            << quote( QString( it.current()->NetNode->name() ) )
            << "]" 
            << endl;
 
         it.current()->NetNode->saveAttributes( TS );
         TS << endl;
     }
 
     { Name2Connection_t & M = NSResources->connections();
       ANetNodeInstance * NNI;
 
       // for all connections
       for( QDictIterator<NodeCollection> it(M);
            it.current();
            ++it ) {
         // all nodes in those connections
         for( QListIterator<ANetNodeInstance> nit(*(it.current())); 
              nit.current();
              ++nit ) {
           // header
           NNI = nit.current();
           TS << '[' 
              << QString(NNI->nodeClass()->name()) 
              << ']' 
              << endl;
           NNI->saveAttributes( TS );
           TS << endl;
         }
 
         TS << "[connection]" << endl;
         it.current()->save(TS);
       }
     }
 
     QDir D(".");
     D.rename( CfgFile + ".bup", CfgFile );
 
     //
     // proper files AND system files regenerated
     //
 
     setModified( 0 );
     return ErrS;
 }
 
 QString NetworkSettingsData::generateSettings( void ) {
     QString S = "";
     Name2SystemFile_t & SFM = NSResources->systemFiles();
     Name2Connection_t & M = NSResources->connections();
     NodeCollection * NC;
     ANetNodeInstance * NNI;
     ANetNodeInstance * FirstWithData;
     SystemFile * SF;
     AsDevice * CurDev;
     ANetNode * NN, * CurDevNN = 0;
     long NoOfDevs;
     long DevCtStart;
     bool needToGenerate;
 
     // regenerate system files
     Log( ( "Generating settings from %s\n", CfgFile.latin1()  ));
 
     //
     // generate files proper to each netnodeinstance
     //
     { Name2Instance_t & NNIs = NSResources->netNodeInstances();
 
       for( QDictIterator<ANetNodeInstance> NNIIt(NNIs);
            NNIIt.current();
            ++NNIIt ) {
         // for all nodes find those that are modified
         NNI = NNIIt.current();
 
         { // get list of proper files for this nodeclass (if any)
           QStringList * PF = NNI->nodeClass()->properFiles();
 
           if( PF ) {
             for ( QStringList::Iterator it = PF->begin(); 
                   it != PF->end(); 
                   ++it ) {
               QFile * F = NNI->openFile( (*it) );
               if( F ) {
                 QTextStream TS( F );
                 if( NNI->generateFile( (*it), F->name(), TS, -1 ) == 2 ) {
                   // problem generating
                   S = qApp->translate( "NetworkSettings", 
                                        "<p>Cannot generate files proper to \"%1\"</p>" ).
                           arg(NNI->nodeClass()->name()) ;
                   delete F;
                   return S;
                 }
                 delete F;
               }
             }
           }
         }
       }
     }
 
     //
     // generate all system files
     //
     for( QDictIterator<SystemFile> sfit(SFM);
          sfit.current();
          ++sfit ) {
       SF = sfit.current();
 
       // reset all 
       for( QDictIterator<NetNode_t> nnit( NSResources->netNodes() );
            nnit.current();
            ++nnit ) {
         nnit.current()->NetNode->setDone(0);
       }
 
       for( QDictIterator<ANetNodeInstance> nniit(
                   NSResources->netNodeInstances() );
            nniit.current();
            ++nniit ) {
         nniit.current()->setDone(0);
       }
 
       for( QDictIterator<NodeCollection> ncit(M);
            ncit.current();
            ++ncit ) {
         ncit.current()->setDone(0);
       }
 
       Log( ( "Generating %s\n", SF->name().latin1() ));
 
       needToGenerate = 0;
 
       // are there netnodes that have instances and need 
       // to write data in this system file ?
       for( QDictIterator<NetNode_t> nnit( NSResources->netNodes() );
            ! needToGenerate && nnit.current();
            ++nnit ) {
 
         NN = nnit.current()->NetNode;
 
         if( NN->hasDataForFile( SF->name() ) ) {
           // netnode can have data
 
           // are there instances of this node ?
           for( QDictIterator<ANetNodeInstance> nniit(
                       NSResources->netNodeInstances() );
                ! needToGenerate && nniit.current();
                ++nniit ) {
             if( nniit.current()->nodeClass() == NN ) {
               // yes
               Log(("Node %s has data\n",
                   nniit.current()->name() ));
               needToGenerate = 1;
               break;
             }
           }
         }
       }
 
       if( ! needToGenerate ) {
         // no instances found that might need to write data
         // in this systemfile
         Log(("No nodes for systemfile %s\n", SF->name().latin1() ));
         continue;
       }
 
       // ok generate this system file
       SF->open();
 
       // global presection for this system file
       if( ! SF->preSection() ) {
         S = qApp->translate( "NetworkSettings", 
                              "<p>Error in section \"Preamble\" for file \"%1\"</p>" ).
             arg( SF->name() );
         return S;
       }
 
       // find connections that want to write to this file
       for( QDictIterator<NodeCollection> ncit(M);
            ncit.current();
            ++ncit ) {
 
         NC = ncit.current();
 
         if( NC->done() ) {
           // already done
           continue;
         }
 
         if( ! NC->hasDataForFile( SF->name() ) ) {
           // no data
           continue;
         }
 
         Log(("Generating %s for connection %s\n",
               SF->name().latin1(), NC->name().latin1() ));
         // find highest item that wants to write data to this file
         FirstWithData = NC->firstWithDataForFile( SF->name() );
 
         // find device on which this connection works
         CurDev = NC->device();
         // class of that node
         CurDevNN = CurDev->netNode()->nodeClass();
 
         Log(( "%s is done %d\n",
           FirstWithData->nodeClass()->name(),
           FirstWithData->nodeClass()->done() ));
 
         if( ! FirstWithData->nodeClass()->done() ) {
           // generate fixed part 
           if( ! SF->preDeviceSection( CurDevNN ) ) {
             S = qApp->translate( "NetworkSettings", 
                                  "<p>Error in section \"Pre-Device\" for file \"%1\"</p>" ).
                 arg( SF->name() );
             return S;
           }
 
           if( FirstWithData->nodeClass()->generateFile( 
                         SF->name(), SF->path(), *SF, -1 ) == 2 ) {
             S = qApp->translate( "NetworkSettings", 
               "<p>Error in section \"Common\" for file \"%1\" and node \"%2\"</p>" ).
                 arg( SF->name() ).
                 arg( CurDevNN->name() );
             return S;
           }
           FirstWithData->nodeClass()->setDone( 1 );
         }
 
         NoOfDevs = 0;
         DevCtStart = -1;
 
         if( SF->knowsDeviceInstances() ) {
           DevCtStart = 0;
           NoOfDevs = CurDevNN->instanceCount();
         }
 
         Log(( "Node %s is done %d\n",
           CurDev->netNode()->nodeClass()->name(),
           CurDev->netNode()->nodeClass()->done() ));
 
         if( ! CurDev->netNode()->nodeClass()->done() ) {
           // first time this device is handled
           // generate common device specific part
           for( int i = DevCtStart; i < NoOfDevs ; i ++ ) {
 
             if( FirstWithData->nodeClass()->generateFile( 
                 SF->name(), SF->path(), *SF, CurDev->netNode(), i ) == 2 ) {
               S = qApp->translate( "NetworkSettings", 
                 "<p>Error in section \"Device\" for file \"%1\" and node \"%2\"</p>" ).
                   arg( SF->name() ).
                   arg( CurDevNN->name() );
               return S;
             }
           }
           CurDev->netNode()->nodeClass()->setDone( 1 );
         }
 
         // generate profile specific info
         // for all nodeconnections that work on the same device
         for( QDictIterator<NodeCollection> ncit2(M);
              ncit2.current();
              ++ncit2 ) {
 
           if( ncit2.current()->device() != CurDev ) {
             // different device
             continue;
           }
 
           Log(("Connection %s of same family\n", ncit2.current()->name().latin1() ));
           // generate 
           NNI = ncit2.current()->firstWithDataForFile( SF->name() );
           for( int i = DevCtStart; i < NoOfDevs ; i ++ ) {
             if( ! SF->preNodeSection( NNI, i ) ) {
               S = qApp->translate( "NetworkSettings", 
                   "<p>Error in \"Pre-Node Part\" for file \"%1\" and node \"%2\"</p>" ).
                   arg( SF->name() ).
                   arg( CurDevNN->name() );
               return S;
             }
 
             switch( NNI->generateFile( 
                           SF->name(), SF->path(), *SF, i ) ) {
               case 0 :
                 (*SF) << endl;
                 break;
               case 1 :
                 break;
               case 2 :
                 S = qApp->translate( "NetworkSettings", 
                   "<p>Error in section \"Node\" for file \"%1\" and node \"%2\"</p>" ).
                     arg( SF->name() ).
                     arg( CurDevNN->name() );
                 return S;
             }
 
             if( ! SF->postNodeSection( NNI, i ) ) {
               S = qApp->translate( "NetworkSettings", 
                   "<p>Error in \"Post-Node Part\" for file \"%1\" and node \"%2\"</p>" ).
                   arg( SF->name() ).
                   arg( CurDevNN->name() );
               return S;
             }
           }
 
           ncit2.current()->setDone( 1 );
 
         }
       }
 
       if( ! SF->postDeviceSection( CurDevNN ) ) {
         S = qApp->translate( "NetworkSettings", 
             "<p>Error in section \"Post-Device\" for file \"%1\" and node \"%2\"</p>" ).
                 arg( SF->name() ).
                 arg( CurDevNN->name() );
         return S;
       }
 
 
       if( ! SF->postSection() ) {
         S = qApp->translate( "NetworkSettings", 
                 "<p>Error in section \"Closure\" for file \"%1\"</p>" ).
                   arg( SF->name() );
         return S;
       }
 
       // end of file
       SF->close();
     }
     return S;
 }
 
 QList<NodeCollection> NetworkSettingsData::collectPossible( const char * Interface ) {
     // collect connections that can work on top of this interface
     NodeCollection * NC;
     QList<NodeCollection> PossibleConnections;
     Name2Connection_t & M = NSResources->connections();
 
     // for all connections
     for( QDictIterator<NodeCollection> it(M);
          it.current();
          ++it ) {
       NC = it.current();
       // check if this profile handles the requested interface
       if( NC->handlesInterface( Interface ) && // if different Intf.
           NC->state() != Disabled && // if not enabled
           NC->state() != IsUp  // if already used
         ) {
         Log( ( "Append %s for %s\n", NC->name().latin1(), Interface));
         PossibleConnections.append( NC );
       }
     }
     return PossibleConnections;
 }
 
 
 /*
     Called by the system to see if interface can be brought UP
 
     if allowed, echo Interface-allowed else Interface-disallowed
 */
 
 bool NetworkSettingsData::canStart( const char * Interface ) {
     // load situation
     NodeCollection * NC = 0;
     QList<NodeCollection> PossibleConnections;
 
     PossibleConnections = collectPossible( Interface );
 
-    Log( ( "Possiblilies %d\n", PossibleConnections.count() ));
+    Log( ( "for %s : Possiblilies %d\n", 
+        Interface, PossibleConnections.count() ));
     switch( PossibleConnections.count() ) {
       case 0 : // no connections
         break;
       case 1 : // one connection
         NC = PossibleConnections.first();
         break;
       default : // need to ask user ?
         return 1;
     }
 
     if( NC ) {
       switch( NC->state() ) {
         case Unchecked :
         case Unknown :
         case Unavailable :
         case Disabled :
           // this profile does not allow interface to be UP
           // -> try others
           break;
         case Off :
           // try to UP the device
           if( ! NC->setState( Activate ) ) {
             // cannot bring device Online -> try other alters
             break;
           }
           // FT
         case Available :
         case IsUp : // also called for 'ifdown'
           // device is ready -> done
+          Log(( "%s-c%d-allowed\n", Interface, NC->number() ));
           printf( "%s-c%d-allowed\n", Interface, NC->number() );
           return 0;
       }
     } 
 
     // if we come here no alternatives are possible
+    Log(( "%s-cnn-disallowed\n", Interface ));
     printf( "%s-cnn-disallowed\n", Interface );
     return 0;
 }
 
 /*
     Called by the system to regenerate config files
 */
 
 bool NetworkSettingsData::regenerate( void ) {
     QString S = generateSettings();
     if( ! S.isEmpty() ) {
       fprintf( stdout, "%s\n", S.latin1() );
       return 1;
     }
     return 0;
 }