callbacks.c

airsnort

         }
         if (len == 0) {   //this is name info
            if (read(fd, &chan, 1) != 1) {
            }
            pi.channel = chan & 0x0F;
            dummyPacket[178] = chan & 0x10 ? 0 : 0x10;
            if (read(fd, &slen, 1) != 1) {
            }
            pi.name = (char*) malloc(slen + 1);
            if (read(fd, pi.name, slen) != slen) {
            }  
            pi.name[slen] = 0;
            addBssid(&cap);
         }
         else {
            pi.channel = 0;
            pi.pack = (Packet *) malloc(sizeof(Packet));
            cap.iv = pi.pack->buf = (unsigned char *) malloc(len - 6);
            pi.pack->len = len - 6;
            pi.pack->next = NULL;
            if (read(fd, pi.pack->buf, len - 6) != (len - 6)) {
            }
            addPacket(NULL, &cap, 1);
         }
      }
      close(fd);
   }
}

/***********************************************************

  format of saved data:

  For ksample packets:

  4 byte integer length of 802.11b data = n+6 (includes bssid)
  6 byte bssid
  n bytes of packet data
     3 byte IV
     n-3 bytes of data w/ 802.11b checksum at the end

  For sample packets

  4 byte integer length = 11
  6 byte bssid
  5 bytes of packet data
     3 byte IV
     1 dummy byte = 0
     1 byte = first byte of 802.11b data (the 0xAA byte)

  For AP name information

  4 byte integer length = 0
  6 byte bssid
  1 byte channel number
  1 byte length of name = n
  n byte AP name

************************************************************/

void
savePacketData                         (GtkButton       *button,
                                        gpointer         user_data)
{
   unsigned char first, dummy = 0;
   Packet *pkt;
   Sample *samp;
   BssidList *temp = head;
   int len, i;
   unsigned char uchar;
   char *fname = gtk_file_selection_get_filename(GTK_FILE_SELECTION(user_data));
   int fd = open(fname, O_WRONLY | O_CREAT, 0644);
   if (fd != -1) {
      for (; temp; temp = temp->next) {
         if (temp->name) {
            len = 0;
            write(fd, &len, sizeof(int));
            write(fd, temp->bssid, 6);
            uchar = temp->channel;
//            uchar |= temp->usingWep ? 0 : 0x10;
            write(fd, &uchar, 1);
            uchar = strlen(temp->name);
            write(fd, &uchar, 1);
            write(fd, temp->name, uchar);
         }
         if (temp->ap) {
            for (pkt = temp->ap->pkts; pkt; pkt = pkt->next) {
               len = pkt->len + 6;
               write(fd, &len, sizeof(int));
               write(fd, temp->bssid, 6);
               write(fd, pkt->buf, pkt->len);
            }
            len = 11;
            for (i = 0; i < 13; i++) {
               for (samp = temp->ap->samples[i]; samp; samp = samp->next) {
                  write(fd, &len, sizeof(int));
                  write(fd, temp->bssid, 6);
                  write(fd, samp->iv, 3);
                  write(fd, &dummy, 1);
                  first = samp->firstByte ^ 0xAA;
                  write(fd, &first, 1);
               }
            }
         }
      }
   }
   close(fd);
   if (quitting) {
      reallyQuit();
   }
}

void
on_savefile_cancel                     (GtkButton       *button,
                                        gpointer         user_data)
{
   if (quitting) {
      reallyQuit();
   }
}

void
on_stats_activate                      (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
//fprintf(stderr, "stats\n");
}

void
on_delete_activate                     (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
   int row, column, result;
//fprintf(stderr, "delete\n");

   result = gtk_clist_get_selection_info(theList, popupEvent->x, popupEvent->y, &row, &column);
   if (result) {
//fprintf(stderr, "row = %d, col = %d\n", row, column);
   }
   else {
//   fprintf(stderr, "not found\n");
   }
}


void
on_stop_activate                       (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
//fprintf(stderr, "stop\n");
}


void
on_gps_activate                        (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
   gtk_widget_show_all (create_GpsDialog());
}


void
on_GpsOk_clicked                       (GtkButton       *button,
                                        gpointer         user_data)
{

}

