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
  28 #ifdef HAVE_CONFIG_H
  29 # include "config.h"
  30 #endif
  31
  32 #ifdef HAVE_AIRPCAP
  33
  34 #include <gtk/gtk.h>
  35 #include <glib.h>
  36 #include <glib/gprintf.h>
  37
  38 #include <string.h>
  39
  40 #include <epan/filesystem.h>
  41 #include <epan/emem.h>
  42 #include <epan/prefs.h>
  43 #include <epan/prefs-int.h>
  44 #include <epan/frequency-utils.h>
  45 #include <epan/crypt/wep-wpadefs.h>
  46
  47 #include <pcap.h>
  48
  49 #include "gtk/main.h"
  50 #include "dlg_utils.h"
  51 #include "gui_utils.h"
  52 #include "simple_dialog.h"
  53 #include "dfilter_expr_dlg.h"
  54 #include "stock_icons.h"
  55 #include "gtkglobals.h"
  56 #include "help_dlg.h"
  57
  58
  59 #include <airpcap.h>
  60 #include "airpcap_loader.h"
  61 #include "airpcap_gui_utils.h"
  62 #include "airpcap_dlg.h"
  63
  64 #include "keys.h"
  65
  66 /* temporary block signals to widgets */
  67 BOOL block_advanced_signals;
  68
  69 /*
  70  * This function is used to write the preferences to the preferences file.
  71  * It has the same behaviour as prefs_main_write() in prefs_dlg.c
  72  */
  73 static void
  74 write_prefs_to_file(void)
  75 {
  76   int err;
  77   char *pf_dir_path;
  78   char *pf_path;
  79
  80   /* Create the directory that holds personal configuration files, if
  81      necessary.  */
  82   if (create_persconffile_dir(&pf_dir_path) == -1) {
  83      simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
  84       "Can't create directory\n\"%s\"\nfor preferences file: %s.", pf_dir_path,
  85       strerror(errno));
  86      g_free(pf_dir_path);
  87   } else {
  88     /* Write the preferencs out. */
  89     err = write_prefs(&pf_path);
  90     if (err != 0) {
  91        simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
  92         "Can't open preferences file\n\"%s\": %s.", pf_path,
  93         strerror(err));
  94        g_free(pf_path);
  95     }
  96   }
  97 }
  98
  99 /*
 100  * This struct will contain useful data for the selected (actual) airpcap device
 101  */
 102 void
 103 airpcap_fill_if_combo(GtkWidget *combo, GList* if_list)
 104 {
 105     int ifn = 0;
 106     GList* popdown_if_list = NULL;
 107     GList* curr = NULL;
 108     airpcap_if_info_t* if_info = NULL;
 109
 110     curr = g_list_nth(if_list, ifn);
 111     if_info = NULL;
 112     if (curr != NULL) if_info = curr->data;
 113
 114     popdown_if_list = NULL;
 115     ifn = g_list_length(if_list) - 1;
 116     while (ifn >= 0) /* reverse order */
 117     {
 118         curr = g_list_nth(if_list, ifn);
 119         if_info = NULL;
 120         if (curr != NULL)
 121             if_info = curr->data;
 122         if (if_info != NULL)
 123             popdown_if_list = g_list_append( popdown_if_list , if_info->description) ;
 124         ifn--;
 125     }
 126     gtk_combo_set_popdown_strings( GTK_COMBO(combo), popdown_if_list) ;
 127     g_list_free(popdown_if_list);
 128
 129     if (airpcap_if_selected != NULL)
 130     {
 131         gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(combo)->entry), airpcap_if_selected->description);
 132     }
 133     else
 134     {
 135         gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(combo)->entry), "No Wireless Interfaces Found");
 136     }
 137 }
 138
 139 /*
 140  * Callback for the select row event in the key list widget
 141  */
 142 void
 143 on_key_ls_select_row(GtkWidget *widget,
 144                      gint row,
 145                      gint column,
 146                      GdkEventButton *event,
 147                      gpointer data)
 148 {
 149     airpcap_key_ls_selected_info_t*  selected_item;
 150
 151     selected_item = g_object_get_data(G_OBJECT(data),AIRPCAP_ADVANCED_SELECTED_KEY_LIST_ITEM_KEY);
 152
 153     selected_item->row = row;
 154     selected_item->column = column;
 155 }
 156
 157 /*
 158  * Callback for the unselect row event in the key list widget
 159  */
 160 void
 161 on_key_ls_unselect_row(GtkWidget *widget,
 162                        gint row,
 163                        gint column,
 164                        GdkEventButton *event,
 165                        gpointer data)
 166 {
 167     airpcap_key_ls_selected_info_t*  selected_item;
 168
 169     selected_item = g_object_get_data(G_OBJECT(data),AIRPCAP_ADVANCED_SELECTED_KEY_LIST_ITEM_KEY);
 170
 171     selected_item->row = NO_ROW_SELECTED;
 172     selected_item->column = NO_COLUMN_SELECTED;
 173 }
 174
 175 /*
 176  * Callback for the click column event in the key list widget
 177  */
 178 void
 179 on_key_ls_click_column(GtkWidget *widget,
 180                        gint column,
 181                        gpointer data)
 182 {
 183 }
 184
 185 /*
 186  * Callback for the crc chackbox
 187  */
 188 static void
 189 on_fcs_ck_toggled(GtkWidget *w, gpointer user_data)
 190
 191 {
 192     if ( !block_advanced_signals && (airpcap_if_selected != NULL))
 193     {
 194         if (airpcap_if_selected->IsFcsPresent)
 195         {
 196             airpcap_if_selected->IsFcsPresent = FALSE;
 197             airpcap_if_selected->saved = FALSE;
 198         }
 199         else
 200         {
 201             airpcap_if_selected->IsFcsPresent = TRUE;
 202             airpcap_if_selected->saved = FALSE;
 203         }
 204     }
 205 }
 206
 207 /*
 208  * Callback for the wrong crc combo
 209  */
 210 static void
 211 on_edit_type_en_changed(GtkWidget *w, gpointer data)
 212 {
 213     GtkWidget *edit_key_w;
 214     GtkWidget *edit_ssid_te;
 215     GtkWidget *type_te;
 216     GtkWidget *key_lb;
 217     GtkWidget *ssid_lb;
 218
 219     gchar* type_text = NULL;
 220
 221     edit_key_w = GTK_WIDGET(data);
 222     type_te    = w;
 223
 224     edit_ssid_te = g_object_get_data(G_OBJECT(edit_key_w),AIRPCAP_ADVANCED_EDIT_KEY_SSID_KEY);
 225     key_lb = g_object_get_data(G_OBJECT(edit_key_w),AIRPCAP_ADVANCED_EDIT_KEY_KEY_LABEL_KEY);
 226     ssid_lb = g_object_get_data(G_OBJECT(edit_key_w),AIRPCAP_ADVANCED_EDIT_KEY_SSID_LABEL_KEY);
 227
 228     type_text = g_strdup(gtk_entry_get_text(GTK_ENTRY(type_te)));
 229
 230     if (string_is_not_empty(type_text))
 231     {
 232         /*
 233          * If it is a WEP key, no SSID is required! Gray out rhe entry text so
 234          * it doesn't create confusion ...
 235          */
 236         if (g_ascii_strcasecmp(type_text,AIRPCAP_WEP_KEY_STRING) == 0)
 237         {
 238             gtk_widget_set_sensitive(edit_ssid_te,FALSE);
 239             /*
 240              * Maybe the user has already entered some text into the SSID field
 241              * and then switched to WEP...
 242              */
 243             gtk_entry_set_text(GTK_ENTRY(edit_ssid_te),"");
 244             gtk_label_set_text(GTK_LABEL(key_lb),"Key");
 245             gtk_label_set_text(GTK_LABEL(ssid_lb),"");
 246         }
 247         else if (g_ascii_strcasecmp(type_text,AIRPCAP_WPA_BIN_KEY_STRING) == 0)
 248         {
 249             gtk_widget_set_sensitive(edit_ssid_te,FALSE);
 250             /*
 251              * Maybe the user has already entered some text into the SSID field
 252              * and then switched to WEP...
 253              */
 254             gtk_entry_set_text(GTK_ENTRY(edit_ssid_te),"");
 255             gtk_label_set_text(GTK_LABEL(key_lb),"Key");
 256             gtk_label_set_text(GTK_LABEL(ssid_lb),"");
 257         }
 258         else if (g_ascii_strcasecmp(type_text,AIRPCAP_WPA_PWD_KEY_STRING) == 0)
 259         {
 260             gtk_widget_set_sensitive(edit_ssid_te,TRUE);
 261             /*
 262              * Maybe the user has already entered some text into the SSID field
 263              * and then switched to WEP...
 264              */
 265             gtk_entry_set_text(GTK_ENTRY(edit_ssid_te),"");
 266             gtk_label_set_text(GTK_LABEL(key_lb),"Passphrase");
 267             gtk_label_set_text(GTK_LABEL(ssid_lb),"SSID");
 268         }
 269     }
 270     gtk_widget_show(edit_ssid_te);
 271
 272     g_free(type_text);
 273 }
 274
 275 /*
 276  * Callback for the wrong crc combo
 277  */
 278 static void
 279 on_add_type_en_changed(GtkWidget *w, gpointer data)
 280 {
 281     GtkWidget *add_key_w;
 282     GtkWidget *add_ssid_te;
 283     GtkWidget *type_te;
 284     GtkWidget *key_lb;
 285     GtkWidget *ssid_lb;
 286
 287     gchar* type_text = NULL;
 288
 289     add_key_w = GTK_WIDGET(data);
 290     type_te    = w;
 291
 292     add_ssid_te = g_object_get_data(G_OBJECT(add_key_w),AIRPCAP_ADVANCED_ADD_KEY_SSID_KEY);
 293     key_lb = g_object_get_data(G_OBJECT(add_key_w),AIRPCAP_ADVANCED_ADD_KEY_KEY_LABEL_KEY);
 294     ssid_lb = g_object_get_data(G_OBJECT(add_key_w),AIRPCAP_ADVANCED_ADD_KEY_SSID_LABEL_KEY);
 295
 296     type_text = g_strdup(gtk_entry_get_text(GTK_ENTRY(type_te)));
 297
 298     if (string_is_not_empty(type_text))
 299     {
 300         /*
 301          * If it is a WEP key, no SSID is required! Gray out rhe entry text so
 302          * it doesn't create confusion ...
 303          */
 304         if (g_ascii_strcasecmp(type_text,AIRPCAP_WEP_KEY_STRING) == 0)
 305         {
 306             gtk_widget_set_sensitive(add_ssid_te,FALSE);
 307             /*
 308              * Maybe the user has already entered some text into the SSID field
 309              * and then switched to WEP...
 310              */
 311             gtk_entry_set_text(GTK_ENTRY(add_ssid_te),"");
 312             gtk_label_set_text(GTK_LABEL(key_lb),"Key");
 313             gtk_label_set_text(GTK_LABEL(ssid_lb),"");
 314         }
 315         else if (g_ascii_strcasecmp(type_text,AIRPCAP_WPA_BIN_KEY_STRING) == 0)
 316         {
 317             gtk_widget_set_sensitive(add_ssid_te,FALSE);
 318             /*
 319              * Maybe the user has already entered some text into the SSID field
 320              * and then switched to WEP...
 321              */
 322             gtk_entry_set_text(GTK_ENTRY(add_ssid_te),"");
 323             gtk_label_set_text(GTK_LABEL(key_lb),"Key");
 324             gtk_label_set_text(GTK_LABEL(ssid_lb),"");
 325         }
 326         else if (g_ascii_strcasecmp(type_text,AIRPCAP_WPA_PWD_KEY_STRING) == 0)
 327         {
 328             gtk_widget_set_sensitive(add_ssid_te,TRUE);
 329             /*
 330              * Maybe the user has already entered some text into the SSID field
 331              * and then switched to WEP...
 332              */
 333             gtk_entry_set_text(GTK_ENTRY(add_ssid_te),"");
 334             gtk_label_set_text(GTK_LABEL(key_lb),"Passphrase");
 335             gtk_label_set_text(GTK_LABEL(ssid_lb),"SSID");
 336         }
 337     }
 338     gtk_widget_show(add_ssid_te);
 339
 340     g_free(type_text);
 341 }
 342
 343 /*
 344  * Returns FALSE if a text string has length 0, i.e. the first char
 345  * is '\0', TRUE otherwise
 346  */
 347 gboolean
 348 string_is_not_empty(gchar *s)
 349 {
 350     if (g_ascii_strcasecmp(s,"") != 0)
 351         return TRUE;
 352     else
 353         return FALSE;
 354 }
 355
 356 /*
 357  * Callback for the wrong crc combo
 358  */
 359 static void
 360 on_fcs_filter_en_changed(GtkWidget *w, gpointer data)
 361 {
 362     const gchar *s;
 363
 364     s = gtk_entry_get_text(GTK_ENTRY(w));
 365
 366     if ( !block_advanced_signals && (data != NULL) && (w != NULL) )
 367     {
 368         if ((g_ascii_strcasecmp("",s)))
 369         {
 370             airpcap_if_selected->CrcValidationOn = airpcap_get_validation_type(s);
 371             airpcap_if_selected->saved = FALSE;
 372         }
 373     }
 374 }
 375
 376 /*
 377  * Changed callback for the channel combobox
 378  */
 379 static void
 380 on_channel_en_changed(GtkWidget *w _U_, gpointer data)
 381 {
 382     const gchar *s;
 383         ULONG ch_freq;
 384
 385     if ( !block_advanced_signals && (data != NULL) && (w != NULL) )
 386     {
 387         s = gtk_entry_get_text(GTK_ENTRY(w));
 388         if ((g_ascii_strcasecmp("",s)))
 389         {
 390             if (airpcap_if_selected != NULL)
 391             {
 392                                 ch_freq = airpcap_get_frequency_from_str(s);
 393                                 airpcap_if_active->channelInfo.Frequency = ch_freq;
 394                 airpcap_if_selected->saved = FALSE;
 395                                 airpcap_update_channel_offset_cb(airpcap_if_selected, ch_freq, GTK_WIDGET(data));
 396             }
 397         }
 398     }
 399 }
 400
 401 /*
 402  * Changed callback for the channel offset combobox
 403  */
 404 static void
 405 on_channel_offset_cb_changed(GtkWidget *w _U_, gpointer data)
 406 {
 407     const gchar *s;
 408         gchar offset;
 409
 410     if ( !block_advanced_signals && (data != NULL) && (w != NULL) )
 411     {
 412         s = gtk_entry_get_text(GTK_ENTRY(w));
 413         if ((g_ascii_strcasecmp("",s)))
 414         {
 415             if (airpcap_if_selected != NULL)
 416             {
 417                                 sscanf(s,"%d",&offset);
 418                                 airpcap_if_selected->channelInfo.ExtChannel = offset;
 419                 airpcap_if_selected->saved = FALSE;
 420             }
 421         }
 422     }
 423 }
 424
 425 /*
 426  * Changed callback for the capture type combobox
 427  */
 428 static void
 429 on_capture_type_en_changed(GtkWidget *w _U_, gpointer data)
 430 {
 431     const gchar *s;
 432
 433     s = gtk_entry_get_text(GTK_ENTRY(w));
 434
 435     if ( !block_advanced_signals && (data != NULL) && (w != NULL) )
 436     {
 437         if ((g_ascii_strcasecmp("",s)))
 438         {
 439             airpcap_if_selected->linkType = airpcap_get_link_type(s);
 440             airpcap_if_selected->saved = FALSE;
 441         }
 442     }
 443 }
 444
 445 /*
 446  * Activate callback for the adapter combobox
 447  */
 448 static void
 449 combo_if_activate_cb(GtkWidget *entry _U_, gpointer data)
 450 {
 451 }
 452
 453 /*
 454  * Thread function used to blink the led
 455  */
 456 void update_blink(gpointer data _U_)
 457 {
 458     airpcap_if_info_t* sel;
 459     PAirpcapHandle ad;
 460     gchar ebuf[AIRPCAP_ERRBUF_SIZE];
 461
 462     sel = (airpcap_if_info_t*)data;
 463
 464     ad = airpcap_if_open(sel->name, ebuf);
 465     if (ad)
 466     {
 467         if (sel->led)
 468         {
 469             airpcap_if_turn_led_off(ad, 0);
 470             sel->led = FALSE;
 471         }
 472         else
 473         {
 474             airpcap_if_turn_led_on(ad, 0);
 475             sel->led = TRUE;
 476         }
 477         airpcap_if_close(ad);
 478     }
 479 }
 480
 481 /*
 482  * Blink button callback
 483  */
 484 void
 485 on_blink_bt_clicked( GtkWidget *blink_bt _U_, gpointer if_data )
 486 {
 487     PAirpcapHandle ad = NULL;
 488     gchar ebuf[AIRPCAP_ERRBUF_SIZE];
 489
 490     if (airpcap_if_selected != NULL)
 491         if (!(airpcap_if_selected->blinking))
 492         {
 493             gtk_button_set_label(GTK_BUTTON(blink_bt),"Stop Blinking");
 494             airpcap_if_selected->tag = gtk_timeout_add(500, (GtkFunction)update_blink,airpcap_if_selected);
 495             airpcap_if_selected->blinking = TRUE;
 496         }
 497         else
 498         {
 499             gtk_button_set_label(GTK_BUTTON(blink_bt),"  Blink Led  ");
 500             gtk_timeout_remove(airpcap_if_selected->tag);
 501             airpcap_if_selected->blinking = FALSE;
 502             /* Switch on the led!  */
 503             ad = airpcap_if_open(airpcap_if_selected->name, ebuf);
 504             if (ad)
 505             {
 506                 gtk_timeout_remove(airpcap_if_selected->tag);
 507                 airpcap_if_turn_led_on(ad, 0);
 508                 airpcap_if_selected->blinking = FALSE;
 509                 airpcap_if_selected->led = TRUE;
 510                 airpcap_if_close(ad);
 511             }
 512         }
 513 }
 514
 515 /*
 516  * Callback for the 'Any' adapter What's This button.
 517  */
 518 void
 519 on_what_s_this_bt_clicked( GtkWidget *blink_bt _U_, gpointer if_data )
 520 {
 521     simple_dialog(ESD_TYPE_INFO,ESD_BTN_OK,
 522                   "The Multi-Channel Aggregator is a virtual device "
 523                   "that can be used to capture packets from all the "
 524                   "AirPcap adapters at the same time.\n"
 525                   "The Capture Type, FCS and Encryption settings of "
 526                   "this virtual device can be configured as for any "
 527                   "real adapter.\nThe channel cannot be changed for "
 528                   "this adapter.\n"
 529                   "Refer to the AirPcap manual for more information.");
 530 }
 531
 532 /* the window was closed, cleanup things */
 533 void
 534 on_key_management_destroy(GtkWidget *w _U_, gpointer data _U_)
 535 {
 536     GtkWidget   *airpcap_advanced_w,
 537     *toolbar;
 538
 539     gint *from_widget = NULL;
 540
 541     /* Retrieve the GUI object pointers */
 542     airpcap_advanced_w  = GTK_WIDGET(data);
 543
 544     toolbar     = GTK_WIDGET(g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_TOOLBAR_KEY));
 545
 546     /* ... */
 547     from_widget = (gint*)g_object_get_data(G_OBJECT(toolbar),AIRPCAP_ADVANCED_FROM_KEY);
 548     /* gray out the toolbar (if we came here from the toolbar advanced button)*/
 549     if ( *from_widget == AIRPCAP_ADVANCED_FROM_TOOLBAR)
 550         gtk_widget_set_sensitive(toolbar,TRUE);
 551     else
 552         gtk_widget_set_sensitive(toolbar,FALSE);
 553
 554     g_free(from_widget);
 555
 556     /* reload the configuration!!! Configuration has not been saved but
 557     the corresponding structure has been modified probably...*/
 558     if (airpcap_if_selected != NULL)
 559     {
 560         if (!airpcap_if_selected->saved)
 561         {
 562             airpcap_load_selected_if_configuration(airpcap_if_selected);
 563         }
 564     }
 565
 566 }
 567
 568 /* the Advenced wireless Settings window was closed, cleanup things */
 569 static void
 570 on_airpcap_advanced_destroy(GtkWidget *w _U_, gpointer data _U_)
 571 {
 572     GtkWidget   *airpcap_advanced_w,
 573     *toolbar;
 574
 575     gint *from_widget = NULL;
 576
 577     /* Retrieve the GUI object pointers */
 578     airpcap_advanced_w  = GTK_WIDGET(data);
 579
 580     toolbar     = GTK_WIDGET(g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_TOOLBAR_KEY));
 581
 582     /* ... */
 583     from_widget = (gint*)g_object_get_data(G_OBJECT(toolbar),AIRPCAP_ADVANCED_FROM_KEY);
 584     /* gray out the toolbar (if we came here from the toolbar advanced button)*/
 585     if ( *from_widget == AIRPCAP_ADVANCED_FROM_TOOLBAR)
 586         gtk_widget_set_sensitive(toolbar,TRUE);
 587     else
 588         gtk_widget_set_sensitive(toolbar,FALSE);
 589
 590     g_free(from_widget);
 591
 592     /* reload the configuration!!! Configuration has not been saved but
 593     the corresponding structure has been modified probably...*/
 594     if (!airpcap_if_selected->saved)
 595     {
 596         airpcap_load_selected_if_configuration(airpcap_if_selected);
 597     }
 598 }
 599
 600 /*
 601  * Callback for the 'Apply' button.
 602  */
 603 /*
 604  * XXX - Pressing 'Apply' has the same effect as pressing 'OK' -- you
 605  * can't revert back to the old set of keys by pressing 'Cancel'.  We
 606  * either need to fix reversion or get rid of the 'Apply' button.
 607  */
 608 void
 609 on_key_management_apply_bt_clicked(GtkWidget *button _U_, gpointer data)
 610 {
 611     /* advenced window */
 612     GtkWidget   *key_management_w;
 613
 614     /* widgets in the toolbar */
 615     GtkWidget   *toolbar;
 616     GtkWidget *toolbar_cm;
 617     GtkWidget   *key_ls;
 618     GtkWidget   *decryption_en;
 619
 620     char* decryption_mode_string = NULL;
 621     module_t *wlan_module = prefs_find_module("wlan");
 622
 623     /* retrieve main window */
 624     key_management_w      = GTK_WIDGET(data);
 625     decryption_en         = GTK_WIDGET(g_object_get_data(G_OBJECT(key_management_w),AIRPCAP_ADVANCED_WEP_DECRYPTION_KEY));
 626     key_ls                = GTK_WIDGET(g_object_get_data(G_OBJECT(key_management_w),AIRPCAP_ADVANCED_KEYLIST_KEY));
 627     toolbar               = GTK_WIDGET(g_object_get_data(G_OBJECT(key_management_w),AIRPCAP_TOOLBAR_KEY));
 628     toolbar_cm            = GTK_WIDGET(g_object_get_data(G_OBJECT(key_management_w),AIRPCAP_TOOLBAR_DECRYPTION_KEY));
 629
 630 #define CANT_SAVE_ERR_STR "Cannot save configuration!\n" \
 631         "In order to store the configuration in the registry you must:\n\n" \
 632         "- Close all the airpcap-based applications.\n"\
 633         "- Have administrative privileges."
 634     /* Set the Decryption Mode */
 635     if (g_ascii_strcasecmp(gtk_entry_get_text(GTK_ENTRY(decryption_en)),AIRPCAP_DECRYPTION_TYPE_STRING_WIRESHARK) == 0)
 636     {
 637         set_wireshark_decryption(TRUE);
 638         if (!set_airpcap_decryption(FALSE)) simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, CANT_SAVE_ERR_STR);
 639     }
 640     else if (g_ascii_strcasecmp(gtk_entry_get_text(GTK_ENTRY(decryption_en)),AIRPCAP_DECRYPTION_TYPE_STRING_AIRPCAP) == 0)
 641     {
 642         set_wireshark_decryption(FALSE);
 643         if (!set_airpcap_decryption(TRUE)) simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, CANT_SAVE_ERR_STR);
 644     }
 645     else if (g_ascii_strcasecmp(gtk_entry_get_text(GTK_ENTRY(decryption_en)),AIRPCAP_DECRYPTION_TYPE_STRING_NONE) == 0)
 646     {
 647         set_wireshark_decryption(FALSE);
 648         if (!set_airpcap_decryption(FALSE)) simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, CANT_SAVE_ERR_STR);
 649     }
 650
 651     /* Save the configuration */
 652     airpcap_read_and_save_decryption_keys_from_clist(key_ls,airpcap_if_selected,airpcap_if_list); /* This will save the keys for every adapter */
 653
 654     /* The update will make redissect al the packets... no need to do it here again */
 655     update_decryption_mode_cm(toolbar_cm);
 656
 657     /* Redissect all the packets, and re-evaluate the display filter. */
 658     prefs_apply(wlan_module);
 659 }
 660 /*
 661  * Callback for the Wireless Advanced Settings 'Apply' button.
 662  */
 663 void
 664 on_advanced_apply_bt_clicked(GtkWidget *button, gpointer data _U_)
 665 {
 666     /* advenced window */
 667     GtkWidget   *main_w;
 668
 669     /* widgets in the toolbar */
 670     GtkWidget   *toolbar,
 671     *toolbar_if_lb,
 672     *toolbar_channel_cm,
 673     *toolbar_channel_offset_cb,
 674     *toolbar_wrong_crc_cm;
 675
 676     /* retrieve main window */
 677     main_w = GTK_WIDGET(data);
 678
 679     toolbar = GTK_WIDGET(g_object_get_data(G_OBJECT(main_w),AIRPCAP_TOOLBAR_KEY));
 680
 681     /* retrieve toolbar info */
 682     toolbar_if_lb                               = GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_INTERFACE_KEY));
 683     toolbar_channel_cm                  = GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_CHANNEL_KEY));
 684     toolbar_channel_offset_cb   = GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_CHANNEL_OFFSET_KEY));
 685     toolbar_wrong_crc_cm                = GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_FCS_FILTER_KEY));
 686
 687     /* Save the configuration (for all ) */
 688     airpcap_save_selected_if_configuration(airpcap_if_selected);
 689
 690     /* Update toolbar (only if airpcap_if_selected is airpcap_if_active)*/
 691     if ( g_ascii_strcasecmp(airpcap_if_selected->description,airpcap_if_active->description) == 0)
 692     {
 693         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)));
 694                 airpcap_update_channel_combo(GTK_WIDGET(toolbar_channel_cm),airpcap_if_selected);
 695                 airpcap_update_channel_offset_combo_entry(GTK_WIDGET(toolbar_channel_offset_cb),airpcap_if_selected->channelInfo.ExtChannel);
 696                 airpcap_validation_type_combo_set_by_type(toolbar_wrong_crc_cm,airpcap_if_selected->CrcValidationOn);
 697     }
 698 }
 699
 700 /*
 701  * Callback for the 'OK' button.
 702  */
 703 static void
 704 airpcap_advanced_ok_cb(GtkWidget *w, gpointer data _U_)
 705 {
 706     /* advenced window */
 707     GtkWidget   *main_w;
 708
 709     /* widgets in the toolbar */
 710     GtkWidget   *toolbar,
 711     *toolbar_if_lb,
 712     *toolbar_channel_cm,
 713     *toolbar_wrong_crc_cm,
 714     *toolbar_decryption_ck;
 715
 716     GtkWidget   *key_ls;
 717
 718     /* retrieve main window */
 719     main_w = GTK_WIDGET(data);
 720
 721     toolbar = GTK_WIDGET(g_object_get_data(G_OBJECT(main_w),AIRPCAP_TOOLBAR_KEY));
 722
 723     key_ls      = GTK_WIDGET(g_object_get_data(G_OBJECT(main_w),AIRPCAP_ADVANCED_KEYLIST_KEY));
 724
 725     /* retrieve toolbar info */
 726     toolbar_if_lb                       = GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_INTERFACE_KEY));
 727     toolbar_channel_cm          = GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_CHANNEL_KEY));
 728     toolbar_wrong_crc_cm        = GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_FCS_FILTER_KEY));
 729     toolbar_decryption_ck       = GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_DECRYPTION_KEY));
 730
 731     /* Save the configuration */
 732     airpcap_add_keys_from_list(key_ls,airpcap_if_selected);
 733     airpcap_save_selected_if_configuration(airpcap_if_selected);
 734     /* Remove gtk timeout */
 735     gtk_timeout_remove(airpcap_if_selected->tag);
 736
 737     /* Update toolbar (only if airpcap_if_selected is airpcap_if_active)*/
 738     if ( g_ascii_strcasecmp(airpcap_if_selected->description,airpcap_if_active->description) == 0)
 739     {
 740         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)));
 741         airpcap_update_channel_combo(GTK_WIDGET(toolbar_channel_cm),airpcap_if_selected);
 742         airpcap_validation_type_combo_set_by_type(toolbar_wrong_crc_cm,airpcap_if_selected->CrcValidationOn);
 743
 744         gtk_signal_handler_block_by_func (GTK_OBJECT(toolbar_decryption_ck),GTK_SIGNAL_FUNC(airpcap_toolbar_encryption_cb), toolbar);
 745         if (airpcap_if_active->DecryptionOn == AIRPCAP_DECRYPTION_ON)
 746             gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toolbar_decryption_ck),TRUE);
 747         else
 748             gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toolbar_decryption_ck),FALSE);
 749         gtk_signal_handler_unblock_by_func (GTK_OBJECT(toolbar_decryption_ck),GTK_SIGNAL_FUNC(airpcap_toolbar_encryption_cb), toolbar);
 750     }
 751 }
 752
 753 /*
 754  * Callback for the 'Reset Configuration' button.
 755  */
 756 void
 757 on_reset_configuration_bt_clicked(GtkWidget *button, gpointer data _U_)
 758 {
 759     return;
 760 }
 761
 762 /*
 763  * Callback used to add a WEP key in the add new key box;
 764  */
 765 static void
 766 on_add_key_ok_bt_clicked(GtkWidget *widget, gpointer data _U_)
 767 {
 768     GtkWidget   *type_cm,
 769     *key_en,
 770     *ssid_en;
 771
 772     GtkWidget   *key_ls;
 773
 774     GString     *new_type_string,
 775     *new_key_string,
 776     *new_ssid_string;
 777
 778     gchar               *type_entered = NULL;
 779     gchar               *key_entered = NULL;
 780     gchar               *ssid_entered = NULL;
 781
 782     airpcap_key_ls_selected_info_t *selected_item;
 783
 784     int keys_in_list = 0;
 785
 786     unsigned int i;
 787
 788     gint r = NO_ROW_SELECTED;
 789     gint c = NO_COLUMN_SELECTED;
 790
 791     key_ls = g_object_get_data(G_OBJECT(data),AIRPCAP_ADVANCED_ADD_KEY_LIST_KEY);
 792     selected_item = g_object_get_data(G_OBJECT(data),AIRPCAP_ADVANCED_SELECTED_KEY_LIST_ITEM_KEY);
 793     type_cm = g_object_get_data(G_OBJECT(data),AIRPCAP_ADVANCED_ADD_KEY_TYPE_KEY);
 794     key_en = g_object_get_data(G_OBJECT(data),AIRPCAP_ADVANCED_ADD_KEY_KEY_KEY);
 795     ssid_en = g_object_get_data(G_OBJECT(data),AIRPCAP_ADVANCED_ADD_KEY_SSID_KEY);
 796
 797     r = selected_item->row;
 798     c = selected_item->column;
 799
 800     keys_in_list = GTK_CLIST(key_ls)->rows;
 801
 802     type_entered = g_strdup(gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(type_cm)->entry)));
 803     key_entered  = g_strdup(gtk_entry_get_text(GTK_ENTRY(key_en)));
 804     ssid_entered = g_strdup(gtk_entry_get_text(GTK_ENTRY(ssid_en)));
 805
 806     /* Check if key is correct */
 807     new_type_string = g_string_new(type_entered);
 808     new_key_string = g_string_new(key_entered);
 809     new_ssid_string = g_string_new(ssid_entered);
 810
 811     g_strchug(new_key_string->str);
 812     g_strchomp(new_key_string->str);
 813
 814     g_strchug(new_ssid_string->str);
 815     g_strchomp(new_ssid_string->str);
 816
 817     /* Check which type of key the user has entered */
 818     if (g_ascii_strcasecmp(new_type_string->str,AIRPCAP_WEP_KEY_STRING) == 0) /* WEP key */
 819     {
 820
 821         if ( ((new_key_string->len) > WEP_KEY_MAX_CHAR_SIZE) || ((new_key_string->len) < WEP_KEY_MIN_CHAR_SIZE))
 822         {
 823             simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"WEP key size out of range!\nValid key size range is %d-%d characters (%d-%d bits).",WEP_KEY_MIN_CHAR_SIZE,WEP_KEY_MAX_CHAR_SIZE,WEP_KEY_MIN_BIT_SIZE,WEP_KEY_MAX_BIT_SIZE);
 824
 825             g_string_free(new_type_string,TRUE);
 826             g_string_free(new_key_string, TRUE);
 827             g_string_free(new_ssid_string,TRUE);
 828
 829             g_free(type_entered);
 830             g_free(key_entered );
 831             g_free(ssid_entered);
 832             return;
 833         }
 834
 835         if ((new_key_string->len % 2) != 0)
 836         {
 837             simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"Invalid WEP key!\nThe number of characters must be even.");
 838
 839             g_string_free(new_type_string,TRUE);
 840             g_string_free(new_key_string, TRUE);
 841             g_string_free(new_ssid_string,TRUE);
 842
 843             g_free(type_entered);
 844             g_free(key_entered );
 845             g_free(ssid_entered);
 846             return;
 847         }
 848
 849         for (i = 0; i < new_key_string->len; i++)
 850         {
 851             if (!g_ascii_isxdigit(new_key_string->str[i]))
 852             {
 853                 simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"Invalid WEP key!\nA WEP key must be a hexadecimal number.\nThe valid characters are: 0123456789ABCDEF.");
 854
 855                 g_string_free(new_type_string,TRUE);
 856                 g_string_free(new_key_string, TRUE);
 857                 g_string_free(new_ssid_string,TRUE);
 858
 859                 g_free(type_entered);
 860                 g_free(key_entered );
 861                 g_free(ssid_entered);
 862                 return;
 863             }
 864         }
 865
 866         /* If so... add key */
 867         airpcap_add_key_to_list(key_ls, new_type_string->str, new_key_string->str, new_ssid_string->str);
 868
 869         if (airpcap_if_selected != NULL) airpcap_if_selected->saved = FALSE;
 870     }
 871     else if (g_ascii_strcasecmp(new_type_string->str,AIRPCAP_WPA_PWD_KEY_STRING) == 0) /* WPA Key */
 872     {
 873         /* XXX - Perform some WPA related input fields check */
 874         /* If everything is ok, modify the entry int he list */
 875
 876         if ( ((new_key_string->len) > WPA_KEY_MAX_CHAR_SIZE) || ((new_key_string->len) < WPA_KEY_MIN_CHAR_SIZE))
 877         {
 878             simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"WPA key size out of range!\nValid key size range is %d-%d ASCII characters (%d-%d bits).",WPA_KEY_MIN_CHAR_SIZE,WPA_KEY_MAX_CHAR_SIZE,WPA_KEY_MIN_BIT_SIZE,WPA_KEY_MAX_BIT_SIZE);
 879
 880             g_string_free(new_type_string,TRUE);
 881             g_string_free(new_key_string, TRUE);
 882             g_string_free(new_ssid_string,TRUE);
 883
 884             g_free(type_entered);
 885             g_free(key_entered );
 886             g_free(ssid_entered);
 887             return;
 888         }
 889
 890         /*
 891          * XXX - Maybe we need some check on the characters? I'm not sure if only stabdard ASCII are ok...
 892          */
 893         if ( ((new_ssid_string->len) > WPA_SSID_MAX_CHAR_SIZE) || ((new_ssid_string->len) < WPA_SSID_MIN_CHAR_SIZE))
 894         {
 895             simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"SSID key size out of range!\nValid SSID size range is %d-%d ASCII characters (%d-%d bits).",WPA_SSID_MIN_CHAR_SIZE,WPA_SSID_MAX_CHAR_SIZE,WPA_SSID_MIN_BIT_SIZE,WPA_SSID_MAX_BIT_SIZE);
 896
 897             g_string_free(new_type_string,TRUE);
 898             g_string_free(new_key_string, TRUE);
 899             g_string_free(new_ssid_string,TRUE);
 900
 901             g_free(type_entered);
 902             g_free(key_entered );
 903             g_free(ssid_entered);
 904             return;
 905         }
 906
 907         /* If so... add key */
 908         airpcap_add_key_to_list(key_ls, new_type_string->str, new_key_string->str, new_ssid_string->str);
 909
 910         if (airpcap_if_selected != NULL) airpcap_if_selected->saved = FALSE;
 911     }
 912     else if (g_ascii_strcasecmp(new_type_string->str,AIRPCAP_WPA_BIN_KEY_STRING) == 0) /* WPA_BIN Key */
 913     {
 914         /* XXX - Perform some WPA_BIN related input fields check */
 915         /* If everything is ok, modify the entry int he list */
 916
 917         if ( ((new_key_string->len) != WPA_PSK_KEY_CHAR_SIZE))
 918         {
 919             simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"WPA PSK/PMK key size is wrong!\nValid key size is %d characters (%d bits).",WPA_PSK_KEY_CHAR_SIZE,WPA_PSK_KEY_BIT_SIZE);
 920
 921             g_string_free(new_type_string,TRUE);
 922             g_string_free(new_key_string, TRUE);
 923             g_string_free(new_ssid_string,TRUE);
 924
 925             g_free(type_entered);
 926             g_free(key_entered );
 927             g_free(ssid_entered);
 928             return;
 929         }
 930
 931         for (i = 0; i < new_key_string->len; i++)
 932         {
 933             if (!g_ascii_isxdigit(new_key_string->str[i]))
 934             {
 935                 simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"Invalid WPA PSK/PMK key!\nKey must be an hexadecimal number.\nThe valid characters are: 0123456789ABCDEF.");
 936
 937                 g_string_free(new_type_string,TRUE);
 938                 g_string_free(new_key_string, TRUE);
 939                 g_string_free(new_ssid_string,TRUE);
 940
 941                 g_free(type_entered);
 942                 g_free(key_entered );
 943                 g_free(ssid_entered);
 944                 return;
 945             }
 946         }
 947
 948         /* If so... add key */
 949         airpcap_add_key_to_list(key_ls, new_type_string->str, new_key_string->str, new_ssid_string->str);
 950
 951         if (airpcap_if_selected != NULL) airpcap_if_selected->saved = FALSE;
 952     }
 953     else /* Should never happen!!! */
 954     {
 955         simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"Unknown error in the key \"Type\" field!");
 956     }
 957
 958     g_string_free(new_type_string,TRUE);
 959     g_string_free(new_key_string, TRUE);
 960     g_string_free(new_ssid_string,TRUE);
 961
 962     g_free(type_entered);
 963     g_free(key_entered );
 964     g_free(ssid_entered);
 965
 966     window_destroy(GTK_WIDGET(data));
 967     return;
 968 }
 969
 970 /*
 971  * Callback used to edit a WEP key in the edit key box;
 972  */
 973 static void
 974 on_edit_key_ok_bt_clicked(GtkWidget *widget, gpointer data _U_)
 975 {
 976     GtkWidget   *type_cm,
 977     *key_en,
 978     *ssid_en;
 979
 980     GtkWidget   *key_ls;
 981
 982     GString     *new_type_string,
 983     *new_key_string,
 984     *new_ssid_string;
 985
 986     gchar               *type_entered = NULL;
 987     gchar               *key_entered = NULL;
 988     gchar               *ssid_entered = NULL;
 989
 990     airpcap_key_ls_selected_info_t *selected_item;
 991
 992     int keys_in_list = 0;
 993
 994     unsigned int i;
 995
 996     gint r = NO_ROW_SELECTED;
 997     gint c = NO_COLUMN_SELECTED;
 998
 999     key_ls = g_object_get_data(G_OBJECT(data),AIRPCAP_ADVANCED_EDIT_KEY_LIST_KEY);
1000     selected_item = g_object_get_data(G_OBJECT(data),AIRPCAP_ADVANCED_EDIT_KEY_SELECTED_KEY);
1001     type_cm = g_object_get_data(G_OBJECT(data),AIRPCAP_ADVANCED_EDIT_KEY_TYPE_KEY);
1002     key_en = g_object_get_data(G_OBJECT(data),AIRPCAP_ADVANCED_EDIT_KEY_KEY_KEY);
1003     ssid_en = g_object_get_data(G_OBJECT(data),AIRPCAP_ADVANCED_EDIT_KEY_SSID_KEY);
1004
1005     r = selected_item->row;
1006     c = selected_item->column;
1007
1008     keys_in_list = GTK_CLIST(key_ls)->rows;
1009
1010     type_entered = g_strdup(gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(type_cm)->entry)));
1011     key_entered  = g_strdup(gtk_entry_get_text(GTK_ENTRY(key_en)));
1012     ssid_entered = g_strdup(gtk_entry_get_text(GTK_ENTRY(ssid_en)));
1013
1014     /* Check if key is correct */
1015     new_type_string = g_string_new(type_entered);
1016     new_key_string = g_string_new(key_entered);
1017     new_ssid_string = g_string_new(ssid_entered);
1018
1019     g_strchug(new_key_string->str);
1020     g_strchomp(new_key_string->str);
1021
1022     g_strchug(new_ssid_string->str);
1023     g_strchomp(new_ssid_string->str);
1024
1025     /* Check which type of key the user has entered */
1026     if (g_ascii_strcasecmp(new_type_string->str,AIRPCAP_WEP_KEY_STRING) == 0) /* WEP key */
1027     {
1028
1029         if ( ((new_key_string->len) > WEP_KEY_MAX_CHAR_SIZE) || ((new_key_string->len) < WEP_KEY_MIN_CHAR_SIZE))
1030         {
1031             simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"WEP key size out of range!\nValid key size range is %d-%d characters (%d-%d bits).",WEP_KEY_MIN_CHAR_SIZE,WEP_KEY_MAX_CHAR_SIZE,WEP_KEY_MIN_BIT_SIZE,WEP_KEY_MAX_BIT_SIZE);
1032
1033             g_string_free(new_type_string,TRUE);
1034             g_string_free(new_key_string, TRUE);
1035             g_string_free(new_ssid_string,TRUE);
1036
1037             g_free(type_entered);
1038             g_free(key_entered );
1039             g_free(ssid_entered);
1040             return;
1041         }
1042
1043         if ((new_key_string->len % 2) != 0)
1044         {
1045             simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"Invalid WEP key!\nThe number of characters must be even.");
1046
1047             g_string_free(new_type_string,TRUE);
1048             g_string_free(new_key_string, TRUE);
1049             g_string_free(new_ssid_string,TRUE);
1050
1051             g_free(type_entered);
1052             g_free(key_entered );
1053             g_free(ssid_entered);
1054             return;
1055         }
1056
1057         for (i = 0; i < new_key_string->len; i++)
1058         {
1059             if (!g_ascii_isxdigit(new_key_string->str[i]))
1060             {
1061                 simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"Invalid WEP key!\nA WEP key must be an hexadecimal number.\nThe valid characters are: 0123456789ABCDEF.");
1062
1063                 g_string_free(new_type_string,TRUE);
1064                 g_string_free(new_key_string, TRUE);
1065                 g_string_free(new_ssid_string,TRUE);
1066
1067                 g_free(type_entered);
1068                 g_free(key_entered );
1069                 g_free(ssid_entered);
1070                 return;
1071             }
1072         }
1073
1074         /* If so... Modify key */
1075         airpcap_modify_key_in_list(key_ls, r, new_type_string->str, new_key_string->str, new_ssid_string->str);
1076
1077         if (airpcap_if_selected != NULL) airpcap_if_selected->saved = FALSE;
1078     }
1079     else if (g_ascii_strcasecmp(new_type_string->str,AIRPCAP_WPA_PWD_KEY_STRING) == 0) /* WPA Key */
1080     {
1081         /* XXX - Perform some WPA related input fields check */
1082         /* If everything is ok, modify the entry int he list */
1083
1084         if ( ((new_key_string->len) > WPA_KEY_MAX_CHAR_SIZE) || ((new_key_string->len) < WPA_KEY_MIN_CHAR_SIZE))
1085         {
1086             simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"WPA key size out of range!\nValid key size range is %d-%d ASCII characters (%d-%d bits).",WPA_KEY_MIN_CHAR_SIZE,WPA_KEY_MAX_CHAR_SIZE,WPA_KEY_MIN_BIT_SIZE,WPA_KEY_MAX_BIT_SIZE);
1087
1088             g_string_free(new_type_string,TRUE);
1089             g_string_free(new_key_string, TRUE);
1090             g_string_free(new_ssid_string,TRUE);
1091
1092             g_free(type_entered);
1093             g_free(key_entered );
1094             g_free(ssid_entered);
1095             return;
1096         }
1097
1098         /*
1099          * XXX - Maybe we need some check on the characters? I'm not sure if only stabdard ASCII are ok...
1100          */
1101         if ( ((new_ssid_string->len) > WPA_SSID_MAX_CHAR_SIZE) || ((new_ssid_string->len) < WPA_SSID_MIN_CHAR_SIZE))
1102         {
1103             simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"SSID key size out of range!\nValid SSID size range is %d-%d ASCII characters (%d-%d bits).",WPA_SSID_MIN_CHAR_SIZE,WPA_SSID_MAX_CHAR_SIZE,WPA_SSID_MIN_BIT_SIZE,WPA_SSID_MAX_BIT_SIZE);
1104
1105             g_string_free(new_type_string,TRUE);
1106             g_string_free(new_key_string, TRUE);
1107             g_string_free(new_ssid_string,TRUE);
1108
1109             g_free(type_entered);
1110             g_free(key_entered );
1111             g_free(ssid_entered);
1112             return;
1113         }
1114
1115         /* If so... Modify key */
1116         airpcap_modify_key_in_list(key_ls, r, new_type_string->str, new_key_string->str, new_ssid_string->str);
1117
1118         if (airpcap_if_selected != NULL) airpcap_if_selected->saved = FALSE;
1119     }
1120     else if (g_ascii_strcasecmp(new_type_string->str,AIRPCAP_WPA_BIN_KEY_STRING) == 0) /* WPA_BIN Key */
1121     {
1122         /* XXX - Perform some WPA_BIN related input fields check */
1123         /* If everything is ok, modify the entry int he list */
1124
1125         if ( ((new_key_string->len) != WPA_PSK_KEY_CHAR_SIZE))
1126         {
1127             simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"WPA PSK/PMK key size is wrong!\nValid key size is %d characters (%d bits).",WPA_PSK_KEY_CHAR_SIZE,WPA_PSK_KEY_BIT_SIZE);
1128
1129             g_string_free(new_type_string,TRUE);
1130             g_string_free(new_key_string, TRUE);
1131             g_string_free(new_ssid_string,TRUE);
1132
1133             g_free(type_entered);
1134             g_free(key_entered );
1135             g_free(ssid_entered);
1136             return;
1137         }
1138
1139         for (i = 0; i < new_key_string->len; i++)
1140         {
1141             if (!g_ascii_isxdigit(new_key_string->str[i]))
1142             {
1143                 simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"Invalid WPA PSK/PMK key!\nKey must be an hexadecimal number.\nThe valid characters are: 0123456789ABCDEF.");
1144
1145                 g_string_free(new_type_string,TRUE);
1146                 g_string_free(new_key_string, TRUE);
1147                 g_string_free(new_ssid_string,TRUE);
1148
1149                 g_free(type_entered);
1150                 g_free(key_entered );
1151                 g_free(ssid_entered);
1152                 return;
1153             }
1154         }
1155
1156         /* If so... Modify key */
1157         airpcap_modify_key_in_list(key_ls, r, new_type_string->str, new_key_string->str, new_ssid_string->str);
1158
1159         if (airpcap_if_selected != NULL) airpcap_if_selected->saved = FALSE;
1160     }
1161     else /* Should never happen!!! */
1162     {
1163         simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"Unknown error in the key \"Type\" field!");
1164     }
1165
1166     g_string_free(new_type_string,TRUE);
1167     g_string_free(new_key_string, TRUE);
1168     g_string_free(new_ssid_string,TRUE);
1169
1170     g_free(type_entered);
1171     g_free(key_entered );
1172     g_free(ssid_entered);
1173
1174     window_destroy(GTK_WIDGET(data));
1175     return;
1176 }
1177
1178 /*
1179  * Callback for the 'Add Key' button.
1180  */
1181 void
1182 on_add_new_key_bt_clicked(GtkWidget *button, gpointer data _U_)
1183 {
1184     GtkWidget *add_key_window;
1185     GtkWidget *add_frame;
1186     GtkWidget *main_v_box;
1187     GtkWidget *add_tb;
1188     GtkWidget *add_frame_al;
1189     GtkWidget *add_type_cm;
1190     GList *add_type_cm_items = NULL;
1191     GtkWidget *add_type_en;
1192     GtkWidget *add_key_te;
1193     GtkWidget *add_ssid_te;
1194     GtkWidget *add_type_lb;
1195     GtkWidget *add_key_lb;
1196     GtkWidget *add_ssid_lb;
1197     GtkWidget *low_h_button_box;
1198     GtkWidget *ok_bt;
1199     GtkWidget *cancel_bt;
1200     GtkWidget *add_frame_lb;
1201
1202     GtkWidget *airpcap_advanced_w;
1203
1204     /* Key List Widget */
1205     GtkWidget   *key_ls;
1206
1207     gint keys_in_list = 0;
1208
1209     /* Selected entry in the key list (if any)*/
1210     airpcap_key_ls_selected_info_t* selected_item;
1211
1212     gint r,c;
1213
1214     airpcap_advanced_w = GTK_WIDGET(data);
1215
1216     /* Retrieve the selected item... if no row is selected, this is null... */
1217     selected_item = g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_ADVANCED_SELECTED_KEY_LIST_ITEM_KEY);
1218
1219     r = selected_item->row;
1220     c = selected_item->column;
1221
1222     /* Retrieve the key list widget pointer, and add it to the add_key_w */
1223     key_ls = g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_ADVANCED_KEYLIST_KEY);
1224
1225     keys_in_list = GTK_CLIST(key_ls)->rows;
1226
1227     if (keys_in_list >= MAX_ENCRYPTION_KEYS) /* Check if we have already reached the maximum number of allowed keys... */
1228     {
1229         simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"Maximum number (%d) of decryption keys reached! You cannot add another key!\n",MAX_ENCRYPTION_KEYS);
1230         return;
1231     }
1232
1233     /* Gray out the Advanced Wireless Setting window */
1234     gtk_widget_set_sensitive(airpcap_advanced_w,FALSE);
1235
1236     /* Pop-up a new window */
1237     add_key_window = window_new (GTK_WINDOW_TOPLEVEL, "Add Decryption Key");
1238     gtk_widget_set_name (add_key_window, "add_key_window");
1239     gtk_container_set_border_width (GTK_CONTAINER (add_key_window), 5);
1240     gtk_window_set_resizable (GTK_WINDOW (add_key_window), FALSE);
1241
1242     main_v_box = gtk_vbox_new (FALSE, 0);
1243     gtk_widget_set_name (main_v_box, "main_v_box");
1244     gtk_widget_show (main_v_box);
1245     gtk_container_add (GTK_CONTAINER (add_key_window), main_v_box);
1246
1247     add_frame = gtk_frame_new (NULL);
1248     gtk_widget_set_name (add_frame, "add_frame");
1249     gtk_widget_show (add_frame);
1250     gtk_box_pack_start (GTK_BOX (main_v_box), add_frame, TRUE, TRUE, 0);
1251
1252     add_frame_al = gtk_alignment_new (0.5, 0.5, 1, 1);
1253     gtk_widget_set_name (add_frame_al, "add_frame_al");
1254     gtk_widget_show (add_frame_al);
1255     gtk_container_add (GTK_CONTAINER (add_frame), add_frame_al);
1256     gtk_alignment_set_padding (GTK_ALIGNMENT (add_frame_al), 0, 0, 12, 0);
1257
1258     add_tb = gtk_table_new (2, 3, FALSE);
1259     gtk_widget_set_name (add_tb, "add_tb");
1260     gtk_container_set_border_width(GTK_CONTAINER(add_tb),5);
1261     gtk_widget_show (add_tb);
1262     gtk_container_add (GTK_CONTAINER (add_frame_al), add_tb);
1263
1264     add_type_cm = gtk_combo_new ();
1265     gtk_widget_set_name (add_type_cm, "add_type_cm");
1266     gtk_widget_show (add_type_cm);
1267     gtk_table_attach (GTK_TABLE (add_tb), add_type_cm, 0, 1, 1, 2,
1268                       (GtkAttachOptions) (GTK_FILL),
1269                       (GtkAttachOptions) (0), 0, 0);
1270     gtk_widget_set_size_request (add_type_cm, 83, -1);
1271     add_type_cm_items = g_list_append (add_type_cm_items, (gpointer) AIRPCAP_WEP_KEY_STRING);
1272
1273     /* XXX - DEcomment only when WPA and WPA_BIN will be ready */
1274 #ifdef HAVE_AIRPDCAP
1275     add_type_cm_items = g_list_append (add_type_cm_items, (gpointer) AIRPCAP_WPA_PWD_KEY_STRING);
1276     add_type_cm_items = g_list_append (add_type_cm_items, (gpointer) AIRPCAP_WPA_BIN_KEY_STRING);
1277 #endif
1278     gtk_combo_set_popdown_strings (GTK_COMBO (add_type_cm),
1279                                    add_type_cm_items);
1280     g_list_free (add_type_cm_items);
1281
1282     add_type_en = GTK_COMBO (add_type_cm)->entry;
1283     gtk_widget_set_name (add_type_en, "add_type_en");
1284     gtk_editable_set_editable (GTK_EDITABLE (add_type_en), FALSE);
1285     gtk_widget_show (add_type_en);
1286
1287     add_key_te = gtk_entry_new ();
1288     gtk_widget_set_name (add_key_te, "add_key_te");
1289
1290     gtk_widget_show (add_key_te);
1291     gtk_table_attach (GTK_TABLE (add_tb), add_key_te, 1, 2, 1, 2,
1292                       (GtkAttachOptions) (0), (GtkAttachOptions) (0), 0, 0);
1293     gtk_widget_set_size_request (add_key_te, 178, -1);
1294
1295     add_ssid_te = gtk_entry_new ();
1296     gtk_widget_set_name (add_ssid_te, "add_ssid_te");
1297     gtk_widget_set_sensitive(add_ssid_te,FALSE);
1298     /* XXX - Decomment only when WPA and WPA_BIN will be ready */
1299     gtk_widget_show (add_ssid_te);
1300     gtk_table_attach (GTK_TABLE (add_tb), add_ssid_te, 2, 3, 1, 2,
1301                       (GtkAttachOptions) (0), (GtkAttachOptions) (0), 0, 0);
1302
1303     add_type_lb = gtk_label_new ("Type");
1304     gtk_widget_set_name (add_type_lb, "add_type_lb");
1305     gtk_widget_show (add_type_lb);
1306     gtk_table_attach (GTK_TABLE (add_tb), add_type_lb, 0, 1, 0, 1,
1307                       (GtkAttachOptions) (GTK_FILL),
1308                       (GtkAttachOptions) (0), 0, 0);
1309     gtk_label_set_justify (GTK_LABEL (add_type_lb), GTK_JUSTIFY_CENTER);
1310
1311     add_key_lb = gtk_label_new ("Key");
1312     gtk_widget_set_name (add_key_lb, "add_key_lb");
1313     gtk_widget_show (add_key_lb);
1314     gtk_table_attach (GTK_TABLE (add_tb), add_key_lb, 1, 2, 0, 1,
1315                       (GtkAttachOptions) (GTK_FILL),
1316                       (GtkAttachOptions) (0), 0, 0);
1317     gtk_label_set_justify (GTK_LABEL (add_key_lb), GTK_JUSTIFY_CENTER);
1318
1319     add_ssid_lb = gtk_label_new ("");
1320     gtk_widget_set_name (add_ssid_lb, "add_ssid_lb");
1321     /* XXX - Decomment only when WPA and WPA_BIN will be ready */
1322     gtk_widget_show (add_ssid_lb);
1323     gtk_table_attach (GTK_TABLE (add_tb), add_ssid_lb, 2, 3, 0, 1,
1324                       (GtkAttachOptions) (GTK_FILL),
1325                       (GtkAttachOptions) (0), 0, 0);
1326     gtk_label_set_justify (GTK_LABEL (add_ssid_lb), GTK_JUSTIFY_CENTER);
1327
1328     low_h_button_box = gtk_hbutton_box_new ();
1329     gtk_widget_set_name (low_h_button_box, "low_h_button_box");
1330     gtk_container_set_border_width (GTK_CONTAINER (low_h_button_box), 5);
1331     gtk_widget_show (low_h_button_box);
1332     gtk_box_pack_end (GTK_BOX (main_v_box), low_h_button_box, FALSE, FALSE, 0);
1333     gtk_button_box_set_layout (GTK_BUTTON_BOX (low_h_button_box),
1334                                GTK_BUTTONBOX_END);
1335
1336     ok_bt = gtk_button_new_with_mnemonic ("OK");
1337     gtk_widget_set_name (ok_bt, "ok_bt");
1338     gtk_widget_show (ok_bt);
1339     gtk_container_add (GTK_CONTAINER (low_h_button_box), ok_bt);
1340     GTK_WIDGET_SET_FLAGS (ok_bt, GTK_CAN_DEFAULT);
1341
1342     cancel_bt = gtk_button_new_with_mnemonic ("Cancel");
1343     gtk_widget_set_name (cancel_bt, "cancel_bt");
1344     gtk_widget_show (cancel_bt);
1345     gtk_container_add (GTK_CONTAINER (low_h_button_box), cancel_bt);
1346     GTK_WIDGET_SET_FLAGS (cancel_bt, GTK_CAN_DEFAULT);
1347
1348     add_frame_lb = gtk_label_new ("<b>Modify Selected Key</b>");
1349     gtk_widget_set_name (add_frame_lb, "add_frame_lb");
1350     gtk_widget_show (add_frame_lb);
1351     gtk_frame_set_label_widget (GTK_FRAME (add_frame), add_frame_lb);
1352     gtk_label_set_use_markup (GTK_LABEL (add_frame_lb), TRUE);
1353
1354     /* Add callbacks */
1355     g_signal_connect(ok_bt, "clicked", G_CALLBACK(on_add_key_ok_bt_clicked), add_key_window );
1356     g_signal_connect(cancel_bt, "clicked", G_CALLBACK(window_cancel_button_cb), add_key_window );
1357     g_signal_connect(add_type_en, "changed", G_CALLBACK(on_add_type_en_changed), add_key_window);
1358     g_signal_connect(add_key_window, "delete_event", G_CALLBACK(window_delete_event_cb), add_key_window);
1359     g_signal_connect(add_key_window, "destroy", G_CALLBACK(on_add_key_w_destroy), data);
1360
1361     /* Add widget data */
1362     g_object_set_data(G_OBJECT(add_key_window),AIRPCAP_ADVANCED_ADD_KEY_LIST_KEY,key_ls);
1363     g_object_set_data(G_OBJECT(add_key_window),AIRPCAP_ADVANCED_SELECTED_KEY_LIST_ITEM_KEY,selected_item);
1364     g_object_set_data(G_OBJECT(add_key_window),AIRPCAP_ADVANCED_ADD_KEY_TYPE_KEY,add_type_cm);
1365     g_object_set_data(G_OBJECT(add_key_window),AIRPCAP_ADVANCED_ADD_KEY_KEY_KEY,add_key_te);
1366     g_object_set_data(G_OBJECT(add_key_window),AIRPCAP_ADVANCED_ADD_KEY_SSID_KEY,add_ssid_te);
1367     g_object_set_data(G_OBJECT(add_key_window),AIRPCAP_ADVANCED_ADD_KEY_KEY_LABEL_KEY,add_key_lb);
1368     g_object_set_data(G_OBJECT(add_key_window),AIRPCAP_ADVANCED_ADD_KEY_SSID_LABEL_KEY,add_ssid_lb);
1369
1370     gtk_widget_show(add_key_window);
1371 }
1372
1373 /*
1374  * Add key window destroy callback
1375  */
1376 static void
1377 add_key_w_destroy_cb(GtkWidget *button, gpointer data _U_)
1378 {
1379     return;
1380 }
1381
1382 /*
1383  * Edit key window destroy callback
1384  */
1385 void
1386 on_edit_key_w_destroy(GtkWidget *button, gpointer data _U_)
1387 {
1388     GtkWidget *airpcap_advanced_w;
1389
1390     airpcap_advanced_w = GTK_WIDGET(data);
1391
1392     gtk_widget_set_sensitive(GTK_WIDGET(airpcap_advanced_w),TRUE);
1393
1394     return;
1395 }
1396
1397 /*
1398  * Add key window destroy callback
1399  */
1400 void
1401 on_add_key_w_destroy(GtkWidget *button, gpointer data _U_)
1402 {
1403     GtkWidget *airpcap_advanced_w;
1404
1405     airpcap_advanced_w = GTK_WIDGET(data);
1406
1407     gtk_widget_set_sensitive(GTK_WIDGET(airpcap_advanced_w),TRUE);
1408
1409     return;
1410 }
1411
1412 /*
1413  * Callback for the 'Remove Key' button.
1414  */
1415 void
1416 on_remove_key_bt_clicked(GtkWidget *button, gpointer data _U_)
1417 {
1418     GtkWidget *key_ls;
1419     GtkWidget *airpcap_advanced_w;
1420
1421     gint keys_in_list;
1422
1423     airpcap_key_ls_selected_info_t *selected_item;
1424
1425     gint c = NO_COLUMN_SELECTED;
1426     gint r = NO_ROW_SELECTED;
1427
1428     airpcap_advanced_w = GTK_WIDGET(data);
1429
1430     /* retrieve needed stuff */
1431     key_ls        = g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_ADVANCED_KEYLIST_KEY);
1432     selected_item = g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_ADVANCED_SELECTED_KEY_LIST_ITEM_KEY);
1433
1434     /*
1435      * Better to store the selected_item data in two new variables, because maybe some
1436      * select_row signal will be emitted somewhere...
1437      */
1438     r = selected_item->row;
1439     c = selected_item->column;
1440
1441     keys_in_list = GTK_CLIST(key_ls)->rows;
1442
1443     if ( r == NO_ROW_SELECTED ) /* No key selected */
1444         return;
1445
1446     /* Remove selected key*/
1447     gtk_clist_remove(GTK_CLIST(key_ls),r);
1448
1449     /* Reselect another row, if any... */
1450     if ( r < (keys_in_list-1) )
1451         gtk_clist_select_row(GTK_CLIST(key_ls),r,c);
1452     else
1453         gtk_clist_select_row(GTK_CLIST(key_ls),r-1,c);
1454
1455     /* Need to save config... */
1456     if (airpcap_if_selected != NULL) airpcap_if_selected->saved = FALSE;
1457 }
1458
1459 /*
1460  * Callback for the 'Edit Key' button.
1461  */
1462 void
1463 on_edit_key_bt_clicked(GtkWidget *button, gpointer data _U_)
1464 {
1465     GtkWidget *edit_key_window;
1466     GtkWidget *edit_frame;
1467     GtkWidget *main_v_box;
1468     GtkWidget *edit_tb;
1469     GtkWidget *edit_frame_al;
1470     GtkWidget *edit_type_cm;
1471     GList *edit_type_cm_items = NULL;
1472     GtkWidget *edit_type_en;
1473     GtkWidget *edit_key_te;
1474     GtkWidget *edit_ssid_te;
1475     GtkWidget *edit_type_lb;
1476     GtkWidget *edit_key_lb;
1477     GtkWidget *edit_ssid_lb;
1478     GtkWidget *low_h_button_box;
1479     GtkWidget *ok_bt;
1480     GtkWidget *cancel_bt;
1481     GtkWidget *edit_frame_lb;
1482
1483     GtkWidget *airpcap_advanced_w;
1484
1485     /* Key List Widget */
1486     GtkWidget   *key_ls;
1487
1488     /* Selected entry in the key list (if any)*/
1489     airpcap_key_ls_selected_info_t* selected_item;
1490
1491     gchar *row_type,
1492     *row_key,
1493     *row_ssid;
1494
1495     gint r,c;
1496
1497     airpcap_advanced_w = GTK_WIDGET(data);
1498
1499     /* Retrieve the selected item... if no row is selected, this is null... */
1500     selected_item = g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_ADVANCED_SELECTED_KEY_LIST_ITEM_KEY);
1501
1502     r = selected_item->row;
1503     c = selected_item->column;
1504
1505     /* Retrieve the key list widget pointer, and add it to the edit_key_w */
1506     key_ls = g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_ADVANCED_KEYLIST_KEY);
1507
1508     if ((r != NO_ROW_SELECTED) && (c != NO_COLUMN_SELECTED))
1509     {
1510         gtk_clist_get_text(GTK_CLIST(key_ls),r,0,&row_type);
1511         gtk_clist_get_text(GTK_CLIST(key_ls),r,1,&row_key);
1512         gtk_clist_get_text(GTK_CLIST(key_ls),r,2,&row_ssid);
1513
1514         /* Gray out the Advanced Wireless Setting window */
1515         gtk_widget_set_sensitive(airpcap_advanced_w,FALSE);
1516
1517         /* Pop-up a new window */
1518         edit_key_window = window_new (GTK_WINDOW_TOPLEVEL, "Edit Decryption Key");
1519         gtk_widget_set_name (edit_key_window, "edit_key_window");
1520         gtk_container_set_border_width (GTK_CONTAINER (edit_key_window), 5);
1521         gtk_window_set_resizable (GTK_WINDOW (edit_key_window), FALSE);
1522
1523         main_v_box = gtk_vbox_new (FALSE, 0);
1524         gtk_widget_set_name (main_v_box, "main_v_box");
1525         gtk_widget_show (main_v_box);
1526         gtk_container_add (GTK_CONTAINER (edit_key_window), main_v_box);
1527
1528         edit_frame = gtk_frame_new (NULL);
1529         gtk_widget_set_name (edit_frame, "edit_frame");
1530         gtk_widget_show (edit_frame);
1531         gtk_box_pack_start (GTK_BOX (main_v_box), edit_frame, TRUE, TRUE, 0);
1532
1533         edit_frame_al = gtk_alignment_new (0.5, 0.5, 1, 1);
1534         gtk_widget_set_name (edit_frame_al, "edit_frame_al");
1535         gtk_widget_show (edit_frame_al);
1536         gtk_container_add (GTK_CONTAINER (edit_frame), edit_frame_al);
1537         gtk_alignment_set_padding (GTK_ALIGNMENT (edit_frame_al), 0, 0, 12, 0);
1538
1539         edit_tb = gtk_table_new (2, 3, FALSE);
1540         gtk_widget_set_name (edit_tb, "edit_tb");
1541         gtk_container_set_border_width(GTK_CONTAINER(edit_tb),5);
1542         gtk_widget_show (edit_tb);
1543         gtk_container_add (GTK_CONTAINER (edit_frame_al), edit_tb);
1544
1545         edit_type_cm = gtk_combo_new ();
1546         gtk_widget_set_name (edit_type_cm, "edit_type_cm");
1547         gtk_widget_show (edit_type_cm);
1548         gtk_table_attach (GTK_TABLE (edit_tb), edit_type_cm, 0, 1, 1, 2,
1549                           (GtkAttachOptions) (GTK_FILL),
1550                           (GtkAttachOptions) (0), 0, 0);
1551         gtk_widget_set_size_request (edit_type_cm, 83, -1);
1552         edit_type_cm_items = g_list_append (edit_type_cm_items, (gpointer) AIRPCAP_WEP_KEY_STRING);
1553         /* XXX - Decomment only when WPA and WPA_BIN support will be ready!!! */
1554 #ifdef HAVE_AIRPDCAP
1555         edit_type_cm_items = g_list_append (edit_type_cm_items, (gpointer) AIRPCAP_WPA_PWD_KEY_STRING);
1556         edit_type_cm_items = g_list_append (edit_type_cm_items, (gpointer) AIRPCAP_WPA_BIN_KEY_STRING);
1557 #endif
1558         gtk_combo_set_popdown_strings (GTK_COMBO (edit_type_cm),
1559                                        edit_type_cm_items);
1560         g_list_free (edit_type_cm_items);
1561
1562         edit_type_en = GTK_COMBO (edit_type_cm)->entry;
1563         gtk_widget_set_name (edit_type_en, "edit_type_en");
1564         /* Set current type */
1565         gtk_entry_set_text(GTK_ENTRY(edit_type_en),row_type);
1566         gtk_editable_set_editable (GTK_EDITABLE (edit_type_en), FALSE);
1567         gtk_widget_show (edit_type_en);
1568
1569         edit_key_te = gtk_entry_new ();
1570         gtk_widget_set_name (edit_key_te, "edit_key_te");
1571         /* Set current key */
1572         gtk_entry_set_text(GTK_ENTRY(edit_key_te),row_key);
1573         gtk_widget_show (edit_key_te);
1574         gtk_table_attach (GTK_TABLE (edit_tb), edit_key_te, 1, 2, 1, 2,
1575                           (GtkAttachOptions) (0), (GtkAttachOptions) (0), 0, 0);
1576         gtk_widget_set_size_request (edit_key_te, 178, -1);
1577
1578         edit_ssid_te = gtk_entry_new ();
1579         gtk_widget_set_name (edit_ssid_te, "edit_ssid_te");
1580
1581         /* Set current ssid (if key type is not WEP!)*/
1582         if (g_ascii_strcasecmp(row_type,AIRPCAP_WEP_KEY_STRING) == 0)
1583         {
1584             gtk_widget_set_sensitive(edit_ssid_te,FALSE);
1585         }
1586         else
1587         {
1588             gtk_widget_set_sensitive(edit_ssid_te,TRUE);
1589             gtk_entry_set_text(GTK_ENTRY(edit_ssid_te),row_ssid);
1590         }
1591
1592         /* XXX - Decomment only when WPA and WPA@ will be ready */
1593 #ifdef HAVE_AIRPDCAP
1594         gtk_widget_show (edit_ssid_te);
1595 #endif
1596         gtk_table_attach (GTK_TABLE (edit_tb), edit_ssid_te, 2, 3, 1, 2,
1597                           (GtkAttachOptions) (0), (GtkAttachOptions) (0), 0, 0);
1598
1599         edit_type_lb = gtk_label_new ("Type");
1600         gtk_widget_set_name (edit_type_lb, "edit_type_lb");
1601         gtk_widget_show (edit_type_lb);
1602         gtk_table_attach (GTK_TABLE (edit_tb), edit_type_lb, 0, 1, 0, 1,
1603                           (GtkAttachOptions) (GTK_FILL),
1604                           (GtkAttachOptions) (0), 0, 0);
1605         gtk_label_set_justify (GTK_LABEL (edit_type_lb), GTK_JUSTIFY_CENTER);
1606
1607         edit_key_lb = gtk_label_new ("Key");
1608         gtk_widget_set_name (edit_key_lb, "edit_key_lb");
1609         gtk_widget_show (edit_key_lb);
1610         gtk_table_attach (GTK_TABLE (edit_tb), edit_key_lb, 1, 2, 0, 1,
1611                           (GtkAttachOptions) (GTK_FILL),
1612                           (GtkAttachOptions) (0), 0, 0);
1613         gtk_label_set_justify (GTK_LABEL (edit_key_lb), GTK_JUSTIFY_CENTER);
1614
1615         edit_ssid_lb = gtk_label_new ("");
1616         gtk_widget_set_name (edit_ssid_lb, "edit_ssid_lb");
1617         /* XXX - Decomment only when WPA and WPA_BIN will be ready */
1618         gtk_widget_show (edit_ssid_lb);
1619         gtk_table_attach (GTK_TABLE (edit_tb), edit_ssid_lb, 2, 3, 0, 1,
1620                           (GtkAttachOptions) (GTK_FILL),
1621                           (GtkAttachOptions) (0), 0, 0);
1622         gtk_label_set_justify (GTK_LABEL (edit_ssid_lb), GTK_JUSTIFY_CENTER);
1623
1624         low_h_button_box = gtk_hbutton_box_new ();
1625         gtk_widget_set_name (low_h_button_box, "low_h_button_box");
1626         gtk_container_set_border_width (GTK_CONTAINER (low_h_button_box), 5);
1627         gtk_widget_show (low_h_button_box);
1628         gtk_box_pack_end (GTK_BOX (main_v_box), low_h_button_box, FALSE, FALSE, 0);
1629         gtk_button_box_set_layout (GTK_BUTTON_BOX (low_h_button_box),
1630                                    GTK_BUTTONBOX_END);
1631
1632         ok_bt = gtk_button_new_with_mnemonic ("OK");
1633         gtk_widget_set_name (ok_bt, "ok_bt");
1634         gtk_widget_show (ok_bt);
1635         gtk_container_add (GTK_CONTAINER (low_h_button_box), ok_bt);
1636         GTK_WIDGET_SET_FLAGS (ok_bt, GTK_CAN_DEFAULT);
1637
1638         cancel_bt = gtk_button_new_with_mnemonic ("Cancel");
1639         gtk_widget_set_name (cancel_bt, "cancel_bt");
1640         gtk_widget_show (cancel_bt);
1641         gtk_container_add (GTK_CONTAINER (low_h_button_box), cancel_bt);
1642         GTK_WIDGET_SET_FLAGS (cancel_bt, GTK_CAN_DEFAULT);
1643
1644         edit_frame_lb = gtk_label_new ("<b>Modify Selected Key</b>");
1645         gtk_widget_set_name (edit_frame_lb, "edit_frame_lb");
1646         gtk_widget_show (edit_frame_lb);
1647         gtk_frame_set_label_widget (GTK_FRAME (edit_frame), edit_frame_lb);
1648         gtk_label_set_use_markup (GTK_LABEL (edit_frame_lb), TRUE);
1649
1650         /* Add callbacks */
1651         g_signal_connect(ok_bt, "clicked", G_CALLBACK(on_edit_key_ok_bt_clicked), edit_key_window );
1652         g_signal_connect(cancel_bt, "clicked", G_CALLBACK(window_cancel_button_cb), edit_key_window );
1653         g_signal_connect(edit_type_en, "changed", G_CALLBACK(on_edit_type_en_changed), edit_key_window);
1654         g_signal_connect(edit_key_window, "delete_event", G_CALLBACK(window_delete_event_cb), edit_key_window);
1655         g_signal_connect(edit_key_window, "destroy", G_CALLBACK(on_edit_key_w_destroy), data);
1656
1657         /* Add widget data */
1658         g_object_set_data(G_OBJECT(edit_key_window),AIRPCAP_ADVANCED_EDIT_KEY_LIST_KEY,key_ls);
1659         g_object_set_data(G_OBJECT(edit_key_window),AIRPCAP_ADVANCED_EDIT_KEY_SELECTED_KEY,selected_item);
1660         g_object_set_data(G_OBJECT(edit_key_window),AIRPCAP_ADVANCED_EDIT_KEY_TYPE_KEY,edit_type_cm);
1661         g_object_set_data(G_OBJECT(edit_key_window),AIRPCAP_ADVANCED_EDIT_KEY_KEY_KEY,edit_key_te);
1662         g_object_set_data(G_OBJECT(edit_key_window),AIRPCAP_ADVANCED_EDIT_KEY_SSID_KEY,edit_ssid_te);
1663         g_object_set_data(G_OBJECT(edit_key_window),AIRPCAP_ADVANCED_EDIT_KEY_KEY_LABEL_KEY,edit_key_lb);
1664         g_object_set_data(G_OBJECT(edit_key_window),AIRPCAP_ADVANCED_EDIT_KEY_SSID_LABEL_KEY,edit_ssid_lb);
1665
1666         gtk_widget_show(edit_key_window);
1667     }
1668 }
1669
1670 /*
1671  * Callback for the 'Move Key Up' button.
1672  */
1673 void
1674 on_move_key_up_bt_clicked(GtkWidget *button, gpointer data _U_)
1675 {
1676     GtkWidget *airpcap_advanced_w;
1677     GtkWidget *key_ls;
1678
1679     gint keys_in_list;
1680
1681     airpcap_key_ls_selected_info_t *selected_item;
1682
1683     gint c = NO_COLUMN_SELECTED;
1684     gint r = NO_ROW_SELECTED;
1685
1686     airpcap_advanced_w = GTK_WIDGET(data);
1687
1688     /* retrieve needed stuff */
1689     key_ls        = g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_ADVANCED_KEYLIST_KEY);
1690     selected_item = g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_ADVANCED_SELECTED_KEY_LIST_ITEM_KEY);
1691
1692     /*
1693      * Better to store the selected_item data in two new variables, because maybe some
1694      * select_row signal will be emitted somewhere...
1695      */
1696     r = selected_item->row;
1697     c = selected_item->column;
1698
1699     keys_in_list = GTK_CLIST(key_ls)->rows;
1700
1701     if (keys_in_list < 2) /* With less than 2 keys, nothing can be moved ... */
1702         return;
1703
1704     if ( r == 0 ) /* Cannot move up the first row */
1705         return;
1706
1707     /* Move up selected key */
1708     gtk_clist_swap_rows (GTK_CLIST(key_ls),r-1,r);
1709
1710     /*
1711      * Re-select the just moved key... so the user can keep pressing 'Move Key Up'
1712      * without re-select the row...
1713      */
1714     gtk_clist_select_row (GTK_CLIST(key_ls),r-1,c);
1715
1716     /* Need to save config... */
1717     if (airpcap_if_selected != NULL) airpcap_if_selected->saved = FALSE;
1718 }
1719
1720 /*
1721  * Callback for the 'Move Key Down' button.
1722  */
1723 void
1724 on_move_key_down_bt_clicked(GtkWidget *button, gpointer data _U_)
1725 {
1726     GtkWidget *airpcap_advanced_w;
1727     GtkWidget *key_ls;
1728
1729     gint keys_in_list;
1730
1731     airpcap_key_ls_selected_info_t *selected_item;
1732
1733     gint c = NO_COLUMN_SELECTED;
1734     gint r = NO_ROW_SELECTED;
1735
1736     airpcap_advanced_w = GTK_WIDGET(data);
1737
1738     /* retrieve needed stuff */
1739     key_ls        = g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_ADVANCED_KEYLIST_KEY);
1740     selected_item = g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_ADVANCED_SELECTED_KEY_LIST_ITEM_KEY);
1741
1742     /*
1743      * Better to store the selected_item data in two new variables, because maybe some
1744      * select_row signal will be emitted somewhere...
1745      */
1746     r = selected_item->row;
1747     c = selected_item->column;
1748
1749     keys_in_list = GTK_CLIST(key_ls)->rows;
1750
1751     if (keys_in_list < 2) /* With less than 2 keys, nothing can be moved ... */
1752         return;
1753
1754     if ( (r+1) == keys_in_list ) /* Cannot move down the last row */
1755         return;
1756
1757     /* Move down selected key */
1758     gtk_clist_swap_rows (GTK_CLIST(key_ls),r,r+1);
1759
1760     /*
1761      * Re-select the just moved key... so the user can keep pressing 'Move Key Down'
1762      * without re-select the row...
1763      */
1764     gtk_clist_select_row (GTK_CLIST(key_ls),r+1,c);
1765
1766     /* Need to save config... */
1767     if (airpcap_if_selected != NULL) airpcap_if_selected->saved = FALSE;
1768 }
1769
1770 /* Turns the decryption on or off */
1771 void
1772 on_enable_decryption_en_changed(GtkWidget *w, gpointer data)
1773 {
1774     GtkEntry *decryption_en;
1775
1776     char* decryption_mode_string = NULL;
1777
1778     decryption_en = GTK_ENTRY(w);
1779
1780     /*
1781      * This callback is called twice: when the current text is canceled ("")
1782      * and then when the 'new text' is added ("new text"). We don't really
1783      * care about the first time, and we just return.
1784      */
1785     if (g_ascii_strcasecmp(gtk_entry_get_text(decryption_en),"") == 0)
1786         return;
1787
1788     if (g_ascii_strcasecmp(gtk_entry_get_text(decryption_en),AIRPCAP_DECRYPTION_TYPE_STRING_WIRESHARK) == 0)
1789     {
1790         set_wireshark_decryption(TRUE);
1791         if (!set_airpcap_decryption(FALSE)) simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, CANT_SAVE_ERR_STR);
1792     }
1793     else if (g_ascii_strcasecmp(gtk_entry_get_text(decryption_en),AIRPCAP_DECRYPTION_TYPE_STRING_AIRPCAP) == 0)
1794     {
1795         set_wireshark_decryption(FALSE);
1796         if (!set_airpcap_decryption(TRUE)) simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, CANT_SAVE_ERR_STR);
1797     }
1798     else if (g_ascii_strcasecmp(gtk_entry_get_text(decryption_en),AIRPCAP_DECRYPTION_TYPE_STRING_NONE) == 0)
1799     {
1800         set_wireshark_decryption(FALSE);
1801         if (!set_airpcap_decryption(FALSE)) simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, CANT_SAVE_ERR_STR);
1802     }
1803
1804     /* Redissect all the packets, and re-evaluate the display filter. */
1805     cf_redissect_packets(&cfile);
1806 }
1807
1808 /*
1809  * Will fill the given combo box with the current decryption mode string
1810  */
1811 void
1812 update_decryption_mode_cm(GtkWidget *w)
1813 {
1814     /*
1815      * This ensures that the entry tet changes... the callback will return immediately, but
1816      * at least next time packets will be redissected...
1817      */
1818     gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(w)->entry),"");
1819
1820     /* Wireshark decryption is on */
1821     if (wireshark_decryption_on())
1822     {
1823         gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(w)->entry),AIRPCAP_DECRYPTION_TYPE_STRING_WIRESHARK);
1824         /* We don't know if AirPcap decryption is on or off, but we just turn it off */
1825         if (!set_airpcap_decryption(FALSE)) simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, CANT_SAVE_ERR_STR);
1826     }
1827     /* AirPcap decryption is on */
1828     else if (airpcap_decryption_on())
1829     {
1830         gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(w)->entry),AIRPCAP_DECRYPTION_TYPE_STRING_AIRPCAP);
1831     }
1832     /* No decryption enabled */
1833     else
1834     {
1835         gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(w)->entry),AIRPCAP_DECRYPTION_TYPE_STRING_NONE);
1836     }
1837
1838     return;
1839 }
1840
1841 /*
1842  * Creates the list of available decryption modes, depending on the adapters found
1843  */
1844 void
1845 update_decryption_mode_list(GtkWidget *w)
1846 {
1847     GList               *enable_decryption_cb_items = NULL;
1848     GtkWidget   *entry;
1849     gchar               *current_text;
1850
1851     if (w == NULL)
1852         return;
1853
1854     entry = GTK_COMBO(w)->entry;
1855     current_text = NULL;
1856
1857     /*
1858      * XXX - Retrieve the current 'decryption mode'. It would be better just block the
1859      * signal handler, but it doesn't work... one of these days I'll try to figure otu why...
1860      */
1861     current_text = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry)));
1862
1863     enable_decryption_cb_items = g_list_append (enable_decryption_cb_items, AIRPCAP_DECRYPTION_TYPE_STRING_NONE);
1864     enable_decryption_cb_items = g_list_append (enable_decryption_cb_items, AIRPCAP_DECRYPTION_TYPE_STRING_WIRESHARK);
1865
1866     if (airpcap_if_list != NULL && g_list_length(airpcap_if_list) > 0)
1867     {
1868         enable_decryption_cb_items = g_list_append (enable_decryption_cb_items, AIRPCAP_DECRYPTION_TYPE_STRING_AIRPCAP);
1869     }
1870     else
1871     {
1872         /* The last decryption mode was 'Driver', but no more AirPcap adapter are found */
1873         if (g_ascii_strcasecmp(current_text,AIRPCAP_DECRYPTION_TYPE_STRING_AIRPCAP) == 0)
1874         {
1875             if (current_text != NULL) g_free(current_text);
1876
1877             current_text = g_strdup(AIRPCAP_DECRYPTION_TYPE_STRING_NONE);
1878         }
1879     }
1880
1881     gtk_signal_handler_block_by_data(GTK_OBJECT(entry),(gpointer)airpcap_tb);
1882     gtk_combo_set_popdown_strings (GTK_COMBO (w), enable_decryption_cb_items);
1883     /* The 'changed' callback will be called twice */
1884     gtk_entry_set_text(GTK_ENTRY(entry),current_text);
1885     gtk_signal_handler_unblock_by_data(GTK_OBJECT(entry),(gpointer)airpcap_tb);
1886
1887     if (current_text != NULL) g_free(current_text);
1888
1889     g_list_free (enable_decryption_cb_items);
1890 }
1891
1892 /* Called to create the airpcap settings' window */
1893 void
1894 display_airpcap_advanced_cb(GtkWidget *w, gpointer data)
1895 {
1896     GtkWidget *airpcap_advanced_w;
1897     GtkWidget *main_box;
1898     GtkWidget *settings_sub_box;
1899     GtkWidget *interface_fr;
1900     GtkWidget *interface_al;
1901     GtkWidget *interface_sub_h_box;
1902     GtkWidget *interface_name_lb;
1903     GtkWidget *blink_bt;
1904     GtkWidget *interface_frame_lb;
1905     GtkWidget *basic_parameters_fr;
1906     GtkWidget *basic_parameters_al;
1907     GtkWidget *basic_parameters_tb;
1908     GtkWidget *channel_lb;
1909     GtkWidget *channel_offset_lb;
1910     GtkWidget *capture_type_lb;
1911     GtkWidget *channel_cm;
1912     GList *channel_cm_items = NULL;
1913     GtkWidget *channel_en;
1914     GtkWidget *capture_type_cm;
1915     GtkWidget *channel_offset_cb;
1916     GList *capture_type_cm_items = NULL;
1917     GtkWidget *capture_type_en;
1918     GtkWidget *fcs_ck;
1919     GtkWidget *basic_parameters_fcs_h_box;
1920     GtkWidget *basic_parameters_fcs_filter_lb;
1921     GtkWidget *fcs_filter_cm;
1922     GList *fcs_filter_cm_items = NULL;
1923     GtkWidget *fcs_filter_en;
1924     GtkWidget *basic_parameters_frame_lb;
1925     GtkWidget *low_buttons_h_box;
1926     GtkWidget *left_h_button_box;
1927     GtkWidget *reset_configuration_bt;
1928     GtkWidget *right_h_button_box;
1929     GtkWidget *ok_bt;
1930     GtkWidget *apply_bt;
1931     GtkWidget *cancel_bt;
1932
1933     /* for loop counter */
1934     guint i;
1935
1936     /* widgets in the toolbar */
1937     GtkWidget   *toolbar,
1938     *toolbar_if_lb,
1939     *toolbar_channel_cm,
1940     *toolbar_wrong_crc_cm;
1941
1942     /* other stuff */
1943     /*GList                             *channel_list,*capture_list;*/
1944     /*GList                             *linktype_list = NULL;*/
1945     gchar                               *capture_s;
1946
1947     /* user data - RETRIEVE pointers of toolbar widgets */
1948     toolbar                             = GTK_WIDGET(data);
1949     toolbar_if_lb               = GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_INTERFACE_KEY));
1950     toolbar_channel_cm  = GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_CHANNEL_KEY));
1951     toolbar_wrong_crc_cm= GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_FCS_FILTER_KEY));
1952
1953     /* gray out the toolbar */
1954     gtk_widget_set_sensitive(toolbar,FALSE);
1955
1956     /* main window */
1957     /* global */
1958
1959     /* NULL to global widgets */
1960     block_advanced_signals = FALSE;
1961
1962     /* the selected is the active, for now */
1963     airpcap_if_selected = airpcap_if_active;
1964
1965     /* Create the new window */
1966     airpcap_advanced_w = window_new(GTK_WINDOW_TOPLEVEL, "Advanced Wireless Settings");
1967
1968     gtk_container_set_border_width (GTK_CONTAINER (airpcap_advanced_w), 5);
1969     gtk_window_set_position (GTK_WINDOW (airpcap_advanced_w),
1970                              GTK_WIN_POS_CENTER);
1971
1972     gtk_window_set_resizable (GTK_WINDOW (airpcap_advanced_w), FALSE);
1973     gtk_window_set_type_hint (GTK_WINDOW (airpcap_advanced_w), GDK_WINDOW_TYPE_HINT_DIALOG);
1974
1975     main_box = gtk_vbox_new (FALSE, 0);
1976     gtk_widget_set_name (main_box, "main_box");
1977     gtk_widget_show (main_box);
1978     gtk_container_add (GTK_CONTAINER (airpcap_advanced_w), main_box);
1979
1980     settings_sub_box = gtk_vbox_new (FALSE, 0);
1981     gtk_widget_set_name (settings_sub_box, "settings_sub_box");
1982     gtk_widget_show (settings_sub_box);
1983     gtk_box_pack_start (GTK_BOX (main_box), settings_sub_box, FALSE, TRUE, 0);
1984
1985     interface_fr = gtk_frame_new (NULL);
1986     gtk_widget_set_name (interface_fr, "interface_fr");
1987     gtk_widget_show (interface_fr);
1988     gtk_box_pack_start (GTK_BOX (settings_sub_box), interface_fr, FALSE, FALSE,
1989                         0);
1990     gtk_container_set_border_width (GTK_CONTAINER (interface_fr), 10);
1991
1992     interface_al = gtk_alignment_new (0.5, 0.5, 1, 1);
1993     gtk_widget_set_name (interface_al, "interface_al");
1994     gtk_widget_show (interface_al);
1995     gtk_container_add (GTK_CONTAINER (interface_fr), interface_al);
1996     gtk_alignment_set_padding (GTK_ALIGNMENT (interface_al), 5, 5, 0, 0);
1997
1998     interface_sub_h_box = gtk_hbox_new (FALSE, 0);
1999     gtk_widget_set_name (interface_sub_h_box, "interface_sub_h_box");
2000     gtk_widget_show (interface_sub_h_box);
2001     gtk_container_add (GTK_CONTAINER (interface_al), interface_sub_h_box);
2002     gtk_container_set_border_width (GTK_CONTAINER (interface_sub_h_box), 5);
2003
2004     /* Fill the interface_box */
2005     if (airpcap_if_active != NULL)
2006     {
2007         interface_name_lb = gtk_label_new(airpcap_if_active->description);
2008     }
2009     else
2010     {
2011         interface_name_lb = gtk_label_new("No airpcap interface found!");
2012         gtk_widget_set_sensitive(main_box,FALSE);
2013     }
2014
2015     gtk_widget_set_name (interface_name_lb, "interface_name_lb");
2016     gtk_widget_show (interface_name_lb);
2017     gtk_box_pack_start (GTK_BOX (interface_sub_h_box), interface_name_lb, TRUE,
2018                         FALSE, 0);
2019
2020     /* If it is NOT the 'Any' Interface */
2021     if (!airpcap_if_is_any(airpcap_if_selected))
2022     {
2023         blink_bt = gtk_button_new_with_mnemonic ("Blink Led");
2024     }
2025     else /* It is the any interface, so it doesn't make sense to have 'Blink' button... */
2026     {
2027         blink_bt = gtk_button_new_with_mnemonic ("What's This?");
2028     }
2029     gtk_widget_set_name (blink_bt, "blink_bt");
2030     gtk_widget_show (blink_bt);
2031     gtk_box_pack_end (GTK_BOX (interface_sub_h_box), blink_bt, FALSE, FALSE, 0);
2032
2033     interface_frame_lb = gtk_label_new ("<b>Interface</b>");
2034     gtk_widget_set_name (interface_frame_lb, "interface_frame_lb");
2035     gtk_widget_show (interface_frame_lb);
2036     gtk_frame_set_label_widget (GTK_FRAME (interface_fr), interface_frame_lb);
2037     gtk_label_set_use_markup (GTK_LABEL (interface_frame_lb), TRUE);
2038
2039     basic_parameters_fr = gtk_frame_new (NULL);
2040     gtk_widget_set_name (basic_parameters_fr, "basic_parameters_fr");
2041     gtk_widget_show (basic_parameters_fr);
2042     gtk_box_pack_start (GTK_BOX (settings_sub_box), basic_parameters_fr, TRUE,FALSE, 0);
2043     gtk_container_set_border_width (GTK_CONTAINER (basic_parameters_fr), 10);
2044
2045     basic_parameters_al = gtk_alignment_new (0.5, 0.5, 1, 1);
2046     gtk_widget_set_name (basic_parameters_al, "basic_parameters_al");
2047     gtk_widget_show (basic_parameters_al);
2048     gtk_container_add (GTK_CONTAINER (basic_parameters_fr),basic_parameters_al);
2049     gtk_alignment_set_padding (GTK_ALIGNMENT (basic_parameters_al), 10, 10, 0, 0);
2050
2051     basic_parameters_tb = gtk_table_new (2, 3, FALSE);
2052     gtk_widget_set_name (basic_parameters_tb, "basic_parameters_tb");
2053     gtk_widget_show (basic_parameters_tb);
2054     gtk_container_add (GTK_CONTAINER (basic_parameters_al),
2055                        basic_parameters_tb);
2056     gtk_container_set_border_width (GTK_CONTAINER (basic_parameters_tb), 5);
2057     gtk_table_set_col_spacings (GTK_TABLE (basic_parameters_tb), 20);
2058
2059     channel_lb = gtk_label_new ("Channel:");
2060     gtk_widget_set_name (channel_lb, "channel_lb");
2061     gtk_widget_show (channel_lb);
2062     gtk_table_attach (GTK_TABLE (basic_parameters_tb), channel_lb, 0, 1, 0, 1,
2063                       (GtkAttachOptions) (GTK_FILL),
2064                       (GtkAttachOptions) (0), 0, 0);
2065     gtk_misc_set_alignment (GTK_MISC (channel_lb), 0, 0.5);
2066
2067     capture_type_lb = gtk_label_new ("Capture Type:");
2068     gtk_widget_set_name (capture_type_lb, "capture_type_lb");
2069     gtk_widget_show (capture_type_lb);
2070     gtk_table_attach (GTK_TABLE (basic_parameters_tb), capture_type_lb, 0, 1, 2,
2071                       3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0),
2072                       0, 0);
2073     gtk_misc_set_alignment (GTK_MISC (capture_type_lb), 0, 0.5);
2074
2075     /* Start: Channel offset label */
2076     channel_offset_lb = gtk_label_new ("Channel Offset:");
2077     gtk_widget_set_name (channel_offset_lb, "channel_offset_lb");
2078     gtk_widget_show (channel_offset_lb);
2079     gtk_table_attach (GTK_TABLE (basic_parameters_tb), channel_offset_lb, 0, 1, 1, 2,
2080                       (GtkAttachOptions) (GTK_FILL),
2081                       (GtkAttachOptions) (0), 0, 0);
2082     gtk_misc_set_alignment (GTK_MISC (channel_offset_lb), 0, 0.5);
2083     /* End: Channel offset label */
2084
2085     /* Start: Channel offset combo box */
2086     channel_offset_cb = gtk_combo_new();
2087     gtk_widget_set_name (channel_offset_cb, "channel_offset_cb");
2088     gtk_editable_set_editable(GTK_EDITABLE(GTK_COMBO(channel_offset_cb)->entry),FALSE);
2089
2090     airpcap_update_channel_offset_cb(airpcap_if_selected, airpcap_if_selected->channelInfo.Frequency, channel_offset_cb);
2091     airpcap_update_channel_offset_combo_entry(channel_offset_cb, airpcap_if_selected->channelInfo.ExtChannel);
2092
2093     gtk_widget_show(channel_offset_cb);
2094
2095     gtk_table_attach (GTK_TABLE (basic_parameters_tb), channel_offset_cb, 1, 2, 1, 2,
2096                   (GtkAttachOptions) (GTK_FILL),
2097                   (GtkAttachOptions) (0), 0, 0);
2098     /* End: Channel offset combo box */
2099
2100     channel_cm = gtk_combo_new ();
2101     gtk_widget_set_name (channel_cm, "channel_cm");
2102     gtk_widget_show (channel_cm);
2103     gtk_table_attach (GTK_TABLE (basic_parameters_tb), channel_cm, 1, 2, 0, 1,
2104                       (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
2105                       (GtkAttachOptions) (0), 0, 0);
2106
2107     if (airpcap_if_selected != NULL && airpcap_if_selected->pSupportedChannels != NULL && airpcap_if_selected->numSupportedChannels > 0){
2108         for (i = 0; i<(airpcap_if_selected->numSupportedChannels); i++){
2109             channel_cm_items = g_list_append(channel_cm_items, ieee80211_mhz_to_str(airpcap_if_selected->pSupportedChannels[i].Frequency));
2110         }
2111         gtk_combo_set_popdown_strings( GTK_COMBO(channel_cm), channel_cm_items);
2112         airpcap_free_channel_combo_list (channel_cm_items);
2113     }
2114
2115     /* Select the first entry */
2116     if (airpcap_if_selected != NULL)
2117     {
2118         airpcap_update_channel_combo(GTK_WIDGET(channel_cm), airpcap_if_selected);
2119     }
2120
2121
2122     channel_en = GTK_COMBO (channel_cm)->entry;
2123     gtk_editable_set_editable(GTK_EDITABLE(channel_en),FALSE);
2124     gtk_widget_set_name (channel_en, "channel_en");
2125     gtk_widget_show (channel_en);
2126
2127     capture_type_cm = gtk_combo_new ();
2128     gtk_widget_set_name (capture_type_cm, "capture_type_cm");
2129     gtk_widget_show (capture_type_cm);
2130     gtk_table_attach (GTK_TABLE (basic_parameters_tb), capture_type_cm, 1, 2, 2,
2131                       3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
2132                       (GtkAttachOptions) (0), 0, 0);
2133     capture_type_cm_items =
2134         g_list_append (capture_type_cm_items, (gpointer) AIRPCAP_LINK_TYPE_NAME_802_11_ONLY);
2135     capture_type_cm_items =
2136         g_list_append (capture_type_cm_items, (gpointer) AIRPCAP_LINK_TYPE_NAME_802_11_PLUS_RADIO);
2137
2138     if (airpcap_get_dll_state() == AIRPCAP_DLL_OK){
2139         capture_type_cm_items =
2140             g_list_append (capture_type_cm_items, (gpointer) AIRPCAP_LINK_TYPE_NAME_802_11_PLUS_PPI);
2141     }
2142     gtk_combo_set_popdown_strings (GTK_COMBO (capture_type_cm),
2143                                    capture_type_cm_items);
2144
2145     /* Current interface value */
2146     capture_s = NULL;
2147     if (airpcap_if_selected != NULL)
2148     {
2149                 if (airpcap_if_selected->linkType == AIRPCAP_LT_802_11){
2150                         capture_s = g_strdup_printf("%s",AIRPCAP_LINK_TYPE_NAME_802_11_ONLY);
2151                 }else if (airpcap_if_selected->linkType == AIRPCAP_LT_802_11_PLUS_RADIO){
2152                         capture_s = g_strdup_printf("%s",AIRPCAP_LINK_TYPE_NAME_802_11_PLUS_RADIO);
2153                 }else if (airpcap_if_selected->linkType == AIRPCAP_LT_802_11_PLUS_PPI){
2154                         capture_s = g_strdup_printf("%s",AIRPCAP_LINK_TYPE_NAME_802_11_PLUS_PPI);
2155                 }
2156
2157         if (capture_s != NULL) gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(capture_type_cm)->entry), capture_s);
2158     }
2159     g_free(capture_s);
2160
2161     g_list_free (capture_type_cm_items);
2162
2163     capture_type_en = GTK_COMBO (capture_type_cm)->entry;
2164     gtk_widget_set_name (capture_type_en, "capture_type_en");
2165     gtk_widget_show (capture_type_en);
2166
2167     fcs_ck = gtk_check_button_new_with_label ("Include 802.11 FCS in Frames");
2168
2169     gtk_widget_set_name (fcs_ck, "fcs_ck");
2170
2171     /* Fcs Presence check box */
2172     if (airpcap_if_selected != NULL)
2173     {
2174         if (airpcap_if_selected->IsFcsPresent)
2175             gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(fcs_ck),TRUE);
2176         else
2177             gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(fcs_ck),FALSE);
2178     }
2179
2180     gtk_widget_show (fcs_ck);
2181     gtk_table_attach (GTK_TABLE (basic_parameters_tb), fcs_ck, 2, 3, 0, 1,
2182                       (GtkAttachOptions) (GTK_FILL),
2183                       (GtkAttachOptions) (0), 0, 0);
2184
2185     basic_parameters_fcs_h_box = gtk_hbox_new (FALSE, 1);
2186     gtk_widget_set_name (basic_parameters_fcs_h_box,
2187                          "basic_parameters_fcs_h_box");
2188     gtk_widget_show (basic_parameters_fcs_h_box);
2189     gtk_table_attach (GTK_TABLE (basic_parameters_tb),
2190                       basic_parameters_fcs_h_box, 2, 3, 2, 3,
2191                       (GtkAttachOptions) (GTK_FILL),
2192                       (GtkAttachOptions) (GTK_FILL), 3, 0);
2193
2194     basic_parameters_fcs_filter_lb = gtk_label_new ("FCS Filter:");
2195     gtk_widget_set_name (basic_parameters_fcs_filter_lb,
2196                          "basic_parameters_fcs_filter_lb");
2197     gtk_widget_show (basic_parameters_fcs_filter_lb);
2198     gtk_box_pack_start (GTK_BOX (basic_parameters_fcs_h_box),
2199                         basic_parameters_fcs_filter_lb, FALSE, FALSE, 0);
2200
2201     fcs_filter_cm = gtk_combo_new ();
2202     gtk_widget_set_name (fcs_filter_cm, "fcs_filter_cm");
2203     gtk_widget_show (fcs_filter_cm);
2204     gtk_box_pack_start (GTK_BOX (basic_parameters_fcs_h_box), fcs_filter_cm,
2205                         FALSE, FALSE, 0);
2206     gtk_widget_set_size_request (fcs_filter_cm, 112, -1);
2207     fcs_filter_cm_items =
2208         g_list_append (fcs_filter_cm_items, (gpointer) "All Frames");
2209     fcs_filter_cm_items =
2210         g_list_append (fcs_filter_cm_items, (gpointer) "Valid Frames");
2211     fcs_filter_cm_items =
2212         g_list_append (fcs_filter_cm_items, (gpointer) "Invalid Frames");
2213     gtk_combo_set_popdown_strings (GTK_COMBO (fcs_filter_cm),
2214                                    fcs_filter_cm_items);
2215     g_list_free (fcs_filter_cm_items);
2216
2217     fcs_filter_en = GTK_COMBO (fcs_filter_cm)->entry;
2218     gtk_widget_set_name (fcs_filter_en, "fcs_filter_en");
2219
2220     if (airpcap_if_selected != NULL)
2221     {
2222         airpcap_validation_type_combo_set_by_type(fcs_filter_cm,airpcap_if_selected->CrcValidationOn);
2223     }
2224
2225     gtk_widget_show (fcs_filter_en);
2226
2227     basic_parameters_frame_lb = gtk_label_new ("<b>Basic Parameters</b>");
2228     gtk_widget_set_name (basic_parameters_frame_lb,
2229                          "basic_parameters_frame_lb");
2230     gtk_widget_show (basic_parameters_frame_lb);
2231
2232     gtk_frame_set_label_widget (GTK_FRAME (basic_parameters_fr),basic_parameters_frame_lb);
2233     gtk_label_set_use_markup (GTK_LABEL (basic_parameters_frame_lb), TRUE);
2234
2235     low_buttons_h_box = gtk_hbox_new (FALSE, 0);
2236     gtk_widget_set_name (low_buttons_h_box, "low_buttons_h_box");
2237     gtk_widget_show (low_buttons_h_box);
2238     gtk_box_pack_end (GTK_BOX (main_box), low_buttons_h_box, FALSE, FALSE, 0);
2239
2240     left_h_button_box = gtk_hbutton_box_new ();
2241     gtk_widget_set_name (left_h_button_box, "left_h_button_box");
2242     gtk_widget_show (left_h_button_box);
2243     gtk_box_pack_start (GTK_BOX (low_buttons_h_box), left_h_button_box, FALSE,
2244                         FALSE, 0);
2245
2246     reset_configuration_bt = gtk_button_new_with_mnemonic ("Reset Configuration");
2247     gtk_widget_set_name (reset_configuration_bt, "reset_configuration_bt");
2248     /* gtk_widget_show (reset_configuration_bt); */
2249     gtk_container_add (GTK_CONTAINER (low_buttons_h_box),
2250                        reset_configuration_bt);
2251     GTK_WIDGET_SET_FLAGS (reset_configuration_bt, GTK_CAN_DEFAULT);
2252
2253     right_h_button_box = dlg_button_row_new(GTK_STOCK_OK, GTK_STOCK_APPLY, GTK_STOCK_CANCEL, NULL);
2254     gtk_widget_show (right_h_button_box);
2255     gtk_box_pack_end (GTK_BOX (low_buttons_h_box), right_h_button_box, FALSE,
2256                       FALSE, 0);
2257     gtk_button_box_set_layout (GTK_BUTTON_BOX (right_h_button_box),
2258                                GTK_BUTTONBOX_END);
2259
2260     ok_bt = g_object_get_data(G_OBJECT(right_h_button_box), GTK_STOCK_OK);
2261     apply_bt = g_object_get_data(G_OBJECT(right_h_button_box), GTK_STOCK_APPLY);
2262     cancel_bt = g_object_get_data(G_OBJECT(right_h_button_box), GTK_STOCK_CANCEL);
2263
2264     /* Connect the callbacks */
2265     g_signal_connect (airpcap_advanced_w, "delete_event", G_CALLBACK(window_delete_event_cb), airpcap_advanced_w);
2266     g_signal_connect (airpcap_advanced_w, "destroy", G_CALLBACK(on_airpcap_advanced_destroy), airpcap_advanced_w);
2267
2268     if (!airpcap_if_is_any(airpcap_if_selected))
2269     {
2270         g_signal_connect (blink_bt, "clicked", G_CALLBACK(on_blink_bt_clicked), airpcap_advanced_w);
2271     }
2272     else
2273     {
2274         g_signal_connect (blink_bt, "clicked", G_CALLBACK(on_what_s_this_bt_clicked), airpcap_advanced_w);
2275     }
2276
2277     g_signal_connect (channel_en, "changed", G_CALLBACK(on_channel_en_changed), channel_offset_cb);
2278     g_signal_connect (GTK_COMBO(channel_offset_cb)->entry, "changed", G_CALLBACK(on_channel_offset_cb_changed), airpcap_advanced_w);
2279     g_signal_connect (capture_type_en, "changed", G_CALLBACK(on_capture_type_en_changed), airpcap_advanced_w);
2280     g_signal_connect (fcs_ck, "toggled", G_CALLBACK(on_fcs_ck_toggled), airpcap_advanced_w);
2281     g_signal_connect (fcs_filter_en, "changed", G_CALLBACK(on_fcs_filter_en_changed), airpcap_advanced_w);
2282     g_signal_connect (reset_configuration_bt, "clicked", G_CALLBACK(on_reset_configuration_bt_clicked), airpcap_advanced_w);
2283     g_signal_connect (apply_bt, "clicked", G_CALLBACK(on_advanced_apply_bt_clicked), airpcap_advanced_w);
2284     g_signal_connect (ok_bt,"clicked", G_CALLBACK(on_advanced_ok_bt_clicked), airpcap_advanced_w);
2285     g_signal_connect (cancel_bt,"clicked", G_CALLBACK(on_advanced_cancel_bt_clicked), airpcap_advanced_w);
2286
2287     /* Different because the window will be closed ... */
2288     /*window_set_cancel_button(airpcap_advanced_w, ok_bt, window_cancel_button_cb);
2289     window_set_cancel_button(airpcap_advanced_w, cancel_bt, window_cancel_button_cb);*/
2290
2291
2292     /* Store pointers to all widgets, for use by lookup_widget(). */
2293     g_object_set_data (G_OBJECT(airpcap_advanced_w), AIRPCAP_ADVANCED_BLINK_KEY, blink_bt);
2294     g_object_set_data (G_OBJECT(airpcap_advanced_w), AIRPCAP_ADVANCED_CHANNEL_KEY,channel_cm);
2295     g_object_set_data (G_OBJECT(airpcap_advanced_w), AIRPCAP_ADVANCED_LINK_TYPE_KEY,capture_type_cm);
2296     g_object_set_data (G_OBJECT(airpcap_advanced_w), AIRPCAP_ADVANCED_FCS_CHECK_KEY, fcs_ck);
2297     g_object_set_data (G_OBJECT(airpcap_advanced_w), AIRPCAP_ADVANCED_FCS_FILTER_KEY, fcs_filter_cm);
2298     g_object_set_data (G_OBJECT(airpcap_advanced_w), AIRPCAP_ADVANCED_OK_KEY, ok_bt);
2299     g_object_set_data (G_OBJECT(airpcap_advanced_w), AIRPCAP_ADVANCED_CANCEL_KEY, cancel_bt);
2300
2301     /*
2302      * I will need the toolbar and the main widget in some callback,
2303      * so I will add the toolbar pointer to the airpcap_advanced_w
2304      */
2305     g_object_set_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_TOOLBAR_KEY,toolbar);
2306
2307     /* At the end, so that it appears completely all together ... */
2308     gtk_widget_show (airpcap_advanced_w);
2309 }
2310
2311 /*
2312  * Callback for the OK button 'clicked' in the Advanced Wireless Settings window.
2313  */
2314 void
2315 on_advanced_ok_bt_clicked(GtkWidget *button, gpointer data _U_)
2316 {
2317     PAirpcapHandle ad = NULL;
2318     gchar ebuf[AIRPCAP_ERRBUF_SIZE];
2319
2320     /* Retrieve object data */
2321     GtkWidget *airpcap_advanced_w;
2322     GtkWidget *channel_combo;
2323     GtkWidget *capture_combo;
2324     GtkWidget *crc_check;
2325     GtkWidget *wrong_crc_combo;
2326     GtkWidget *blink_bt;
2327     GtkWidget *interface_combo;
2328     GtkWidget *cancel_bt;
2329     GtkWidget *ok_bt;
2330
2331     /* widgets in the toolbar */
2332     GtkWidget   *toolbar,
2333     *toolbar_if_lb,
2334     *toolbar_channel_cm,
2335         *toolbar_channel_offset_cb,
2336     *toolbar_wrong_crc_cm,
2337     *advanced_bt;
2338
2339     /* Retrieve the GUI object pointers */
2340     airpcap_advanced_w                  = GTK_WIDGET(data);
2341     interface_combo                             = GTK_WIDGET(g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_ADVANCED_INTERFACE_KEY));
2342     channel_combo                               = GTK_WIDGET(g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_ADVANCED_CHANNEL_KEY));
2343     capture_combo                               = GTK_WIDGET(g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_ADVANCED_LINK_TYPE_KEY));
2344     crc_check                                   = GTK_WIDGET(g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_ADVANCED_FCS_CHECK_KEY));
2345     wrong_crc_combo                             = GTK_WIDGET(g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_ADVANCED_FCS_FILTER_KEY));
2346     blink_bt                                    = GTK_WIDGET(g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_ADVANCED_BLINK_KEY));
2347     cancel_bt                                   = GTK_WIDGET(g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_ADVANCED_CANCEL_KEY));
2348     ok_bt                                               = GTK_WIDGET(g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_ADVANCED_OK_KEY));
2349     advanced_bt                                 = GTK_WIDGET(g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_ADVANCED_KEY));
2350
2351     toolbar                                             = GTK_WIDGET(g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_TOOLBAR_KEY));
2352
2353     /* retrieve toolbar info */
2354     toolbar_if_lb                       = GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_INTERFACE_KEY));
2355     toolbar_channel_cm          = GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_CHANNEL_KEY));
2356     toolbar_channel_offset_cb   = GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_CHANNEL_OFFSET_KEY));
2357     toolbar_wrong_crc_cm        = GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_FCS_FILTER_KEY));
2358
2359     /* Stop blinking ALL leds (go through the airpcap_if_list) */
2360     if (airpcap_if_selected != NULL)
2361     {
2362         ad = airpcap_if_open(airpcap_if_selected->name, ebuf);
2363         if (ad)
2364         {
2365             gtk_timeout_remove(airpcap_if_selected->tag);
2366             airpcap_if_turn_led_on(ad, 0);
2367             airpcap_if_selected->blinking = FALSE;
2368             airpcap_if_selected->led = TRUE;
2369             airpcap_if_close(ad);
2370         }
2371     }
2372
2373     /* ??? - Ask if want to save configuration */
2374
2375     /* Save the configuration */
2376     airpcap_save_selected_if_configuration(airpcap_if_selected);
2377     /* Remove gtk timeout */
2378     gtk_timeout_remove(airpcap_if_selected->tag);
2379
2380     /* Update toolbar (only if airpcap_if_selected is airpcap_if_active)*/
2381     if ( g_ascii_strcasecmp(airpcap_if_selected->description,airpcap_if_active->description) == 0)
2382     {
2383         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)));
2384         airpcap_update_channel_combo(GTK_WIDGET(toolbar_channel_cm),airpcap_if_selected);
2385         airpcap_update_channel_offset_combo_entry(GTK_WIDGET(toolbar_channel_offset_cb),airpcap_if_selected->channelInfo.ExtChannel);
2386         airpcap_validation_type_combo_set_by_type(toolbar_wrong_crc_cm,airpcap_if_selected->CrcValidationOn);
2387     }
2388
2389     /* If interface active is airpcap, set sensitive TRUE for airpcap toolbar */
2390     if ( get_airpcap_if_from_name(airpcap_if_list,airpcap_if_active->description) != NULL)
2391     {
2392         airpcap_set_toolbar_start_capture(airpcap_if_active);
2393     }
2394     else
2395     {
2396         airpcap_set_toolbar_stop_capture(airpcap_if_active);
2397     }
2398
2399     gtk_widget_destroy(airpcap_advanced_w);
2400 }
2401
2402 /*
2403  * Callback for the CANCEL button 'clicked' in the Advanced Wireless Settings window.
2404  */
2405 void
2406 on_advanced_cancel_bt_clicked(GtkWidget *button, gpointer data _U_)
2407 {
2408     PAirpcapHandle ad = NULL;
2409     gchar ebuf[AIRPCAP_ERRBUF_SIZE];
2410
2411     /* Retrieve object data */
2412     GtkWidget *airpcap_advanced_w;
2413     GtkWidget *channel_combo;
2414     GtkWidget *capture_combo;
2415     GtkWidget *crc_check;
2416     GtkWidget *wrong_crc_combo;
2417     GtkWidget *blink_bt;
2418     GtkWidget *interface_combo;
2419     GtkWidget *cancel_bt;
2420     GtkWidget *ok_bt;
2421
2422     /* widgets in the toolbar */
2423     GtkWidget   *toolbar,
2424     *toolbar_if_lb,
2425     *toolbar_channel_cm,
2426     *toolbar_wrong_crc_cm,
2427     *advanced_bt;
2428
2429     /* Retrieve the GUI object pointers */
2430     airpcap_advanced_w  = GTK_WIDGET(data);
2431     interface_combo             = GTK_WIDGET(g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_ADVANCED_INTERFACE_KEY));
2432     channel_combo               = GTK_WIDGET(g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_ADVANCED_CHANNEL_KEY));
2433     capture_combo               = GTK_WIDGET(g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_ADVANCED_LINK_TYPE_KEY));
2434     crc_check                   = GTK_WIDGET(g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_ADVANCED_FCS_CHECK_KEY));
2435     wrong_crc_combo             = GTK_WIDGET(g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_ADVANCED_FCS_FILTER_KEY));
2436     blink_bt                    = GTK_WIDGET(g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_ADVANCED_BLINK_KEY));
2437     cancel_bt                   = GTK_WIDGET(g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_ADVANCED_CANCEL_KEY));
2438     ok_bt                               = GTK_WIDGET(g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_ADVANCED_OK_KEY));
2439     advanced_bt                 = GTK_WIDGET(g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_ADVANCED_KEY));
2440
2441     toolbar = GTK_WIDGET(g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_TOOLBAR_KEY));
2442
2443     /* retrieve toolbar info */
2444     toolbar_if_lb                       = GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_INTERFACE_KEY));
2445     toolbar_channel_cm          = GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_CHANNEL_KEY));
2446     toolbar_wrong_crc_cm        = GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_FCS_FILTER_KEY));
2447
2448     /* Stop blinking ALL leds (go through the airpcap_if_list) */
2449     if (airpcap_if_selected != NULL)
2450     {
2451         ad = airpcap_if_open(airpcap_if_selected->name, ebuf);
2452         if (ad)
2453         {
2454             gtk_timeout_remove(airpcap_if_selected->tag);
2455             airpcap_if_turn_led_on(ad, 0);
2456             airpcap_if_selected->blinking = FALSE;
2457             airpcap_if_selected->led = TRUE;
2458             airpcap_if_close(ad);
2459         }
2460     }
2461
2462     /* reload the configuration!!! Configuration has not been saved but
2463         the corresponding structure has been modified probably...*/
2464     if (!airpcap_if_selected->saved)
2465     {
2466         airpcap_load_selected_if_configuration(airpcap_if_selected);
2467     }
2468
2469     gtk_widget_destroy(airpcap_advanced_w);
2470 }
2471
2472 /* Called to create the key management window */
2473 void
2474 display_airpcap_key_management_cb(GtkWidget *w, gpointer data)
2475 {
2476     GtkWidget *key_management_w;
2477     GtkWidget *main_box;
2478     GtkWidget *keys_fr;
2479     GtkWidget *keys_al;
2480     GtkWidget *keys_h_sub_box;
2481     GtkWidget *enable_decryption_tb;
2482     GtkWidget *enable_decryption_lb;
2483     GtkWidget *enable_decryption_cb;
2484     /*GList     *enable_decryption_cb_items = NULL;*/
2485     GtkWidget *enable_decryption_en;
2486     GtkWidget *keys_v_sub_box;
2487     GtkWidget *keys_scrolled_w;
2488     GtkWidget *key_ls;
2489     GtkWidget *key_list_decryption_type_col_lb;
2490     GtkWidget *key_list_decryption_key_col_lb;
2491     GtkWidget *key_ls_decryption_ssid_col_lb;
2492     GtkWidget *key_v_button_box;
2493     GtkWidget *add_new_key_bt;
2494     GtkWidget *remove_key_bt;
2495     GtkWidget *edit_key_bt;
2496     GtkWidget *move_key_up_bt;
2497     GtkWidget *move_key_down_bt;
2498     GtkWidget *keys_frame_lb;
2499     GtkWidget *low_buttons_h_box;
2500     GtkWidget *left_h_button_box;
2501     GtkWidget *reset_configuration_bt;
2502     GtkWidget *right_h_button_box;
2503     GtkWidget *ok_bt;
2504     GtkWidget *apply_bt;
2505     GtkWidget *cancel_bt;
2506
2507     /* widgets in the toolbar */
2508     GtkWidget   *toolbar,
2509     *toolbar_decryption_ck;
2510
2511     /* other stuff */
2512     /*GList                             *channel_list,*capture_list;*/
2513     /*GList                             *linktype_list = NULL;*/
2514
2515     /* Selected row/column structure */
2516     airpcap_key_ls_selected_info_t *key_ls_selected_item;
2517     key_ls_selected_item = (airpcap_key_ls_selected_info_t*)g_malloc(sizeof(airpcap_key_ls_selected_info_t));
2518     key_ls_selected_item->row = NO_ROW_SELECTED;
2519     key_ls_selected_item->column = NO_COLUMN_SELECTED;
2520
2521     /* user data - RETRIEVE pointers of toolbar widgets */
2522     toolbar                               = GTK_WIDGET(data);
2523     toolbar_decryption_ck = GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_DECRYPTION_KEY));
2524
2525     /* gray out the toolbar */
2526     gtk_widget_set_sensitive(toolbar,FALSE);
2527
2528     /* main window */
2529     /* global */
2530
2531     /* NULL to global widgets */
2532     block_advanced_signals = FALSE;
2533
2534     /* the selected is the active, for now */
2535     airpcap_if_selected = airpcap_if_active;
2536
2537     /* Create the new window */
2538     key_management_w = window_new(GTK_WINDOW_TOPLEVEL, "Decryption Key Management");
2539
2540     gtk_container_set_border_width (GTK_CONTAINER (key_management_w), 5);
2541     gtk_window_set_position (GTK_WINDOW (key_management_w),
2542                              GTK_WIN_POS_CENTER);
2543
2544     gtk_window_set_resizable (GTK_WINDOW (key_management_w), FALSE);
2545     gtk_window_set_type_hint (GTK_WINDOW (key_management_w), GDK_WINDOW_TYPE_HINT_DIALOG);
2546
2547     main_box = gtk_vbox_new (FALSE, 0);
2548     gtk_widget_set_name (main_box, "main_box");
2549     gtk_widget_show (main_box);
2550     gtk_container_add (GTK_CONTAINER (key_management_w), main_box);
2551
2552     keys_fr = gtk_frame_new (NULL);
2553     gtk_widget_set_name (keys_fr, "keys_fr");
2554     gtk_widget_show (keys_fr);
2555     gtk_box_pack_start (GTK_BOX (main_box), keys_fr, FALSE, FALSE, 0);
2556     gtk_container_set_border_width (GTK_CONTAINER (keys_fr), 10);
2557
2558     keys_al = gtk_alignment_new (0.5, 0.5, 1, 1);
2559     gtk_widget_set_name (keys_al, "keys_al");
2560     gtk_widget_show (keys_al);
2561     gtk_container_add (GTK_CONTAINER (keys_fr), keys_al);
2562     gtk_container_set_border_width (GTK_CONTAINER (keys_al), 5);
2563
2564     gtk_alignment_set_padding (GTK_ALIGNMENT (keys_al), 0, 0, 12, 0);
2565
2566     keys_h_sub_box = gtk_vbox_new (FALSE, 0);
2567     gtk_widget_set_name (keys_h_sub_box, "keys_h_sub_box");
2568     gtk_widget_show (keys_h_sub_box);
2569     gtk_container_add (GTK_CONTAINER (keys_al), keys_h_sub_box);
2570
2571     enable_decryption_tb = gtk_table_new (1, 2, FALSE);
2572     gtk_widget_set_name (enable_decryption_tb, "enable_decryption_tb");
2573     gtk_widget_show (enable_decryption_tb);
2574     gtk_box_pack_start (GTK_BOX (keys_h_sub_box), enable_decryption_tb, FALSE,
2575                         FALSE, 0);
2576     gtk_table_set_col_spacings (GTK_TABLE (enable_decryption_tb), 6);
2577
2578     enable_decryption_lb = gtk_label_new ("Select Decryption Mode");
2579     gtk_widget_set_name (enable_decryption_lb, "enable_decryption_lb");
2580     gtk_widget_show (enable_decryption_lb);
2581     gtk_table_attach (GTK_TABLE (enable_decryption_tb), enable_decryption_lb, 1,
2582                       2, 0, 1, (GtkAttachOptions) (GTK_FILL),
2583                       (GtkAttachOptions) (0), 0, 0);
2584     gtk_misc_set_alignment (GTK_MISC (enable_decryption_lb), 0, 0.5);
2585
2586     enable_decryption_cb = gtk_combo_new ();
2587     gtk_widget_set_name (enable_decryption_cb, "enable_decryption_cb");
2588     gtk_widget_show (enable_decryption_cb);
2589     gtk_table_attach (GTK_TABLE (enable_decryption_tb), enable_decryption_cb, 0,
2590                       1, 0, 1, (GtkAttachOptions) (0), (GtkAttachOptions) (0),
2591                       0, 0);
2592     gtk_widget_set_size_request (enable_decryption_cb, 83, -1);
2593     update_decryption_mode_list(enable_decryption_cb);
2594
2595     enable_decryption_en = GTK_COMBO (enable_decryption_cb)->entry;
2596     gtk_widget_set_name (enable_decryption_en, "enable_decryption_en");
2597     gtk_widget_show (enable_decryption_en);
2598     gtk_editable_set_editable (GTK_EDITABLE (enable_decryption_en), FALSE);
2599     GTK_WIDGET_UNSET_FLAGS (enable_decryption_en, GTK_CAN_FOCUS);
2600
2601     /* Set correct decryption mode!!!! */
2602     update_decryption_mode_cm(enable_decryption_cb);
2603
2604     keys_v_sub_box = gtk_hbox_new (FALSE, 0);
2605     gtk_widget_set_name (keys_v_sub_box, "keys_v_sub_box");
2606     gtk_widget_show (keys_v_sub_box);
2607     gtk_box_pack_start (GTK_BOX (keys_h_sub_box), keys_v_sub_box, TRUE, TRUE, 0);
2608
2609     keys_scrolled_w = gtk_scrolled_window_new (NULL, NULL);
2610     gtk_widget_set_name (keys_scrolled_w, "keys_scrolled_w");
2611     gtk_widget_show (keys_scrolled_w);
2612     gtk_box_pack_start (GTK_BOX (keys_v_sub_box), keys_scrolled_w, TRUE, TRUE,
2613                         0);
2614     gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (keys_scrolled_w), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
2615
2616 #ifdef HAVE_AIRPDCAP
2617     key_ls = gtk_clist_new (3);
2618 #else
2619     key_ls = gtk_clist_new (2);
2620 #endif
2621
2622     gtk_widget_set_name (key_ls, "key_ls");
2623     gtk_widget_show (key_ls);
2624
2625     gtk_container_add (GTK_CONTAINER (keys_scrolled_w), key_ls);
2626     gtk_clist_set_column_width (GTK_CLIST (key_ls), 0, 54);
2627     gtk_clist_set_column_width (GTK_CLIST (key_ls), 1, 113);
2628 #ifdef HAVE_AIRPDCAP
2629     gtk_clist_set_column_width (GTK_CLIST (key_ls), 2, 80);
2630 #endif
2631     gtk_clist_column_titles_show (GTK_CLIST (key_ls));
2632     gtk_clist_set_shadow_type (GTK_CLIST (key_ls), GTK_SHADOW_ETCHED_IN);
2633     gtk_clist_set_column_justification(GTK_CLIST (key_ls),0,GTK_JUSTIFY_CENTER);
2634
2635     key_list_decryption_type_col_lb = gtk_label_new ("Type");
2636     gtk_widget_set_name (key_list_decryption_type_col_lb,
2637                          "key_list_decryption_type_col_lb");
2638     gtk_widget_show (key_list_decryption_type_col_lb);
2639     gtk_clist_set_column_widget (GTK_CLIST (key_ls), 0, key_list_decryption_type_col_lb);
2640
2641     key_list_decryption_key_col_lb = gtk_label_new ("Key");
2642     gtk_widget_set_name (key_list_decryption_key_col_lb,
2643                          "key_list_decryption_key_col_lb");
2644     gtk_widget_show (key_list_decryption_key_col_lb);
2645     gtk_clist_set_column_widget (GTK_CLIST (key_ls), 1,
2646                                  key_list_decryption_key_col_lb);
2647
2648 #ifdef HAVE_AIRPDCAP
2649     key_ls_decryption_ssid_col_lb = gtk_label_new ("SSID");
2650     gtk_widget_set_name (key_ls_decryption_ssid_col_lb,
2651                          "key_ls_decryption_ssid_col_lb");
2652     gtk_widget_show (key_ls_decryption_ssid_col_lb);
2653     gtk_clist_set_column_widget (GTK_CLIST (key_ls), 2,
2654                                  key_ls_decryption_ssid_col_lb);
2655 #endif
2656
2657
2658     key_v_button_box = gtk_vbutton_box_new ();
2659     gtk_widget_set_name (key_v_button_box, "key_v_button_box");
2660     gtk_widget_show (key_v_button_box);
2661     gtk_box_pack_start (GTK_BOX (keys_v_sub_box), key_v_button_box, FALSE, TRUE,
2662                         0);
2663
2664     add_new_key_bt = gtk_button_new_from_stock(GTK_STOCK_NEW);
2665     gtk_widget_set_name (add_new_key_bt, "add_new_key_bt");
2666     gtk_widget_show (add_new_key_bt);
2667     gtk_container_add (GTK_CONTAINER (key_v_button_box), add_new_key_bt);
2668     GTK_WIDGET_SET_FLAGS (add_new_key_bt, GTK_CAN_DEFAULT);
2669
2670     edit_key_bt = gtk_button_new_from_stock(WIRESHARK_STOCK_EDIT);
2671     gtk_widget_set_name (edit_key_bt, "edit_key_bt");
2672     gtk_widget_show (edit_key_bt);
2673     gtk_container_add (GTK_CONTAINER (key_v_button_box), edit_key_bt);
2674     GTK_WIDGET_SET_FLAGS (edit_key_bt, GTK_CAN_DEFAULT);
2675
2676     remove_key_bt = gtk_button_new_from_stock(GTK_STOCK_DELETE);
2677     gtk_widget_set_name (remove_key_bt, "remove_key_bt");
2678     gtk_widget_show (remove_key_bt);
2679     gtk_container_add (GTK_CONTAINER (key_v_button_box), remove_key_bt);
2680     GTK_WIDGET_SET_FLAGS (remove_key_bt, GTK_CAN_DEFAULT);
2681
2682     move_key_up_bt = gtk_button_new_from_stock(GTK_STOCK_GO_UP);
2683     gtk_widget_set_name (move_key_up_bt, "move_key_up_bt");
2684     gtk_widget_show (move_key_up_bt);
2685     gtk_container_add (GTK_CONTAINER (key_v_button_box), move_key_up_bt);
2686     GTK_WIDGET_SET_FLAGS (move_key_up_bt, GTK_CAN_DEFAULT);
2687
2688     move_key_down_bt = gtk_button_new_from_stock(GTK_STOCK_GO_DOWN);
2689     gtk_widget_set_name (move_key_down_bt, "move_key_down_bt");
2690     gtk_widget_show (move_key_down_bt);
2691     gtk_container_add (GTK_CONTAINER (key_v_button_box), move_key_down_bt);
2692     GTK_WIDGET_SET_FLAGS (move_key_down_bt, GTK_CAN_DEFAULT);
2693
2694     keys_frame_lb = gtk_label_new ("<b>Decryption Keys</b>");
2695     gtk_widget_set_name (keys_frame_lb, "keys_frame_lb");
2696     gtk_widget_show (keys_frame_lb);
2697
2698     gtk_frame_set_label_widget (GTK_FRAME (keys_fr), keys_frame_lb);
2699     gtk_label_set_use_markup (GTK_LABEL (keys_frame_lb), TRUE);
2700
2701     low_buttons_h_box = gtk_hbox_new (FALSE, 0);
2702     gtk_widget_set_name (low_buttons_h_box, "low_buttons_h_box");
2703     gtk_widget_show (low_buttons_h_box);
2704     gtk_box_pack_end (GTK_BOX (main_box), low_buttons_h_box, FALSE, FALSE, 0);
2705
2706     left_h_button_box = gtk_hbutton_box_new ();
2707     gtk_widget_set_name (left_h_button_box, "left_h_button_box");
2708     gtk_widget_show (left_h_button_box);
2709     gtk_box_pack_start (GTK_BOX (low_buttons_h_box), left_h_button_box, FALSE,
2710                         FALSE, 0);
2711
2712     reset_configuration_bt = gtk_button_new_with_mnemonic ("Reset Configuration");
2713     gtk_widget_set_name (reset_configuration_bt, "reset_configuration_bt");
2714     /* gtk_widget_show (reset_configuration_bt); */
2715     gtk_container_add (GTK_CONTAINER (left_h_button_box),
2716                        reset_configuration_bt);
2717     GTK_WIDGET_SET_FLAGS (reset_configuration_bt, GTK_CAN_DEFAULT);
2718
2719     right_h_button_box = dlg_button_row_new(GTK_STOCK_OK, GTK_STOCK_APPLY, GTK_STOCK_CANCEL, NULL);
2720     gtk_widget_set_name (right_h_button_box, "right_h_button_box");
2721     gtk_widget_show (right_h_button_box);
2722     gtk_box_pack_end (GTK_BOX (low_buttons_h_box), right_h_button_box, FALSE,
2723                       FALSE, 0);
2724     gtk_button_box_set_layout (GTK_BUTTON_BOX (right_h_button_box),
2725                                GTK_BUTTONBOX_END);
2726
2727     ok_bt = g_object_get_data(G_OBJECT(right_h_button_box), GTK_STOCK_OK);
2728     apply_bt = g_object_get_data(G_OBJECT(right_h_button_box), GTK_STOCK_APPLY);
2729     cancel_bt = g_object_get_data(G_OBJECT(right_h_button_box), GTK_STOCK_CANCEL);
2730
2731     /* Connect the callbacks */
2732     g_signal_connect (key_management_w, "delete_event", G_CALLBACK(window_delete_event_cb), key_management_w);
2733     g_signal_connect (key_management_w, "destroy", G_CALLBACK(on_key_management_destroy), key_management_w);
2734     g_signal_connect (add_new_key_bt, "clicked", G_CALLBACK(on_add_new_key_bt_clicked), key_management_w);
2735     g_signal_connect (remove_key_bt, "clicked", G_CALLBACK(on_remove_key_bt_clicked), key_management_w);
2736     g_signal_connect (edit_key_bt, "clicked", G_CALLBACK(on_edit_key_bt_clicked), key_management_w);
2737     g_signal_connect (move_key_up_bt, "clicked", G_CALLBACK(on_move_key_up_bt_clicked), key_management_w);
2738     g_signal_connect (move_key_down_bt, "clicked", G_CALLBACK(on_move_key_down_bt_clicked), key_management_w);
2739     g_signal_connect (reset_configuration_bt, "clicked", G_CALLBACK(on_reset_configuration_bt_clicked), key_management_w);
2740     g_signal_connect (apply_bt, "clicked", G_CALLBACK(on_key_management_apply_bt_clicked), key_management_w);
2741     g_signal_connect (ok_bt, "clicked", G_CALLBACK(on_key_management_ok_bt_clicked), key_management_w);
2742     g_signal_connect (cancel_bt, "clicked", G_CALLBACK(on_key_management_cancel_bt_clicked), key_management_w);
2743     g_signal_connect (key_ls, "select_row", G_CALLBACK(on_key_ls_select_row), key_management_w);
2744     g_signal_connect (key_ls, "unselect_row", G_CALLBACK(on_key_ls_unselect_row), key_management_w);
2745     g_signal_connect (key_ls, "click_column", G_CALLBACK(on_key_ls_click_column), key_management_w);
2746
2747     /* Different because the window will be closed ... */
2748     /*window_set_cancel_button(key_management_w, ok_bt, window_cancel_button_cb);
2749     window_set_cancel_button(key_management_w, cancel_bt, window_cancel_button_cb);*/
2750
2751     g_object_set_data (G_OBJECT(key_management_w), AIRPCAP_ADVANCED_SELECTED_KEY_LIST_ITEM_KEY,key_ls_selected_item);
2752
2753     /* Store pointers to all widgets, for use by lookup_widget(). */
2754     g_object_set_data (G_OBJECT(key_management_w), AIRPCAP_ADVANCED_WEP_DECRYPTION_KEY, enable_decryption_en);
2755     g_object_set_data (G_OBJECT(key_management_w), AIRPCAP_ADVANCED_KEYLIST_KEY, key_ls);
2756     g_object_set_data (G_OBJECT(key_management_w), AIRPCAP_ADVANCED_OK_KEY, ok_bt);
2757     g_object_set_data (G_OBJECT(key_management_w), AIRPCAP_ADVANCED_CANCEL_KEY, cancel_bt);
2758
2759     /*
2760      * I will need the toolbar and the main widget in some callback,
2761      * so I will add the toolbar pointer to the key_management_w
2762      */
2763     g_object_set_data(G_OBJECT(key_management_w),AIRPCAP_TOOLBAR_KEY,toolbar);
2764     g_object_set_data (G_OBJECT(key_management_w), AIRPCAP_TOOLBAR_DECRYPTION_KEY, toolbar_decryption_ck);
2765
2766     /* FIRST OF ALL, CHECK THE KEY COLLECTIONS */
2767     /*
2768      * This will read the decryption keys from the preferences file, and will store
2769      * them into the registry...
2770      */
2771     if (!airpcap_check_decryption_keys(airpcap_if_list))
2772     {
2773         /* Ask the user what to do ...*/
2774         airpcap_keys_check_w(key_management_w,NULL);
2775     }
2776     else /* Keys from lists are equals, or wireshark has got no keys */
2777     {
2778         airpcap_load_decryption_keys(airpcap_if_list);
2779         airpcap_fill_key_list(key_ls);
2780         /* At the end, so that it appears completely all together ... */
2781         gtk_widget_show (key_management_w);
2782     }
2783 }
2784
2785 /*
2786  * Callback for the OK button 'clicked' in the Decryption Key Management window.
2787  */
2788 void
2789 on_key_management_ok_bt_clicked(GtkWidget *button, gpointer data)
2790 {
2791     /* advenced window */
2792     GtkWidget   *key_management_w;
2793
2794     /* retrieve main window */
2795     key_management_w      = GTK_WIDGET(data);
2796
2797     /* Apply the current decryption preferences */
2798     on_key_management_apply_bt_clicked(button, data);
2799
2800     /* Save the preferences to preferences file!!! */
2801     write_prefs_to_file();
2802
2803     /* If interface active is airpcap, set sensitive TRUE for airpcap toolbar */
2804     if (airpcap_if_list != NULL && g_list_length(airpcap_if_list) > 0)
2805     {
2806         if (airpcap_if_active != NULL)
2807         {
2808             if ( get_airpcap_if_from_name(airpcap_if_list,airpcap_if_active->description) != NULL)
2809             {
2810                 airpcap_set_toolbar_start_capture(airpcap_if_active);
2811             }
2812             else
2813             {
2814                 airpcap_set_toolbar_stop_capture(airpcap_if_active);
2815             }
2816         }
2817     }
2818
2819     gtk_widget_destroy(key_management_w);
2820 }
2821
2822 /*
2823  * Callback for the CANCEL button 'clicked' in the Decryption Key Management window.
2824  */
2825 void
2826 on_key_management_cancel_bt_clicked(GtkWidget *button, gpointer data _U_)
2827 {
2828     PAirpcapHandle ad = NULL;
2829
2830     /* Retrieve object data */
2831     GtkWidget *key_management_w;
2832     GtkWidget *cancel_bt;
2833     GtkWidget *ok_bt;
2834     GtkWidget *key_ls;
2835
2836     /* widgets in the toolbar */
2837     GtkWidget   *toolbar,
2838     *toolbar_decryption_ck,
2839     *key_management_bt;
2840
2841     /* Row selected structure */
2842     airpcap_key_ls_selected_info_t *selected_item;
2843
2844     /* Retrieve the GUI object pointers */
2845     key_management_w    = GTK_WIDGET(data);
2846     cancel_bt                   = GTK_WIDGET(g_object_get_data(G_OBJECT(key_management_w),AIRPCAP_ADVANCED_CANCEL_KEY));
2847     ok_bt                               = GTK_WIDGET(g_object_get_data(G_OBJECT(key_management_w),AIRPCAP_ADVANCED_OK_KEY));
2848     key_ls                              = GTK_WIDGET(g_object_get_data(G_OBJECT(key_management_w),AIRPCAP_ADVANCED_KEYLIST_KEY));
2849     key_management_bt   = GTK_WIDGET(g_object_get_data(G_OBJECT(key_management_w),AIRPCAP_ADVANCED_KEY));
2850
2851     toolbar = GTK_WIDGET(g_object_get_data(G_OBJECT(key_management_w),AIRPCAP_TOOLBAR_KEY));
2852
2853     /* retrieve toolbar info */
2854     toolbar_decryption_ck       = GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_DECRYPTION_KEY));
2855
2856     /* Retrieve the selected row item pointer... */
2857     selected_item                       = (airpcap_key_ls_selected_info_t*)(g_object_get_data(G_OBJECT(key_management_w),AIRPCAP_ADVANCED_SELECTED_KEY_LIST_ITEM_KEY));
2858     /* And free it */
2859     g_free(selected_item);
2860
2861     gtk_widget_destroy(key_management_w);
2862 }
2863
2864 /*
2865  * Dialog box that appears whenever keys are not consistent between wireshark and AirPcap
2866  */
2867 void
2868 airpcap_keys_check_w(GtkWidget *w, gpointer data)
2869 {
2870     GtkWidget *keys_check_w;
2871     GtkWidget *main_v_box;
2872     GtkWidget *warning_lb;
2873     GtkWidget *radio_tb;
2874     GtkWidget *keep_rb;
2875     GSList *radio_bt_group = NULL;
2876     GtkWidget *merge_rb;
2877     GtkWidget *import_rb;
2878     GtkWidget *ignore_rb;
2879     GtkWidget *keep_lb;
2880     GtkWidget *merge_lb;
2881     GtkWidget *import_lb;
2882     GtkWidget *ignore_lb;
2883     GtkWidget *low_h_button_box;
2884     GtkWidget *ok_bt;
2885     GtkWidget *cancel_bt;
2886
2887     keys_check_w = window_new (GTK_WINDOW_TOPLEVEL, "Decryption Key Warning");
2888     gtk_widget_set_name (keys_check_w, "keys_check_w");
2889     gtk_window_set_resizable (GTK_WINDOW (keys_check_w), FALSE);
2890
2891     main_v_box = gtk_vbox_new (FALSE, 0);
2892     gtk_widget_set_name (main_v_box, "main_v_box");
2893     gtk_widget_show (main_v_box);
2894     gtk_container_add (GTK_CONTAINER (keys_check_w), main_v_box);
2895
2896     warning_lb = gtk_label_new("<b>WARNING!</b> Decryption keys specified in Wireshark's preferences file differ from those specified for the AirPcap adapter(s). You can choose to:");
2897     gtk_label_set_use_markup (GTK_LABEL (warning_lb), TRUE);
2898     gtk_widget_set_name (warning_lb, "warning_lb");
2899     gtk_widget_show (warning_lb);
2900     gtk_box_pack_start (GTK_BOX (main_v_box), warning_lb, FALSE, FALSE, 0);
2901     gtk_label_set_justify (GTK_LABEL (warning_lb), GTK_JUSTIFY_CENTER);
2902     gtk_label_set_line_wrap (GTK_LABEL (warning_lb), TRUE);
2903
2904     radio_tb = gtk_table_new (4, 2, FALSE);
2905     gtk_widget_set_name (radio_tb, "radio_tb");
2906     gtk_widget_show (radio_tb);
2907     gtk_box_pack_start (GTK_BOX (main_v_box), radio_tb, TRUE, FALSE, 0);
2908     gtk_container_set_border_width (GTK_CONTAINER (radio_tb), 5);
2909     gtk_table_set_col_spacings (GTK_TABLE (radio_tb), 8);
2910
2911     keep_rb = gtk_radio_button_new_with_mnemonic (NULL, "Keep");
2912     gtk_widget_set_name (keep_rb, "keep_rb");
2913     gtk_widget_show (keep_rb);
2914     gtk_table_attach (GTK_TABLE (radio_tb), keep_rb, 0, 1, 0, 1,
2915                       (GtkAttachOptions) (GTK_FILL),
2916                       (GtkAttachOptions) (0), 0, 0);
2917     gtk_radio_button_set_group (GTK_RADIO_BUTTON (keep_rb), radio_bt_group);
2918     radio_bt_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (keep_rb));
2919
2920     merge_rb = gtk_radio_button_new_with_mnemonic (NULL, "Merge");
2921     gtk_widget_set_name (merge_rb, "merge_rb");
2922     gtk_widget_show (merge_rb);
2923     gtk_table_attach (GTK_TABLE (radio_tb), merge_rb, 0, 1, 1, 2,
2924                       (GtkAttachOptions) (GTK_FILL),
2925                       (GtkAttachOptions) (0), 0, 0);
2926     gtk_radio_button_set_group (GTK_RADIO_BUTTON (merge_rb), radio_bt_group);
2927     radio_bt_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (merge_rb));
2928
2929     import_rb = gtk_radio_button_new_with_mnemonic (NULL, "Import");
2930     gtk_widget_set_name (import_rb, "import_rb");
2931     gtk_widget_show (import_rb);
2932     gtk_table_attach (GTK_TABLE (radio_tb), import_rb, 0, 1, 2, 3,
2933                       (GtkAttachOptions) (GTK_FILL),
2934                       (GtkAttachOptions) (0), 0, 0);
2935     gtk_radio_button_set_group (GTK_RADIO_BUTTON (import_rb), radio_bt_group);
2936     radio_bt_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (import_rb));
2937
2938     ignore_rb = gtk_radio_button_new_with_mnemonic (NULL, "Ignore");
2939     gtk_widget_set_name (ignore_rb, "ignore_rb");
2940     gtk_widget_show (ignore_rb);
2941     gtk_table_attach (GTK_TABLE (radio_tb), ignore_rb, 0, 1, 3, 4,
2942                       (GtkAttachOptions) (GTK_FILL),
2943                       (GtkAttachOptions) (0), 0, 0);
2944     gtk_radio_button_set_group (GTK_RADIO_BUTTON (ignore_rb), radio_bt_group);
2945     radio_bt_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (ignore_rb));
2946
2947     keep_lb =
2948         gtk_label_new
2949         ("Use Wireshark keys, thus overwriting AirPcap adapter(s) ones.");
2950     gtk_widget_set_name (keep_lb, "keep_lb");
2951     gtk_widget_show (keep_lb);
2952     gtk_table_attach (GTK_TABLE (radio_tb), keep_lb, 1, 2, 0, 1,
2953                       (GtkAttachOptions) (GTK_FILL),
2954                       (GtkAttachOptions) (0), 0, 0);
2955     gtk_misc_set_alignment (GTK_MISC (keep_lb), 0, 0.5);
2956
2957     merge_lb = gtk_label_new ("Merge Wireshark and AirPcap adapter(s) keys.");
2958     gtk_widget_set_name (merge_lb, "merge_lb");
2959     gtk_widget_show (merge_lb);
2960     gtk_table_attach (GTK_TABLE (radio_tb), merge_lb, 1, 2, 1, 2,
2961                       (GtkAttachOptions) (GTK_FILL),
2962                       (GtkAttachOptions) (0), 0, 0);
2963     gtk_misc_set_alignment (GTK_MISC (merge_lb), 0, 0.5);
2964
2965     import_lb =
2966         gtk_label_new
2967         ("Use AirPcap adapter(s) keys, thus overwriting Wireshark ones.");
2968     gtk_widget_set_name (import_lb, "import_lb");
2969     gtk_widget_show (import_lb);
2970     gtk_table_attach (GTK_TABLE (radio_tb), import_lb, 1, 2, 2, 3,
2971                       (GtkAttachOptions) (GTK_FILL),
2972                       (GtkAttachOptions) (0), 0, 0);
2973     gtk_misc_set_alignment (GTK_MISC (import_lb), 0, 0.5);
2974
2975     ignore_lb =
2976         gtk_label_new
2977         ("Keep using different set of keys. Remember that in this case, this dialog box will appear whenever you will attempt to modify/add/remove decryption keys.");
2978     gtk_widget_set_name (ignore_lb, "ignore_lb");
2979     gtk_widget_show (ignore_lb);
2980     gtk_table_attach (GTK_TABLE (radio_tb), ignore_lb, 1, 2, 3, 4,
2981                       (GtkAttachOptions) (GTK_FILL),
2982                       (GtkAttachOptions) (0), 0, 0);
2983     gtk_label_set_line_wrap (GTK_LABEL (ignore_lb), TRUE);
2984     gtk_misc_set_alignment (GTK_MISC (ignore_lb), 0, 0.5);
2985
2986     low_h_button_box = gtk_hbutton_box_new ();
2987     gtk_widget_set_name (low_h_button_box, "low_h_button_box");
2988     gtk_widget_show (low_h_button_box);
2989     gtk_box_pack_start (GTK_BOX (main_v_box), low_h_button_box, FALSE, FALSE,
2990                         0);
2991     gtk_button_box_set_layout (GTK_BUTTON_BOX (low_h_button_box),
2992                                GTK_BUTTONBOX_SPREAD);
2993
2994     ok_bt = gtk_button_new_with_mnemonic ("OK");
2995     gtk_widget_set_name (ok_bt, "ok_bt");
2996     gtk_widget_show (ok_bt);
2997     gtk_container_add (GTK_CONTAINER (low_h_button_box), ok_bt);
2998     GTK_WIDGET_SET_FLAGS (ok_bt, GTK_CAN_DEFAULT);
2999
3000     cancel_bt = gtk_button_new_with_mnemonic ("Cancel");
3001     gtk_widget_set_name (cancel_bt, "cancel_bt");
3002     gtk_widget_show (cancel_bt);
3003     gtk_container_add (GTK_CONTAINER (low_h_button_box), cancel_bt);
3004     GTK_WIDGET_SET_FLAGS (cancel_bt, GTK_CAN_DEFAULT);
3005
3006     /* Store pointers to all widgets, for use by lookup_widget(). */
3007     g_signal_connect (ok_bt, "clicked", G_CALLBACK(on_keys_check_ok_bt_clicked), keys_check_w);
3008     g_signal_connect (cancel_bt, "clicked", G_CALLBACK(on_keys_check_cancel_bt_clicked), keys_check_w);
3009     g_signal_connect (keys_check_w, "destroy", G_CALLBACK(on_keys_check_w_destroy), keys_check_w);
3010
3011     /* Store pointers to all widgets, for use by lookup_widget(). */
3012     g_object_set_data(G_OBJECT(keys_check_w),AIRPCAP_CHECK_WINDOW_KEY,w);
3013     g_object_set_data(G_OBJECT(keys_check_w),AIRPCAP_CHECK_WINDOW_RADIO_MERGE_KEY,merge_rb);
3014     g_object_set_data(G_OBJECT(keys_check_w),AIRPCAP_CHECK_WINDOW_RADIO_KEEP_KEY,keep_rb);
3015     g_object_set_data(G_OBJECT(keys_check_w),AIRPCAP_CHECK_WINDOW_RADIO_IMPORT_KEY,import_rb);
3016     g_object_set_data(G_OBJECT(keys_check_w),AIRPCAP_CHECK_WINDOW_RADIO_IGNORE_KEY,ignore_rb);
3017     g_object_set_data(G_OBJECT(keys_check_w),AIRPCAP_CHECK_WINDOW_RADIO_GROUP_KEY,radio_bt_group);
3018
3019     gtk_widget_set_sensitive(top_level,FALSE);
3020     gtk_widget_show(keys_check_w);
3021 }
3022
3023 void
3024 on_keys_check_cancel_bt_clicked (GtkWidget *button, gpointer user_data)
3025 {
3026     GtkWidget *key_management_w;
3027     GtkWidget *keys_check_w;
3028     GtkWidget *key_ls;
3029
3030     keys_check_w = GTK_WIDGET(user_data);
3031
3032     key_management_w = g_object_get_data(G_OBJECT(keys_check_w),AIRPCAP_CHECK_WINDOW_KEY);
3033
3034     /* w may be NULL if airpcap_keys_check_w() has been called while wireshark was loading,
3035        and is not NULL if it was called when the Key Management widget has been clicked */
3036     if (key_management_w != NULL)
3037     {
3038         /*  ... */
3039         key_ls = g_object_get_data(G_OBJECT(key_management_w),AIRPCAP_ADVANCED_KEYLIST_KEY);
3040         airpcap_fill_key_list(key_ls);
3041         gtk_widget_show (key_management_w);
3042     }
3043
3044     gtk_widget_destroy(keys_check_w);
3045 }
3046
3047 void
3048 on_keys_check_ok_bt_clicked (GtkWidget *button, gpointer user_data)
3049 {
3050     GtkWidget *key_management_w;
3051     GtkWidget *keys_check_w;
3052
3053     GtkWidget *merge_rb,
3054     *keep_rb,
3055     *import_rb,
3056     *ignore_rb;
3057
3058     keys_check_w = GTK_WIDGET(user_data);
3059
3060     key_management_w = g_object_get_data(G_OBJECT(keys_check_w),AIRPCAP_CHECK_WINDOW_KEY);
3061     merge_rb  = g_object_get_data(G_OBJECT(keys_check_w),AIRPCAP_CHECK_WINDOW_RADIO_MERGE_KEY);
3062     keep_rb   = g_object_get_data(G_OBJECT(keys_check_w),AIRPCAP_CHECK_WINDOW_RADIO_KEEP_KEY);
3063     import_rb = g_object_get_data(G_OBJECT(keys_check_w),AIRPCAP_CHECK_WINDOW_RADIO_IMPORT_KEY);
3064     ignore_rb = g_object_get_data(G_OBJECT(keys_check_w),AIRPCAP_CHECK_WINDOW_RADIO_IGNORE_KEY);
3065
3066     /* Find out which radio button is selected and call the correct function */
3067     if (GTK_TOGGLE_BUTTON(merge_rb)->active) on_merge_bt_clicked (merge_rb,keys_check_w);
3068     else if (GTK_TOGGLE_BUTTON(keep_rb)->active) on_keep_bt_clicked (keep_rb,keys_check_w);
3069     else if (GTK_TOGGLE_BUTTON(import_rb)->active) on_import_bt_clicked (import_rb,keys_check_w);
3070     else if (GTK_TOGGLE_BUTTON(ignore_rb)->active) on_ignore_bt_clicked (ignore_rb,keys_check_w);
3071     else on_keys_check_cancel_bt_clicked(NULL,keys_check_w);
3072 }
3073
3074 void
3075 on_keys_check_w_destroy (GtkWidget *w, gpointer user_data)
3076 {
3077     gtk_widget_set_sensitive(top_level,TRUE);
3078     gtk_widget_set_sensitive(GTK_WIDGET(user_data),TRUE);
3079 }
3080
3081 void
3082 on_keep_bt_clicked (GtkWidget *button, gpointer user_data)
3083 {
3084     GtkWidget *key_management_w;
3085     GtkWidget *keys_check_w;
3086     GtkWidget *key_ls=NULL;
3087
3088     GList* wireshark_keys=NULL;
3089     guint n_wireshark_keys = 0;
3090
3091     GList* merged_keys=NULL;
3092     guint n_merged_keys = 0;
3093
3094     guint n_adapters=0;
3095     guint n_total_keys=0;
3096
3097     keys_check_w = GTK_WIDGET(user_data);
3098
3099     key_management_w = g_object_get_data(G_OBJECT(keys_check_w),AIRPCAP_CHECK_WINDOW_KEY);
3100
3101     n_adapters = g_list_length(airpcap_if_list);
3102
3103     /* Retrieve Wireshark keys */
3104     wireshark_keys = get_wireshark_keys();
3105     n_wireshark_keys = g_list_length(wireshark_keys);
3106     n_total_keys += n_wireshark_keys;
3107
3108     merged_keys = merge_key_list(wireshark_keys,NULL);
3109     n_merged_keys = g_list_length(merged_keys);
3110
3111     /* Set up this new list as default for Wireshark and Adapters... */
3112     airpcap_save_decryption_keys(merged_keys,airpcap_if_list);
3113
3114     /* Write the preferences to the preferences file (here is not needed, by the way)*/
3115     write_prefs_to_file();
3116
3117     /* Free the memory */
3118     free_key_list(wireshark_keys);
3119
3120     /* Close the window */
3121     gtk_widget_destroy(keys_check_w);
3122
3123     /* w may be NULL if airpcap_keys_check_w() has been called while wireshark was loading,
3124        and is not NULL if it was called when the Key Management widget has been clicked */
3125     if (key_management_w != NULL)
3126     {
3127         /*  ... */
3128         key_ls = g_object_get_data(G_OBJECT(key_management_w),AIRPCAP_ADVANCED_KEYLIST_KEY);
3129         airpcap_fill_key_list(key_ls);
3130         gtk_widget_show (key_management_w);
3131     }
3132 }
3133
3134 void
3135 on_merge_bt_clicked (GtkWidget * button, gpointer user_data)
3136 {
3137     GtkWidget *key_management_w;
3138     GtkWidget *keys_check_w;
3139     GtkWidget *key_ls;
3140
3141     guint n_adapters = 0;
3142     guint n_wireshark_keys = 0;
3143     guint n_driver_keys = 0;
3144     guint n_curr_adapter_keys = 0;
3145     guint n_total_keys = 0;
3146     guint n_merged_keys = 0;
3147     guint i = 0;
3148
3149     GList* wireshark_keys=NULL;
3150     GList* driver_keys=NULL;
3151     GList* current_adapter_keys=NULL;
3152     GList* merged_list = NULL;
3153     GList* merged_list_tmp = NULL;
3154
3155     airpcap_if_info_t* curr_adapter;
3156
3157     keys_check_w = GTK_WIDGET(user_data);
3158
3159     key_management_w = g_object_get_data(G_OBJECT(keys_check_w),AIRPCAP_CHECK_WINDOW_KEY);
3160
3161     n_adapters = g_list_length(airpcap_if_list);
3162
3163     /* Retrieve Wireshark keys */
3164     wireshark_keys = get_wireshark_keys();
3165     n_wireshark_keys = g_list_length(wireshark_keys);
3166     n_total_keys += n_wireshark_keys;
3167
3168     merged_list = merge_key_list(wireshark_keys,NULL);
3169
3170     /* Retrieve AirPcap driver's keys */
3171     driver_keys = get_airpcap_driver_keys();
3172     n_driver_keys = g_list_length(driver_keys);
3173     n_total_keys += n_driver_keys;
3174
3175     merged_list = merge_key_list(merged_list,driver_keys);
3176
3177     /* NOW wireshark_keys and driver_keys ARE no more needed... at the end, we will have to free them! */
3178     for (i = 0; i<n_adapters; i++)
3179     {
3180         curr_adapter = (airpcap_if_info_t*)g_list_nth_data(airpcap_if_list,i);
3181         current_adapter_keys = get_airpcap_device_keys(curr_adapter);
3182         n_curr_adapter_keys = g_list_length(current_adapter_keys);
3183
3184         merged_list_tmp = merged_list;
3185         merged_list = merge_key_list(merged_list_tmp,current_adapter_keys);
3186         free_key_list(merged_list_tmp);
3187
3188         n_total_keys += n_curr_adapter_keys;
3189     }
3190
3191     n_merged_keys = g_list_length(merged_list);
3192
3193     /* Set up this new list as default for Wireshark and Adapters... */
3194     airpcap_save_decryption_keys(merged_list,airpcap_if_list);
3195
3196     /* Write the preferences to the preferences file */
3197     write_prefs_to_file();
3198
3199     free_key_list(wireshark_keys);
3200     free_key_list(driver_keys);
3201
3202     gtk_widget_destroy(keys_check_w);
3203
3204     /* w may be NULL if airpcap_keys_check_w() has been called while wireshark was loading,
3205        and is not NULL if it was called when the Key Management widget has been clicked */
3206     if (key_management_w != NULL)
3207     {
3208         /*  ... */
3209         key_ls = g_object_get_data(G_OBJECT(key_management_w),AIRPCAP_ADVANCED_KEYLIST_KEY);
3210         airpcap_fill_key_list(key_ls);
3211         gtk_widget_show (key_management_w);
3212     }
3213 }
3214
3215
3216 void
3217 on_import_bt_clicked (GtkWidget * button, gpointer user_data)
3218 {
3219     GtkWidget *key_management_w;
3220     GtkWidget *keys_check_w;
3221     GtkWidget *key_ls;
3222
3223     guint n_adapters = 0;
3224     guint n_wireshark_keys = 0;
3225     guint n_driver_keys = 0;
3226     guint n_curr_adapter_keys = 0;
3227     guint n_total_keys = 0;
3228     guint n_merged_keys = 0;
3229     guint i = 0;
3230
3231     GList* wireshark_keys=NULL;
3232     GList* driver_keys=NULL;
3233     GList* current_adapter_keys=NULL;
3234     GList* merged_list = NULL;
3235     GList* merged_list_tmp = NULL;
3236
3237     airpcap_if_info_t* curr_adapter;
3238
3239     keys_check_w = GTK_WIDGET(user_data);
3240
3241     key_management_w = g_object_get_data(G_OBJECT(keys_check_w),AIRPCAP_CHECK_WINDOW_KEY);
3242
3243     n_adapters = g_list_length(airpcap_if_list);
3244
3245     wireshark_keys = get_wireshark_keys();
3246     n_wireshark_keys = g_list_length(wireshark_keys);
3247     n_total_keys += n_wireshark_keys;
3248
3249     /* Retrieve AirPcap driver's keys */
3250     driver_keys = get_airpcap_driver_keys();
3251     n_driver_keys = g_list_length(driver_keys);
3252     n_total_keys += n_driver_keys;
3253
3254     merged_list = merge_key_list(merged_list,driver_keys);
3255
3256     /* NOW wireshark_keys IS no more needed... at the end, we will have to free it! */
3257     for (i = 0; i<n_adapters; i++)
3258     {
3259         curr_adapter = (airpcap_if_info_t*)g_list_nth_data(airpcap_if_list,i);
3260         current_adapter_keys = get_airpcap_device_keys(curr_adapter);
3261         n_curr_adapter_keys = g_list_length(current_adapter_keys);
3262
3263         merged_list_tmp = merged_list;
3264         merged_list = merge_key_list(merged_list_tmp,current_adapter_keys);
3265         free_key_list(merged_list_tmp);
3266
3267         n_total_keys += n_curr_adapter_keys;
3268     }
3269
3270     n_merged_keys = g_list_length(merged_list);
3271
3272     /* Set up this new list as default for Wireshark and Adapters... */
3273     airpcap_save_decryption_keys(merged_list,airpcap_if_list);
3274
3275     /* Write the preferences to the preferences file */
3276     write_prefs_to_file();
3277
3278     free_key_list(wireshark_keys);
3279     free_key_list(driver_keys);
3280
3281     gtk_widget_destroy(keys_check_w);
3282
3283     /* w may be NULL if airpcap_keys_check_w() has been called while wireshark was loading,
3284        and is not NULL if it was called when the Key Management widget has been clicked */
3285     if (key_management_w != NULL)
3286     {
3287         /*  ... */
3288         key_ls = g_object_get_data(G_OBJECT(key_management_w),AIRPCAP_ADVANCED_KEYLIST_KEY);
3289         airpcap_fill_key_list(key_ls);
3290         gtk_widget_show (key_management_w);
3291     }
3292 }
3293
3294
3295 void
3296 on_ignore_bt_clicked (GtkWidget * button, gpointer user_data)
3297 {
3298     GtkWidget *key_management_w;
3299     GtkWidget *keys_check_w;
3300     GtkWidget *key_ls;
3301
3302     keys_check_w = GTK_WIDGET(user_data);
3303
3304     key_management_w = g_object_get_data(G_OBJECT(keys_check_w),AIRPCAP_CHECK_WINDOW_KEY);
3305
3306     /* w may be NULL if airpcap_keys_check_w() has been called while wireshark was loading,
3307        and is not NULL if it was called when the Key Management widget has been clicked */
3308     if (key_management_w != NULL)
3309     {
3310         /*  ... */
3311         key_ls = g_object_get_data(G_OBJECT(key_management_w),AIRPCAP_ADVANCED_KEYLIST_KEY);
3312         airpcap_fill_key_list(key_ls);
3313         gtk_widget_show (key_management_w);
3314     }
3315
3316     gtk_widget_destroy(keys_check_w);
3317 }
3318
3319
3320 #endif /* HAVE_AIRPCAP */