added cardmode and sniffer

7 files changed, 808 insertions, 1 deletions

diff --git a/noncore/net/wellenreiter/libwellenreiter/source/Makefile b/noncore/net/wellenreiter/libwellenreiter/source/Makefile
index 05a5bd3..3670d96 100644
--- a/noncore/net/wellenreiter/libwellenreiter/source/Makefile
+++ b/noncore/net/wellenreiter/libwellenreiter/source/Makefile
@@ -1,17 +1,17 @@
 # $Id$
 
 INCLUDES = 
 LIBRARIES =
-LIBOBJ = sock.o log.o
+LIBOBJ = proto.o sock.o log.o cardmode.o sniff.o
 CXX = g++ -Wall -pedantic -g  $(INCLUDES) -DDEBUG
 
         static:libwellenreiter.a
 libwellenreiter.a: $(LIBOBJ)
         ar -cr libwellenreiter.a $(LIBOBJ)
 
         shared:libwellenreiter.so
 libwellenreiter.so: $(LIBOBJ)
         $(CXX) -shared -o libwellenreiter.so $(LIBOBJ)
 
 clean:
         rm -f *.o *.a *.so *~
diff --git a/noncore/net/wellenreiter/libwellenreiter/source/cardmode.cc b/noncore/net/wellenreiter/libwellenreiter/source/cardmode.cc
new file mode 100644
index 0000000..62c2940
--- a/dev/null
+++ b/noncore/net/wellenreiter/libwellenreiter/source/cardmode.cc
@@ -0,0 +1,97 @@
+/* 
+ * Set card modes for sniffing
+ *
+ * $Id$
+ */
+
+#include "cardmode.hh"
+
+/* main card into monitor function */
+int card_into_monitormode (void *orighandle, char *device, int cardtype)
+{
+  int datalink; /* used for getting the pcap datalink type */
+  char CiscoRFMON[35] = "/proc/driver/aironet/";
+  FILE *CISCO_CONFIG_FILE;
+  char errbuf[PCAP_ERRBUF_SIZE];
+  pcap_t *handle;
+  
+  handle = (pcap_t *)orighandle;
+
+  /* Checks if we have a device to sniff on */
+  if(device == NULL)
+  {
+      wl_logerr("No device given");
+      return 0;
+  }
+  
+  /* Setting the prmiscous and up flag to the interface */
+  if (!card_set_promisc_up(device))
+  {
+    wl_logerr("Cannot set interface to promisc mode: %s", strerror(errno));
+    return 0;
+  } 
+  wl_loginfo("Interface set to promisc mode");
+  
+  /* Check the cardtype and executes the commands to go into monitor mode */
+  if (cardtype == CARD_TYPE_CISCO)
+  {
+      /* bring the sniffer into rfmon  mode */
+      snprintf(CiscoRFMON, sizeof(CiscoRFMON), DEFAULT_PATH, device);
+      if((CISCO_CONFIG_FILE = fopen(CiscoRFMON,"w")) == NULL)
+      {
+          wl_logerr("Cannot open config file: %s", strerror(errno));
+          return 0;
+      }
+      fputs ("Mode: r",CISCO_CONFIG_FILE);
+      fputs ("Mode: y",CISCO_CONFIG_FILE);
+      fputs ("XmitPower: 1",CISCO_CONFIG_FILE);
+      fclose(CISCO_CONFIG_FILE);
+  }
+  else if (cardtype == CARD_TYPE_NG)
+  {
+      char wlanngcmd[62];
+      snprintf(wlanngcmd, sizeof(wlanngcmd), "%s %s lnxreq_wlansniff channel=1 enable=true", WLANCTL_PATH, device);
+      if (system(wlanngcmd) != 0)
+      {
+          wl_logerr("Could not set %s in raw mode, check cardtype", device);
+          return 0;
+      }
+  }
+  else if (cardtype == CARD_TYPE_HOSTAP)
+  {
+      wl_logerr("Got a host-ap card, nothing is implemented now");
+  }
+   
+  /* Check the interface if it is in the correct raw mode */
+  if((handle = pcap_open_live(device, BUFSIZ, 1, 0, errbuf)) == NULL)
+  {
+      wl_logerr("pcap_open_live() failed: %s", strerror(errno));
+      return 0;
+  }
+  
+#ifdef HAVE_PCAP_NONBLOCK
+  pcap_setnonblock(handle, 1, errstr);
+#endif
+  
+  /* getting the datalink type */
+  datalink = pcap_datalink(handle);
+  
+  if (datalink != DLT_IEEE802_11) /* Rawmode is IEEE802_11 */
+  {
+      wl_loginfo("Interface %s does not work in the correct 802.11 raw mode", device);
+      pcap_close(handle); 
+      return 0;
+  }
+  wl_loginfo("Your successfully listen on %s in 802.11 raw mode", device);
+  
+  return 1;
+}
+
+/* Set card into promisc mode */
+int card_set_promisc_up (const char *device)
+{
+  char ifconfigcmd[32];
+  snprintf(ifconfigcmd, sizeof(ifconfigcmd), SBIN_PATH, device);
+
+  return (system(ifconfigcmd) ? 1 : 0);
+}
diff --git a/noncore/net/wellenreiter/libwellenreiter/source/cardmode.hh b/noncore/net/wellenreiter/libwellenreiter/source/cardmode.hh
new file mode 100644
index 0000000..d80b24b
--- a/dev/null
+++ b/noncore/net/wellenreiter/libwellenreiter/source/cardmode.hh
@@ -0,0 +1,34 @@
+/* $Id$ */
+
+#ifndef CARDMODE_HH
+#define CARDMODE_HH
+
+#include <string.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>
+
+#include "../../libwellenreiter/source/log.hh"
+
+/* Defines, used for the card setup */
+#define   DEFAULT_PATH       "/proc/driver/aironet/%s/Config"
+        #define   CARD_TYPE_CISCO1
+        #define   CARD_TYPE_NG        2
+        #define   CARD_TYPE_HOSTAP3
+
+/* only for now, until we have the daemon running */
+/*the config file should provide these information */
+#define   CARD_TYPE              CARD_TYPE_CISCO
+        #define   SBIN_PATH         "/sbin/ifconfig %s promisc up"
+#define   WLANCTL_PATH           "/sbin/wlanctl-ng"
+
+/* Prototypes */
+
+int card_into_monitormode (void *, char *, int);
+int card_set_promisc_up (const char *);
+
+#endif /* CARDMODE_HH */
diff --git a/noncore/net/wellenreiter/libwellenreiter/source/extract.hh b/noncore/net/wellenreiter/libwellenreiter/source/extract.hh
new file mode 100644
index 0000000..f948bcb
--- a/dev/null
+++ b/noncore/net/wellenreiter/libwellenreiter/source/extract.hh
@@ -0,0 +1,59 @@
+/* $Id$ */
+/*
+ * Copyright (c) 1992, 1993, 1994, 1995, 1996
+         *The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that: (1) source code distributions
+ * retain the above copyright notice and this paragraph in its entirety, (2)
+ * distributions including binary code include the above copyright notice and
+ * this paragraph in its entirety in the documentation or other materials
+ * provided with the distribution, and (3) all advertising materials mentioning
+ * features or use of this software display the following acknowledgement:
+ * ``This product includes software developed by the University of California,
+ * Lawrence Berkeley Laboratory and its contributors.'' Neither the name of
+ * the University nor the names of its contributors may be used to endorse
+ * or promote products derived from this software without specific prior
+ * written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+/* Network to host order macros */
+
+#ifndef EXTRACT_HH
+#define EXTRACT_HH
+
+#ifdef LBL_ALIGN
+#define EXTRACT_16BITS(p) \
+        ((u_int16_t)((u_int16_t)*((const u_int8_t *)(p) + 0) << 8 | \
+                     (u_int16_t)*((const u_int8_t *)(p) + 1)))
+#define EXTRACT_32BITS(p) \
+        ((u_int32_t)((u_int32_t)*((const u_int8_t *)(p) + 0) << 24 | \
+                     (u_int32_t)*((const u_int8_t *)(p) + 1) << 16 | \
+                     (u_int32_t)*((const u_int8_t *)(p) + 2) << 8 | \
+                     (u_int32_t)*((const u_int8_t *)(p) + 3)))
+#else
+#define EXTRACT_16BITS(p) \
+        ((u_int16_t)ntohs(*(const u_int16_t *)(p)))
+#define EXTRACT_32BITS(p) \
+        ((u_int32_t)ntohl(*(const u_int32_t *)(p)))
+#endif
+
+#define EXTRACT_24BITS(p) \
+        ((u_int32_t)((u_int32_t)*((const u_int8_t *)(p) + 0) << 16 | \
+                     (u_int32_t)*((const u_int8_t *)(p) + 1) << 8 | \
+                     (u_int32_t)*((const u_int8_t *)(p) + 2)))
+
+/* Little endian protocol host order macros */
+#define EXTRACT_LE_8BITS(p) (*(p))
+#define EXTRACT_LE_16BITS(p) \
+        ((u_int16_t)((u_int16_t)*((const u_int8_t *)(p) + 1) << 8 | \
+                     (u_int16_t)*((const u_int8_t *)(p) + 0)))
+#define EXTRACT_LE_32BITS(p) \
+        ((u_int32_t)((u_int32_t)*((const u_int8_t *)(p) + 3) << 24 | \
+                     (u_int32_t)*((const u_int8_t *)(p) + 2) << 16 | \
+                     (u_int32_t)*((const u_int8_t *)(p) + 1) << 8 | \
+                     (u_int32_t)*((const u_int8_t *)(p) + 0)))
+
+#endif /* EXTRACT_HH */
diff --git a/noncore/net/wellenreiter/libwellenreiter/source/ieee802_11.hh b/noncore/net/wellenreiter/libwellenreiter/source/ieee802_11.hh
new file mode 100644
index 0000000..872fd40
--- a/dev/null
+++ b/noncore/net/wellenreiter/libwellenreiter/source/ieee802_11.hh
@@ -0,0 +1,250 @@
+/* $Id$ */
+/*
+ * Copyright (c) 2001
+         *Fortress Technologies
+ *      Charlie Lenahan ( clenahan@fortresstech.com )
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that: (1) source code distributions
+ * retain the above copyright notice and this paragraph in its entirety, (2)
+ * distributions including binary code include the above copyright notice and
+ * this paragraph in its entirety in the documentation or other materials
+ * provided with the distribution, and (3) all advertising materials mentioning
+ * features or use of this software display the following acknowledgement:
+ * ``This product includes software developed by the University of California,
+ * Lawrence Berkeley Laboratory and its contributors.'' Neither the name of
+ * the University nor the names of its contributors may be used to endorse
+ * or promote products derived from this software without specific prior
+ * written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+#ifndef IEEE802_11_HH
+#define IEEE802_11_HH
+
+        #define IEEE802_11_FC_LEN2
+
+#define T_MGMT 0x0  /* management */
+#define T_CTRL 0x1  /* control */
+#define T_DATA 0x2 /* data */
+#define T_RESV 0x3  /* reserved */
+
+        #define ST_ASSOC_REQUEST   0x0
+        #define ST_ASSOC_RESPONSE 0x1
+        #define ST_REASSOC_REQUEST   0x2
+        #define ST_REASSOC_RESPONSE  0x3
+        #define ST_PROBE_REQUEST   0x4
+        #define ST_PROBE_RESPONSE   0x5
+        /* RESERVED             0x6  */
+        /* RESERVED             0x7  */
+        #define ST_BEACON       0x8
+        #define ST_ATIM                 0x9
+        #define ST_DISASSOC     0xA
+        #define ST_AUTH                 0xB
+        #define ST_DEAUTH       0xC
+        /* RESERVED             0xD  */
+        /* RESERVED             0xE  */
+        /* RESERVED             0xF  */
+
+
+        #define CTRL_PS_POLL0xA
+        #define CTRL_RTS0xB
+        #define CTRL_CTS0xC
+        #define CTRL_ACK0xD
+        #define CTRL_CF_END0xE
+        #define CTRL_END_ACK0xF
+
+/*
+ * Bits in the frame control field.
+ */
+        #define FC_VERSION(fc)  ((fc) & 0x3)
+        #define FC_TYPE(fc)     (((fc) >> 2) & 0x3)
+        #define FC_SUBTYPE(fc)  (((fc) >> 4) & 0xF)
+        #define FC_TO_DS(fc)    ((fc) & 0x0100)
+        #define FC_FROM_DS(fc)  ((fc) & 0x0200)
+        #define FC_MORE_FLAG(fc)((fc) & 0x0400)
+        #define FC_RETRY(fc)    ((fc) & 0x0800)
+        #define FC_POWER_MGMT(fc)((fc) & 0x1000)
+        #define FC_MORE_DATA(fc)((fc) & 0x2000)
+        #define FC_WEP(fc)      ((fc) & 0x4000)
+        #define FC_ORDER(fc)    ((fc) & 0x8000)
+
+struct mgmt_header_t {
+          u_int16_tfc;
+          u_int16_t duration;
+          u_int8_tda[6];
+          u_int8_tsa[6];
+          u_int8_tbssid[6];
+          u_int16_tseq_ctrl;
+};
+
+        #define MGMT_HEADER_LEN(2+2+6+6+6+2)
+
+        #define CAPABILITY_ESS(cap)((cap) & 0x0001)
+        #define CAPABILITY_IBSS(cap)((cap) & 0x0002)
+        #define CAPABILITY_CFP(cap)((cap) & 0x0004)
+        #define CAPABILITY_CFP_REQ(cap)((cap) & 0x0008)
+        #define CAPABILITY_PRIVACY(cap)((cap) & 0x0010)
+
+struct ssid_t {
+          u_int8_telement_id;
+          u_int8_tlength;
+          u_char        ssid[33];  /* 32 + 1 for null */
+} ;
+
+struct rates_t {
+          u_int8_telement_id;
+          u_int8_tlength;
+          u_int8_trate[8];
+};
+
+struct challenge_t {
+          u_int8_telement_id;
+          u_int8_tlength;
+          u_int8_ttext[254]; /* 1-253 + 1 for null */
+};
+struct fh_t {
+          u_int8_telement_id;
+          u_int8_tlength;
+          u_int16_tdwell_time;
+          u_int8_thop_set;
+          u_int8_t hop_pattern;
+          u_int8_thop_index;
+};
+
+struct ds_t {
+          u_int8_telement_id;
+          u_int8_tlength;
+          u_int8_tchannel;
+};
+
+struct cf_t {
+          u_int8_telement_id;
+          u_int8_tlength;
+          u_int8_tcount;
+          u_int8_tperiod;
+          u_int16_tmax_duration;
+          u_int16_tdur_remaing;
+};
+
+struct tim_t {
+          u_int8_telement_id;
+          u_int8_tlength;
+          u_int8_tcount;
+          u_int8_tperiod;
+          u_int8_tbitmap_control;
+          u_int8_tbitmap[251];
+};
+
+        #define E_SSID          0
+        #define E_RATES 1
+        #define E_FH     2
+        #define E_DS    3
+        #define E_CF     4
+        #define E_TIM    5
+        #define E_IBSS          6
+        #define E_CISCO         133
+        /* reserved     7 */
+        /* reserved     8 */
+        /* reserved     9 */
+        /* reserved     10 */
+        /* reserved     11 */
+        /* reserved     12 */
+        /* reserved     13 */
+        /* reserved     14 */
+        /* reserved     15 */
+        /* reserved     16 */
+
+        #define E_CHALLENGE 16
+        /* reserved     17 */
+        /* reserved     18 */
+        /* reserved     19 */
+        /* reserved     16 */
+        /* reserved     16 */
+
+
+struct mgmt_body_t {
+          u_int8_t   timestamp[8];
+          u_int16_t  beacon_interval;
+          u_int16_t listen_interval;
+          u_int16_t status_code;
+          u_int16_t aid;
+          u_char        ap[6];
+          u_int16_treason_code;
+          u_int16_tauth_alg;
+          u_int16_tauth_trans_seq_num;
+  struct challenge_t  challenge;
+          u_int16_tcapability_info;
+          struct ssid_tssid;
+          struct rates_t rates;
+          struct ds_tds;
+          struct cf_tcf;
+          struct fh_tfh;
+          struct tim_ttim;
+};
+
+struct ctrl_rts_t {
+          u_int16_tfc;
+          u_int16_tduration;
+          u_int8_tra[6];
+          u_int8_tta[6];
+          u_int8_tfcs[4];
+};
+
+        #define CTRL_RTS_LEN(2+2+6+6+4)
+
+struct ctrl_cts_t {
+          u_int16_tfc;
+          u_int16_tduration;
+          u_int8_tra[6];
+          u_int8_tfcs[4];
+};
+
+        #define CTRL_CTS_LEN(2+2+6+4)
+
+struct ctrl_ack_t {
+          u_int16_tfc;
+          u_int16_tduration;
+          u_int8_tra[6];
+          u_int8_tfcs[4];
+};
+
+        #define CTRL_ACK_LEN(2+2+6+4)
+
+struct ctrl_ps_poll_t {
+          u_int16_tfc;
+          u_int16_taid;
+          u_int8_tbssid[6];
+          u_int8_tta[6];
+          u_int8_tfcs[4];
+};
+
+        #define CTRL_PS_POLL_LEN(2+2+6+6+4)
+
+struct ctrl_end_t {
+          u_int16_tfc;
+          u_int16_tduration;
+          u_int8_tra[6];
+          u_int8_tbssid[6];
+          u_int8_tfcs[4];
+};
+
+        #define CTRL_END_LEN(2+2+6+6+4)
+
+struct ctrl_end_ack_t {
+          u_int16_tfc;
+          u_int16_tduration;
+          u_int8_tra[6];
+          u_int8_tbssid[6];
+          u_int8_tfcs[4];
+};
+
+        #define CTRL_END_ACK_LEN(2+2+6+6+4)
+
+        #define IV_IV(iv)((iv) & 0xFFFFFF)
+        #define IV_PAD(iv)(((iv) >> 24) & 0x3F)
+        #define IV_KEYID(iv)(((iv) >> 30) & 0x03)
+
+#endif /* IEEE802_11_HH */
diff --git a/noncore/net/wellenreiter/libwellenreiter/source/sniff.cc b/noncore/net/wellenreiter/libwellenreiter/source/sniff.cc
new file mode 100644
index 0000000..fedd8fc
--- a/dev/null
+++ b/noncore/net/wellenreiter/libwellenreiter/source/sniff.cc
@@ -0,0 +1,303 @@
+/* 
+ *  rfmon mode sniffer
+ *
+ *  $Id$
+ */
+
+#include "sniff.hh"
+#include "ieee802_11.hh"
+#include "extract.hh"
+#include "log.hh"
+
+/* Main function, checks packets */
+void process_packets(const struct pcap_pkthdr *pkthdr, const unsigned char *packet)
+{
+  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;
+  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;
+  
+  switch (FC_TYPE(fc)) 
+  {
+      /* Is it a managemnet frame? */
+    case T_MGMT:
+      switch (FC_SUBTYPE(fc))
+      {
+        case ST_BEACON:
+          if (handle_beacon(fc, packet,pinfoptr) ==0)
+          {
+              if (!strcmp(pinfoptr->desthwaddr,"ff:ff:ff:ff:ff:ff") == 0)
+              {
+                  /* 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:");
+                }
+              else if(pinfoptr->cap_ESS == 0 && pinfoptr->cap_IBSS == 1) 
+                {
+                  printf ("\nHave found an AD-HOC station:");
+                  
+                }
+              if (strcmp (pinfoptr->ssid,NONBROADCASTING) ==0)
+                {
+                  printf ("\n\tOn a non-broadcasting network");
+                }
+              else
+                {
+                  printf ("\n\tOn network : %s",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);
+            }
+                  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 
+           all the infos is placed into the packetinfo structure                 */
+int decode_80211b_hdr(const u_char *p,struct packetinfo *ppinfo)
+{
+  const struct mgmt_header_t *mgthdr = (const struct mgmt_header_t *) p;
+  ppinfo->fcsubtype = FC_SUBTYPE(mgthdr->fc);
+  
+  /* Get the sender, bssid and dest mac address */
+  etheraddr_string(mgthdr->bssid,ppinfo->bssid);
+  etheraddr_string(mgthdr->da,ppinfo->desthwaddr);
+  etheraddr_string(mgthdr->sa,ppinfo->sndhwaddr);
+  ppinfo->fc_wep = FC_WEP(mgthdr->fc);
+  return 0;
+}
+
+
+void etheraddr_string(register const u_char *ep, char *text)
+{
+  static char hex[] = "0123456789abcdef";
+  register unsigned int i, j;
+  register char *cp;
+  char buf[sizeof("00:00:00:00:00:00")];
+  cp = buf;
+  if ((j = *ep >> 4) != 0)
+    *cp++ = hex[j];
+  *cp++ = hex[*ep++ & 0xf];
+  for (i = 5; (int)--i >= 0;) {
+    *cp++ = ':';
+    if ((j = *ep >> 4) != 0)
+      *cp++ = hex[j];
+    *cp++ = hex[*ep++ & 0xf];
+  }
+  *cp = '\0';
+  strcpy(text,buf);
+}
+
+/* beacon handler */
+int handle_beacon(u_int16_t fc, const u_char *p,struct packetinfo *ppinfo)
+{
+  struct mgmt_body_t pbody;
+  int offset = 0;
+  
+  /* Get the static informations out of the packet */
+  memset(&pbody, 0, sizeof(pbody));
+  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;
+              else
+                  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 */
+
+
+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:
+      wl_logerr("unknown IEEE802.11 frame type (%d)", FC_TYPE(fc));
+      break;
+  }
+  return iLength;
+}
diff --git a/noncore/net/wellenreiter/libwellenreiter/source/sniff.hh b/noncore/net/wellenreiter/libwellenreiter/source/sniff.hh
new file mode 100644
index 0000000..fa8519b
--- a/dev/null
+++ b/noncore/net/wellenreiter/libwellenreiter/source/sniff.hh
@@ -0,0 +1,64 @@
+/* $Id$ */
+
+#ifndef SNIFF_HH
+#define SNIFF_HH
+
+#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;
+  int ssid_len;
+};
+
+void process_packets(const struct pcap_pkthdr* pkthdr,const u_char* packet);
+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 */
+#define TCHECK(var) TCHECK2(var, sizeof(var))
+
+#endif /* SNIFF_HH */