scanner.c File Reference

#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>
#include <src/keyboard.h>
#include <src/errmsg.h>
#include <wtap.h>

Include dependency graph for scanner.c:

Go to the source code of this file.

Functions
void	Bye (int ExitCode)
void	HelpAndBye (void)
void	VersionAndBye (void)
void	DispConf (ConfigStruct *config)
void	parse_keystring ()
void	check_keys ()
void	stop_signal (void)
void	ChangeChannel_th (void *ptr1)
int	main (int argc, char **argv)
Variables
static UINT8	ID [] = "$Id: scanner.c 178 2007-08-11 16:57:24Z poggij $"
ConfigStruct	config
ScanResult_t	Res
WINDOW *	Title_WND
WINDOW *	Panel_WND
WINDOW *	Sum_WND
WINDOW *	RealTime_WND
Statistics_t	Stats
UINT8	CursesIsInUse = (UINT8) 0
pthread_mutex_t	screen_mutex = PTHREAD_MUTEX_INITIALIZER
	MUTEX for lock screen, so only one func write to it at the same time.
pthread_t	thread_ChgChan
pthread_t	thread_RefreshRTW
pthread_t	thread_checkkey
UINT8	stop_sniffing = (UINT8) 0

---

Function Documentation

void Bye

(

int

ExitCode

)

void HelpAndBye

(

void

)

void VersionAndBye

(

void

)

void DispConf

(

ConfigStruct *

config

)

Definition at line 1587 of file functions.c.

References Bye(), ConfigStruct::CheckScreenSize, CISCO_CVS_CARD, ConfigStruct::DateFormat, ConfigStruct::DebugLevel, ConfigStruct::devname, ConfigStruct::devname2, ERROR_UNKNOWN_INTERFACE, FALSE, ConfigStruct::IDS_is_ON, InterfaceIsExistant(), MAX_DEBUG_LEVEL, ConfigStruct::MaxPacket, ConfigStruct::OutDotFileName, ConfigStruct::OutDumpFileName, ConfigStruct::OutFileName, ConfigStruct::SendAlert2Syslog, ConfigStruct::SingleChannel, ConfigStruct::TimeToSleepBeforeChangeChannel, and ConfigStruct::TypeOfCard.

Referenced by main().

{

  if (config->TypeOfCard == CISCO_CVS_CARD) {
    fprintf(stdout, "Interfaces used: %s and %s \n", config->devname,
            config->devname2);
    if (InterfaceIsExistant(config->devname2) == FALSE) {
      fprintf(stderr, "Arg, the interface %s is not existant\n",
              config->devname2);
      Bye(ERROR_UNKNOWN_INTERFACE);
    }
  } else {
    fprintf(stdout, "Interface used: %s\n", config->devname);
  }
  if (InterfaceIsExistant(config->devname) == FALSE) {
    fprintf(stderr, "Arg, the interface %s is not existant\n",
            config->devname);
    Bye(ERROR_UNKNOWN_INTERFACE);
  }

  fprintf(stdout, "Debug Level: %d", config->DebugLevel);
  if (config->DebugLevel == MAX_DEBUG_LEVEL)
    fprintf(stdout, " (Crazy level)");
  // Out Files
  fprintf(stdout, "\nOutput filename: %s",
          (config->OutFileName == NULL) ? "<none>" : config->OutFileName);
  fprintf(stdout, "\nPCap dump file: %s",
          (config->OutDumpFileName ==
           NULL) ? "<none>" : config->OutDumpFileName);
  fprintf(stdout, "\nDot output filename: %s",
          (config->OutDotFileName ==
           NULL) ? "<none>" : config->OutDotFileName);

  fprintf(stdout, "\nChannel scan : %d", config->SingleChannel);
  if (config->SingleChannel == 0)
    fprintf(stdout, " (All channels)");
  fprintf(stdout, "\nSleep between channel hop: %d",
          config->TimeToSleepBeforeChangeChannel);

  fprintf(stdout, "\nMax packets before quit: %d",
          (int) config->MaxPacket);
  if (!config->MaxPacket)
    fprintf(stdout, " (Don't quit)");
  fprintf(stdout, "\nDate format: %s",
          (config->DateFormat) ? "Timestamp" : "Human readable");
  fprintf(stdout, "\nCurses Screen size detection: %s",
          (config->CheckScreenSize) ? "Enabled" : "Disabled");
  fprintf(stdout, "\nIDS active: %s",
          (config->IDS_is_ON) ? "Enabled" : "Disabled");
  fprintf(stdout, "\nSend IDS alert to Syslog: %s\n",
          (config->SendAlert2Syslog) ? "Enabled" : "Disabled");

// Add channels per second scan info.
}

