Channelswitch

3 files changed, 53 insertions, 32 deletions

diff --git a/noncore/net/wellenreiter/daemon/source/daemon.cc b/noncore/net/wellenreiter/daemon/source/daemon.cc
index 8471efc..46a50ed 100644
--- a/noncore/net/wellenreiter/daemon/source/daemon.cc
+++ b/noncore/net/wellenreiter/daemon/source/daemon.cc
@@ -1,193 +1,193 @@
 /*
  * Startup functions of wellenreiter
  *
  * $Id$
  */
 
 #include "config.hh"
 #include "daemon.hh"
 
 /* should be parsed from cfg-file */
 #define MAXCHANNEL 13
-#define CHANINTERVAL 700000
+#define CHANINTERVAL 500000
 
 /* Main function of wellenreiterd */
 int main(int argc, char **argv)
 {
   int sock, maxfd, retval;
   char buffer[WL_SOCKBUF];
   struct pcap_pkthdr header;
   struct sockaddr_in saddr;
   pcap_t *handletopcap;
   wl_cardtype_t cardtype;
   pthread_t sub;
   const unsigned char *packet;
 
   fd_set rset;
 
   fprintf(stderr, "wellenreiterd %s\n\n", VERSION);
   fprintf(stderr, "(c) 2002 by M-M-M\n\n");
 
   if(argc < 3)
     usage();
   
   /* Set sniffer device */
   memset(cardtype.iface, 0, sizeof(cardtype.iface));
   strncpy(cardtype.iface, (char *)argv[1], sizeof(cardtype.iface) - 1);
 
   /* Set card type */
   cardtype.type = atoi(argv[2]);
   if(cardtype.type < 1 || cardtype.type > 4)
     usage();
 
   /* set card into monitor mode */
   if(!card_into_monitormode(&handletopcap, cardtype.iface, 
                             cardtype.type))
   {
     wl_logerr("Cannot initialize the wireless-card, aborting");
     exit(EXIT_FAILURE);
   }
   wl_loginfo("Set card into monitor mode");
 
   /* setup pcap */
   if((handletopcap = pcap_open_live(cardtype.iface, 
                                     BUFSIZ, 1, 0, NULL)) == NULL)
   {
     wl_logerr("pcap_open_live() failed: %s", strerror(errno));
     exit(EXIT_FAILURE);
   }
   
 #ifdef HAVE_PCAP_NONBLOCK
   pcap_setnonblock(handletopcap, 1, NULL);
 #endif
   
   /* Setup socket for incoming commands */
   if((sock=wl_setupsock(DAEMONADDR, DAEMONPORT, saddr)) < 0)
   {
     wl_logerr("Cannot setup socket");
     exit(EXIT_FAILURE);
   } 
   wl_loginfo("Set up socket '%d' for GUI communication", sock);
 
   /* Create channelswitching thread */
   if(pthread_create(&sub, NULL, channel_switcher, 
                     (void *)&cardtype) != 0)
   {
     wl_logerr("Cannot create thread: %s", strerror(errno));
     close(sock);
     exit(EXIT_FAILURE);
   } 
   if(pthread_detach(sub))
   {
     wl_logerr("Error detaching thread");
     close(sock);
     pthread_exit((pthread_t *)sub);
     exit(EXIT_FAILURE);
   }
   wl_loginfo("Created and detached channel switching thread");
   
   FD_ZERO(&rset);
 
   /* Start main loop */
   wl_loginfo("Starting main loop");
   while(1)
   {
 
     FD_SET(sock, &rset);
     FD_SET(pcap_fileno(handletopcap), &rset);
 
     /* maxfd = biggest filefd */
     maxfd = (sock > pcap_fileno(handletopcap) ? 
              sock + 1 : pcap_fileno(handletopcap)) + 1;
 
     if(select(maxfd, &rset, NULL, NULL, NULL) < 0)
     {
       wl_logerr("Error calling select: %s", strerror(errno));
       break;
     }     
 
     /* Got data on local socket from GUI */
     if(FD_ISSET(sock, &rset))
     {
       /* Receive data from socket */
       if((retval=wl_recv(&sock, saddr, buffer, sizeof(buffer))) < 0)
       {
         wl_logerr("Error trying to read: %s", strerror(errno));
         break;
       }
       else
       {
         /* check type of packet and start function according to it */
         switch(retval)
         {
           case 98:
            wl_loginfo("Received STARTSNIFF command");
            break;
           case 99:
             wl_loginfo("Received STOPSNIFF command");
             break;
           default:
             wl_logerr("Received unknown command: %d", retval);
             break;
         }
       }
     } /* FD_ISSET */
 
     /* Check pcap lib for packets */
     if(FD_ISSET(pcap_fileno(handletopcap), &rset))
     {
 
       /* Grab one single packet */
       packet = pcap_next(handletopcap, &header);
 
       /* process the packet */
       process_packets(&header,*&packet, GUIADDR, GUIPORT);
     }
 
   } /* while(1) */
   
   close(sock);
   exit(EXIT_SUCCESS);
 }
 
 void 
 usage(void)
 {
   fprintf(stderr, "Usage: wellenreiter <device> <cardtype>\n"      \
           "\t<device>   = Wirelessdevice (e.g. wlan0)\n" \
           "\t<cardtype> = Cardtype:\tCisco\t= 1\n"       \
           "\t\t\t\tNG\t= 2\n"                             \
                   "\t\t\t\tHOSTAP\t= 3\n"                 \
           "\t\t\t\tLUCENT\t= 4\n");
   exit(EXIT_FAILURE);
 }
 
 void * 
 channel_switcher(void *cardtypeptr)
 {
   wl_cardtype_t *cardtype;
   int channel=1;
 
   /* Get card info struct */
   cardtype = (wl_cardtype_t *)cardtypeptr;
 
   while(1)
   {
 
     /* If channel bigger than maxchannel, set to 1 */
     if(channel > MAXCHANNEL)
       channel=1;
     
     /* Set channel */
     if(!card_set_channel(cardtype->iface, channel, cardtype->type))
     {
       wl_logerr("Cannot set channel, thread exiting");
       pthread_exit(NULL);
     }
     
     /* sleep */
     usleep(CHANINTERVAL);
     
     channel++;
   } /* while */
 }
