First test of wlan driver, sends beacon every 2 seconds

1 files changed, 1083 insertions, 960 deletions

diff --git a/src/transport/gnunet-transport-wlan-helper.c b/src/transport/gnunet-transport-wlan-helper.c
index 088a1fc85..5220ff067 100644
--- a/src/transport/gnunet-transport-wlan-helper.c
+++ b/src/transport/gnunet-transport-wlan-helper.c
@@ -1,22 +1,22 @@
 /*
-     This file is part of GNUnet.
-     (C) 2010 Christian Grothoff (and other contributing authors)
-
-     GNUnet is free software; you can redistribute it and/or modify
-     it under the terms of the GNU General Public License as published
-     by the Free Software Foundation; either version 3, or (at your
-     option) any later version.
-
-     GNUnet 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.
-
-     You should have received a copy of the GNU General Public License
-     along with GNUnet; see the file COPYING.  If not, write to the
-     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-     Boston, MA 02111-1307, USA.
-*/
+ This file is part of GNUnet.
+ (C) 2010 Christian Grothoff (and other contributing authors)
+
+ GNUnet is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published
+ by the Free Software Foundation; either version 3, or (at your
+ option) any later version.
+
+ GNUnet 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.
+
+ You should have received a copy of the GNU General Public License
+ along with GNUnet; see the file COPYING.  If not, write to the
+ Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA.
+ */
 
 /**
  * @file src/transport/gnunet-transport-wlan-helper.c
@@ -28,8 +28,36 @@
  * gnunet
  */
 
+#include <sys/socket.h>
+#include <sys/ioctl.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <sys/time.h>
+#include <sys/stat.h>
+#include <netpacket/packet.h>
+#include <linux/if_ether.h>
+#include <linux/if.h>
+#include <linux/wireless.h>
+#include <netinet/in.h>
+#include <linux/if_tun.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <dirent.h>
+//#include <sys/utsname.h>
+#include <sys/param.h>
 
-#include "platform.h"
+/*
+ //#include <resolv.h>
+ #include <string.h>
+ #include <utime.h>
+ //#include <unistd.h>
+ #include <getopt.h>
+ */
+//#include "platform.h"
 #include "gnunet_constants.h"
 #include "gnunet_os_lib.h"
 #include "gnunet_transport_plugin.h"
@@ -39,15 +67,91 @@
 #include "gnunet_common.h"
 #include "gnunet-transport-wlan-helper.h"
 #include "gnunet_crypto_lib.h"
-#include "ieee80211_radiotap.h"
+
 #include <pcap.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/stat.h>
 
+#include "wlan/radiotap-parser.h"
+/* radiotap-parser defines types like u8 that
+ * ieee80211_radiotap.h needs
+ *
+ * we use our local copy of ieee80211_radiotap.h
+ *
+ * - since we can't support extensions we don't understand
+ * - since linux does not include it in userspace headers
+ */
+#include "wlan/ieee80211_radiotap.h"
+#include "wlan/crctable_osdep.h"
+#include "wlan/loopback_helper.h"
+
+#define ARPHRD_IEEE80211        801
+#define ARPHRD_IEEE80211_PRISM  802
+#define ARPHRD_IEEE80211_FULL   803
 
+int first;
+int closeprog;
 
+#include "wlan/helper_common.h"
+#include "wlan/loopback_helper.h"
 
+#define DEBUG 1
+
+typedef enum
+{
+  DT_NULL = 0,
+  DT_WLANNG,
+  DT_HOSTAP,
+  DT_MADWIFI,
+  DT_MADWIFING,
+  DT_BCM43XX,
+  DT_ORINOCO,
+  DT_ZD1211RW,
+  DT_ACX,
+  DT_MAC80211_RT,
+  DT_AT76USB,
+  DT_IPW2200
+
+} DRIVER_TYPE;
+
+static const char * szaDriverTypes[] =
+  { [DT_NULL] = "Unknown", [DT_WLANNG] = "Wlan-NG", [DT_HOSTAP] = "HostAP",
+      [DT_MADWIFI] = "Madwifi", [DT_MADWIFING] = "Madwifi-NG",
+      [DT_BCM43XX] = "BCM43xx", [DT_ORINOCO] = "Orinoco",
+      [DT_ZD1211RW] = "ZD1211RW", [DT_ACX] = "ACX",
+      [DT_MAC80211_RT] = "Mac80211-Radiotap", [DT_AT76USB] = "Atmel 76_usb",
+      [DT_IPW2200] = "ipw2200" };
+
+struct Hardware_Infos
+{
+
+  struct sendbuf *write_pout;
+  int fd_in, arptype_in;
+  int fd_out, arptype_out;
+  int fd_main;
+  int fd_rtc;
+
+  DRIVER_TYPE drivertype; /* inited to DT_UNKNOWN on allocation by wi_alloc */
+
+  FILE *f_cap_in;
+
+  struct pcap_file_header pfh_in;
+
+  int sysfs_inject;
+  int channel;
+  int freq;
+  int rate;
+  int tx_power;
+  char *wlanctlng; /* XXX never set */
+  char *iwpriv;
+  char *iwconfig;
+  char *ifconfig;
+  char *iface;
+  char *main_if;
+  unsigned char pl_mac[6];
+  int inject_wlanng;
+};
 
 //#include "radiotap.h"
 
@@ -57,20 +161,11 @@ char mac[] =
 
 /* wifi bitrate to use in 500kHz units */
 
-static const u8 u8aRatesToUse[] = {
-
-        54*2,
-        48*2,
-        36*2,
-        24*2,
-        18*2,
-        12*2,
-        9*2,
-        11*2,
-        11, // 5.5
-        2*2,
-        1*2
-};
+static const u8 u8aRatesToUse[] =
+  {
+
+  54 * 2, 48 * 2, 36 * 2, 24 * 2, 18 * 2, 12 * 2, 9 * 2, 11 * 2, 11, // 5.5
+      2 * 2, 1 * 2 };
 
 #define OFFSET_FLAGS 0x10
 #define OFFSET_RATE 0x11
@@ -78,809 +173,813 @@ static const u8 u8aRatesToUse[] = {
 // this is where we store a summary of the
 // information from the radiotap header
 
-typedef struct  {
-        int m_nChannel;
-        int m_nChannelFlags;
-        int m_nRate;
-        int m_nAntenna;
-        int m_nRadiotapFlags;
-} __attribute__((packed)) PENUMBRA_RADIOTAP_DATA;
+typedef struct
+{
+  int m_nChannel;
+  int m_nChannelFlags;
+  int m_nRate;
+  int m_nAntenna;
+  int m_nRadiotapFlags;
+}__attribute__((packed)) PENUMBRA_RADIOTAP_DATA;
 
-void
-Dump(u8 * pu8, int nLength)
+static void
+sigfunc_hw(int sig)
 {
-        char sz[256], szBuf[512], szChar[17], *buf, fFirst = 1;
-        unsigned char baaLast[2][16];
-        uint n, nPos = 0, nStart = 0, nLine = 0, nSameCount = 0;
-
-        buf = szBuf;
-        szChar[0] = '\0';
-
-        for (n = 0; n < nLength; n++) {
-                baaLast[(nLine&1)^1][n&0xf] = pu8[n];
-                if ((pu8[n] < 32) || (pu8[n] >= 0x7f))
-                        szChar[n&0xf] = '.';
-                else
-                        szChar[n&0xf] = pu8[n];
-                szChar[(n&0xf)+1] = '\0';
-                nPos += sprintf(&sz[nPos], "%02X ",
-                        baaLast[(nLine&1)^1][n&0xf]);
-                if ((n&15) != 15)
-                        continue;
-                if ((memcmp(baaLast[0], baaLast[1], 16) == 0) && (!fFirst)) {
-                        nSameCount++;
-                } else {
-                        if (nSameCount)
-                                buf += sprintf(buf, "(repeated %d times)\n",
-                                        nSameCount);
-                        buf += sprintf(buf, "%04x: %s %s\n",
-                                nStart, sz, szChar);
-                        nSameCount = 0;
-                        printf("%s", szBuf);
-                        buf = szBuf;
-                }
-                nPos = 0; nStart = n+1; nLine++;
-                fFirst = 0; sz[0] = '\0'; szChar[0] = '\0';
-        }
-        if (nSameCount)
-                buf += sprintf(buf, "(repeated %d times)\n", nSameCount);
-
-        buf += sprintf(buf, "%04x: %s", nStart, sz);
-        if (n & 0xf) {
-                *buf++ = ' ';
-                while (n & 0xf) {
-                        buf += sprintf(buf, "   ");
-                        n++;
-                }
-        }
-        buf += sprintf(buf, "%s\n", szChar);
-        printf("%s", szBuf);
+  closeprog = 1;
 }
 
-
 void
-usage()
+Dump(u8 * pu8, int nLength)
 {
-        printf(
-            "Usage: wlan-hwd [options] <interface>\n\nOptions\n"
-            "-f/--fcs           Mark as having FCS (CRC) already\n"
-            "                   (pkt ends with 4 x sacrificial - chars)\n"
-            "Example:\n"
-            "  echo -n mon0 > /sys/class/ieee80211/phy0/add_iface\n"
-            "  iwconfig mon0 mode monitor\n"
-            "  ifconfig mon0 up\n"
-            "  wlan-hwd mon0        Spam down mon0 with\n"
-            "                       radiotap header first\n"
-            "\n");
-        exit(1);
-}
+  char sz[256], szBuf[512], szChar[17], *buf, fFirst = 1;
+  unsigned char baaLast[2][16];
+  uint n, nPos = 0, nStart = 0, nLine = 0, nSameCount = 0;
 
-int flagHelp = 0, flagMarkWithFCS = 0;
-int flagVerbose = 0;
+  buf = szBuf;
+  szChar[0] = '\0';
 
+  for (n = 0; n < nLength; n++)
+    {
+      baaLast[(nLine & 1) ^ 1][n & 0xf] = pu8[n];
+      if ((pu8[n] < 32) || (pu8[n] >= 0x7f))
+        szChar[n & 0xf] = '.';
+      else
+        szChar[n & 0xf] = pu8[n];
+      szChar[(n & 0xf) + 1] = '\0';
+      nPos += sprintf(&sz[nPos], "%02X ", baaLast[(nLine & 1) ^ 1][n & 0xf]);
+      if ((n & 15) != 15)
+        continue;
+      if ((memcmp(baaLast[0], baaLast[1], 16) == 0) && (!fFirst))
+        {
+          nSameCount++;
+        }
+      else
+        {
+          if (nSameCount)
+            buf += sprintf(buf, "(repeated %d times)\n", nSameCount);
+          buf += sprintf(buf, "%04x: %s %s\n", nStart, sz, szChar);
+          nSameCount = 0;
+          printf("%s", szBuf);
+          buf = szBuf;
+        }
+      nPos = 0;
+      nStart = n + 1;
+      nLine++;
+      fFirst = 0;
+      sz[0] = '\0';
+      szChar[0] = '\0';
+    }
+  if (nSameCount)
+    buf += sprintf(buf, "(repeated %d times)\n", nSameCount);
 
-/*
- * Radiotap parser
- *
- * Copyright 2007               Andy Green <andy@warmcat.com>
- */
-
-/**
- * ieee80211_radiotap_iterator_init - radiotap parser iterator initialization
- * @param iterator: radiotap_iterator to initialize
- * @param radiotap_header: radiotap header to parse
- * @param max_length: total length we can parse into (eg, whole packet length)
- *
- * @return 0 or a negative error code if there is a problem.
- *
- * This function initializes an opaque iterator struct which can then
- * be passed to ieee80211_radiotap_iterator_next() to visit every radiotap
- * argument which is present in the header.  It knows about extended
- * present headers and handles them.
- *
- * How to use:
- * call __ieee80211_radiotap_iterator_init() to init a semi-opaque iterator
- * struct ieee80211_radiotap_iterator (no need to init the struct beforehand)
- * checking for a good 0 return code.  Then loop calling
- * __ieee80211_radiotap_iterator_next()... it returns either 0,
- * -ENOENT if there are no more args to parse, or -EINVAL if there is a problem.
- * The iterator's this_arg member points to the start of the argument
- * associated with the current argument index that is present, which can be
- * found in the iterator's this_arg_index member.  This arg index corresponds
- * to the IEEE80211_RADIOTAP_... defines.
- *
- * Radiotap header length:
- * You can find the CPU-endian total radiotap header length in
- * iterator->max_length after executing ieee80211_radiotap_iterator_init()
- * successfully.
- *
- * Example code:
- * See Documentation/networking/radiotap-headers.txt
- */
+  buf += sprintf(buf, "%04x: %s", nStart, sz);
+  if (n & 0xf)
+    {
+      *buf++ = ' ';
+      while (n & 0xf)
+        {
+          buf += sprintf(buf, "   ");
+          n++;
+        }
+    }
+  buf += sprintf(buf, "%s\n", szChar);
+  printf("%s", szBuf);
+}
 