void parse_keystring

(

)

Definition at line 49 of file keyboard.c.

References AIRJACK_CARD, CHANNEL_MAX, ConfigStruct::ChannelHop, CLEAR_KEYBOARD_BUFFER, ClearPanel(), debug, ConfigStruct::DebugLevel, ConfigStruct::devname, DISPLAY_ACK_BIT, DISPLAY_BEACON_BIT, DISPLAY_CONTROL_BIT, DISPLAY_DATA_BIT, DISPLAY_PROBE_BIT, DISPLAY_STATION_BIT, ConfigStruct::DoNotDisplay, EXIT_WITH_Q, FALSE, ConfigStruct::FirstNIC, HOP_MAX, HOP_MIN, ConfigStruct::JammingNow, KEYBOARD_BUFFER, keyindex, keystring, MAX_DEBUG_LEVEL, ResetAllDetectedClient(), screen_mutex, selectChannel(), Send_To_All_BSSID_A_Deauth(), ConfigStruct::SingleChannel, stop_sniffing, SWITCH_BIT, TIME_TO_SLEEP_BEFORE_CHANGE_CHANNEL, ConfigStruct::TimeToSleepBeforeChangeChannel, TRUE, ConfigStruct::TypeOfCard, and warning().

Referenced by check_keys_th().

{
  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;
  }
}

void check_keys

(

)

void stop_signal

(

void

)

Signal Handler

Definition at line 77 of file scanner.c.

References EXIT_BY_CTRLC, screen_mutex, stop_sniffing, and warning().

Referenced by main().

{
  // 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 = EXIT_BY_CTRLC;
  }
}

void ChangeChannel_th

(

void *

ptr1

)

Definition at line 112 of file scanner.c.

References ConfigStruct::ChannelHop, debug, EXIT_PB_WITH_CHANNEL_HOP, NextChannel(), ConfigStruct::SingleChannel, stop_sniffing, ConfigStruct::TimeToSleepBeforeChangeChannel, and warning().

Referenced by main().

{
  struct timeb binary_now, TimeScann;
  char *devname;
  register UINT32 TTSBCC;
  register UINT32 TTSBCC100;

  //struct timespec delay;

  ftime(&TimeScann);
  devname = (char *) ptr1;

  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 = EXIT_PB_WITH_CHANNEL_HOP;
        debug(2, "devname = %s, ChannelHop=%d\n",
              devname, config.ChannelHop);
        warning("Can't change Channel\n");
        break;                  // Exit while (stop_sniffing == 0)
      }
    }
    usleep(TTSBCC100);
  }
  pthread_exit(0);
}

int main	(	int	argc,
		char **	argv
	)

Write it also on file if wanted

A little mark for better view :)

Exit from curses environment

Close file if needed, it's better clean

Close file if needed, it's better clean

Close RaxSocket

put card in a normal state

Write the summary

And the .dot file also

Definition at line 154 of file scanner.c.