diff --git a/noncore/net/wellenreiter/libwellenreiter/source/cardmode.cc b/noncore/net/wellenreiter/libwellenreiter/source/cardmode.cc
index 0c23922..9e0a772 100644
--- a/noncore/net/wellenreiter/libwellenreiter/source/cardmode.cc
+++ b/noncore/net/wellenreiter/libwellenreiter/source/cardmode.cc
@@ -1,192 +1,210 @@
 /* 
  * Set card modes for sniffing
  *
  * $Id$
  */
 
 #include "cardmode.hh"
 #include "wl_log.hh"
 
 /* main card into monitor function */
 int card_into_monitormode (pcap_t **orighandle, char *device, int cardtype)
 {
   char CiscoRFMON[35] = "/proc/driver/aironet/";
   FILE *CISCO_CONFIG_FILE;
 
   /* Checks if we have a device to sniff on */
   if(device == NULL)
   {
       wl_logerr("No device given");
       return 0;
   }
   
   /* Setting the promiscous and up flag to the interface */
   if (!card_set_promisc_up(device))
   {
     wl_logerr("Cannot set interface to promisc mode");
     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) - 1, 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) - 1, "%s %s lnxreq_wlansniff channel=1 enable=true", WLANCTL_PATH, device);
+      snprintf(wlanngcmd, sizeof(wlanngcmd) - 1, "$(which wlanctl-ng) %s lnxreq_wlansniff channel=%d enable=true", device, 1);
       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");
      char hostapcmd[250];
