analyse.c

Go to the documentation of this file.

/* Linux Prism II Stumbler - Utility Scan for 802_11 networks under Linux
 * 
 * File : analyse.c
 * Project : WifiScanner (c) 2002 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.com
 *
 * 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: analyse.c,v 1.36 2005/02/23 11:36:52 poggij Exp $
 */

#include <include.h>
#include <src/analyse.h>
#include <src/interface.h>
#include <src/crt_io.h>
#include <src/conversion.h>
#include <src/manuf.h>

// Private declaration
void LogPutSSID_byAddMAc(UINT8 AddMac[WLAN_ADDR_LEN], char *SSID);
void LogPutSSID_byBSSID(UINT8 BSSID[WLAN_ADDR_LEN], char *SSID);
void CalculCoef(UINT32 X[HISTORY_SIZE],
                UINT32 Y[HISTORY_SIZE], float *a, float *b);

static UINT8 ID[] =
    "$Id: analyse.c,v 1.36 2005/02/23 11:36:52 poggij Exp $";
static UINT16 NumberOfDetectedClient = 0;
static ClientInfo_t ClientInfo[MAX_NUMBER_OF_DETECTED_CLIENT];
const UINT8 BroadcastMAC[WLAN_ADDR_LEN] =
    { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };

// External references
extern WINDOW *Panel_WND, *RealTime_WND;
extern ScanResult_t Res;
extern Statistics_t Stats;
extern UINT8 ids_warning;
extern ConfigStruct config;

#ifdef WITH_THREAD
extern pthread_mutex_t screen_mutex;
#endif


// --------------------

UINT8
CompareAddMac(UINT8 AddMac1[WLAN_ADDR_LEN], UINT8 AddMac2[WLAN_ADDR_LEN])
{
#ifdef WORDS_BIGENDIAN
// Big Endian = Not Intel
  return (((UINT64) AddMac1 & 0xFFFFFFFFFFFF0000ll) ==
          ((UINT64) AddMac2 & 0xFFFFFFFFFFFF0000ll));
#else
// Littel Endian = Intel
  return (((UINT64) AddMac1[5] & 0x0000FFFFFFFFFFFFll) ==
          ((UINT64) AddMac2[5] & 0x0000FFFFFFFFFFFFll));
#endif
}

void LogPutSN(UINT8 AddMac[WLAN_ADDR_LEN], UINT32 SN)
{
  register UINT16 i, j;

  for (i = 0; i < NumberOfDetectedClient; i++) {
    if (CompareAddMac(ClientInfo[i].AddMac, AddMac)) {
      for (j = (HISTORY_SIZE - 1); j != 0; j--) {
        ClientInfo[i].SN[j] = ClientInfo[i].SN[j - 1];
      }
      ClientInfo[i].SN[0] = SN;
      if (ClientInfo[i].SNMax < SN)
        ClientInfo[i].SNMax = SN;
      else if ((ClientInfo[i].SNMin > SN)
               || (ClientInfo[i].SNMin == 0))
        ClientInfo[i].SNMin = SN;

      UINT32 summe = 0;

      for (j = 0; j < 4; j++) {
        summe += ClientInfo[i].SN[j];
      }
      ClientInfo[i].SNMed = (summe / HISTORY_SIZE);

      break;
    }
  }
}

void LogPutRate(UINT8 AddMac[WLAN_ADDR_LEN], UINT8 Rate)
{
  register UINT16 i;

  for (i = 0; i < NumberOfDetectedClient; i++) {
    if (CompareAddMac(ClientInfo[i].AddMac, AddMac)) {
      if (ClientInfo[i].RateMax < Rate)
        ClientInfo[i].RateMax = Rate;
      else if ((ClientInfo[i].RateMin > Rate)
               || (ClientInfo[i].RateMin == 0))
        ClientInfo[i].RateMin = Rate;
      break;
    }
  }
}