-int ieee80211_radiotap_iterator_init(
-    struct ieee80211_radiotap_iterator *iterator,
-    struct ieee80211_radiotap_header *radiotap_header,
-    int max_length)
+void
+usage()
 {
-        /* Linux only supports version 0 radiotap format */
-        if (radiotap_header->it_version)
-                return -EINVAL;
-
-        /* sanity check for allowed length and radiotap length field */
-        if (max_length < le16_to_cpu(radiotap_header->it_len))
-                return -EINVAL;
-
-        iterator->rtheader = radiotap_header;
-        iterator->max_length = le16_to_cpu(radiotap_header->it_len);
-        iterator->arg_index = 0;
-        iterator->bitmap_shifter = le32_to_cpu(radiotap_header->it_present);
-        iterator->arg = (u8 *)radiotap_header + sizeof(*radiotap_header);
-        iterator->this_arg = 0;
-
-        /* find payload start allowing for extended bitmap(s) */
-
-        if (unlikely(iterator->bitmap_shifter & (1<<IEEE80211_RADIOTAP_EXT))) {
-                while (le32_to_cpu(*((u32 *)iterator->arg)) &
-                                   (1<<IEEE80211_RADIOTAP_EXT)) {
-                        iterator->arg += sizeof(u32);
-
-                        /*
-                         * check for insanity where the present bitmaps
-                         * keep claiming to extend up to or even beyond the
-                         * stated radiotap header length
-                         */
-
-                        if (((ulong)iterator->arg -
-                             (ulong)iterator->rtheader) > iterator->max_length)
-                                return -EINVAL;
-                }
-
-                iterator->arg += sizeof(u32);
-
-                /*
-                 * no need to check again for blowing past stated radiotap
-                 * header length, because ieee80211_radiotap_iterator_next
-                 * checks it before it is dereferenced
-                 */
-        }
-
-        /* we are all initialized happily */
-
-        return 0;
+  printf("Usage: wlan-hwd [options] <interface>\n\nOptions\n"
+    "-f/--fcs           Mark as having FCS (CRC) already\n"
+    "                   (pkt ends with 4 x sacrificial - chars)\n"
+    "Example:\n"
+    "  echo -n mon0 > /sys/class/ieee80211/phy0/add_iface\n"
+    "  iwconfig mon0 mode monitor\n"
+    "  ifconfig mon0 up\n"
+    "  wlan-hwd mon0        Spam down mon0 with\n"
+    "                       radiotap header first\n"
+    "\n");
+  exit(1);
 }
 
-
-/**
- * ieee80211_radiotap_iterator_next - return next radiotap parser iterator arg
- * @param iterator: radiotap_iterator to move to next arg (if any)
- *
- * @return 0 if there is an argument to handle,
- * -ENOENT if there are no more args or -EINVAL
- * if there is something else wrong.
- *
- * This function provides the next radiotap arg index (IEEE80211_RADIOTAP_*)
- * in this_arg_index and sets this_arg to point to the
- * payload for the field.  It takes care of alignment handling and extended
- * present fields.  this_arg can be changed by the caller (eg,
- * incremented to move inside a compound argument like
- * IEEE80211_RADIOTAP_CHANNEL).  The args pointed to are in
- * little-endian format whatever the endianess of your CPU.
- */
-
-int ieee80211_radiotap_iterator_next(
-    struct ieee80211_radiotap_iterator *iterator)
+void
+packet_callback(unsigned char *Args, const struct pcap_pkthdr* Pkthdr,
+    unsigned char *Packet)
 {
-
-        /*
-         * small length lookup table for all radiotap types we heard of
-         * starting from b0 in the bitmap, so we can walk the payload
-         * area of the radiotap header
-         *
-         * There is a requirement to pad args, so that args
-         * of a given length must begin at a boundary of that length
-         * -- but note that compound args are allowed (eg, 2 x u16
-         * for IEEE80211_RADIOTAP_CHANNEL) so total arg length is not
-         * a reliable indicator of alignment requirement.
-         *
-         * upper nybble: content alignment for arg
-         * lower nybble: content length for arg
-         */
-
-        static const u8 rt_sizes[] = {
-                [IEEE80211_RADIOTAP_TSFT] = 0x88,
-                [IEEE80211_RADIOTAP_FLAGS] = 0x11,
-                [IEEE80211_RADIOTAP_RATE] = 0x11,
-                [IEEE80211_RADIOTAP_CHANNEL] = 0x24,
-                [IEEE80211_RADIOTAP_FHSS] = 0x22,
-                [IEEE80211_RADIOTAP_DBM_ANTSIGNAL] = 0x11,
-                [IEEE80211_RADIOTAP_DBM_ANTNOISE] = 0x11,
-                [IEEE80211_RADIOTAP_LOCK_QUALITY] = 0x22,
-                [IEEE80211_RADIOTAP_TX_ATTENUATION] = 0x22,
-                [IEEE80211_RADIOTAP_DB_TX_ATTENUATION] = 0x22,
-                [IEEE80211_RADIOTAP_DBM_TX_POWER] = 0x11,
-                [IEEE80211_RADIOTAP_ANTENNA] = 0x11,
-                [IEEE80211_RADIOTAP_DB_ANTSIGNAL] = 0x11,
-                [IEEE80211_RADIOTAP_DB_ANTNOISE] = 0x11,
-                [IEEE80211_RADIOTAP_TX_FLAGS] = 0x22,
-                [IEEE80211_RADIOTAP_RX_FLAGS] = 0x22,
-                [IEEE80211_RADIOTAP_RTS_RETRIES] = 0x11,
-                [IEEE80211_RADIOTAP_DATA_RETRIES] = 0x11
-                /*
-                 * add more here as they are defined in
-                 * include/net/ieee80211_radiotap.h
-                 */
-        };
-
-        /*
-         * for every radiotap entry we can at
-         * least skip (by knowing the length)...
-         */
-
-        while (iterator->arg_index < sizeof(rt_sizes)) {
-                int hit = 0;
-                int pad;
-
-                if (!(iterator->bitmap_shifter & 1))
-                        goto next_entry; /* arg not present */
-
-                /*
-                 * arg is present, account for alignment padding
-                 *  8-bit args can be at any alignment
-                 * 16-bit args must start on 16-bit boundary
-                 * 32-bit args must start on 32-bit boundary
-                 * 64-bit args must start on 64-bit boundary
-                 *
-                 * note that total arg size can differ from alignment of
-                 * elements inside arg, so we use upper nybble of length
-                 * table to base alignment on
-                 *
-                 * also note: these alignments are ** relative to the
-                 * start of the radiotap header **.  There is no guarantee
-                 * that the radiotap header itself is aligned on any
-                 * kind of boundary.
-                 */
-
-                pad = (((ulong)iterator->arg) -
-                        ((ulong)iterator->rtheader)) &
-                        ((rt_sizes[iterator->arg_index] >> 4) - 1);
-
-                if (pad)
-                        iterator->arg_index +=
-                                (rt_sizes[iterator->arg_index] >> 4) - pad;
-
-                /*
-                 * this is what we will return to user, but we need to
-                 * move on first so next call has something fresh to test
-                 */
-                iterator->this_arg_index = iterator->arg_index;
-                iterator->this_arg = iterator->arg;
-                hit = 1;
-
-                /* internally move on the size of this arg */
-                iterator->arg += rt_sizes[iterator->arg_index] & 0x0f;
-
-                /*
-                 * check for insanity where we are given a bitmap that
-                 * claims to have more arg content than the length of the
-                 * radiotap section.  We will normally end up equalling this
-                 * max_length on the last arg, never exceeding it.
-                 */
-
-                if (((ulong)iterator->arg - (ulong)iterator->rtheader) >
-                    iterator->max_length)
-                        return -EINVAL;
-
-        next_entry:
-                iterator->arg_index++;
-                if (unlikely((iterator->arg_index & 31) == 0)) {
-                        /* completed current u32 bitmap */
-                        if (iterator->bitmap_shifter & 1) {
-                                /* b31 was set, there is more */
-                                /* move to next u32 bitmap */
-                                iterator->bitmap_shifter =
-                                    le32_to_cpu(*iterator->next_bitmap);
-                                iterator->next_bitmap++;
-                        } else {
-                                /* no more bitmaps: end */
-                                iterator->arg_index = sizeof(rt_sizes);
-                        }
-                } else { /* just try the next bit */
-                        iterator->bitmap_shifter >>= 1;
-                }
-
-                /* if we found a valid arg earlier, return it now */
-                if (hit)
-                        return 0;
-        }
-
-        /* we don't know how to handle any more args, we're done */
-        return -ENOENT;
+  fprintf(stderr, "+");
+  fflush(stderr);
 }
 
