开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 其他 > 查看源码
airodump.c
资源名称：1121aircrack-2.41.zip　[点击查看]
上传用户：fubang
上传日期：2009-06-18
资源大小：2071k
文件大小：50k
源码类别：

其他

开发平台：

Unix_Linux

airodump.c：源码内容
  1. /*
  2.  *  pcap-compatible 802.11 packet sniffer
  3.  *
  4.  *  Copyright (C) 2004,2005  Christophe Devine
  5.  *
  6.  *  This program is free software; you can redistribute it and/or modify
  7.  *  it under the terms of the GNU General Public License as published by
  8.  *  the Free Software Foundation; either version 2 of the License, or
  9.  *  (at your option) any later version.
  10.  *
  11.  *  This program is distributed in the hope that it will be useful,
  12.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  *  GNU General Public License for more details.
  15.  *
  16.  *  You should have received a copy of the GNU General Public License
  17.  *  along with this program; if not, write to the Free Software
  18.  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19.  */
  21. #include <sys/socket.h>
  22. #include <sys/ioctl.h>
  23. #include <sys/types.h>
  24. #include <sys/wait.h>
  25. #include <sys/time.h>
  27. #include <netpacket/packet.h>
  28. #include <linux/if_ether.h>
  29. #include <linux/wireless.h>
  30. #include <arpa/inet.h>
  31. #include <unistd.h>
  32. #include <signal.h>
  33. #include <string.h>
  34. #include <stdlib.h>
  35. #include <stdio.h>
  36. #include <errno.h>
  37. #include <time.h>
  39. #include "pcap.h"
  40. #include "uniqueiv.c"
  42. /* some constants */
  44. #define FORMAT_CAP 1
  45. #define FORMAT_IVS 2
  47. #define ARPHRD_IEEE80211        801
  48. #define ARPHRD_IEEE80211_PRISM  802
  49. #define ARPHRD_IEEE80211_FULL   803
  51. #define REFRESH_RATE 100000  /* delay in us between updates */
  53. #define BROADCAST_ADDR "xFFxFFxFFxFFxFFxFF"
  55. #define NB_PWR  5       /* size of signal power ring buffer */
  56. #define NB_PRB 10       /* size of probed ESSID ring buffer */
  58. char *f_ext[4] = { "txt", "gps", "cap", "ivs" };
  59. int bg_chans[] = { 1, 7, 13, 2, 8, 3, 14, 9, 4, 10, 5, 11, 6, 12, 0 };
  61. /* linked list of detected access points */
  63. struct AP_info
  64. {
  65.     struct AP_info *prev;     /* prev. AP in list         */
  66.     struct AP_info *next;     /* next  AP in list         */
  68.     time_t tinit, tlast;      /* first and last time seen */
  70.     int channel;              /* AP radio channel         */
  71.     int max_speed;            /* AP maximum speed in Mb/s */
  72.     int avg_power;            /* averaged signal power    */
  73.     int power_index;          /* index in power ring buf. */
  74.     int power_lvl[NB_PWR];    /* signal power ring buffer */
  75.     int preamble;             /* 0 = long, 1 = short      */
  76.     int encryption;           /* 0 = none, > 1 = WEP/WPA  */
  78.     unsigned long nb_bcn;     /* total number of beacons  */
  79.     unsigned long nb_pkt;     /* total number of packets  */
  80.     unsigned long nb_data;    /* number of  data packets  */
  82.     unsigned char bssid[6];   /* the access point's MAC   */
  83.     unsigned char essid[36];  /* ascii network identifier */
  85.     unsigned char lanip[4];   /* last detected ip address */
  86.                               /* if non-encrypted network */
  88.     unsigned char **uiv_root; /* unique iv root structure */
  89.                               /* if wep-encrypted network */
  90. };
  92. /* linked list of detected clients */
  94. struct ST_info
  95. {
  96.     struct ST_info *prev;    /* the prev client in list   */
  97.     struct ST_info *next;    /* the next client in list   */
  98.     struct AP_info *base;    /* AP this client belongs to */
  99.     time_t tinit, tlast;     /* first and last time seen  */
  100.     unsigned long nb_pkt;    /* total number of packets   */
  101.     unsigned char stmac[6];  /* the client's MAC address  */
  102.     int probe_index;         /* probed ESSIDs ring index  */
  103.     char probes[NB_PRB][36]; /* probed ESSIDs ring buffer */
  104.     int power;               /* last signal power         */
  105. };
  107. /* bunch of global stuff */
  109. struct globals
  110. {
  111.     struct AP_info *ap_1st, *ap_end;
  112.     struct ST_info *st_1st, *st_end;
  114.     unsigned char prev_bssid[6];
  116.     int f_index;            /* outfiles index       */
  117.     FILE *f_txt;            /* output csv file      */
  118.     FILE *f_gps;            /* output gps file      */
  119.     FILE *f_cap;            /* output cap file      */
  120.     FILE *f_ivs;            /* output ivs file      */
  122.     int battery;            /* remaining battery %  */
  123.     int channel;            /* current channel #    */
  124.     int ch_pipe[2];         /* current channel pipe */
  125.     int gc_pipe[2];         /* gps coordinates pipe */
  126.     float gps_loc[5];       /* gps coordinates      */
  127.     int save_gps;           /* keep gps file flag   */
  129.     int is_wlanng;          /* set if wlan-ng       */
  130.     int is_orinoco;         /* set if orinoco       */
  131.     int do_exit;            /* interrupt flag       */
  132.     struct winsize ws;      /* console window size  */
  133. }
  134. G;
  136. /* setup the output files */
  138. int dump_initialize( char *prefix, int ivs_only )
  139. {
  140.     int i;
  141.     FILE *f;
  142.     char ofn[1024];
  144.     /* check not to overflow the ofn buffer */
  146.     if( strlen( prefix ) >= sizeof( ofn ) - 10 )
  147.         prefix[sizeof( ofn ) - 10] = '';
  149.     /* make sure not to overwrite any existing file */
  151.     memset( ofn, 0, sizeof( ofn ) );
  153.     G.f_index = 1;
  155.     do
  156.     {
  157.         for( i = 0; i < 4; i++ )
  158.         {
  159.             snprintf( ofn,  sizeof( ofn ) - 1, "%s-%02d.%s",
  160.                       prefix, G.f_index, f_ext[i] );
  162.             if( ( f = fopen( ofn, "rb+" ) ) != NULL )
  163.             {
  164.                 fclose( f );
  165.                 G.f_index++;
  166.                 break;
  167.             }
  168.         }
  169.     }
  170.     while( i < 4 );
  172.     /* create the output CVS & GPS files */
  174.     snprintf( ofn,  sizeof( ofn ) - 1, "%s-%02d.txt",
  175.               prefix, G.f_index );
  177.     if( ( G.f_txt = fopen( ofn, "wb+" ) ) == NULL )
  178.     {
  179.         perror( "fopen failed" );
  180.         fprintf( stderr, "Could not create "%s".n", ofn );
  181.         return( 1 );
  182.     }
  184.     snprintf( ofn,  sizeof( ofn ) - 1, "%s-%02d.gps",
  185.               prefix, G.f_index );
  187.     if( ( G.f_gps = fopen( ofn, "wb+" ) ) == NULL )
  188.     {
  189.         perror( "fopen failed" );
  190.         fprintf( stderr, "Could not create "%s".n", ofn );
  191.         return( 1 );
  192.     }
  194.     /* create the output packet capture file */
  196.     if( ivs_only == 0 )
  197.     {
  198.         struct pcap_file_header pfh;
  200.         snprintf( ofn,  sizeof( ofn ) - 1, "%s-%02d.cap",
  201.                   prefix, G.f_index );
  203.         if( ( G.f_cap = fopen( ofn, "wb+" ) ) == NULL )
  204.         {
  205.             perror( "fopen failed" );
  206.             fprintf( stderr, "Could not create "%s".n", ofn );
  207.             return( 1 );
  208.         }
  210.         pfh.magic           = TCPDUMP_MAGIC;
  211.         pfh.version_major   = PCAP_VERSION_MAJOR;
  212.         pfh.version_minor   = PCAP_VERSION_MINOR;
  213.         pfh.thiszone        = 0;
  214.         pfh.sigfigs         = 0;
  215.         pfh.snaplen         = 65535;
  216.         pfh.linktype        = LINKTYPE_IEEE802_11;
  218.         if( fwrite( &pfh, 1, sizeof( pfh ), G.f_cap ) !=
  219.                     (size_t) sizeof( pfh ) )
  220.         {
  221.             perror( "fwrite(pcap file header) failed" );
  222.             return( 1 );
  223.         }
  224.     }
  225.     else
  226.     {
  227.         snprintf( ofn,  sizeof( ofn ) - 1, "%s-%02d.ivs",
  228.                   prefix, G.f_index );
  230.         if( ( G.f_ivs = fopen( ofn, "wb+" ) ) == NULL )
  231.         {
  232.             perror( "fopen failed" );
  233.             fprintf( stderr, "Could not create "%s".n", ofn );
  234.             return( 1 );
  235.         }
  237.         if( fwrite( IVSONLY_MAGIC, 1, 4, G.f_ivs ) != (size_t) 4 )
  238.         {
  239.             perror( "fwrite(IVs file header) failed" );
  240.             return( 1 );
  241.         }
  242.     }
  244.     return( 0 );
  245. }
  247. int dump_add_packet( unsigned char *h80211, int caplen, int power )
  248. {
  249.     int i, n, z;
  250.     unsigned char *p, c;
  251.     unsigned char bssid[6];
  252.     unsigned char stmac[6];
  253.     struct pcap_pkthdr pkh;
  254.     struct timeval tv;
  256.     struct AP_info *ap_cur = NULL;
  257.     struct ST_info *st_cur = NULL;
  258.     struct AP_info *ap_prv = NULL;
  259.     struct ST_info *st_prv = NULL;
  261.     /* skip packets smaller than a 802.11 header */
  263.     if( caplen < 24 )
  264.         goto write_packet;
  266.     /* skip (uninteresting) control frames */
  268.     if( ( h80211[0] & 0x0C ) == 0x04 )
  269.         goto write_packet;
  271.     /* locate the access point's MAC address */
  273.     switch( h80211[1] & 3 )
  274.     {
  275.         case  0: memcpy( bssid, h80211 + 16, 6 ); break;
  276.         case  1: memcpy( bssid, h80211 +  4, 6 ); break;
  277.         case  2: memcpy( bssid, h80211 + 10, 6 ); break;
  278.         default: memcpy( bssid, h80211 +  4, 6 ); break;
  279.     }
  281.     /* update our chained list of access points */
  283.     ap_cur = G.ap_1st;
  284.     ap_prv = NULL;
  286.     while( ap_cur != NULL )
  287.     {
  288.         if( ! memcmp( ap_cur->bssid, bssid, 6 ) )
  289.             break;
  291.         ap_prv = ap_cur;
  292.         ap_cur = ap_cur->next;
  293.     }
  295.     /* if it's a new access point, add it */
  297.     if( ap_cur == NULL )
  298.     {
  299.         if( ! ( ap_cur = (struct AP_info *) malloc(
  300.                          sizeof( struct AP_info ) ) ) )
  301.         {
  302.             perror( "malloc failed" );
  303.             return( 1 );
  304.         }
  306.         memset( ap_cur, 0, sizeof( struct AP_info ) );
  308.         if( G.ap_1st == NULL )
  309.             G.ap_1st = ap_cur;
  310.         else
  311.             ap_prv->next  = ap_cur;
  313.         memcpy( ap_cur->bssid, bssid, 6 );
  315.         ap_cur->prev = ap_prv;
  317.         ap_cur->tinit = time( NULL );
  318.         ap_cur->tlast = time( NULL );
  320.         ap_cur->avg_power   = -1;
  321.         ap_cur->power_index = -1;
  323.         for( i = 0; i < NB_PWR; i++ )
  324.             ap_cur->power_lvl[i] = -1;
  326.         ap_cur->channel    = -1;
  327.         ap_cur->max_speed  = -1;
  328.         ap_cur->encryption = -1;
  330.         ap_cur->uiv_root = uniqueiv_init();
  332.         G.ap_end = ap_cur;
  333.     }
  335.     /* update the last time seen */
  337.     ap_cur->tlast = time( NULL );
  339.     /* only update power if packets comes from
  340.      * the AP: either type == mgmt and SA != BSSID,
  341.      * or FromDS == 1 and ToDS == 0 */
  343.     if( ( ( h80211[1] & 3 ) == 0 &&
  344.             memcmp( h80211 + 10, bssid, 6 ) == 0 ) ||
  345.         ( ( h80211[1] & 3 ) == 2 ) )
  346.     {
  347.         ap_cur->power_index = ( ap_cur->power_index + 1 ) % NB_PWR;
  348.         ap_cur->power_lvl[ap_cur->power_index] = power;
  350.         ap_cur->avg_power = 0;
  352.         for( i = 0, n = 0; i < NB_PWR; i++ )
  353.         {
  354.             if( ap_cur->power_lvl[i] != -1 )
  355.             {
  356.                 ap_cur->avg_power += ap_cur->power_lvl[i];
  357.                 n++;
  358.             }
  359.         }
  361.         if( n > 0 )
  362.             ap_cur->avg_power /= n;
  363.         else
  364.             ap_cur->avg_power = -1;
  365.     }
  367.     if( h80211[0] == 0x80 )
  368.         ap_cur->nb_bcn++;
  370.     ap_cur->nb_pkt++;
  372.     /* locate the station MAC in the 802.11 header */
  374.     switch( h80211[1] & 3 )
  375.     {
  376.         case  0:
  378.             /* if management, check that SA != BSSID */
  380.             if( memcmp( h80211 + 10, bssid, 6 ) == 0 )
  381.                 goto skip_station;
  383.             memcpy( stmac, h80211 + 10, 6 );
  384.             break;
  386.         case  1:
  388.             /* ToDS packet, must come from a client */
  390.             memcpy( stmac, h80211 + 10, 6 );
  391.             break;
  393.         case  2:
  395.             /* FromDS packet, reject broadcast MACs */
  397.             if( h80211[4] != 0 ) goto skip_station;
  398.             memcpy( stmac, h80211 +  4, 6 ); break;
  400.         default: goto skip_station;
  401.     }
  403.     /* update our chained list of wireless stations */
  405.     st_cur = G.st_1st;
  406.     st_prv = NULL;
  408.     while( st_cur != NULL )
  409.     {
  410.         if( ! memcmp( st_cur->stmac, stmac, 6 ) )
  411.             break;
  413.         st_prv = st_cur;
  414.         st_cur = st_cur->next;
  415.     }
  417.     /* if it's a new client, add it */
  419.     if( st_cur == NULL )
  420.     {
  421.         if( ! ( st_cur = (struct ST_info *) malloc(
  422.                          sizeof( struct ST_info ) ) ) )
  423.         {
  424.             perror( "malloc failed" );
  425.             return( 1 );
  426.         }
  428.         memset( st_cur, 0, sizeof( struct ST_info ) );
  430.         if( G.st_1st == NULL )
  431.             G.st_1st = st_cur;
  432.         else
  433.             st_prv->next  = st_cur;
  435.         memcpy( st_cur->stmac, stmac, 6 );
  437.         st_cur->prev = st_prv;
  439.         st_cur->tinit = time( NULL );
  440.         st_cur->tlast = time( NULL );
  442.         st_cur->power = -1;
  444.         st_cur->probe_index = -1;
  446.         for( i = 0; i < NB_PRB; i++ )
  447.             memset( st_cur->probes[i], 0, sizeof(
  448.                     st_cur->probes[i] ) );
  450.         G.st_end = st_cur;
  451.     }
  453.     if( st_cur->base == NULL ||
  454.         memcmp( ap_cur->bssid, BROADCAST_ADDR, 6 ) != 0 )
  455.         st_cur->base = ap_cur;
  457.     /* update the last time seen */
  459.     st_cur->tlast = time( NULL );
  461.     /* only update power if packets comes from the 
  462.      * client: either type == Mgmt and SA != BSSID,
  463.      * or FromDS == 0 and ToDS == 1 */
  465.     if( ( ( h80211[1] & 3 ) == 0 &&
  466.             memcmp( h80211 + 10, bssid, 6 ) != 0 ) ||
  467.         ( ( h80211[1] & 3 ) == 1 ) )
  468.     {
  469.         st_cur->power = power;
  470.     }
  472.     st_cur->nb_pkt++;
  474. skip_station:
  476.     /* packet parsing: Probe Request */
  478.     if( h80211[0] == 0x40 && st_cur != NULL )
  479.     {
  480.         p = h80211 + 24;
  482.         while( p < h80211 + caplen )
  483.         {
  484.             if( p + 2 + p[1] > h80211 + caplen )
  485.                 break;
  487.             if( p[0] == 0x00 && p[1] > 0 && p[2] != '' &&
  488.                 ( p[1] > 1 || p[2] != ' ' ) )
  489.             {
  490.                 n = ( p[1] > 32 ) ? 32 : p[1];
  492.                 for( i = 0; i < n; i++ )
  493.                     if( p[2 + i] > 0 && p[2 + i] < ' ' )
  494.                         goto skip_probe;
  496.                 /* got a valid ASCII probed ESSID, check if it's
  497.                    already in the ring buffer */
  499.                 for( i = 0; i < NB_PRB; i++ )
  500.                     if( memcmp( st_cur->probes[i], p + 2, n ) == 0 )
  501.                         goto skip_probe;
  503.                 st_cur->probe_index = ( st_cur->probe_index + 1 ) % NB_PRB;
  504.                 memset( st_cur->probes[st_cur->probe_index], 0, 36 );
  505.                 memcpy( st_cur->probes[st_cur->probe_index], p + 2, n );
  507.                 for( i = 0; i < n; i++ )
  508.                 {
  509.                     c = p[2 + i];
  510.                     if( c == 0 || ( c > 126 && c < 160 ) ) c = '.';
  511.                     st_cur->probes[st_cur->probe_index][i] = c;
  512.                 }
  513.             }
  515.             p += 2 + p[1];
  516.         }
  517.     }
  519. skip_probe:
  521.     /* packet parsing: Beacon or Probe Response */
  523.     if( h80211[0] == 0x80 || h80211[0] == 0x50 )
  524.     {
  525.         if( ap_cur->encryption < 0 )
  526.             ap_cur->encryption = ( h80211[34] & 0x10 ) >> 4;
  528.         ap_cur->preamble = ( h80211[34] & 0x20 ) >> 5;
  530.         p = h80211 + 36;
  532.         while( p < h80211 + caplen )
  533.         {
  534.             if( p + 2 + p[1] > h80211 + caplen )
  535.                 break;
  537.             if( p[0] == 0x00 && p[1] > 0 && p[2] != '' &&
  538.                 ( p[1] > 1 || p[2] != ' ' ) )
  539.             {
  540.                 /* found a non-cloaked ESSID */
  542.                 n = ( p[1] > 32 ) ? 32 : p[1];
  544.                 memset( ap_cur->essid, 0, 36 );
  545.                 memcpy( ap_cur->essid, p + 2, n );
  547.                 for( i = 0; i < n; i++ )
  548.                     if( ( ap_cur->essid[i] >   0 && ap_cur->essid[i] <  32 ) ||
  549.                         ( ap_cur->essid[i] > 126 && ap_cur->essid[i] < 160 ) )
  550.                         ap_cur->essid[i] = '.';
  551.             }
  553.             /* get the maximum speed in Mb and the AP's channel */
  555.             if( p[0] == 0x01 || p[0] == 0x32 )
  556.                 ap_cur->max_speed = ( p[1 + p[1]] & 0x7F ) / 2;
  558.             if( p[0] == 0x03 )
  559.                 ap_cur->channel = p[2];
  561.             p += 2 + p[1];
  562.         }
  563.     }
  565.     /* packet parsing: Association Request */
  567.     if( h80211[0] == 0x00 )
  568.     {
  569.         p = h80211 + 28;
  571.         while( p < h80211 + caplen )
  572.         {
  573.             if( p + 2 + p[1] > h80211 + caplen )
  574.                 break;
  576.             if( p[0] == 0x00 && p[1] > 0 && p[2] != '' &&
  577.                 ( p[1] > 1 || p[2] != ' ' ) )
  578.             {
  579.                 /* found a non-cloaked ESSID */
  581.                 n = ( p[1] > 32 ) ? 32 : p[1];
  583.                 memset( ap_cur->essid, 0, 33 );
  584.                 memcpy( ap_cur->essid, p + 2, n );
  586.                 for( i = 0; i < n; i++ )
  587.                     if( ap_cur->essid[i] < 32 ||
  588.                       ( ap_cur->essid[i] > 126 && ap_cur->essid[i] < 160 ) )
  589.                         ap_cur->essid[i] = '.';
  590.             }
  592.             p += 2 + p[1];
  593.         }
  594.     }
  596.     /* packet parsing: some data */
  598.     if( ( h80211[0] & 0x0C ) == 0x08 )
  599.     {
  600.         /* update the channel if we didn't get any beacon */
  602.         if( ap_cur->channel == -1 )
  603.             ap_cur->channel = G.channel;
  605.         /* check the SNAP header to see if data is encrypted */
  607.         z = ( ( h80211[1] & 3 ) != 3 ) ? 24 : 30;
  609.         if( z + 26 > caplen )
  610.             goto write_packet;
  612.         if( h80211[z] == h80211[z + 1] && h80211[z + 2] == 0x03 )
  613.         {
  614.             if( ap_cur->encryption < 0 )
  615.                 ap_cur->encryption = 0;
  617.             /* if ethertype == IPv4, find the LAN address */
  619.             if( h80211[z + 6] == 0x08 && h80211[z + 7] == 0x00 &&
  620.                 ( h80211[1] & 3 ) == 0x01 )
  621.                     memcpy( ap_cur->lanip, &h80211[z + 20], 4 );
  623.             if( h80211[z + 6] == 0x08 && h80211[z + 7] == 0x06 )
  624.                 memcpy( ap_cur->lanip, &h80211[z + 22], 4 );
  625.         }
  626.         else
  627.             ap_cur->encryption = 2 + ( ( h80211[z + 3] & 0x20 ) >> 5 );
  629.         if( z + 10 > caplen )
  630.             goto write_packet;
  632.         if( ap_cur->encryption == 2 )
  633.         {
  634.             /* WEP: check if we've already seen this IV */
  636.             if( ! uniqueiv_check( ap_cur->uiv_root, &h80211[z] ) )
  637.             {
  638.                 /* first time seen IVs */
  640.                 if( G.f_ivs != NULL )
  641.                 {
  642.                     unsigned char iv_info[64];
  644.                     if( memcmp( G.prev_bssid, ap_cur->bssid, 6 ) == 0 )
  645.                     {
  646.                         iv_info[0] = 0xFF;
  647.                         memcpy( iv_info + 1, &h80211[z    ], 3 );
  648.                         memcpy( iv_info + 4, &h80211[z + 4], 2 );
  649.                         n =  6;
  650.                     }
  651.                     else
  652.                     {
  653.                         memcpy( G.prev_bssid, ap_cur->bssid,  6 );
  654.                         memcpy( iv_info     , ap_cur->bssid,  6 );
  655.                         memcpy( iv_info + 6 , &h80211[z    ], 3 );
  656.                         memcpy( iv_info + 9 , &h80211[z + 4], 2 );
  657.                         n = 11;
  658.                     }
  660.                     if( fwrite( iv_info, 1, n, G.f_ivs ) != (size_t) n )
  661.                     {
  662.                         perror( "fwrite(IV info) failed" );
  663.                         return( 1 );
  664.                     }
  665.                 }
  667.                 uniqueiv_mark( ap_cur->uiv_root, &h80211[z] );
  669.                 ap_cur->nb_data++;
  670.             }
  671.         }
  672.         else
  673.             ap_cur->nb_data++;
  674.     }
  676. write_packet:
  678.     if( G.f_cap != NULL )
  679.     {
  680.         pkh.caplen = pkh.len = caplen;
  682.         gettimeofday( &tv, NULL );
  684.         pkh.tv_sec  =   tv.tv_sec;
  685.         pkh.tv_usec = ( tv.tv_usec & ~0x1ff ) + power + 64;
  687.         n = sizeof( pkh );
  689.         if( fwrite( &pkh, 1, n, G.f_cap ) != (size_t) n )
  690.         {
  691.             perror( "fwrite(packet header) failed" );
  692.             return( 1 );
  693.         }
  695.         fflush( stdout );
  697.         n = pkh.caplen;
  699.         if( fwrite( h80211, 1, n, G.f_cap ) != (size_t) n )
  700.         {
  701.             perror( "fwrite(packet data) failed" );
  702.             return( 1 );
  703.         }
  705.         fflush( stdout );
  706.     }
  708.     return( 0 );
  709. }
  711. void dump_sort_power( void )
  712. {
  713.     time_t tt = time( NULL );
  715.     /* thanks to Arnaud Cornet :-) */
  717.     struct AP_info *new_ap_1st = NULL;
  718.     struct AP_info *new_ap_end = NULL;
  720.     struct ST_info *new_st_1st = NULL;
  721.     struct ST_info *new_st_end = NULL;
  723.     struct ST_info *st_cur, *st_min;
  724.     struct AP_info *ap_cur, *ap_min;
  726.     /* sort the aps by power first */
  728.     while( G.ap_1st )
  729.     {
  730.         ap_min = NULL;
  731.         ap_cur = G.ap_1st;
  733.         while( ap_cur != NULL )
  734.         {
  735.             if( tt - ap_cur->tlast > 20 )
  736.                 ap_min = ap_cur;
  738.             ap_cur = ap_cur->next;
  739.         }
  741.         if( ap_min == NULL )
  742.         {
  743.             ap_min = ap_cur = G.ap_1st;
  745.             while( ap_cur != NULL )
  746.             {
  747.                 if( ap_cur->avg_power < ap_min->avg_power)
  748.                     ap_min = ap_cur;
  750.                 ap_cur = ap_cur->next;
  751.             }
  752.         }
  754.         if( ap_min == G.ap_1st )
  755.             G.ap_1st = ap_min->next;
  757.         if( ap_min == G.ap_end )
  758.             G.ap_end = ap_min->prev;
  760.         if( ap_min->next )
  761.             ap_min->next->prev = ap_min->prev;
  763.         if( ap_min->prev )
  764.             ap_min->prev->next = ap_min->next;
  766.         if( new_ap_end )
  767.         {
  768.             new_ap_end->next = ap_min;
  769.             ap_min->prev = new_ap_end;
  770.             new_ap_end = ap_min;
  771.             new_ap_end->next = NULL;
  772.         }
  773.         else
  774.         {
  775.             new_ap_1st = new_ap_end = ap_min;
  776.             ap_min->next = ap_min->prev = NULL;
  777.         }
  778.     }
  780.     G.ap_1st = new_ap_1st;
  781.     G.ap_end = new_ap_end;
  783.     /* now sort the stations */
  785.     while( G.st_1st )
  786.     {
  787.         st_min = NULL;
  788.         st_cur = G.st_1st;
  790.         while( st_cur != NULL )
  791.         {
  792.             if( tt - st_cur->tlast > 60 )
  793.                 st_min = st_cur;
  795.             st_cur = st_cur->next;
  796.         }
  798.         if( st_min == NULL )
  799.         {
  800.             st_min = st_cur = G.st_1st;
  802.             while( st_cur != NULL )
  803.             {
  804.                 if( st_cur->power < st_min->power)
  805.                     st_min = st_cur;
  807.                 st_cur = st_cur->next;
  808.             }
  809.         }
  811.         if( st_min == G.st_1st )
  812.             G.st_1st = st_min->next;
  814.         if( st_min == G.st_end )
  815.             G.st_end = st_min->prev;
  817.         if( st_min->next )
  818.             st_min->next->prev = st_min->prev;
  820.         if( st_min->prev )
  821.             st_min->prev->next = st_min->next;
  823.         if( new_st_end )
  824.         {
  825.             new_st_end->next = st_min;
  826.             st_min->prev = new_st_end;
  827.             new_st_end = st_min;
  828.             new_st_end->next = NULL;
  829.         }
  830.         else
  831.         {
  832.             new_st_1st = new_st_end = st_min;
  833.             st_min->next = st_min->prev = NULL;
  834.         }
  835.     }
  837.     G.st_1st = new_st_1st;
  838.     G.st_end = new_st_end;
  839. }
  841. void dump_print( int ws_row, int ws_col )
  842. {
  843.     time_t tt;
  844.     struct tm *lt;
  845.     int nlines, i, n;
  846.     char strbuf[512];
  847.     char ssid_list[512];
  848.     struct AP_info *ap_cur;
  849.     struct ST_info *st_cur;
  851.     nlines = 2;
  853.     if( nlines >= ws_row )
  854.         return;
  856.     tt = time( NULL );
  857.     lt = localtime( &tt );
  859.     /* display the channel, battery, position and current time */
  861.     memset( strbuf, ' ', ws_col - 1 );
  862.     strbuf[ws_col - 1] = '';
  863.     fprintf( stderr, "%sn", strbuf );
  865.     snprintf( strbuf, sizeof( strbuf ) - 1,
  866.               " CH %2d ][ BAT %3d%% ][ GPS %8.3f %8.3f %8.3f %6.2f "
  867.               "][ %04d-%02d-%02d %02d:%02d ", G.channel, G.battery,
  868.               G.gps_loc[0], G.gps_loc[1], G.gps_loc[2], G.gps_loc[3],
  869.               1900 + lt->tm_year, 1 + lt->tm_mon, lt->tm_mday,
  870.               lt->tm_hour, lt->tm_min );
  872.     strbuf[ws_col - 1] = '';
  873.     fprintf( stderr, "%sn", strbuf );
  875.     /* print some informations about each detected AP */
  877.     nlines += 3;
  879.     if( nlines >= ws_row )
  880.         return;
  882.     memset( strbuf, ' ', ws_col - 1 );
  883.     strbuf[ws_col - 1] = '';
  884.     fprintf( stderr, "%sn", strbuf );
  886.     memcpy( strbuf, " BSSID              PWR  Beacons"
  887.                     "   # Data  CH  MB  ENC   ESSID", 62 );
  888.     strbuf[ws_col - 1] = '';
  889.     fprintf( stderr, "%sn", strbuf );
  891.     memset( strbuf, ' ', ws_col - 1 );
  892.     strbuf[ws_col - 1] = '';
  893.     fprintf( stderr, "%sn", strbuf );
  895.     ap_cur = G.ap_end;
  897.     while( ap_cur != NULL )
  898.     {
  899.         /* skip APs with only one packet, or those older than 2 min.
  900.          * always skip if bssid == broadcast */
  902.         if( ap_cur->nb_pkt < 2 || time( NULL ) - ap_cur->tlast > 120 ||
  903.             memcmp( ap_cur->bssid, BROADCAST_ADDR, 6 ) == 0 )
  904.         {
  905.             ap_cur = ap_cur->prev;
  906.             continue;
  907.         }
  909.         nlines++;
  911.         if( nlines >= ws_row )
  912.             return;
  914.         fprintf( stderr, " %02X:%02X:%02X:%02X:%02X:%02X",
  915.                 ap_cur->bssid[0], ap_cur->bssid[1],
  916.                 ap_cur->bssid[2], ap_cur->bssid[3],
  917.                 ap_cur->bssid[4], ap_cur->bssid[5] );
  919.         fprintf( stderr, "  %3d %8ld %8ld",
  920.                  ap_cur->avg_power,
  921.                  ap_cur->nb_bcn,
  922.                  ap_cur->nb_data );
  924.         fprintf( stderr, " %3d %3d%c ",
  925.                  ap_cur->channel, ap_cur->max_speed,
  926.                  ( ap_cur->preamble ) ? '.' : ' ' );
  928.         switch( ap_cur->encryption )
  929.         {
  930.             case  0: fprintf( stderr, "OPN " ); break;
  931.             case  1: fprintf( stderr, "WEP?" ); break;
  932.             case  2: fprintf( stderr, "WEP " ); break;
  933.             case  3: fprintf( stderr, "WPA " ); break;
  934.             default: fprintf( stderr, "    " ); break;
  935.         }
  937.         if( ws_col > 58 )
  938.         {
  939.             memset( strbuf, 0, sizeof( strbuf ) );
  940.             snprintf( strbuf,  sizeof( strbuf ) - 1,
  941.                       "%-256s", ap_cur->essid );
  942.             strbuf[ws_col - 58] = '';
  943.             fprintf( stderr, "  %s", strbuf );
  944.         }
  946.         fprintf( stderr, "n" );
  948.         ap_cur = ap_cur->prev;
  949.     }
  951.     /* print some informations about each detected station */
  953.     nlines += 3;
  955.     if( nlines >= ws_row )
  956.         return;
  958.     memset( strbuf, ' ', ws_col - 1 );
  959.     strbuf[ws_col - 1] = '';
  960.     fprintf( stderr, "%sn", strbuf );
  962.     memcpy( strbuf, " BSSID              STATION "
  963.             "           PWR  Packets  Probes", 59 );
  964.     strbuf[ws_col - 1] = '';
  965.     fprintf( stderr, "%sn", strbuf );
  967.     memset( strbuf, ' ', ws_col - 1 );
  968.     strbuf[ws_col - 1] = '';
  969.     fprintf( stderr, "%sn", strbuf );
  971.     ap_cur = G.ap_end;
  973.     while( ap_cur != NULL )
  974.     {
  975.         if( ap_cur->nb_pkt < 2 ||
  976.             time( NULL ) - ap_cur->tlast > 120 )
  977.         {
  978.             ap_cur = ap_cur->prev;
  979.             continue;
  980.         }
  982.         if( nlines >= ws_row )
  983.             return;
  985.         st_cur = G.st_end;
  987.         while( st_cur != NULL )
  988.         {
  989.             if( st_cur->base != ap_cur ||
  990.                 time( NULL ) - st_cur->tlast > 120 )
  991.             {
  992.                 st_cur = st_cur->prev;
  993.                 continue;
  994.             }
  996.             nlines++;
  998.             if( ws_row != 0 && nlines > ws_row )
  999.                 return;
  1001.             if( ! memcmp( ap_cur->bssid, BROADCAST_ADDR, 6 ) )
  1002.                 fprintf( stderr, " (not associated) " );
  1003.             else
  1004.                 fprintf( stderr, " %02X:%02X:%02X:%02X:%02X:%02X",
  1005.                         ap_cur->bssid[0], ap_cur->bssid[1],
  1006.                         ap_cur->bssid[2], ap_cur->bssid[3],
  1007.                         ap_cur->bssid[4], ap_cur->bssid[5] );
  1009.             fprintf( stderr, "  %02X:%02X:%02X:%02X:%02X:%02X",
  1010.                     st_cur->stmac[0], st_cur->stmac[1],
  1011.                     st_cur->stmac[2], st_cur->stmac[3],
  1012.                     st_cur->stmac[4], st_cur->stmac[5] );
  1014.             fprintf( stderr, "  %3d", st_cur->power );
  1015.             fprintf( stderr, " %8ld", st_cur->nb_pkt );
  1017.             if( ws_col > 53 )
  1018.             {
  1019.                 memset( ssid_list, 0, sizeof( ssid_list ) );
  1021.                 for( i = 0, n = 0; i < NB_PRB; i++ )
  1022.                 {
  1023.                     if( st_cur->probes[i][0] == '' )
  1024.                         continue;
  1026.                     snprintf( ssid_list + n, sizeof( ssid_list ) - n - 1,
  1027.                               "%c%s", ( i > 0 ) ? ',' : ' ',
  1028.                               st_cur->probes[i] );
  1030.                     n += ( 1 + strlen( st_cur->probes[i] ) );
  1032.                     if( n >= (int) sizeof( ssid_list ) )
  1033.                         break;
  1034.                 }
  1036.                 memset( strbuf, 0, sizeof( strbuf ) );
  1037.                 snprintf( strbuf,  sizeof( strbuf ) - 1,
  1038.                           "%-256s", ssid_list );
  1039.                 strbuf[ws_col - 53] = '';
  1040.                 fprintf( stderr, " %s", strbuf );
  1041.             }
  1043.             fprintf( stderr, "n" );
  1045.             st_cur = st_cur->prev;
  1046.         }
  1048.         ap_cur = ap_cur->prev;
  1049.     }
  1050. }
  1052. void dump_write_csv( void )
  1053. {
  1054.     int i, n;
  1055.     struct tm *ltime;
  1056.     char ssid_list[512];
  1057.     struct AP_info *ap_cur;
  1058.     struct ST_info *st_cur;
  1060.     fseek( G.f_txt, 0, SEEK_SET );
  1062.     fprintf( G.f_txt,
  1063.         "rnBSSID, First time seen, Last time seen, channel, Speed, "
  1064.         "Privacy, Power, # beacons, # data, LAN IP, ESSIDrn" );
  1066.     ap_cur = G.ap_1st;
  1068.     while( ap_cur != NULL )
  1069.     {
  1070.         if( memcmp( ap_cur->bssid, BROADCAST_ADDR, 6 ) == 0 )
  1071.         {
  1072.             ap_cur = ap_cur->next;
  1073.             continue;
  1074.         }
  1076.         if( ap_cur->nb_pkt < 2 )
  1077.         {
  1078.             ap_cur = ap_cur->next;
  1079.             continue;
  1080.         }
  1082.         fprintf( G.f_txt, "%02X:%02X:%02X:%02X:%02X:%02X, ",
  1083.                  ap_cur->bssid[0], ap_cur->bssid[1],
  1084.                  ap_cur->bssid[2], ap_cur->bssid[3],
  1085.                  ap_cur->bssid[4], ap_cur->bssid[5] );
  1087.         ltime = localtime( &ap_cur->tinit );
  1089.         fprintf( G.f_txt, "%04d-%02d-%02d %02d:%02d:%02d, ",
  1090.                  1900 + ltime->tm_year, 1 + ltime->tm_mon,
  1091.                  ltime->tm_mday, ltime->tm_hour,
  1092.                  ltime->tm_min,  ltime->tm_sec );
  1094.         ltime = localtime( &ap_cur->tlast );
  1096.         fprintf( G.f_txt, "%04d-%02d-%02d %02d:%02d:%02d, ",
  1097.                  1900 + ltime->tm_year, 1 + ltime->tm_mon,
  1098.                  ltime->tm_mday, ltime->tm_hour,
  1099.                  ltime->tm_min,  ltime->tm_sec );
  1101.         fprintf( G.f_txt, "%2d, %3d, ",
  1102.                  ap_cur->channel,
  1103.                  ap_cur->max_speed );
  1105.         switch( ap_cur->encryption )
  1106.         {
  1107.             case  0: fprintf( G.f_txt, "OPN " ); break;
  1108.             case  1: fprintf( G.f_txt, "WEP?" ); break;
  1109.             case  2: fprintf( G.f_txt, "WEP " ); break;
  1110.             case  3: fprintf( G.f_txt, "WPA " ); break;
  1111.             default: fprintf( G.f_txt, "    " ); break;
  1112.         }
  1114.         fprintf( G.f_txt, ", %3d, %8ld, %8ld, ",
  1115.                  ap_cur->avg_power,
  1116.                  ap_cur->nb_bcn,
  1117.                  ap_cur->nb_data );
  1119.         fprintf( G.f_txt, "%3d.%3d.%3d.%3d, ",
  1120.                  ap_cur->lanip[0], ap_cur->lanip[1],
  1121.                  ap_cur->lanip[2], ap_cur->lanip[2] );
  1123.         fprintf( G.f_txt, "%-32srn", ap_cur->essid );
  1125.         ap_cur = ap_cur->next;
  1126.     }
  1128.     fprintf( G.f_txt,
  1129.         "rnStation MAC, First time seen, Last time seen, "
  1130.         "Power, # packets, BSSID, Probed ESSIDsrn" );
  1132.     st_cur = G.st_1st;
  1134.     while( st_cur != NULL )
  1135.     {
  1136.         ap_cur = st_cur->base;
  1138.         if( ap_cur->nb_pkt < 2 )
  1139.         {
  1140.             st_cur = st_cur->next;
  1141.             continue;
  1142.         }
  1144.         fprintf( G.f_txt, "%02X:%02X:%02X:%02X:%02X:%02X, ",
  1145.                  st_cur->stmac[0], st_cur->stmac[1],
  1146.                  st_cur->stmac[2], st_cur->stmac[3],
  1147.                  st_cur->stmac[4], st_cur->stmac[5] );
  1149.         ltime = localtime( &st_cur->tinit );
  1151.         fprintf( G.f_txt, "%04d-%02d-%02d %02d:%02d:%02d, ",
  1152.                  1900 + ltime->tm_year, 1 + ltime->tm_mon,
  1153.                  ltime->tm_mday, ltime->tm_hour,
  1154.                  ltime->tm_min,  ltime->tm_sec );
  1156.         ltime = localtime( &st_cur->tlast );
  1158.         fprintf( G.f_txt, "%04d-%02d-%02d %02d:%02d:%02d, ",
  1159.                  1900 + ltime->tm_year, 1 + ltime->tm_mon,
  1160.                  ltime->tm_mday, ltime->tm_hour,
  1161.                  ltime->tm_min,  ltime->tm_sec );
  1163.         fprintf( G.f_txt, "%3d, %8ld, ",
  1164.                  st_cur->power,
  1165.                  st_cur->nb_pkt );
  1167.         if( ! memcmp( ap_cur->bssid, BROADCAST_ADDR, 6 ) )
  1168.             fprintf( G.f_txt, "(not associated) ," );
  1169.         else
  1170.             fprintf( G.f_txt, "%02X:%02X:%02X:%02X:%02X:%02X,",
  1171.                      ap_cur->bssid[0], ap_cur->bssid[1],
  1172.                      ap_cur->bssid[2], ap_cur->bssid[3],
  1173.                      ap_cur->bssid[4], ap_cur->bssid[5] );
  1175.         memset( ssid_list, 0, sizeof( ssid_list ) );
  1177.         for( i = 0, n = 0; i < NB_PRB; i++ )
  1178.         {
  1179.             if( st_cur->probes[i][0] == '' )
  1180.                 continue;
  1182.             snprintf( ssid_list + n, sizeof( ssid_list ) - n - 1,
  1183.                       "%c%s", ( i > 0 ) ? ',' : ' ', st_cur->probes[i] );
  1185.             n += ( 1 + strlen( st_cur->probes[i] ) );
  1186.             if( n >= (int) sizeof( ssid_list ) )
  1187.                 break;
  1188.         }
  1190.         fprintf( G.f_txt, "%srn", ssid_list );
  1192.         st_cur = st_cur->next;
  1193.     }
  1195.     fprintf( G.f_txt, "rn" );
  1196.     fflush( G.f_txt );
  1197.     sync();
  1198. }
  1200. void update_battery( void )
  1201. {
  1202.     FILE *f;
  1203.     char line[256], *p;
  1204.     int a, total, b, remaining, i;
  1206.     G.battery = -1;
  1208.     if( ( f = fopen( "/proc/apm", "r" ) ) != NULL )
  1209.     {
  1210.         /* old fashioned APM interface */
  1212.         memset( line, 0, sizeof( line ) );
  1213.         fgets( line, sizeof( line ) - 1, f );
  1214.         p = strtok( line, " " );
  1215.         for( i = 0; i < 6; i++ )
  1216.         {
  1217.             if( p == NULL ) return;
  1218.             p = strtok( NULL, " " );
  1219.         }
  1220.         if( p == NULL ) return;
  1221.         sscanf( p, "%d%%", &G.battery );
  1222.         return;
  1223.     }
  1225.     total = 1;
  1226.     remaining = 0;
  1228.     for( i = 0; i < 4; i++ )
  1229.     {
  1230.         /* ACPI interface w/ multiple batteries support */
  1232.         memset( line, 0, sizeof( line ) );
  1233.         snprintf( line,  sizeof( line ) - 1,
  1234.                   "/proc/acpi/battery/BAT%d/info", i );
  1236.         if( ( f = fopen( line, "r" ) ) == NULL )
  1237.             continue;
  1239.         while( fgets( line, sizeof( line ), f ) != NULL )
  1240.         {
  1241.             if( memcmp( line, "design capacity:         ", 25 ) == 0 )
  1242.             {
  1243.                 sscanf( line + 25, "%d", &a );
  1244.                 break;
  1245.             }   
  1246.         }
  1247.         fclose( f );
  1249.         memset( line, 0, sizeof( line ) );
  1250.         snprintf( line,  sizeof( line ) - 1,
  1251.                   "/proc/acpi/battery/BAT%d/state", i );
  1253.         if( ( f = fopen( line, "r" ) ) == NULL )
  1254.             continue;
  1256.         while( fgets( line, sizeof( line ), f ) != NULL )
  1257.         {
  1258.             if( memcmp( line, "remaining capacity:      ", 25 ) == 0 )
  1259.             {
  1260.                 sscanf( line + 25, "%d", &b );
  1261.                 break;
  1262.             }   
  1263.         }
  1264.         fclose( f );
  1266.         total += a;
  1267.         remaining += b;
  1268.     }
  1270.     G.battery = ( 100 * remaining ) / total;
  1271. }
  1273. void gps_tracker( void )
  1274. {
  1275.     int gpsd_sock;
  1276.     char line[256], *p;
  1277.     struct sockaddr_in gpsd_addr;
  1279.     /* attempt to connect to localhost, port 2947 */
  1281.     gpsd_sock = socket( AF_INET, SOCK_STREAM, 0 );
  1283.     if( gpsd_sock < 0 )
  1284.         return;
  1286.     gpsd_addr.sin_family      = AF_INET;
  1287.     gpsd_addr.sin_port        = htons( 2947 );
  1288.     gpsd_addr.sin_addr.s_addr = inet_addr( "127.0.0.1" );
  1290.     if( connect( gpsd_sock, (struct sockaddr *) &gpsd_addr,
  1291.                  sizeof( gpsd_addr ) ) < 0 )
  1292.         return;
  1294.     /* loop reading the GPS coordinates */
  1296.     while( 1 )
  1297.     {
  1298.         sleep( 1 );
  1300.         memset( G.gps_loc, 0, sizeof( float ) * 5 );
  1302.         /* read position, speed, heading, altitude */
  1304.         memset( line, 0, sizeof( line ) );
  1305.         snprintf( line,  sizeof( line ) - 1, "PVTADrn" );
  1306.         if( send( gpsd_sock, line, 3, 0 ) != 3 )
  1307.             return;
  1309.         memset( line, 0, sizeof( line ) );
  1310.         if( recv( gpsd_sock, line, sizeof( line ) - 1, 0 ) <= 0 )
  1311.             return;
  1313.         if( memcmp( line, "GPSD,P=", 7 ) != 0 )
  1314.             continue;
  1316.         /* make sure the coordinates are present */
  1318.         if( line[7] == '?' )
  1319.             continue;
  1321.         sscanf( line + 7, "%f %f", &G.gps_loc[0], &G.gps_loc[1] );
  1323.         if( ( p = strstr( line, "V=" ) ) == NULL ) continue;
  1324.         sscanf( p + 2, "%f", &G.gps_loc[2] ); /* speed */
  1326.         if( ( p = strstr( line, "T=" ) ) == NULL ) continue;
  1327.         sscanf( p + 2, "%f", &G.gps_loc[3] ); /* heading */
  1329.         if( ( p = strstr( line, "A=" ) ) == NULL ) continue;
  1330.         sscanf( p + 2, "%f", &G.gps_loc[4] ); /* altitude */
  1332.         fputs( line, G.f_gps );
  1334.         G.save_gps = 1;
  1336.         write( G.gc_pipe[1], G.gps_loc, sizeof( float ) * 5 );
  1337.         kill( getppid(), SIGUSR2 );
  1338.     }
  1339. }
  1341. void sighandler( int signum )
  1342. {
  1343.     signal( signum, sighandler );
  1345.     if( signum == SIGUSR1 )
  1346.         read( G.ch_pipe[0], &G.channel, sizeof( int ) );
  1348.     if( signum == SIGUSR2 )
  1349.         read( G.gc_pipe[0], &G.gps_loc, sizeof( float ) * 5 );
  1351.     if( signum == SIGINT || signum == SIGTERM )
  1352.     {
  1353.         alarm( 1 );
  1354.         G.do_exit = 1;
  1355.         signal( SIGALRM, sighandler );
  1356.         printf( "n" );
  1357.     }
  1359.     if( signum == SIGSEGV )
  1360.     {
  1361.         fprintf( stderr, "Caught signal 11 (SIGSEGV). Please"
  1362.                          " contact the author!33[?25hnn" );
  1363.         fflush( stdout );
  1364.         exit( 1 );
  1365.     }
  1367.     if( signum == SIGALRM )
  1368.     {
  1369.         fprintf( stderr, "Caught signal 14 (SIGALRM). Please"
  1370.                          " contact the author!33[?25hnn" );
  1371.         fflush( stdout );
  1372.         exit( 1 );
  1373.     }
  1375.     if( signum == SIGCHLD )
  1376.         wait( NULL );
  1378.     if( signum == SIGWINCH )
  1379.     {
  1380.         fprintf( stderr, "33[2J" );
  1381.         fflush( stdout );
  1382.     }
  1383. }
  1385. int disable_wep_key( char *interface, int fd_raw )
  1386. {
  1387.     struct iwreq wrq;
  1389.     memset( &wrq, 0, sizeof( struct iwreq ) );
  1390.     strncpy( wrq.ifr_name, interface, IFNAMSIZ );
  1391.     wrq.u.data.flags = IW_ENCODE_DISABLED | IW_ENCODE_NOKEY;
  1393.     return( ioctl( fd_raw, SIOCSIWENCODE, &wrq ) != 0 );
  1394. }
  1396. int set_channel( char *interface, int fd_raw, int channel )
  1397. {
  1398.     char s[32];
  1399.     int pid, status;
  1400.     struct iwreq wrq;
  1402.     if( G.is_wlanng )
  1403.     {
  1404.         memset( s, 0, sizeof( s ) );
  1405.         snprintf( s,  sizeof( s ) - 1, "channel=%d", channel );
  1407.         if( ( pid = fork() ) == 0 )
  1408.         {
  1409.             close( 0 ); close( 1 ); close( 2 ); chdir( "/" );
  1410.             execlp( "wlanctl-ng", "wlanctl-ng", interface,
  1411.                     "lnxreq_wlansniff", s, NULL );
  1412.             exit( 1 );
  1413.         }
  1415.         waitpid( pid, &status, 0 );
  1417.         if( WIFEXITED(status) )
  1418.             return( WEXITSTATUS(status) );
  1419.         else
  1420.             return( 1 );
  1421.     }
  1423.     if( G.is_orinoco )
  1424.     {
  1425.         memset( s, 0, sizeof( s ) );
  1426.         snprintf( s,  sizeof( s ) - 1, "%d", channel );
  1428.         if( ( pid = fork() ) == 0 )
  1429.         {
  1430.             close( 0 ); close( 1 ); close( 2 ); chdir( "/" );
  1431.             execlp( "iwpriv", "iwpriv", interface,
  1432.                     "monitor", "1", s, NULL );
  1433.             exit( 1 );
  1434.         }
  1436.         waitpid( pid, &status, 0 );
  1437.     }
  1439.     memset( &wrq, 0, sizeof( struct iwreq ) );
  1440.     strncpy( wrq.ifr_name, interface, IFNAMSIZ );
  1441.     wrq.u.freq.m = (double) channel;
  1442.     wrq.u.freq.e = (double) 0;
  1444.     if( ioctl( fd_raw, SIOCSIWFREQ, &wrq ) < 0 )
  1445.     {
  1446.         usleep( 10000 ); /* madwifi needs a second chance */
  1448.         if( ioctl( fd_raw, SIOCSIWFREQ, &wrq ) < 0 )
  1449.         {
  1450. /*          perror( "ioctl(SIOCSIWFREQ) failed" ); */
  1451.             return( 1 );
  1452.         }
  1453.     }
  1455.     return( 0 );
  1456. }
  1458. int set_monitor( char *interface, int fd_raw )
  1459. {
  1460.     int pid, status;
  1461.     struct iwreq wrq;
  1463.     if( G.is_wlanng )
  1464.     {
  1465.         if( ( pid = fork() ) == 0 )
  1466.         {
  1467.             close( 0 ); close( 1 ); close( 2 ); chdir( "/" );
  1468.             execlp( "wlanctl-ng", "wlanctl-ng", interface,
  1469.                     "lnxreq_wlansniff", "enable=true",
  1470.                     "prismheader=true", "wlanheader=false",
  1471.                     "stripfcs=true", "keepwepflags=true", NULL );
  1472.             exit( 1 );
  1473.         }
  1475.         waitpid( pid, &status, 0 );
  1477.         if( WIFEXITED(status) )
  1478.             return( WEXITSTATUS(status) );
  1479.         else
  1480.             return( 1 );
  1481.     }
  1483.     memset( &wrq, 0, sizeof( struct iwreq ) );
  1484.     strncpy( wrq.ifr_name, interface, IFNAMSIZ );
  1485.     wrq.u.mode = IW_MODE_MONITOR;
  1487.     if( ioctl( fd_raw, SIOCSIWMODE, &wrq ) < 0 )
  1488.     {
  1489.         perror( "ioctl(SIOCSIWMODE) failed" );
  1490.         return( 1 );
  1491.     }
  1493.     set_channel( interface, fd_raw, 10 );
  1495.     return( 0 );
  1496. }
  1498. void channel_hopper( char *interface, int fd_raw )
  1499. {
  1500.     int ch, ch_idx = 0;
  1502.     while( getppid() != 1 )
  1503.     {
  1504.         ch_idx++;
  1506.         if( bg_chans[ch_idx] ==  0 )
  1507.             ch_idx = 0;
  1509.         if( bg_chans[ch_idx] == -1 ) 
  1510.         {
  1511.             usleep( 10000 );
  1512.             continue;
  1513.         }
  1515.         ch = bg_chans[ch_idx];
  1517.         if( set_channel( interface, fd_raw, ch ) == 0 )
  1518.         {
  1519.             write( G.ch_pipe[1], &ch, sizeof( int ) );
  1520.             kill( getppid(), SIGUSR1 );
  1521.             usleep( 350000 );
  1522.         }
  1523.         else
  1524.             bg_chans[ch_idx] = -1;      /* remove invalid channel */
  1525.     }
  1527.     exit( 0 );
  1528. }
  1530. char usage[] =
  1532. "n"
  1533. "  airodump %d.%d - (C) 2004,2005 Christophe Devinen"
  1534. "n"
  1535. "  usage: airodump <interface> <output prefix> [channel] [IVs flag]n"
  1536. "n"
  1537. "  Specify 0 as the channel to hop between 2.4 GHz channels.n"
  1538. "  Set the optional IVs flag to 1 to only save the capturedn"
  1539. "  IVs - the resulting file is only useful for WEP cracking.n"
  1540. "n"
  1541. "  If the gpsd daemon is running, airodump will retrieve andn"
  1542. "  save the current GPS coordinates in text format.n"
  1543. "n";
  1545. int main( int argc, char *argv[] )
  1546. {
  1547.     long time_slept;
  1548.     int n, caplen, pid;
  1549.     int fd_raw, arptype;
  1550.     int ivs_only, power;
  1551.     time_t tt1, tt2, tt3;
  1553.     unsigned char *buffer;
  1554.     unsigned char *h80211;
  1556.     struct ifreq ifr;
  1557.     struct packet_mreq mr;
  1558.     struct sockaddr_ll sll;
  1559.     struct timeval tv0;
  1560.     struct timeval tv1;
  1561.     struct timeval tv2;
  1562.     struct winsize ws;
  1564.     fd_set rfds;
  1566.     /* initialize a bunch of variables */
  1568.     memset( &G, 0, sizeof( G ) );
  1570.     ivs_only    =  0;
  1571.     power       = -1;
  1572.     fd_raw      = -1;
  1573.     arptype     =  0;
  1574.     time_slept  =  0;
  1576.     /* check the arguments */
  1578.     if( argc < 3 || argc > 5 )
  1579.     {
  1580.         printf( usage, _MAJ, _MIN );
  1581.         return( 1 );
  1582.     }
  1584.     if( argc > 3 )
  1585.         G.channel = atoi( argv[3] );
  1587.     if( argc > 4 )
  1588.         ivs_only  = atoi( argv[4] );
  1590.     /* create the raw socket and drop privileges */
  1592.     fd_raw = socket( PF_PACKET, SOCK_RAW, htons( ETH_P_ALL ) );
  1594.     if( fd_raw < 0 )
  1595.     {
  1596.         perror( "socket(PF_PACKET) failed" );
  1597.         fprintf( stderr, "This program requires root privileges.n" );
  1598.         return( 1 );
  1599.     }
  1601.     setuid( getuid() );
  1603.     /* reserve the buffer space */
  1605.     if( ( buffer = (unsigned char *) malloc( 65536 ) ) == NULL )
  1606.     {
  1607.         perror( "malloc failed" );
  1608.         return( 1 );
  1609.     }
  1611.     /* find the interface index */
  1613.     memset( &ifr, 0, sizeof( ifr ) );
  1614.     strncpy( ifr.ifr_name, argv[1], sizeof( ifr.ifr_name ) - 1 );
  1616.     if( ioctl( fd_raw, SIOCGIFINDEX, &ifr ) < 0 )
  1617.     {
  1618.         fprintf( stderr, "%s is not a network interface.n", argv[1] );
  1619.         return( 1 );
  1620.     }
  1622.     memset( &sll, 0, sizeof( sll ) );
  1623.     sll.sll_family   = AF_PACKET;
  1624.     sll.sll_ifindex  = ifr.ifr_ifindex;
  1625.     sll.sll_protocol = htons( ETH_P_ALL );
  1627.     if( memcmp( argv[1], "wlan", 4 ) == 0 )
  1628.     {
  1629.         if( ( pid = fork() ) == 0 )     /* wlan-ng brain damage */
  1630.         {
  1631.             close( 0 ); close( 1 ); close( 2 ); chdir( "/" );
  1632.             execlp( "wlanctl-ng", "wlanctl-ng", argv[1],
  1633.                     "lnxreq_ifstate", "ifstate=enable", NULL );
  1634.             exit( 1 );
  1635.         }
  1637.         waitpid( pid, &n, 0 );
  1639.         if( WIFEXITED(n) && WEXITSTATUS(n) == 0 )
  1640.             G.is_wlanng = 1;
  1642.         if( ! fork() )                  /* hostap card reset */
  1643.         {
  1644.             close( 0 ); close( 1 ); close( 2 ); chdir( "/" );
  1645.             execlp( "iwpriv", "iwpriv", argv[1], "reset", "1", NULL );
  1646.             exit( 1 );
  1647.         }
  1648.         wait( NULL );
  1649.     }
  1651.     /* test if orinoco */
  1653.     if( memcmp( argv[1], "eth", 3 ) == 0 )
  1654.     {
  1655.         if( ( pid = fork() ) == 0 )
  1656.         {
  1657.             close( 0 ); close( 1 ); close( 2 ); chdir( "/" );
  1658.             execlp( "iwpriv", "iwpriv", argv[1], "get_port3", NULL );
  1659.             exit( 1 );
  1660.         }
  1662.         waitpid( pid, &n, 0 );
  1664.         if( WIFEXITED(n) && WEXITSTATUS(n) == 0 )
  1665.             G.is_orinoco = 1;
  1666.     }
  1668.     /* make sure the interface is up */
  1670.     ifr.ifr_flags = IFF_UP | IFF_BROADCAST | IFF_RUNNING;        
  1672.     if( ioctl( fd_raw, SIOCSIFFLAGS, &ifr ) < 0 )
  1673.     {
  1674.         perror( "ioctl(SIOCSIFFLAGS) failed" );
  1675.         return( 1 );
  1676.     }
  1678.     set_monitor( argv[1], fd_raw );
  1680.     /* bind the raw socket to the interface */
  1682.     if( bind( fd_raw, (struct sockaddr *) &sll,
  1683.               sizeof( sll ) ) < 0 )
  1684.     {
  1685.         perror( "bind(ETH_P_ALL) failed" );
  1686.         return( 1 );
  1687.     }
  1689.     /* couple of iwprivs to enable the prism header */
  1691.     if( ! fork() )  /* hostap */
  1692.     {
  1693.         close( 0 ); close( 1 ); close( 2 ); chdir( "/" );
  1694.         execlp( "iwpriv", "iwpriv", argv[1], "monitor_type", "1", NULL );
  1695.         exit( 1 );
  1696.     }
  1697.     wait( NULL );
  1699.     if( ! fork() )  /* r8180 */
  1700.     {
  1701.         close( 0 ); close( 1 ); close( 2 ); chdir( "/" );
  1702.         execlp( "iwpriv", "iwpriv", argv[1], "prismhdr", "1", NULL );
  1703.         exit( 1 );
  1704.     }
  1705.     wait( NULL );
  1707.     if( ! fork() )  /* prism54 */
  1708.     {
  1709.         close( 0 ); close( 1 ); close( 2 ); chdir( "/" );
  1710.         execlp( "iwpriv", "iwpriv", argv[1], "set_prismhdr", "1", NULL );
  1711.         exit( 1 );
  1712.     }
  1713.     wait( NULL );
  1715.     /* make sure the WEP key is off */
  1717.     disable_wep_key( argv[1], fd_raw );
  1719.     /* start a child to hop between channels */
  1721.     if( G.channel == 0 )
  1722.     {
  1723.         pipe( G.ch_pipe );
  1725.         signal( SIGUSR1, sighandler );
  1727.         if( ! fork() )
  1728.         {
  1729.             channel_hopper( argv[1], fd_raw );
  1730.             exit( 1 );
  1731.         }
  1732.     }
  1733.     else
  1734.         set_channel( argv[1], fd_raw, G.channel );
  1736.     /* start the GPS tracker */
  1738.     pipe( G.gc_pipe );
  1739.     signal( SIGUSR2, sighandler );
  1741.     if( ! fork() )
  1742.     {
  1743.         gps_tracker();
  1744.         exit( 1 );
  1745.     }
  1747.     usleep( 50000 );
  1748.     waitpid( -1, NULL, WNOHANG );
  1750.     /* lookup the hardware type */
  1752.     if( ioctl( fd_raw, SIOCGIFHWADDR, &ifr ) < 0 )
  1753.     {
  1754.         perror( "ioctl(SIOCGIFHWADDR) failed" );
  1755.         return( 1 );
  1756.     }
  1758.     arptype = ifr.ifr_hwaddr.sa_family;
  1760.     if( arptype != ARPHRD_IEEE80211 &&
  1761.         arptype != ARPHRD_IEEE80211_PRISM &&
  1762.         arptype != ARPHRD_IEEE80211_FULL )
  1763.     {
  1764.         if( arptype == 1 )
  1765.             fprintf( stderr, "nARP linktype is set to 1 (Ethernet) " );
  1766.         else
  1767.             fprintf( stderr, "nUnsupported hardware link type %4d ",
  1768.                      arptype );
  1770.         fprintf( stderr, "- expected ARPHRD_IEEE80211nor ARPHRD_IEEE8021"
  1771.                          "1_PRISM instead.  Make sure RFMON is enabled:n"
  1772.                          "run 'ifconfig %s up; iwconfig %s mode Monitor "
  1773.                          "channel <#>'nn", argv[1], argv[1] );
  1774.         return( 1 );
  1775.     }
  1777.     /* enable promiscuous mode */
  1779.     memset( &mr, 0, sizeof( mr ) );
  1780.     mr.mr_ifindex = sll.sll_ifindex;
  1781.     mr.mr_type    = PACKET_MR_PROMISC;
  1783.     if( setsockopt( fd_raw, SOL_PACKET, PACKET_ADD_MEMBERSHIP,
  1784.                     &mr, sizeof( mr ) ) < 0 )
  1785.     {
  1786.         perror( "setsockopt(PACKET_MR_PROMISC) failed" );
  1787.         return( 1 );
  1788.     }
  1790.     /* open or create the output files */
  1792.     if( dump_initialize( argv[2], ivs_only ) )
  1793.         return( 1 );
  1795.     signal( SIGINT,   sighandler );
  1796.     signal( SIGSEGV,  sighandler );
  1797.     signal( SIGTERM,  sighandler );
  1798.     signal( SIGWINCH, sighandler );
  1800.     sighandler( SIGWINCH );
  1802.     fprintf( stderr, "33[?25l33[2Jn" );
  1804.     update_battery();
  1806.     tt1 = time( NULL );
  1807.     tt2 = time( NULL );
  1808.     tt3 = time( NULL );
  1810.     while( 1 )
  1811.     {
  1812.         if( G.do_exit ) break;
  1814.         if( time( NULL ) - tt1 >= 20 )
  1815.         {
  1816.             /* update the csv stats file */
  1818.             tt1 = time( NULL );
  1819.             dump_write_csv();
  1821.             /* sort the APs by power */
  1823.             dump_sort_power();
  1824.         }
  1826.         if( time( NULL ) - tt2 > 3 )
  1827.         {
  1828.             /* update the battery state */
  1830.             tt2 = time( NULL );
  1831.             update_battery();
  1833.             /* flush the output files */
  1835.             if( G.f_cap != NULL ) fflush( G.f_cap );
  1836.             if( G.f_ivs != NULL ) fflush( G.f_ivs );
  1837.         }
  1839.         /* capture one packet */
  1841.         FD_ZERO( &rfds );
  1842.         FD_SET( fd_raw, &rfds );
  1844.         tv0.tv_sec  = 0;
  1845.         tv0.tv_usec = REFRESH_RATE;
  1847.         gettimeofday( &tv1, NULL );
  1849.         if( select( fd_raw + 1, &rfds, NULL, NULL, &tv0 ) < 0 )
  1850.         {
  1851.             if( errno == EINTR ) continue;
  1852.             perror( "select failed" );
  1853.             return( 1 );
  1854.         }
  1856.         gettimeofday( &tv2, NULL );
  1858.         time_slept += 1000000 * ( tv2.tv_sec  - tv1.tv_sec  )
  1859.                               + ( tv2.tv_usec - tv1.tv_usec );
  1861.         if( time_slept > REFRESH_RATE )
  1862.         {
  1863.             time_slept = 0;
  1865.             /* update the window size */
  1867.             if( ioctl( 0, TIOCGWINSZ, &ws ) < 0 )
  1868.             {
  1869.                 ws.ws_row = 25;
  1870.                 ws.ws_col = 80;
  1871.             }
  1873.             if( ws.ws_col <   1 ) ws.ws_col =   1;
  1874.             if( ws.ws_col > 300 ) ws.ws_col = 300;
  1876.             /* display the list of access points we have */
  1878.             fprintf( stderr, "33[1;1H" );
  1879.             dump_print( ws.ws_row, ws.ws_col );
  1880.             fprintf( stderr, "33[J" );
  1881.             fflush( stdout );
  1882.             continue;
  1883.         }
  1885.         if( ! FD_ISSET( fd_raw, &rfds ) )
  1886.             continue;
  1888.         /* one packet available for reading */
  1890.         memset( buffer, 0, 4096 );
  1892.         if( ( caplen = read( fd_raw, buffer, 65535 ) ) < 0 )
  1893.         {
  1894.             perror( "read failed" );
  1895.             return( 1 );
  1896.         }
  1898.         /* if device is an atheros, remove the FCS */
  1900.         if( ! memcmp( argv[1], "ath", 3 ) )
  1901.             caplen -= 4;
  1903.         /* prism (wlan-ng) header parsing */
  1905.         h80211 = buffer;
  1907.         if( arptype == ARPHRD_IEEE80211_PRISM )
  1908.         {
  1909.             if( buffer[7] == 0x40 )
  1910.             {
  1911.                 /* prism54 uses a different format */
  1913.                 power = buffer[0x33];
  1915.                 n = 0x40;
  1916.             }
  1917.             else
  1918.             {
  1919.                 power = *(int *)( buffer + 0x5C );
  1921.                 if( ! memcmp( argv[1], "ath", 3 ) )
  1922.                     power -= *(int *)( buffer + 0x68 );
  1924.                 n = *(int *)( buffer + 4 );
  1925.             }
  1927.             if( n <= 0 || n >= caplen )
  1928.                 continue;
  1930.             h80211 += n;
  1931.             caplen -= n;
  1932.         }
  1934.         /* radiotap header parsing */
  1936.         if( arptype == ARPHRD_IEEE80211_FULL )
  1937.         {
  1938.             if( buffer[0] != 0 )
  1939.             {
  1940.                 fprintf( stderr, "Wrong radiotap header version.n" );
  1941.                 return( 1 );
  1942.             }
  1944.             n = *(unsigned short *)( buffer + 2 );
  1946.             if( *(int *)( buffer + 4 ) == 0x0000082E )
  1947.                 power = buffer[14];     /* ipw2200 1.0.7 */
  1949.             if( n <= 0 || n >= caplen )
  1950.                 continue;
  1952.             h80211 += n;
  1953.             caplen -= n;
  1954.         }
  1956.         dump_add_packet( h80211, caplen, power );
  1957.     }
  1959.     dump_write_csv();
  1961.     if( G.f_txt != NULL ) fclose( G.f_txt );
  1962.     if( G.f_gps != NULL ) fclose( G.f_gps );
  1963.     if( G.f_cap != NULL ) fclose( G.f_cap );
  1964.     if( G.f_ivs != NULL ) fclose( G.f_ivs );
  1966.     if( ! G.save_gps )
  1967.     {
  1968.         sprintf( (char *) buffer, "%s-%02d.gps", argv[2], G.f_index );
  1969.         unlink(  (char *) buffer );
  1970.     }
  1972.     fprintf( stderr, "33[?25h" );
  1973.     fflush( stdout );
  1975.     return( 0 );
  1976. }