void LogPutMaxRate(UINT8 AddMac[WLAN_ADDR_LEN], UINT8 Rate)
{
  register UINT16 i;

  for (i = 0; i < NumberOfDetectedClient; i++) {
    if (CompareAddMac(ClientInfo[i].AddMac, AddMac)) {
      ClientInfo[i].MaxSpeed = Rate;
    }
  }
}
void LogDetectedClient(UINT8 AddMac[WLAN_ADDR_LEN])
{
  register UINT16 i;
  UINT8 Founded = 0;

  if (NumberOfDetectedClient >= MAX_NUMBER_OF_DETECTED_CLIENT)
    return;

  if (CompareAddMac(BroadcastMAC, AddMac))
    Founded = 2;

  for (i = 0; i < NumberOfDetectedClient; i++) {
    if (CompareAddMac(ClientInfo[i].AddMac, AddMac)) {
      Founded = 1;
      break;
    }
  }
  if (!Founded) {
    debug(1,
          "New client found (%02X:%02X:%02X:%02X:%02X:%02X)\n",
          AddMac[0], AddMac[1], AddMac[2], AddMac[3],
          AddMac[4], AddMac[5]);
    memset(&ClientInfo[NumberOfDetectedClient], 0, sizeof(ClientInfo_t));
    memcpy(&ClientInfo[NumberOfDetectedClient].AddMac, AddMac,
           WLAN_ADDR_LEN);
    memcpy(&ClientInfo[NumberOfDetectedClient].Manuf,
           AddMacToManufName(ClientInfo[i].AddMac), MANUF_MAXSTRINGLENGTH);
    memcpy(&ClientInfo[NumberOfDetectedClient].Model,
           AddMacToManufModel(ClientInfo[i].AddMac),
           MANUF_MAXSTRINGLENGTH);
    NumberOfDetectedClient++;
  }
}

void LogPutBSSID(UINT8 AddMac[WLAN_ADDR_LEN], UINT8 BSSID[WLAN_ADDR_LEN])
{
  register UINT16 i;

  // ignore broadcast BUG #557306
  if (CompareAddMac(BSSID, BroadcastMAC) == 0) {
    for (i = 0; i < NumberOfDetectedClient; i++) {
      if (CompareAddMac(ClientInfo[i].AddMac, AddMac)) {
        memcpy(&ClientInfo[i].BSSID, BSSID, WLAN_ADDR_LEN);
        break;
      }
    }
  }
}

void LogPutDS(UINT8 AddMac[WLAN_ADDR_LEN])
{
  register UINT16 i;

  for (i = 0; i < NumberOfDetectedClient; i++) {
    if (CompareAddMac(ClientInfo[i].AddMac, AddMac)) {
      ClientInfo[i].IsDS = 1;
      break;
    }
  }
}

void LogPutWep(UINT8 BSSID[WLAN_ADDR_LEN], UINT8 hasWep)
{
  register UINT16 i;

  for (i = 0; i < NumberOfDetectedClient; i++) {
    if (CompareAddMac(ClientInfo[i].BSSID, BSSID)) {
      ClientInfo[i].hasWep = hasWep;
    }
  }
}

void LogPutChannel_byAddMac(UINT8 AddMac[WLAN_ADDR_LEN], UINT8 Channel)
{
  register UINT16 i;

  for (i = 0; i < NumberOfDetectedClient; i++) {
    if (CompareAddMac(ClientInfo[i].AddMac, AddMac)) {
      ClientInfo[i].Channel = Channel;
      break;
    }
  }
}


void LogPutChannel_byBSSID(UINT8 BSSID[WLAN_ADDR_LEN], UINT8 Channel)
{
  register UINT16 i;

  for (i = 0; i < NumberOfDetectedClient; i++) {
    if (CompareAddMac(ClientInfo[i].BSSID, BSSID)) {
      ClientInfo[i].Channel = Channel;
    }
  }
}

void
LogPutChannel(UINT8 AddMac[WLAN_ADDR_LEN],
              UINT8 BSSID[WLAN_ADDR_LEN], UINT8 Channel)
{
  if (CompareAddMac(BSSID, BroadcastMAC) == 0) {
    if (CompareAddMac(BSSID, BroadcastMAC))
      LogPutChannel_byAddMac(AddMac, Channel);
    else
      LogPutChannel_byBSSID(BSSID, Channel);
  }
}


void LogPutSSID_byAddMac(UINT8 AddMac[WLAN_ADDR_LEN], char *SSID)
{
  register UINT16 i;

/*  warning (">>1 SSID '%s' (%02X:%02X:%02X:%02X:%02X:%02X)\n",
           SSID, AddMac[0], AddMac[1], AddMac[2], AddMac[3], AddMac[4], AddMac[5]); /// XXX
*/
  for (i = 0; i < NumberOfDetectedClient; i++) {
    if (CompareAddMac(ClientInfo[i].AddMac, AddMac)) {
      //    ClientInfo[i].SSID ""           and SSID not " "
      //if ((strlen (ClientInfo[i].SSID) == 0) && (strncmp (SSID, " ", 32))) {  // BUG #557123
      strncpy(ClientInfo[i].SSID, SSID, WLAN_SSID_MAXLEN);
      //}
      break;
    }
  }
}


