scanner.c

Go to the documentation of this file.

/*
 * File : scanner.c
 * Project : WifiScanner (c) 2002-2004 Hervé Schauer Consultants
 * Usage : This utility is written for use with IEEE 802.11 adapters based
 * on Intersil's PRISM II chipset (PCMCIA).
 * 
 * Base code was from prismstumbler Jan Fernquist <Jan.B.Fernquist@telia.com>
 * and wlanctl from www.linux-wlan.org
 *
 * This program 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 2
 * of the License, or (at your option) any later version.
 * 
 * This program 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 this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *
 * 
 */


#include <include.h>
#include <src/interface.h>
#include <src/driver.h>
#include <src/functions.h>
#include <src/analyse.h>
#include <src/scanner.h>
#include <src/crt_io.h>
#include <src/conversion.h>
#ifdef WITH_WIRETAP
#include <wtap.h>
#endif


/*
*/
void Bye(void);
void HelpAndBye(void);
void VersionAndBye(void);
void DispConf(ConfigStruct * config);

void parse_keystring();
void check_keys();

static UINT8 ID[] =
    "$Id: scanner.c,v 1.54 2005/02/23 11:36:53 poggij Exp $";

/*
 * Use globals, ugly ... 
 */
ConfigStruct config;

ScanResult_t Res;
WINDOW *Title_WND, *Panel_WND, *Sum_WND, *RealTime_WND;
Statistics_t Stats;
UINT8 CursesIsInUse = (UINT8) 0;        /* To know if curses environment is in use */

#ifdef WITH_THREAD

pthread_mutex_t screen_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_t thread_ChgChan, thread_RefreshRTW, thread_checkkey;
UINT8 stop_sniffing = (UINT8) 0;
#else
static UINT8 stop_sniffing = (UINT8) 0;
#endif

char keystring[KEYBOARD_BUFFER];
int keyindex = 0;

RETSIGTYPE stop_signal(void)
{
  // We don't need to stop, if we know that we will stop
  if (!stop_sniffing) {
#ifdef WITH_THREAD
    // Clean and Force STOP the thread
    pthread_mutex_unlock(&screen_mutex);
    //pthread_kill( &thread_ChgChan, (int) 1);
    pthread_mutex_destroy(&screen_mutex);
#endif
    warning("Received CTRL-C - sniffing aborted\n\n");
    stop_sniffing = (UINT8) 1;
  }
}

/*
 *  Display help text and leave
 */
void HelpAndBye(void)
{
  fprintf(stderr, "%s", HELPTEXT);
  fprintf(stderr, "\nPlease send Bug report to : %s\n\n", WIFISCANNER_BUG);
  exit(EXIT_SUCCESS);
}

// Just exit, not sure this function is usefull
void Bye(void)
{
  exit(EXIT_SUCCESS);
}

#ifdef WITH_THREAD
void ChangeChannel_th(void *ptr1)
{
  struct timeb binary_now, TimeScann;
  char *devname;
  register UINT32 TTSBCC;
  register UINT32 TTSBCC100;

  //struct timespec delay;

  ftime(&TimeScann);
  devname = (char *) ptr1;
  /* For other OS than Linux :
     delay.tv_sec = 0;
     delay.tv_nsec = config.TimeToSleepBeforeChangeChannel * 100000;
   */

  while (stop_sniffing == 0) {
        /*** Time trigger for change channel ***/
    TTSBCC = config.TimeToSleepBeforeChangeChannel;
    TTSBCC100 = config.TimeToSleepBeforeChangeChannel * 100;
    // Save time, so we change channel only when it's time
    ftime(&binary_now);
    // is it time to change channel ?
    if (config.SingleChannel == 0 &&
        ((binary_now.time - TimeScann.time) * 1000) +
        ((binary_now.millitm - TimeScann.millitm)) >=
        (signed long) TTSBCC) {
      /* it's time to change Channel */
      ftime(&TimeScann);
      if (NextChannel(devname, config.ChannelHop)) {
        stop_sniffing = 2;
        debug(2, "devname = %s, ChannelHop=%d\n",
              devname, config.ChannelHop);
        debug(0, "Can't change Channel\n");
        break;                  // Exit while (stop_sniffing == 0)
      }
    }
    //pthread_delay_np (&delay);
    usleep(TTSBCC100);
  }
  pthread_exit(0);
}
#endif


/*
 * Keyboard Handling
 */