-#define FIFO_FILE1       "/tmp/MYFIFOin"
-#define FIFO_FILE2       "/tmp/MYFIFOout"
-#define MAXLINE         4096
+unsigned long
+calc_crc_osdep(unsigned char * buf, int len)
+{
+  unsigned long crc = 0xFFFFFFFF;
 
-static int first;
-static int closeprog;
+  for (; len > 0; len--, buf++)
+    crc = crc_tbl_osdep[(crc ^ *buf) & 0xFF] ^ (crc >> 8);
 
-static void 
-sigfunc(int sig)
-{
-  closeprog = 1;  
-  unlink(FIFO_FILE1);
-  unlink(FIFO_FILE2);
+  return (~crc);
 }
 
-struct sendbuf {
-  int pos;
-  int size;
-  char buf[MAXLINE * 2];
-};
+/* CRC checksum verification routine */
 
-static void
-stdin_send (void *cls,
-                      void *client,
-                      const struct GNUNET_MessageHeader *hdr)
+int
+check_crc_buf_osdep(unsigned char *buf, int len)
 {
-  struct sendbuf *write_pout = cls;
-  int sendsize;
-  struct GNUNET_MessageHeader newheader;
-  char * from;
-  char * to;
+  unsigned long crc;
 
-  sendsize = ntohs(hdr->size) - sizeof(struct RadiotapHeader) ;
+  if (len < 0)
+    return 0;
 
+  crc = calc_crc_osdep(buf, len);
+  buf += len;
+  return (((crc) & 0xFF) == buf[0] && ((crc >> 8) & 0xFF) == buf[1] && ((crc
+      >> 16) & 0xFF) == buf[2] && ((crc >> 24) & 0xFF) == buf[3]);
+}
 
-  if(GNUNET_MESSAGE_TYPE_WLAN_HELPER_DATA != ntohs(hdr->type)){
-    fprintf(stderr, "Function stdin_send: wrong packet type\n");
-    exit(1);
-  }
-  if((sendsize + write_pout->size) > MAXLINE * 2){
-    fprintf(stderr, "Function stdin_send: Packet too big for buffer\n");
-    exit(1);
-  }
+/* Search a file recursively */
+static char *
+searchInside(const char * dir, const char * filename)
+{
+  char * ret;
+  char * curfile;
+  struct stat sb;
+  int len, lentot;
+  DIR *dp;
+  struct dirent *ep;
+
+  dp = opendir(dir);
+  if (dp == NULL)
+    {
+      return NULL;
+    }
 
+  len = strlen(filename);
+  lentot = strlen(dir) + 256 + 2;
+  curfile = (char *) calloc(1, lentot);
 
-  newheader.size = htons(sendsize);
-  newheader.type = htons(GNUNET_MESSAGE_TYPE_WLAN_HELPER_DATA);
+  while ((ep = readdir(dp)) != NULL)
+    {
 
+      memset(curfile, 0, lentot);
+      sprintf(curfile, "%s/%s", dir, ep->d_name);
 
-  to = write_pout->buf + write_pout->size;
-  memcpy(to, &newheader, sizeof(struct GNUNET_MessageHeader));
-  write_pout->size += sizeof(struct GNUNET_MessageHeader);
+      //Checking if it's the good file
+      if ((int) strlen(ep->d_name) == len && !strcmp(ep->d_name, filename))
+        {
+          (void) closedir(dp);
+          return curfile;
+        }
+      lstat(curfile, &sb);
 
-  from = ((char *) hdr) + sizeof(struct RadiotapHeader) + sizeof(struct GNUNET_MessageHeader);
-  to = write_pout->buf + write_pout->size;
-  memcpy(to, from, sendsize - sizeof(struct GNUNET_MessageHeader));
-  write_pout->size += sendsize - sizeof(struct GNUNET_MessageHeader);
+      //If it's a directory and not a link, try to go inside to search
+      if (S_ISDIR(sb.st_mode) && !S_ISLNK(sb.st_mode))
+        {
+          //Check if the directory isn't "." or ".."
+          if (strcmp(".", ep->d_name) && strcmp("..", ep->d_name))
+            {
+              //Recursive call
+              ret = searchInside(curfile, filename);
+              if (ret != NULL)
+                {
+                  (void) closedir(dp);
+                  free(curfile);
+                  return ret;
+                }
+            }
+        }
+    }
+  (void) closedir(dp);
+  free(curfile);
+  return NULL;
 }
 
-static void
-file_in_send (void *cls,
-              void *client,
-              const struct GNUNET_MessageHeader *hdr)
+/* Search a wireless tool and return its path */
+static char *
+wiToolsPath(const char * tool)
 {
-  struct sendbuf * write_std = cls;
-  uint16_t sendsize;
+  char * path;
+  int i, nbelems;
+  static const char * paths[] =
+    { "/sbin", "/usr/sbin", "/usr/local/sbin", "/bin", "/usr/bin",
+        "/usr/local/bin", "/tmp" };
 
-  sendsize = ntohs(hdr->size);
+  nbelems = sizeof(paths) / sizeof(char *);
 
-  if (GNUNET_MESSAGE_TYPE_WLAN_HELPER_DATA != ntohs(hdr->type))
+  for (i = 0; i < nbelems; i++)
     {
-      fprintf (stderr, 
-               "Function file_in_send: wrong packet type\n");
-      exit(1);
+      path = searchInside(paths[i], tool);
+      if (path != NULL)
+        return path;
     }
-  if((sendsize + write_std->size) > MAXLINE * 2){
-    fprintf(stderr, "Function file_in_send: Packet too big for buffer\n");
-    exit(1);
-  }
 
-  memcpy(write_std->buf + write_std->size, hdr, sendsize);
-  write_std->size += sendsize;
+  return NULL;
 }
 
-/**
- * function to create GNUNET_MESSAGE_TYPE_WLAN_HELPER_CONTROL message for plugin
- * @param buffer pointer to buffer for the message
- * @param mac pointer to the mac address
- * @return number of bytes written
- */
+static int
+linux_get_channel(struct Hardware_Infos *dev)
+{
+  struct iwreq wrq;
+  int fd, frequency;
+  int chan = 0;
 
-int
-send_mac_to_plugin(char* buffer, char * mac){
+  memset(&wrq, 0, sizeof(struct iwreq));
 
-  struct Wlan_Helper_Control_Message macmsg;
+  if (dev->main_if)
+    strncpy(wrq.ifr_name, dev->main_if, IFNAMSIZ );
+  else
+    strncpy(wrq.ifr_name, dev->iface, IFNAMSIZ );
+
+  fd = dev->fd_in;
+  if (dev->drivertype == DT_IPW2200)
+    fd = dev->fd_main;
 
+  if (ioctl(fd, SIOCGIWFREQ, &wrq) < 0)
+    return (-1);
 
+  frequency = wrq.u.freq.m;
+  if (frequency > 100000000)
+    frequency /= 100000;
+  else if (frequency > 1000000)
+    frequency /= 1000;
 
-  memcpy(macmsg.mac.mac, mac, sizeof(struct MacAddress));
-  macmsg.hdr.size = htons(sizeof(struct Wlan_Helper_Control_Message));
-  macmsg.hdr.type = htons(GNUNET_MESSAGE_TYPE_WLAN_HELPER_CONTROL);
+  if (frequency > 1000)
+    chan = getChannelFromFrequency(frequency);
+  else
+    chan = frequency;
 
-  memcpy(buffer, &macmsg, sizeof(struct Wlan_Helper_Control_Message));
-  return sizeof(struct Wlan_Helper_Control_Message);
+  return chan;
 }
 
-int
-testmode(int argc, char *argv[])
+static int
+linux_read(struct Hardware_Infos * dev, unsigned char *buf, int count,
+    struct rx_info * ri)
 {
-  struct stat st;
-  int erg;
+  unsigned char tmpbuf[4096];
+
+  int caplen, n, got_signal, got_noise, got_channel, fcs_removed;
+
+  caplen = n = got_signal = got_noise = got_channel = fcs_removed = 0;
+
+  if ((unsigned) count > sizeof(tmpbuf))
+    return (-1);
+  caplen = read(dev->fd_in, tmpbuf, count);
+  if (0 > caplen)
+    {
+      if (errno == EAGAIN)
+        return (0);
+
+      perror("read failed");
+      return (-1);
+    }
 
-  FILE *fpin;
-  FILE *fpout;
+  memset(buf, 0, sizeof(buf));
 
-  int fdpin;
-  int fdpout;
+  /* XXX */
+  if (ri)
+    memset(ri, 0, sizeof(*ri));
 
-  //make the fifos if needed
-  if (0 != stat(FIFO_FILE1, &st))
+  if (dev->arptype_in == ARPHRD_IEEE80211_PRISM)
     {
-      if (0 == stat(FIFO_FILE2, &st))
+      /* skip the prism header */
+      if (tmpbuf[7] == 0x40)
         {
-        fprintf(stderr, "FIFO_FILE2 exists, but FIFO_FILE1 not\n");
-          exit(1);
+          /* prism54 uses a different format */
+          if (ri)
+            {
+              ri->ri_power = tmpbuf[0x33];
+              ri->ri_noise = *(unsigned int *) (tmpbuf + 0x33 + 12);
+              ri->ri_rate = (*(unsigned int *) (tmpbuf + 0x33 + 24)) * 500000;
+
+              got_signal = 1;
+              got_noise = 1;
+            }
+
+          n = 0x40;
         }
+      else
+        {
+          if (ri)
+            {
+              ri->ri_mactime = *(u_int64_t*) (tmpbuf + 0x5C - 48);
+              ri->ri_channel = *(unsigned int *) (tmpbuf + 0x5C - 36);
+              ri->ri_power = *(unsigned int *) (tmpbuf + 0x5C);
+              ri->ri_noise = *(unsigned int *) (tmpbuf + 0x5C + 12);
+              ri->ri_rate = (*(unsigned int *) (tmpbuf + 0x5C + 24)) * 500000;
+
+              got_channel = 1;
+              got_signal = 1;
+              got_noise = 1;
+            }
 
-      umask(0);
-      erg = mknod(FIFO_FILE1, S_IFIFO | 0666, 0);
-      erg = mknod(FIFO_FILE2, S_IFIFO | 0666, 0);
+          n = *(int *) (tmpbuf + 4);
+        }
 
+      if (n < 8 || n >= caplen)
+        return (0);
     }
-  else
+
+  if (dev->arptype_in == ARPHRD_IEEE80211_FULL)
     {
+      struct ieee80211_radiotap_iterator iterator;
+      struct ieee80211_radiotap_header *rthdr;
+
+      rthdr = (struct ieee80211_radiotap_header *) tmpbuf;
+
+      if (ieee80211_radiotap_iterator_init(&iterator, rthdr, caplen) < 0)
+        return (0);
 
-      if (0 != stat(FIFO_FILE2, &st))
+      /* go through the radiotap arguments we have been given
+       * by the driver
+       */
+
+      while (ri && (ieee80211_radiotap_iterator_next(&iterator) >= 0))
         {
-        fprintf(stderr, "FIFO_FILE1 exists, but FIFO_FILE2 not\n");
-          exit(1);
+
+          switch (iterator.this_arg_index)
+            {
+
+          case IEEE80211_RADIOTAP_TSFT:
+            ri->ri_mactime = le64_to_cpu(*((uint64_t*) iterator.this_arg));
+            break;
+
+          case IEEE80211_RADIOTAP_DBM_ANTSIGNAL:
+            if (!got_signal)
+              {
+                if (*iterator.this_arg < 127)
+                  ri->ri_power = *iterator.this_arg;
+                else
+                  ri->ri_power = *iterator.this_arg - 255;
+
+                got_signal = 1;
+              }
+            break;
+
+          case IEEE80211_RADIOTAP_DB_ANTSIGNAL:
+            if (!got_signal)
+              {
+                if (*iterator.this_arg < 127)
+                  ri->ri_power = *iterator.this_arg;
+                else
+                  ri->ri_power = *iterator.this_arg - 255;
+
+                got_signal = 1;
+              }
+            break;
+
+          case IEEE80211_RADIOTAP_DBM_ANTNOISE:
+            if (!got_noise)
+              {
+                if (*iterator.this_arg < 127)
+                  ri->ri_noise = *iterator.this_arg;
+                else
+                  ri->ri_noise = *iterator.this_arg - 255;
+
+                got_noise = 1;
+              }
+            break;
+
+          case IEEE80211_RADIOTAP_DB_ANTNOISE:
+            if (!got_noise)
+              {
+                if (*iterator.this_arg < 127)
+                  ri->ri_noise = *iterator.this_arg;
+                else
+                  ri->ri_noise = *iterator.this_arg - 255;
+
+                got_noise = 1;
+              }
+            break;
+
+          case IEEE80211_RADIOTAP_ANTENNA:
+            ri->ri_antenna = *iterator.this_arg;
+            break;
+
+          case IEEE80211_RADIOTAP_CHANNEL:
+            ri->ri_channel = *iterator.this_arg;
+            got_channel = 1;
+            break;
+
+          case IEEE80211_RADIOTAP_RATE:
+            ri->ri_rate = (*iterator.this_arg) * 500000;
+            break;
+
+          case IEEE80211_RADIOTAP_FLAGS:
+            /* is the CRC visible at the end?
+             * remove
+             */
+            if (*iterator.this_arg & IEEE80211_RADIOTAP_F_FCS)
+              {
+                fcs_removed = 1;
+                caplen -= 4;
+              }
+
+            if (*iterator.this_arg & IEEE80211_RADIOTAP_F_RX_BADFCS)
+              return (0);
+
+            break;
+
+            }
         }
 
+      n = le16_to_cpu(rthdr->it_len);
+
+      if (n <= 0 || n >= caplen)
+        return (0);
     }
 
-  if (strstr(argv[2], "1"))
+  caplen -= n;
+
+  //detect fcs at the end, even if the flag wasn't set and remove it
+  if (fcs_removed == 0 && check_crc_buf_osdep(tmpbuf + n, caplen - 4) == 1)
     {
-      //fprintf(stderr, "First\n");
-      first = 1;
-      fpin = fopen(FIFO_FILE1, "r");
-      if (NULL == fpin)
-        {
-        fprintf(stderr, "fopen of read FIFO_FILE1\n");
-          exit(1);
-        }
-      if (NULL == (fpout = fopen(FIFO_FILE2, "w")))
+      caplen -= 4;
+    }
+
+  memcpy(buf, tmpbuf + n, caplen);
+
+  if (ri && !got_channel)
+    ri->ri_channel = linux_get_channel(dev);
+
+  return (caplen);
+}
+
+static int
+linux_write(struct Hardware_Infos * dev, unsigned char *buf, unsigned int count)
+{
+  int ret, usedrtap = 0;
+  unsigned short int *p_rtlen;
+
+  unsigned char * u8aRadiotap = buf;
+
+  /* Pointer to the radiotap header length field for later use. */
+  p_rtlen = (unsigned short int*) (u8aRadiotap + 2);
+  usedrtap = 0;
+  ret = write(dev->fd_out, buf, count);
+
+  if (ret < 0)
+    {
+      if (errno == EAGAIN || errno == EWOULDBLOCK || errno == ENOBUFS || errno
+          == ENOMEM)
         {
-        fprintf(stderr, "fopen of write FIFO_FILE2\n");
-          exit(1);
+          usleep(10000);
+          return (0);
         }
 
+      perror("write failed");
+      return (-1);
     }
-  else
+
+  /* radiotap header length is stored little endian on all systems */
+  if (usedrtap)
+    ret -= letoh16(*p_rtlen);
+
+  if (ret < 0)
     {
-      first = 0;
-      //fprintf(stderr, "Second\n");
-      if (NULL == (fpout = fopen(FIFO_FILE1, "w")))
+      if (errno == EAGAIN || errno == EWOULDBLOCK || errno == ENOBUFS || errno
+          == ENOMEM)
         {
-        fprintf(stderr, "fopen of write FIFO_FILE1\n");
-          exit(1);
-        }
-      if (NULL == (fpin = fopen(FIFO_FILE2, "r")))
-        {
-        fprintf(stderr, "fopen of read FIFO_FILE2\n");
-          exit(1);
+          usleep(10000);
+          return (0);
         }
 
+      perror("write failed");
+      return (-1);
     }
 
-  fdpin = fileno(fpin);
-  if (fdpin >= FD_SETSIZE)
+  return (ret);
+}
+
+static int
+openraw(struct Hardware_Infos * dev, char * iface, int fd, int * arptype,
+    uint8_t *mac)
+{
+  struct ifreq ifr;
+  struct iwreq wrq;
+  struct packet_mreq mr;
+  struct sockaddr_ll sll;
+
+  /* find the interface index */
+
+  memset(&ifr, 0, sizeof(ifr));
+  strncpy(ifr.ifr_name, iface, sizeof(ifr.ifr_name) - 1);
+
+  if (ioctl(fd, SIOCGIFINDEX, &ifr) < 0)
     {
-      fprintf(stderr, "File fdpin number too large (%d > %u)\n", fdpin,
-          (unsigned int) FD_SETSIZE);
-      close(fdpin);
-      return -1;
+      printf("Interface %s: \n", iface);
+      perror("ioctl(SIOCGIFINDEX) failed");
+      return (1);
     }
 
-  fdpout = fileno(fpout);
-  if (fdpout >= FD_SETSIZE)
+  memset(&sll, 0, sizeof(sll));
+  sll.sll_family = AF_PACKET;
+  sll.sll_ifindex = ifr.ifr_ifindex;
+
+  switch (dev->drivertype)
     {
-      fprintf(stderr, "File fdpout number too large (%d > %u)\n", fdpout,
-          (unsigned int) FD_SETSIZE);
-      close(fdpout);
-      return -1;
+  default:
+    sll.sll_protocol = htons(ETH_P_ALL);
+    break;
+    }
 
+  /* lookup the hardware type */
+
+  if (ioctl(fd, SIOCGIFHWADDR, &ifr) < 0)
+    {
+      printf("Interface %s: \n", iface);
+      perror("ioctl(SIOCGIFHWADDR) failed");
+      return (1);
     }
 
-  signal(SIGINT, &sigfunc);
-  signal(SIGTERM, &sigfunc);
+  /* lookup iw mode */
+  memset(&wrq, 0, sizeof(struct iwreq));
+  strncpy(wrq.ifr_name, iface, IFNAMSIZ);
 
-  char readbuf[MAXLINE];
-  int readsize = 0;
-  struct sendbuf write_std;
-  write_std.size = 0;
-  write_std.pos = 0;
+  if (ioctl(fd, SIOCGIWMODE, &wrq) < 0)
+    {
+      /* most probably not supported (ie for rtap ipw interface) *
+       * so just assume its correctly set...                     */
+      wrq.u.mode = IW_MODE_MONITOR;
+    }
 
-  struct sendbuf write_pout;
-  write_pout.size = 0;
-  write_pout.pos = 0;
+  if ((ifr.ifr_hwaddr.sa_family != ARPHRD_IEEE80211 && ifr.ifr_hwaddr.sa_family
+      != ARPHRD_IEEE80211_PRISM && ifr.ifr_hwaddr.sa_family
+      != ARPHRD_IEEE80211_FULL) || (wrq.u.mode != IW_MODE_MONITOR))
+    {
+      printf("Error: %s not in monitor mode\n", iface);
+      return (1);
+    }
 
-  int ret = 0;
-  int maxfd = 0;
+  /* Is interface st to up, broadcast & running ? */
+  if ((ifr.ifr_flags | IFF_UP | IFF_BROADCAST | IFF_RUNNING) != ifr.ifr_flags)
+    {
+      /* Bring interface up*/
+      ifr.ifr_flags |= IFF_UP | IFF_BROADCAST | IFF_RUNNING;
 
-  fd_set rfds;
-  fd_set wfds;
-  struct timeval tv;
-  int retval;
+      if (ioctl(fd, SIOCSIFFLAGS, &ifr) < 0)
+        {
+          perror("ioctl(SIOCSIFFLAGS) failed");
+          return (1);
+        }
+    }
+  /* bind the raw socket to the interface */
 
+  if (bind(fd, (struct sockaddr *) &sll, sizeof(sll)) < 0)
+    {
+      printf("Interface %s: \n", iface);
+      perror("bind(ETH_P_ALL) failed");
+      return (1);
+    }
 
+  /* lookup the hardware type */
 
-  struct GNUNET_SERVER_MessageStreamTokenizer * stdin_mst;
-  struct GNUNET_SERVER_MessageStreamTokenizer * file_in_mst;
+  if (ioctl(fd, SIOCGIFHWADDR, &ifr) < 0)
+    {
+      printf("Interface %s: \n", iface);
+      perror("ioctl(SIOCGIFHWADDR) failed");
+      return (1);
+    }
 
-  stdin_mst = GNUNET_SERVER_mst_create(&stdin_send, &write_pout);
-  file_in_mst = GNUNET_SERVER_mst_create(&file_in_send, &write_std);
+  memcpy(mac, (unsigned char*) ifr.ifr_hwaddr.sa_data, 6);
 
-  //send mac first
+  *arptype = ifr.ifr_hwaddr.sa_family;
 
-  struct MacAddress macaddr;
+  if (ifr.ifr_hwaddr.sa_family != ARPHRD_IEEE80211 && ifr.ifr_hwaddr.sa_family
+      != ARPHRD_IEEE80211_PRISM && ifr.ifr_hwaddr.sa_family
+      != ARPHRD_IEEE80211_FULL)
+    {
+      if (ifr.ifr_hwaddr.sa_family == 1)
+        fprintf(stderr, "\nARP linktype is set to 1 (Ethernet) ");
+      else
+        fprintf(stderr, "\nUnsupported hardware link type %4d ",
+            ifr.ifr_hwaddr.sa_family);
+
+      fprintf(stderr, "- expected ARPHRD_IEEE80211,\nARPHRD_IEEE80211_"
+        "FULL or ARPHRD_IEEE80211_PRISM instead.  Make\n"
+        "sure RFMON is enabled: run 'airmon-ng start %s"
+        " <#>'\nSysfs injection support was not found "
+        "either.\n\n", iface);
+      return (1);
+    }
 
-  //Send random mac address
-  macaddr.mac[0] = 0x13;
-  macaddr.mac[1] = 0x22;
-  macaddr.mac[2] = 0x33;
-  macaddr.mac[3] = 0x44;
-  macaddr.mac[4] = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_STRONG, 256);
-  macaddr.mac[5] = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_NONCE, 256);
+  /* enable promiscuous mode */
 
-  write_std.size = send_mac_to_plugin((char *) &write_std.buf, macaddr.mac);
+  memset(&mr, 0, sizeof(mr));
+  mr.mr_ifindex = sll.sll_ifindex;
+  mr.mr_type = PACKET_MR_PROMISC;
 
-  /*
-  //wait
-  tv.tv_sec = 2;
-  tv.tv_usec = 0;
-  retval = select(0, NULL, NULL, NULL, &tv);
+  if (setsockopt(fd, SOL_PACKET, PACKET_ADD_MEMBERSHIP, &mr, sizeof(mr)) < 0)
+    {
+      perror("setsockopt(PACKET_MR_PROMISC) failed");
+      return (1);
+    }
 
+  return (0);
+}
 
-  tv.tv_sec = 3;
-  tv.tv_usec = 0;
-  // if there is something to write
-  FD_ZERO(&wfds);
-  FD_SET(STDOUT_FILENO, &wfds);
+int
+wlaninit(struct Hardware_Infos * dev, char *iface)
+{
 
-  retval = select(STDOUT_FILENO + 1, NULL, &wfds, NULL, &tv);
+  char *iwpriv;
+  char strbuf[512];
+  dev->inject_wlanng = 1;
+  dev->rate = 2; /* default to 1Mbps if nothing is set */
 
-  if (FD_ISSET(STDOUT_FILENO, &wfds))
+  /* open raw socks */
+  dev->fd_in = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
+  if (0 > dev->fd_in)
     {
-      ret = write(STDOUT_FILENO, write_std.buf + write_std.pos, write_std.size
-          - write_std.pos);
-
-      if (0 > ret)
-        {
-          closeprog = 1;
-          fprintf(stderr, "Write ERROR to STDOUT");
-          exit(1);
-        }
-      else
-        {
-          write_std.pos += ret;
-          // check if finished
-          if (write_std.pos == write_std.size)
-            {
-              write_std.pos = 0;
-              write_std.size = 0;
-            }
-        }
+      perror("socket(PF_PACKET) failed at fd_in");
+      if (getuid() != 0)
+        fprintf(stderr, "This program requires root privileges.\n");
+      return (1);
     }
 
-  memcpy(&write_std.buf, &macmsg, sizeof(struct Wlan_Helper_Control_Message));
-  write_std.size = sizeof(struct Wlan_Helper_Control_Message);
-  */
-
-  //wait
-  tv.tv_sec = 2;
-  tv.tv_usec = 0;
-  retval = select(0, NULL, NULL, NULL, &tv);
-
-  while (0 == closeprog)
+  dev->fd_main = socket(PF_PACKET, SOCK_RAW, htons( ETH_P_ALL ) );
+  if (0 > dev->fd_main)
     {
+      perror("socket(PF_PACKET) failed at fd_main");
+      if (getuid() != 0)
+        fprintf(stderr, "This program requires root privileges.\n");
+      return (1);
+    }
 
-      maxfd = 0;
+  /* Check iwpriv existence */
 
-      //set timeout
-      tv.tv_sec = 5;
-      tv.tv_usec = 0;
+  iwpriv = wiToolsPath("iwpriv");
+  dev->iwpriv = iwpriv;
+  dev->iwconfig = wiToolsPath("iwconfig");
+  dev->ifconfig = wiToolsPath("ifconfig");
 
-      FD_ZERO(&rfds);
-      // if output queue is empty
-      if (0 == write_pout.size)
-        {
-          FD_SET(STDIN_FILENO, &rfds);
+  if (!iwpriv)
+    {
+      fprintf(stderr, "Can't find wireless tools, exiting.\n");
+      goto close_in;
+    }
 
-        }
-      if (0 == write_std.size)
-        {
-          FD_SET(fdpin, &rfds);
-          maxfd = fdpin;
-        }
-      FD_ZERO(&wfds);
-      // if there is something to write
-      if (0 < write_std.size){
-        FD_SET(STDOUT_FILENO, &wfds);
-        maxfd = MAX(maxfd, STDOUT_FILENO);
-      }
+  dev->fd_out = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
+  if (0 > dev->fd_out)
+    {
+      perror("socket(PF_PACKET) failed at fd_out");
+      goto close_in;
+    }
 
-      if (0 < write_pout.size){
-        FD_SET(fdpout, &wfds);
-        maxfd = MAX(maxfd, fdpout);
-      }
+  /* figure out device type */
 
+  /* mac80211 radiotap injection
+   * detected based on interface called mon...
+   * since mac80211 allows multiple virtual interfaces
+   *
+   * note though that the virtual interfaces are ultimately using a
+   * single physical radio: that means for example they must all
+   * operate on the same channel
+   */
 
-      retval = select(maxfd + 1, &rfds, &wfds, NULL, &tv);
+  /* mac80211 stack detection */
+  memset(strbuf, 0, sizeof(strbuf));
+  snprintf(strbuf, sizeof(strbuf) - 1,
+      "ls /sys/class/net/%s/phy80211/subsystem >/dev/null 2>/dev/null", iface);
 
-      if (-1 == retval && EINTR == errno)
-        {
-          continue;
-        }
-      if (0 > retval)
-        {
-          fprintf(stderr, "select failed: %s\n", strerror(errno));
-          exit(1);
-        }
+  if (system(strbuf) == 0)
+    dev->drivertype = DT_MAC80211_RT;
 
-      if (FD_ISSET(STDOUT_FILENO, &wfds))
-        {
-          ret = write(STDOUT_FILENO, write_std.buf + write_std.pos,
-              write_std.size - write_std.pos);
+  else
+    {
+      // At the moment only mac80211 tested
+      return 1;
+    }
 
-          if (0 > ret)
-            {
-              closeprog = 1;
-              fprintf(stderr, "Write ERROR to STDOUT\n");
-              exit(1);
-            }
-          else
-            {
-              write_std.pos += ret;
-              // check if finished
-              if (write_std.pos == write_std.size)
-                {
-                  write_std.pos = 0;
-                  write_std.size = 0;
-                }
-            }
-        }
+#ifdef DEBUG
+  fprintf(stderr, "Interface %s -> driver: %s\n", iface,
+      szaDriverTypes[dev->drivertype]);
+#endif
 
-      if (FD_ISSET(fdpout, &wfds))
-        {
-          ret = write(fdpout, write_pout.buf + write_pout.pos, write_pout.size
-              - write_pout.pos);
+  if (openraw(dev, iface, dev->fd_out, &dev->arptype_out, dev->pl_mac) != 0)
+    {
+      goto close_out;
+    }
 
-          if (0 > ret)
-            {
-              closeprog = 1;
-              fprintf(stderr, "Write ERROR to fdpout\n");
-            }
-          else
-            {
-              write_pout.pos += ret;
-              // check if finished
-              if (write_pout.pos == write_pout.size)
-                {
-                  write_pout.pos = 0;
-                  write_pout.size = 0;
-                }
-            }
-        }
+  dev->fd_in = dev->fd_out;
 
-      if (FD_ISSET(STDIN_FILENO, &rfds))
-        {
-          readsize = read(STDIN_FILENO, readbuf, sizeof(readbuf));
+  dev->arptype_in = dev->arptype_out;
 
-          if (0 > readsize)
-            {
-              closeprog = 1;
-              fprintf(stderr, "Read ERROR to STDIN_FILENO\n");
-            }
-          else if (0 < readsize)
-            {
-              GNUNET_SERVER_mst_receive(stdin_mst, NULL, readbuf, readsize,
-                  GNUNET_NO, GNUNET_NO);
+  return 0;
+  close_out: close(dev->fd_out);
+  close_in: close(dev->fd_in);
+  return 1;
+}
 
-            }
-          else
-            {
-              //eof
-              closeprog = 1;
-            }
-        }
+static void
+stdin_send_hw(void *cls, void *client, const struct GNUNET_MessageHeader *hdr)
+{
+  struct Hardware_Infos * dev = cls;
+  struct sendbuf *write_pout = dev->write_pout;
+  struct Radiotap_Send * header = (struct Radiotap_Send *) &hdr[1];
+  int sendsize;
 
-      if (FD_ISSET(fdpin, &rfds))
-        {
-          readsize = read(fdpin, readbuf, sizeof(readbuf));
+  unsigned char u8aRadiotap[] =
+    { 0x00, 0x00, // <-- radiotap version
+        0x0c, 0x00, // <- radiotap header length
+        0x04, 0x80, 0x00, 0x00, // <-- bitmap
+        0x00, // <-- rate
+        0x00, // <-- padding for natural alignment
+        0x18, 0x00, // <-- TX flags
+      };
 
-          if (0 > readsize)
-            {
-              closeprog = 1;
-              fprintf(stderr, "Read ERROR to fdpin: %s\n", strerror(errno));
-              closeprog = 1;
-            }
-          else if (0 < readsize)
-            {
-              GNUNET_SERVER_mst_receive(file_in_mst, NULL, readbuf, readsize,
-                  GNUNET_NO, GNUNET_NO);
+  sendsize = ntohs(hdr->size) - sizeof(struct Radiotap_Send)
+      - sizeof(struct GNUNET_MessageHeader);
 
-            }
-          else
-            {
-              //eof
-              closeprog = 1;
-            }
-        }
+  if ((sendsize) > MAXLINE * 2)
+    {
+      fprintf(stderr, "Function stdin_send: Packet too big for buffer\n");
+      exit(1);
+    }
 
+  if (GNUNET_MESSAGE_TYPE_WLAN_HELPER_DATA != ntohs(hdr->type))
+    {
+      fprintf(stderr, "Function stdin_send: wrong packet type\n");
+      exit(1);
     }
 
-  //clean up
-  fclose(fpout);
-  fclose(fpin);
+  u8aRadiotap[8] = header->rate;
 
-  if (1 == first)
+  switch (dev->drivertype)
     {
-      unlink(FIFO_FILE1);
-      unlink(FIFO_FILE2);
+
+  case DT_MAC80211_RT:
+    memcpy(write_pout->buf, u8aRadiotap, sizeof(u8aRadiotap));
+    memcpy(write_pout->buf + sizeof(u8aRadiotap), write_pout->buf
+        + sizeof(struct Radiotap_Send) + sizeof(struct GNUNET_MessageHeader),
+        sendsize);
+    sendsize += sizeof(u8aRadiotap);
+
+    //usedrtap = 1;
+    break;
+  default:
+    break;
     }
 
-  return (0);
+  write_pout->size = sendsize;
 }
 