void LogPutSSID_byBSSID(UINT8 BSSID[WLAN_ADDR_LEN], char *SSID)
{
  register UINT16 i;

/*  warning (">>2 SSID '%s' (%02X:%02X:%02X:%02X:%02X:%02X)\n",
           SSID, BSSID[0], BSSID[1], BSSID[2], BSSID[3], BSSID[4], BSSID[5]); /// XXX
*/
  for (i = 0; i < NumberOfDetectedClient; i++) {
    if (CompareAddMac(ClientInfo[i].BSSID, BSSID)) {
      if ((strlen(ClientInfo[i].SSID) == 0)
          || ((strncmp(SSID, "<Hidden SSID>", 32))
              && (strncmp(SSID, "<Hidden SSID of known length>", 32)))) {
        strncpy(ClientInfo[i].SSID, SSID, WLAN_SSID_MAXLEN);
      }
    }
  }
}

void
LogPutSSID(UINT8 AddMac[WLAN_ADDR_LEN],
           UINT8 BSSID[WLAN_ADDR_LEN], char *SSID)
{
  // We don't initialyse SSID if it's blank, BUG #557123
  //   SSID not ""         and  SSID not " "
  if ((strlen(SSID) != 0) && (strncmp(SSID, " ", 32))) {
    if (CompareAddMac(BSSID, BroadcastMAC))
      LogPutSSID_byAddMac(AddMac, SSID);
    else
      LogPutSSID_byBSSID(BSSID, SSID);
  }
}

void LogPutIsAP(UINT8 AddMac[WLAN_ADDR_LEN], UINT8 hasWep, UINT16 bcn_int)
{
  register UINT16 i, j;
  UINT8 BSSID[WLAN_ADDR_LEN];

  for (i = 0; i < NumberOfDetectedClient; i++) {
    if (CompareAddMac(ClientInfo[i].AddMac, AddMac)) {
      ClientInfo[i].hasWep = hasWep;
      // A little rotation of Beacon Interval
      for (j = (HISTORY_SIZE - 1); j != 0; j--)
        ClientInfo[i].bcn_int[j] = ClientInfo[i].bcn_int[j - 1];
      if (bcn_int != 0)
        ClientInfo[i].bcn_int[0] = bcn_int;
      memcpy(&BSSID, ClientInfo[i].BSSID, WLAN_ADDR_LEN);
      //if (!ClientInfo[i].IsP2P)
      ClientInfo[i].IsAP = 1;
      break;
    }
  }
  LogPutWep(BSSID, hasWep);
}

void LogPutIsP2P(UINT8 AddMac[WLAN_ADDR_LEN], UINT8 hasWep, UINT16 bcn_int)
{
  register UINT16 i, j;

  for (i = 0; i < NumberOfDetectedClient; i++) {
    if (CompareAddMac(ClientInfo[i].AddMac, AddMac)) {
      ClientInfo[i].hasWep = hasWep;
      // A little rotation of Beacon Interval
      for (j = (HISTORY_SIZE - 1); j != 0; j--)
        ClientInfo[i].bcn_int[j] = ClientInfo[i].bcn_int[j - 1];
      if (bcn_int != 0)
        ClientInfo[i].bcn_int[0] = bcn_int;
      ClientInfo[i].IsP2P = 1;
      ClientInfo[i].IsAP = 0;
      debug(1, "IsP2P > %s\n", ClientInfo[i].AddMac);
      break;
    }
  }
}

void
LogPutOtherInformation(UINT8 AddMac[WLAN_ADDR_LEN], char *OtherInformation)
{
  register UINT16 i;

  for (i = 0; i < NumberOfDetectedClient; i++) {
    if (CompareAddMac(ClientInfo[i].AddMac, AddMac)) {
      strncpy(ClientInfo[i].OtherInformation,
              OtherInformation, (MAXSIZE_OTHERINFORMATION - 1));
      break;
    }
  }
}