#ifdef WITH_THREAD
void check_keys_th()
{
  UINT8 car;

  nodelay(stdscr, TRUE);        // FIXME move it ...
  while (stop_sniffing == 0) {
    if ((car = tolower(getch())) != ERR) {
      if ((car >= ' ') && (car <= '~')) {
        // Check if it's not a bad char
        keystring[keyindex] = car;
        debug(3, "We Hit : #%c# - keyindex=%d\n", keystring[keyindex],
              keyindex);
        keyindex = (keyindex + 1) % KEYBOARD_BUFFER;
        pthread_mutex_lock(&screen_mutex);
        mvwprintw(Sum_WND, 11, 11, "(%-4s)", keystring);
        wrefresh(Sum_WND);
        pthread_mutex_unlock(&screen_mutex);
        parse_keystring();
      }
    }
    //pthread_delay_np (&delay);
    usleep(100000);
  }
}
#else
void check_keys()
{
  nodelay(stdscr, TRUE);        // FIXME move it ...
  if ((keystring[keyindex] = tolower(getch())) != ERR) {
    if ((keystring[keyindex] >= ' ') && (keystring[keyindex] <= '~')) {
      // Check if it's not a bad char
      debug(3, "We Hit : #%c# - keyindex=%d\n", keystring[keyindex],
            keyindex);
      keyindex = (keyindex + 1) % KEYBOARD_BUFFER;
      mvwprintw(Sum_WND, 11, 11, "(%-4s)", keystring);
      wrefresh(Sum_WND);
      parse_keystring();
    } else {
      keystring[keyindex] = 0;
    }
  }
}
#endif



/******** MAIN ********/

