gtk/airpcap_dlg.c

   1 /* airpcap_dlg.c
   2  *
   3  * $Id$
   4  *
   5  * Giorgio Tino <giorgio.tino@cacetech.com>
   6  * Copyright (c) CACE Technologies, LLC 2006
   7  *
   8  * Wireshark - Network traffic analyzer
   9  * By Gerald Combs <gerald@wireshark.org>
  10  * Copyright 2000 Gerald Combs
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with this program; if not, write to the Free Software
  24  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  25  */
  26
  27 #ifdef HAVE_CONFIG_H
  28 # include "config.h"
  29 #endif
  30
  31 #ifdef HAVE_AIRPCAP
  32
  33 #include <gtk/gtk.h>
  34 #include <glib.h>
  35 #include <glib/gprintf.h>
  36
  37 #include <string.h>
  38
  39 #include <epan/filesystem.h>
  40
  41 #include <pcap.h>
  42
  43 #include "gtk/main.h"
  44 #include "dlg_utils.h"
  45 #include "gui_utils.h"
  46 #include "simple_dialog.h"
  47 #include "dfilter_expr_dlg.h"
  48 #include "compat_macros.h"
  49 #include "gtkglobals.h"
  50 #include "help_dlg.h"
  51
  52 #include <airpcap.h>
  53 #include "airpcap_loader.h"
  54 #include "airpcap_gui_utils.h"
  55 #include "airpcap_dlg.h"
  56
  57 #include "keys.h"
  58
  59 /* temporary block signals to widgets */
  60 BOOL block_advanced_signals;
  61
  62 /*
  63  * This struct will contain useful data for the selected (actual) airpcap device
  64  */
  65 void
  66 airpcap_fill_if_combo(GtkWidget *combo, GList* if_list)
  67 {
  68 int ifn = 0;
  69 GList* popdown_if_list = NULL;
  70 GList* curr = NULL;
  71 airpcap_if_info_t* if_info = NULL;
  72
  73         curr = g_list_nth(if_list, ifn);
  74         if_info = NULL;
  75         if(curr != NULL) if_info = curr->data;
  76
  77         popdown_if_list = NULL;
  78         ifn = g_list_length(if_list) - 1;
  79         while(ifn >= 0) /* reverse order */
  80                 {
  81                 curr = g_list_nth(if_list, ifn);
  82                 if_info = NULL;
  83                 if(curr != NULL)
  84                         if_info = curr->data;
  85                 if(if_info != NULL)
  86                         popdown_if_list = g_list_append( popdown_if_list , if_info->description) ;
  87                 ifn--;
  88                 }
  89         gtk_combo_set_popdown_strings( GTK_COMBO(combo), popdown_if_list) ;
  90
  91         if(airpcap_if_selected != NULL)
  92                 {
  93                 gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(combo)->entry), airpcap_if_selected->description);
  94                 }
  95         else
  96                 {
  97                 gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(combo)->entry), "No Wireless Interfaces Found");
  98                 }
  99 }
 100
 101 /*
 102  * Callback for the crc chackbox
 103  */
 104 static void
 105 crc_check_cb(GtkWidget *w, gpointer user_data)
 106 {
 107 if( !block_advanced_signals && (airpcap_if_selected != NULL))
 108         {
 109         if(airpcap_if_selected->IsFcsPresent)
 110                 {
 111                 airpcap_if_selected->IsFcsPresent = FALSE;
 112                 airpcap_if_selected->saved = FALSE;
 113                 }
 114         else
 115                 {
 116                 airpcap_if_selected->IsFcsPresent = TRUE;
 117                 airpcap_if_selected->saved = FALSE;
 118                 }
 119         }
 120 }
 121
 122 /*
 123  * Callback for the wrong crc combo
 124  */
 125 static void
 126 wrong_crc_combo_cb(GtkWidget *w, gpointer data)
 127 {
 128 const gchar *s;
 129
 130 s = gtk_entry_get_text(GTK_ENTRY(data));
 131
 132 if( !block_advanced_signals && (data != NULL) && (w != NULL) )
 133         {
 134         if((g_strcasecmp("",s)))
 135                 {
 136                 airpcap_if_selected->CrcValidationOn = airpcap_get_validation_type(s);
 137                 airpcap_if_selected->saved = FALSE;
 138                 }
 139         }
 140 }
 141
 142 /*
 143  * Changed callback for the channel combobox
 144  */
 145 static void
 146 channel_changed_cb(GtkWidget *w _U_, gpointer data)
 147 {
 148 const gchar *s;
 149
 150   s = gtk_entry_get_text(GTK_ENTRY(data));
 151
 152 if( !block_advanced_signals && (data != NULL) && (w != NULL) )
 153         {
 154         s = gtk_entry_get_text(GTK_ENTRY(data));
 155         if((g_strcasecmp("",s)))
 156                 {
 157                 if(airpcap_if_selected != NULL)
 158                         {
 159                         airpcap_if_selected->channel = airpcap_get_channel_number(s);
 160                         airpcap_if_selected->saved = FALSE;
 161                         }
 162                 }
 163         }
 164 }
 165
 166 /*
 167  * Changed callback for the link layer combobox
 168  */
 169 static void
 170 link_type_changed_cb(GtkWidget *w _U_, gpointer data)
 171 {
 172 const gchar *s;
 173
 174 s = gtk_entry_get_text(GTK_ENTRY(data));
 175
 176 if( !block_advanced_signals && (data != NULL) && (w != NULL) )
 177         {
 178         if((g_strcasecmp("",s)))
 179                 {
 180                 airpcap_if_selected->linkType = airpcap_get_link_type(s);
 181                 airpcap_if_selected->saved = FALSE;
 182                 }
 183         }
 184 }
 185
 186 /*
 187  * Activate callback for the adapter combobox
 188  */
 189 static void
 190 combo_if_activate_cb(GtkWidget *entry _U_, gpointer data)
 191 {
 192 }
 193
 194 /*
 195  * Changed callback for the adapter combobox
 196  */
 197 static void
 198 airpcap_advanced_combo_if_changed_cb(GtkWidget *w _U_, gpointer data)
 199 {
 200 const gchar* s = NULL;
 201
 202 s = gtk_entry_get_text(GTK_ENTRY(w));
 203
 204 if((g_strcasecmp("",s)))
 205         {
 206   /* We are trying to change the interface to set up...*/
 207   /* Check if the current interface settings need to be SAVED! */
 208   if( (airpcap_if_selected != NULL) && !block_advanced_signals)
 209                 {
 210                 if( (airpcap_if_selected->saved) ) /* Just change interface */
 211                         {
 212                         /* No changes for this interface, no need to save anything */
 213                         airpcap_change_if(w,data);
 214                         }
 215                 else
 216                         {
 217                         /* Popup a dialog to ask if user wants to save settings for selected
 218                          * interface before changing it...
 219                          */
 220                         airpcap_ask_for_save(w,data);
 221                         }
 222                 }
 223         }
 224 }
 225
 226 /*
 227  * Takes the keys from the GtkList widget, and add them to the interface list
 228  */
 229 void
 230 airpcap_add_keys_from_list(GtkWidget *keylist, airpcap_if_info_t *if_info)
 231 {
 232 GtkWidget       *key_ls;
 233
 234 GString         *new_key;
 235
 236 gchar           *text_entered = NULL;
 237
 238 GtkWidget       *nl_item,*nl_lb;
 239
 240 GList           *list,
 241                         *children;
 242
 243 /* airpcap stuff */
 244 UINT i, j;
 245 gchar s[3];
 246 PAirpcapKeysCollection KeysCollection;
 247 ULONG KeysCollectionSize;
 248 UCHAR KeyByte;
 249
 250 UINT keys_in_list = 0;
 251
 252 key_ls  = keylist;
 253
 254 keys_in_list = (UINT)g_list_length(GTK_LIST(key_ls)->children);
 255
 256 if(keys_in_list > 0)
 257 {
 258         /*
 259          * Save the encryption keys, if we have any of them
 260          */
 261         KeysCollectionSize = 0;
 262
 263         /*
 264          * Calculate the size of the keys collection
 265          */
 266         KeysCollectionSize = sizeof(AirpcapKeysCollection) + keys_in_list * sizeof(AirpcapKey);
 267
 268         /*
 269          * Allocate the collection
 270          */
 271         KeysCollection = (PAirpcapKeysCollection)malloc(KeysCollectionSize);
 272         if(!KeysCollection)
 273         {
 274                 /* Simple dialog ERROR */
 275                 simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"%s","Failed mamory allocation for KeysCollection!");
 276                 return;
 277         }
 278
 279         /*
 280          * Populate the key collection
 281          */
 282         list = GTK_LIST(key_ls)->children;
 283         KeysCollection->nKeys = keys_in_list;
 284
 285         for(i = 0; i < keys_in_list; i++)
 286         {
 287                 KeysCollection->Keys[i].KeyType = AIRPCAP_KEYTYPE_WEP;
 288
 289                 /* Retrieve the Item corresponding to the i-th key */
 290                 nl_item = g_list_nth_data(list, i);
 291                 children = gtk_container_children(GTK_CONTAINER(nl_item));
 292                 nl_lb = g_list_nth_data(children,0);
 293                 new_key = g_string_new(GTK_LABEL(nl_lb)->label);
 294
 295                 KeysCollection->Keys[i].KeyLen = new_key->len / 2;
 296                 memset(&KeysCollection->Keys[i].KeyData, 0, sizeof(KeysCollection->Keys[i].KeyData));
 297
 298                 for(j = 0 ; j < new_key->len; j += 2)
 299                 {
 300                         s[0] = new_key->str[j];
 301                         s[1] = new_key->str[j+1];
 302                         s[2] = '\0';
 303                         KeyByte = (UCHAR)strtol(s, NULL, 16);
 304                         KeysCollection->Keys[i].KeyData[j / 2] = KeyByte;
 305                 }
 306         }
 307
 308         /*
 309          * Free the old adapter key collection!
 310          */
 311         if(airpcap_if_selected->keysCollection != NULL)
 312                 g_free(airpcap_if_selected->keysCollection);
 313
 314         /*
 315          * Set this collection ad the new one
 316          */
 317         airpcap_if_selected->keysCollection = KeysCollection;
 318         airpcap_if_selected->keysCollectionSize = KeysCollectionSize;
 319 }
 320
 321 return;
 322 }
 323
 324
 325 /*
 326  * Pop-up window, used to ask the user if he wants to save the selected interface settings
 327  * when closing the window.
 328  */
 329 void
 330 airpcap_ask_for_save_before_closing(GtkWidget *w _U_, gpointer data)
 331 {
 332         GtkWidget* dialog;
 333
 334     dialog = simple_dialog(ESD_TYPE_CONFIRMATION, ESD_BTNS_SAVE_DONTSAVE_CANCEL,
 335                 PRIMARY_TEXT_START "Save settings before closing?" PRIMARY_TEXT_END "\n\n"
 336                 "If you close the window without saving, changes you made will\nbe discarded.");
 337     simple_dialog_set_cb(dialog, airpcap_dialog_save_before_closing_cb, data);
 338 }
 339
 340 /* user confirmed the "Save settings..." dialog */
 341 void
 342 airpcap_dialog_save_before_closing_cb(gpointer dialog _U_, gint btn, gpointer data)
 343 {
 344 GtkWidget* interface_combo;
 345 GtkWidget* key_ls;
 346
 347 /* I need the combo box entry */
 348 interface_combo         = GTK_WIDGET(OBJECT_GET_DATA(GTK_WIDGET(data),AIRPCAP_ADVANCED_INTERFACE_KEY));
 349 key_ls                          = GTK_WIDGET(OBJECT_GET_DATA(data,AIRPCAP_ADVANCED_KEYLIST_KEY));
 350
 351     switch(btn) {
 352     case(ESD_BTN_SAVE):
 353         /* save interface and exit  */
 354                 airpcap_add_keys_from_list(key_ls,airpcap_if_selected);
 355                 airpcap_save_selected_if_configuration(airpcap_if_selected);
 356                 /* Remove gtk timeout */
 357                 gtk_timeout_remove(airpcap_if_selected->tag);
 358         break;
 359     case(ESD_BTN_DONT_SAVE):
 360         /* exit without saving */
 361         break;
 362
 363     default:
 364                 break;
 365     }
 366 }
 367
 368 /*
 369  * Pop-up window, used to ask the user if he wants to save the selected interface settings
 370  * when changing the interface in the advanced dialog box
 371  */
 372 void
 373 airpcap_ask_for_save(GtkWidget *entry _U_, gpointer data)
 374 {
 375         GtkWidget* dialog;
 376
 377     dialog = simple_dialog(ESD_TYPE_CONFIRMATION, ESD_BTNS_SAVE_DONTSAVE_CANCEL,
 378                 PRIMARY_TEXT_START "Save settings before changing interface?" PRIMARY_TEXT_END "\n\n"
 379                 "If you change interface without saving, changes you made will\nbe discarded.");
 380     simple_dialog_set_cb(dialog, airpcap_dialog_save_cb, data);
 381
 382 }
 383
 384 /* user confirmed the "Save settings..." dialog */
 385 void
 386 airpcap_dialog_save_cb(GtkWidget* dialog _U_, gint btn, gpointer data)
 387 {
 388 GtkWidget* interface_combo;
 389 GtkWidget* key_ls;
 390
 391 /* I need the combo box entry */
 392 interface_combo         = GTK_WIDGET(OBJECT_GET_DATA(GTK_WIDGET(data),AIRPCAP_ADVANCED_INTERFACE_KEY));
 393 key_ls                          = GTK_WIDGET(OBJECT_GET_DATA(data,AIRPCAP_ADVANCED_KEYLIST_KEY));
 394
 395     switch(btn) {
 396     case(ESD_BTN_SAVE):
 397         /* save interface and change  */
 398                 airpcap_add_keys_from_list(key_ls,airpcap_if_selected);
 399                 airpcap_save_selected_if_configuration(airpcap_if_selected);
 400                 /* Remove gtk timeout */
 401                 gtk_timeout_remove(airpcap_if_selected->tag);
 402                 airpcap_change_if(GTK_COMBO(interface_combo)->entry,data);
 403         break;
 404     case(ESD_BTN_DONT_SAVE):
 405         /* change interface without saving */
 406                 airpcap_change_if(GTK_COMBO(interface_combo)->entry,data);
 407         break;
 408     case(ESD_BTN_CANCEL):
 409                 /* don't change interface and don't save */
 410         break;
 411     default:
 412                 break;
 413     }
 414 }
 415
 416 /*
 417  * Function used to change the selected interface and advanced dialog box
 418  */
 419 void
 420 airpcap_change_if(GtkWidget *entry _U_, gpointer data)
 421 {
 422   const gchar *s;
 423   gchar *channel_s;
 424   gchar *capture_s;
 425   GtkWidget *main_w;
 426
 427   GtkWidget *interface_combo;
 428   GtkWidget *channel_combo;
 429   GtkWidget *capture_combo;
 430   GtkWidget *crc_check;
 431   GtkWidget *wrong_crc_combo;
 432   GtkWidget *blink_bt;
 433   GtkWidget *key_ls;
 434
 435   airpcap_if_info_t *new_if;
 436
 437   /* Retrieve the GUI object pointers */
 438   main_w = GTK_WIDGET(data);
 439   interface_combo   = GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_INTERFACE_KEY));
 440   channel_combo         = GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_CHANNEL_KEY));
 441   capture_combo         = GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_LINK_TYPE_KEY));
 442   crc_check                     = GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_CRC_KEY));
 443   wrong_crc_combo       = GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_WRONG_CRC_KEY));
 444   blink_bt                      = GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_BLINK_KEY));
 445   key_ls                        = GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_KEYLIST_KEY));
 446
 447   s = gtk_entry_get_text(GTK_ENTRY(entry));
 448
 449   /* Select actual interface*/
 450   new_if = get_airpcap_if_from_description(airpcap_if_list, s);
 451
 452   /* And change the GUI according to it... */
 453   /* This should always happen, but it seems that the callback is
 454    * called twice, the first time with an 'empty' text... so it
 455    * will return NULL!
 456    */
 457   if(new_if != NULL)
 458         {
 459         airpcap_if_selected = new_if;
 460
 461         new_if = NULL;
 462         /* I need to 'block' signals to widgets or they will receive a signal now
 463            and will change twice */
 464         block_advanced_signals = TRUE;
 465
 466         /* Blink button */
 467         if(airpcap_if_selected->blinking)
 468                 {
 469                 #if GTK_MAJOR_VERSION >= 2
 470                 gtk_button_set_label(GTK_BUTTON(blink_bt),"Stop Blinking");
 471                 #else
 472                 gtk_label_set_text(GTK_LABEL(GTK_BIN(blink_bt)->child),"Stop Blinking");
 473                 #endif
 474                 }
 475         else
 476                 {
 477                 #if GTK_MAJOR_VERSION >= 2
 478                 gtk_button_set_label(GTK_BUTTON(blink_bt),"  Blink Led  ");
 479                 #else
 480                 gtk_label_set_text(GTK_LABEL(GTK_BIN(blink_bt)->child),"  Blink Led  ");
 481                 #endif
 482                 }
 483
 484         /* Channel combo */
 485         channel_s = g_strdup_printf("%d",airpcap_if_selected->channel);
 486         if(channel_combo != NULL) /* this event seems to happen when combo is still NULL */
 487                 gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(channel_combo)->entry), channel_s);
 488
 489         /* Link Layer combo */
 490         capture_s = NULL;
 491         if(airpcap_if_selected->linkType == AIRPCAP_LT_802_11)
 492                 {
 493                         capture_s = g_strdup_printf(AIRPCAP_LINK_TYPE_NAME_802_11_ONLY);
 494                         if(capture_combo != NULL) /* this event seems to happen when combo is still NULL */
 495                                 gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(capture_combo)->entry), capture_s);
 496                 }
 497         else if(airpcap_if_selected->linkType == AIRPCAP_LT_802_11_PLUS_RADIO)
 498                 {
 499                         capture_s = g_strdup_printf(AIRPCAP_LINK_TYPE_NAME_802_11_PLUS_RADIO);
 500                         if(capture_combo != NULL) /* this event seems to happen when combo is still NULL */
 501                                 gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(capture_combo)->entry), capture_s);
 502                 }
 503
 504         /* Fcs Presence check box */
 505         if(airpcap_if_selected->IsFcsPresent)
 506                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(crc_check),TRUE);
 507         else
 508                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(crc_check),FALSE);
 509
 510         /* Wrong Crc combo box */
 511         if(airpcap_if_selected->CrcValidationOn == AIRPCAP_VT_ACCEPT_EVERYTHING)
 512                 gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(wrong_crc_combo)->entry),AIRPCAP_VALIDATION_TYPE_NAME_ALL);
 513         else if(airpcap_if_selected->CrcValidationOn == AIRPCAP_VT_ACCEPT_CORRECT_FRAMES)
 514                 gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(wrong_crc_combo)->entry),AIRPCAP_VALIDATION_TYPE_NAME_CORRECT);
 515         else if(airpcap_if_selected->CrcValidationOn == AIRPCAP_VT_ACCEPT_CORRUPT_FRAMES)
 516                 gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(wrong_crc_combo)->entry),AIRPCAP_VALIDATION_TYPE_NAME_CORRUPT);
 517
 518         /* Remove old keys */
 519         gtk_list_remove_items(GTK_LIST(key_ls),GTK_LIST(key_ls)->children);
 520         /* Add new keys */
 521         airpcap_fill_key_list(key_ls,airpcap_if_selected);
 522
 523         /* Enable the signals again */
 524         block_advanced_signals = FALSE;
 525         }
 526 }
 527
 528 /*
 529  * Thread function used to blink the led
 530  */
 531 void update_blink(gpointer data _U_)
 532 {
 533 airpcap_if_info_t* sel;
 534 PAirpcapHandle ad;
 535 gchar ebuf[AIRPCAP_ERRBUF_SIZE];
 536
 537 sel = (airpcap_if_info_t*)data;
 538
 539 ad = airpcap_if_open(get_airpcap_name_from_description(airpcap_if_list, sel->description), ebuf);
 540 if(ad)
 541         {
 542         if(sel->led)
 543                 {
 544                 airpcap_if_turn_led_off(ad, 0);
 545                 sel->led = FALSE;
 546                 }
 547         else
 548                 {
 549                 airpcap_if_turn_led_on(ad, 0);
 550                 sel->led = TRUE;
 551                 }
 552         airpcap_if_close(ad);
 553         }
 554 }
 555
 556 /*
 557  * Blink button callback
 558  */
 559 void
 560 blink_cb( GtkWidget *blink_bt _U_, gpointer if_data )
 561 {
 562 PAirpcapHandle ad = NULL;
 563 gchar ebuf[AIRPCAP_ERRBUF_SIZE];
 564
 565 if(airpcap_if_selected != NULL)
 566         if(!(airpcap_if_selected->blinking))
 567                 {
 568                 #if GTK_MAJOR_VERSION >= 2
 569                 gtk_button_set_label(GTK_BUTTON(blink_bt),"Stop Blinking");
 570                 #else
 571                 gtk_label_set_text(GTK_LABEL(GTK_BIN(blink_bt)->child),"Stop Blinking");
 572                 #endif
 573                 airpcap_if_selected->tag = gtk_timeout_add(500, (GtkFunction)update_blink,airpcap_if_selected);
 574                 airpcap_if_selected->blinking = TRUE;
 575                 }
 576         else
 577                 {
 578                 #if GTK_MAJOR_VERSION >= 2
 579                 gtk_button_set_label(GTK_BUTTON(blink_bt),"  Blink Led  ");
 580                 #else
 581                 gtk_label_set_text(GTK_LABEL(GTK_BIN(blink_bt)->child),"  Blink Led  ");
 582                 #endif
 583                 gtk_timeout_remove(airpcap_if_selected->tag);
 584                 airpcap_if_selected->blinking = FALSE;
 585                 /* Switch on the led!  */
 586                 ad = airpcap_if_open(airpcap_if_selected->name, ebuf);
 587                 if(ad)
 588                         {
 589                         gtk_timeout_remove(airpcap_if_selected->tag);
 590                         airpcap_if_turn_led_on(ad, 0);
 591                         airpcap_if_selected->blinking = FALSE;
 592                         airpcap_if_selected->led = TRUE;
 593                         airpcap_if_close(ad);
 594                         }
 595                 }
 596 }
 597
 598 /* the window was closed, cleanup things */
 599 static void
 600 airpcap_if_destroy_cb(GtkWidget *w _U_, gpointer user_data _U_)
 601 {
 602         PAirpcapHandle ad = NULL;
 603         gchar ebuf[AIRPCAP_ERRBUF_SIZE];
 604
 605         /* Retrieve object data */
 606     GtkWidget *main_w;
 607     GtkWidget *channel_combo;
 608     GtkWidget *capture_combo;
 609     GtkWidget *crc_check;
 610     GtkWidget *wrong_crc_combo;
 611     GtkWidget *blink_bt;
 612         GtkWidget *interface_combo;
 613         GtkWidget *cancel_bt;
 614         GtkWidget *ok_bt;
 615         GtkWidget *key_ls;
 616
 617         /* widgets in the toolbar */
 618         GtkWidget       *toolbar,
 619                                 *toolbar_if_lb,
 620                                 *toolbar_channel_cm,
 621                                 *toolbar_wrong_crc_cm,
 622                                 *toolbar_decryption_ck,
 623                                 *advanced_bt;
 624
 625         gint *from_widget = NULL;
 626
 627     /* Retrieve the GUI object pointers */
 628     main_w = GTK_WIDGET(user_data);
 629         interface_combo         = GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_INTERFACE_KEY));
 630     channel_combo               = GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_CHANNEL_KEY));
 631     capture_combo               = GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_LINK_TYPE_KEY));
 632     crc_check                   = GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_CRC_KEY));
 633     wrong_crc_combo             = GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_WRONG_CRC_KEY));
 634     blink_bt                    = GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_BLINK_KEY));
 635         cancel_bt                       = GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_CANCEL_KEY));
 636         ok_bt                           = GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_OK_KEY));
 637         key_ls                          = GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_KEYLIST_KEY));
 638         advanced_bt                     = GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_KEY));
 639
 640         toolbar = GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_TOOLBAR_KEY));
 641
 642         /* retrieve toolbar info */
 643         toolbar_if_lb                   = GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_INTERFACE_KEY));
 644         toolbar_channel_cm              = GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_CHANNEL_KEY));
 645         toolbar_wrong_crc_cm    = GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_WRONG_CRC_KEY));
 646         toolbar_decryption_ck   = GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_DECRYPTION_KEY));
 647
 648         from_widget     = (gint*)OBJECT_GET_DATA(toolbar,AIRPCAP_ADVANCED_FROM_KEY);
 649
 650         /* ... */
 651         /* gray out the toolbar (if we came here from the toolbar advanced button)*/
 652         if( *from_widget == AIRPCAP_ADVANCED_FROM_TOOLBAR)
 653                 gtk_widget_set_sensitive(toolbar,TRUE);
 654
 655         /* Stop blinking ALL leds (go through the airpcap_if_list) */
 656         if(airpcap_if_selected != NULL)
 657         {
 658         ad = airpcap_if_open(airpcap_if_selected->name, ebuf);
 659         if(ad)
 660                 {
 661                 gtk_timeout_remove(airpcap_if_selected->tag);
 662                 airpcap_if_turn_led_on(ad, 0);
 663                 airpcap_if_selected->blinking = FALSE;
 664                 airpcap_if_selected->led = TRUE;
 665                 airpcap_if_close(ad);
 666                 }
 667         }
 668
 669         /* See if the 'Cancel' button was pressed or not
 670          * if button is pressed, don't save configuration!
 671          */
 672         if(GTK_BUTTON(cancel_bt)->in_button)
 673                 {
 674                 /* reload the configuration!!! Configuration has not been saved but
 675                    the corresponding structure has been modified probably...*/
 676                 if(!airpcap_if_selected->saved)
 677                         {
 678                         airpcap_load_selected_if_configuration(airpcap_if_selected);
 679                         }
 680
 681                 /* NULL to everything */
 682                 main_w = NULL;
 683                 blink_bt = NULL;
 684                 channel_combo = NULL;
 685                 interface_combo = NULL;
 686                 capture_combo = NULL;
 687                 crc_check = NULL;
 688                 wrong_crc_combo = NULL;
 689
 690                 /* ... */
 691                 /* gray out the toolbar (if we came here from the toolbar advanced button)*/
 692                 if( *from_widget == AIRPCAP_ADVANCED_FROM_TOOLBAR)
 693                         gtk_widget_set_sensitive(toolbar,TRUE);
 694
 695                 g_free(from_widget);
 696                 return;
 697                 }
 698         else if(GTK_BUTTON(ok_bt)->in_button)
 699                 {
 700
 701                 /* ??? - Ask if want to save configuration */
 702
 703                 /* Save the configuration */
 704                 airpcap_add_keys_from_list(key_ls,airpcap_if_selected);
 705                 airpcap_save_selected_if_configuration(airpcap_if_selected);
 706                 /* Remove gtk timeout */
 707                 gtk_timeout_remove(airpcap_if_selected->tag);
 708
 709                 /* Update toolbar (only if airpcap_if_selected is airpcap_if_active)*/
 710                 if( g_strcasecmp(airpcap_if_selected->description,airpcap_if_active->description) == 0)
 711                         {
 712                         gtk_label_set_text(GTK_LABEL(toolbar_if_lb), g_strdup_printf("%s %s\t","Current Wireless Interface: #",airpcap_get_if_string_number(airpcap_if_selected)));
 713
 714                         airpcap_update_channel_combo(GTK_WIDGET(toolbar_channel_cm),airpcap_if_selected);
 715
 716             airpcap_validation_type_combo_set_by_type(toolbar_wrong_crc_cm,airpcap_if_selected->CrcValidationOn);
 717
 718                         gtk_signal_handler_block_by_func (GTK_OBJECT(toolbar_decryption_ck),GTK_SIGNAL_FUNC(airpcap_toolbar_encryption_cb), toolbar);
 719                         if(airpcap_if_active->DecryptionOn == AIRPCAP_DECRYPTION_ON)
 720                                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toolbar_decryption_ck),TRUE);
 721                         else
 722                                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toolbar_decryption_ck),FALSE);
 723                         gtk_signal_handler_unblock_by_func (GTK_OBJECT(toolbar_decryption_ck),GTK_SIGNAL_FUNC(airpcap_toolbar_encryption_cb), toolbar);
 724                         }
 725
 726                 /* If interface active is airpcap, set sensitive TRUE for airpcap toolbar */
 727                 if( get_airpcap_if_by_name(airpcap_if_list,airpcap_if_active->description) != NULL)
 728                         {
 729                         airpcap_set_toolbar_start_capture(airpcap_if_active);
 730                         }
 731                 else
 732                         {
 733                         airpcap_set_toolbar_stop_capture(airpcap_if_active);
 734                         }
 735
 736                         /* NULL to everything */
 737                         main_w = NULL;
 738                         blink_bt = NULL;
 739                         channel_combo = NULL;
 740                         interface_combo = NULL;
 741                         capture_combo = NULL;
 742                         crc_check = NULL;
 743                         wrong_crc_combo = NULL;
 744
 745                                 /* ... */
 746                 /* gray out the toolbar (if we came here from the toolbar advanced button)*/
 747                 if( *from_widget == AIRPCAP_ADVANCED_FROM_OPTIONS)
 748                         gtk_widget_set_sensitive(toolbar,FALSE);
 749
 750                 g_free(from_widget);
 751                 return;
 752                 }
 753
 754                 /* reload the configuration!!! Configuration has not been saved but
 755            the corresponding structure has been modified probably...*/
 756         if(!airpcap_if_selected->saved)
 757                 {
 758                 airpcap_load_selected_if_configuration(airpcap_if_selected);
 759                 }
 760 }
 761
 762 /*
 763  * Callback for the 'Apply' button.
 764  */
 765 static void
 766 airpcap_advanced_apply_cb(GtkWidget *button, gpointer data _U_)
 767 {
 768         /* advenced window */
 769         GtkWidget       *main_w;
 770
 771         /* widgets in the toolbar */
 772         GtkWidget       *toolbar,
 773                                 *toolbar_if_lb,
 774                                 *toolbar_channel_cm,
 775                                 *toolbar_wrong_crc_cm,
 776                                 *toolbar_decryption_ck;
 777
 778         GtkWidget   *key_ls;
 779
 780         /* retrieve main window */
 781         main_w = GTK_WIDGET(data);
 782         key_ls  = GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_KEYLIST_KEY));
 783
 784         toolbar = GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_TOOLBAR_KEY));
 785
 786         /* retrieve toolbar info */
 787         toolbar_if_lb                   = GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_INTERFACE_KEY));
 788         toolbar_channel_cm              = GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_CHANNEL_KEY));
 789         toolbar_wrong_crc_cm    = GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_WRONG_CRC_KEY));
 790         toolbar_decryption_ck   = GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_DECRYPTION_KEY));
 791
 792         /* Save the configuration */
 793         airpcap_add_keys_from_list(key_ls,airpcap_if_selected);
 794         airpcap_save_selected_if_configuration(airpcap_if_selected);
 795
 796         /* Update toolbar (only if airpcap_if_selected is airpcap_if_active)*/
 797         if( g_strcasecmp(airpcap_if_selected->description,airpcap_if_active->description) == 0)
 798                 {
 799                 gtk_label_set_text(GTK_LABEL(toolbar_if_lb), g_strdup_printf("%s %s\t","Current Wireless Interface: #",airpcap_get_if_string_number(airpcap_if_selected)));
 800                 airpcap_update_channel_combo(GTK_WIDGET(toolbar_channel_cm),airpcap_if_selected);
 801                 airpcap_validation_type_combo_set_by_type(toolbar_wrong_crc_cm,airpcap_if_selected->CrcValidationOn);
 802
 803         gtk_signal_handler_block_by_func (GTK_OBJECT(toolbar_decryption_ck),GTK_SIGNAL_FUNC(airpcap_toolbar_encryption_cb), toolbar);
 804                 if(airpcap_if_active->DecryptionOn == AIRPCAP_DECRYPTION_ON)
 805                         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toolbar_decryption_ck),TRUE);
 806                 else
 807                         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toolbar_decryption_ck),FALSE);
 808                 gtk_signal_handler_unblock_by_func (GTK_OBJECT(toolbar_decryption_ck),GTK_SIGNAL_FUNC(airpcap_toolbar_encryption_cb), toolbar);
 809                 }
 810 }
 811
 812 /*
 813  * Callback for the 'Ok' button.
 814  */
 815 static void
 816 airpcap_advanced_ok_cb(GtkWidget *w, gpointer data _U_)
 817 {
 818         /* advenced window */
 819         GtkWidget       *main_w;
 820
 821         /* widgets in the toolbar */
 822         GtkWidget       *toolbar,
 823                                 *toolbar_if_lb,
 824                                 *toolbar_channel_cm,
 825                                 *toolbar_wrong_crc_cm,
 826                                 *toolbar_decryption_ck;
 827
 828         GtkWidget       *key_ls;
 829
 830         /* retrieve main window */
 831         main_w = GTK_WIDGET(data);
 832
 833         toolbar = GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_TOOLBAR_KEY));
 834
 835         key_ls  = GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_KEYLIST_KEY));
 836
 837         /* retrieve toolbar info */
 838         toolbar_if_lb                   = GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_INTERFACE_KEY));
 839         toolbar_channel_cm              = GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_CHANNEL_KEY));
 840         toolbar_wrong_crc_cm    = GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_WRONG_CRC_KEY));
 841         toolbar_decryption_ck   = GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_DECRYPTION_KEY));
 842
 843         /* Save the configuration */
 844         airpcap_add_keys_from_list(key_ls,airpcap_if_selected);
 845         airpcap_save_selected_if_configuration(airpcap_if_selected);
 846         /* Remove gtk timeout */
 847         gtk_timeout_remove(airpcap_if_selected->tag);
 848
 849         /* Update toolbar (only if airpcap_if_selected is airpcap_if_active)*/
 850         if( g_strcasecmp(airpcap_if_selected->description,airpcap_if_active->description) == 0)
 851                 {
 852                 gtk_label_set_text(GTK_LABEL(toolbar_if_lb), g_strdup_printf("%s %s\t","Current Wireless Interface: #",airpcap_get_if_string_number(airpcap_if_selected)));
 853                 airpcap_update_channel_combo(GTK_WIDGET(toolbar_channel_cm),airpcap_if_selected);
 854                 airpcap_validation_type_combo_set_by_type(toolbar_wrong_crc_cm,airpcap_if_selected->CrcValidationOn);
 855
 856         gtk_signal_handler_block_by_func (GTK_OBJECT(toolbar_decryption_ck),GTK_SIGNAL_FUNC(airpcap_toolbar_encryption_cb), toolbar);
 857                 if(airpcap_if_active->DecryptionOn == AIRPCAP_DECRYPTION_ON)
 858                         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toolbar_decryption_ck),TRUE);
 859                 else
 860                         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toolbar_decryption_ck),FALSE);
 861                 gtk_signal_handler_unblock_by_func (GTK_OBJECT(toolbar_decryption_ck),GTK_SIGNAL_FUNC(airpcap_toolbar_encryption_cb), toolbar);
 862                 }
 863 }
 864
 865 /*
 866  * Callback for the 'Reset Configuration' button.
 867  */
 868 static void
 869 airpcap_advanced_reset_configuration_cb(GtkWidget *button, gpointer data _U_)
 870 {
 871
 872 }
 873
 874 /*
 875  * Callback for the 'About' button.
 876  */
 877 static void
 878 airpcap_advanced_about_cb(GtkWidget *button, gpointer data _U_)
 879 {
 880         /* retrieve toolbar info */
 881 }
 882
 883 /*
 884  * Callback used to add a WEP key in the add new key box;
 885  */
 886 static void
 887 add_key(GtkWidget *widget, gpointer data _U_)
 888 {
 889 GtkWidget       *text,
 890                         *key_ls,
 891                         *ok_bt;
 892
 893 GString         *new_key;
 894
 895 gchar           *text_entered = NULL;
 896
 897 int keys_in_list = 0;
 898 unsigned int i;
 899
 900 text    = OBJECT_GET_DATA(GTK_WIDGET(data),AIRPCAP_ADVANCED_ADD_KEY_TEXT_KEY);
 901 ok_bt   = OBJECT_GET_DATA(GTK_WIDGET(data),AIRPCAP_ADVANCED_ADD_KEY_OK_KEY);
 902 key_ls  = OBJECT_GET_DATA(GTK_WIDGET(data),AIRPCAP_ADVANCED_KEYLIST_KEY);
 903
 904 keys_in_list = g_list_length(GTK_LIST(key_ls)->children);
 905 text_entered = g_strdup(gtk_entry_get_text(GTK_ENTRY(text)));
 906
 907 /* Too many keys? */
 908 if(keys_in_list == MAX_ENCRYPTION_KEYS)
 909         {
 910         simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"%s","Reached the Wep Keys Limit for this Interface.");
 911         return;
 912         }
 913
 914 /* Check if key is correct */
 915 new_key = g_string_new(text_entered);
 916
 917 g_strchug(new_key->str);
 918 g_strchomp(new_key->str);
 919
 920 if((new_key->len) > WEP_KEY_MAX_CHAR_SIZE)
 921         {
 922         simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"WEP key size out of range!\nValid key size range is 2-%d characters (8-%d bits).",WEP_KEY_MAX_CHAR_SIZE,WEP_KEY_MAX_SIZE*8);
 923     return;
 924         }
 925
 926 if((new_key->len % 2) != 0)
 927         {
 928         simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"Wrong WEP key!\nThe number of characters must be even.");
 929         return;
 930         }
 931
 932 for(i = 0; i < new_key->len; i++)
 933         {
 934         if(!g_ascii_isxdigit(new_key->str[i]))
 935                 {
 936                 simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"Wrong WEP key!\nA WEP key must be an hexadecimal number.\nThe valid characters are: 0123456789ABCDEF.");
 937                 return;
 938                 }
 939         }
 940
 941 /* If so... Add key */
 942 airpcap_add_key_to_list(key_ls,new_key->str);
 943
 944 airpcap_if_selected->saved = FALSE;
 945
 946 g_string_free(new_key,TRUE);
 947 g_free(text_entered);
 948
 949 window_destroy(GTK_WIDGET(data));
 950
 951 return;
 952 }
 953
 954 /*
 955  * Callback used to add a WEP key in the edit key box;
 956  */
 957 static void
 958 edit_key(GtkWidget *widget, gpointer data _U_)
 959 {
 960 GtkWidget       *text,
 961                         *key_ls,
 962                         *ok_bt;
 963
 964 GString         *new_key;
 965
 966 gchar           *text_entered = NULL;
 967
 968 GtkWidget       *label;
 969
 970
 971 int keys_in_list = 0;
 972 unsigned int i;
 973
 974 text    = OBJECT_GET_DATA(GTK_WIDGET(data),AIRPCAP_ADVANCED_EDIT_KEY_TEXT_KEY);
 975 ok_bt   = OBJECT_GET_DATA(GTK_WIDGET(data),AIRPCAP_ADVANCED_EDIT_KEY_OK_KEY);
 976 key_ls  = OBJECT_GET_DATA(GTK_WIDGET(data),AIRPCAP_ADVANCED_KEYLIST_KEY);
 977 label   = OBJECT_GET_DATA(GTK_WIDGET(data),AIRPCAP_ADVANCED_EDIT_KEY_LABEL_KEY);
 978
 979 keys_in_list = g_list_length(GTK_LIST(key_ls)->children);
 980 text_entered = g_strdup(gtk_entry_get_text(GTK_ENTRY(text)));
 981
 982 /* Check if key is correct */
 983 new_key = g_string_new(text_entered);
 984
 985 g_strchug(new_key->str);
 986 g_strchomp(new_key->str);
 987
 988 if((new_key->len) > WEP_KEY_MAX_CHAR_SIZE)
 989         {
 990         simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"WEP key size out of range!\nValid key size range is 2-%d characters (8-%d bits).",WEP_KEY_MAX_CHAR_SIZE,WEP_KEY_MAX_SIZE*8);
 991     return;
 992         }
 993
 994 if((new_key->len % 2) != 0)
 995         {
 996         simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"Wrong WEP key!\nThe number of characters must be even.");
 997         return;
 998         }
 999
