From bcb704366cb5e333a626c18c308c7e0448a8e69f Mon Sep 17 00:00:00 2001
From: toma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>
Date: Wed, 25 Nov 2009 17:56:58 +0000
Subject: 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
---
 lanbrowsing/lisa/netscanner.cpp | 663 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 663 insertions(+)
 create mode 100644 lanbrowsing/lisa/netscanner.cpp

(limited to 'lanbrowsing/lisa/netscanner.cpp')

diff --git a/lanbrowsing/lisa/netscanner.cpp b/lanbrowsing/lisa/netscanner.cpp
new file mode 100644
index 00000000..acf0515c
--- /dev/null
+++ b/lanbrowsing/lisa/netscanner.cpp
@@ -0,0 +1,663 @@
+/*    netscanner.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 "netscanner.h"
+#include "ipaddress.h"
+#include "lisadefines.h"
+#include <iostream>
+
+#ifdef LISA_DEBUG
+#undef LISA_DEBUG
+#endif
+#define LISA_DEBUG 0
+
+#ifdef dcerr
+#undef dcerr
+#endif
+
+#ifdef mdcerr
+#undef mdcerr
+#endif
+
+#define dcerr if (LISA_DEBUG==1) std::cerr<<"NetScanner::"
+#define mdcerr if (LISA_DEBUG==1) std::cerr<<procId<<" NetScanner::"
+
+#include <stdio.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#ifdef __osf__
+#undef BYTE_ORDER
+#define _OSF_SOURCE
+#undef _MACHINE_ENDIAN_H_
+#undef __STDC__
+#define __STDC__ 0
+#include <netinet/ip.h>
+#undef __STDC__
+#define __STDC__ 1
+#endif
+#include <netinet/in_systm.h>
+#include <netinet/ip.h>
+#include <netinet/ip_icmp.h>
+
+#ifndef INADDR_NONE
+#define INADDR_NONE -1
+#endif
+
+struct ICMPEchoRequest
+{
+   unsigned char type;
+   unsigned char code;
+   unsigned short int checkSum;
+   unsigned short id;
+   unsigned short seqNumber;
+};
+
+unsigned short in_cksum(unsigned short *addr, int len)
+{
+   int nleft = len;
+	int sum(0);
+	unsigned short	*w = addr;
+	unsigned short	answer = 0;
+
+	/*
+	 * Our algorithm is simple, using a 32 bit accumulator (sum), we add
+	 * sequential 16 bit words to it, and at the end, fold back all the
+	 * carry bits from the top 16 bits into the lower 16 bits.
+	 */
+   while (nleft > 1)
+   {
+      sum += *w++;
+      nleft -= 2;
+	}
+
+   /* 4mop up an odd byte, if necessary */
+   if (nleft == 1)
+   {
+		*(unsigned char *)(&answer) = *(unsigned char *)w ;
+      sum += answer;
+   }
+
+   /* 4add back carry outs from top 16 bits to low 16 bits */
+   sum = (sum >> 16) + (sum & 0xffff);	/* add hi 16 to low 16 */
+   sum += (sum >> 16);			/* add carry */
+   answer = ~sum;				/* truncate to 16 bits */
+   return(answer);
+}
+
+
+NetScanner::NetScanner(int& rawSocketFD, int strictMode)
+:procId("")
+,m_firstWait(5)
+,m_secondWait(15)
+,m_strictMode(strictMode)
+,m_rawSocketFD(rawSocketFD)
+,validator()
+,ipRangeStr(";")
+,m_maxPings(256)
+,m_deliverUnnamedHosts(0)
+,m_useNmblookup(0)
+,hostList(0)
+,tmpIPRange("")
+{}
+
+NetScanner::~NetScanner()
+{
+//   std::cerr<<"----------- Netscanner dtor "<<std::endl;
+   delete hostList;
+   ::close(m_rawSocketFD);
+}
+
+void addMissingSemicolon(MyString& text)
+{
+   if (text.isEmpty()) return;
+   if (text[text.length()-1]!=';')
+      text+=';';
+}
+
+void NetScanner::configure(Config& config)
+{
+   //ranges are not allowed in strict mode
+   if (!m_strictMode)
+   {
+      ipRangeStr=stripWhiteSpace(config.getEntry("PingAddresses",""));
+      addMissingSemicolon(ipRangeStr);
+   }
+   MyString pingNames=stripWhiteSpace(config.getEntry("PingNames",""));
+   addMissingSemicolon(pingNames);
+   MyString nextName;
+   int semicolonPos=pingNames.find(';');
+   int hostsAdded(0);
+   while (semicolonPos!=-1)
+   {
+      nextName=pingNames.left(semicolonPos);
+      mdcerr<<"configure(): looking up -"<<nextName<<"-"<<std::endl;
+      //now the name lookup
+      in_addr server_addr;
+      hostent *hp=gethostbyname(nextName.data());
+      if (hp!=0)
+      {
+         if ((m_strictMode) && (hostsAdded>=STRICTMODEMAXHOSTS))
+            break;
+         memcpy(&server_addr, hp->h_addr, sizeof(server_addr));
+         char *ip=inet_ntoa(server_addr);
+         mdcerr<<"configure(): looking up "<<nextName<<" gives -"<<ip<<"-"<<std::endl;
+         ipRangeStr=ipRangeStr+ip+';';
+         hostsAdded++;
+      }
+
+      pingNames=pingNames.mid(semicolonPos+1);
+      semicolonPos=pingNames.find(';');
+   }
+   if ((!ipRangeStr.isEmpty()) && (ipRangeStr[0]==';'))
+      ipRangeStr=ipRangeStr.mid(1);
+   m_deliverUnnamedHosts=config.getEntry("DeliverUnnamedHosts",0);
+   m_useNmblookup=config.getEntry("SearchUsingNmblookup",0);
+   m_maxPings=config.getEntry("MaxPingsAtOnce",256);
+   m_firstWait=config.getEntry("FirstWait",5);
+   m_secondWait=config.getEntry("SecondWait",15);
+   if (m_firstWait<1) m_firstWait=1;
+   if (m_maxPings<8) m_maxPings=8;
+   if (m_maxPings>1024) m_maxPings=1024;
+   //on some systems (Solaris ?) select() doesn't work correctly
+   // if the microseconds are more than 1.000.000
+   if (m_firstWait>99) m_firstWait=99;
+   if (m_secondWait>99) m_secondWait=99;
+   mdcerr<<"configure(): "<<ipRangeStr<<std::endl;
+}
+
+struct in_addr NetScanner::getIPfromArray(unsigned int index)
+{
+   //mdcerr<<std::endl<<"*** start ***"<<std::endl;
+   unsigned int tmpIndex(0),indexLeft(index);
+   resetIPRange();
+   MyString tmp(getNextIPRange());
+//   mdcerr<<"NetScanner::getIPFromArray: -"<<tmp<<"-"<<std::endl;
+   while (!tmp.isEmpty())
+   {
+      if (tmp.contains('/'))
+      {
+         //mdcerr<<"net/mask combination detected"<<std::endl;
+         MyString netStr(tmp.left(tmp.find("/")));
+         MyString maskStr(tmp.mid(tmp.find("/")+1));
+         unsigned int mask(IPAddress(maskStr).asInt());
+         unsigned int net(IPAddress(netStr).asInt()&mask);
+         if ((~mask)<indexLeft)
+         {
+            indexLeft=indexLeft-(~mask+1);
+            tmpIndex+=(~mask)+1;
+            //mdcerr<<"i: "<<tmpIndex<<" left: "<<indexLeft<<std::endl;
+         }
+         else
+         {
+            net+=indexLeft;
+            return IPAddress(net).asStruct();
+            //return string2Struct(ipInt2String(net));
+         }
+      }
+      else if (tmp.contains('-')==1)
+      {
+         //mdcerr<<"single range detected"<<std::endl;
+         MyString fromIPStr(tmp.left(tmp.find("-")));
+         MyString toIPStr(tmp.mid(tmp.find("-")+1));
+         //mdcerr<<"fromIPStr: "<<fromIPStr<<std::endl;
+         //mdcerr<<"toIPStr: "<<toIPStr<<std::endl;
+         unsigned int fromIP(IPAddress(fromIPStr).asInt());
+         unsigned int toIP(IPAddress(toIPStr).asInt());
+         //unsigned int fromIP(ipString2Int(fromIPStr)), toIP(ipString2Int(toIPStr));
+         //index hinter diesem bereich
+         if ((fromIP+indexLeft)>toIP)
+         {
+            tmpIndex+=1+toIP-fromIP;
+            indexLeft=indexLeft-(1+toIP-fromIP);
+            //mdcerr<<"i: "<<tmpIndex<<" left: "<<indexLeft<<std::endl;
+         }
+         //index in diesem bereich
+         else
+         {
+            fromIP+=indexLeft;
+            return IPAddress(fromIP).asStruct();
+            //return string2Struct(ipInt2String(fromIP));
+         }
+         
+      }
+      else if (tmp.contains('-')==4)
+      {
+         //mdcerr<<"multiple range detected"<<std::endl;
+         int cp(tmp.find('-'));
+         int from1(atoi(tmp.left(cp).data()));
+         tmp=tmp.mid(cp+1);
+
+         cp=tmp.find('.');
+         int to1(atoi(tmp.left(cp).data()));
+         tmp=tmp.mid(cp+1);
+
+         cp=tmp.find('-');
+         int from2(atoi(tmp.left(cp).data()));
+         tmp=tmp.mid(cp+1);
+
+         cp=tmp.find('.');
+         int to2(atoi(tmp.left(cp).data()));
+         tmp=tmp.mid(cp+1);
+
+         cp=tmp.find('-');
+         int from3(atoi(tmp.left(cp).data()));
+         tmp=tmp.mid(cp+1);
+
+         cp=tmp.find('.');
+         int to3(atoi(tmp.left(cp).data()));
+         tmp=tmp.mid(cp+1);
+
+         cp=tmp.find('-');
+         int from4(atoi(tmp.left(cp).data()));
+         tmp=tmp.mid(cp+1);
+
+         int to4(atoi(tmp.data()));
+         
+         unsigned int count((1+to4-from4)*(1+to3-from3)*(1+to2-from2)*(1+to1-from1));
+         if (count<indexLeft)
+         {
+            tmpIndex+=count;
+            indexLeft-=count;
+            //mdcerr<<"i: "<<tmpIndex<<" left: "<<indexLeft<<std::endl;
+         }
+         else
+         {
+            for (int b1=from1; b1<=to1; b1++)
+               for (int b2=from2; b2<=to2; b2++)
+                  for (int b3=from3; b3<=to3; b3++)
+                     for (int b4=from4; b4<=to4; b4++)
+                     {
+                        if (tmpIndex==index)
+                        {
+                           return IPAddress(b1,b2,b3,b4).asStruct();
+                        };
+                        tmpIndex++;
+                        indexLeft--;
+                        //mdcerr<<"i: "<<tmpIndex<<" left:"<<indexLeft<<std::endl;
+                     }
+         }
+      }
+      //single IP address
+      else if (tmp.contains('.')==3)
+      {
+         //mdcerr<<"single IP address detected"<<std::endl;
+         //if (tmpIndex==index) return string2Struct(tmp);
+         if (tmpIndex==index) return IPAddress(tmp).asStruct();
+         else
+         {
+            tmpIndex++;
+            indexLeft--;
+            //mdcerr<<"i: "<<tmpIndex<<" left: "<<indexLeft<<std::endl;
+         }
+      }
+      //mdcerr<<"nextIPRange: *"<<tmp<<"*"<<std::endl;
+      tmp=getNextIPRange();
+   }
+   return IPAddress("0.0.0.0").asStruct();
+}
+
+void NetScanner::resetIPRange()
+{
+   tmpIPRange=ipRangeStr;
+}
+
+MyString NetScanner::getNextIPRange()
+{
+   if (tmpIPRange.contains(';')<1) return "";
+   int cp(tmpIPRange.find(';'));
+   MyString tmp(tmpIPRange.left(cp));
+   tmpIPRange=tmpIPRange.mid(cp+1);
+   return tmp;
+}
+
+char* NetScanner::ip2Name(struct in_addr ip)
+{
+   struct hostent *hostname=0;
+   // Set the hostname of node
+   if ( ( hostname = gethostbyaddr( (char *) &ip.s_addr, 4, AF_INET  ) ) == 0 )
+   {
+      mdcerr << "ip2Name gethostbyname* error" << std::endl;
+      return inet_ntoa( ip );
+   }
+   mdcerr<<"ip2name -"<<hostname->h_name<<std::endl;
+   return hostname->h_name;
+}
+
+void NetScanner::nmblookupScan(std::list<Node>* newList)
+{
+   mdcerr<<"nmblookupScan()"<<std::endl;
+   //newList->clear();
+   FILE * nmblookupFile=popen("nmblookup \"*\"","r");
+   //no success
+   if (nmblookupFile==0)
+   {
+      mdcerr<<"nmblookupScan(): could not start nmblookup"<<std::endl;
+      return;
+   };
+   MyString dummy("");
+   char *receiveBuffer=0;
+   int bufferSize(0);
+   int nmblookupFd=fileno(nmblookupFile);
+   struct timeval tv;
+   fd_set fds;
+   int done(0);
+   int timeOuts(0);
+   char *tmpBuf=new char[16*1024];
+   do
+   {
+      FD_ZERO(&fds);
+      FD_SET(nmblookupFd,&fds);
+      tv.tv_sec=10;
+      tv.tv_usec=0;
+      int result=select(nmblookupFd+1,&fds,0,0,&tv);
+      //error
+      if (result<0)
+         done=1;
+      //timeout
+      else if (result==0)
+      {
+         timeOuts++;
+         //3 time outs make 30 seconds, this should be *much* more than enough
+         if (timeOuts>=3)
+            done=1;
+      }
+      else if (result>0)
+      {
+         //read stuff
+         int bytesRead=::read(nmblookupFd,tmpBuf,16*1024);
+         //pipe closed
+         if (bytesRead==0)
+            done=1;
+         else
+         {
+            char *newBuf=new char[bufferSize+bytesRead];
+            if (receiveBuffer!=0)
+            {
+               memcpy(newBuf,receiveBuffer,bufferSize);
+               delete [] receiveBuffer;
+            }
+            memcpy(newBuf+bufferSize,tmpBuf,bytesRead);
+            receiveBuffer=newBuf;
+            bufferSize+=bytesRead;
+         }
+      }
+   } while (!done);
+
+   // Warning: The return value of pclose may be incorrect due to the
+   // SIGCHLD handler that is installed. Ignore it!
+   pclose(nmblookupFile);
+
+   delete [] tmpBuf;
+   //we received nothing
+   if (receiveBuffer==0)
+      return;
+
+   //check for a terrminating '\0'
+   if (receiveBuffer[bufferSize-1]=='\0')
+      receiveBuffer[bufferSize-1]='\0';
+
+   //std::cerr<<receiveBuffer<<std::endl;
+
+   tmpBuf=receiveBuffer;
+   int bytesLeft=bufferSize;
+
+   int bufferState=0;
+   while (bytesLeft>0)
+   {
+      //mdcerr<<"bytesLeft: "<<bytesLeft<<" received: "<<bufferSize<<std::endl;
+      //since we added a terminating \0 we can be sure here
+      char *endOfLine=(char*)memchr(tmpBuf,'\n',bytesLeft);
+      //point to the last character
+      if (endOfLine==0)
+         endOfLine=receiveBuffer+bufferSize-1;
+
+      //0-terminate the string
+      *endOfLine='\0';
+      //now tmpBuf to endOfLine is a 0-terminated string
+      int strLength=strlen(tmpBuf);
+      //hmm, if this happens, there must be something really wrong
+      if (strLength>1000)
+         break;
+
+      bytesLeft=bytesLeft-strLength-1;
+
+      if (bufferState==0)
+      {
+         if (isdigit(tmpBuf[0]))
+            bufferState=1;
+      }
+      //yes, no else !
+      if (bufferState==1)
+      {
+         char tmpIP[1024];
+         //std::cerr<<"tmpBuf: -"<<tmpBuf<<"-"<<std::endl;
+         if (sscanf(tmpBuf,"%s *<00>\n",tmpIP) == 1) {
+             mdcerr<<"nmblookupScan: tmpIP: -"<<tmpIP<<"-"<<std::endl;
+             struct sockaddr_in addr;
+             if ((addr.sin_addr.s_addr = inet_addr(tmpIP)) != INADDR_NONE)
+                 if  (!hostAlreadyInList(addr.sin_addr.s_addr,newList))
+                 {
+                     if (validator.isValid(addr.sin_addr.s_addr))
+                     {
+                         mdcerr<<"nmblookupScan: adding "<<inet_ntoa(addr.sin_addr)<<std::endl;
+                         newList->push_back(Node(dummy,addr.sin_addr.s_addr));
+                     }
+                 }
+             }
+      }
+      tmpBuf=endOfLine+1;
+   };
+   mdcerr<<"nmblookupScan: finished"<<std::endl;
+   delete [] receiveBuffer;
+}
+
+void NetScanner::pingScan(std::list<Node>* newList)   //the ping-version
+{
+   mdcerr<<"pingScan()"<<std::endl;
+   //newList->clear();
+   MyString dummy("");
+   mdcerr<<"pingScan: m_maxPings: "<<m_maxPings<<std::endl;
+
+   pid_t pid=getpid();
+   ICMPEchoRequest echo;
+   echo.type=ICMP_ECHO;
+   echo.code=0;
+   echo.id=pid;
+   echo.seqNumber=0;
+   echo.checkSum=0;
+   echo.checkSum=in_cksum((unsigned short *)&echo,8);
+
+   char receiveBuf[16*1024];
+   //before we start first read everything what might be in the receive buffer
+   //of the raw socket
+
+   timeval tv1;
+   //wait a moment for answers
+   tv1.tv_sec = 0;
+   tv1.tv_usec = 0;
+   fd_set clearSet;
+   FD_ZERO(&clearSet);
+   FD_SET(m_rawSocketFD,&clearSet);
+   while(select(m_rawSocketFD,&clearSet,0,0,&tv1)>0)
+   {
+      ::recvfrom(m_rawSocketFD,(char*)&receiveBuf,16*1024,0,0,0);
+      tv1.tv_sec = 0;
+      tv1.tv_usec = 0;
+      FD_ZERO(&clearSet);
+      FD_SET(m_rawSocketFD,&clearSet);
+   }
+   //now the buffer should be empty
+   
+   //wait a moment for answers
+   tv1.tv_sec = 0;
+   tv1.tv_usec = m_firstWait*10*1000;//0.5 sec
+
+   int loopCount(2);
+   if (m_secondWait<0)
+      loopCount=1;
+   for (int repeatOnce=0; repeatOnce<loopCount; repeatOnce++)
+   {
+      mdcerr<<"******************** starting loop *****************"<<std::endl;
+      unsigned int current(0);
+      int finished(0);
+      while (!finished)
+      {
+         for (int con=0; con<m_maxPings; con++)
+         {
+            struct in_addr tmpIP;
+            do
+            {
+               tmpIP=getIPfromArray(current);
+               current++;
+//               mdcerr<<"pingScan(): trying "<<inet_ntoa(tmpIP)<<std::endl;
+               if (hostAlreadyInList(tmpIP.s_addr,newList))
+                  mdcerr<<"already in list :-)"<<std::endl;
+               if (!validator.isValid(tmpIP.s_addr))
+                  mdcerr<<"pingScan(): invalid IP :-("<<std::endl;
+               //ping only hosts which are allowed to receive the results
+               //and which are not in the list
+            } while ( (tmpIP.s_addr!=0)
+                      && ((!validator.isValid(tmpIP.s_addr))
+                      || (hostAlreadyInList(tmpIP.s_addr,newList))));
+
+            finished=(tmpIP.s_addr==0);
+            if (!finished)
+            {
+               //send the icmp echo request
+               struct sockaddr_in toAddr;
+               toAddr.sin_family = AF_INET;
+               toAddr.sin_addr = tmpIP;
+               toAddr.sin_port = 0;
+               (void)sendto(m_rawSocketFD,(char*)&echo,sizeof(echo),0,(sockaddr*)&toAddr,sizeof(toAddr));
+               //int sb=sendto(sockFD,(char*)&echo,sizeof(echo),0,(sockaddr*)&toAddr,sizeof(toAddr));
+//               mdcerr<<"pingScan: pinging "<<inet_ntoa(toAddr.sin_addr)<<std::endl;
+            }
+            else break;
+         }
+         select(0,0,0,0,&tv1);
+         //now read the answers, hopefully
+         struct sockaddr_in fromAddr;
+         socklen_t length(sizeof(fromAddr));
+         int received(0);
+
+         fd_set sockFDset;
+         FD_ZERO(&sockFDset);
+         FD_SET(m_rawSocketFD,&sockFDset);
+         tv1.tv_sec=0;
+         tv1.tv_usec=0;
+         while(select(m_rawSocketFD+1,&sockFDset,0,0,&tv1)>0)
+         {
+            received=recvfrom(m_rawSocketFD, (char*)&receiveBuf, 16*1024, 0,
+			      (sockaddr*)&fromAddr, &length);
+            if (received!=-1)
+            {
+//               mdcerr<<"pingScan: received from "<<inet_ntoa(fromAddr.sin_addr)<<" "<<received<<" b, ";
+               struct ip *ipFrame=(ip*)&receiveBuf;
+               int icmpOffset=(ipFrame->ip_hl)*4;
+               icmp *recIcmpFrame=(icmp*)(receiveBuf+icmpOffset);
+               int iType=recIcmpFrame->icmp_type;
+               //if its a ICMP echo reply
+               if ((iType==ICMP_ECHOREPLY)
+                   //to an echo request we sent
+                   && (recIcmpFrame->icmp_id==pid)
+                   //and the host is not yet in the list
+                   && (!hostAlreadyInList(fromAddr.sin_addr.s_addr,newList)))
+               {
+                  //this is an answer to our request :-)
+//                  mdcerr<<"pingScan: adding "<<inet_ntoa(fromAddr.sin_addr)<<std::endl;
+                  newList->push_back(Node(dummy,fromAddr.sin_addr.s_addr));
+               }
+            }
+            tv1.tv_sec=0;
+            tv1.tv_usec=0;
+            FD_ZERO(&sockFDset);
+            FD_SET(m_rawSocketFD,&sockFDset);
+            //FD_SET(sockFD,&sockFDset);
+         }
+      }
+      tv1.tv_sec = 0;
+      tv1.tv_usec = m_secondWait*10*1000;//0.5 sec
+   }
+   mdcerr<<"pingScan() ends"<<std::endl;
+}
+
+void NetScanner::doScan()
+{
+   mdcerr<<"doScan"<<std::endl;
+   //child
+   std::list<Node>* tmpPingList=new std::list<Node>;
+   mdcerr<<"doScan: created list"<<std::endl;
+   if (m_useNmblookup)
+      nmblookupScan(tmpPingList);
+   pingScan(tmpPingList);
+   // get the names from cache or lookup
+   completeNames(tmpPingList);
+   mdcerr<<"doScan: completed names"<<std::endl;
+   if (m_deliverUnnamedHosts==0)
+      removeUnnamedHosts(tmpPingList);
+
+   mdcerr<<"doScan: added hosts"<<std::endl;
+   
+   delete hostList;
+   hostList=tmpPingList;
+}
+
+int NetScanner::hostAlreadyInList(int ip, std::list<Node>* nodes)
+{
+   for (std::list<Node>::iterator node = nodes->begin(); node != nodes->end(); node++)
+   {
+      if (node->ip==ip)
+         return 1;
+   }
+   return 0;
+}
+
+void NetScanner::removeUnnamedHosts(std::list<Node>* nodes)
+{
+   nodes->remove_if(is_unnamed_node());
+}
+
+void NetScanner::completeNames(std::list<Node>* nodes)
+{
+   struct sockaddr_in tmpAddr;
+   //for every host
+   for (std::list<Node>::iterator node = nodes->begin(); node != nodes->end(); node++)
+   {
+      tmpAddr.sin_addr.s_addr=node->ip;
+      mdcerr<<"completeNames: looking up "<<inet_ntoa(tmpAddr.sin_addr)<<std::endl;
+      int done(0);
+      //first look wether we have the name already
+      if (hostList!=0) for (std::list<Node>::iterator oldNode=hostList->begin(); oldNode!=hostList->end(); oldNode++)
+      {
+         if (node->ip==oldNode->ip)
+         {
+            mdcerr<<"completeNames: cached: "<<oldNode->name<<" :-)"<<std::endl;
+            node->name=oldNode->name;
+            done=1;
+            break;
+         }
+      }
+      //otherwise do a name lookup
+      if (!done)
+      {
+         //IPAddress tmpAddress(node->ip);
+         //mdcerr<<"NetScanner::completeNames: doing actual lookup"<<std::endl;
+         node->name=ip2Name(tmpAddr.sin_addr);
+         mdcerr<<"completeNames: resolved: "<<node->name<<std::endl;
+      }
+   }
+}
+
-- 
cgit v1.2.1