-void packet_callback(unsigned char *Args,
-                      const struct pcap_pkthdr* Pkthdr,
-                      unsigned char *Packet)
+int
+maketest(unsigned char * buf)
 {
-fprintf(stderr, "+"); fflush(stderr);
-}
+  unsigned char u8aRadiotap[] =
+    { 0x00, 0x00, // <-- radiotap version
+        0x0c, 0x00, // <- radiotap header length
+        0x04, 0x80, 0x00, 0x00, // <-- bitmap
+        0x00, // <-- rate
+        0x00, // <-- padding for natural alignment
+        0x18, 0x00, // <-- TX flags
+      };
+
+  static const uint8_t u8aIeeeHeader[] =
+    { 0x08, 0x01, // Frame Control 0x08= 00001000 -> | b1,2 = 0 -> Version 0;
+        //      b3,4 = 10 -> Data; b5-8 = 0 -> Normal Data
+        //      0x01 = 00000001 -> | b1 = 1 to DS; b2 = 0 not from DS;
+        0x00, 0x00, // Duration/ID
+        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // mac1 - in this case receiver
+        0x13, 0x22, 0x33, 0x44, 0x55, 0x66, // mac2 - in this case sender
+        0x13, 0x22, 0x33, 0x44, 0x55, 0x66, // mac3 - in this case bssid
+        0x10, 0x86, //Sequence Control
+      };
+
+  static const char txt[] = "Hallo1Hallo2 Hallo3 Hallo4...998877665544332211";
+
+  u8aRadiotap[8] = 8;
+  memcpy(buf, u8aRadiotap, sizeof(u8aRadiotap));
+  struct ieee80211_frame * ieee = (struct ieee80211_frame *) u8aIeeeHeader;
+  memcpy(buf + sizeof(u8aRadiotap), ieee, sizeof(u8aIeeeHeader));
+  memcpy(buf + sizeof(u8aRadiotap) + sizeof(u8aIeeeHeader), txt, sizeof(txt));
+  return sizeof(u8aRadiotap) + sizeof(u8aIeeeHeader) + sizeof(txt);
 
