implemented sniffer function in daemon.cc

1 files changed, 1 insertions, 40 deletions

diff --git a/noncore/net/wellenreiter/daemon/source/sniffer.cc b/noncore/net/wellenreiter/daemon/source/sniffer.cc
index be64d67..66d5b6f 100644
--- a/noncore/net/wellenreiter/daemon/source/sniffer.cc
+++ b/noncore/net/wellenreiter/daemon/source/sniffer.cc
@@ -1,101 +1,62 @@
 /* 
  *  rfmon mode sniffer
  *  This works only with cisco wireless cards with an rfmon
  *  able driver and not with wifi stuff.
  *
  *  $Id$
  */
 
 #include "config.hh"
 #include "cardmode.hh"
 #include "sniffer.hh"
 #include "ieee802_11.hh"
 #include "extract.hh"
 
-int main(void)
-        {
-        if(card_into_monitormode (SNIFFER_DEVICE, CARD_TYPE_NG) < 0)
-                return 0;
-                start_sniffing (SNIFFER_DEVICE);
-
-  return 1;
-}
-
-int start_sniffing (char * device)
-{
- 
-                pcap_t *handletopcap;     /* The handle to the libpcap */
-        char errbuf[PCAP_ERRBUF_SIZE]; /* The errorbuffer of libpacap */
-        struct pcap_pkthdr header;     /* The packet header from pcap*/
-    const u_char *packet;          /* The actual packet content*/
-
-        /* opening the pcap for sniffing */
-        handletopcap = pcap_open_live(device, BUFSIZ, 1, 1000, errbuf);
-
-        #ifdef HAVE_PCAP_NONBLOCK
-            pcap_setnonblock(handletopcap, 1, errstr);
-        #endif
-        /*start scanning */
-        //pcap_loop(handletopcap,-1,process_packets,NULL);
-        /* Loope endless */
-        while(1)
-        {
-                /* Grab one single packet */
-            packet = pcap_next(handletopcap, &header);
-
-                /* process the packet */
-                        process_packets(NULL,&header,*&packet);         
-        }
-
-        printf("\nDone processing packets... wheew!\n");
-        return 1;
-}
-
 void process_packets(u_char *useless,const struct pcap_pkthdr* pkthdr,const u_char* packet)
 {
         u_int caplen = pkthdr->caplen;
         u_int length = pkthdr->len;
         u_int16_t fc;
         u_int HEADER_LENGTH;
 
         /* pinfo holds all interresting information for us */
         struct packetinfo pinfo;
         struct packetinfo *pinfoptr;
         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;
         }
 
         /* Decode 802.11b header out of the packet */
         if (decode_80211b_hdr(packet,pinfoptr) == 0)
         {
                 /* Justification of the ofset to further process the packet */
                 length -= HEADER_LENGTH;
                 caplen -= HEADER_LENGTH;
                 packet += HEADER_LENGTH;
         }
         else
         {   /* Something is wrong,could not be a correct packet */
                 return;
         }
@@ -253,95 +214,95 @@ int handle_beacon(u_int16_t fc, const u_char *p,struct packetinfo *ppinfo)
                                         {
                                                 ppinfo->ssid = (char *)pbody.ssid.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:
                                 memcpy(&(pbody.cf),p+offset,8); offset +=8;
                                 break;
                         case E_TIM:
                                 memcpy(&(pbody.tim),p+offset,2); offset +=2;
                                 memcpy(&(pbody.tim.count),p+offset,3); offset +=3;
                                 if ((pbody.tim.length -3) > 0)
                                 {
                                         memcpy((pbody.tim.bitmap),p+(pbody.tim.length -3),(pbody.tim.length -3));
                                         offset += pbody.tim.length -3;
                                 }
                                 break;
                         default:
 
                         offset+= *(p+offset+1) + 2;
                         break;
                 } /* end of switch*/
         } /* end of for loop */
         return 0;
         
 } /* End of handle_beacon */
 
 
-static int GetHeaderLength(u_int16_t fc)
+int GetHeaderLength(u_int16_t fc)
 {
         int iLength=0;
 
         switch (FC_TYPE(fc)) {
         case T_MGMT:
                 iLength = MGMT_HEADER_LEN;
                 break;
         case T_CTRL:
                 switch (FC_SUBTYPE(fc)) {
                 case CTRL_PS_POLL:
                         iLength = CTRL_PS_POLL_LEN;
                         break;
                 case CTRL_RTS:
                         iLength = CTRL_RTS_LEN;
                         break;
                 case CTRL_CTS:
                         iLength = CTRL_CTS_LEN;
                         break;
                 case CTRL_ACK:
                         iLength = CTRL_ACK_LEN;
                         break;
                 case CTRL_CF_END:
                         iLength = CTRL_END_LEN;
                         break;
                 case CTRL_END_ACK:
                         iLength = CTRL_END_ACK_LEN;
                         break;
                 default:
                         iLength = 0;
                         break;
                 }
                 break;
         case T_DATA:
                 if (FC_TO_DS(fc) && FC_FROM_DS(fc))
                         iLength = 30;
                 else
                         iLength = 24;
                 break;
         default:
                 printf("unknown IEEE802.11 frame type (%d)",
                     FC_TYPE(fc));
                 break;
         }
 
         return iLength;
 }