keyboard.c

Go to the documentation of this file.

/*
 * File : keyboard.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).
 * 
 * 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/crt_io.h>
#include <src/functions.h>
#include <src/airjack.h>
#include <src/driver.h>
#include <src/analyse.h>
#include <src/interface.h>

static const char svnid[] = "@(#) $Id: keyboard.c 175 2007-07-25 15:44:55Z poggij $";

char keystring[KEYBOARD_BUFFER];
int keyindex = 0;

extern UINT8 stop_sniffing;
extern pthread_mutex_t screen_mutex;
extern WINDOW *Title_WND, *Panel_WND, *Sum_WND, *RealTime_WND;
extern ConfigStruct config;

/*
 * Parse key buffer & fire commands
 */

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

void parse_keystring()
{
  register int chan = 0;
  register int ret = 0;

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

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

      ret = selectChannel(config.devname, config.SingleChannel);
      if (ret != 0) {
        selectChannel(config.devname, chan);    // PB, so go back previous channel
        config.SingleChannel = chan;
        warning("Channel %d is forbidden (%d)\n", chan, ret);
      }
      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':
      warning(" UPPER Q to Quit\n");
      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 = EXIT_WITH_Q;
      }
      break;
    case 'r':
      // Do a reset of all captured station
      // Thank's to Guillaume Lehembre for the Idea
      ResetAllDetectedClient();
      ClearPanel();
      CLEAR_KEYBOARD_BUFFER;
      break;
    case 's':                  // change channel more Slowly
      if (config.TimeToSleepBeforeChangeChannel < 500)
        config.TimeToSleepBeforeChangeChannel += 10;
      else
        config.TimeToSleepBeforeChangeChannel += 100;
      debug(2,
            "config.TimeToSleepBeforeChangeChannel = %d ms\n",
            config.TimeToSleepBeforeChangeChannel);
      CLEAR_KEYBOARD_BUFFER;
      break;
    case 'f':                  // change channel more Fast
      if (config.TimeToSleepBeforeChangeChannel < 500)
        config.TimeToSleepBeforeChangeChannel -= 10;
      else
        config.TimeToSleepBeforeChangeChannel -= 100;
      if (config.TimeToSleepBeforeChangeChannel < 25)
        config.TimeToSleepBeforeChangeChannel = 25;
      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 abcdps for hiding/showing Ack, Beacon, Control, Data, Probe and Stations\n"
        "r reset all detected packet\n"
              "D Send de-authentication to all BSSID\n"
              "J Start/Stop jamming\n"
              "Q exit, stop, quit, goback home ...\n");
      CLEAR_KEYBOARD_BUFFER;
      break;
    case 'D':
      // Send De-authentification to ALL BSSID :-)
      // Work only with AIRJACK driver
      if (config.TypeOfCard == AIRJACK_CARD) {
        Send_To_All_BSSID_A_Deauth();
      } else {
        warning
            ("De-authentication is only available with Airjack26 driver\n");
      }
      CLEAR_KEYBOARD_BUFFER;
      break;
    case 'J':
      // Activate the Jamming process
      //  send de-authentication to FF:FF:FF:FF:FF:FF when a beacon is detected
      if (config.TypeOfCard == AIRJACK_CARD) {
        if (config.JammingNow == TRUE) {
          config.JammingNow = FALSE;
        } else {
          config.JammingNow = TRUE;
        }
      } else {
        warning("Jamming is only available with Airjack26 driver\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, DISPLAY_ACK_BIT);
        debug(1, "Switch display of ACK\n");
        break;
      case 'b':
        SWITCH_BIT(config.DoNotDisplay, DISPLAY_BEACON_BIT);
        debug(1, "Switch display of BEACON\n");
        break;
      case 'c':
        SWITCH_BIT(config.DoNotDisplay, DISPLAY_CONTROL_BIT);
        debug(1, "Switch display of CONTROL\n");
        break;
      case 'd':
        SWITCH_BIT(config.DoNotDisplay, DISPLAY_DATA_BIT);
        debug(1, "Switch display of DATA\n");
        break;
      case 'p':
        SWITCH_BIT(config.DoNotDisplay, DISPLAY_PROBE_BIT);
        debug(1, "Switch display of PROBE REQ/RES\n");
        break;
      case 's':
        SWITCH_BIT(config.DoNotDisplay, DISPLAY_STATION_BIT);
        debug(1, "Switch display of STATION\n");
  ClearPanel();
        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';

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

      if (chan >= 0 && chan <= CHANNEL_MAX) {
        ret = selectChannel(config.devname, chan);
        if (ret == 0) {
          config.SingleChannel = (UINT8) chan;  // All is OK
        } else {
          selectChannel(config.devname, config.SingleChannel);  // PB, so go back previous channel
          warning("Channel %d is forbidden (%d)\n", chan, ret);
        }
        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;
  }
}

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

  nodelay(stdscr, TRUE);        // FIXME move it ...
  while (stop_sniffing == 0) {
    //if ((car = tolower(getch())) != ERR) {
    if ((car = 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(void)
{
  nodelay(stdscr, TRUE);        // FIXME move it ...
  //if ((keystring[keyindex] = tolower(getch())) != ERR) {
  if ((keystring[keyindex] = 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

---