int main(int argc, char **argv)
{
  int recvlen;                  // Size of packet received

  //int MaxPacketPerChannel;    // Number of packet received before the next channel is select
  struct tm *ascii_now = NULL;  // The timestamp in ASCII (human readable)
  struct timeb binary_now;
  unsigned char msgbuf[MAX_BUFFER_SIZE];        // packet container

#ifdef WITHOUT_THREAD
  struct timeb TimeScann;
#endif
#ifdef WITH_WIRETAP
  struct wtap_pkthdr packet_hdr_info;   // pointer to the header of wtap packet 
  int wtap_error;
  wtap_dumper *dump_file = NULL;        // pointer to the file used to save pcap data
#else
  char *dump_file = NULL;
#endif
  UINT64 CatchPacket = 0;
  char PacketStatus[256];
  FILE *OutFile = NULL, *OutDumpFile = NULL, *OutDotFile = NULL;
  UINT8 GotItOne = FALSE;
  UINT8 ids_warning = (UINT8) 0;
  char strChannel[8];
  UINT8 ActifChannel = 0;
  int ret;


  // Wifiscanner Info Banner
  fprintf(stderr,
          "WifiScanner v%s (c) 2002-2004 Hervé Schauer Consultants (",
          WIFISCANNER_VERSION);
  fprintf(stderr, "Jerome.Poggi@hsc-labs.com)\n\n");

  // Root permissions test
  if (getuid() != 0) {
    warning
        ("Hum hum, you seem to be not have the root capabilities...\n"
         "wifiscanner -h for help\n"
         "Try to obtain root capabilities and re-run me :-)\n");
    Bye();
  }
  // Configuration declaration
  InitConfiguration(&config);

  /* parse command line */
  ParseCommandLine(argc, argv, &config);
  DispConf(&config);

  // For information
  debug(3, "Size of ClientInfo_t struct : %6d bytes\n",
        sizeof(ClientInfo_t));
  debug(3, "Size of ClientInfo_t array  : %6d bytes\n",
        (sizeof(ClientInfo_t) * MAX_NUMBER_OF_DETECTED_CLIENT));

  // We try to interract with the card, if it's not possible we exit
  if (openCard(config.devname)) {
    fatal("The interface can not be found or initialize\n");
  }
  // Sanity check
  if (config.OutFileName) {
    if ((OutFile = fopen(config.OutFileName, "a")) == NULL) {
      fatal("Cant open outfile %s for writing\n", config.OutFileName);
    }
  }
#ifdef WITH_WIRETAP
  // Sanity check
  if (config.OutDumpFileName) {
    dump_file =
        wtap_dump_open(config.OutDumpFileName, WTAP_FILE_PCAP,
                       WTAP_ENCAP_IEEE_802_11, 2344, &wtap_error);
    if (!dump_file) {
      fatal("Cannot make the dump file!\n");
    }
  }
#endif


  fprintf(stderr, "Install interrupt handler...\n");
  if (signal(SIGINT, (__sighandler_t) stop_signal) == SIG_ERR) {
    fatal("AAAARRRGGG ! Can't install the SIGINT handler !\n");
  }
  if (signal(SIGTERM, (__sighandler_t) stop_signal) == SIG_ERR) {
    fatal("AAAARRRGGG ! Can't install the SIGTERM handler !\n");
  }
  if (signal(SIGHUP, (__sighandler_t) stop_signal) == SIG_ERR) {
    fatal("AAAARRRGGG ! Can't install the SIGHUP handler !\n");
  }
  fprintf(stderr, "Beginning scan of the 802.11b networks...\n");
  fprintf(stderr, "Use CTRL-C or Q to stop sniffing\n");

  if (config.TypeOfCard == CISCO_CVS_CARD) {
    ret = openPacket(config.devname2);
    if (ret < 0) {
      fprintf(stderr, "Can't open pcap %s device (err: %d = %s)\n",
              config.devname2, errno, strerror(errno));
      exit(EXIT_FAILURE);
    }
  } else {
    ret = openPacket(config.devname);
    if (ret < 0) {
      fprintf(stderr, "Can't open pcap %s device (err: %d = %s)\n",
              config.devname, errno, strerror(errno));
#ifdef WITH_WIRETAP
      //wtap_dump_close(dump_file, &wtap_error);
#endif
      exit(EXIT_FAILURE);
    }
  }

#ifdef HAVE_LIBNCURSES
  /* Initialisation of NCURSES */
  CursesIsInUse = TRUE;
  InitScreen(config.CheckScreenSize);
  if (config.IDS_is_ON == TRUE)
    mvwprintw(Sum_WND, 17, 3, "IDS is ON ");
#else
  if (config.IDS_is_ON == TRUE)
    fprintf(stderr, "IDS is ON");
#endif

  /*** 
   * Change my Priority and put all keyboard input to trash
   ***/

  (void) setvbuf(stdin, NULL, _IONBF, 0);       // Input go to trash :-)
  (void) setpriority(PRIO_PROCESS, 0, -15);     // take more CPU than normal

  /***
   *  Initialisation of the selected channel in single channel scan 
   ***/
  if (config.SingleChannel &&
      !selectChannel(config.devname, config.SingleChannel)) {
    //stop_sniffing = 1;
    warning("Can't initialize Channel number %d !\n",
            config.SingleChannel);
    //sleep (5);
  }



/*
 * We install our threads here 
 */
#ifdef WITH_THREAD
  // Thread for changing channel
  // ---------------------------
  if ((config.TypeOfCard != CISCO_CVS_CARD)
      && (config.TypeOfCard != CISCO_CARD)) {
    ret =
        pthread_create(&thread_ChgChan, NULL, (void *) &ChangeChannel_th,
                       (void *) config.devname);
    if (ret < 0)
      fatal("Boom ! Thread to change channel cannot create (err:%d)\n",
            ret);
  }
  // Thread to refresh screen only one time per second
  // -------------------------------------------------
  if (config.DebugLevel < 2) {
    ret =
        pthread_create(&thread_RefreshRTW, NULL,
                       (void *) &RefreshRealTime_WND_th, (void *) NULL);
    if (ret < 0)
      fatal("Boom ! Thread to refresh screen cannot create (err:%d)\n",
            ret);
  }
  // Thread to check keyboard
  // ------------------------
  ret =
      pthread_create(&thread_checkkey, NULL, (void *) &check_keys_th,
                     (void *) config.devname);
  if (ret < 0)
    fatal("Boom ! Thread to manage keyboard cannot create (err:%d)\n",
          ret);
#else
  ftime(&TimeScann);
#endif

  /*****
    This is the linear and threaded scheduler
    TODO : To convert in more thread (Work in progress) :-)
    TODO : It's better to be ONLY threaded
  ******/
  while (stop_sniffing == 0) {

#ifdef WITHOUT_THREAD
    check_keys();
        /*** Time trigger for change channel ***/
    // Save time, so we change channel only when it's time
    ftime(&binary_now);
    // is it time to change channel ?
    if (((binary_now.time - TimeScann.time) * 1000) +
        (binary_now.millitm - TimeScann.millitm) >=
        (config.TimeToSleepBeforeChangeChannel)) {
      /* it's time to change Channel */
      if (!config.SingleChannel) {
        ftime(&TimeScann);
        if (NextChannel(config.devname, config.ChannelHop)) {
          stop_sniffing = 2;
          debug(0, "Can't change Channel\n");
          break;                // Exit while (stop_sniffing == 0)
        }
      }
    }
#endif

        /*** Get packet process ***/
    memset(msgbuf, 0, MAX_BUFFER_SIZE);
    recvlen =
        getPacket(msgbuf, MAX_BUFFER_SIZE, TIMEOUT_TRY_TO_READ_PAQUET);
    if (recvlen > 0) {
      // Get it one ? Yes ! so analyse it
      Stats.Packets++;
      GotItOne = TRUE;
      // Save the hardware channel before the washing machine
      ActifChannel = Res.SChannel;
      memset(&Res, 0, sizeof(Res));
      Res.SChannel = ActifChannel;
      // Print the packet number and size
      debug(2, "Packet number : %ld\n", CatchPacket);
      debug(2, "recvlen = %X\n", recvlen);

      // Just an Hexdump packet
      if (config.DebugLevel >= 2) {
        DumpHexPaquets(RealTime_WND, msgbuf, recvlen);
        //wrefresh(RealTime_WND);
      }
      /* END DEBUG */

#ifdef WITH_WIRETAP
 /*** Write DATA to DumpFile ***/
      if (config.OutDumpFileName) {
        /*
         * Setup Wiretap packet header 
         */
        gettimeofday(&packet_hdr_info.ts, NULL);
        packet_hdr_info.caplen = recvlen;
        packet_hdr_info.len = recvlen;
        packet_hdr_info.pkt_encap = WTAP_ENCAP_IEEE_802_11;

        /*
         * Now we can save the frame to the capture file 
         */
        if (!wtap_dump
            (dump_file, &packet_hdr_info, NULL, &msgbuf, &wtap_error)) {
          stop_sniffing = 4;
          debug(0, "Can't save DATA\n");
          goto NoPacketIsCatched;
        }
      }
#endif

      /*
       * Analyse Data and Write Result
       */
      if (processPacket(msgbuf, recvlen)) {
        // Define how and what we display for channel
        ChannelToStr(strChannel, Res.Channel, Res.SChannel);
        //debug (0, "SSID = '%s'\n", Res.SSID);

        // Save the maximum strength of signal for print an hitogram
        if (Stats.MaxSignal[ActifChannel - 1] < Res.Signal)
          Stats.MaxSignal[ActifChannel - 1] = Res.Signal;

        // Different date format.
        ftime(&binary_now);
        if (config.DateFormat == 0) {
          snprintf(PacketStatus, 256,
                   "%d.%03d,\"%s\",%s,%s,%s,%03d,%03d,%s,%s,%s,%s,%s,%s,%s\n",
                   (int) binary_now.time,
                   binary_now.millitm,
                   Res.SSID, strChannel,
                   BoolToWepNoWep(Res.hasWep),
                   BoolToStaAp(GET_TYPE_BIT_AP(Res.TypeOfClient)),
                   Res.Signal, Res.Noise,
                   Res.DestMac, Res.SrcMac,
                   Res.BssId,
                   RateToString(Res.Rate),
                   TypeOfClientToString(Res.TypeOfClient),
                   SubTypeOfClientToString
                   (Res.TypeOfClient), Res.TypeOfPacket);
        } else {
          ascii_now = localtime(&binary_now.time);
          snprintf(PacketStatus, 256,
                   "%02d/%02d/%04d %02d:%02d:%02d.%03d,"
                   "\"%s\",%s,%s,%s,%03d,%03d,%s,%s,%s,%s,%s,%s,%s\n",
                   ascii_now->tm_mon + 1,
                   ascii_now->tm_mday,
                   ascii_now->tm_year + 1900,
                   ascii_now->tm_hour,
                   ascii_now->tm_min,
                   (binary_now.millitm == 1000) ?
                   (ascii_now->tm_sec + 1) : ascii_now->tm_sec,
                   (binary_now.millitm == 1000) ?
                   0 : binary_now.millitm,
                   Res.SSID, strChannel, BoolToWepNoWep(Res.hasWep),
                   BoolToStaAp(GET_TYPE_BIT_AP(Res.TypeOfClient)),
                   Res.Signal, Res.Noise, Res.DestMac, Res.SrcMac,
                   Res.BssId, RateToString(Res.Rate),
                   TypeOfClientToString(Res.TypeOfClient),
                   SubTypeOfClientToString(Res.TypeOfClient),
                   Res.TypeOfPacket);
        }

        // SWITCH : DISPLAY or NOT a sort of Packet
        if (!((DO_NOT_DISPLAY_ACK)
              || (DO_NOT_DISPLAY_BEACON)
              || (DO_NOT_DISPLAY_CONTROL)
              || (DO_NOT_DISPLAY_DATA))) {
#ifdef HAVE_LIBNCURSES
          wprintw(RealTime_WND, "%s", PacketStatus);
#else
          fprintf(stdout, "%s", PacketStatus);
#endif                          //#ifdef HAVE_LIBNCURSES
        }
        if (OutFile) {
          fprintf(OutFile, "%s", PacketStatus);
          fflush(OutFile);
        }
        debug(1, "--- END OF PACKET PROCESSING ---\n");
#ifdef HAVE_LIBNCURSES
        WritePanel(TRUE);
        //RefreshRealTime_WND(GotItOne);
#else
        fflush(stdout);
#endif                          // #ifdef HAVE_LIBNCURSES
      } else {                  /* if (processPacket */
        /* Packet is not analysed */
        // Init of time
        //ftime (&binary_now);

        if (Res.TypeOfPacket != NULL) {
          if (config.DateFormat == 0) {
            snprintf(PacketStatus, 256,
                     "%d.%03d,%s\n",
                     (int) binary_now.
                     time, binary_now.millitm, Res.TypeOfPacket);
          } else {
            ascii_now = localtime(&binary_now.time);
            snprintf(PacketStatus, 256,
                     "%02d/%02d/%04d %02d:%02d:%02d.%03d,%s\n",
                     ascii_now->tm_mon + 1,
                     ascii_now->tm_mday,
                     ascii_now->tm_year + 1900,
                     ascii_now->tm_hour,
                     ascii_now->tm_min,
                     ascii_now->tm_sec,
                     binary_now.millitm, Res.TypeOfPacket);
          }

#ifdef HAVE_LIBNCURSES
          wprintw(RealTime_WND, "%s", PacketStatus);
          WritePanel(FALSE);
          //RefreshRealTime_WND(GotItOne);
#else
          fprintf(stdout, "%s\n", PacketStatus);
#endif                          // #ifdef HAVE_LIBNCURSES

          // Write it also on file if wanted
          if (OutFile) {
            fprintf(OutFile, "%s", PacketStatus);
          }
        }
      }
      // Exit if we reach the maximum of packets wanted
      ++CatchPacket;
      if ((config.MaxPacket != 0)
          && (CatchPacket >= (config.MaxPacket + Stats.INVLD))) {
        stop_sniffing = 5;      // Exit the principal loop
        warning("Max packets reached\n");
      }
    } else {
      // No packet ? so sleep and wait
      /* An another solution is to used "blocking" IO */
      //if (config.SingleChannel)
      //usleep (TIMEOUT_TRY_TO_READ_PAQUET);
      usleep(config.TimeToSleepBeforeChangeChannel * 10);
    }
  NoPacketIsCatched:

    if (GotItOne) {
      if ((config.IDS_is_ON == TRUE) && ((ids_warning = IDS()) != 0)) {
        ascii_now = localtime(&binary_now.time);
#ifdef HAVE_LIBNCURSES
        if (config.DateFormat == 0) {
          mvwprintw(Panel_WND, ROW_WND_PANEL - 1, 24, "IDS WARNING (%d)",
                    (int) binary_now.time);
        } else {
          mvwprintw(Panel_WND, ROW_WND_PANEL - 1, 24,
                    "IDS WARNING (%02d/%02d/%04d %02d:%02d:%02d)",
                    ascii_now->tm_mon + 1, ascii_now->tm_mday,
                    ascii_now->tm_year + 1900, ascii_now->tm_hour,
                    ascii_now->tm_min, ascii_now->tm_sec);
        }
#else
        if (config.DateFormat == 0) {

          fprintf(stderr, "IDS WARNING (%d)", (int) binary_now.time);
        } else {
          fprintf(stderr,
                  "IDS WARNING (%02d/%02d/%04d %02d:%02d:%02d)",
                  ascii_now->tm_mon + 1,
                  ascii_now->tm_mday,
                  ascii_now->tm_year + 1900,
                  ascii_now->tm_hour,
                  ascii_now->tm_min, ascii_now->tm_sec);
        }
#endif
      }
    }
#ifdef HAVE_LIBNCURSES
    WriteSummary();
    RefreshRealTime_WND(GotItOne);
#endif
    // For refreshing screen only one time per second
    GotItOne = FALSE;
  }                             /* while still sniffing */

#ifdef WITH_THREAD
  // Destroy MUTEX
  pthread_mutex_destroy(&screen_mutex);
  // Wait thread to exit
  if (!config.SingleChannel) {  // TODO check if thread_ChgChan if is null and kill thread if not
    void *ret;

    warning("Waiting thread_ChgChan to exit...");
    (void) pthread_join(thread_ChgChan, &ret);
    warning("OK\n");
  }
  if (config.DebugLevel < 2) {
    void *ret;

    warning("Waiting thread_RefreshRTW to exit...");
    (void) pthread_join(thread_RefreshRTW, &ret);
    warning("OK\n");
  }
#endif
  if (config.DebugLevel > 0) {
    warning("Wait 5 seconds before exit...\n");
    sleep(5);
  }

  EndCurses();                  

  if (OutFile) {                
    fclose(OutFile);
  }
#ifdef WITH_WIRETAP
  if (OutDumpFile) {            
    wtap_dump_close(dump_file, &wtap_error);
  }
#endif

  closePacket();                
  shutCard(config.devname);     

  LogWriteReport();             

  if (config.OutDotFileName) {  
    if ((OutDotFile = fopen(config.OutDotFileName, "w")) == NULL) {
      fatal("Cant open outfile %s for writing\n", config.OutDotFileName);
    }
    LogWriteDOT(OutDotFile);
    fclose(OutDotFile);
  }

  if (!config.SingleChannel) {
    LogWriteHisto();
  }

  debug(1, "Stop Sniffing = %d\n", stop_sniffing);
  exit(EXIT_SUCCESS);
}