References BoolToStaAp(), BoolToWepNoWep(), ScanResult_t::BssId, Bye(), ChangeChannel_th(), ScanResult_t::Channel, ConfigStruct::ChannelHop, ChannelToStr(), check_keys(), check_keys_th(), ConfigStruct::CheckScreenSize, CISCO_CARD, CISCO_CVS_CARD, closePacket(), CursesIsInUse, ConfigStruct::DateFormat, debug, DEBUG_POINT, ConfigStruct::DebugLevel, ScanResult_t::DestMac, ConfigStruct::devname, ConfigStruct::devname2, DispConf(), DO_NOT_DISPLAY_ACK, DO_NOT_DISPLAY_BEACON, DO_NOT_DISPLAY_CONTROL, DO_NOT_DISPLAY_DATA, DO_NOT_DISPLAY_PROBE, DumpHexPaquets(), EndCurses(), ERROR_CANT_OPEN_FILE, ERROR_NOT_ROOT, ERROR_PCAP_CANT_OPEN, ERROR_SIG_HANDLER, ERROR_THREAD_CANT_INIT, ERROR_UNKNOWN_INTERFACE, EXIT_CANT_SAVE_DATA, EXIT_MAX_PACKET_REACHED, EXIT_PB_WITH_CHANNEL_HOP, FALSE, fatal(), GET_TYPE_BIT_AP, GET_TYPE_BIT_FROMDS, getPacket(), ScanResult_t::hasWep, ScanResult_t::hasWPA, IDS(), ConfigStruct::IDS_is_ON, ids_warning, InitConfiguration(), InitScreen(), Statistics_t::INVLD, LogWriteDOT(), LogWriteHisto(), LogWriteReport(), MAX_BUFFER_SIZE, MAX_NUMBER_OF_DETECTED_CLIENT, ConfigStruct::MaxPacket, Statistics_t::MaxSignal, NextChannel(), NO_ERROR, ScanResult_t::Noise, openCard(), openPacket(), ConfigStruct::OutDotFileName, ConfigStruct::OutDumpFileName, ConfigStruct::OutFileName, Statistics_t::Packets, Panel_WND, ParseCommandLine(), PCAP_VIRTUAL_CARD, processPacket(), ScanResult_t::Rate, RateToString(), RealTime_WND, RefreshRealTime_WND(), RefreshRealTime_WND_th(), ROW_WND_PANEL, ScanResult_t::SChannel, screen_mutex, selectChannel(), shutCard(), ScanResult_t::Signal, ConfigStruct::SingleChannel, ScanResult_t::SrcMac, ScanResult_t::SSID, stop_signal(), stop_sniffing, SubTypeOfClientToString(), Sum_WND, thread_checkkey, thread_ChgChan, thread_RefreshRTW, ConfigStruct::TimeToSleepBeforeChangeChannel, TRUE, ConfigStruct::TypeOfCard, ScanResult_t::TypeOfClient, TypeOfClientToString(), ScanResult_t::TypeOfPacket, ScanResult_t::TypeSubtype, warning(), WIFISCANNER_VERSION, WLAN_FSTYPE_PROBEREQ, WLAN_FTYPE_MGMT, WLAN_GET_FC_FSTYPE, WLAN_GET_FC_FTYPE, wlan_header, WritePanel(), and WriteSummary().

{
  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;
  UINT8 msgbuf[MAX_BUFFER_SIZE];        // packet container
  p80211_caphdr_t wlan_header;

#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;
  FILE *OutDumpFile = NULL;
  FILE *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-2008 Hervé Schauer Consultants (",
          WIFISCANNER_VERSION);
  fprintf(stderr, "Jerome.Poggi@hsc-labs.com)\n\n");

  // Configuration declaration
  InitConfiguration(&config);

  /* parse command line */
  ParseCommandLine(argc, argv, &config);
  
  // 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(ERROR_NOT_ROOT);
  }
  
  // Display the configuration
  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(ERROR_UNKNOWN_INTERFACE, "The interface can not be found or initialize\n");
  }
  // Sanity check
  if (config.OutFileName) {
    if ((OutFile = fopen(config.OutFileName, "a")) == NULL) {
      fatal(ERROR_CANT_OPEN_FILE, "Cant open outfile %s for writing\n", config.OutFileName);
    }
  }
