implemented send_to_gui

2 files changed, 31 insertions, 20 deletions

diff --git a/noncore/net/wellenreiter/libwellenreiter/source/sniff.cc b/noncore/net/wellenreiter/libwellenreiter/source/sniff.cc
index fedd8fc..66299d1 100644
--- a/noncore/net/wellenreiter/libwellenreiter/source/sniff.cc
+++ b/noncore/net/wellenreiter/libwellenreiter/source/sniff.cc
@@ -1,46 +1,51 @@
 /* 
  *  rfmon mode sniffer
  *
  *  $Id$
  */
 
 #include "sniff.hh"
 #include "ieee802_11.hh"
 #include "extract.hh"
 #include "log.hh"
+#include "proto.hh"
 
 /* Main function, checks packets */
-void process_packets(const struct pcap_pkthdr *pkthdr, const unsigned char *packet)
+void process_packets(const struct pcap_pkthdr *pkthdr, const unsigned char *packet, char *guihost, int guiport)
 {
   unsigned int caplen = pkthdr->caplen;
   unsigned int length = pkthdr->len;
   u_int16_t fc;
   unsigned int HEADER_LENGTH;
   
   /* pinfo holds all interresting information for us */
   struct packetinfo pinfo;
   struct packetinfo *pinfoptr;
+
+  /* wl_network_t will finally be set and send to the ui */
+  wl_network_t wl_net;
+
   pinfoptr=&pinfo;
   
   pinfoptr->isvalid = 0;
   pinfoptr->pktlen = pkthdr->len;
   
   if (caplen < IEEE802_11_FC_LEN) 
   {
       /* This is a garbage packet, because is does not long enough
 	 to hold a 802.11b header */
       pinfoptr->isvalid = 0;
       return;
   }
   
   /* Gets the framecontrol bits (2bytes long) */
   fc = EXTRACT_LE_16BITS(packet);
   
   HEADER_LENGTH = GetHeaderLength(fc);
   
   if (caplen < HEADER_LENGTH) 
   {
       /* This is a garbage packet, because it is not long enough
 	 to hold a correct header of its type */
       pinfoptr->isvalid = 0;
       return;
@@ -71,70 +76,76 @@ void process_packets(const struct pcap_pkthdr *pkthdr, const unsigned char *pack
 		  /* Every beacon must have the broadcast as destination
 		     so it must be a shitti packet */
 		  pinfoptr->isvalid = 0;
 		  return;
 	      } 
 	      
 	      if (pinfoptr->cap_ESS == pinfoptr->cap_IBSS)
 	      {
 		  /* Only one of both are possible, so must be 
 		     a noise packet, if this comes up */
 		  pinfoptr->isvalid = 0;
 		  return;
 	      }
 	      if (pinfoptr->channel < 1 || pinfoptr->channel > 14)
 	      {
 		  /* Only channels between 1 and 14 are possible
 		     others must be noise packets */
 		  pinfoptr->isvalid = 0;
 		  return;
 	      }
 
 
 	      /* Here should be the infos to the gui issued */
 	      if (pinfoptr->cap_ESS == 1 &&pinfoptr->cap_IBSS ==0)
-	      {
-		  printf ("\nHave found an accesspoint:");
+		{
+		  wl_loginfo("Found an access point");
+		  wl_net.net_type=1;
 		}
 	      else if(pinfoptr->cap_ESS == 0 && pinfoptr->cap_IBSS == 1) 
 		{
-		  printf ("\nHave found an AD-HOC station:");
-		  
+		  wl_loginfo("Found an ad-hoc network");
+		  wl_net.net_type=2;
 		}
 	      if (strcmp (pinfoptr->ssid,NONBROADCASTING) ==0)
 		{
-		  printf ("\n\tOn a non-broadcasting network");
+		  wl_loginfo("Net is a non-broadcasting network");
 		}
 	      else
 		{
-		  printf ("\n\tOn network : %s",pinfoptr->ssid);
+		  wl_loginfo("SSID is: %s", pinfoptr->ssid);
+		  //		  wl_net.bssid=pinfoptr->ssid;
 		}
-	      printf ("\n\tLen SSID   : %d",pinfoptr->ssid_len);
-	      printf ("\n\tOn Channel : %d",pinfoptr->channel);
-	      printf ("\n\tEncryption : %s", pinfoptr->cap_WEP ? "ON" : "OFF");
-	      printf ("\n\tMacaddress : %s",pinfoptr->sndhwaddr);
-	      printf ("\n\tBssid      : %s",pinfoptr->bssid);
-	      printf ("\n\tDest	   : %s\n",pinfoptr->desthwaddr);
+
+	      wl_net.ssid_len=pinfoptr->ssid_len;
+	      wl_net.channel=pinfoptr->channel;
+	      wl_net.wep=pinfoptr->cap_WEP;
+	      memcpy(wl_net.mac, pinfoptr->sndhwaddr, sizeof(wl_net.mac));;
+	      memcpy(wl_net.bssid, pinfoptr->ssid, sizeof(wl_net.bssid));
+
+	      //	      printf ("\n\tDest	   : %s\n",pinfoptr->desthwaddr);
+	      send_network_found((char *)guihost, guiport, &wl_net);
+	      wl_loginfo("Sent network to GUI '%s:%d'", guihost, guiport);
 	    }
 	  break;	
 	default:
 	  wl_logerr("Unknown IEEE802.11 frame subtype (%d)", FC_SUBTYPE(fc));
 	  break;	
 	} /* End of switch over different mgt frame types */
       
       break;
   
   case T_CTRL:
     wl_loginfo("Received control frame, not implemented yet");
     break;
 
   case T_DATA:
     wl_loginfo("Received date frame, not implemented yet");
     break;
 
   default:
     wl_logerr("Unknown IEEE802.11 frame type (%d)", FC_TYPE(fc));
     break;
     }
 }
 
 /* This decodes the 802.11b frame header out of the 802.11b packet 
@@ -184,51 +195,51 @@ int handle_beacon(u_int16_t fc, const u_char *p,struct packetinfo *ppinfo)
   memcpy(&pbody.timestamp, p, 8);
   offset += 8;
   pbody.beacon_interval = EXTRACT_LE_16BITS(p+offset);
   offset += 2;
   pbody.capability_info = EXTRACT_LE_16BITS(p+offset);
   offset += 2;
   
   /* Gets the different flags out of the capabilities */
   ppinfo->cap_ESS = CAPABILITY_ESS(pbody.capability_info);
   ppinfo->cap_IBSS = CAPABILITY_IBSS(pbody.capability_info);
   ppinfo->cap_WEP = CAPABILITY_PRIVACY(pbody.capability_info);
   
   /* Gets the tagged elements out of the packets */
   while (offset + 1 < ppinfo->pktlen)
   {
       switch (*(p + offset)) 
       {
 	case E_SSID:
 	  memcpy(&(pbody.ssid),p+offset,2); offset += 2;
 	  if (pbody.ssid.length > 0)
 	  {
 	      memcpy(&(pbody.ssid.ssid),p+offset,pbody.ssid.length); offset += pbody.ssid.length;
 	      pbody.ssid.ssid[pbody.ssid.length]='\0';
 	      if (strcmp((char *)pbody.ssid.ssid,"")==0)
-	   	  ppinfo->ssid = NONBROADCASTING;
+		memcpy(ppinfo->ssid, NONBROADCASTING, sizeof(ppinfo->ssid));
 	      else
-		  ppinfo->ssid = (char *)pbody.ssid.ssid;
+		  memcpy(ppinfo->ssid, pbody.ssid.ssid, sizeof(ppinfo->ssid));
 	      ppinfo->ssid_len = pbody.ssid.length;
 	  }
 	  break;
 	  
 	case E_CHALLENGE:
 	  memcpy(&(pbody.challenge),p+offset,2); offset += 2;
 	  if (pbody.challenge.length > 0)
 	  {
 	      memcpy(&(pbody.challenge.text),p+offset,pbody.challenge.length); offset += pbody.challenge.length;
 	      pbody.challenge.text[pbody.challenge.length]='\0';
 	  }
 	  break;
 	case E_RATES:
 	  memcpy(&(pbody.rates),p+offset,2); offset += 2;
 	  if (pbody.rates.length > 0) 
 	  {
 	    memcpy(&(pbody.rates.rate),p+offset,pbody.rates.length); offset += pbody.rates.length;
 	  }
 	  break;
 	case E_DS:
 	  memcpy(&(pbody.ds),p+offset,3); offset +=3;
 	  ppinfo->channel = pbody.ds.channel;
 	  break;
 	case E_CF:
diff --git a/noncore/net/wellenreiter/libwellenreiter/source/sniff.hh b/noncore/net/wellenreiter/libwellenreiter/source/sniff.hh
index fa8519b..60cdc43 100644
--- a/noncore/net/wellenreiter/libwellenreiter/source/sniff.hh
+++ b/noncore/net/wellenreiter/libwellenreiter/source/sniff.hh
@@ -6,56 +6,56 @@
 #include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <pcap.h>  
 #include <errno.h>
 #include <sys/socket.h>
 #include <netinet/in.h>
 #include <arpa/inet.h>
 #include <net/bpf.h>
 
 #define   NONBROADCASTING "non-broadcasting"
 
 /* holds all the interresting data */
 struct packetinfo
 {
   int isvalid;
   int pktlen;
   int fctype;
   int fcsubtype;
   int fc_wep;
   int cap_WEP;
   int cap_IBSS;
   int cap_ESS;
   int channel;
-  char bssid[sizeof("00:00:00:00:00:00")];
-  char desthwaddr[sizeof("00:00:00:00:00:00")];
-  char sndhwaddr[sizeof("00:00:00:00:00:00")];
-  char *ssid;	
+  char bssid[sizeof("00:00:00:00:00:00") + 1];
+  char desthwaddr[sizeof("00:00:00:00:00:00") + 1];
+  char sndhwaddr[sizeof("00:00:00:00:00:00") + 1];
+  char ssid[128];
   int ssid_len;
 };
 
-void process_packets(const struct pcap_pkthdr* pkthdr,const u_char* packet);
+void process_packets(const struct pcap_pkthdr* pkthdr,const u_char* packet, char *, int);
 int decode_80211b_hdr(const u_char *p,struct packetinfo *ppinfo);
 void etheraddr_string(register const u_char *ep,char * text);
 int handle_beacon(u_int16_t fc, const u_char *p,struct packetinfo *ppinfo);
 
 int GetHeaderLength(u_int16_t fc);
 
 /*
  * True if  "l" bytes of "var" were captured.
  *
  * The "snapend - (l) <= snapend" checks to make sure "l" isn't so large
  * that "snapend - (l)" underflows.
  *
  * The check is for <= rather than < because "l" might be 0.
  */
 #define TTEST2(var, l) (snapend - (l) <= snapend && \
 			(const u_char *)&(var) <= snapend - (l))
 
 /* True if "var" was captured */
 #define TTEST(var) TTEST2(var, sizeof(var))
 
 /* Bail if "l" bytes of "var" were not captured */
 #define TCHECK2(var, l) if (!TTEST2(var, l)) goto trunc
 
 /* Bail if "var" was not captured */