Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.

BUG:215923


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdenetwork@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 1058 insertions, 0 deletions

diff --git a/lanbrowsing/lisa/netmanager.cpp b/lanbrowsing/lisa/netmanager.cpp
new file mode 100644
index 00000000..e652ce97
--- /dev/null
+++ b/lanbrowsing/lisa/netmanager.cpp
@@ -0,0 +1,1058 @@
+ /*    netmanager.cpp
+ *
+ *    Copyright (c) 2000, Alexander Neundorf
+ *    neundorf@kde.org
+ *
+ *    You may distribute under the terms of the GNU General Public
+ *    License as specified in the COPYING file.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ */
+
+#include "config.h"
+
+#include "netmanager.h"
+#include "lisadefines.h"
+
+#include <iostream>
+#include <unistd.h>
+
+#include <sys/un.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <netinet/in.h>
+#include <strings.h>
+#include <errno.h>
+#include <string.h>
+#include <signal.h>
+#include <pwd.h>
+
+#ifndef AF_LOCAL
+#define AF_LOCAL AF_UNIX
+#endif
+
+
+#ifdef LISA_DEBUG
+#undef LISA_DEBUG
+#endif
+
+#ifdef dcerr
+#undef dcerr
+#endif
+
+#ifdef mdcerr
+#undef mdcerr
+#endif
+
+#define LISA_DEBUG 0
+#define dcerr if (LISA_DEBUG==1) std::cerr<<"NetManager "
+#define mdcerr if (LISA_DEBUG==1) std::cerr<<procId<<" NetManager "
+
+static void sig_child_handler(int)
+{
+   int saved_errno = errno;
+   
+   while (waitpid(-1, NULL, WNOHANG) > 0)
+      ; // repeat
+   
+   errno = saved_errno;
+}
+
+NetManager::NetManager(int& rawSocketFD, int portToUse, MyString configFile, int configStyle, int strictMode)
+:NetScanner(rawSocketFD,strictMode)
+//,validator()
+,m_listenFD(-1)
+,m_bcFD(-1)
+,m_basePort(portToUse)
+,m_pipeFD(-1)
+,m_receiveBuffer(0)
+,m_receivedBytes(0)
+,m_childPid(0)
+,m_lastUpdate(0)
+
+,m_isInformed(0)
+,m_isBeingScanned(0)
+,m_firstRun(1)
+,m_serverServer(0)
+,m_servedThisPeriod(0)
+
+,m_serveCount(0)
+,m_refreshTime(60)
+,m_initialRefreshTime(60)
+,m_increasedRefreshTime(0)
+,m_broadcastAddress(0)
+,m_extraConfigFile(configFile)
+,m_configStyle(configStyle)
+,m_usedConfigFileName("")
+{
+   mdcerr<<"NetManager::NetManager"<<std::endl;
+   m_startedAt=time(0);
+   
+   struct sigaction act;
+   act.sa_handler=sig_child_handler;
+   sigemptyset(&(act.sa_mask));
+   sigaddset(&(act.sa_mask), SIGCHLD);
+   // Make sure we don't block this signal. gdb tends to do that :-(
+   sigprocmask(SIG_UNBLOCK, &(act.sa_mask), 0);
+
+   act.sa_flags = SA_NOCLDSTOP;
+#ifdef SA_RESTART
+   act.sa_flags |= SA_RESTART;
+#endif
+
+   sigaction( SIGCHLD, &act, NULL );
+}
+
+NetManager::~NetManager()
+{
+   mdcerr<<"NetManager destructor ..."<<std::endl;
+   if (m_receiveBuffer!=0) delete [] m_receiveBuffer;
+   ::close(m_listenFD);
+   ::close(m_bcFD);
+}
+
+void NetManager::readConfig()
+{
+   m_usedConfigFileName=getConfigFileName();
+   if (m_usedConfigFileName.isEmpty())
+   {
+      std::cout<<"configfile not found"<<std::endl;
+      std::cout<<"use the command line option --help and \ntake a look at the README for more information"<<std::endl;
+      exit(1);
+   }
+
+   Config config(m_usedConfigFileName);
+   NetManager::configure(config);
+   NetScanner::configure(config);
+   validator.configure(config);
+   //after reading the new configuration we should really update
+   m_lastUpdate=0;
+}
+
+void NetManager::configure(Config& config)
+{
+   m_refreshTime=config.getEntry("UpdatePeriod",300);
+   MyString tmp=stripWhiteSpace(config.getEntry("BroadcastNetwork","0.0.0.0/255.255.255.255;"));
+   tmp=tmp+";";
+   mdcerr<<"NetManager::readConfig: "<<tmp<<std::endl;
+   MyString netAddressStr=tmp.left(tmp.find('/'));
+   tmp=tmp.mid(tmp.find('/')+1);
+   tmp=tmp.left(tmp.find(';'));
+   mdcerr<<"NetManager::readConfig: broadcastNet "<<netAddressStr<<" with mask "<<tmp<<std::endl;
+   int netMask=inet_addr(tmp.c_str());
+   int netAddress=inet_addr(netAddressStr.c_str());
+   m_broadcastAddress= netAddress | (~netMask);
+   mdcerr<<"NetManager::readConfig: net "<<std::ios::hex<<netAddress<<" with mask "<<netMask<<" gives "<<m_broadcastAddress<<std::endl;
+   
+   //maybe this way we can avoid that all servers on the net send
+   //their requests synchronously, since now the refreshtime isn't
+   //always the eact value of m_refreshTime, but differs always slightly
+   if ((m_refreshTime%SELECT_TIMEOUT)==0) m_refreshTime+=2;
+   //some limits from half a minute to half an hour
+   if (m_refreshTime<30) m_refreshTime=30;
+   if (m_refreshTime>1800) m_refreshTime=1800;
+   m_initialRefreshTime=m_refreshTime;
+}
+
+int NetManager::prepare()
+{
+   mdcerr<<"NetManager::prepare"<<std::endl;
+
+   ::close(m_listenFD);
+   ::close(m_bcFD);
+   int result(0);
+   if (m_strictMode)
+   {
+      m_listenFD=::socket(AF_LOCAL, SOCK_STREAM, 0);
+      //m_listenFD=::socket(AF_LOCAL, SOCK_STREAM, IPPROTO_TCP);
+      MyString socketName("/tmp/resLisa-");
+      struct passwd *user = getpwuid( getuid() );
+      if ( user )
+         socketName+=user->pw_name;
+      else
+         //should never happen
+         socketName+="???";
+      ::unlink(socketName.data());
+      sockaddr_un serverAddr;
+      if (socketName.length() >= sizeof(serverAddr.sun_path))
+      {
+         std::cout<<"NetManager::prepare: your user name  \""<<user->pw_name<<"\" is too long, exiting."<<std::endl;
+         return 0;
+      }
+      memset((void*)&serverAddr, 0, sizeof(serverAddr));
+      serverAddr.sun_family=AF_LOCAL;
+      strncpy(serverAddr.sun_path,socketName.data(),sizeof(serverAddr.sun_path));
+      result=::bind(m_listenFD,(sockaddr*) &serverAddr,sizeof(serverAddr));
+      if (result!=0)
+      {
+         std::cout<<"NetManager::prepare: bind (UNIX socket) failed, errno: "<<errno<<std::endl;
+         return 0;
+      }
+   }
+   else
+   {
+      //create a listening port and listen
+      m_listenFD = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+      if (m_listenFD==-1)
+      {
+         std::cout<<"NetManager::prepare: socket(TCP) failed, errno: "<<errno<<std::endl;
+         return 0;
+      }
+
+      sockaddr_in serverAddress;
+//      bzero((char*)&serverAddress, sizeof(serverAddress));
+      memset((void*)&serverAddress, 0, sizeof(serverAddress));
+      serverAddress.sin_family      = AF_INET;
+      serverAddress.sin_addr.s_addr = htonl(INADDR_ANY);
+      serverAddress.sin_port        = htons(m_basePort);
+
+      int on(1);
+      result=setsockopt(m_listenFD, SOL_SOCKET, SO_REUSEADDR, (char*)&on, sizeof(on));
+      if (result!=0)
+      {
+         std::cout<<"NetManager::prepare: setsockopt(SO_REUSEADDR) failed"<<std::endl;
+         return 0;
+      }
+      result=::bind(m_listenFD, (struct sockaddr *) &serverAddress, sizeof(serverAddress));
+      if (result!=0)
+      {
+         std::cout<<"NetManager::prepare: bind (TCP) failed, errno: "<<errno<<std::endl;
+         return 0;
+      }
+   }
+   result=::listen(m_listenFD, 32);
+   if (result!=0)
+   {
+      std::cout<<"NetManager::prepare: listen failed"<<std::endl;
+      return 0;
+   }
+   mdcerr<<"NetManager::prepare: listening on port "<<m_basePort<<"..."<<std::endl;
+
+   return 1;
+}
+
+void NetManager::generateFDset(fd_set *tmpFDs)
+{
+   mdcerr<<"NetManager::generateFDset"<<std::endl;
+   
+   FD_ZERO(tmpFDs);
+   FD_SET(m_listenFD,tmpFDs);
+   mdcerr<<"NetManager::generateFDset: adding listen FD="<<m_listenFD<<std::endl;
+//   for (Client* tmpClient=clients.first(); tmpClient!=0; tmpClient=clients.next())
+   for (std::list<Client>::iterator tmpClient=clients.begin(); tmpClient != clients.end(); tmpClient++)
+      if (tmpClient->fd()!=-1)
+      {
+         mdcerr<<"NetManager::generateFDset: adding client FD="<<tmpClient->fd()<<std::endl;
+         FD_SET(tmpClient->fd(),tmpFDs);
+      }
+
+   if (m_pipeFD!=-1)
+   {
+      mdcerr<<"NetManager::generateFDset: adding pipeFD="<<m_pipeFD<<std::endl;
+      FD_SET(m_pipeFD,tmpFDs);
+   }
+
+   if ((m_bcFD!=-1) && (!m_strictMode))
+   {
+      mdcerr<<"NetManager::generateFDset: adding m_bcFD="<<m_bcFD<<std::endl;
+      FD_SET(m_bcFD,tmpFDs);
+   }
+}
+
+int NetManager::waitForSomethingToHappen(fd_set *tmpFDs)
+{
+   mdcerr<<"NetManager::waitForSomethingToHappen for 10 seconds"<<std::endl;
+   if (m_firstRun)
+   {
+      tv.tv_sec = 1;
+      m_firstRun=0;
+   }
+   else
+      tv.tv_sec = SELECT_TIMEOUT;
+
+   tv.tv_usec = 0;
+   //generateFDset(tmpFDs);
+   int result=select(getMaxFD(),tmpFDs,0,0,&tv);
+   if (result>0) return 1;
+   else return 0;
+}
+
+int NetManager::getMaxFD()
+{
+   int maxFD(m_listenFD);
+//   for (Client* tmpClient=clients.first(); tmpClient!=0; tmpClient=clients.next())
+   for (std::list<Client>::iterator tmpClient=clients.begin(); tmpClient != clients.end(); tmpClient++)
+      if (tmpClient->fd()>maxFD)
+         maxFD=tmpClient->fd();
+
+   if (m_pipeFD>maxFD) maxFD=m_pipeFD;
+   if (m_bcFD>maxFD) maxFD=m_bcFD;
+
+   mdcerr<<"NetManager::getMaxFD()="<<maxFD+1<<std::endl;
+   return maxFD+1;
+}
+
+int fileReadable(const MyString& filename)
+{
+   FILE *file=::fopen(filename.data(), "r");
+   if (file==0)
+      return 0;
+   fclose(file);
+   return 1;
+}
+
+MyString NetManager::getConfigFileName()
+{
+   MyString tmpBase(CONFIGFILEBASENAME);
+
+   if (m_strictMode)
+      tmpBase=STRICTCONFIGFILEBASENAME;
+
+   if (!m_extraConfigFile.isEmpty())
+      m_configStyle=EXTRACONFIGSTYLE;
+
+   MyString tmpFilename;
+   if (m_configStyle==EXTRACONFIGSTYLE)
+   {
+      tmpFilename=m_extraConfigFile;
+      if (fileReadable(tmpFilename))
+         return tmpFilename;
+      return "";
+   }
+   else if (m_configStyle==UNIXCONFIGSTYLE)
+   {
+      tmpFilename=getenv("HOME");
+      tmpFilename+=MyString("/.")+tmpBase;
+      if (fileReadable(tmpFilename))
+         return tmpFilename;
+      tmpFilename="/etc/";
+      tmpFilename+=tmpBase;
+      if (fileReadable(tmpFilename))
+         return tmpFilename;
+      return "";
+   }
+/*   else if (m_configStyle==KDE1CONFIGSTYLE)
+   {
+      tmpFilename=getenv("HOME");
+      tmpFilename+=MyString("/.kde/share/config/")+tmpBase;
+      if (fileReadable(tmpFilename))
+         return tmpFilename;
+      tmpFilename=getenv("KDEDIR");
+      tmpFilename+=MyString("/share/config/")+tmpBase;
+      if (fileReadable(tmpFilename))
+         return tmpFilename;
+      return "";
+   }
+   else if (m_configStyle==KDE2CONFIGSTYLE)
+   {
+      FILE *kdeConfig=popen("kde-config --path config","r");
+      if (kdeConfig==0)
+      {
+         std::cout<<"could not execute kde-config, check your KDE 2 installation\n"<<std::endl;
+         return "";
+      };
+      //this should be large enough
+      char buf[4*1024];
+      memset(buf,0,4*1024);
+      fgets(buf,4*1024-1,kdeConfig);
+      // Warning: The return value of plcose may be incorrect due to the
+      // SIGCHLD handler that is installed. Ignore it!
+      pclose(kdeConfig);
+      int length=strlen(buf);
+      if (buf[length-1]=='\n') buf[length-1]='\0';
+      MyString kdeDirs(buf);
+      while (kdeDirs.contains(':'))
+      {
+         MyString nextDir=kdeDirs.left(kdeDirs.find(':'));
+         kdeDirs=kdeDirs.mid(kdeDirs.find(':')+1);
+         nextDir=nextDir+tmpBase;
+         mdcerr<<"trying to open "<<nextDir<<std::endl;
+         if (fileReadable(nextDir))
+            return nextDir;
+      };
+      kdeDirs=kdeDirs+tmpBase;
+      mdcerr<<"trying to open "<<kdeDirs<<std::endl;
+      if (fileReadable(kdeDirs))
+         return kdeDirs;
+      kdeDirs="/etc/";
+      kdeDirs=kdeDirs+tmpBase;
+      if (fileReadable(kdeDirs))
+         return kdeDirs;
+      return "";
+   }*/
+   return "";
+}
+
+int NetManager::run()
+{
+   int continueMainLoop(1);
+   //not forever
+	while(continueMainLoop)
+   {
+      mdcerr<<"\nNetManager::run: next loop: "<<clients.size()<<" clients"<<std::endl;
+      fd_set tmpFDs;
+      generateFDset(&tmpFDs);
+
+      int result=waitForSomethingToHappen(&tmpFDs);
+      mdcerr<<"NetManager::run: something happened..."<<std::endl;
+      //timeout
+      if (result==0)
+      {
+         mdcerr<<"NetManager::run: serverServer=="<<m_serverServer<<std::endl;
+         mdcerr<<"NetManager::run: scanning after timeout"<<std::endl;
+         scan();
+      }
+      else
+      {
+         //a new connection ?
+         if (FD_ISSET(m_listenFD,&tmpFDs))
+         {
+            mdcerr<<"NetManager::run: on m_listenFD"<<std::endl;
+            struct sockaddr_in clientAddress;
+            socklen_t clilen(sizeof(clientAddress));
+//            bzero((char*)&clientAddress, clilen);
+            memset((void*)&clientAddress,0,sizeof(clientAddress));
+            int connectionFD=::accept(m_listenFD,(struct sockaddr *) &clientAddress, &clilen);
+            if ((validator.isValid(clientAddress.sin_addr.s_addr)) || (m_strictMode))
+            {
+               mdcerr<<"NetManager::run: adding client"<<std::endl;
+               addClient(connectionFD);
+               m_servedThisPeriod=1;
+               m_refreshTime=m_initialRefreshTime;
+               m_increasedRefreshTime=0;
+            }
+            else
+            {
+               mdcerr<<"NetManager::run: kicking client"<<std::endl;
+               ::close(connectionFD);
+            }
+         }
+         checkClientsAndPipes(&tmpFDs);
+      }
+      serveAndClean();
+   }
+   return 1;
+}
+
+void NetManager::addClient(int socketFD)
+{
+   mdcerr<<"NetManager::addClient on FD="<<socketFD<<std::endl;
+   if (socketFD==-1) return;
+   Client c(this,socketFD,0);
+   clients.push_back(c);
+}
+
+void NetManager::checkClientsAndPipes(fd_set *tmpFDs)
+{
+   mdcerr<<"NetManager::checkClientsAndPipes()"<<std::endl;
+   //actually the clients should not send anything
+//   for (Client *tmpClient=clients.first(); tmpClient!=0; tmpClient=clients.next())
+   for (std::list<Client>::iterator tmpClient=clients.begin(); tmpClient != clients.end(); tmpClient++)
+   {
+      mdcerr<<"NetManager::checkClientsAndPipes: checking client"<<std::endl;
+      if (FD_ISSET(tmpClient->fd(),tmpFDs))
+      {
+         mdcerr<<"NetManager::checkClientsAndPipes: client sent something"<<std::endl;
+         tmpClient->read();
+      }
+   }
+
+   //now check wether we received a broadcast
+   //m_bcFD should always be -1 in strictMode
+   if ((m_bcFD!=-1) && (!m_strictMode))
+   {
+      mdcerr<<"NetManager::checkClientsAndPipe: checking bcFD"<<std::endl;
+      //yes !
+      if (FD_ISSET(m_bcFD,tmpFDs))
+         answerBroadcast();
+   }
+
+   //read the stuff from the forked pipe
+   if (m_pipeFD!=-1)
+   {
+      mdcerr<<"NetManager::checkClientsAndPipe: checking pipe"<<std::endl;
+      if (FD_ISSET(m_pipeFD,tmpFDs))
+      {
+         mdcerr<<"NetManager::checkClientsAndPipes: pipe sent something"<<std::endl;
+         int result=readDataFromFD(m_pipeFD);
+         if (result!=1)
+         {
+            ::close(m_pipeFD);
+            m_pipeFD=-1;
+            mdcerr<<"NetManager::checkClientsAndPipes: everything read from pipe from proc "<<m_childPid<<std::endl;
+            processScanResults();
+         }
+      }
+   }
+}
+
+void NetManager::answerBroadcast()
+{
+   //actually we should never get here in strictMode
+   if (m_strictMode) return;
+   
+   //this one is called only in checkClientsAndPipes()
+   //if we are sure that we received something on m_bcFD
+   //so we don't need to check here again
+   
+   mdcerr<<"NetManager::answerBroadcast: received BC"<<std::endl;
+   struct sockaddr_in sAddr;
+   socklen_t length(sizeof(sockaddr_in));
+   char buf[1024];
+   int result=recvfrom(m_bcFD, (char*)buf, 1024, 0, (sockaddr*)&sAddr,&length);
+   mdcerr<<"NetManager::answerBroadcast: received successfully"<<std::endl;
+   //did recvfrom() succeed ?
+   //our frame is exactly MYFRAMELENGTH bytes big, if the received one has a different size,
+   //it must be something different
+   if (result!=MYFRAMELENGTH) return;
+   //if it has the correct size, it also must have the correct identifier
+   MyFrameType *frame=(MyFrameType*)(void*)buf;
+   if ((ntohl(frame->id)!=MY_ID) ||
+       ((ntohl(frame->unused1)==getpid()) && (ntohl(frame->unused2)==m_startedAt)))
+   {
+      mdcerr<<"NetManager::answerBroadcast: must be the same machine"<<std::endl;
+      return;
+   }
+
+   //mdcerr<<"received "<<ntohl(buf[0])<<" from "<<inet_ntoa(sAddr.sin_addr)<<hex<<" ";
+   //mdcerr<<sAddr.sin_addr.s_addr<<" //"<<ntohl(sAddr.sin_addr.s_addr)<<dec<<std::endl;
+   //will we answer this request ?
+   if (!validator.isValid(sAddr.sin_addr.s_addr))
+   {
+      mdcerr<<"NetManager::answerBroadcast: invalid sender"<<std::endl;
+      return;
+   }
+
+   //create the answering socket
+
+   int answerFD=::socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+   if (answerFD==-1)
+   {
+      mdcerr<<"NetManager::answerBroadcast: could not create answering socket"<<std::endl;
+      return;
+   }
+   
+   sAddr.sin_family=AF_INET;
+   sAddr.sin_port=htons(m_basePort+1);
+   MyFrameType answerFrame;
+   answerFrame.id=htonl(MY_ID);
+   answerFrame.unused1=0;
+   answerFrame.unused2=0;
+   //don't care about the result
+   mdcerr<<"NetManager::answerBroadcast: sending answer"<<std::endl;
+
+   result=::sendto(answerFD,(char*)&answerFrame,sizeof(answerFrame),0,(sockaddr*)&sAddr,length);
+   mdcerr<<"sent "<<result<<" byte using sendto"<<std::endl;
+   ::close(answerFD);
+   //sent answer
+}
+
+void NetManager::serveAndClean()
+{
+   //try to serve the request
+//   for (Client *tmpClient=clients.first(); tmpClient!=0; tmpClient=clients.next())
+   for (std::list<Client>::iterator tmpClient=clients.begin(); tmpClient != clients.end(); tmpClient++)
+   {
+      mdcerr<<"NetManager::serveAndClean: trying to get info"<<std::endl;
+      tmpClient->tryToGetInfo();
+   }
+   
+   //try to delete served the clients
+   /** PM: substituted STL code
+   for (Client* tmpClient=clients.first();tmpClient!=0; tmpClient=clients.next())
+   {
+      //if we served the client or if he's already half a minute
+      //connected remove it
+      //this way we get rid of clients if something went wrong and
+      //maybe it's even a security point, I don't know
+      if ((tmpClient->done()) || (tmpClient->age()>30))
+      {
+         mdcerr<<"NetManager::serveAndClean: removing Client"<<std::endl;
+         clients.remove(tmpClient);
+         tmpClient=clients.first();
+      }
+      }*/
+   clients.remove_if(client_is_done());
+}
+
+void NetManager::scan()
+{
+   mdcerr<<"NetManager::scan()"<<std::endl;
+   if (isBeingScanned()) return;
+
+   time_t currentTime=time(0);
+   mdcerr<<"currentTime: "<<currentTime<<" lastUpdate: "<<m_lastUpdate<<std::endl;
+   if ((currentTime-m_lastUpdate)<m_refreshTime) return;
+   mdcerr<<"NetManager::scan: scanning..."<<std::endl;
+
+   m_isBeingScanned=1;
+   int fileDescr[2];
+   ::pipe(fileDescr);
+   mdcerr<<"NetScanner::scan: file-descr[0]: "<<fileDescr[0]<<std::endl;
+   mdcerr<<"NetScanner::scan: file-descr[1]: "<<fileDescr[1]<<std::endl;
+   int pid=fork();
+	if (pid==-1)
+	{
+      mdcerr<<"NetScanner::scan: error occurred"<<std::endl;
+      return;
+   }
+   else if (pid!=0)
+   {
+      //parent
+      ::close(fileDescr[1]);
+      m_pipeFD=fileDescr[0];
+      m_childPid=pid;
+      return;
+   }
+   //child
+   procId="** child ** ";
+   mdcerr<<" NetManager::scan: a child was born"<<std::endl;
+   if (m_strictMode)
+   {
+      mdcerr<<" NetManager::scan: scanning myself in strict mode, becoming serverServer"<<std::endl;
+      doScan();
+      //in the child we don't have to call setServerServer()
+      //since this opens the listening socket, what has to be done
+      //in the parent process
+      m_serverServer=1;
+   }
+   else
+   {
+      int serverAddress=findServerServer();
+      if (serverAddress==0)
+      {
+         mdcerr<<" NetManager::scan: scanning myself, becoming serverServer"<<std::endl;
+         doScan();
+         //in the child we don't have to call setServerServer()
+         //since this opens the listening socket, what has to be done
+         //in the parent process
+         m_serverServer=1;
+      }
+      else
+      {
+         mdcerr<<" NetManager::scan: getting list from serverServer"<<std::endl;
+         getListFromServerServer(serverAddress);
+         m_serverServer=0;
+      }
+   }
+   mdcerr<<" NetScanner::scan: sending information to parent process"<<std::endl;
+   writeDataToFD(fileDescr[1],m_serverServer);
+   mdcerr<<" NetScanner::scan: closed FD: "<<::close(fileDescr[1])<<std::endl;
+   mdcerr<<" NetScanner::scan: exiting now"<<std::endl;
+   ::exit(0);
+}
+
+int NetManager::writeDataToFD(int fd, int serverServer)
+{
+   mdcerr<<" NetManager::writeDataToFD fd="<<fd<<std::endl;
+   m_serveCount++;
+   char buffer[1024];
+   
+   int length;
+//   for (Node* tmpNode=hostList->first(); tmpNode!=0; tmpNode=hostList->next())
+   for (std::list<Node>::iterator tmpNode=hostList->begin(); tmpNode!=hostList->end(); tmpNode++)
+   {
+      sprintf(buffer,"%u %s\n",tmpNode->ip,tmpNode->name.left(1000).c_str());
+      length=strlen(buffer)+1;
+      const char *currentBuf=buffer;
+      //make sure that everything is written
+      while (length>0)
+      {
+         int result=::write(fd,currentBuf,length);
+         mdcerr<<"NetManager::writeDataToFD: wrote "<<result<<" bytes"<<std::endl;
+         if (result==-1)
+         {
+            perror("hmmpf: ");
+            return 0;
+         }
+         length-=result;
+         currentBuf+=result;
+      }
+   }
+   //and a last line
+   sprintf(buffer,"%d succeeded\n",serverServer);
+   length=strlen(buffer)+1;
+   const char *currentBuf=buffer;
+   //make sure that everything is written
+   while (length>0)
+   {
+      int result=::write(fd,currentBuf,length);
+      if (result==-1) return 0;
+      length-=result;
+      currentBuf+=result;
+   }
+   return 1;
+}
+
+int NetManager::readDataFromFD(int fd)
+{
+   mdcerr<<"NetManager::readDataFromFD"<<std::endl;
+   char tmpBuf[64*1024];
+   int result=::read(fd,tmpBuf,64*1024);
+   mdcerr<<"NetManager::readDataFromFD: read "<<result<<" bytes"<<std::endl;
+   if (result==-1) return -1;
+   if (result==0)
+   {
+      mdcerr<<"NetManager::readDataFromFD: FD was closed"<<std::endl;
+      return 0;
+   }
+   char *newBuf=new char[m_receivedBytes+result];
+   if (m_receiveBuffer!=0) memcpy(newBuf,m_receiveBuffer,m_receivedBytes);
+   memcpy(newBuf+m_receivedBytes,tmpBuf,result);
+   m_receivedBytes+=result;
+   if (m_receiveBuffer!=0) delete [] m_receiveBuffer;
+   m_receiveBuffer=newBuf;
+   // too much data - abort at 2MB to avoid memory exhaustion
+   if (m_receivedBytes>2*1024*1024)
+     return 0;
+
+   return 1;
+}
+
+int NetManager::processScanResults()
+{
+   mdcerr<<"NetManager::processScanResults"<<std::endl;
+   if (m_receiveBuffer==0) return 0;
+   std::list<Node> *newNodes=new std::list<Node>;
+
+   char *tmpBuf=m_receiveBuffer;
+   int bytesLeft=m_receivedBytes;
+   mdcerr<<"m_receivedBytes: "<<m_receivedBytes<<" bytesLeft: "<<bytesLeft<<std::endl;
+   //this should be large enough for a name
+   //and the stuff which is inserted into the buffer
+   //comes only from ourselves ... or attackers :-(
+   char tmpName[1024*4];
+   while (bytesLeft>0)
+   {
+      int tmpIP=2;  // well, some impossible IP address, 0 and 1 are already used for the last line of output
+      tmpName[0]='\0';
+      if ((memchr(tmpBuf,0,bytesLeft)==0) || (memchr(tmpBuf,int('\n'),bytesLeft)==0))
+      {
+         delete newNodes;
+         hostList->clear();
+
+         m_lastUpdate=time(0);
+         delete [] m_receiveBuffer;
+         m_receiveBuffer=0;
+         m_receivedBytes=0;
+         m_isInformed=1;
+         m_isBeingScanned=0;
+         return 0;
+      }
+      //mdcerr<<"NetManager::processScanResults: processing -"<<tmpBuf;
+      //since we check for 0 and \n with memchr() we can be sure
+      //at this point that tmpBuf is correctly terminated
+      int length=strlen(tmpBuf)+1;
+      if (length<(4*1024))
+         sscanf(tmpBuf,"%u %s\n",&tmpIP,tmpName);
+
+      bytesLeft-=length;
+      tmpBuf+=length;
+      mdcerr<<"length: "<<length<<" bytesLeft: "<<bytesLeft<<std::endl;
+      if ((bytesLeft==0) && ((tmpIP==0) ||(tmpIP==1)) && (strstr(tmpName,"succeeded")!=0))
+      {
+         mdcerr<<"NetManager::processScanResults: succeeded :-)"<<std::endl;
+         delete hostList;
+         hostList=newNodes;
+
+         m_lastUpdate=time(0);
+         delete [] m_receiveBuffer;
+         m_receiveBuffer=0;
+         m_receivedBytes=0;
+         m_isInformed=1;
+         m_isBeingScanned=0;
+         adjustRefreshTime(tmpIP);
+         enableServerServer(tmpIP);
+         //m_serverServer=tmpIP;
+
+         return 1;
+      }
+      else if (tmpIP!=2)
+      {
+         //mdcerr<<"NetManager::processScanResults: adding host: "<<tmpName<<" with ip: "<<tmpIP<<std::endl;
+         newNodes->push_back(Node(tmpName,tmpIP));
+      }
+   }
+   //something failed :-(
+   delete newNodes;
+   hostList->clear();
+
+   m_lastUpdate=time(0);
+   delete [] m_receiveBuffer;
+   m_receiveBuffer=0;
+   m_receivedBytes=0;
+   m_isInformed=1;
+   m_isBeingScanned=0;
+
+   mdcerr<<"NetScanner::processScanResult: finished"<<std::endl;
+   return 0;
+}
+
+void NetManager::adjustRefreshTime(int serverServer)
+{
+   //we are becoming server server
+   if (((m_serverServer==0) && (serverServer)) || (m_servedThisPeriod))
+   {
+      m_increasedRefreshTime=0;
+      m_refreshTime=m_initialRefreshTime;
+   }
+   //nobody accessed the server since the last update
+   //so increase the refresh time
+   //this should happen more seldom to the serverServer
+   //than to others
+   else
+   {
+      //up to the 16 times refresh time
+      if (m_increasedRefreshTime<4)
+      {
+         m_increasedRefreshTime++;
+         m_refreshTime*=2;
+      };
+   };
+   m_servedThisPeriod=0;
+   
+}
+
+void NetManager::enableServerServer(int on)
+{
+   mdcerr<<"NetManager::enableServerServer: "<<on<<std::endl;
+   //in strictMode we don't listen to broadcasts from the network
+   if (m_strictMode) return;
+
+   m_serverServer=on;
+   if (on)
+   {
+      //nothing has to be done
+      if (m_bcFD!=-1) return;
+      // otherwise create the socket which will listen for broadcasts
+      sockaddr_in my_addr;
+      my_addr.sin_family=AF_INET;
+      my_addr.sin_port=htons(m_basePort);
+      my_addr.sin_addr.s_addr=0;
+
+      m_bcFD=::socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+      if (m_bcFD==-1)
+      {
+         mdcerr<<"NetManager::enableServerServer: socket() failed"<<std::endl;
+         m_serverServer=0;
+         return;
+      };
+      int on(1);
+      int result=setsockopt(m_bcFD, SOL_SOCKET, SO_REUSEADDR, (char*)&on, sizeof(on));
+      if (result!=0)
+      {
+         mdcerr<<"NetManager::enableServerServer: setsockopt(SO_REUSEADDR) failed"<<std::endl;
+         m_serverServer=0;
+         ::close(m_bcFD);
+         m_bcFD=-1;
+         return;
+      };
+      result=::bind(m_bcFD, (struct sockaddr *) &my_addr, sizeof(my_addr));
+      if (result!=0)
+      {
+         mdcerr<<"NetManager::enableServerServer: bind (UDP) failed"<<std::endl;
+         m_serverServer=0;
+         ::close(m_bcFD);
+         m_bcFD=-1;
+         return;
+      };
+   }
+   else
+   {
+      ::close(m_bcFD);
+      m_bcFD=-1;
+   };
+}
+
+int NetManager::findServerServer()
+{
+   mdcerr<<" NetManager::findServerServer"<<std::endl;
+   //actually this should never be called in strictMode
+   if (m_strictMode) return 0;
+   if (!validator.isValid(m_broadcastAddress))
+   {
+      mdcerr<<" NetManager::findServerServer: invalid broadcastAddress"<<std::endl;
+      return 0;
+   };
+   //create a socket for sending the broadcast
+   //we don't have to set SO_REUSEADDR, since we don't call bind()
+   //to this socket
+   int requestFD=::socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+   if (requestFD==-1)
+   {
+      mdcerr<<" NetManager::findServerServer: could not create request socket"<<std::endl;
+      return 0;
+   };
+
+   int on(1);
+   //this is actually the only socket which will send broacasts
+   int result=setsockopt(requestFD, SOL_SOCKET, SO_BROADCAST,(char*)&on, sizeof(on));
+   if (result!=0)
+   {
+      mdcerr<<"setsockopt(SO_BROADCAST) failed"<<std::endl;
+      ::close(requestFD);
+      return 0;
+   };
+   
+   //create a socket for receiving the answers
+   int answerFD=::socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+   if (answerFD==-1)
+   {
+      mdcerr<<" NetManager::findServerServer"<<std::endl;
+      ::close(requestFD);
+      return 0;
+   };
+   
+   //since this socket will be bound, we have to set SO_REUSEADDR
+   result=setsockopt(answerFD, SOL_SOCKET, SO_REUSEADDR, (char*)&on, sizeof(on));
+   if (result!=0)
+   {
+      mdcerr<<"setsockopt(SO_REUSEADDR) failed"<<std::endl;
+      ::close(answerFD);
+      ::close(requestFD);
+      return 0;
+   };
+   
+   sockaddr_in my_addr;
+   my_addr.sin_family=AF_INET;
+   my_addr.sin_port=htons(m_basePort+1);
+   my_addr.sin_addr.s_addr=0;
+   //this one has to be bound
+   result=::bind(answerFD, (struct sockaddr *) &my_addr, sizeof(my_addr));
+   if (result!=0)
+   {
+      mdcerr<<"bind (UDP) failed"<<std::endl;
+      ::close(answerFD);
+      ::close(requestFD);
+      return 0;
+   };
+   
+   //now send the broadcast
+   struct sockaddr_in sAddr;
+   sAddr.sin_addr.s_addr=m_broadcastAddress;
+   sAddr.sin_family=AF_INET;
+   sAddr.sin_port=htons(m_basePort);
+   socklen_t length(sizeof(sockaddr_in));
+   mdcerr<<" NetManager::findServerServer: broadcasting to: "
+   <<std::ios::hex<<m_broadcastAddress<<std::ios::dec<<std::endl;
+   
+   MyFrameType requestFrame;
+   requestFrame.id=htonl(MY_ID);
+   requestFrame.unused1=htonl(getppid());
+   requestFrame.unused2=htonl(m_startedAt);
+
+   result=::sendto(requestFD,(char*)&requestFrame,sizeof(requestFrame),0,(sockaddr*)&sAddr,length);
+   ::close(requestFD);
+   if (result!=MYFRAMELENGTH)
+   {
+      mdcerr<<" NetManager::findServerServer: sent wrong number of bytes: "<<result<<std::endl;
+      ::close(answerFD);
+      return 0;
+   };
+   //wait for an answer
+   struct timeval tv;
+   tv.tv_sec=0;
+   tv.tv_usec=1000*250; //0.1 sec
+   fd_set fdSet;
+   FD_ZERO(&fdSet);
+   FD_SET(answerFD,&fdSet);
+   result=select(answerFD+1,&fdSet,0,0,&tv);
+   if (result<0)
+   {
+      mdcerr<<" NetManager::findServerServer: select() failed: "<<result<<std::endl;
+      mdcerr<<" NetManager::findServerServer: answerFD="<<answerFD<<std::endl;
+      perror("select:");
+      ::close(answerFD);
+      return 0;
+   }
+   if (result==0)
+   {
+      mdcerr<<" NetManager::findServerServer: nobody answered "<<std::endl;
+      ::close(answerFD);
+      return 0;
+   }
+   mdcerr<<"received offer "<<std::endl;
+   struct sockaddr_in addr;
+   length=sizeof(sockaddr_in);
+   char buf[1024];
+   result=recvfrom(answerFD, (char*)buf, 1024, 0, (sockaddr*) &addr,&length);
+   if (result!=MYFRAMELENGTH)
+   {
+      mdcerr<<" NetManager::findServerServer: wrong number of bytes: "<<result<<std::endl;
+      ::close(answerFD);
+      return 0;
+   };
+   MyFrameType *frame=(MyFrameType*)(void*)buf;
+   //wrong identifier ?
+   if (ntohl(frame->id)!=MY_ID)
+   {
+      mdcerr<<" NetManager::findServerServer: wrong id"<<std::endl;
+      ::close(answerFD);
+      return 0;
+   };
+
+   mdcerr<<"received from "<<inet_ntoa(addr.sin_addr)<<std::endl;
+
+   ::close(answerFD);
+   //return the ip of the server server in network byte order
+   return addr.sin_addr.s_addr;
+}
+
+void NetManager::getListFromServerServer( int address)
+{
+   mdcerr<<"NetManager::getListFromServerServer"<<std::endl;
+   //actually we should never get here in strictMode
+   if (m_strictMode) return;
+   //open a tcp socket to the serverserver
+   int serverServerFD=::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+   if (serverServerFD==-1)
+      return;
+   sockaddr_in addr;
+   //we get the address already in network byte order
+   addr.sin_addr.s_addr=address;
+   addr.sin_family=AF_INET;
+   addr.sin_port=htons(m_basePort);
+   int result=::connect(serverServerFD,(sockaddr*)&addr,sizeof(addr));
+   if (result!=0)
+   {
+      ::close(serverServerFD);
+      return;
+   };
+   do
+   {
+      result=readDataFromFD(serverServerFD);
+   } while (result==1);
+   ::close(serverServerFD);
+   processScanResults();
+   mdcerr<<"NetManager::getListFromServerServer succeeded"<<std::endl;
+}
+
+void NetManager::printState()
+{
+   std::cerr<<"LAN Information Server Lisa "MYVERSION"\nAlexander Neundorf <neundorf@kde.org>\n";
+   std::cerr<<"Reading options from config file: "<<m_usedConfigFileName<<std::endl;
+   std::cerr<<"StrictMode: "<<m_strictMode<<std::endl;
+   std::cerr<<"ServerServer: "<<m_serverServer<<std::endl;
+   std::cerr<<"UseNmblookup: "<<m_useNmblookup<<std::endl;
+   std::cerr<<"Pinging: "<<ipRangeStr<<std::endl;
+   std::cerr<<"Allowed hosts: "<<validator.validAddresses()<<std::endl;
+   std::cerr<<"Broadcasting to: "<<std::ios::hex<<ntohl(m_broadcastAddress)<<std::ios::dec<<std::endl;
+   std::cerr<<"Initial update period: "<<m_initialRefreshTime<<" seconds"<<std::endl;
+   std::cerr<<"Current update period: "<<m_refreshTime<<" seconds"<<std::endl;
+   std::cerr<<"Last update: "<<time(0)-m_lastUpdate<<" seconds over"<<std::endl;
+   std::cerr<<"Waiting "<<m_firstWait<<" 1/100th seconds for echo answers on the first try"<<std::endl;
+   std::cerr<<"Waiting "<<m_secondWait<<" 1/100th seconds for echo answers on the second try"<<std::endl;
+   std::cerr<<"Sending "<<m_maxPings<<" echo requests at once"<<std::endl;
+   std::cerr<<"Publishing unnamed hosts: "<<m_deliverUnnamedHosts<<std::endl;
+   std::cerr<<"Already served "<<m_serveCount<<" times"<<std::endl;
+}
+
+//this one is not used at the moment
+/*int NetManager::uptime()
+{
+   return (time(0)-m_startedAt);
+};*/