#ifdef WITH_WIRETAP
  // Sanity check
  if (config.OutDumpFileName) {
    dump_file = malloc(sizeof dump_file);
    dump_file =
        wtap_dump_open(config.OutDumpFileName, WTAP_FILE_PCAP,
                       WTAP_ENCAP_IEEE_802_11, 2344, FALSE, &wtap_error);
    //WTAP_ENCAP_ETHERNET, 2344, FALSE, &wtap_error);
    if (!dump_file) {
      fatal(ERROR_CANT_OPEN_FILE, "Cannot make the dump file!\n");
    }
    debug(3, "dump_file pointer is : %08X\n", dump_file);
  }
#endif

  // Install interrupt handler...
  fprintf(stderr, "Install interrupt handler...\n");
  if ((signal(SIGINT, (__sighandler_t) stop_signal) == SIG_ERR) ||
      (signal(SIGTERM, (__sighandler_t) stop_signal) == SIG_ERR) ||
      (signal(SIGHUP, (__sighandler_t) stop_signal) == SIG_ERR)) {
    fatal(ERROR_SIG_HANDLER ,"AAAARRRGGG ! Can't install the SIGHUP handler !\n");
  }

  // Open PCAP File
  fprintf(stderr, "Open the packet capture interface (pcap)\n");
  if (config.TypeOfCard == CISCO_CVS_CARD) {
    ret = openPacket(config.devname2);
    if (ret != NO_ERROR) {
      fprintf(stderr, "Can't open pcap %s device2 (err: %d = %s)\n",
              config.devname2, errno, strerror(errno));
      Bye(ERROR_PCAP_CANT_OPEN);
    }
  } else {
    if (config.TypeOfCard != PCAP_VIRTUAL_CARD) {
      ret = openPacket(config.devname);
      debug(3, " openPacket(config.devname) = %d\n", ret);
      if (ret != NO_ERROR) {
        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
        Bye(ERROR_PCAP_CANT_OPEN);
      }
    }
  }

  fprintf(stderr, "Beginning scan of the 802.11b networks...\n");
  fprintf(stderr, "Use CTRL-C or Q to stop sniffing\n");

