callbacks.c

AirSnort 是一个无线局域网工具

#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <pthread.h>
#include <string.h>

#include <gtk/gtk.h>

#include "callbacks.h"
#include "interface.h"
#include "support.h"

#include "display.h"
#include "capture.h"
#include "crack.h"
#include "bssidlist.h"
#include <pcap.h>

void reallyQuit(void);

#ifndef DLT_PRISM_HEADER
#define DLT_PRISM_HEADER 119
#endif

#ifndef DLT_AIRONET_HEADER
#define DLT_AIRONET_HEADER 120
#endif

int scan = 1;
int oldscan;
int chan = 6;
int spinchan = 6;
int funcId = 0;
int doCapture = 0;
pthread_t capThread;
int breadth40 = 3;
int breadth128 = 2;
int quitting = 0;
int logfile = 0;
char dumpfile[256] = {0};
int cardType = 0;
int realized = 0;

int readPcapFile = 0;

char *cards[] = { "Prism2 (wlan-ng)", "Orinoco (orinoco_cs)", "Other" };
static const int NUM_CARDS = sizeof(cards);

GtkCList *theList;
GdkEventButton *popupEvent;
GtkCheckMenuItem *logFileMenu;
char errbuf[PCAP_ERRBUF_SIZE];

void reallyQuit() {
   doCapture = 0;
   if (logfile != -1) {
      close(logfile);
   }
   saveOpts();
   gtk_main_quit();
}

/* Function to open a dialog box displaying the message provided. */

void quick_message(char *title, char *message) {

   GtkWidget *dialog, *label, *okay_button;

   /* Create the widgets */
   
   dialog = gtk_dialog_new();
   gtk_window_set_title(GTK_WINDOW(dialog), title);
   gtk_window_set_modal(GTK_WINDOW(dialog), 1);
   gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER);
   gtk_container_set_border_width (GTK_CONTAINER (GTK_DIALOG(dialog)->action_area), 10);
   gtk_container_set_border_width (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox), 10);

   label = gtk_label_new (message);
   okay_button = gtk_button_new_with_label("Okay");
   
   /* Ensure that the dialog box is destroyed when the user clicks ok. */
   
   gtk_signal_connect_object (GTK_OBJECT (okay_button), "clicked",
                              GTK_SIGNAL_FUNC (gtk_widget_destroy), GTK_OBJECT(dialog));
   gtk_box_pack_start (GTK_BOX (GTK_DIALOG(dialog)->action_area), okay_button, TRUE, FALSE, 0);

   /* Add the label, and show everything we've added to the dialog. */

   gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox),
                      label);
   gtk_widget_show_all (dialog);
}

void
on_AirSnortWindow_realize              (GtkWidget       *widget,
                                        gpointer         user_data)
{
   theList = (GtkCList*) user_data;
   if (!funcId) {
      funcId = gtk_timeout_add( 500, (GtkFunction) update, user_data); 
   }
}


gboolean
on_AirSnortWindow_delete_event         (GtkWidget       *widget,
                                        GdkEvent        *event,
                                        gpointer         user_data)
{
   if (!head) {
      reallyQuit();
   }
   else {
      gtk_widget_show_all (create_CloseDlg());
   }
  return TRUE;
}


void
on_load_activate                       (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
   if (doCapture) {
      quick_message("Error", "Can't load while capture in progress");
      return;
   }
   gtk_widget_show_all (create_FileLoad());
}


void
on_save_activate                       (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
   gtk_widget_show_all (create_SaveFile());
}


void
on_exit_activate                       (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
   if (!head) {
      reallyQuit();
   }
   else {
      gtk_widget_show_all (create_CloseDlg());
   }
}


void
on_clear_activate                      (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
   on_Clear_clicked(NULL, (gpointer)theList);
}

void
on_about_activate                      (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
   gtk_widget_show_all (create_AboutDlg());
}