void LogPutTimestamp(UINT8 AddMac[WLAN_ADDR_LEN], UINT64 TimeStamp)
{
  register UINT16 i;
  UINT8 j;

  for (i = 0; i < NumberOfDetectedClient; i++) {
    if (CompareAddMac(ClientInfo[i].AddMac, AddMac)) {
      for (j = (HISTORY_SIZE - 1); j != 0; j--) {
        ClientInfo[i].TimeStamp[j] = ClientInfo[i].TimeStamp[j - 1];
      }
      ClientInfo[i].TimeStamp[0] = TimeStamp;
      debug(3, "TS : %016llX %016llX %016llX %016llX\n",
            ClientInfo[i].TimeStamp[0],
            ClientInfo[i].TimeStamp[1],
            ClientInfo[i].TimeStamp[2], ClientInfo[i].TimeStamp[3]);
      break;
    }
  }
}

void
LogPutSeqNum(UINT8 AddMac[WLAN_ADDR_LEN],
             UINT8 AddMacDst[WLAN_ADDR_LEN], UINT16 SeqNum)
{
  register UINT16 i, j;

  if (CompareAddMac(AddMacDst, BroadcastMAC)) {
    for (i = 0; i < NumberOfDetectedClient; i++) {
      if (CompareAddMac(ClientInfo[i].AddMac, AddMac)) {
        for (j = (HISTORY_SIZE - 1); j != 0; j--) {
          ClientInfo[i].SeqNum[j] = ClientInfo[i].SeqNum[j - 1];
        }
        ClientInfo[i].SeqNum[0] = WLAN_GET_SEQ_SEQNUM(SeqNum);
        break;
      }
    }
  }
}

void LogPutLastIV(UINT8 AddMac[WLAN_ADDR_LEN], UINT8 IV[4])
{
  register UINT16 i;

  for (i = 0; i < NumberOfDetectedClient; i++) {
    if (CompareAddMac(ClientInfo[i].AddMac, AddMac)) {
      ClientInfo[i].LastIV[0] = IV[0];
      ClientInfo[i].LastIV[1] = IV[1];
      ClientInfo[i].LastIV[2] = IV[2];
      ClientInfo[i].LastIV[3] = IV[3];
      break;
    }
  }
}

void LogWriteReport(void)
{
  int i;
  UINT8 j;

  printf("\n\n");
  printf("Now a summary of the detection :\n");
  printf("--------------------------------\n");

  if (NumberOfDetectedClient == 0) {
    printf("No 802.11b information has been catched\n\n");
  }

  for (i = 0; i < NumberOfDetectedClient; i++) {
    printf("Station (%02X:%02X:%02X:%02X:%02X:%02X)  -  ",
           ClientInfo[i].AddMac[0], ClientInfo[i].AddMac[1],
           ClientInfo[i].AddMac[2], ClientInfo[i].AddMac[3],
           ClientInfo[i].AddMac[4], ClientInfo[i].AddMac[5]);
    printf("BSSID=%02X:%02X:%02X:%02X:%02X:%02X  -  ",
           ClientInfo[i].BSSID[0], ClientInfo[i].BSSID[1],
           ClientInfo[i].BSSID[2], ClientInfo[i].BSSID[3],
           ClientInfo[i].BSSID[4], ClientInfo[i].BSSID[5]);

    if ((strlen(ClientInfo[i].SSID) == 0)
        || ((strlen(ClientInfo[i].SSID) == 1)
            && (*ClientInfo[i].SSID == 0x20)))
      printf("SSID is not broadcasted\n");
    else {
      //printf ("SSID='%s'\n", ClientInfo[i].SSID);
      printf("SSID='");
      for (j = 0; j < strlen(ClientInfo[i].SSID); j++) {
        if (isprint(ClientInfo[i].SSID[j]))
          printf("%c", ClientInfo[i].SSID[j]);
        else
          printf("/0x%02X", ClientInfo[i].SSID[j]);
      }
      printf("'\n");
    }

    printf("  Manufacturer/Model : %s / %s\n",
           AddMacToManufName(ClientInfo[i].AddMac),
           AddMacToManufModel(ClientInfo[i].AddMac));

    if (ClientInfo[i].SNMax != ClientInfo[i].SNMin)
      printf("  Signal is between %u and %u",
             ClientInfo[i].SNMin, ClientInfo[i].SNMax);
    else
      printf("  Signal is stable at %u", ClientInfo[i].SNMax);

    if (ClientInfo[i].RateMax != ClientInfo[i].RateMin)
      printf(" and Data rate is between %s and %s\n",
             RateToString(ClientInfo[i].RateMin),
             RateToString(ClientInfo[i].RateMax));
    else
      printf(" and Data rate is %s\n",
             RateToString(ClientInfo[i].RateMax));

    if (ClientInfo[i].MaxSpeed != 0)
      printf("  Max speed available is %s\n",
             RateToString(ClientInfo[i].MaxSpeed));

    if (ClientInfo[i].hasWep)
      printf("  Channel %d with Wep\n", ClientInfo[i].Channel);
    else
      printf("  Channel %d with no Wep\n", ClientInfo[i].Channel);

    if (ClientInfo[i].bcn_int[0] != 0)
      printf("  1 beacon every %d ms is sent\n", ClientInfo[i].bcn_int[0]);

    if (ClientInfo[i].IsDS) {
      if (ClientInfo[i].IsAP) { // #568053
        printf
            ("  This is an AP that do some NAT or is a router (because it's also a DS)\n");
      } else {
        printf
            ("  This stations is in the Wired network (DS) of the BSSID\n");
      }
    } else {
      if (ClientInfo[i].IsAP)
        printf("  This is an AP\n");
      else if (ClientInfo[i].IsP2P)
        printf("  This an Ad-HOC client\n");
      else
        printf("  This is a client\n");
    }

    if (ClientInfo[i].OtherInformation == NULL) {
      printf("  Other information discovered:\n");
      printf("   > \"%s\"\n", ClientInfo[i].OtherInformation);
    }

    printf("-------------\n");
  }
}