+}
 
 int
 hardwaremode(int argc, char *argv[])
 {
 
+  struct Hardware_Infos dev;
   struct ifreq ifreq;
-  char mac[6];
-  int SockFD;
+  struct rx_info * rxinfo;
+  uint8_t * mac = dev.pl_mac;
+  int fdpin, fdpout;
 
-  int fdpin;
-  int fdpout;
+  signal(SIGINT, &sigfunc_hw);
+  signal(SIGTERM, &sigfunc_hw);
 
-  pcap_t *ppcap = NULL;
-  char szErrbuf[PCAP_ERRBUF_SIZE];
-
-  SockFD = socket(AF_INET, SOCK_DGRAM, 0);
-
-  strcpy(ifreq.ifr_name, argv[1]);
-  if (ioctl(SockFD, SIOCGIFHWADDR, &ifreq) < 0)
+  if (wlaninit(&dev, argv[1]))
     {
-      printf("SIOCGIFHWADDR(%s): %m\n", ifreq.ifr_name);
-      return 0;
+      return 1;
     }
 
-  //copy mac to mac array
-  memcpy(mac, ifreq.ifr_hwaddr.sa_data, sizeof(struct MacAddress));
-
   printf("Device %s -> Ethernet %02x:%02x:%02x:%02x:%02x:%02x\n",
       ifreq.ifr_name, (int) mac[0], (int) mac[1], (int) mac[2], (int) mac[3],
       (int) mac[4], (int) mac[5]);
 
-  return 0;
-  // open the interface in pcap
-  ppcap = pcap_open_live(argv[1], 800, 1, 20, szErrbuf);
-  if (ppcap == NULL)
-    {
-      printf("Unable to open interface %s in pcap: %s\n", argv[1], szErrbuf);
-      return (1);
-    }
+  //return 0;
 
   char readbuf[MAXLINE];
   int readsize = 0;
@@ -892,6 +991,8 @@ hardwaremode(int argc, char *argv[])
   write_pout.size = 0;
   write_pout.pos = 0;
 
+  dev.write_pout = &write_pout;
+
   int ret = 0;
   int maxfd = 0;
 
@@ -901,13 +1002,11 @@ hardwaremode(int argc, char *argv[])
   int retval;
 
   struct GNUNET_SERVER_MessageStreamTokenizer * stdin_mst;
-  struct GNUNET_SERVER_MessageStreamTokenizer * file_in_mst;
 
-  fdpin = pcap_fileno(ppcap);
-  fdpout = pcap_fileno(ppcap);
+  fdpin = dev.fd_in;
+  fdpout = dev.fd_out;
 
-  stdin_mst = GNUNET_SERVER_mst_create(&stdin_send, &write_pout);
-  file_in_mst = GNUNET_SERVER_mst_create(&file_in_send, &write_std);
+  stdin_mst = GNUNET_SERVER_mst_create(&stdin_send_hw, &dev);
 
   //send mac first
 
@@ -921,6 +1020,11 @@ hardwaremode(int argc, char *argv[])
   while (0 == closeprog)
     {
 
+      write_pout.size = maketest(write_pout.buf);
+      tv.tv_sec = 2;
+      tv.tv_usec = 0;
+      retval = select(0, NULL, NULL, NULL, &tv);
+
       maxfd = 0;
 
       //set timeout
@@ -936,8 +1040,8 @@ hardwaremode(int argc, char *argv[])
         }
       if (0 == write_std.size)
         {
-          FD_SET(fdpin, &rfds);
-          maxfd = fdpin;
+          //FD_SET(fdpin, &rfds);
+          //maxfd = fdpin;
         }
       FD_ZERO(&wfds);
       // if there is something to write
@@ -990,8 +1094,10 @@ hardwaremode(int argc, char *argv[])
 
       if (FD_ISSET(fdpout, &wfds))
         {
-          ret = write(fdpout, write_pout.buf + write_pout.pos, write_pout.size
-              - write_pout.pos);
+
+          ret = linux_write(&dev, write_pout.buf, write_pout.size);
+          //ret = write(fdpout, write_pout.buf + write_pout.pos, write_pout.size
+          //    - write_pout.pos);
 
           if (0 > ret)
             {
@@ -1002,11 +1108,17 @@ hardwaremode(int argc, char *argv[])
             {
               write_pout.pos += ret;
               // check if finished
-              if (write_pout.pos == write_pout.size)
+              if (write_pout.pos != write_pout.size && ret != 0)
+                {
+                  closeprog = 1;
+                  fprintf(stderr, "Write ERROR packet not in one piece send: %u, %u\n", write_pout.pos, write_pout.size);
+                }
+              else if (write_pout.pos == write_pout.size)
                 {
                   write_pout.pos = 0;
                   write_pout.size = 0;
                 }
+
             }
         }
 
@@ -1034,7 +1146,13 @@ hardwaremode(int argc, char *argv[])
 
       if (FD_ISSET(fdpin, &rfds))
         {
-          readsize = read(fdpin, readbuf, sizeof(readbuf));
+          rxinfo = (struct rx_info *) (write_pout.buf
+              + sizeof(struct GNUNET_MessageHeader));
+          readsize = linux_read(&dev, (unsigned char *) readbuf
+              + sizeof(struct rx_info) + sizeof(struct GNUNET_MessageHeader),
+              sizeof(readbuf) - sizeof(struct rx_info)
+                  - sizeof(struct GNUNET_MessageHeader), rxinfo);
+          //readsize = read(fdpin, readbuf, sizeof(readbuf));
 
           if (0 > readsize)
             {
@@ -1044,19 +1162,19 @@ hardwaremode(int argc, char *argv[])
             }
           else if (0 < readsize)
             {
-              GNUNET_SERVER_mst_receive(file_in_mst, NULL, readbuf, readsize,
-                  GNUNET_NO, GNUNET_NO);
 
             }
           else
             {
               //eof
-              closeprog = 1;
+              //closeprog = 1;
             }
         }
 
     }
 
+  return 0;
+
 }
 
 int