void
on_Start_clicked                       (GtkButton       *button,
                                        gpointer         user_data)
{
   char cmd[80];
   CaptureArg *ca;
   if (doCapture) return;

   if (!scan) {
      chan = spinchan;
   }
   if (cardType == PRISM) {
      sprintf(cmd, "wlanctl-ng %s lnxreq_ifstate ifstate=enable > /dev/null", dev);
      system(cmd);
      sprintf(cmd, "ifconfig %s up", dev);
      system(cmd);
   }
   if (setChannel(chan)) {
      quick_message("Error", "Could not set monitor mode");
      return;
   }  
   doCapture = 1;
   ca = (CaptureArg*) malloc(sizeof(CaptureArg));
   ca->pcap = pcap_open_live(dev, 3000, 1, 0, errbuf);
   if (ca->pcap) {
      switch (pcap_datalink(ca->pcap)) {
         case DLT_PRISM_HEADER:
            ca->offset = 144;
            break;
         case DLT_IEEE802_11:
            ca->offset = 0;
            break;
         case DLT_AIRONET_HEADER:
            ca->offset = 0;
            break;
         default: //COOKED
            ca->offset = 160;
      }
      if (*dumpfile) {
         ca->dump = pcap_dump_open(ca->pcap, dumpfile);
         dumpfile[0] = 0;
      }
      else {
         ca->dump = NULL;
      }
      pthread_create(&capThread, NULL, capture, ca);
   }
}


void
on_Stop_clicked                        (GtkButton       *button,
                                        gpointer         user_data)
{
   doCapture = 0;
}


void
on_freq_changed                        (GtkEditable     *editable,
                                        gpointer         user_data)
{
   spinchan = gtk_spin_button_get_value_as_int((GtkSpinButton*) editable);
   if (!scan) {
      chan = spinchan; 
      if (doCapture) {
         setChannel(chan);
      }
   }
}


void
on_scan_toggled                        (GtkToggleButton *togglebutton,
                                        gpointer         user_data)
{
   scan = gtk_toggle_button_get_active(togglebutton); 
   if (!scan) {
      chan = spinchan; 
      if (doCapture) {
         setChannel(chan);
      }
   }
}


void
on_Clear_clicked                       (GtkButton       *button,
                                        gpointer         user_data)
{
   gtk_clist_clear((GtkCList*) user_data);
   clearList();
}


void
on_DataList_select_row                 (GtkCList        *clist,
                                        gint             row,
                                        gint             column,
                                        GdkEvent        *event,
                                        gpointer         user_data)
{

}

void myPositionFunc(GtkMenu *menu, int *x, int *y, gpointer data) {
   popupEvent = (GdkEventButton*) data;
   *x = popupEvent->x_root;
   *y = popupEvent->y_root;
}

gboolean
on_DataList_button_press_event         (GtkWidget       *widget,
                                        GdkEventButton  *event,
                                        gpointer         user_data)
{
   if (event->button == 3) {
      gtk_menu_popup (GTK_MENU(create_ListPopup()), NULL, NULL, 
                      myPositionFunc, event, event->button, 0);
   }
   return FALSE;
}

void
on_CloseYes_clicked                    (GtkButton       *button,
                                        gpointer         user_data)
{
   quitting = 1;
   gtk_widget_show_all (create_SaveFile());
}

void
on_CloseNo_clicked                     (GtkButton       *button,
                                        gpointer         user_data)
{
   reallyQuit();
}

void
loadPacketFile                         (GtkButton       *button,
                                        gpointer         user_data)
{
   PacketInfo pi;
   CaptureRec cap;
   unsigned char bssid[6], sta[] = {0,0,0,0,0,0};
   unsigned char dummyPacket[200];
   int len;
   unsigned char slen, chan;
   char *fname = gtk_file_selection_get_filename(GTK_FILE_SELECTION(user_data));
   int fd = open(fname, O_RDONLY);
   cap.pInfo = &pi;
   cap.bssid = bssid;
   cap.sta = sta;
   pi.raw = dummyPacket;
   if (fd != -1) {
      while (read(fd, &len, sizeof(int)) == sizeof(int)) {
         if (read(fd, bssid, 6) != 6) {