/*
 * Parse key buffer & fire commands
 */

#define CLEAR_KEYBOARD_BUFFER       memset (keystring, 0, KEYBOARD_BUFFER);keyindex = 0;

void parse_keystring()
{

  switch (keyindex) {
  case 1:
    switch (keystring[0]) {
    case '+':                  // Go to next channel
    case '-':                  // Go to previous channel
      if ((keystring[0] == '+')
          && (config.SingleChannel < 14))
        config.SingleChannel++;
      if ((keystring[0] == '-')
          && (config.SingleChannel > 0))
        config.SingleChannel--;

      config.SingleChannel = (config.SingleChannel % (CHANNEL_MAX + 1));

      selectChannel(config.devname, config.SingleChannel);
      CLEAR_KEYBOARD_BUFFER;
      break;
    case 'a':                  // Go to next channel
    case 'w':                  // Go to previous channel
      if ((keystring[0] == 'a') && (config.FirstNIC > 0))
        config.FirstNIC--;
      if (keystring[0] == 'w')
        config.FirstNIC++;
      debug(3, "config.FirstNIC = %d\n", config.FirstNIC);
      CLEAR_KEYBOARD_BUFFER;
      break;
    case 'q':                  // It's time to exit
      // We don't need to stop, if we know that we will stop
      if (!stop_sniffing) {
#ifdef WITH_THREAD
        // Clean and Force STOP the thread
        pthread_mutex_unlock(&screen_mutex);
        pthread_mutex_destroy(&screen_mutex);
#endif
        warning("Q was hit - sniffing aborted\n\n");
        stop_sniffing = (UINT8) 1;
      }
      break;
    case 's':                  // change channel more Slowly
      config.TimeToSleepBeforeChangeChannel += 10;
      debug(2,
            "config.TimeToSleepBeforeChangeChannel = %d ms\n",
            config.TimeToSleepBeforeChangeChannel);
      CLEAR_KEYBOARD_BUFFER;
      break;
    case 'f':                  // change channel more Fast
      config.TimeToSleepBeforeChangeChannel -= 10;
      if (config.TimeToSleepBeforeChangeChannel < 10)
        config.TimeToSleepBeforeChangeChannel = 10;
      debug(2,
            "config.TimeToSleepBeforeChangeChannel = %d ms\n",
            config.TimeToSleepBeforeChangeChannel);
      CLEAR_KEYBOARD_BUFFER;
      break;
    case 'd':                  // default TimeToSleepBeforeChangeChannel
      config.TimeToSleepBeforeChangeChannel =
          TIME_TO_SLEEP_BEFORE_CHANGE_CHANNEL;
      debug(2,
            "config.TimeToSleepBeforeChangeChannel = %d ms\n",
            config.TimeToSleepBeforeChangeChannel);
      CLEAR_KEYBOARD_BUFFER;
      break;
    case 'h':
      warning("Help :\n" "Q for quit\n"
              "C??C to scan channel ??\n"
              "+ - to increment or decrement channel to scan\n"
              "A W to scroll in the upper window\n"
              "F S D for scan more fast, more slow and default time\n"
              "J+ J- for changing channel hop\n"
              "V+ V- for changing verbose level\n"
              "N abcd for hiding/showing Ack, Beacon, Control and Data\n");
      CLEAR_KEYBOARD_BUFFER;
      break;
    case 'c':                  // a 4 key option
    case 'j':                  // a 2 key option
    case 'v':                  // a 2 key option
    case 'n':                  // a 2 key option
      break;
    default:                   // the user hit the keyboard, but don't know what he do
      CLEAR_KEYBOARD_BUFFER;
      break;
    }
    break;
  case 2:
    switch (keystring[0]) {
    case 'c':
      break;
    case 'j':
      switch (keystring[1]) {
      case '+':                // Go to next channel hop
        if (config.ChannelHop < HOP_MAX)
          config.ChannelHop++;
        break;
      case '-':                // Go to previous channel hop
        if (config.ChannelHop > HOP_MIN)
          config.ChannelHop--;
        break;
      default:
        break;
      }
      debug(2, "config.ChannelHop = %d\n", config.ChannelHop);
      CLEAR_KEYBOARD_BUFFER;
      break;
    case 'v':
      switch (keystring[1]) {
      case '+':                // Be more verbose
        if (config.DebugLevel < MAX_DEBUG_LEVEL)
          config.DebugLevel++;
        break;
      case '-':                // Be less verbose
        if (config.DebugLevel > 0)
          config.DebugLevel--;
        break;
      default:
        CLEAR_KEYBOARD_BUFFER;
        break;
      }
      debug(1, "DebugLevel=%d\n", config.DebugLevel);
      CLEAR_KEYBOARD_BUFFER;
      keyindex = 0;
      memset(keystring, 0, KEYBOARD_BUFFER);
      break;
    case 'n':
      switch (keystring[1]) {
      case 'a':
        SWITCH_BIT(config.DoNotDisplay, 0);
        debug(1, "Switch display of ACK\n");
        break;
      case 'b':
        SWITCH_BIT(config.DoNotDisplay, 1);
        debug(1, "Switch display of BEACON\n");
        break;
      case 'c':
        SWITCH_BIT(config.DoNotDisplay, 2);
        debug(1, "Switch display of CONTROL\n");
        break;
      case 'd':
        SWITCH_BIT(config.DoNotDisplay, 3);
        debug(1, "Switch display of DATA\n");
        break;
      case 's':
        SWITCH_BIT(config.DoNotDisplay, 4);
        debug(1, "Switch display of STATION\n");
        break;
      default:
        CLEAR_KEYBOARD_BUFFER;
        break;
      }
      CLEAR_KEYBOARD_BUFFER;
      break;
    default:
      CLEAR_KEYBOARD_BUFFER;
      break;
    }
    break;
  case 3:
    break;
  case 4:
    // Sequence : C??C
    // Change channel to a fixed channel
    if (keystring[0] == 'c' && keystring[3] == 'c') {
      keystring[3] = '\0';
      register int chan = 0;

      if (keystring[1] == '0')
        chan = atoi(keystring + 2);
      else
        chan = atoi(keystring + 1);

      if (chan >= 0 && chan < CHANNEL_MAX) {
        config.SingleChannel = (UINT8) chan;
        selectChannel(config.devname, config.SingleChannel);
        memset(keystring, 0, KEYBOARD_BUFFER);
        keyindex = 0;
      }
      debug(2, "Scan only channel %d\n", config.SingleChannel);
    } else {
      CLEAR_KEYBOARD_BUFFER;
    }
    break;
  default:                     // the user hit the keyboard, but don't know what he do
    CLEAR_KEYBOARD_BUFFER;      // So we think that it was sleeping  ;-) and forget ...
    break;
  }
}

---