#ifdef HAVE_LIBNCURSES
  // Do a pause, so debug info can be read
  if (config.DebugLevel >= 1) {
    debug(1, "Wait 5 seconds, so debug info can be read\n");
    sleep(5);                   // Sleep 5 seconds, so debug info can be read
  }
  /* 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 = EXIT_PB_WITH_CHANNEL_INIT;
    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(ERROR_THREAD_CANT_INIT, "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(ERROR_THREAD_CANT_INIT, "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(ERROR_THREAD_CANT_INIT, "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) {

    // debug (3, "## Begin of loop ## dump_file pointer is : %08X\n", dump_file);
#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) != NO_ERROR) {
          stop_sniffing = EXIT_PB_WITH_CHANNEL_HOP;
          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);
    recvlen = getPacket(&wlan_header, msgbuf, MAX_BUFFER_SIZE);

    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;

        DEBUG_POINT;

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

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

        // Different date format.
        ftime(&binary_now);
        if (config.DateFormat == 0) {
          snprintf(PacketStatus, 255,
                   "%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, Res.hasWPA),
                   BoolToStaAp(GET_TYPE_BIT_AP(Res.TypeOfClient), GET_TYPE_BIT_FROMDS(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, 255,
                   "%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, Res.hasWPA),
                   BoolToStaAp(GET_TYPE_BIT_AP(Res.TypeOfClient), GET_TYPE_BIT_FROMDS(Res.TypeOfClient)),
                   Res.Signal, Res.Noise, Res.DestMac, Res.SrcMac,
                   Res.BssId, RateToString(Res.Rate),
                   TypeOfClientToString(Res.TypeOfClient),
                   SubTypeOfClientToString(Res.TypeOfClient),
                   Res.TypeOfPacket);
        }

        // Save the maximum strength of signal for print an hitogram
        // Do it only if it not a Control packet
        if (((WLAN_GET_FC_FTYPE(Res.TypeSubtype) == WLAN_FTYPE_MGMT) &&
             (WLAN_GET_FC_FSTYPE(Res.TypeSubtype) == WLAN_FSTYPE_PROBEREQ)
            )
            ) {
          debug(3, "PROBEREQ no power was save\n");
        } else {
          if (Stats.MaxSignal[ActifChannel - 1] < Res.Signal) {
            Stats.MaxSignal[ActifChannel - 1] = Res.Signal;
          }
        }

        // 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)
              || (DO_NOT_DISPLAY_PROBE))) {
#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, 255,
                     "%d.%03d,%s\n",
                     (int) binary_now.
                     time, binary_now.millitm, Res.TypeOfPacket);
          } else {
            ascii_now = localtime(&binary_now.time);
            snprintf(PacketStatus, 255,
                     "%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);
    warning("Bad Packet !\n");
//    DumpHexPaquets(RealTime_WND, msgbuf, recvlen);
          //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 = EXIT_MAX_PACKET_REACHED;        // 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
  // 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");
  }
  // Destroy MUTEX
  pthread_mutex_destroy(&screen_mutex);
#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);
    free(dump_file);
  }
#endif

  closePacket();                
  shutCard(config.devname);     

  LogWriteReport();             

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

  debug(3, "Stop Sniffing = %d\n", stop_sniffing);
  Bye(stop_sniffing);
}

---

Variable Documentation

UINT8 ID[] = "$Id: scanner.c 178 2007-08-11 16:57:24Z poggij $" [static]

Definition at line 53 of file scanner.c.

ConfigStruct config

Definition at line 58 of file scanner.c.

ScanResult_t Res

Definition at line 60 of file scanner.c.

Referenced by analyseACK(), analyseBeacon(), analyseCTS(), analyseData(), analyseMGMT(), analyseProbeRep(), analyseProbeReq(), analysePSPOLL(), analyseRTS(), dataIsCrypted(), processPacket(), ProcessTagBits(), and UpdateOtherInformation().

WINDOW* Title_WND

Definition at line 61 of file scanner.c.

Referenced by InitScreen(), and RefreshAllWND().

WINDOW * Panel_WND

Definition at line 61 of file scanner.c.

Referenced by ClearPanel(), InitScreen(), main(), RefreshAllWND(), RefreshRealTime_WND(), RefreshRealTime_WND_th(), and WritePanel().

WINDOW * Sum_WND

Definition at line 61 of file scanner.c.

Referenced by check_keys_th(), InitScreen(), main(), PrintScaleChannel(), RefreshAllWND(), and WriteSummary().

WINDOW * RealTime_WND

Definition at line 61 of file scanner.c.

Referenced by analyseBeacon(), debug(), debugTS(), FillRadioData(), getPacketIPW(), getPacketPCAP(), InitScreen(), main(), RefreshAllWND(), RefreshRealTime_WND(), RefreshRealTime_WND_th(), warning(), and warning_if_error().

Statistics_t Stats

Definition at line 62 of file scanner.c.

UINT8 CursesIsInUse = (UINT8) 0

Definition at line 63 of file scanner.c.

Referenced by debug(), debugTS(), EndCurses(), fatal(), main(), warning(), and warning_if_error().

pthread_mutex_t screen_mutex = PTHREAD_MUTEX_INITIALIZER

MUTEX for lock screen, so only one func write to it at the same time.

Definition at line 67 of file scanner.c.

Referenced by check_keys_th(), ClearPanel(), debug(), debugTS(), DumpHexPaquets(), main(), parse_keystring(), PrintScaleChannel(), RefreshAllWND(), RefreshRealTime_WND_th(), stop_signal(), warning(), warning_if_error(), WritePanel(), and WriteSummary().

pthread_t thread_ChgChan

Definition at line 68 of file scanner.c.

Referenced by main().

pthread_t thread_RefreshRTW

Definition at line 68 of file scanner.c.

Referenced by main().

pthread_t thread_checkkey

Definition at line 68 of file scanner.c.

Referenced by main().

UINT8 stop_sniffing = (UINT8) 0

Definition at line 69 of file scanner.c.

Referenced by ChangeChannel_th(), check_keys_th(), main(), parse_keystring(), RefreshRealTime_WND_th(), and stop_signal().