@@ -1074,269 +1192,274 @@ main(int argc, char *argv[])
     {
 
       return testmode(argc, argv);
-    } else {
+    }
+  else
+    {
       hardwaremode(argc, argv);
     }
 
 #if 0
-        u8 u8aSendBuffer[500];
-        char szErrbuf[PCAP_ERRBUF_SIZE];
-        int nCaptureHeaderLength = 0, n80211HeaderLength = 0, nLinkEncap = 0;
-        int nOrdinal = 0, r, nDelay = 100000;
-        int nRateIndex = 0, retval, bytes;
-        pcap_t *ppcap = NULL;
-        struct bpf_program bpfprogram;
-        char * szProgram = "", fBrokenSocket = 0;
-        u16 u16HeaderLen;
-        char szHostname[PATH_MAX];
-
-        if (gethostname(szHostname, sizeof (szHostname) - 1)) {
-                perror("unable to get hostname");
-        }
-        szHostname[sizeof (szHostname) - 1] = '\0';
-
-
-        printf("Packetspammer (c)2007 Andy Green <andy@warmcat.com>  GPL2\n");
-
-        while (1) {
-                int nOptionIndex;
-                static const struct option optiona[] = {
-                        { "delay", required_argument, NULL, 'd' },
-                        { "fcs", no_argument, &flagMarkWithFCS, 1 },
-                        { "help", no_argument, &flagHelp, 1 },
-                        { "verbose", no_argument, &flagVerbose, 1},
-                        { 0, 0, 0, 0 }
-                };
-                int c = getopt_long(argc, argv, "d:hf",
-                        optiona, &nOptionIndex);
-
-                if (c == -1)
-                        break;
-                switch (c) {
-                case 0: // long option
-                        break;
-
-                case 'h': // help
-                        usage();
-
-                case 'd': // delay
-                        nDelay = atoi(optarg);
-                        break;
-
-                case 'f': // mark as FCS attached
-                        flagMarkWithFCS = 1;
-                        break;
-
-                case 'v': //Verbose / readable output to cout
-                        flagVerbose = 1;
-                        break;
-
-                default:
-                        printf("unknown switch %c\n", c);
-                        usage();
-                        break;
-                }
-        }
-
-        if (optind >= argc)
-                usage();
-
-
-                // open the interface in pcap
-
-        szErrbuf[0] = '\0';
-        ppcap = pcap_open_live(argv[optind], 800, 1, 20, szErrbuf);
-        if (ppcap == NULL) {
-                printf("Unable to open interface %s in pcap: %s\n",
-                    argv[optind], szErrbuf);
-                return (1);
-        }
-
-        //get mac from interface
-
-        /*int sock, j, k;
-        char mac[32];
-
-        sock=socket(PF_INET, SOCK_STREAM, 0);
-        if (-1==sock) {
-                perror("can not open socket\n");
-                return 1;
-        }
-
-        if (-1==ioctl(sock, SIOCGIFHWADDR, &ifr)) {
-                perror("ioctl(SIOCGIFHWADDR) ");
-                return 1;
-        }
-        for (j=0, k=0; j<6; j++) {
-                k+=snprintf(mac+k, sizeof(mac)-k-1, j ? ":%02X" : "%02X",
-                        (int)(unsigned int)(unsigned char)ifr.ifr_hwaddr.sa_data[j]);
-        }
-        mac[sizeof(mac)-1]='\0';
-        */
-
-        //get header type
-        nLinkEncap = pcap_datalink(ppcap);
-        nCaptureHeaderLength = 0;
-
-        switch (nLinkEncap) {
-
-                case DLT_PRISM_HEADER:
-                        printf("DLT_PRISM_HEADER Encap\n");
-                        nCaptureHeaderLength = 0x40;
-                        n80211HeaderLength = 0x20; // ieee80211 comes after this
-                        szProgram = "radio[0x4a:4]==0x13223344";
-                        break;
-
-                case DLT_IEEE802_11_RADIO:
-                        printf("DLT_IEEE802_11_RADIO Encap\n");
-                        nCaptureHeaderLength = 0x40;
-                        n80211HeaderLength = 0x18; // ieee80211 comes after this
-                        szProgram = "ether[0x0a:4]==0x13223344";
-                        break;
-
-                default:
-                        printf("!!! unknown encapsulation on %s !\n", argv[1]);
-                        return (1);
-
-        }
-
-        if (pcap_compile(ppcap, &bpfprogram, szProgram, 1, 0) == -1) {
-                puts(szProgram);
-                puts(pcap_geterr(ppcap));
-                return (1);
-        } else {
-                if (pcap_setfilter(ppcap, &bpfprogram) == -1) {
-                        puts(szProgram);
-                        puts(pcap_geterr(ppcap));
-                } else {
-                        printf("RX Filter applied\n");
-                }
-                pcap_freecode(&bpfprogram);
-        }
-
-        pcap_setnonblock(ppcap, 1, szErrbuf);
-
-        printf("   (delay between packets %dus)\n", nDelay);
-
-        memset(u8aSendBuffer, 0, sizeof (u8aSendBuffer));
-
-        while (!fBrokenSocket) {
-                u8 * pu8 = u8aSendBuffer;
-                struct pcap_pkthdr * ppcapPacketHeader = NULL;
-                struct ieee80211_radiotap_iterator rti;
-                PENUMBRA_RADIOTAP_DATA prd;
-                //init of the values
-                prd.m_nRate = 255;
-                prd.m_nChannel = 255;
-                prd.m_nAntenna = 255;
-                prd.m_nRadiotapFlags = 255;
-                u8 * pu8Payload = u8aSendBuffer;
-                int n, nRate;
-
-                // receive
-
-                retval = pcap_next_ex(ppcap, &ppcapPacketHeader,
-                    (const u_char**)&pu8Payload);
-
-                if (retval < 0) {
-                        fBrokenSocket = 1;
-                        continue;
-                }
-
-                if (retval != 1)
-                        goto do_tx;
-
-                u16HeaderLen = (pu8Payload[2] + (pu8Payload[3] << 8));
-
-                printf("rtap: ");
-                Dump(pu8Payload, u16HeaderLen);
-
-                if (ppcapPacketHeader->len <
-                    (u16HeaderLen + n80211HeaderLength))
-                        continue;
-
-                bytes = ppcapPacketHeader->len -
-                        (u16HeaderLen + n80211HeaderLength);
-                if (bytes < 0)
-                        continue;
-
-                if (ieee80211_radiotap_iterator_init(&rti,
-                    (struct ieee80211_radiotap_header *)pu8Payload,
-                    bytes) < 0)
-                        continue;
-
-                while ((n = ieee80211_radiotap_iterator_next(&rti)) == 0) {
-
-                        switch (rti.this_arg_index) {
-                        case IEEE80211_RADIOTAP_RATE:
-                                prd.m_nRate = (*rti.this_arg);
-                                break;
-
-                        case IEEE80211_RADIOTAP_CHANNEL:
-                                prd.m_nChannel =
-                                    le16_to_cpu(*((u16 *)rti.this_arg));
-                                prd.m_nChannelFlags =
-                                    le16_to_cpu(*((u16 *)(rti.this_arg + 2)));
-                                break;
-
-                        case IEEE80211_RADIOTAP_ANTENNA:
-                                prd.m_nAntenna = (*rti.this_arg) + 1;
-                                break;
-
-                        case IEEE80211_RADIOTAP_FLAGS:
-                                prd.m_nRadiotapFlags = *rti.this_arg;
-                                break;
-
-                        }
-                }
-
-                pu8Payload += u16HeaderLen + n80211HeaderLength;
-
-                if (prd.m_nRadiotapFlags & IEEE80211_RADIOTAP_F_FCS)
-                        bytes -= 4;
-
-                printf("RX: Rate: %2d.%dMbps, Freq: %d.%dGHz, "
-                    "Ant: %d, Flags: 0x%X\n",
-                    prd.m_nRate / 2, 5 * (prd.m_nRate & 1),
-                    prd.m_nChannel / 1000,
-                    prd.m_nChannel - ((prd.m_nChannel / 1000) * 1000),
-                    prd.m_nAntenna,
-                    prd.m_nRadiotapFlags);
-
-                Dump(pu8Payload, bytes);
-
-        do_tx:
-
-                // transmit
-
-                memcpy(u8aSendBuffer, u8aRadiotapHeader,
-                        sizeof (u8aRadiotapHeader));
-                if (flagMarkWithFCS)
-                        pu8[OFFSET_FLAGS] |= IEEE80211_RADIOTAP_F_FCS;
-                nRate = pu8[OFFSET_RATE] = u8aRatesToUse[nRateIndex++];
-                if (nRateIndex >= sizeof (u8aRatesToUse))
-                        nRateIndex = 0;
-                pu8 += sizeof (u8aRadiotapHeader);
-
-                memcpy(pu8, u8aIeeeHeader, sizeof (u8aIeeeHeader));
-                pu8 += sizeof (u8aIeeeHeader);
-
-                pu8 += sprintf((char *)u8aSendBuffer,
-                    "Packetspammer %02d"
-                    "broadcast packet"
-                    "#%05d -- :-D --%s ----",
-                    nRate/2, nOrdinal++, szHostname);
-                r = pcap_inject(ppcap, u8aSendBuffer, pu8 - u8aSendBuffer);
-                if (r != (pu8-u8aSendBuffer)) {
-                        perror("Trouble injecting packet");
-                        return (1);
-                }
-                if (nDelay)
-                        usleep(nDelay);
-        }
+  u8 u8aSendBuffer[500];
+  char szErrbuf[PCAP_ERRBUF_SIZE];
+  int nCaptureHeaderLength = 0, n80211HeaderLength = 0, nLinkEncap = 0;
+  int nOrdinal = 0, r, nDelay = 100000;
+  int nRateIndex = 0, retval, bytes;
+  pcap_t *ppcap = NULL;
+  struct bpf_program bpfprogram;
+  char * szProgram = "", fBrokenSocket = 0;
+  u16 u16HeaderLen;
+  char szHostname[PATH_MAX];
+
+  if (gethostname(szHostname, sizeof (szHostname) - 1))
+    {
+      perror("unable to get hostname");
+    }
+  szHostname[sizeof (szHostname) - 1] = '\0';
+
+  printf("Packetspammer (c)2007 Andy Green <andy@warmcat.com>  GPL2\n");
+
+  while (1)
+    {
+      int nOptionIndex;
+      static const struct option optiona[] =
+        {
+            { "delay", required_argument, NULL, 'd'},
+            { "fcs", no_argument, &flagMarkWithFCS, 1},
+            { "help", no_argument, &flagHelp, 1},
+            { "verbose", no_argument, &flagVerbose, 1},
+            { 0, 0, 0, 0}
+        };
+      int c = getopt_long(argc, argv, "d:hf",
+          optiona, &nOptionIndex);
+
+      if (c == -1)
+      break;
+      switch (c)
+        {
+          case 0: // long option
+          break;
+
+          case 'h': // help
+          usage();
+
+          case 'd': // delay
+          nDelay = atoi(optarg);
+          break;
+
+          case 'f': // mark as FCS attached
+          flagMarkWithFCS = 1;
+          break;
+
+          case 'v': //Verbose / readable output to cout
+          flagVerbose = 1;
+          break;
+
+          default:
+          printf("unknown switch %c\n", c);
+          usage();
+          break;
+        }
+    }
+
+  if (optind >= argc)
+  usage();
 