void LogWriteDOT(FILE * filename)
{
  int i;

  if (NumberOfDetectedClient == 0) {
    printf("No 802.11b information has catched\n");
    printf("So no .dot file is created\n\n");
  } else {
    printf("802.11b information has catched so I make my .dot file ");
  }

  fprintf(filename,
          "digraph xyz {\n  ratio=compress;\n  size=\"8,8\";\n"
          "  rankdir=LR;\n  node [shape=box,fontsize=8];\n");

  for (i = 0; i < NumberOfDetectedClient; i++) {
    printf(".");
    fprintf(filename, "\"%02X:%02X:%02X:%02X:%02X:%02X\" -> ",
            ClientInfo[i].BSSID[0], ClientInfo[i].BSSID[1],
            ClientInfo[i].BSSID[2], ClientInfo[i].BSSID[3],
            ClientInfo[i].BSSID[4], ClientInfo[i].BSSID[5]);
    fprintf(filename, "\"%02X:%02X:%02X:%02X:%02X:%02X\";\n",
            ClientInfo[i].AddMac[0], ClientInfo[i].AddMac[1],
            ClientInfo[i].AddMac[2], ClientInfo[i].AddMac[3],
            ClientInfo[i].AddMac[4], ClientInfo[i].AddMac[5]);
    if (ClientInfo[i].IsDS)
      fprintf(filename,
              "\"%02X:%02X:%02X:%02X:%02X:%02X\" [shape=diamond];\n",
              ClientInfo[i].AddMac[0],
              ClientInfo[i].AddMac[1],
              ClientInfo[i].AddMac[2],
              ClientInfo[i].AddMac[3],
              ClientInfo[i].AddMac[4], ClientInfo[i].AddMac[5]);
    else {
      if (ClientInfo[i].IsAP) {
        fprintf(filename,
                "\"%02X:%02X:%02X:%02X:%02X:%02X\" [shape=circle,label=\"",
                ClientInfo[i].AddMac[0],
                ClientInfo[i].AddMac[1],
                ClientInfo[i].AddMac[2],
                ClientInfo[i].AddMac[3],
                ClientInfo[i].AddMac[4], ClientInfo[i].AddMac[5]);
        fprintf(filename,
                "%02X:%02X:%02X:%02X:%02X:%02X\\nSSID='%s'\"];\n",
                ClientInfo[i].AddMac[0],
                ClientInfo[i].AddMac[1],
                ClientInfo[i].AddMac[2],
                ClientInfo[i].AddMac[3],
                ClientInfo[i].AddMac[4],
                ClientInfo[i].AddMac[5], ClientInfo[i].SSID);
      }
    }
  }
  fprintf(filename, "}\n");
  printf("Done!\n\n");
}