1000 for(i = 0; i < new_key->len; i++)
1001         {
1002         if(!g_ascii_isxdigit(new_key->str[i]))
1003                 {
1004                 simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"Wrong WEP key!\nA WEP key must be an hexadecimal number.\nThe valid characters are: 0123456789ABCDEF.");
1005                 return;
1006                 }
1007         }
1008
1009 /* If so... modify key */
1010 gtk_label_set_text(GTK_LABEL(label),new_key->str);
1011
1012 airpcap_if_selected->saved = FALSE;
1013
1014 g_string_free(new_key,TRUE);
1015 g_free(text_entered);
1016
1017 window_destroy(GTK_WIDGET(data));
1018 return;
1019 }
1020
1021 /*
1022  * Callback for the 'Add Key' button.
1023  */
1024 static void
1025 airpcap_advanced_add_key_cb(GtkWidget *button, gpointer data _U_)
1026 {
1027 /* Window */
1028 GtkWidget       *add_key_w;
1029
1030 /*  Frame */
1031 GtkWidget       *add_key_frame;
1032
1033 /* Boxes */
1034 GtkWidget       *main_box,      /* vertical */
1035                         *key_box,       /* orizontal */
1036                         *text_box,  /* orizontal */
1037                         *button_box;/* orizontal (packed to end)*/
1038
1039 /* Text Entry */
1040 GtkWidget       *key_text_entry;
1041
1042 /* Buttons */
1043 GtkWidget       *key_ok_bt,
1044                         *key_cancel_bt;
1045
1046 /* Key List Widget */
1047 GtkWidget       *key_ls;
1048
1049         /* Pop-up a new window */
1050         add_key_w = window_new (GTK_WINDOW_TOPLEVEL,"Add a WEP Key");
1051
1052         /* Connect events */
1053     SIGNAL_CONNECT(add_key_w, "delete_event",window_delete_event_cb, add_key_w);
1054     SIGNAL_CONNECT(add_key_w, "destroy",add_key_w_destroy_cb, add_key_w);
1055
1056         /* Sets the border width of the window. */
1057         gtk_container_set_border_width (GTK_CONTAINER (add_key_w), 5);
1058
1059         /* Retrieve the key list widget pointer, and add it to the add_key_w */
1060         key_ls = OBJECT_GET_DATA(GTK_WIDGET(data),AIRPCAP_ADVANCED_KEYLIST_KEY);
1061         OBJECT_SET_DATA(GTK_WIDGET(add_key_w),AIRPCAP_ADVANCED_KEYLIST_KEY,key_ls);
1062         OBJECT_SET_DATA(GTK_WIDGET(add_key_w),AIRPCAP_ADVANCED_KEY,data);
1063
1064         /* Create boxes */
1065         main_box = gtk_vbox_new(FALSE,1);
1066         key_box = gtk_hbox_new(FALSE,1);
1067         button_box = gtk_hbox_new(FALSE,1);
1068         text_box = gtk_hbox_new(TRUE,1);
1069
1070         /* Add the two sub boxes to the main box */
1071         gtk_box_pack_start(GTK_BOX(main_box), key_box, FALSE, FALSE, 1);
1072         gtk_box_pack_start(GTK_BOX(main_box), button_box, FALSE, FALSE, 1);
1073
1074         /* Add the main box to the main window */
1075         gtk_container_add(GTK_CONTAINER(add_key_w),main_box);
1076
1077         /* Crete key frame */
1078         add_key_frame = gtk_frame_new("");
1079         gtk_frame_set_label(GTK_FRAME(add_key_frame),"Key");
1080         #if GTK_MAJOR_VERSION < 2
1081         gtk_widget_set_usize( GTK_WIDGET(add_key_frame),
1082                                   200,
1083                                   -1 );
1084         #else
1085         gtk_widget_set_size_request( GTK_WIDGET(add_key_frame),
1086                                   200,
1087                                   -1 );
1088     #endif
1089
1090         gtk_box_pack_start(GTK_BOX(key_box), add_key_frame, FALSE, FALSE, 1);
1091
1092         /* Create and Add text entry*/
1093         key_text_entry = gtk_entry_new();
1094         OBJECT_SET_DATA(add_key_w, AIRPCAP_ADVANCED_ADD_KEY_TEXT_KEY, key_text_entry);
1095         SIGNAL_CONNECT(key_text_entry, "activate", add_key, add_key_w );
1096         gtk_box_pack_start(GTK_BOX(text_box), key_text_entry, FALSE, FALSE, 1);
1097         gtk_container_add(GTK_CONTAINER(add_key_frame),text_box);
1098         gtk_container_set_border_width (GTK_CONTAINER (text_box), 5);
1099
1100         /* Create and add buttons */
1101         key_ok_bt = gtk_button_new_with_label("OK");
1102         SIGNAL_CONNECT(key_ok_bt, "clicked", add_key, add_key_w );
1103         OBJECT_SET_DATA(add_key_w, AIRPCAP_ADVANCED_ADD_KEY_OK_KEY, key_ok_bt);
1104                 #if GTK_MAJOR_VERSION < 2
1105         gtk_widget_set_usize( GTK_WIDGET(key_ok_bt),
1106                                   50,
1107                                   -1 );
1108         #else
1109         gtk_widget_set_size_request( GTK_WIDGET(key_ok_bt),
1110                                   50,
1111                                   -1 );
1112     #endif
1113         key_cancel_bt = gtk_button_new_with_label("Cancel");
1114         SIGNAL_CONNECT(key_cancel_bt, "clicked", window_cancel_button_cb, add_key_w );
1115                 #if GTK_MAJOR_VERSION < 2
1116         gtk_widget_set_usize( GTK_WIDGET(key_cancel_bt),
1117                                   50,
1118                                   -1 );
1119         #else
1120         gtk_widget_set_size_request( GTK_WIDGET(key_cancel_bt),
1121                                   50,
1122                                   -1 );
1123     #endif
1124
1125         gtk_box_pack_end(GTK_BOX(button_box), key_cancel_bt, FALSE, FALSE, 1);
1126         gtk_box_pack_end(GTK_BOX(button_box), key_ok_bt, FALSE, FALSE, 1);
1127
1128         /* Show all */
1129         gtk_widget_show(key_ok_bt);
1130         gtk_widget_show(key_cancel_bt);
1131         gtk_widget_show(key_text_entry);
1132         gtk_widget_show(add_key_frame);
1133         gtk_widget_show(text_box);
1134         gtk_widget_show(button_box);
1135         gtk_widget_show(key_box);
1136         gtk_widget_show(main_box);
1137         gtk_widget_show(add_key_w);
1138 }
1139
1140 /*
1141  * Add key window destroy callback
1142  */
1143 static void
1144 add_key_w_destroy_cb(GtkWidget *button, gpointer data _U_)
1145 {
1146 return;
1147 }
1148
1149 /*
1150  * Edit key window destroy callback
1151  */
1152 static void
1153 edit_key_w_destroy_cb(GtkWidget *button, gpointer data _U_)
1154 {
1155 return;
1156 }
1157
1158 /*
1159  * Callback for the 'Remove Key' button.
1160  */
1161 static void
1162 airpcap_advanced_remove_key_cb(GtkWidget *button, gpointer data _U_)
1163 {
1164 GtkList *key_ls;
1165 GtkWidget *label;
1166 GList *item = NULL;
1167 gint n;
1168
1169 /* retrieve key list */
1170 key_ls = GTK_LIST(data);
1171
1172 /* Remove selected keys*/
1173 if(key_ls->selection != NULL)
1174         {
1175         item = g_list_nth(key_ls->selection,0);
1176         if(item != NULL)
1177                 {
1178                 n = gtk_list_child_position(key_ls,item->data);
1179                 label = GTK_BIN(item->data)->child;
1180                 gtk_list_clear_items(key_ls,n,n+1);
1181                 }
1182         }
1183
1184 /* Need to save config... */
1185 airpcap_if_selected->saved = FALSE;
1186 }
1187
1188 /*
1189  * Callback for the 'Edit Key' button.
1190  */
1191 static void
1192 airpcap_advanced_edit_key_cb(GtkWidget *button, gpointer data _U_)
1193 {
1194 /* Window */
1195 GtkWidget       *edit_key_w;
1196
1197 /*  Frame */
1198 GtkWidget       *edit_key_frame;
1199
1200 /* Boxes */
1201 GtkWidget       *main_box,      /* vertical */
1202                         *key_box,       /* orizontal */
1203                         *text_box,  /* orizontal */
1204                         *button_box;/* orizontal (packed to end)*/
1205
1206 /* Text Entry */
1207 GtkWidget       *key_text_entry;
1208
1209 /* Buttons */
1210 GtkWidget       *key_ok_bt,
1211                         *key_cancel_bt;
1212
1213 /* Key List Widget */
1214 GtkWidget       *key_ls;
1215
1216 GtkWidget *label;
1217 GList *item = NULL;
1218 gint n;
1219
1220 /* Retrieve the key list widget pointer, and add it to the edit_key_w */
1221 key_ls = OBJECT_GET_DATA(GTK_WIDGET(data),AIRPCAP_ADVANCED_KEYLIST_KEY);
1222
1223 /*
1224  * Check if a key has been selected. If not, just do nothing.
1225  */
1226 if(GTK_LIST(key_ls)->selection != NULL)
1227     {
1228     item = g_list_nth(GTK_LIST(key_ls)->selection,0);
1229     if(item != NULL)
1230         {
1231         /* Pop-up a new window */
1232         edit_key_w = window_new (GTK_WINDOW_TOPLEVEL,"Edit a WEP Key");
1233
1234         /* Connect events */
1235         SIGNAL_CONNECT(edit_key_w, "delete_event",window_delete_event_cb, edit_key_w);
1236         SIGNAL_CONNECT(edit_key_w, "destroy",edit_key_w_destroy_cb, edit_key_w);
1237
1238         /* Sets the border width of the window. */
1239         gtk_container_set_border_width (GTK_CONTAINER (edit_key_w), 5);
1240
1241         OBJECT_SET_DATA(GTK_WIDGET(edit_key_w),AIRPCAP_ADVANCED_KEYLIST_KEY,key_ls);
1242         OBJECT_SET_DATA(GTK_WIDGET(edit_key_w),AIRPCAP_ADVANCED_KEY,data);
1243
1244         /* Create boxes */
1245         main_box = gtk_vbox_new(FALSE,1);
1246         key_box = gtk_hbox_new(FALSE,1);
1247         button_box = gtk_hbox_new(FALSE,1);
1248         text_box = gtk_hbox_new(TRUE,1);
1249
1250         /* Add the two sub boxes to the main box */
1251         gtk_box_pack_start(GTK_BOX(main_box), key_box, FALSE, FALSE, 1);
1252         gtk_box_pack_start(GTK_BOX(main_box), button_box, FALSE, FALSE, 1);
1253
1254         /* Add the main box to the main window */
1255         gtk_container_add(GTK_CONTAINER(edit_key_w),main_box);
1256
1257         /* Crete key frame */
1258         edit_key_frame = gtk_frame_new("");
1259         gtk_frame_set_label(GTK_FRAME(edit_key_frame),"Key");
1260         #if GTK_MAJOR_VERSION < 2
1261         gtk_widget_set_usize( GTK_WIDGET(edit_key_frame),
1262                                       200,
1263                                       -1 );
1264         #else
1265         gtk_widget_set_size_request( GTK_WIDGET(edit_key_frame),
1266                                       200,
1267                                       -1 );
1268         #endif
1269
1270         gtk_box_pack_start(GTK_BOX(key_box), edit_key_frame, FALSE, FALSE, 1);
1271
1272         /* Create and Add text entry*/
1273         key_text_entry = gtk_entry_new();
1274         /* Retrieve the currently selected entry */
1275         if(GTK_LIST(key_ls)->selection != NULL)
1276                 {
1277                 item = g_list_nth(GTK_LIST(key_ls)->selection,0);
1278                 if(item != NULL)
1279                         {
1280                         n = gtk_list_child_position(GTK_LIST(key_ls),item->data);
1281                         label = GTK_BIN(item->data)->child;
1282                         /* Pass the pointer as data */
1283                         OBJECT_SET_DATA(edit_key_w,AIRPCAP_ADVANCED_EDIT_KEY_LABEL_KEY,label);
1284                         }
1285                 }
1286         gtk_entry_set_text(GTK_ENTRY(key_text_entry),GTK_LABEL(label)->label);
1287         OBJECT_SET_DATA(edit_key_w, AIRPCAP_ADVANCED_EDIT_KEY_TEXT_KEY, key_text_entry);
1288         SIGNAL_CONNECT(key_text_entry, "activate", edit_key, edit_key_w );
1289         gtk_box_pack_start(GTK_BOX(text_box), key_text_entry, FALSE, FALSE, 1);
1290         gtk_container_add(GTK_CONTAINER(edit_key_frame),text_box);
1291         gtk_container_set_border_width (GTK_CONTAINER (text_box), 5);
1292
1293         /* Create and add buttons */
1294         key_ok_bt = gtk_button_new_with_label("OK");
1295         SIGNAL_CONNECT(key_ok_bt, "clicked", edit_key, edit_key_w );
1296         OBJECT_SET_DATA(edit_key_w, AIRPCAP_ADVANCED_EDIT_KEY_OK_KEY, key_ok_bt);
1297                 #if GTK_MAJOR_VERSION < 2
1298         gtk_widget_set_usize( GTK_WIDGET(key_ok_bt),
1299                                       50,
1300                                       -1 );
1301         #else
1302         gtk_widget_set_size_request( GTK_WIDGET(key_ok_bt),
1303                                       50,
1304                                       -1 );
1305         #endif
1306         key_cancel_bt = gtk_button_new_with_label("Cancel");
1307         SIGNAL_CONNECT(key_cancel_bt, "clicked", window_cancel_button_cb, edit_key_w );
1308                 #if GTK_MAJOR_VERSION < 2
1309         gtk_widget_set_usize( GTK_WIDGET(key_cancel_bt),
1310                                       50,
1311                                       -1 );
1312         #else
1313         gtk_widget_set_size_request( GTK_WIDGET(key_cancel_bt),
1314                                       50,
1315                                       -1 );
1316         #endif
1317
1318         gtk_box_pack_end(GTK_BOX(button_box), key_cancel_bt, FALSE, FALSE, 1);
1319         gtk_box_pack_end(GTK_BOX(button_box), key_ok_bt, FALSE, FALSE, 1);
1320
1321         /* Show all */
1322         gtk_widget_show(key_ok_bt);
1323         gtk_widget_show(key_cancel_bt);
1324         gtk_widget_show(key_text_entry);
1325         gtk_widget_show(edit_key_frame);
1326         gtk_widget_show(text_box);
1327         gtk_widget_show(button_box);
1328         gtk_widget_show(key_box);
1329         gtk_widget_show(main_box);
1330         gtk_widget_show(edit_key_w);
1331         }
1332     }
1333 }
1334
1335 /*
1336  * Callback for the 'Move Key Up' button.
1337  */
1338 static void
1339 airpcap_advanced_move_key_up_cb(GtkWidget *button, gpointer data _U_)
1340 {
1341 GtkList *key_ls;
1342 GtkWidget *label,*nl_lb,*nl_item;
1343 GList *new_list = NULL;
1344 GList *item = NULL;
1345 gint n;
1346
1347 /* retrieve key list */
1348 key_ls = GTK_LIST(data);
1349
1350 /* Remove selected keys*/
1351 if(key_ls->selection != NULL)
1352         {
1353         item = g_list_nth(key_ls->selection,0);
1354         if(item != NULL)
1355                 {
1356                 n = gtk_list_child_position(key_ls,item->data);
1357                 if(n>0)
1358                         {
1359                         label = GTK_BIN(item->data)->child;
1360                         nl_lb = gtk_label_new(GTK_LABEL(label)->label);
1361                         gtk_list_clear_items(key_ls,n,n+1);
1362                         nl_item = gtk_list_item_new();
1363                         gtk_misc_set_alignment (GTK_MISC (nl_lb), 0.0, 0.5);
1364                         gtk_container_add(GTK_CONTAINER(nl_item), nl_lb);
1365                         gtk_widget_show(nl_lb);
1366                         gtk_widget_show(nl_item);
1367                         new_list = g_list_append(new_list,nl_item);
1368                         gtk_list_insert_items(key_ls,new_list,n-1);
1369                         gtk_list_select_item(key_ls,n-1);
1370                         }
1371                 }
1372         }
1373
1374 /* Need to save config... */
1375 airpcap_if_selected->saved = FALSE;
1376 }
1377
1378 /*
1379  * Callback for the 'Move Key Down' button.
1380  */
1381 static void
1382 airpcap_advanced_move_key_down_cb(GtkWidget *button, gpointer data _U_)
1383 {
1384 GtkList *key_ls;
1385 GtkWidget *label,*nl_lb,*nl_item;
1386 GList *new_list = NULL;
1387 GList *item = NULL;
1388 unsigned int n;
1389
1390 /* retrieve key list */
1391 key_ls = GTK_LIST(data);
1392
1393 /* Remove selected keys*/
1394 if(key_ls->selection != NULL)
1395         {
1396         item = g_list_nth(key_ls->selection,0);
1397         if(item != NULL)
1398                 {
1399                 n = gtk_list_child_position(key_ls,item->data);
1400                 if(n< (g_list_length(key_ls->children)-1))
1401                         {
1402                         label = GTK_BIN(item->data)->child;
1403                         nl_lb = gtk_label_new(GTK_LABEL(label)->label);
1404                         gtk_list_clear_items(key_ls,n,n+1);
1405
1406                         nl_item = gtk_list_item_new();
1407                         gtk_misc_set_alignment (GTK_MISC (nl_lb), 0.0, 0.5);
1408                         gtk_container_add(GTK_CONTAINER(nl_item), nl_lb);
1409                         gtk_widget_show(nl_lb);
1410                         gtk_widget_show(nl_item);
1411
1412                         new_list = g_list_append(new_list,nl_item);
1413                         gtk_list_insert_items(key_ls,new_list,n+1);
1414                         gtk_list_select_item(key_ls,n+1);
1415                         }
1416                 }
1417         }
1418
1419 /* Need to save config... */
1420 airpcap_if_selected->saved = FALSE;
1421 }
1422
1423 /* Turns the decryption on or off */
1424 static void
1425 wep_encryption_check_cb(GtkWidget *w, gpointer data)
1426 {
1427 if( !block_advanced_signals && (airpcap_if_selected != NULL))
1428         {
1429         if(airpcap_if_selected->DecryptionOn == AIRPCAP_DECRYPTION_ON)
1430                 {
1431                 airpcap_if_selected->DecryptionOn = AIRPCAP_DECRYPTION_OFF;
1432                 airpcap_if_selected->saved = FALSE;
1433                 }
1434         else
1435                 {
1436                 airpcap_if_selected->DecryptionOn = AIRPCAP_DECRYPTION_ON;
1437                 airpcap_if_selected->saved = FALSE;
1438                 }
1439         }
1440 }
1441
1442 /* Called to create the airpcap settings' window */
1443 void
1444 display_airpcap_advanced_cb(GtkWidget *w, gpointer data)
1445 {
1446         /* Main window */
1447         GtkWidget   *airpcap_advanced_w;
1448
1449         /* Blink button */
1450         GtkWidget       *blink_bt,
1451                                 *channel_combo;
1452         /* Combos */
1453         GtkWidget       *interface_combo,
1454                                 *capture_combo;
1455
1456         /* check */
1457         GtkWidget   *wrong_crc_combo;
1458
1459         /* key list*/
1460         GtkWidget   *key_ls;
1461
1462         /* frames */
1463         GtkWidget   *interface_frame,
1464                                 *basic_frame,
1465                                 *wep_frame;
1466         /* boxes */
1467         GtkWidget       *main_box,
1468                                 *buttons_box_1,
1469                                 *buttons_box_2,
1470                                 *interface_box,
1471                                 *basic_box,
1472                                 *basic_combo_box,
1473                                 *basic_check_box,
1474                                 *basic_label_box,
1475                                 *basic_wrong_box,
1476                                 *wep_box,
1477                                 *wep_sub_box,
1478                                 *encryption_box,
1479                                 *wep_buttons_box;
1480         /* buttons */
1481         /* blink button is global */
1482         GtkWidget       *add_new_key_bt,
1483                                 *remove_key_bt,
1484                                 *edit_key_bt,
1485                                 *move_key_up_bt,
1486                                 *move_key_down_bt,
1487                                 *reset_configuration_bt,
1488                                 *about_bt,
1489                                 *apply_bt,
1490                                 *ok_bt,
1491                                 *cancel_bt;
1492         /* combo */
1493
1494         /* shortcut to combo entry */
1495         GtkWidget       *link_type_te,
1496                                 *wrong_crc_te,
1497                                 *channel_te;
1498         /* check */
1499         /* global check buttons */
1500         GtkWidget   *crc_check,
1501                                 *encryption_check;
1502         /* label */
1503         GtkWidget       *channel_lb,
1504                                 *wrong_lb,
1505                                 *capture_lb;
1506         /* text field */
1507         GtkWidget   *key_text;
1508
1509         /* widgets in the toolbar */
1510         GtkWidget       *toolbar,
1511                                 *toolbar_if_lb,
1512                                 *toolbar_channel_cm,
1513                                 *toolbar_wrong_crc_cm;
1514
1515         /* other stuff */
1516         GList                           *channel_list,*capture_list;
1517         GList                           *linktype_list = NULL;
1518         gchar                           *capture_s;
1519
1520
1521         /* user data - RETRIEVE pointers of toolbar widgets */
1522         toolbar                         = GTK_WIDGET(data);
1523     toolbar_if_lb               = GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_INTERFACE_KEY));
1524     toolbar_channel_cm  = GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_CHANNEL_KEY));
1525     toolbar_wrong_crc_cm= GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_WRONG_CRC_KEY));
1526
1527         /* gray out the toolbar */
1528         gtk_widget_set_sensitive(toolbar,FALSE);
1529
1530         /* main window */
1531         /* global */
1532
1533         /* NULL to global widgets */
1534         blink_bt = NULL;
1535         channel_combo = NULL;
1536         block_advanced_signals = FALSE;
1537
1538         /* the selected is the active, for now */
1539         airpcap_if_selected = airpcap_if_active;
1540
1541         /* Create the new window */
1542         airpcap_advanced_w = window_new(GTK_WINDOW_TOPLEVEL, "Advanced Wireless Settings");
1543
1544         /*
1545          * I will need the toolbar and the main widget in some callback,
1546          * so I will add the toolbar pointer to the airpcap_advanced_w
1547          */
1548         OBJECT_SET_DATA(airpcap_advanced_w,AIRPCAP_TOOLBAR_KEY,toolbar);
1549
1550         /* Connect the callbacks */
1551         SIGNAL_CONNECT(airpcap_advanced_w, "delete_event", window_delete_event_cb, airpcap_advanced_w);
1552     SIGNAL_CONNECT(airpcap_advanced_w, "destroy", airpcap_if_destroy_cb, airpcap_advanced_w);
1553
1554         /* Set the size */
1555         /* Sets the border width of the window. */
1556         gtk_container_set_border_width (GTK_CONTAINER (airpcap_advanced_w), 10);
1557
1558         /* Create the main box */
1559         main_box = gtk_vbox_new(FALSE,0);
1560
1561         /* Create the button boxes */
1562         buttons_box_1 = gtk_hbox_new(FALSE,0);
1563         buttons_box_2 = gtk_hbox_new(FALSE,0);
1564
1565         /* Create the buttons for box 1 */
1566         reset_configuration_bt = gtk_button_new_with_label("Reset Configuration");
1567         SIGNAL_CONNECT(reset_configuration_bt, "clicked", airpcap_advanced_reset_configuration_cb, toolbar);
1568         gtk_widget_show(reset_configuration_bt);
1569
1570         about_bt = gtk_button_new_with_label("About");
1571         SIGNAL_CONNECT(about_bt, "clicked", airpcap_advanced_about_cb, toolbar);
1572         gtk_widget_show(about_bt);
1573
1574         /* Add them to box 1 */
1575         gtk_box_pack_start (GTK_BOX (buttons_box_1), reset_configuration_bt, FALSE, FALSE, 1);
1576         gtk_box_pack_start (GTK_BOX (buttons_box_1), about_bt, FALSE, FALSE, 1);
1577
1578     /* Create the buttons for box 2 */
1579         apply_bt = gtk_button_new_with_label("Apply");
1580         SIGNAL_CONNECT(apply_bt, "clicked", airpcap_advanced_apply_cb, airpcap_advanced_w);
1581         gtk_widget_show(apply_bt);
1582
1583         ok_bt = gtk_button_new_with_label("Ok");
1584         OBJECT_SET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_OK_KEY,ok_bt);
1585         window_set_cancel_button(airpcap_advanced_w, ok_bt, window_cancel_button_cb);
1586         gtk_widget_show(ok_bt);
1587
1588         cancel_bt = gtk_button_new_with_label("Cancel");
1589         OBJECT_SET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_CANCEL_KEY,cancel_bt);
1590         window_set_cancel_button(airpcap_advanced_w, cancel_bt, window_cancel_button_cb);
1591         gtk_widget_show(cancel_bt);
1592
1593         /* Add them to box 2 */
1594         gtk_box_pack_end (GTK_BOX (buttons_box_2), cancel_bt, FALSE, FALSE, 1);
1595         gtk_box_pack_end (GTK_BOX (buttons_box_2), apply_bt,  FALSE, FALSE, 1);
1596         gtk_box_pack_end (GTK_BOX (buttons_box_2), ok_bt,     FALSE, FALSE, 1);
1597
1598         /* Create the three main frames */
1599         interface_frame = gtk_frame_new("");
1600         gtk_frame_set_label(GTK_FRAME(interface_frame),"Interface");
1601
1602         basic_frame = gtk_frame_new("");
1603         gtk_frame_set_label(GTK_FRAME(basic_frame),"Basic Parameters");
1604
1605         wep_frame = gtk_frame_new("");
1606         gtk_frame_set_label(GTK_FRAME(wep_frame),"WEP Keys");
1607
1608         /* Create the three sub boxes */
1609         interface_box = gtk_hbox_new(FALSE,0);
1610         basic_box     = gtk_hbox_new(FALSE,0);
1611         wep_box       = gtk_vbox_new(FALSE,0);
1612
1613         /* Fill the interface_box */
1614         if(airpcap_if_active != NULL)
1615                 {
1616                 interface_combo = gtk_label_new(airpcap_if_active->description);
1617                 }
1618         else
1619                 {
1620                 interface_combo = gtk_label_new("No airpcap interface found!");
1621                 gtk_widget_set_sensitive(main_box,FALSE);
1622                 }
1623
1624         OBJECT_SET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_INTERFACE_KEY,interface_combo);
1625         gtk_box_pack_start (GTK_BOX (interface_box), interface_combo, TRUE, TRUE, 0);
1626         gtk_widget_show(interface_combo);
1627
1628         /* blink led button (BEFORE interface_combo, 'cause its callback will need blink_bt)*/
1629         blink_bt = gtk_button_new_with_label("  Blink Led  ");
1630         OBJECT_SET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_BLINK_KEY,blink_bt);
1631         gtk_box_pack_end (GTK_BOX (interface_box), blink_bt, FALSE, FALSE, 0);
1632         SIGNAL_CONNECT(blink_bt, "clicked", blink_cb, NULL);
1633         gtk_widget_show(blink_bt);
1634
1635         gtk_container_set_border_width (GTK_CONTAINER (interface_box), 10);
1636
1637         /* Fill the basic_box */
1638         /* Create the two vertical boxes for combo and check */
1639         basic_combo_box = gtk_vbox_new(TRUE,0);
1640         basic_check_box = gtk_vbox_new(TRUE,0);
1641         basic_label_box = gtk_vbox_new(TRUE,0);
1642
1643         /* Create the Wrong CRC horiziontal box */
1644         basic_wrong_box = gtk_hbox_new(FALSE,0);
1645
1646         /* Fill the label vbox */
1647         channel_lb = gtk_label_new("Channel:      ");
1648         gtk_label_set_justify(GTK_LABEL(channel_lb),GTK_JUSTIFY_LEFT);
1649         gtk_box_pack_start (GTK_BOX (basic_label_box), channel_lb, TRUE, TRUE, 0);
1650         gtk_widget_show(channel_lb);
1651         capture_lb = gtk_label_new("Capture Type:");
1652         gtk_label_set_justify(GTK_LABEL(capture_lb),GTK_JUSTIFY_LEFT);
1653         gtk_box_pack_start (GTK_BOX (basic_label_box), capture_lb, TRUE, TRUE, 0);
1654         gtk_widget_show(capture_lb);
1655
1656         /* Create the two combo boxes */
1657         channel_combo = gtk_combo_new();
1658         OBJECT_SET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_CHANNEL_KEY,channel_combo);
1659
1660         channel_list = NULL;
1661         channel_list = g_list_append(channel_list, "1");
1662     channel_list = g_list_append(channel_list, "2");
1663     channel_list = g_list_append(channel_list, "3");
1664     channel_list = g_list_append(channel_list, "4");
1665         channel_list = g_list_append(channel_list, "5");
1666         channel_list = g_list_append(channel_list, "6");
1667         channel_list = g_list_append(channel_list, "7");
1668         channel_list = g_list_append(channel_list, "8");
1669         channel_list = g_list_append(channel_list, "9");
1670         channel_list = g_list_append(channel_list, "10");
1671         channel_list = g_list_append(channel_list, "11");
1672         channel_list = g_list_append(channel_list, "12");
1673         channel_list = g_list_append(channel_list, "13");
1674         channel_list = g_list_append(channel_list, "14");
1675         gtk_combo_set_popdown_strings( GTK_COMBO(channel_combo), channel_list) ;
1676
1677         /* Select the first entry */
1678         if(airpcap_if_selected != NULL)
1679                 {
1680                 airpcap_update_channel_combo(GTK_WIDGET(channel_combo), airpcap_if_selected);
1681                 }
1682
1683         channel_te = GTK_COMBO(channel_combo)->entry;
1684         gtk_editable_set_editable(GTK_EDITABLE(channel_te),FALSE);
1685     SIGNAL_CONNECT(channel_te, "changed",  channel_changed_cb, channel_te);
1686         gtk_box_pack_start (GTK_BOX (basic_combo_box), channel_combo, FALSE, FALSE, 0);
1687         gtk_widget_show(channel_combo);
1688
1689         capture_combo = gtk_combo_new();
1690         OBJECT_SET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_LINK_TYPE_KEY,capture_combo);
1691         capture_list = NULL;
1692         capture_list = g_list_append(capture_list, AIRPCAP_LINK_TYPE_NAME_802_11_ONLY);
1693     capture_list = g_list_append(capture_list, AIRPCAP_LINK_TYPE_NAME_802_11_PLUS_RADIO);
1694         gtk_combo_set_popdown_strings( GTK_COMBO(capture_combo), capture_list) ;
1695
1696         capture_s = NULL;
1697         if(airpcap_if_selected != NULL)
1698                 {
1699                 if(airpcap_if_selected->linkType == AIRPCAP_LT_802_11)
1700                         capture_s = g_strdup_printf("%s",AIRPCAP_LINK_TYPE_NAME_802_11_ONLY);
1701                 else if(airpcap_if_selected->linkType == AIRPCAP_LT_802_11_PLUS_RADIO)
1702                         capture_s = g_strdup_printf("%s",AIRPCAP_LINK_TYPE_NAME_802_11_PLUS_RADIO);
1703                 if(capture_s != NULL) gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(capture_combo)->entry), capture_s);
1704                 }
1705         g_free(capture_s);
1706
1707         link_type_te = GTK_COMBO(capture_combo)->entry;
1708         gtk_editable_set_editable(GTK_EDITABLE(link_type_te),FALSE);
1709     SIGNAL_CONNECT(link_type_te, "changed",  link_type_changed_cb, link_type_te);
1710         gtk_box_pack_start (GTK_BOX (basic_combo_box), capture_combo, FALSE, FALSE, 1);
1711         gtk_widget_show(capture_combo);
1712
1713         /* Create the two check boxes */
1714         crc_check               = gtk_check_button_new_with_label("Include 802.11 FCS in Frames");
1715         OBJECT_SET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_CRC_KEY,crc_check);
1716
1717         /* Fcs Presence check box */
1718         if(airpcap_if_selected != NULL)
1719                 {
1720                 if(airpcap_if_selected->IsFcsPresent)
1721                         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(crc_check),TRUE);
1722                 else
1723                         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(crc_check),FALSE);
1724                 }
1725
1726         SIGNAL_CONNECT(crc_check,"toggled",crc_check_cb,NULL);
1727         gtk_box_pack_start (GTK_BOX (basic_check_box), crc_check, FALSE, FALSE, 0);
1728         gtk_widget_show(crc_check);
1729
1730         /* CRC Filter label */
1731         wrong_lb = gtk_label_new("FCS Filter:");
1732         gtk_box_pack_start (GTK_BOX (basic_wrong_box), wrong_lb, FALSE, FALSE, 0);
1733         gtk_widget_show(wrong_lb);
1734
1735         /* CRC Filter combo */
1736         wrong_crc_combo = gtk_combo_new();
1737         OBJECT_SET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_WRONG_CRC_KEY,wrong_crc_combo);
1738
1739         linktype_list = g_list_append(linktype_list, AIRPCAP_VALIDATION_TYPE_NAME_ALL);
1740         linktype_list = g_list_append(linktype_list, AIRPCAP_VALIDATION_TYPE_NAME_CORRECT);
1741     linktype_list = g_list_append(linktype_list, AIRPCAP_VALIDATION_TYPE_NAME_CORRUPT);
1742
1743         gtk_combo_set_popdown_strings( GTK_COMBO(wrong_crc_combo), linktype_list) ;
1744
1745         wrong_crc_te = GTK_COMBO(wrong_crc_combo)->entry;
1746
1747         if(airpcap_if_selected != NULL)
1748                 {
1749                 airpcap_validation_type_combo_set_by_type(wrong_crc_combo,airpcap_if_selected->CrcValidationOn);
1750                 }
1751
1752         gtk_editable_set_editable(GTK_EDITABLE(wrong_crc_te),FALSE);
1753         SIGNAL_CONNECT(wrong_crc_te,"changed",wrong_crc_combo_cb,wrong_crc_te);
1754         gtk_box_pack_start (GTK_BOX (basic_wrong_box), wrong_crc_combo, FALSE, FALSE, 0);
1755         gtk_widget_show(wrong_crc_combo);
1756
1757         gtk_box_pack_start(GTK_BOX(basic_check_box), basic_wrong_box, FALSE, FALSE, 0);
1758         gtk_widget_show(basic_wrong_box);
1759
1760         /* Add the vertical inner boxes to the basic_box */
1761         gtk_box_pack_start (GTK_BOX (basic_box), basic_label_box, FALSE, FALSE, 10);
1762         gtk_box_pack_start (GTK_BOX (basic_box), basic_combo_box, FALSE, FALSE, 10);
1763         gtk_box_pack_start (GTK_BOX (basic_box), basic_check_box, FALSE, FALSE, 10);
1764
1765         gtk_container_set_border_width (GTK_CONTAINER (basic_box), 10);
1766
1767         /* Fill the wep_box */
1768         wep_sub_box = gtk_hbox_new(FALSE,1);
1769         gtk_widget_show(wep_sub_box);
1770         encryption_box = gtk_hbox_new(FALSE,1);
1771         gtk_widget_show(encryption_box);
1772
1773         /* encryption enabled box */
1774         encryption_check = gtk_check_button_new_with_label("Enable WEP Decryption");
1775         OBJECT_SET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_WEP_DECRYPTION_KEY,encryption_check);
1776
1777         /* Fcs Presence check box */
1778         if(airpcap_if_selected != NULL)
1779                 {
1780                 if(airpcap_if_selected->DecryptionOn == AIRPCAP_DECRYPTION_ON)
1781                         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(encryption_check),TRUE);
1782                 else
1783                         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(encryption_check),FALSE);
1784                 }
1785
1786         SIGNAL_CONNECT(encryption_check,"toggled",wep_encryption_check_cb,NULL);
1787         gtk_box_pack_start (GTK_BOX (encryption_box), encryption_check, FALSE, FALSE, 0);
1788         gtk_widget_show(encryption_check);
1789
1790         /* WEP text box */
1791         key_text = scrolled_window_new(NULL, NULL);
1792     /* never use a scrollbar in x direction, show the complete relation string */
1793     gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(key_text),
1794                                    GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
1795     #if GTK_MAJOR_VERSION >= 2
1796     gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(key_text),
1797                                    GTK_SHADOW_IN);
1798     #endif
1799
1800         /* add WEP keys if present... */
1801     key_ls = gtk_list_new();
1802     gtk_list_set_selection_mode(GTK_LIST(key_ls), GTK_SELECTION_SINGLE);
1803         OBJECT_SET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_KEYLIST_KEY,key_ls);
1804
1805         airpcap_fill_key_list(key_ls,airpcap_if_selected);
1806         gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(key_text),key_ls);
1807         gtk_widget_show(key_ls);
1808         gtk_box_pack_start (GTK_BOX (wep_sub_box), key_text, TRUE, TRUE, 0);
1809         gtk_widget_show(key_text);
1810
1811         /* WEP buttons */
1812         wep_buttons_box = gtk_vbox_new(FALSE,0);
1813
1814         /* Create and add buttons */
1815         add_new_key_bt = gtk_button_new_with_label("Add New Key");
1816         SIGNAL_CONNECT(add_new_key_bt, "clicked", airpcap_advanced_add_key_cb, airpcap_advanced_w);
1817         gtk_box_pack_start (GTK_BOX (wep_buttons_box), add_new_key_bt, FALSE, FALSE, 0);
1818         gtk_widget_show(add_new_key_bt);
1819         remove_key_bt = gtk_button_new_with_label("Remove Key");
1820         SIGNAL_CONNECT(remove_key_bt, "clicked", airpcap_advanced_remove_key_cb, key_ls);
1821         gtk_box_pack_start (GTK_BOX (wep_buttons_box), remove_key_bt, FALSE, FALSE, 0);
1822         gtk_widget_show(remove_key_bt);
1823         edit_key_bt = gtk_button_new_with_label("Edit Key");
1824         SIGNAL_CONNECT(edit_key_bt, "clicked", airpcap_advanced_edit_key_cb, airpcap_advanced_w);
1825         gtk_box_pack_start (GTK_BOX (wep_buttons_box), edit_key_bt, FALSE, FALSE, 0);
1826         gtk_widget_show(edit_key_bt);
1827         move_key_up_bt = gtk_button_new_with_label("Move Key Up");
1828         SIGNAL_CONNECT(move_key_up_bt, "clicked", airpcap_advanced_move_key_up_cb, key_ls);
1829         gtk_box_pack_start (GTK_BOX (wep_buttons_box), move_key_up_bt, FALSE, FALSE, 0);
1830         gtk_widget_show(move_key_up_bt);
1831         move_key_down_bt = gtk_button_new_with_label("Move Key Down");
1832         SIGNAL_CONNECT(move_key_down_bt, "clicked", airpcap_advanced_move_key_down_cb, key_ls);
1833         gtk_box_pack_start (GTK_BOX (wep_buttons_box), move_key_down_bt, FALSE, FALSE, 0);
1834         gtk_widget_show(move_key_down_bt);
1835
1836         gtk_box_pack_end (GTK_BOX (wep_sub_box), wep_buttons_box, FALSE, FALSE, 0);
1837
1838         gtk_container_set_border_width (GTK_CONTAINER (wep_sub_box), 10);
1839
1840         gtk_box_pack_start (GTK_BOX (wep_box), encryption_box, FALSE, FALSE,0);
1841         gtk_box_pack_start (GTK_BOX (wep_box), wep_sub_box, FALSE, FALSE,0);
1842         gtk_widget_show(wep_sub_box);
1843
1844         /* Add them to the frames */
1845         gtk_container_add(GTK_CONTAINER(interface_frame),interface_box);
1846         gtk_container_add(GTK_CONTAINER(basic_frame),basic_box);
1847         gtk_container_add(GTK_CONTAINER(wep_frame),wep_box);
1848
1849         /* Add frames to the main box */
1850         gtk_box_pack_start (GTK_BOX (main_box), interface_frame, FALSE, FALSE, 1);
1851         gtk_box_pack_start (GTK_BOX (main_box), basic_frame, FALSE, FALSE, 1);
1852         gtk_box_pack_start (GTK_BOX (main_box), wep_frame, FALSE, FALSE, 1);
1853
1854         /* Add buttons' boxes to the main box */
1855         gtk_box_pack_start (GTK_BOX (main_box), buttons_box_2, FALSE, FALSE, 1);
1856
1857         /* Add the main box to the main window */
1858         gtk_container_add(GTK_CONTAINER(airpcap_advanced_w),main_box);
1859
1860         /* SHOW EVERYTHING */
1861         /* Show the WEP key buttons */
1862         gtk_widget_show (wep_buttons_box);
1863
1864         /* Show the combo and check boxes */
1865         gtk_widget_show (basic_label_box);
1866         gtk_widget_show (basic_combo_box);
1867         gtk_widget_show (basic_check_box);
1868
1869         /* Show the button boxes */
1870         gtk_widget_show (buttons_box_1);
1871         gtk_widget_show (buttons_box_2);
1872
1873         /* Show the frames */
1874         gtk_widget_show (interface_frame);
1875         gtk_widget_show (basic_frame);
1876         gtk_widget_show (wep_frame);
1877
1878         /* Show the sub main boxes */
1879         gtk_widget_show (interface_box);
1880         gtk_widget_show (basic_box);
1881         gtk_widget_show (wep_box);
1882
1883         /* Show the main box */
1884         gtk_widget_show (main_box);
1885
1886         /* Show the window */
1887         gtk_widget_show (airpcap_advanced_w);
1888 }
1889
1890 #endif /* HAVE_AIRPCAP */