-     snprintf(hostapcmd, sizeof(hostapcmd) -1, "%s %s monitor 2", IWPRIV_PATH, device);
+     snprintf(hostapcmd, sizeof(hostapcmd) -1, "$(which iwpriv) %s monitor 2 %d", device,1);
      if (system(hostapcmd) !=0)
      {
          wl_logerr("Could not set %s in raw mode, check cardtype", device);
         return 0;
      }
   }
-  else if (cardtype == CARD_TYPE_ORINOCCO)
+  else if (cardtype == CARD_TYPE_ORINOCCO || cardtype == CARD_TYPE_HOSTAP)
   {
-     char lucentcmd[62];
-     snprintf(lucentcmd, sizeof(lucentcmd) - 1, "$(which iwpriv) %s monitor 2 %d", device, 1);
-      if (system(lucentcmd) != 0)
-      {
-          wl_logerr("Could not set %s in raw mode, check cardtype", device);
-          return 0;
+         if (!card_set_channel (device, 1, CARD_TYPE_ORINOCCO))
+         {
+            wl_logerr("Could not set %s in raw mode, check cardtype", device);
+            return 0;
       }
       else
       {
-          wl_loginfo("Successfully set %s into raw mode",device);
+            wl_loginfo("Successfully set %s into raw mode",device);
       }
   }
 
   /* Setting the promiscous and up flag to the interface */
   if (!card_check_rfmon_datalink(device))
   {
     wl_logerr("Cannot set interface to rfmon mode");
     return 0;
   }
   else 
   {
     wl_loginfo("Interface set to rfmon mode");
   }
   return 1;
 }
 
 /* Check card is in the rfmon mode */
 int card_check_rfmon_datalink (char *device)
 {
   int datalinktype=0;
   pcap_t *phandle;
   phandle = pcap_open_live(device, 65,0,0,NULL);
   datalinktype = pcap_datalink (phandle);
   pcap_close(phandle);
 
   if (datalinktype != DLT_IEEE802_11) /* Rawmode is IEEE802_11 */
     {
         return 0;
     }
   else
   {
     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)
 {
     int err;
     /* First generate a socket to use with iocalls */
     int fd = socket(AF_INET, SOCK_DGRAM, 0);
     if (fd < 0)
     {
         /* In case of an error */
         perror("socket");
         return 0;
     }
 
     /* Fill an empty an interface structure with the right flags (UP and Promsic) */
     struct ifreq ifr;
     strncpy(ifr.ifr_name, device,10);
     ifr.ifr_flags = IFF_UP + IFF_PROMISC;
     err = ioctl(fd, SIOCSIFFLAGS, &ifr);
     if (err < 0)
     {
             perror("Could not access the interface, ");
         return 0;
     }
     
     /* Get the informations back from the interface to check if the flags are correct */
     strncpy(ifr.ifr_name, device,10);
     ioctl(fd, SIOCGIFFLAGS, &ifr);
     if (err < 0)
     {
         perror("Could not access the interface, ");
         return 0;
     }
 
     if(ifr.ifr_flags && IFF_UP)
     {
      printf("%s is ok\n", device);
      return 1;
     }
     else
     {
      printf("%s flags could not be set", device);
      return 0;
     }
 }
 
 /* Set channel (Wireless frequency) of the device */
 int card_set_channel (const char *device, int channel, int cardtype)
 {
     if (cardtype == CARD_TYPE_CISCO)
     {
             /* Cisco cards don't need channelswitching */
             return 1;
     }
     /* If it is a lucent orinocco card */ 
-    else if (cardtype == CARD_TYPE_ORINOCCO)
+    else if (cardtype == CARD_TYPE_ORINOCCO || cardtype == CARD_TYPE_HOSTAP)
     {
-        char lucentreset[63];
-        char lucentcmd[62];
-        snprintf(lucentreset, sizeof(lucentreset) -1,"$(which iwpriv) %s force_reset", device);
-        if (system(lucentreset) != 0)
-        {
-          wl_logerr("Could not reset the card %s",device);
-          return 0;
-        }
-        snprintf(lucentcmd, sizeof(lucentcmd) - 1, "$(which iwpriv) %s monitor 2 %d", device, channel);
-        if (system(lucentcmd) != 0)
-      {
-          wl_logerr("Could not set %s in raw mode, check cardtype", device);
-          return 0;
-      }
-      wl_loginfo("Channel %d set on interface %s",channel,device);
-      return 1;
+            int fd;
+           //Wireless tools structure for the iocalls
+           struct iwreq ireq;  
+           int *ptr;
+           /* Socket needed to use the iocall to */
+           fd = socket(AF_INET, SOCK_STREAM, 0);
+           if ( fd == -1 ) {
+              return -1;
+           }
+           ptr = (int *) ireq.u.name;
+           // This is the monitor mode for 802.11 non-prism header
+           ptr[0] = 2;
+           ptr[1] = channel;
+           strcpy(ireq.ifr_ifrn.ifrn_name, device);
+           if (ioctl( fd, SIOCIWFIRSTPRIV + 0x8, &ireq)==0)
+           {
+                  /* All was fine... */
+                  // close(fd);
+                wl_loginfo("Set channel %d on interface %s",channel, device);
+               return 1;
+           }
+           else
+           {   /* iocall does not work */
+                        wl_logerr("Could not set channel %d on %s, check cardtype",channel, device);
+                        return 0;
+           }
     }
-   
+    else if (cardtype == CARD_TYPE_NG)
+        {
+                char wlanngcmd[62];
+                snprintf(wlanngcmd, sizeof(wlanngcmd) - 1, "$(which wlanctl-ng) %s lnxreq_wlansniff channel=%d enable=true", device, channel);
+                if (system(wlanngcmd) != 0)
+                {
+                        wl_logerr("Could not set channel %d on %s, check cardtype",channel, device);
+                        return 0;
+                }
+
+        }
     /* For undefined situations */
         return 0;
 }
 
diff --git a/noncore/net/wellenreiter/libwellenreiter/source/cardmode.hh b/noncore/net/wellenreiter/libwellenreiter/source/cardmode.hh
index 3a1991b..242d8c5 100644
--- a/noncore/net/wellenreiter/libwellenreiter/source/cardmode.hh
+++ b/noncore/net/wellenreiter/libwellenreiter/source/cardmode.hh
@@ -1,44 +1,47 @@
 /* $Id$ */
 
 #ifndef CARDMODE_HH
 #define CARDMODE_HH
 
 #include <string.h>
 #include <stdlib.h>
 #include <errno.h>
 #include <sys/types.h>
 #include <sys/time.h>
 #include <sys/socket.h>
 #include <netinet/in.h>
 #include <arpa/inet.h>
 #include <sys/ioctl.h>
 #include <linux/if.h>
+#include <linux/wireless.h>
+
+#ifndef SIOCIWFIRSTPRIV
+#define SIOCIWFIRSTPRIV SIOCDEVPRIVATE
+#endif
+
 
 extern "C"
 {
 #include <net/bpf.h>
 #include <pcap.h>  
 }
 
 /* Defines, used for the card setup */
 #define   DEFAULT_PATH       "/proc/driver/aironet/%s/Config"
 #define   CISCO_STATUS       "/proc/driver/aironet/%s/Status"
         #define   CARD_TYPE_CISCO 1
         #define   CARD_TYPE_NG    2
         #define   CARD_TYPE_HOSTAP3
 #define   CARD_TYPE_ORINOCCO  4
 
 /* only for now, until we have the daemon running */
 /*the config file should provide these information */
 #define   CARD_TYPE              CARD_TYPE_HOSTAP
-        #define   SBIN_PATH         "/sbin/ifconfig %s promisc up"
-#define   WLANCTL_PATH           "/sbin/wlanctl-ng"
-        #define   IWPRIV_PATH    "/sbin/iwpriv"
 
 /* Prototypes */
 int card_check_rfmon_datalink (char *device);
 int card_into_monitormode (pcap_t **, char *, int);
 int card_set_promisc_up (const char *);
 int card_set_channel (const char *device, int channel,int cardtype); 
 
 #endif /* CARDMODE_HH */