void LogWriteHisto(void)
{
#define HISTO_SIGNAL_SIZE 32
#define HISTO_SIGNAL_CHAN 14

  UINT8 i, Max = 0;
  float divid = 0;
  int j;
  char histo[HISTO_SIGNAL_SIZE][HISTO_SIGNAL_CHAN];

  if (NumberOfDetectedClient != 0) {

    printf("\n Spectral repartition :\n-----------------------\n\n");

    for (i = 0; i < HISTO_SIGNAL_CHAN; i++) {
      debug(3, "%d,", Stats.MaxSignal[i]);
      if (Stats.MaxSignal[i] > Max)
        Max = Stats.MaxSignal[i];
    }

    divid = (float) (Max + 1) / (float) HISTO_SIGNAL_SIZE;
    debug(3, "divid=%f\n", divid);

    for (i = 0; i < HISTO_SIGNAL_CHAN; i++) {
      for (j = 0; j < HISTO_SIGNAL_SIZE; j++)
        histo[j][i] = '-';      // Clear histo
    }

    for (i = 0; i < HISTO_SIGNAL_CHAN; i++) {
      for (j = 0; j < (Stats.MaxSignal[i] / divid); j++) {
        histo[j][i] = '*';      // Fill histo
      }
    }

    printf("    01 02 03 04 05 06 07 08 09 10 11 12 13     14\n");
    for (j = HISTO_SIGNAL_SIZE; j != 0; j--) {
      printf("%3d ", (UINT8) (j * divid));
      for (i = 0; i < HISTO_SIGNAL_CHAN; i++) {
        if (i == (HISTO_SIGNAL_CHAN - 1))
          printf("    ");       // separation between channel 13 and 14
        printf("%c%c ", histo[j - 1][i], histo[j - 1][i]);
      }
      printf("\n");
    }
    printf("    01 02 03 04 05 06 07 08 09 10 11 12 13     14\n\n");
  }
}

/*
Function that display the Upper Panel
*/
void WritePanel(UINT8 GoodPacket)
{
  UINT8 i;
  char Line[256];
  char Histo[HISTOSIZE + 2];
  char MAC[20];
  char TYPE[4];
  UINT8 SNMax = 0;
  static UINT8 MaxFromAll = 1;
  UINT16 HistoSize = 0, HostDisplayed;
  UINT16 MinAff, MaxAff, Posit = 1, SizeOfWin;

  SizeOfWin = (ROW_WND_PANEL - 2);
  if (config.FirstNIC == 0) {
    if (NumberOfDetectedClient > SizeOfWin)
      MinAff = NumberOfDetectedClient - SizeOfWin;
    else
      MinAff = 0;
    MaxAff = NumberOfDetectedClient;
  } else {
    if (config.FirstNIC < (NumberOfDetectedClient - SizeOfWin)) {
      MinAff = config.FirstNIC;
      if (config.FirstNIC + SizeOfWin < NumberOfDetectedClient)
        MaxAff = config.FirstNIC + SizeOfWin;
      else
        MaxAff = NumberOfDetectedClient - 1;
    } else {
      config.FirstNIC = 0;
      MinAff = NumberOfDetectedClient - SizeOfWin;
    }
  }

#ifdef WITH_THREAD
  pthread_mutex_lock(&screen_mutex);
#endif
  //for (i = MinAff; i < MaxAff; i++) {
  HostDisplayed = 0;
  i = MinAff;
  while ((HostDisplayed < SizeOfWin) || (i < NumberOfDetectedClient)) {
    // If we don't need to display this AP/STA, we skip it
    if (IS_BIT_SET(config.DoNotDisplay, 4)) {
      while ((!ClientInfo[i].IsAP)
             && (i < NumberOfDetectedClient)) {
        i++;
      }
    }
    if (i >= NumberOfDetectedClient)
      break;
    snprintf(MAC, 20, "%02X:%02X:%02X:%02X:%02X:%02X",
             ClientInfo[i].AddMac[0], ClientInfo[i].AddMac[1],
             ClientInfo[i].AddMac[2], ClientInfo[i].AddMac[3],
             ClientInfo[i].AddMac[4], ClientInfo[i].AddMac[5]);
    strncpy(Histo,
            "|____________________________________________",
            HISTOSIZE + 1);

    if ((ClientInfo[i].SNMax > MaxFromAll)
        || (Res.Signal > MaxFromAll)) {
      if (Res.Signal > MaxFromAll)
        MaxFromAll = Res.Signal;
      else
        MaxFromAll = ClientInfo[i].SNMax;
    }

    if (GoodPacket) {
      HistoSize =
          (UINT16) ((ClientInfo[i].SNMed * HISTOSIZE) / MaxFromAll);
      if (!strncmp(MAC, Res.SrcMac, 20)) {
        strncpy(Histo,
                "|=======================================================",
                HistoSize);
        mvwprintw(Panel_WND, Posit, 1, ">");
      } else {
        strncpy(Histo,
                "|.......................................................",
                HistoSize);
        mvwprintw(Panel_WND, Posit, 1, " ");
      }
    }

    /* if SN/2 > 64 then SNMax = 64 else SNMax = SN/2 */
    SNMax = (ClientInfo[i].SNMax * HISTOSIZE) / MaxFromAll;
    if (SNMax <= HISTOSIZE) {
      Histo[SNMax - 1] = '|';
      //Histo[HISTOSIZE] = ' ';
    }
    Histo[HISTOSIZE + 1] = 0;
    snprintf(Line, COL_WND_PANEL - POS_HISTO - 1,
             "%s (%d,%d,%d) %s  ", Histo,
             ((GoodPacket
               && !strncmp(MAC, Res.SrcMac,
                           20)) ? Res.Signal : 0),
             (int) ClientInfo[i].SNMed,
             (int) ClientInfo[i].SNMax, ClientInfo[i].Manuf);

    if (ClientInfo[i].IsP2P)
      snprintf(TYPE, 4, "ADH");
    else if (ClientInfo[i].IsAP)
      snprintf(TYPE, 4, "AP ");
    else
      snprintf(TYPE, 4, "STA");

    // We Write now
    mvwprintw(Panel_WND, Posit, 2, "%s", TYPE);
    mvwprintw(Panel_WND, Posit, POS_MAC, "%s", MAC);
    //mvwprintw (Panel_WND, Posit, POS_MAC, "%d,%d", ClientInfo[i].IsP2P, ClientInfo[i].IsAP);
    mvwprintw(Panel_WND, Posit, POS_SSID,
              "\"%s\"                          ", ClientInfo[i].SSID);
    mvwprintw(Panel_WND, Posit, POS_HISTO, " %s", Line);
    Posit++;
    HostDisplayed++;
    i++;
  }

  wrefresh(Panel_WND);
#ifdef WITH_THREAD
  pthread_mutex_unlock(&screen_mutex);
#endif
  debug(3, "WritePanel Line #%d\n", __LINE__);
}