void
on_log_activate                        (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
   logFileMenu = GTK_CHECK_MENU_ITEM(menuitem);
   if (logFileMenu->active) {
      gtk_widget_show_all (create_LogFile());
   }
   else if (logfile) {  //file is open, time to close
//      close(logfile);
//      logfile = -1;
   }
}

void
on_log_ok_clicked                      (GtkButton       *button,
                                        gpointer         user_data)
{
   //this will only take effect when user clicks start to begin a capture
   strcpy(dumpfile, gtk_file_selection_get_filename(GTK_FILE_SELECTION(user_data)));
}

void
on_log_cancel_button_clicked           (GtkButton       *button,
                                        gpointer         user_data)
{
   gtk_check_menu_item_set_active(logFileMenu, 0);
}

void
on_load_pcap_file_activate             (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
   if (!doCapture) {
      gtk_widget_show_all (create_PcapFile());
   }
   else {  //can't load while capturing
      quick_message("Error", "Can't load while capture in progress");
   }

}

void
on_pcap_ok_clicked                     (GtkButton       *button,
                                        gpointer         user_data)
{
   CaptureArg *ca = (CaptureArg*) malloc(sizeof(CaptureArg));
   char *fname = gtk_file_selection_get_filename(GTK_FILE_SELECTION(user_data));
   ca->pcap = pcap_open_offline(fname, errbuf);
   if (ca->pcap) {
      switch (pcap_datalink(ca->pcap)) {
         case DLT_PRISM_HEADER:
            ca->offset = 144;
            break;
         default: //DLT_IEEE802_11
            ca->offset = 0;
      }
      ca->dump = NULL;
      oldscan = scan;
      scan = 0;
      doCapture = 1;
      readPcapFile = 1;
      pthread_create(&capThread, NULL, capture, ca);
   }

}

void
on_CardType_changed                    (GtkEditable     *editable,
                                        gpointer         user_data)
{
   char *ct = gtk_entry_get_text(GTK_ENTRY(editable));
   for (cardType = 0; cardType < NUM_CARDS; cardType++) {
      if (!strcmp(cards[cardType], ct)) break;
   }
   if (cardType == OTHER && realized) {
      //tell user that they must set monitor mode manually
      quick_message("Notice", "You must place your card into monitor mode\nmanually.  Channel scan may not be available");
   }
}


void
on_DeviceName_changed                  (GtkEditable     *editable,
                                        gpointer         user_data)
{
   strcpy(dev, gtk_entry_get_text(GTK_ENTRY(editable)));
}

void breadthChanged(void) {
   BssidList *node;
   for (node = head; node; node = node->next) {
      if (node->usingWep && !node->ap->cracked) {
         node->channelChanged = 1;
         sem_post(&(node->crackSem));
      }
   }
}

void
on_breadth40_changed                   (GtkEditable     *editable,
                                        gpointer         user_data)
{
   breadth40 = gtk_spin_button_get_value_as_int((GtkSpinButton*) editable);
   breadthChanged();
}


void
on_breadth128_changed                  (GtkEditable     *editable,
                                        gpointer         user_data)
{
   breadth128 = gtk_spin_button_get_value_as_int((GtkSpinButton*) editable);
   breadthChanged();
}


void
on_freq_realize                        (GtkWidget       *widget,
                                        gpointer         user_data)
{
   gtk_spin_button_set_value((GtkSpinButton*) widget, chan);
}


void
on_CardType_realize                    (GtkWidget       *widget,
                                        gpointer         user_data)
{
   gtk_entry_set_text (GTK_ENTRY (widget), cards[cardType]);
   realized = 1;
}


void
on_DeviceName_realize                  (GtkWidget       *widget,
                                        gpointer         user_data)
{
   gtk_entry_set_text(GTK_ENTRY(widget), dev);
}


void
on_breadth40_realize                   (GtkWidget       *widget,
                                        gpointer         user_data)
{
   gtk_spin_button_set_value((GtkSpinButton*) widget, breadth40);
}


void
on_breadth128_realize                  (GtkWidget       *widget,
                                        gpointer         user_data)
{
   gtk_spin_button_set_value((GtkSpinButton*) widget, breadth128);
}