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