void DoSummary(void)
{
  UINT8 i;
  UINT8 ChanTab[14] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };

  Stats.AP = 0;
  Stats.STA = 0;
  Stats.Channel = 0;

  for (i = 0; i < NumberOfDetectedClient; i++) {
    ChanTab[ClientInfo[i].Channel] = 1;

    if (ClientInfo[i].IsAP)
      Stats.AP++;
    else
      Stats.STA++;
  }

  for (i = 0; i < 14; i++) {
    if (ChanTab[i] != 0)
      Stats.Channel++;
  }
}

/* ******** */
/* IDS ZONE */
/* ******** */

void
CalculCoef(UINT32 X[HISTORY_SIZE],
           UINT32 Y[HISTORY_SIZE], float *a, float *b)
{
  float aa[HISTORY_SIZE], bb[HISTORY_SIZE];
  UINT8 NbData, i;

  // in case of ...
#if (HISTORY_SIZE < 2)
#error "STOP ?! HISTORY_SIZE MUST be greater than 1. Change it on include.h"
#endif

  // Find number of data to analyse
  NbData = 0;
  for (i = 0; i < HISTORY_SIZE; i++) {
    if ((X[i] != 0) && (Y[i] != 0))
      NbData++;
  }

  // Calculate all aa and all bb
  for (i = 0; i < (NbData - 1); i++) {
    aa[i] = (Y[i] - Y[i + 1]) / (X[i] - X[i + 1]);
    bb[i] = Y[i] / (aa[i] * X[i]);
  }

  *a = *b = 0;
  for (i = 0; i < NbData; i++) {
    *a = *a + aa[i];
    *b = *b + bb[i];
  }
  *a = *a / NbData;
  *b = *b / NbData;
}