+  // open the interface in pcap
+
+  szErrbuf[0] = '\0';
+  ppcap = pcap_open_live(argv[optind], 800, 1, 20, szErrbuf);
+  if (ppcap == NULL)
+    {
+      printf("Unable to open interface %s in pcap: %s\n",
+          argv[optind], szErrbuf);
+      return (1);
+    }
+
+  //get mac from interface
+
+  /*int sock, j, k;
+   char mac[32];
+
+   sock=socket(PF_INET, SOCK_STREAM, 0);
+   if (-1==sock) {
+   perror("can not open socket\n");
+   return 1;
+   }
+
+   if (-1==ioctl(sock, SIOCGIFHWADDR, &ifr)) {
+   perror("ioctl(SIOCGIFHWADDR) ");
+   return 1;
+   }
+   for (j=0, k=0; j<6; j++) {
+   k+=snprintf(mac+k, sizeof(mac)-k-1, j ? ":%02X" : "%02X",
+   (int)(unsigned int)(unsigned char)ifr.ifr_hwaddr.sa_data[j]);
+   }
+   mac[sizeof(mac)-1]='\0';
+   */
+
+  //get header type
+  nLinkEncap = pcap_datalink(ppcap);
+  nCaptureHeaderLength = 0;
+
+  switch (nLinkEncap)
+    {
+
+      case DLT_PRISM_HEADER:
+      printf("DLT_PRISM_HEADER Encap\n");
+      nCaptureHeaderLength = 0x40;
+      n80211HeaderLength = 0x20; // ieee80211 comes after this
+      szProgram = "radio[0x4a:4]==0x13223344";
+      break;
+
+      case DLT_IEEE802_11_RADIO:
+      printf("DLT_IEEE802_11_RADIO Encap\n");
+      nCaptureHeaderLength = 0x40;
+      n80211HeaderLength = 0x18; // ieee80211 comes after this
+      szProgram = "ether[0x0a:4]==0x13223344";
+      break;
+
+      default:
+      printf("!!! unknown encapsulation on %s !\n", argv[1]);
+      return (1);
+
+    }
+
+  if (pcap_compile(ppcap, &bpfprogram, szProgram, 1, 0) == -1)
+    {
+      puts(szProgram);
+      puts(pcap_geterr(ppcap));
+      return (1);
+    }
+  else
+    {
+      if (pcap_setfilter(ppcap, &bpfprogram) == -1)
+        {
+          puts(szProgram);
+          puts(pcap_geterr(ppcap));
+        }
+      else
+        {
+          printf("RX Filter applied\n");
+        }
+      pcap_freecode(&bpfprogram);
+    }
+
+  pcap_setnonblock(ppcap, 1, szErrbuf);
+
+  printf("   (delay between packets %dus)\n", nDelay);
+
+  memset(u8aSendBuffer, 0, sizeof(u8aSendBuffer));
+
+  while (!fBrokenSocket)
+    {
+      u8 * pu8 = u8aSendBuffer;
+      struct pcap_pkthdr * ppcapPacketHeader = NULL;
+      struct ieee80211_radiotap_iterator rti;
+      PENUMBRA_RADIOTAP_DATA prd;
+      //init of the values
+      prd.m_nRate = 255;
+      prd.m_nChannel = 255;
+      prd.m_nAntenna = 255;
+      prd.m_nRadiotapFlags = 255;
+      u8 * pu8Payload = u8aSendBuffer;
+      int n, nRate;
+
+      // receive
+
+      retval = pcap_next_ex(ppcap, &ppcapPacketHeader,
+          (const u_char**) &pu8Payload);
+
+      if (retval < 0)
+        {
+          fBrokenSocket = 1;
+          continue;
+        }
+
+      if (retval != 1)
+      goto do_tx;
+
+      u16HeaderLen = (pu8Payload[2] + (pu8Payload[3] << 8));
+
+      printf("rtap: ");
+      Dump(pu8Payload, u16HeaderLen);
+
+      if (ppcapPacketHeader->len < (u16HeaderLen + n80211HeaderLength))
+      continue;
+
+      bytes = ppcapPacketHeader->len - (u16HeaderLen + n80211HeaderLength);
+      if (bytes < 0)
+      continue;
+
+      if (ieee80211_radiotap_iterator_init(&rti,
+              (struct ieee80211_radiotap_header *) pu8Payload, bytes) < 0)
+      continue;
+
+      while ((n = ieee80211_radiotap_iterator_next(&rti)) == 0)
+        {
+
+          switch (rti.this_arg_index)
+            {
+              case IEEE80211_RADIOTAP_RATE:
+              prd.m_nRate = (*rti.this_arg);
+              break;
+
+              case IEEE80211_RADIOTAP_CHANNEL:
+              prd.m_nChannel = le16_to_cpu(*((u16 *)rti.this_arg));
+              prd.m_nChannelFlags = le16_to_cpu(*((u16 *)(rti.this_arg + 2)));
+              break;
+
+              case IEEE80211_RADIOTAP_ANTENNA:
+              prd.m_nAntenna = (*rti.this_arg) + 1;
+              break;
+
+              case IEEE80211_RADIOTAP_FLAGS:
+              prd.m_nRadiotapFlags = *rti.this_arg;
+              break;
+
+            }
+        }
+
+      pu8Payload += u16HeaderLen + n80211HeaderLength;
+
+      if (prd.m_nRadiotapFlags & IEEE80211_RADIOTAP_F_FCS)
+      bytes -= 4;
+
+      printf("RX: Rate: %2d.%dMbps, Freq: %d.%dGHz, "
+          "Ant: %d, Flags: 0x%X\n", prd.m_nRate / 2, 5 * (prd.m_nRate & 1),
+          prd.m_nChannel / 1000, prd.m_nChannel - ((prd.m_nChannel / 1000)
+              * 1000), prd.m_nAntenna, prd.m_nRadiotapFlags);
+
+      Dump(pu8Payload, bytes);
+
+      do_tx:
+
+      // transmit
+
+      memcpy(u8aSendBuffer, u8aRadiotapHeader, sizeof(u8aRadiotapHeader));
+      if (flagMarkWithFCS)
+      pu8[OFFSET_FLAGS] |= IEEE80211_RADIOTAP_F_FCS;
+      nRate = pu8[OFFSET_RATE] = u8aRatesToUse[nRateIndex++];
+      if (nRateIndex >= sizeof(u8aRatesToUse))
+      nRateIndex = 0;
+      pu8 += sizeof(u8aRadiotapHeader);
+
+      memcpy(pu8, u8aIeeeHeader, sizeof(u8aIeeeHeader));
+      pu8 += sizeof(u8aIeeeHeader);
+
+      pu8 += sprintf((char *) u8aSendBuffer, "Packetspammer %02d"
+          "broadcast packet"
+          "#%05d -- :-D --%s ----", nRate / 2, nOrdinal++, szHostname);
+      r = pcap_inject(ppcap, u8aSendBuffer, pu8 - u8aSendBuffer);
+      if (r != (pu8 - u8aSendBuffer))
+        {
+          perror("Trouble injecting packet");
+          return (1);
+        }
+      if (nDelay)
+      usleep(nDelay);
+    }
 
 #endif
-        return (0);
+  return (0);
 }