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.
 *
 */

/* $Id: scanner.c 178 2007-08-11 16:57:24Z poggij $ */

#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>
#ifdef WITH_WIRETAP
#include <wtap.h>
#endif


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

void parse_keystring();
void check_keys();

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

/*
 * 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

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

/*
 *  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(int ExitCode)
{
  fflush(stdout);
  fflush(stderr);
  fprintf(stderr, "%s\n", ErrorsMsg[ExitCode]);
  exit(ExitCode);
}

#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;

  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);
}
#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;
  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);
}

---