UINT8 IDS_BcnInt(void)
{
  register UINT16 i;
  UINT8 ret = 0, j;
  char MAC[20];
  char Message[1024];

  for (i = 0; i < NumberOfDetectedClient; i++) {
    for (j = 0; j < (HISTORY_SIZE - 1); j++) {
      if (((ClientInfo[i].bcn_int[j] != 0)
           && (ClientInfo[i].bcn_int[j + 1] != 0))
          && (ClientInfo[i].bcn_int[j] != ClientInfo[i].bcn_int[j + 1])) {
        snprintf(MAC, 20,
                 "%02X:%02X:%02X:%02X:%02X:%02X",
                 ClientInfo[i].AddMac[0],
                 ClientInfo[i].AddMac[1],
                 ClientInfo[i].AddMac[2],
                 ClientInfo[i].AddMac[3],
                 ClientInfo[i].AddMac[4], ClientInfo[i].AddMac[5]);
        snprintf(Message, 1024,
                 "IDS WARNING - beacon interval is changing for %s from %dms to %dms\n",
                 MAC, ClientInfo[i].bcn_int[j + 1],
                 ClientInfo[i].bcn_int[j]);
        Send_IDS_Warning(Message);
        ret = 0x01;             
        break;
      }
    }
  }
  return ret;
}

UINT8 IDS_TimeStamp(void)
{
  register UINT16 i;
  UINT8 ret = 0, j;
  char MAC[20];
  char Message[1024];

  // Analysis of Time Stamps
  for (i = 0; i < NumberOfDetectedClient; i++) {
    for (j = 0; j < (HISTORY_SIZE - 1); j++) {
      if (((ClientInfo[i].TimeStamp[j] != 0)
           && (ClientInfo[i].TimeStamp[j + 1] != 0))
          && (ClientInfo[i].TimeStamp[j] < ClientInfo[i].TimeStamp[j + 1])) {
        snprintf(MAC, 20,
                 "%02X:%02X:%02X:%02X:%02X:%02X",
                 ClientInfo[i].AddMac[0],
                 ClientInfo[i].AddMac[1],
                 ClientInfo[i].AddMac[2],
                 ClientInfo[i].AddMac[3],
                 ClientInfo[i].AddMac[4], ClientInfo[i].AddMac[5]);
        snprintf(Message, 1024,
                 "IDS WARNING - Time Stamp is not correct for %s\n", MAC);
        Send_IDS_Warning(Message);
        snprintf(Message, 1024,
                 " Difference between two catched packets is : %lluµs %llums\n",
                 ClientInfo[i].TimeStamp[j + 1] -
                 ClientInfo[i].TimeStamp[j],
                 (ClientInfo[i].TimeStamp[j + 1] -
                  ClientInfo[i].TimeStamp[j]) * 100);
        Send_IDS_Warning(Message);
/*        snprintf(Message, 1024, "Timestamps = (0x%016llX,0x%016llX)\n",
                 ClientInfo[i].TimeStamp[j],
                 ClientInfo[i].TimeStamp[j + 1]);
        Send_IDS_Warning(Message); */
        ret = 0x02;             
        break;
      }
    }
  }
  return ret;
}

UINT8 IDS_Var_SeqNum(void)
{
  register UINT16 i;
  UINT8 ret = 0, j;
  char MAC[20];
  char Message[1024];

  // Analysis of variation of Seqnum
  for (i = 0; i < NumberOfDetectedClient; i++) {
    for (j = 0; j < (HISTORY_SIZE - 1); j++) {
      if (((ClientInfo[i].SeqNum[j] != 0)
           && (ClientInfo[i].SeqNum[j + 1] != 0))
          && (ClientInfo[i].SeqNum[j] < ClientInfo[i].SeqNum[j + 1])) {
        snprintf(MAC, 20,
                 "%02X:%02X:%02X:%02X:%02X:%02X",
                 ClientInfo[i].AddMac[0],
                 ClientInfo[i].AddMac[1],
                 ClientInfo[i].AddMac[2],
                 ClientInfo[i].AddMac[3],
                 ClientInfo[i].AddMac[4], ClientInfo[i].AddMac[5]);
        snprintf(Message, 1024,
                 "IDS WARNING - Sequence Number is not correct for %s\n",
                 MAC);
        Send_IDS_Warning(Message);
        debug(1, "SeqNum = (0x%04X,0x%04X)\n", ClientInfo[i].SeqNum[j],
              ClientInfo[i].SeqNum[j + 1]);
        ret = 0x04;             
        break;
      }
    }
  }
  return ret;
}

UINT8 IDS_Detect_FakeAP(void)
{
  // TODO
  //  must use CalcCoef ...
  return 0;
}

UINT8 IDS(void)
{
  UINT8 ret = 0;

  ret += IDS_BcnInt();
  ret += IDS_TimeStamp();
  ret += IDS_Var_SeqNum();
  ret += IDS_Detect_FakeAP();

  return (ret);
}

---