Move gtk to ui/gtk.

This looses the last checkin to gtk, will add this manually back.

svn path=/trunk/; revision=40518

1 files changed, 2911 insertions, 0 deletions

diff --git a/ui/gtk/airpcap_dlg.c b/ui/gtk/airpcap_dlg.c
new file mode 100644
index 0000000000..0ab3d717fb
--- /dev/null
+++ b/ui/gtk/airpcap_dlg.c
@@ -0,0 +1,2911 @@
+/* airpcap_dlg.c
+ *
+ * $Id$
+ *
+ * Giorgio Tino <giorgio.tino@cacetech.com>
+ * Copyright (c) CACE Technologies, LLC 2006
+ *
+ * Wireshark - Network traffic analyzer
+ * By Gerald Combs <gerald@wireshark.org>
+ * Copyright 2000 Gerald Combs
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#ifdef HAVE_AIRPCAP
+
+#include <gtk/gtk.h>
+/*#include <glib/gprintf.h> */
+
+#include <string.h>
+
+#include <epan/filesystem.h>
+#include <epan/emem.h>
+#include <epan/prefs.h>
+#include <epan/prefs-int.h>
+#include <epan/frequency-utils.h>
+#include <epan/crypt/wep-wpadefs.h>
+
+#include <pcap.h>
+
+#include "../simple_dialog.h"
+
+#include "ui/gtk/main.h"
+#include "ui/gtk/dlg_utils.h"
+#include "ui/gtk/gui_utils.h"
+#include "ui/gtk/dfilter_expr_dlg.h"
+#include "ui/gtk/stock_icons.h"
+#include "ui/gtk/gtkglobals.h"
+#include "ui/gtk/help_dlg.h"
+#include "ui/gtk/keys.h"
+#include "ui/gtk/old-gtk-compat.h"
+
+#include <airpcap.h>
+#include "airpcap_loader.h"
+#include "airpcap_gui_utils.h"
+#include "airpcap_dlg.h"
+
+/*
+ * This structure is used because we need to store infos about the currently selected
+ * row in the key list.
+ */
+typedef struct{
+    gint row;
+}airpcap_key_ls_selected_info_t;
+
+/*
+ * This function is used to write the preferences to the preferences file.
+ * It has the same behaviour as prefs_main_write() in prefs_dlg.c
+ */
+static void
+write_prefs_to_file(void)
+{
+    int err;
+    char *pf_dir_path;
+    char *pf_path;
+
+    /* Create the directory that holds personal configuration files, if
+       necessary.  */
+    if (create_persconffile_dir(&pf_dir_path) == -1) {
+        simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
+                      "Can't create directory\n\"%s\"\nfor preferences file: %s.", pf_dir_path,
+                      g_strerror(errno));
+        g_free(pf_dir_path);
+    } else {
+        /* Write the preferencs out. */
+        err = write_prefs(&pf_path);
+        if (err != 0) {
+            simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
+                          "Can't open preferences file\n\"%s\": %s.", pf_path,
+                          g_strerror(err));
+            g_free(pf_path);
+        }
+    }
+}
+
+/*
+ * Callback for the select row event in the key list widget
+ */
+static void
+on_key_list_select_row(GtkTreeSelection *selection, gpointer data)
+{
+    GtkWidget *add_new_key_bt, *edit_key_bt, *remove_key_bt;
+    GtkWidget *move_key_up_bt, *move_key_down_bt;
+    GtkTreeIter iter;
+    GtkTreeModel *model;
+    GtkTreePath *path, *path_up, *path_down;
+
+    add_new_key_bt = g_object_get_data(G_OBJECT(data), AIRPCAP_KEY_MGMT_NEW_KEY);
+    edit_key_bt = g_object_get_data(G_OBJECT(data), AIRPCAP_KEY_MGMT_EDIT_KEY);
+    remove_key_bt = g_object_get_data(G_OBJECT(data), AIRPCAP_KEY_MGMT_DELETE_KEY);
+    move_key_up_bt = g_object_get_data(G_OBJECT(data), AIRPCAP_KEY_MGMT_UP_KEY);
+    move_key_down_bt = g_object_get_data(G_OBJECT(data), AIRPCAP_KEY_MGMT_DOWN_KEY);
+
+    if (gtk_tree_selection_get_selected(selection, &model, &iter)) {
+        path = gtk_tree_model_get_path(model, &iter);
+        path_up = gtk_tree_path_copy(path);
+        path_down = gtk_tree_path_copy(path);
+        gtk_tree_path_next(path_down);
+
+        if (gtk_tree_model_iter_n_children(model, NULL) >= MAX_ENCRYPTION_KEYS) {
+            gtk_widget_set_sensitive(add_new_key_bt, FALSE);
+        } else {
+            gtk_widget_set_sensitive(add_new_key_bt, TRUE);
+        }
+
+        gtk_widget_set_sensitive(edit_key_bt, TRUE);
+        gtk_widget_set_sensitive(remove_key_bt, TRUE);
+
+        /* ...and we have to use two different methods to figure out first/last because? */
+        if (gtk_tree_path_prev(path_up)) {
+            gtk_widget_set_sensitive(move_key_up_bt, TRUE);
+        } else {
+            gtk_widget_set_sensitive(move_key_up_bt, FALSE);
+        }
+
+        if (gtk_tree_model_get_iter(model, &iter, path_down)) {
+            gtk_widget_set_sensitive(move_key_down_bt, TRUE);
+        } else {
+            gtk_widget_set_sensitive(move_key_down_bt, FALSE);
+        }
+
+        gtk_tree_path_free(path);
+        gtk_tree_path_free(path_up);
+        gtk_tree_path_free(path_down);
+    } else {
+        gtk_widget_set_sensitive(add_new_key_bt, FALSE);
+        gtk_widget_set_sensitive(edit_key_bt, FALSE);
+        gtk_widget_set_sensitive(remove_key_bt, FALSE);
+        gtk_widget_set_sensitive(move_key_up_bt, FALSE);
+        gtk_widget_set_sensitive(move_key_down_bt, FALSE);
+    }
+}
+/*
+ * Callback for the select row event in the key list widget
+ */
+static void
+on_key_list_reorder(GtkTreeModel *model _U_, GtkTreePath *path _U_, GtkTreeIter *iter _U_, gpointer no _U_, gpointer data) {
+    GtkTreeSelection *selection;
+
+    selection = g_object_get_data(G_OBJECT(data), AIRPCAP_ADVANCED_EDIT_KEY_SELECTION_KEY);
+    on_key_list_select_row(selection, data);
+}
+
+/*
+ * Callback for the crc checkbox
+ */
+static void
+on_fcs_ck_toggled(GtkWidget *w _U_, gpointer user_data _U_)
+
+{
+    if (airpcap_if_selected != NULL)
+    {
+        if (airpcap_if_selected->IsFcsPresent)
+        {
+            airpcap_if_selected->IsFcsPresent = FALSE;
+            airpcap_if_selected->saved = FALSE;
+        }
+        else
+        {
+            airpcap_if_selected->IsFcsPresent = TRUE;
+            airpcap_if_selected->saved = FALSE;
+        }
+    }
+}
+
+/*
+ * Callback for the wrong crc combo
+ */
+static void
+on_edit_type_cb_changed(GtkWidget *w, gpointer data)
+{
+    GtkWidget *edit_key_w;
+    GtkWidget *edit_ssid_te;
+    GtkWidget *type_cb;
+    GtkWidget *key_lb;
+    GtkWidget *ssid_lb;
+
+    gchar* type_text = NULL;
+
+    edit_key_w = GTK_WIDGET(data);
+    type_cb    = w;
+
+    edit_ssid_te = g_object_get_data(G_OBJECT(edit_key_w),AIRPCAP_ADVANCED_EDIT_KEY_SSID_KEY);
+    key_lb = g_object_get_data(G_OBJECT(edit_key_w),AIRPCAP_ADVANCED_EDIT_KEY_KEY_LABEL_KEY);
+    ssid_lb = g_object_get_data(G_OBJECT(edit_key_w),AIRPCAP_ADVANCED_EDIT_KEY_SSID_LABEL_KEY);
+
+    type_text = gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT(type_cb));
+
+    if (g_ascii_strcasecmp(type_text, ""))
+    {
+        /*
+         * If it is a WEP key, no SSID is required! Gray out the entry text so
+         * it doesn't create confusion ...
+         */
+        if (g_ascii_strcasecmp(type_text,AIRPCAP_WEP_KEY_STRING) == 0)
+        {
+            gtk_widget_set_sensitive(edit_ssid_te,FALSE);
+            /*
+             * Maybe the user has already entered some text into the SSID field
+             * and then switched to WEP...
+             */
+            gtk_entry_set_text(GTK_ENTRY(edit_ssid_te),"");
+            gtk_label_set_text(GTK_LABEL(key_lb),"Key");
+            gtk_label_set_text(GTK_LABEL(ssid_lb),"");
+        }
+        else if (g_ascii_strcasecmp(type_text,AIRPCAP_WPA_BIN_KEY_STRING) == 0)
+        {
+            gtk_widget_set_sensitive(edit_ssid_te,FALSE);
+            /*
+             * Maybe the user has already entered some text into the SSID field
+             * and then switched to WPA...
+             */
+            gtk_entry_set_text(GTK_ENTRY(edit_ssid_te),"");
+            gtk_label_set_text(GTK_LABEL(key_lb),"Key");
+            gtk_label_set_text(GTK_LABEL(ssid_lb),"");
+        }
+        else if (g_ascii_strcasecmp(type_text,AIRPCAP_WPA_PWD_KEY_STRING) == 0)
+        {
+            gtk_widget_set_sensitive(edit_ssid_te,TRUE);
+            /*
+             * Maybe the user has already entered some text into the SSID field
+             * and then switched to WPA...
+             */
+            gtk_entry_set_text(GTK_ENTRY(edit_ssid_te),"");
+            gtk_label_set_text(GTK_LABEL(key_lb),"Passphrase");
+            gtk_label_set_text(GTK_LABEL(ssid_lb),"SSID");
+        }
+    }
+    gtk_widget_show(edit_ssid_te);
+
+    g_free(type_text);
+}
+
+/*
+ * Callback for the wrong crc combo
+ */
+static void
+on_add_type_cb_changed(GtkWidget *w, gpointer data)
+{
+    GtkWidget *add_key_w;
+    GtkWidget *add_ssid_te;
+    GtkWidget *type_cb;
+    GtkWidget *key_lb;
+    GtkWidget *ssid_lb;
+
+    gchar* type_text = NULL;
+
+    add_key_w = GTK_WIDGET(data);
+    type_cb   = w;
+
+    add_ssid_te = g_object_get_data(G_OBJECT(add_key_w),AIRPCAP_ADVANCED_ADD_KEY_SSID_KEY);
+    key_lb = g_object_get_data(G_OBJECT(add_key_w),AIRPCAP_ADVANCED_ADD_KEY_KEY_LABEL_KEY);
+    ssid_lb = g_object_get_data(G_OBJECT(add_key_w),AIRPCAP_ADVANCED_ADD_KEY_SSID_LABEL_KEY);
+
+    type_text = gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT(type_cb));
+
+    if (g_ascii_strcasecmp(type_text, ""))
+    {
+        /*
+         * If it is a WEP key, no SSID is required! Gray out rhe entry text so
+         * it doesn't create confusion ...
+         */
+        if (g_ascii_strcasecmp(type_text,AIRPCAP_WEP_KEY_STRING) == 0)
+        {
+            gtk_widget_set_sensitive(add_ssid_te,FALSE);
+            /*
+             * Maybe the user has already entered some text into the SSID field
+             * and then switched to WEP...
+             */
+            gtk_entry_set_text(GTK_ENTRY(add_ssid_te),"");
+            gtk_label_set_text(GTK_LABEL(key_lb),"Key");
+            gtk_label_set_text(GTK_LABEL(ssid_lb),"");
+        }
+        else if (g_ascii_strcasecmp(type_text,AIRPCAP_WPA_BIN_KEY_STRING) == 0)
+        {
+            gtk_widget_set_sensitive(add_ssid_te,FALSE);
+            /*
+             * Maybe the user has already entered some text into the SSID field
+             * and then switched to WPA...
+             */
+            gtk_entry_set_text(GTK_ENTRY(add_ssid_te),"");
+            gtk_label_set_text(GTK_LABEL(key_lb),"Key");
+            gtk_label_set_text(GTK_LABEL(ssid_lb),"");
+        }
+        else if (g_ascii_strcasecmp(type_text,AIRPCAP_WPA_PWD_KEY_STRING) == 0)
+        {
+            gtk_widget_set_sensitive(add_ssid_te,TRUE);
+            /*
+             * Maybe the user has already entered some text into the SSID field
+             * and then switched to WPA...
+             */
+            gtk_entry_set_text(GTK_ENTRY(add_ssid_te),"");
+            gtk_label_set_text(GTK_LABEL(key_lb),"Passphrase");
+            gtk_label_set_text(GTK_LABEL(ssid_lb),"SSID");
+        }
+    }
+    gtk_widget_show(add_ssid_te);
+
+    g_free(type_text);
+}
+
+/*
+ * Callback for the wrong crc combo
+ */
+static void
+on_fcs_filter_cb_changed(GtkWidget *fcs_filter_cb, gpointer data _U_)
+{
+    gchar *fcs_filter_str;
+
+    if (fcs_filter_cb != NULL)
+    {
+        fcs_filter_str = gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT(fcs_filter_cb));
+        if (fcs_filter_str && (g_ascii_strcasecmp("", fcs_filter_str)))
+        {
+            airpcap_if_selected->CrcValidationOn = airpcap_get_validation_type(fcs_filter_str);
+            airpcap_if_selected->saved = FALSE;
+        }
+        g_free(fcs_filter_str);
+    }
+}
+
+
+/*
+ * Changed callback for the capture type combobox
+ */
+static void
+on_capture_type_cb_changed(GtkWidget *cb, gpointer user_data _U_)
+{
+    gchar *s;
+
+    if (cb == NULL) {
+        return;
+    }
+
+    s = gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT(cb));
+
+    if ((g_ascii_strcasecmp("",s)))
+    {
+        airpcap_if_selected->linkType = airpcap_get_link_type(s);
+        airpcap_if_selected->saved = FALSE;
+    }
+    g_free(s);
+}
+
+/*
+ * Thread function used to blink the led
+ */
+static gboolean
+update_blink(gpointer data)
+{
+    airpcap_if_info_t* sel;
+    PAirpcapHandle ad;
+    gchar ebuf[AIRPCAP_ERRBUF_SIZE];
+
+    sel = (airpcap_if_info_t*)data;
+
+    ad = airpcap_if_open(sel->name, ebuf);
+    if (ad)
+    {
+        if (sel->led)
+        {
+            airpcap_if_turn_led_off(ad, 0);
+            sel->led = FALSE;
+        }
+        else
+        {
+            airpcap_if_turn_led_on(ad, 0);
+            sel->led = TRUE;
+        }
+        airpcap_if_close(ad);
+    }
+    return TRUE;
+}
+
+/*
+ * Blink button callback
+ */
+static void
+on_blink_bt_clicked( GtkWidget *blink_bt, gpointer data _U_)
+{
+    PAirpcapHandle ad = NULL;
+    gchar ebuf[AIRPCAP_ERRBUF_SIZE];
+
+    if (airpcap_if_selected != NULL) {
+        if (!(airpcap_if_selected->blinking))
+        {
+            gtk_button_set_label(GTK_BUTTON(blink_bt),"Stop Blinking");
+            airpcap_if_selected->tag = g_timeout_add(500,update_blink,airpcap_if_selected);
+            airpcap_if_selected->blinking = TRUE;
+        }
+        else
+        {
+            gtk_button_set_label(GTK_BUTTON(blink_bt),"  Blink Led  ");
+            g_source_remove(airpcap_if_selected->tag);
+            airpcap_if_selected->blinking = FALSE;
+            /* Switch on the led!  */
+            ad = airpcap_if_open(airpcap_if_selected->name, ebuf);
+            if (ad)
+            {
+                g_source_remove(airpcap_if_selected->tag);
+                airpcap_if_turn_led_on(ad, 0);
+                airpcap_if_selected->blinking = FALSE;
+                airpcap_if_selected->led = TRUE;
+                airpcap_if_close(ad);
+            }
+        }
+    }
+}
+
+/*
+ * Callback for the 'Any' adapter What's This button.
+ */
+static void
+on_what_s_this_bt_clicked( GtkWidget *blink_bt _U_, gpointer data _U_)
+{
+    simple_dialog(ESD_TYPE_INFO,ESD_BTN_OK,
+                  "The Multi-Channel Aggregator is a virtual device "
+                  "that can be used to capture packets from all the "
+                  "AirPcap adapters at the same time.\n"
+                  "The Capture Type, FCS and Encryption settings of "
+                  "this virtual device can be configured as for any "
+                  "real adapter.\nThe channel cannot be changed for "
+                  "this adapter.\n"
+                  "Refer to the AirPcap manual for more information.");
+}
+
+/* the window was closed, cleanup things */
+static void
+on_key_management_destroy(GtkWidget *w _U_, gpointer data)
+{
+    GtkWidget *airpcap_advanced_w,
+              *toolbar;
+
+    gint *from_widget = NULL;
+
+    /* Retrieve the GUI object pointers */
+    airpcap_advanced_w = GTK_WIDGET(data);
+
+    toolbar = GTK_WIDGET(g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_TOOLBAR_KEY));
+
+    /* ... */
+    from_widget = (gint*)g_object_get_data(G_OBJECT(toolbar),AIRPCAP_ADVANCED_FROM_KEY);
+    /* gray out the toolbar (if we came here from the toolbar advanced button)*/
+    if ( *from_widget == AIRPCAP_ADVANCED_FROM_TOOLBAR)
+        gtk_widget_set_sensitive(toolbar,TRUE);
+    else
+        gtk_widget_set_sensitive(toolbar,FALSE);
+
+    g_free(from_widget);
+
+    /* reload the configuration!!! Configuration has not been saved but
+    the corresponding structure has been modified probably...*/
+    if (airpcap_if_selected != NULL)
+    {
+        if (!airpcap_if_selected->saved)
+        {
+            airpcap_load_selected_if_configuration(airpcap_if_selected);
+        }
+    }
+
+}
+
+/* the Advenced wireless Settings window was closed, cleanup things */
+static void
+on_airpcap_advanced_destroy(GtkWidget *w _U_, gpointer data)
+{
+    GtkWidget *airpcap_advanced_w,
+              *toolbar;
+
+    gint *from_widget = NULL;
+
+    /* Retrieve the GUI object pointers */
+    airpcap_advanced_w = GTK_WIDGET(data);
+
+    toolbar = GTK_WIDGET(g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_TOOLBAR_KEY));
+
+    /* ... */
+    from_widget = (gint*)g_object_get_data(G_OBJECT(toolbar),AIRPCAP_ADVANCED_FROM_KEY);
+    /* gray out the toolbar (if we came here from the toolbar advanced button)*/
+    if ( *from_widget == AIRPCAP_ADVANCED_FROM_TOOLBAR)
+        gtk_widget_set_sensitive(toolbar,TRUE);
+    else
+        gtk_widget_set_sensitive(toolbar,FALSE);
+
+    g_free(from_widget);
+
+    /* reload the configuration!!! Configuration has not been saved but
+    the corresponding structure has been modified probably...*/
+    if (!airpcap_if_selected->saved)
+    {
+        airpcap_load_selected_if_configuration(airpcap_if_selected);
+    }
+}
+
+/*
+ * Callback for the 'Apply' button.
+ */
+/*
+ * XXX - Pressing 'Apply' has the same effect as pressing 'OK' -- you
+ * can't revert back to the old set of keys by pressing 'Cancel'.  We
+ * either need to fix reversion or get rid of the 'Apply' button.
+ */
+static void
+on_key_management_apply_bt_clicked(GtkWidget *button _U_, gpointer data)
+{
+    /* advenced window */
+    GtkWidget   *key_management_w;
+
+    /* widgets in the toolbar */
+    GtkWidget   *toolbar;
+    GtkWidget   *toolbar_cb;
+    GtkWidget   *decryption_mode_cb;
+
+    GtkListStore *key_list_store;
+
+    module_t *wlan_module = prefs_find_module("wlan");
+    gchar *decryption_mode_string;
+
+    /* retrieve main window */
+    key_management_w      = GTK_WIDGET(data);
+    decryption_mode_cb    = GTK_WIDGET(g_object_get_data(G_OBJECT(key_management_w),AIRPCAP_ADVANCED_DECRYPTION_MODE_KEY));
+    key_list_store        = GTK_LIST_STORE(g_object_get_data(G_OBJECT(key_management_w),AIRPCAP_ADVANCED_KEYLIST_KEY));
+    toolbar               = GTK_WIDGET(g_object_get_data(G_OBJECT(key_management_w),AIRPCAP_TOOLBAR_KEY));
+    toolbar_cb            = GTK_WIDGET(g_object_get_data(G_OBJECT(key_management_w),AIRPCAP_TOOLBAR_DECRYPTION_KEY));
+
+#define CANT_SAVE_ERR_STR "Cannot save configuration! Another application " \
+    "might be using AirPcap, or you might not have sufficient privileges."
+    /* Set the Decryption Mode */
+
+    decryption_mode_string = gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT(decryption_mode_cb));
+    if (g_ascii_strcasecmp(decryption_mode_string, AIRPCAP_DECRYPTION_TYPE_STRING_WIRESHARK) == 0)
+    {
+        set_wireshark_decryption(TRUE);
+        if (!set_airpcap_decryption(FALSE)) g_warning(CANT_SAVE_ERR_STR);
+    }
+    else if (g_ascii_strcasecmp(decryption_mode_string, AIRPCAP_DECRYPTION_TYPE_STRING_AIRPCAP) == 0)
+    {
+        set_wireshark_decryption(FALSE);
+        if (!set_airpcap_decryption(TRUE)) g_warning(CANT_SAVE_ERR_STR);
+    }
+    else if (g_ascii_strcasecmp(decryption_mode_string, AIRPCAP_DECRYPTION_TYPE_STRING_NONE) == 0)
+    {
+        set_wireshark_decryption(FALSE);
+        if (!set_airpcap_decryption(FALSE)) g_warning(CANT_SAVE_ERR_STR);
+    }
+    g_free(decryption_mode_string);
+
+    /* Save the configuration */
+    airpcap_read_and_save_decryption_keys_from_list_store(key_list_store,airpcap_if_selected,airpcap_if_list); /* This will save the keys for every adapter */
+
+    /* The update will make redissect al the packets... no need to do it here again */
+    update_decryption_mode(toolbar_cb);
+
+    /* Redissect all the packets, and re-evaluate the display filter. */
+    prefs_apply(wlan_module);
+}
+
+/*
+ * Callback used to add a WEP key in the add new key box;
+ */
+static void
+on_add_key_ok_bt_clicked(GtkWidget *widget _U_, gpointer data)
+{
+    GtkWidget   *type_cb,
+                *key_en,
+                *ssid_en;
+
+    GtkListStore *key_list_store;
+
+    GString     *new_type_string,
+                *new_key_string,
+                *new_ssid_string;
+
+    gchar       *type_entered = NULL;
+    gchar       *key_entered = NULL;
+    gchar       *ssid_entered = NULL;
+
+    unsigned int i;
+
+    key_list_store = g_object_get_data(G_OBJECT(data),AIRPCAP_ADVANCED_ADD_KEY_LIST_KEY);
+    type_cb = g_object_get_data(G_OBJECT(data),AIRPCAP_ADVANCED_ADD_KEY_TYPE_KEY);
+    key_en = g_object_get_data(G_OBJECT(data),AIRPCAP_ADVANCED_ADD_KEY_KEY_KEY);
+    ssid_en = g_object_get_data(G_OBJECT(data),AIRPCAP_ADVANCED_ADD_KEY_SSID_KEY);
+
+    type_entered = gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT(type_cb));
+    key_entered  = g_strdup(gtk_entry_get_text(GTK_ENTRY(key_en)));
+    ssid_entered = g_strdup(gtk_entry_get_text(GTK_ENTRY(ssid_en)));
+
+    /* Check if key is correct */
+    new_type_string = g_string_new(type_entered);
+    new_key_string = g_string_new(key_entered);
+    new_ssid_string = g_string_new(ssid_entered);
+
+    g_free(type_entered);
+    g_free(key_entered );
+    g_free(ssid_entered);
+
+    g_strstrip(new_key_string->str);
+    g_strstrip(new_ssid_string->str);
+
+    /* Check which type of key the user has entered */
+    if (g_ascii_strcasecmp(new_type_string->str,AIRPCAP_WEP_KEY_STRING) == 0) /* WEP key */
+    {
+
+        if ( ((new_key_string->len) > WEP_KEY_MAX_CHAR_SIZE) || ((new_key_string->len) < WEP_KEY_MIN_CHAR_SIZE))
+        {
+            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);
+
+            g_string_free(new_type_string,TRUE);
+            g_string_free(new_key_string, TRUE);
+            g_string_free(new_ssid_string,TRUE);
+
+            return;
+        }
+
+        if ((new_key_string->len % 2) != 0)
+        {
+            simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"Invalid WEP key!\nThe number of characters must be even.");
+
+            g_string_free(new_type_string,TRUE);
+            g_string_free(new_key_string, TRUE);
+            g_string_free(new_ssid_string,TRUE);
+
+            return;
+        }
+
+        for (i = 0; i < new_key_string->len; i++)
+        {
+            if (!g_ascii_isxdigit(new_key_string->str[i]))
+            {
+                simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"Invalid WEP key!\nA WEP key must be a hexadecimal number.\nThe valid characters are: 0123456789ABCDEF.");
+
+                g_string_free(new_type_string,TRUE);
+                g_string_free(new_key_string, TRUE);
+                g_string_free(new_ssid_string,TRUE);
+
+                return;
+            }
+        }
+
+        /* If so... add key */
+        airpcap_add_key_to_list(key_list_store, new_type_string->str, new_key_string->str, new_ssid_string->str);
+
+        if (airpcap_if_selected != NULL) airpcap_if_selected->saved = FALSE;
+    }
+    else if (g_ascii_strcasecmp(new_type_string->str,AIRPCAP_WPA_PWD_KEY_STRING) == 0) /* WPA Key */
+    {
+        /* XXX - Perform some WPA related input fields check */
+        /* If everything is ok, modify the entry in the list */
+
+        if ( ((new_key_string->len) > WPA_KEY_MAX_CHAR_SIZE) || ((new_key_string->len) < WPA_KEY_MIN_CHAR_SIZE))
+        {
+            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);
+
+            g_string_free(new_type_string,TRUE);
+            g_string_free(new_key_string, TRUE);
+            g_string_free(new_ssid_string,TRUE);
+
+            return;
+        }
+
+        /*
+         * XXX - Maybe we need some check on the characters? I'm not sure if only standard ASCII are ok...
+         */
+        if ((new_ssid_string->len) > WPA_SSID_MAX_CHAR_SIZE)
+        {
+            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);
+
+            g_string_free(new_type_string,TRUE);
+            g_string_free(new_key_string, TRUE);
+            g_string_free(new_ssid_string,TRUE);
+
+            return;
+        }
+
+        /* If so... add key */
+        airpcap_add_key_to_list(key_list_store, new_type_string->str, new_key_string->str, new_ssid_string->str);
+
+        if (airpcap_if_selected != NULL) airpcap_if_selected->saved = FALSE;
+    }
+    else if (g_ascii_strcasecmp(new_type_string->str,AIRPCAP_WPA_BIN_KEY_STRING) == 0) /* WPA_BIN Key */
+    {
+        /* XXX - Perform some WPA_BIN related input fields check */
+        /* If everything is ok, modify the entry int he list */
+
+        if ( ((new_key_string->len) != WPA_PSK_KEY_CHAR_SIZE))
+        {
+            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);
+
+            g_string_free(new_type_string,TRUE);
+            g_string_free(new_key_string, TRUE);
+            g_string_free(new_ssid_string,TRUE);
+
+            return;
+        }
+
+        for (i = 0; i < new_key_string->len; i++)
+        {
+            if (!g_ascii_isxdigit(new_key_string->str[i]))
+            {
+                simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"Invalid WPA PSK/PMK key!\nKey must be an hexadecimal number.\nThe valid characters are: 0123456789ABCDEF.");
+
+                g_string_free(new_type_string,TRUE);
+                g_string_free(new_key_string, TRUE);
+                g_string_free(new_ssid_string,TRUE);
+
+                return;
+            }
+        }
+
+        /* If so... add key */
+        airpcap_add_key_to_list(key_list_store, new_type_string->str, new_key_string->str, new_ssid_string->str);
+
+        if (airpcap_if_selected != NULL) airpcap_if_selected->saved = FALSE;
+    }
+    else /* Should never happen!!! */
+    {
+        simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"Unknown error in the key \"Type\" field!");
+    }
+
+    g_string_free(new_type_string,TRUE);
+    g_string_free(new_key_string, TRUE);
+    g_string_free(new_ssid_string,TRUE);
+
+    window_destroy(GTK_WIDGET(data));
+    return;
+}
+
+/*
+ * Callback used to edit a WEP key in the edit key box;
+ */
+static void
+on_edit_key_ok_bt_clicked(GtkWidget *widget _U_, gpointer data)
+{
+    GtkWidget   *type_cb,
+                *key_en,
+                *ssid_en;
+
+    GtkListStore *key_list_store;
+    GtkTreeSelection *selection;
+    GtkTreeIter iter;
+
+    GString     *new_type_string,
+                *new_key_string,
+                *new_ssid_string;
+
+    gchar       *type_entered = NULL;
+    gchar       *key_entered = NULL;
+    gchar       *ssid_entered = NULL;
+
+    unsigned int i;
+
+    key_list_store = g_object_get_data(G_OBJECT(data),AIRPCAP_ADVANCED_EDIT_KEY_LIST_KEY);
+    selection = g_object_get_data(G_OBJECT(data), AIRPCAP_ADVANCED_EDIT_KEY_SELECTION_KEY);
+    type_cb = g_object_get_data(G_OBJECT(data),AIRPCAP_ADVANCED_EDIT_KEY_TYPE_KEY);
+    key_en = g_object_get_data(G_OBJECT(data),AIRPCAP_ADVANCED_EDIT_KEY_KEY_KEY);
+    ssid_en = g_object_get_data(G_OBJECT(data),AIRPCAP_ADVANCED_EDIT_KEY_SSID_KEY);
+
+    if (!gtk_tree_selection_get_selected(selection, NULL, &iter))
+      return;
+
+    type_entered = gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT(type_cb));
+    key_entered  = g_strdup(gtk_entry_get_text(GTK_ENTRY(key_en)));
+    ssid_entered = g_strdup(gtk_entry_get_text(GTK_ENTRY(ssid_en)));
+
+    g_strstrip(key_entered);
+    g_strstrip(ssid_entered);
+
+    /* Check if key is correct */
+    new_type_string = g_string_new(type_entered);
+    new_key_string = g_string_new(key_entered);
+    new_ssid_string = g_string_new(ssid_entered);
+
+    g_free(type_entered);
+    g_free(key_entered );
+    g_free(ssid_entered);
+
+    /* Check which type of key the user has entered */
+    if (g_ascii_strcasecmp(new_type_string->str,AIRPCAP_WEP_KEY_STRING) == 0) /* WEP key */
+    {
+
+        if ( ((new_key_string->len) > WEP_KEY_MAX_CHAR_SIZE) || ((new_key_string->len) < WEP_KEY_MIN_CHAR_SIZE))
+        {
+            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);
+
+            g_string_free(new_type_string,TRUE);
+            g_string_free(new_key_string, TRUE);
+            g_string_free(new_ssid_string,TRUE);
+
+            return;
+        }
+
+        if ((new_key_string->len % 2) != 0)
+        {
+            simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"Invalid WEP key!\nThe number of characters must be even.");
+
+            g_string_free(new_type_string,TRUE);
+            g_string_free(new_key_string, TRUE);
+            g_string_free(new_ssid_string,TRUE);
+
+            return;
+        }
+
+        for (i = 0; i < new_key_string->len; i++)
+        {
+            if (!g_ascii_isxdigit(new_key_string->str[i]))
+            {
+                simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"Invalid WEP key!\nA WEP key must be an hexadecimal number.\nThe valid characters are: 0123456789ABCDEF.");
+
+                g_string_free(new_type_string,TRUE);
+                g_string_free(new_key_string, TRUE);
+                g_string_free(new_ssid_string,TRUE);
+
+                return;
+            }
+        }
+
+        /* If so... Modify key */
+        gtk_list_store_set(key_list_store, &iter,
+            KL_COL_TYPE, new_type_string->str,
+            KL_COL_KEY, new_key_string->str,
+            KL_COL_SSID, new_ssid_string->str,
+            -1);
+
+        if (airpcap_if_selected != NULL) airpcap_if_selected->saved = FALSE;
+    }
+    else if (g_ascii_strcasecmp(new_type_string->str,AIRPCAP_WPA_PWD_KEY_STRING) == 0) /* WPA Key */
+    {
+        /* XXX - Perform some WPA related input fields check */
+        /* If everything is ok, modify the entry in the list */
+
+        if ( ((new_key_string->len) > WPA_KEY_MAX_CHAR_SIZE) || ((new_key_string->len) < WPA_KEY_MIN_CHAR_SIZE))
+        {
+            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);
+
+            g_string_free(new_type_string,TRUE);
+            g_string_free(new_key_string, TRUE);
+            g_string_free(new_ssid_string,TRUE);
+
+            return;
+        }
+
+        /*
+         * XXX - Maybe we need some check on the characters? I'm not sure if only standard ASCII are ok...
+         */
+        if ((new_ssid_string->len) > WPA_SSID_MAX_CHAR_SIZE)
+        {
+            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);
+
+            g_string_free(new_type_string,TRUE);
+            g_string_free(new_key_string, TRUE);
+            g_string_free(new_ssid_string,TRUE);
+
+            return;
+        }
+
+        /* If so... Modify key */
+        gtk_list_store_set(key_list_store, &iter,
+            KL_COL_TYPE, new_type_string->str,
+            KL_COL_KEY, new_key_string->str,
+            KL_COL_SSID, new_ssid_string->str,
+            -1);
+
+        if (airpcap_if_selected != NULL) airpcap_if_selected->saved = FALSE;
+    }
+    else if (g_ascii_strcasecmp(new_type_string->str,AIRPCAP_WPA_BIN_KEY_STRING) == 0) /* WPA_BIN Key */
+    {
+        /* XXX - Perform some WPA_BIN related input fields check */
+        /* If everything is ok, modify the entry in the list */
+
+        if ( ((new_key_string->len) != WPA_PSK_KEY_CHAR_SIZE))
+        {
+            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);
+
+            g_string_free(new_type_string,TRUE);
+            g_string_free(new_key_string, TRUE);
+            g_string_free(new_ssid_string,TRUE);
+
+            return;
+        }
+
+        for (i = 0; i < new_key_string->len; i++)
+        {
+            if (!g_ascii_isxdigit(new_key_string->str[i]))
+            {
+                simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"Invalid WPA PSK/PMK key!\nKey must be an hexadecimal number.\nThe valid characters are: 0123456789ABCDEF.");
+
+                g_string_free(new_type_string,TRUE);
+                g_string_free(new_key_string, TRUE);
+                g_string_free(new_ssid_string,TRUE);
+
+                return;
+            }
+        }
+
+        /* If so... Modify key */
+        gtk_list_store_set(key_list_store, &iter,
+            KL_COL_TYPE, new_type_string->str,
+            KL_COL_KEY, new_key_string->str,
+            KL_COL_SSID, new_ssid_string->str,
+            -1);
+
+        if (airpcap_if_selected != NULL) airpcap_if_selected->saved = FALSE;
+    }
+    else /* Should never happen!!! */
+    {
+        simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"Unknown error in the key \"Type\" field!");
+    }
+
+    g_string_free(new_type_string,TRUE);
+    g_string_free(new_key_string, TRUE);
+    g_string_free(new_ssid_string,TRUE);
+
+    window_destroy(GTK_WIDGET(data));
+    return;
+}
+
+/*
+ * Add key window destroy callback
+ */
+static void
+on_add_key_w_destroy(GtkWidget *button _U_, gpointer data)
+{
+    GtkWidget *airpcap_advanced_w;
+
+    airpcap_advanced_w = GTK_WIDGET(data);
+
+    gtk_widget_set_sensitive(GTK_WIDGET(airpcap_advanced_w),TRUE);
+
+    return;
+}
+
+/*
+ * Callback for the 'Add Key' button.
+ */
+static void
+on_add_new_key_bt_clicked(GtkWidget *button _U_, gpointer data)
+{
+    GtkWidget *add_key_window;
+    GtkWidget *add_frame;
+    GtkWidget *main_v_box;
+    GtkWidget *add_tb;
+    GtkWidget *add_frame_al;
+    GtkWidget *add_type_cb;
+    GtkWidget *add_key_te;
+    GtkWidget *add_ssid_te;
+    GtkWidget *add_type_lb;
+    GtkWidget *add_key_lb;
+    GtkWidget *add_ssid_lb;
+    GtkWidget *low_h_button_box;
+    GtkWidget *ok_bt;
+    GtkWidget *cancel_bt;
+    GtkWidget *add_frame_lb;
+
+    GtkWidget *airpcap_advanced_w;
+
+    GtkListStore *key_list_store;
+
+    airpcap_advanced_w = GTK_WIDGET(data);
+
+    key_list_store = g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_ADVANCED_KEYLIST_KEY);
+
+    if (gtk_tree_model_iter_n_children(GTK_TREE_MODEL(key_list_store), NULL) >= MAX_ENCRYPTION_KEYS)
+    {
+        simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"Maximum number (%d) of decryption keys reached! You cannot add another key!\n",MAX_ENCRYPTION_KEYS);
+        return;
+    }
+
+    /* Gray out the Advanced Wireless Setting window */
+    gtk_widget_set_sensitive(airpcap_advanced_w,FALSE);
+
+    /* Pop-up a new window */
+    add_key_window = dlg_window_new ("Add Decryption Key");
+    gtk_widget_set_name (add_key_window, "add_key_window");
+    gtk_container_set_border_width (GTK_CONTAINER (add_key_window), 5);
+    gtk_window_set_resizable (GTK_WINDOW (add_key_window), FALSE);
+
+    main_v_box = gtk_vbox_new (FALSE, 0);
+    gtk_widget_set_name (main_v_box, "main_v_box");
+    gtk_widget_show (main_v_box);
+    gtk_container_add (GTK_CONTAINER (add_key_window), main_v_box);
+
+    add_frame = gtk_frame_new (NULL);
+    gtk_widget_set_name (add_frame, "add_frame");
+    gtk_widget_show (add_frame);
+    gtk_box_pack_start (GTK_BOX (main_v_box), add_frame, TRUE, TRUE, 0);
+
+    add_frame_al = gtk_alignment_new (0.5, 0.5, 1, 1);
+    gtk_widget_set_name (add_frame_al, "add_frame_al");
+    gtk_widget_show (add_frame_al);
+    gtk_container_add (GTK_CONTAINER (add_frame), add_frame_al);
+    gtk_alignment_set_padding (GTK_ALIGNMENT (add_frame_al), 0, 0, 12, 0);
+
+    add_tb = gtk_table_new (2, 3, FALSE);
+    gtk_widget_set_name (add_tb, "add_tb");
+    gtk_container_set_border_width(GTK_CONTAINER(add_tb),5);
+    gtk_widget_show (add_tb);
+    gtk_container_add (GTK_CONTAINER (add_frame_al), add_tb);
+
+    add_type_cb = gtk_combo_box_text_new();
+    gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT(add_type_cb), AIRPCAP_WEP_KEY_STRING);
+
+    gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT(add_type_cb), AIRPCAP_WPA_PWD_KEY_STRING);
+    gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT(add_type_cb), AIRPCAP_WPA_BIN_KEY_STRING);
+    gtk_combo_box_set_active(GTK_COMBO_BOX(add_type_cb), 0);
+    gtk_widget_set_name (add_type_cb, "add_type_cb");
+    gtk_widget_show (add_type_cb);
+    gtk_table_attach (GTK_TABLE (add_tb), add_type_cb, 0, 1, 1, 2,
+                      (GtkAttachOptions) (GTK_FILL),
+                      (GtkAttachOptions) (0), 0, 0);
+    gtk_widget_set_size_request (add_type_cb, 83, -1);
+
+    add_key_te = gtk_entry_new ();
+    gtk_widget_set_name (add_key_te, "add_key_te");
+
+    gtk_widget_show (add_key_te);
+    gtk_table_attach (GTK_TABLE (add_tb), add_key_te, 1, 2, 1, 2,
+                      (GtkAttachOptions) (0), (GtkAttachOptions) (0), 0, 0);
+    gtk_widget_set_size_request (add_key_te, 178, -1);
+
+    add_ssid_te = gtk_entry_new ();
+    gtk_widget_set_name (add_ssid_te, "add_ssid_te");
+    gtk_widget_set_sensitive(add_ssid_te,FALSE);
+    /* XXX - Decomment only when WPA and WPA_BIN will be ready */
+    gtk_widget_show (add_ssid_te);
+    gtk_table_attach (GTK_TABLE (add_tb), add_ssid_te, 2, 3, 1, 2,
+                      (GtkAttachOptions) (0), (GtkAttachOptions) (0), 0, 0);
+
+    add_type_lb = gtk_label_new ("Type");
+    gtk_widget_set_name (add_type_lb, "add_type_lb");
+    gtk_widget_show (add_type_lb);
+    gtk_table_attach (GTK_TABLE (add_tb), add_type_lb, 0, 1, 0, 1,
+                      (GtkAttachOptions) (GTK_FILL),
+                      (GtkAttachOptions) (0), 0, 0);
+    gtk_label_set_justify (GTK_LABEL (add_type_lb), GTK_JUSTIFY_CENTER);
+
+    add_key_lb = gtk_label_new ("Key");
+    gtk_widget_set_name (add_key_lb, "add_key_lb");
+    gtk_widget_show (add_key_lb);
+    gtk_table_attach (GTK_TABLE (add_tb), add_key_lb, 1, 2, 0, 1,
+                      (GtkAttachOptions) (GTK_FILL),
+                      (GtkAttachOptions) (0), 0, 0);
+    gtk_label_set_justify (GTK_LABEL (add_key_lb), GTK_JUSTIFY_CENTER);
+
+    add_ssid_lb = gtk_label_new ("");
+    gtk_widget_set_name (add_ssid_lb, "add_ssid_lb");
+    /* XXX - Decomment only when WPA and WPA_BIN will be ready */
+    gtk_widget_show (add_ssid_lb);
+    gtk_table_attach (GTK_TABLE (add_tb), add_ssid_lb, 2, 3, 0, 1,
+                      (GtkAttachOptions) (GTK_FILL),
+                      (GtkAttachOptions) (0), 0, 0);
+    gtk_label_set_justify (GTK_LABEL (add_ssid_lb), GTK_JUSTIFY_CENTER);
+
+    low_h_button_box = gtk_hbutton_box_new ();
+    gtk_widget_set_name (low_h_button_box, "low_h_button_box");
+    gtk_container_set_border_width (GTK_CONTAINER (low_h_button_box), 5);
+    gtk_widget_show (low_h_button_box);
+    gtk_box_pack_end (GTK_BOX (main_v_box), low_h_button_box, FALSE, FALSE, 0);
+    gtk_button_box_set_layout (GTK_BUTTON_BOX (low_h_button_box),
+                               GTK_BUTTONBOX_END);
+
+    ok_bt = gtk_button_new_with_mnemonic ("OK");
+    gtk_widget_set_name (ok_bt, "ok_bt");
+    gtk_widget_show (ok_bt);
+    gtk_container_add (GTK_CONTAINER (low_h_button_box), ok_bt);
+#if GTK_CHECK_VERSION(2,18,0)
+    gtk_widget_set_can_default (ok_bt, TRUE);
+#else
+    GTK_WIDGET_SET_FLAGS (ok_bt, GTK_CAN_DEFAULT);
+#endif
+
+    cancel_bt = gtk_button_new_with_mnemonic ("Cancel");
+    gtk_widget_set_name (cancel_bt, "cancel_bt");
+    gtk_widget_show (cancel_bt);
+    gtk_container_add (GTK_CONTAINER (low_h_button_box), cancel_bt);
+#if GTK_CHECK_VERSION(2,18,0)
+    gtk_widget_set_can_default (cancel_bt, TRUE);
+#else
+    GTK_WIDGET_SET_FLAGS (cancel_bt, GTK_CAN_DEFAULT);
+#endif
+
+    add_frame_lb = gtk_label_new ("<b>Modify Selected Key</b>");
+    gtk_widget_set_name (add_frame_lb, "add_frame_lb");
+    gtk_widget_show (add_frame_lb);
+    gtk_frame_set_label_widget (GTK_FRAME (add_frame), add_frame_lb);
+    gtk_label_set_use_markup (GTK_LABEL (add_frame_lb), TRUE);
+
+    /* Add callbacks */
+    g_signal_connect(ok_bt, "clicked", G_CALLBACK(on_add_key_ok_bt_clicked), add_key_window );
+    g_signal_connect(cancel_bt, "clicked", G_CALLBACK(window_cancel_button_cb), add_key_window );
+    g_signal_connect(add_type_cb, "changed", G_CALLBACK(on_add_type_cb_changed), add_key_window);
+    g_signal_connect(add_key_window, "delete_event", G_CALLBACK(window_delete_event_cb), NULL);
+    g_signal_connect(add_key_window, "destroy", G_CALLBACK(on_add_key_w_destroy), data);
+
+    /* Add widget data */
+    g_object_set_data(G_OBJECT(add_key_window),AIRPCAP_ADVANCED_ADD_KEY_LIST_KEY,key_list_store);
+    g_object_set_data(G_OBJECT(add_key_window),AIRPCAP_ADVANCED_ADD_KEY_TYPE_KEY,add_type_cb);
+    g_object_set_data(G_OBJECT(add_key_window),AIRPCAP_ADVANCED_ADD_KEY_KEY_KEY,add_key_te);
+    g_object_set_data(G_OBJECT(add_key_window),AIRPCAP_ADVANCED_ADD_KEY_SSID_KEY,add_ssid_te);
+    g_object_set_data(G_OBJECT(add_key_window),AIRPCAP_ADVANCED_ADD_KEY_KEY_LABEL_KEY,add_key_lb);
+    g_object_set_data(G_OBJECT(add_key_window),AIRPCAP_ADVANCED_ADD_KEY_SSID_LABEL_KEY,add_ssid_lb);
+
+    gtk_widget_show(add_key_window);
+}
+
+/*
+ * Edit key window destroy callback
+ */
+static void
+on_edit_key_w_destroy(GtkWidget *button _U_, gpointer data)
+{
+    GtkWidget *airpcap_advanced_w;
+
+    airpcap_advanced_w = GTK_WIDGET(data);
+
+    gtk_widget_set_sensitive(GTK_WIDGET(airpcap_advanced_w),TRUE);
+
+    return;
+}
+
+/*
+ * Callback for the 'Remove Key' button.
+ */
+static void
+on_remove_key_bt_clicked(GtkWidget *button _U_, gpointer data)
+{
+    GtkTreeModel *model;
+    GtkTreeIter iter;
+    GtkTreeSelection *selection;
+
+    /* retrieve needed stuff */
+    selection = g_object_get_data(G_OBJECT(data), AIRPCAP_ADVANCED_EDIT_KEY_SELECTION_KEY);
+
+    if (!gtk_tree_selection_get_selected(selection, &model, &iter))
+      return;
+
+    /* Remove selected key */
+    gtk_list_store_remove(GTK_LIST_STORE(model), &iter);
+    gtk_tree_selection_select_iter(selection, &iter);
+    /* XXX - select the last item if needed? */
+
+    /* Need to save config... */
+    if (airpcap_if_selected != NULL) airpcap_if_selected->saved = FALSE;
+}
+
+/*
+ * Callback for the 'Edit Key' button.
+ */
+static void
+on_edit_key_bt_clicked(GtkWidget *button _U_, gpointer data)
+{
+    GtkWidget *edit_key_window;
+    GtkWidget *edit_frame;
+    GtkWidget *main_v_box;
+    GtkWidget *edit_tb;
+    GtkWidget *edit_frame_al;
+    GtkWidget *edit_type_cb;
+    GtkWidget *edit_key_te;
+    GtkWidget *edit_ssid_te;
+    GtkWidget *edit_type_lb;
+    GtkWidget *edit_key_lb;
+    GtkWidget *edit_ssid_lb;
+    GtkWidget *low_h_button_box;
+    GtkWidget *ok_bt;
+    GtkWidget *cancel_bt;
+    GtkWidget *edit_frame_lb;
+
+    GtkWidget *airpcap_advanced_w;
+
+    GtkTreeModel *model;
+    GtkTreeIter iter;
+    GtkTreeSelection *selection;
+
+    /* Key List Store */
+    GtkListStore *key_list_store;
+
+    gchar *row_type,
+          *row_key,
+          *row_ssid = "";
+
+    airpcap_advanced_w = GTK_WIDGET(data);
+
+    /* Retrieve the selected item... if no row is selected, this is null... */
+    selection = g_object_get_data(G_OBJECT(data), AIRPCAP_ADVANCED_EDIT_KEY_SELECTION_KEY);
+    key_list_store = g_object_get_data (G_OBJECT(data), AIRPCAP_ADVANCED_KEYLIST_KEY);
+
+
+    if (!gtk_tree_selection_get_selected(selection, &model, &iter))
+      return;
+
+    gtk_tree_model_get(model, &iter,
+                       KL_COL_TYPE, &row_type,
+                       KL_COL_KEY, &row_key,
+                       KL_COL_SSID, &row_ssid,
+                       -1);
+
+    /* Gray out the Advanced Wireless Setting window */
+    gtk_widget_set_sensitive(airpcap_advanced_w,FALSE);
+
+    /* Pop-up a new window */
+    edit_key_window = dlg_window_new("Edit Decryption Key");
+    gtk_widget_set_name (edit_key_window, "edit_key_window");
+    gtk_container_set_border_width (GTK_CONTAINER (edit_key_window), 5);
+    gtk_window_set_resizable (GTK_WINDOW (edit_key_window), FALSE);
+
+    main_v_box = gtk_vbox_new (FALSE, 0);
+    gtk_widget_set_name (main_v_box, "main_v_box");
+    gtk_widget_show (main_v_box);
+    gtk_container_add (GTK_CONTAINER (edit_key_window), main_v_box);
+
+    edit_frame = gtk_frame_new (NULL);
+    gtk_widget_set_name (edit_frame, "edit_frame");
+    gtk_widget_show (edit_frame);
+    gtk_box_pack_start (GTK_BOX (main_v_box), edit_frame, TRUE, TRUE, 0);
+
+    edit_frame_al = gtk_alignment_new (0.5, 0.5, 1, 1);
+    gtk_widget_set_name (edit_frame_al, "edit_frame_al");
+    gtk_widget_show (edit_frame_al);
+    gtk_container_add (GTK_CONTAINER (edit_frame), edit_frame_al);
+    gtk_alignment_set_padding (GTK_ALIGNMENT (edit_frame_al), 0, 0, 12, 0);
+
+    edit_tb = gtk_table_new (2, 3, FALSE);
+    gtk_widget_set_name (edit_tb, "edit_tb");
+    gtk_container_set_border_width(GTK_CONTAINER(edit_tb),5);
+    gtk_widget_show (edit_tb);
+    gtk_container_add (GTK_CONTAINER (edit_frame_al), edit_tb);
+
+    edit_type_cb = gtk_combo_box_text_new();
+    gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT(edit_type_cb), AIRPCAP_WEP_KEY_STRING);
+
+    gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT(edit_type_cb), AIRPCAP_WPA_PWD_KEY_STRING);
+    gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT(edit_type_cb), AIRPCAP_WPA_BIN_KEY_STRING);
+    /* Set current type */
+    gtk_combo_box_set_active(GTK_COMBO_BOX(edit_type_cb), 0);
+    if (g_ascii_strcasecmp(row_type, AIRPCAP_WPA_PWD_KEY_STRING) == 0) {
+        gtk_combo_box_set_active(GTK_COMBO_BOX(edit_type_cb), 1);
+    } else if (g_ascii_strcasecmp(row_type, AIRPCAP_WPA_BIN_KEY_STRING) == 0) {
+        gtk_combo_box_set_active(GTK_COMBO_BOX(edit_type_cb), 2);
+    }
+    gtk_widget_set_name (edit_type_cb, "edit_type_cb");
+    gtk_widget_show (edit_type_cb);
+    gtk_table_attach (GTK_TABLE (edit_tb), edit_type_cb, 0, 1, 1, 2,
+                      (GtkAttachOptions) (GTK_FILL),
+                      (GtkAttachOptions) (0), 0, 0);
+    gtk_widget_set_size_request (edit_type_cb, 83, -1);
+
+    edit_key_te = gtk_entry_new ();
+    gtk_widget_set_name (edit_key_te, "edit_key_te");
+    /* Set current key */
+    gtk_entry_set_text(GTK_ENTRY(edit_key_te),row_key);
+    gtk_widget_show (edit_key_te);
+    gtk_table_attach (GTK_TABLE (edit_tb), edit_key_te, 1, 2, 1, 2,
+                      (GtkAttachOptions) (0), (GtkAttachOptions) (0), 0, 0);
+    gtk_widget_set_size_request (edit_key_te, 178, -1);
+
+    edit_ssid_te = gtk_entry_new ();
+    gtk_widget_set_name (edit_ssid_te, "edit_ssid_te");
+
+    /* Set current ssid (if key type is not WEP!)*/
+    if (g_ascii_strcasecmp(row_type,AIRPCAP_WEP_KEY_STRING) == 0)
+    {
+        gtk_widget_set_sensitive(edit_ssid_te,FALSE);
+    }
+    else
+    {
+        gtk_widget_set_sensitive(edit_ssid_te,TRUE);
+        gtk_entry_set_text(GTK_ENTRY(edit_ssid_te),row_ssid);
+    }
+
+    /* XXX - Decomment only when WPA and WPA@ will be ready */
+    gtk_widget_show (edit_ssid_te);
+    gtk_table_attach (GTK_TABLE (edit_tb), edit_ssid_te, 2, 3, 1, 2,
+                      (GtkAttachOptions) (0), (GtkAttachOptions) (0), 0, 0);
+
+    edit_type_lb = gtk_label_new ("Type");
+    gtk_widget_set_name (edit_type_lb, "edit_type_lb");
+    gtk_widget_show (edit_type_lb);
+    gtk_table_attach (GTK_TABLE (edit_tb), edit_type_lb, 0, 1, 0, 1,
+                      (GtkAttachOptions) (GTK_FILL),
+                      (GtkAttachOptions) (0), 0, 0);
+    gtk_label_set_justify (GTK_LABEL (edit_type_lb), GTK_JUSTIFY_CENTER);
+
+    edit_key_lb = gtk_label_new ("Key");
+    gtk_widget_set_name (edit_key_lb, "edit_key_lb");
+    gtk_widget_show (edit_key_lb);
+    gtk_table_attach (GTK_TABLE (edit_tb), edit_key_lb, 1, 2, 0, 1,
+                      (GtkAttachOptions) (GTK_FILL),
+                      (GtkAttachOptions) (0), 0, 0);
+    gtk_label_set_justify (GTK_LABEL (edit_key_lb), GTK_JUSTIFY_CENTER);
+
+    edit_ssid_lb = gtk_label_new ("");
+    gtk_widget_set_name (edit_ssid_lb, "edit_ssid_lb");
+    /* XXX - Decomment only when WPA and WPA_BIN will be ready */
+    gtk_widget_show (edit_ssid_lb);
+    gtk_table_attach (GTK_TABLE (edit_tb), edit_ssid_lb, 2, 3, 0, 1,
+                      (GtkAttachOptions) (GTK_FILL),
+                      (GtkAttachOptions) (0), 0, 0);
+    gtk_label_set_justify (GTK_LABEL (edit_ssid_lb), GTK_JUSTIFY_CENTER);
+
+    low_h_button_box = gtk_hbutton_box_new ();
+    gtk_widget_set_name (low_h_button_box, "low_h_button_box");
+    gtk_container_set_border_width (GTK_CONTAINER (low_h_button_box), 5);
+    gtk_widget_show (low_h_button_box);
+    gtk_box_pack_end (GTK_BOX (main_v_box), low_h_button_box, FALSE, FALSE, 0);
+    gtk_button_box_set_layout (GTK_BUTTON_BOX (low_h_button_box),
+                               GTK_BUTTONBOX_END);
+
+    ok_bt = gtk_button_new_with_mnemonic ("OK");
+    gtk_widget_set_name (ok_bt, "ok_bt");
+    gtk_widget_show (ok_bt);
+    gtk_container_add (GTK_CONTAINER (low_h_button_box), ok_bt);
+#if GTK_CHECK_VERSION(2,18,0)
+    gtk_widget_set_can_default (ok_bt, TRUE);
+#else
+    GTK_WIDGET_SET_FLAGS (ok_bt, GTK_CAN_DEFAULT);
+#endif
+
+    cancel_bt = gtk_button_new_with_mnemonic ("Cancel");
+    gtk_widget_set_name (cancel_bt, "cancel_bt");
+    gtk_widget_show (cancel_bt);
+    gtk_container_add (GTK_CONTAINER (low_h_button_box), cancel_bt);
+#if GTK_CHECK_VERSION(2,18,0)
+    gtk_widget_set_can_default (cancel_bt, TRUE);
+#else
+    GTK_WIDGET_SET_FLAGS (cancel_bt, GTK_CAN_DEFAULT);
+#endif
+
+    edit_frame_lb = gtk_label_new ("<b>Modify Selected Key</b>");
+    gtk_widget_set_name (edit_frame_lb, "edit_frame_lb");
+    gtk_widget_show (edit_frame_lb);
+    gtk_frame_set_label_widget (GTK_FRAME (edit_frame), edit_frame_lb);
+    gtk_label_set_use_markup (GTK_LABEL (edit_frame_lb), TRUE);
+
+    /* Add callbacks */
+    g_signal_connect(ok_bt, "clicked", G_CALLBACK(on_edit_key_ok_bt_clicked), edit_key_window );
+    g_signal_connect(cancel_bt, "clicked", G_CALLBACK(window_cancel_button_cb), edit_key_window );
+    g_signal_connect(edit_type_cb, "changed", G_CALLBACK(on_edit_type_cb_changed), edit_key_window);
+    g_signal_connect(edit_key_window, "delete_event", G_CALLBACK(window_delete_event_cb), NULL);
+    g_signal_connect(edit_key_window, "destroy", G_CALLBACK(on_edit_key_w_destroy), data);
+
+    /* Add widget data */
+    g_object_set_data(G_OBJECT(edit_key_window),AIRPCAP_ADVANCED_EDIT_KEY_LIST_KEY,key_list_store);
+    g_object_set_data(G_OBJECT(edit_key_window),AIRPCAP_ADVANCED_EDIT_KEY_SELECTION_KEY,selection);
+    g_object_set_data(G_OBJECT(edit_key_window),AIRPCAP_ADVANCED_EDIT_KEY_TYPE_KEY,edit_type_cb);
+    g_object_set_data(G_OBJECT(edit_key_window),AIRPCAP_ADVANCED_EDIT_KEY_KEY_KEY,edit_key_te);
+    g_object_set_data(G_OBJECT(edit_key_window),AIRPCAP_ADVANCED_EDIT_KEY_SSID_KEY,edit_ssid_te);
+    g_object_set_data(G_OBJECT(edit_key_window),AIRPCAP_ADVANCED_EDIT_KEY_KEY_LABEL_KEY,edit_key_lb);
+    g_object_set_data(G_OBJECT(edit_key_window),AIRPCAP_ADVANCED_EDIT_KEY_SSID_LABEL_KEY,edit_ssid_lb);
+
+
+    g_free(row_type);
+    g_free(row_key);
+    g_free(row_ssid);
+    gtk_widget_show(edit_key_window);
+}
+
+/*
+ * Callback for the 'Move Key Up' button.
+ */
+static void
+on_move_key_up_bt_clicked(GtkWidget *button _U_, gpointer key_list)
+{
+    tree_view_list_store_move_selection(GTK_TREE_VIEW(key_list), TRUE);
+}
+
+/*
+ * Callback for the 'Move Key Down' button.
+ */
+static void
+on_move_key_down_bt_clicked(GtkWidget *button _U_, gpointer list_view)
+{
+    tree_view_list_store_move_selection(GTK_TREE_VIEW(list_view), FALSE);
+}
+
+/* Turns the decryption on or off */
+void
+on_decryption_mode_cb_changed(GtkWidget *cb, gpointer data _U_)
+{
+    gint cur_active;
+
+    if (cb == NULL) {
+        return;
+    }
+
+    cur_active = gtk_combo_box_get_active(GTK_COMBO_BOX(cb));
+
+    if (cur_active < 0) {
+        return;
+    }
+
+    switch(cur_active) {
+        /* XXX - Don't use magic numbers here */
+        case 1: /* Wireshark */
+            set_wireshark_decryption(TRUE);
+            if (!set_airpcap_decryption(FALSE)) g_warning(CANT_SAVE_ERR_STR);
+            break;
+        case 2: /* Driver */
+            set_wireshark_decryption(FALSE);
+            if (!set_airpcap_decryption(TRUE)) g_warning(CANT_SAVE_ERR_STR);
+            break;
+        default:
+            set_wireshark_decryption(FALSE);
+            if (!set_airpcap_decryption(FALSE)) g_warning(CANT_SAVE_ERR_STR);
+            break;
+    }
+
+    /* Redissect all the packets, and re-evaluate the display filter. */
+    redissect_packets();
+}
+
+/*
+ * Selects the current decryption mode string in the decryption mode combo box
+ */
+void
+update_decryption_mode(GtkWidget *cb)
+{
+    if (cb == NULL) {
+        return;
+    }
+
+    /* Wireshark decryption is on */
+    if (wireshark_decryption_on())
+    {
+        gtk_combo_box_set_active(GTK_COMBO_BOX(cb), 1);
+    }
+    /* AirPcap decryption is on */
+    else if (airpcap_decryption_on())
+    {
+        gtk_combo_box_set_active(GTK_COMBO_BOX(cb), 2);
+    }
+    /* No decryption enabled */
+    else
+    {
+        gtk_combo_box_set_active(GTK_COMBO_BOX(cb), 0);
+    }
+
+    return;
+}
+
+/*
+ * Creates the list of available decryption modes, depending on the adapters found
+ */
+void
+update_decryption_mode_list(GtkWidget *cb)
+{
+    gchar *current_text;
+
+    if (cb == NULL)
+        return;
+
+    current_text = NULL;
+
+    /*
+     * XXX - Retrieve the current 'decryption mode'. It would be better just block the
+     * signal handler, but it doesn't work... one of these days I'll try to figure out why...
+     */
+    current_text = gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT(cb));
+
+    while (gtk_tree_model_iter_n_children(gtk_combo_box_get_model(GTK_COMBO_BOX(cb)), NULL) > 0) {
+        gtk_combo_box_text_remove(GTK_COMBO_BOX_TEXT(cb), 0);
+    }
+
+    gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT(cb), AIRPCAP_DECRYPTION_TYPE_STRING_NONE);
+    gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT(cb), AIRPCAP_DECRYPTION_TYPE_STRING_WIRESHARK);
+
+    if (airpcap_if_list != NULL && g_list_length(airpcap_if_list) > 0)
+    {
+        gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT(cb), AIRPCAP_DECRYPTION_TYPE_STRING_AIRPCAP);
+    }
+    else
+    {
+        /* The last decryption mode was 'Driver', but no more AirPcap adapter are found */
+        if (current_text == NULL || g_ascii_strcasecmp(current_text, AIRPCAP_DECRYPTION_TYPE_STRING_AIRPCAP) == 0)
+        {
+            g_free(current_text);
+            current_text = g_strdup(AIRPCAP_DECRYPTION_TYPE_STRING_NONE);
+        }
+    }
+
+    if (g_ascii_strcasecmp(current_text, AIRPCAP_DECRYPTION_TYPE_STRING_WIRESHARK) == 0) {
+        gtk_combo_box_set_active(GTK_COMBO_BOX(cb), 1);
+    } else if (g_ascii_strcasecmp(current_text, AIRPCAP_DECRYPTION_TYPE_STRING_AIRPCAP) == 0) {
+        gtk_combo_box_set_active(GTK_COMBO_BOX(cb), 2);
+    } else { /* None / Invalid */
+        gtk_combo_box_set_active(GTK_COMBO_BOX(cb), 0);
+    }
+
+    g_free(current_text);
+}
+
+
+/*
+ * Callback for the Wireless Advanced Settings 'Apply' button.
+ */
+static void
+on_advanced_apply_bt_clicked(GtkWidget *button _U_, gpointer data)
+{
+    /* advenced window */
+    GtkWidget    *airpcap_advanced_w;
+    GtkWidget    *channel_cb, *channel_offset_cb;
+
+    /* widgets in the toolbar */
+    GtkWidget    *toolbar,
+                 *toolbar_if_lb,
+                 *toolbar_channel_cb,
+                 *toolbar_channel_offset_cb,
+                 *toolbar_fcs_filter_cb;
+
+    /* retrieve main window */
+    airpcap_advanced_w = GTK_WIDGET(data);
+
+    /* Set the channel and offset */
+    channel_cb = GTK_WIDGET(g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_ADVANCED_CHANNEL_KEY));
+    channel_offset_cb = GTK_WIDGET(g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_ADVANCED_CHANNEL_OFFSET_KEY));
+    airpcap_channel_offset_changed_cb(channel_offset_cb, NULL);
+    airpcap_channel_changed_set_cb(channel_cb, channel_offset_cb);
+
+
+    toolbar = GTK_WIDGET(g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_TOOLBAR_KEY));
+
+    /* retrieve toolbar info */
+    toolbar_if_lb = GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_INTERFACE_KEY));
+    toolbar_channel_cb = GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_CHANNEL_KEY));
+    toolbar_channel_offset_cb = GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_CHANNEL_OFFSET_KEY));
+    toolbar_fcs_filter_cb = GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_FCS_FILTER_KEY));
+
+    /* Save the configuration (for all ) */
+    airpcap_save_selected_if_configuration(airpcap_if_selected);
+
+    /* Update toolbar (only if airpcap_if_selected is airpcap_if_active)*/
+    if ( g_ascii_strcasecmp(airpcap_if_selected->description,airpcap_if_active->description) == 0)
+    {
+        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)));
+        airpcap_update_channel_combo(GTK_WIDGET(toolbar_channel_cb),airpcap_if_selected);
+        airpcap_update_channel_offset_combo(airpcap_if_selected, airpcap_if_selected->channelInfo.Frequency, toolbar_channel_offset_cb, TRUE);
+        airpcap_validation_type_combo_set_by_type(toolbar_fcs_filter_cb,airpcap_if_selected->CrcValidationOn);
+    }
+}
+
+/*
+ * Callback for the OK button 'clicked' in the Advanced Wireless Settings window.
+ */
+static void
+on_advanced_ok_bt_clicked(GtkWidget *button _U_, gpointer data)
+{
+    PAirpcapHandle ad = NULL;
+    gchar ebuf[AIRPCAP_ERRBUF_SIZE];
+
+    /* Retrieve object data */
+    GtkWidget *airpcap_advanced_w = GTK_WIDGET(data);
+
+    if (airpcap_if_selected == NULL) { /* There's not much we can do. */
+        gtk_widget_destroy(airpcap_advanced_w);
+        return;
+    }
+
+    on_advanced_apply_bt_clicked(button, data);
+
+    /* Stop blinking our LED */
+    ad = airpcap_if_open(airpcap_if_selected->name, ebuf);
+    if (ad)
+    {
+        g_source_remove(airpcap_if_selected->tag);
+        airpcap_if_turn_led_on(ad, 0);
+        airpcap_if_selected->blinking = FALSE;
+        airpcap_if_selected->led = TRUE;
+        airpcap_if_close(ad);
+    }
+
+    /* Remove GLIB timeout */
+    g_source_remove(airpcap_if_selected->tag);
+
+    gtk_widget_destroy(airpcap_advanced_w);
+}
+
+/*
+ * Callback for the CANCEL button 'clicked' in the Advanced Wireless Settings window.
+ */
+static void
+on_advanced_cancel_bt_clicked(GtkWidget *button _U_, gpointer data)
+{
+    PAirpcapHandle ad = NULL;
+    gchar ebuf[AIRPCAP_ERRBUF_SIZE];
+
+    /* Retrieve object data */
+    GtkWidget *airpcap_advanced_w;
+    GtkWidget *channel_combo;
+    GtkWidget *capture_combo;
+    GtkWidget *crc_check;
+    GtkWidget *wrong_crc_combo;
+    GtkWidget *blink_bt;
+    GtkWidget *interface_combo;
+    GtkWidget *cancel_bt;
+    GtkWidget *ok_bt;
+
+    /* widgets in the toolbar */
+    GtkWidget *toolbar,
+              *toolbar_if_lb,
+              *toolbar_channel_cb,
+              *toolbar_wrong_crc_cb,
+              *advanced_bt;
+
+    /* Retrieve the GUI object pointers */
+    airpcap_advanced_w  = GTK_WIDGET(data);
+    interface_combo     = GTK_WIDGET(g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_ADVANCED_INTERFACE_KEY));
+    channel_combo       = GTK_WIDGET(g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_ADVANCED_CHANNEL_KEY));
+    capture_combo       = GTK_WIDGET(g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_ADVANCED_LINK_TYPE_KEY));
+    crc_check           = GTK_WIDGET(g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_ADVANCED_FCS_CHECK_KEY));
+    wrong_crc_combo     = GTK_WIDGET(g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_ADVANCED_FCS_FILTER_KEY));
+    blink_bt            = GTK_WIDGET(g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_ADVANCED_BLINK_KEY));
+    cancel_bt           = GTK_WIDGET(g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_ADVANCED_CANCEL_KEY));
+    ok_bt               = GTK_WIDGET(g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_ADVANCED_OK_KEY));
+    advanced_bt         = GTK_WIDGET(g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_ADVANCED_KEY));
+
+    toolbar = GTK_WIDGET(g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_TOOLBAR_KEY));
+
+    /* retrieve toolbar info */
+    toolbar_if_lb           = GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_INTERFACE_KEY));
+    toolbar_channel_cb      = GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_CHANNEL_KEY));
+    toolbar_wrong_crc_cb    = GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_FCS_FILTER_KEY));
+
+    /* Stop blinking ALL leds (go through the airpcap_if_list) */
+    if (airpcap_if_selected != NULL)
+    {
+        ad = airpcap_if_open(airpcap_if_selected->name, ebuf);
+        if (ad)
+        {
+            g_source_remove(airpcap_if_selected->tag);
+            airpcap_if_turn_led_on(ad, 0);
+            airpcap_if_selected->blinking = FALSE;
+            airpcap_if_selected->led = TRUE;
+            airpcap_if_close(ad);
+        }
+    }
+
+    /* reload the configuration!!! Configuration has not been saved but
+        the corresponding structure has been modified probably...*/
+    if (!airpcap_if_selected->saved)
+    {
+        airpcap_load_selected_if_configuration(airpcap_if_selected);
+    }
+
+    gtk_widget_destroy(airpcap_advanced_w);
+}
+
+
+/* Called to create the airpcap settings' window */
+void
+display_airpcap_advanced_cb(GtkWidget *w _U_, gpointer data)
+{
+    GtkWidget *airpcap_advanced_w;
+    GtkWidget *main_box;
+    GtkWidget *settings_sub_box;
+    GtkWidget *interface_fr;
+    GtkWidget *interface_al;
+    GtkWidget *interface_sub_h_box;
+    GtkWidget *interface_name_lb;
+    GtkWidget *blink_bt;
+    GtkWidget *interface_frame_lb;
+    GtkWidget *basic_parameters_fr;
+    GtkWidget *basic_parameters_al;
+    GtkWidget *basic_parameters_tb;
+    GtkWidget *channel_lb;
+    GtkWidget *channel_offset_lb;
+    GtkWidget *capture_type_lb;
+    GtkWidget *channel_cb;
+    GtkWidget *channel_offset_cb;
+    GtkWidget *capture_type_cb;
+    GtkWidget *fcs_ck;
+    GtkWidget *basic_parameters_fcs_h_box;
+    GtkWidget *basic_parameters_fcs_filter_lb;
+    GtkWidget *fcs_filter_cb;
+    GtkWidget *basic_parameters_frame_lb;
+    GtkWidget *low_buttons_h_box;
+    GtkWidget *left_h_button_box;
+    GtkWidget *right_h_button_box;
+    GtkWidget *ok_bt;
+    GtkWidget *apply_bt;
+    GtkWidget *cancel_bt;
+
+    /* widgets in the toolbar */
+    GtkWidget *toolbar,
+              *toolbar_if_lb,
+              *toolbar_channel_cb,
+              *toolbar_wrong_crc_cb;
+
+    /* user data - RETRIEVE pointers of toolbar widgets */
+    toolbar              = GTK_WIDGET(data);
+    toolbar_if_lb        = GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_INTERFACE_KEY));
+    toolbar_channel_cb   = GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_CHANNEL_KEY));
+    toolbar_wrong_crc_cb = GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_FCS_FILTER_KEY));
+
+    /* gray out the toolbar */
+    gtk_widget_set_sensitive(toolbar,FALSE);
+
+    /* main window */
+    /* global */
+
+    /* the selected is the active, for now */
+    airpcap_if_selected = airpcap_if_active;
+
+    /* Create the new window */
+    airpcap_advanced_w = dlg_window_new("Advanced Wireless Settings");  /* transient_for top_level */
+    gtk_window_set_destroy_with_parent (GTK_WINDOW(airpcap_advanced_w), TRUE);
+
+    gtk_container_set_border_width (GTK_CONTAINER (airpcap_advanced_w), 5);
+    gtk_window_set_position (GTK_WINDOW (airpcap_advanced_w),
+                             GTK_WIN_POS_CENTER);
+
+    gtk_window_set_resizable (GTK_WINDOW (airpcap_advanced_w), FALSE);
+    gtk_window_set_type_hint (GTK_WINDOW (airpcap_advanced_w), GDK_WINDOW_TYPE_HINT_DIALOG);
+
+    main_box = gtk_vbox_new (FALSE, 0);
+    gtk_widget_set_name (main_box, "main_box");
+    gtk_widget_show (main_box);
+    gtk_container_add (GTK_CONTAINER (airpcap_advanced_w), main_box);
+
+    settings_sub_box = gtk_vbox_new (FALSE, 0);
+    gtk_widget_set_name (settings_sub_box, "settings_sub_box");
+    gtk_widget_show (settings_sub_box);
+    gtk_box_pack_start (GTK_BOX (main_box), settings_sub_box, FALSE, TRUE, 0);
+
+    interface_fr = gtk_frame_new (NULL);
+    gtk_widget_set_name (interface_fr, "interface_fr");
+    gtk_widget_show (interface_fr);
+    gtk_box_pack_start (GTK_BOX (settings_sub_box), interface_fr, FALSE, FALSE,
+                        0);
+    gtk_container_set_border_width (GTK_CONTAINER (interface_fr), 10);
+
+    interface_al = gtk_alignment_new (0.5, 0.5, 1, 1);
+    gtk_widget_set_name (interface_al, "interface_al");
+    gtk_widget_show (interface_al);
+    gtk_container_add (GTK_CONTAINER (interface_fr), interface_al);
+    gtk_alignment_set_padding (GTK_ALIGNMENT (interface_al), 5, 5, 0, 0);
+
+    interface_sub_h_box = gtk_hbox_new (FALSE, 0);
+    gtk_widget_set_name (interface_sub_h_box, "interface_sub_h_box");
+    gtk_widget_show (interface_sub_h_box);
+    gtk_container_add (GTK_CONTAINER (interface_al), interface_sub_h_box);
+    gtk_container_set_border_width (GTK_CONTAINER (interface_sub_h_box), 5);
+
+    /* Fill the interface_box */
+    if (airpcap_if_active != NULL)
+    {
+        interface_name_lb = gtk_label_new(airpcap_if_active->description);
+    }
+    else
+    {
+        interface_name_lb = gtk_label_new("No airpcap interface found!");
+        gtk_widget_set_sensitive(main_box,FALSE);
+    }
+
+    gtk_widget_set_name (interface_name_lb, "interface_name_lb");
+    gtk_widget_show (interface_name_lb);
+    gtk_box_pack_start (GTK_BOX (interface_sub_h_box), interface_name_lb, TRUE,
+                        FALSE, 0);
+
+    /* If it is NOT the 'Any' Interface */
+    if (!airpcap_if_is_any(airpcap_if_selected))
+    {
+        blink_bt = gtk_button_new_with_mnemonic ("Blink Led");
+    }
+    else /* It is the any interface, so it doesn't make sense to have 'Blink' button... */
+    {
+        blink_bt = gtk_button_new_with_mnemonic ("What's This?");
+    }
+    gtk_widget_set_name (blink_bt, "blink_bt");
+    gtk_widget_show (blink_bt);
+    gtk_box_pack_end (GTK_BOX (interface_sub_h_box), blink_bt, FALSE, FALSE, 0);
+
+    interface_frame_lb = gtk_label_new ("<b>Interface</b>");
+    gtk_widget_set_name (interface_frame_lb, "interface_frame_lb");
+    gtk_widget_show (interface_frame_lb);
+    gtk_frame_set_label_widget (GTK_FRAME (interface_fr), interface_frame_lb);
+    gtk_label_set_use_markup (GTK_LABEL (interface_frame_lb), TRUE);
+
+    basic_parameters_fr = gtk_frame_new (NULL);
+    gtk_widget_set_name (basic_parameters_fr, "basic_parameters_fr");
+    gtk_widget_show (basic_parameters_fr);
+    gtk_box_pack_start (GTK_BOX (settings_sub_box), basic_parameters_fr, TRUE,FALSE, 0);
+    gtk_container_set_border_width (GTK_CONTAINER (basic_parameters_fr), 10);
+
+    basic_parameters_al = gtk_alignment_new (0.5, 0.5, 1, 1);
+    gtk_widget_set_name (basic_parameters_al, "basic_parameters_al");
+    gtk_widget_show (basic_parameters_al);
+    gtk_container_add (GTK_CONTAINER (basic_parameters_fr),basic_parameters_al);
+    gtk_alignment_set_padding (GTK_ALIGNMENT (basic_parameters_al), 10, 10, 0, 0);
+
+    basic_parameters_tb = gtk_table_new (2, 3, FALSE);
+    gtk_widget_set_name (basic_parameters_tb, "basic_parameters_tb");
+    gtk_widget_show (basic_parameters_tb);
+    gtk_container_add (GTK_CONTAINER (basic_parameters_al),
+                       basic_parameters_tb);
+    gtk_container_set_border_width (GTK_CONTAINER (basic_parameters_tb), 5);
+    gtk_table_set_col_spacings (GTK_TABLE (basic_parameters_tb), 20);
+
+    channel_lb = gtk_label_new ("Channel:");
+    gtk_widget_set_name (channel_lb, "channel_lb");
+    gtk_widget_show (channel_lb);
+    gtk_table_attach (GTK_TABLE (basic_parameters_tb), channel_lb, 0, 1, 0, 1,
+                      (GtkAttachOptions) (GTK_FILL),
+                      (GtkAttachOptions) (0), 0, 0);
+    gtk_misc_set_alignment (GTK_MISC (channel_lb), 0, 0.5);
+
+    capture_type_lb = gtk_label_new ("Capture Type:");
+    gtk_widget_set_name (capture_type_lb, "capture_type_lb");
+    gtk_widget_show (capture_type_lb);
+    gtk_table_attach (GTK_TABLE (basic_parameters_tb), capture_type_lb, 0, 1, 2,
+                      3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0),
+                      0, 0);
+    gtk_misc_set_alignment (GTK_MISC (capture_type_lb), 0, 0.5);
+
+    /* Start: Channel offset label */
+    channel_offset_lb = gtk_label_new ("Channel Offset:");
+    gtk_widget_set_name (channel_offset_lb, "channel_offset_lb");
+    gtk_widget_show (channel_offset_lb);
+    gtk_table_attach (GTK_TABLE (basic_parameters_tb), channel_offset_lb, 0, 1, 1, 2,
+                      (GtkAttachOptions) (GTK_FILL),
+                      (GtkAttachOptions) (0), 0, 0);
+    gtk_misc_set_alignment (GTK_MISC (channel_offset_lb), 0, 0.5);
+    /* End: Channel offset label */
+
+    /* Start: Channel offset combo box */
+    channel_offset_cb = gtk_combo_box_text_new();
+    gtk_widget_set_name (channel_offset_cb, "channel_offset_cb");
+
+    airpcap_update_channel_offset_combo(airpcap_if_selected, airpcap_if_selected->channelInfo.Frequency, channel_offset_cb, FALSE);
+
+    gtk_widget_show(channel_offset_cb);
+
+    gtk_table_attach (GTK_TABLE (basic_parameters_tb), channel_offset_cb, 1, 2, 1, 2,
+                  (GtkAttachOptions) (GTK_FILL),
+                  (GtkAttachOptions) (0), 0, 0);
+    /* End: Channel offset combo box */
+
+    channel_cb = gtk_combo_box_text_new();
+    gtk_widget_set_name (channel_cb, "channel_cb");
+    gtk_widget_show (channel_cb);
+    gtk_table_attach (GTK_TABLE (basic_parameters_tb), channel_cb, 1, 2, 0, 1,
+                      (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
+                      (GtkAttachOptions) (0), 0, 0);
+
+    /* Select the current channel */
+    airpcap_update_channel_combo(GTK_WIDGET(channel_cb), airpcap_if_selected);
+
+    capture_type_cb = gtk_combo_box_text_new();
+    gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT(capture_type_cb), AIRPCAP_LINK_TYPE_NAME_802_11_ONLY);
+    gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT(capture_type_cb), AIRPCAP_LINK_TYPE_NAME_802_11_PLUS_RADIO);
+    if (airpcap_get_dll_state() == AIRPCAP_DLL_OK) {
+        gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT(capture_type_cb), AIRPCAP_LINK_TYPE_NAME_802_11_PLUS_PPI);
+    }
+
+    gtk_widget_set_name (capture_type_cb, "capture_type_cb");
+    gtk_widget_show (capture_type_cb);
+    gtk_table_attach (GTK_TABLE (basic_parameters_tb), capture_type_cb, 1, 2, 2,
+                      3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
+                      (GtkAttachOptions) (0), 0, 0);
+
+    /* Current interface value */
+    if (airpcap_if_selected != NULL)
+    {
+        if (airpcap_if_selected->linkType == AIRPCAP_LT_802_11_PLUS_RADIO){
+            gtk_combo_box_set_active(GTK_COMBO_BOX(capture_type_cb), AIRPCAP_LINK_TYPE_NUM_802_11_PLUS_RADIO);
+        }else if (airpcap_if_selected->linkType == AIRPCAP_LT_802_11_PLUS_PPI){
+            gtk_combo_box_set_active(GTK_COMBO_BOX(capture_type_cb), AIRPCAP_LINK_TYPE_NUM_802_11_PLUS_PPI);
+        } else {
+            gtk_combo_box_set_active(GTK_COMBO_BOX(capture_type_cb), AIRPCAP_LINK_TYPE_NUM_802_11_ONLY);
+        }
+    }
+
+    fcs_ck = gtk_check_button_new_with_label ("Include 802.11 FCS in Frames");
+
+    gtk_widget_set_name (fcs_ck, "fcs_ck");
+
+    /* Fcs Presence check box */
+    if (airpcap_if_selected != NULL)
+    {
+        if (airpcap_if_selected->IsFcsPresent)
+            gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(fcs_ck),TRUE);
+        else
+            gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(fcs_ck),FALSE);
+    }
+
+    gtk_widget_show (fcs_ck);
+    gtk_table_attach (GTK_TABLE (basic_parameters_tb), fcs_ck, 2, 3, 0, 1,
+                      (GtkAttachOptions) (GTK_FILL),
+                      (GtkAttachOptions) (0), 0, 0);
+
+    basic_parameters_fcs_h_box = gtk_hbox_new (FALSE, 1);
+    gtk_widget_set_name (basic_parameters_fcs_h_box,
+                         "basic_parameters_fcs_h_box");
+    gtk_widget_show (basic_parameters_fcs_h_box);
+    gtk_table_attach (GTK_TABLE (basic_parameters_tb),
+                      basic_parameters_fcs_h_box, 2, 3, 2, 3,
+                      (GtkAttachOptions) (GTK_FILL),
+                      (GtkAttachOptions) (GTK_FILL), 3, 0);
+
+    basic_parameters_fcs_filter_lb = gtk_label_new ("FCS Filter:");
+    gtk_widget_set_name (basic_parameters_fcs_filter_lb,
+                         "basic_parameters_fcs_filter_lb");
+    gtk_widget_show (basic_parameters_fcs_filter_lb);
+    gtk_box_pack_start (GTK_BOX (basic_parameters_fcs_h_box),
+                        basic_parameters_fcs_filter_lb, FALSE, FALSE, 0);
+
+    fcs_filter_cb = gtk_combo_box_text_new();
+    gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT(fcs_filter_cb), airpcap_get_validation_name(AIRPCAP_VT_ACCEPT_EVERYTHING));
+    gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT(fcs_filter_cb), airpcap_get_validation_name(AIRPCAP_VT_ACCEPT_CORRECT_FRAMES));
+    gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT(fcs_filter_cb), airpcap_get_validation_name(AIRPCAP_VT_ACCEPT_CORRUPT_FRAMES));
+    gtk_combo_box_set_active(GTK_COMBO_BOX(fcs_filter_cb), 0);
+    gtk_widget_set_name (fcs_filter_cb, "fcs_filter_cb");
+    gtk_widget_show (fcs_filter_cb);
+    gtk_box_pack_start (GTK_BOX (basic_parameters_fcs_h_box), fcs_filter_cb,
+                        FALSE, FALSE, 0);
+    gtk_widget_set_size_request (fcs_filter_cb, 112, -1);
+
+    if (airpcap_if_selected != NULL)
+    {
+        airpcap_validation_type_combo_set_by_type(fcs_filter_cb, airpcap_if_selected->CrcValidationOn);
+    }
+
+    basic_parameters_frame_lb = gtk_label_new ("<b>Basic Parameters</b>");
+    gtk_widget_set_name (basic_parameters_frame_lb,
+                         "basic_parameters_frame_lb");
+    gtk_widget_show (basic_parameters_frame_lb);
+
+    gtk_frame_set_label_widget (GTK_FRAME (basic_parameters_fr),basic_parameters_frame_lb);
+    gtk_label_set_use_markup (GTK_LABEL (basic_parameters_frame_lb), TRUE);
+
+    low_buttons_h_box = gtk_hbox_new (FALSE, 0);
+    gtk_widget_set_name (low_buttons_h_box, "low_buttons_h_box");
+    gtk_widget_show (low_buttons_h_box);
+    gtk_box_pack_end (GTK_BOX (main_box), low_buttons_h_box, FALSE, FALSE, 0);
+
+    left_h_button_box = gtk_hbutton_box_new ();
+    gtk_widget_set_name (left_h_button_box, "left_h_button_box");
+    gtk_widget_show (left_h_button_box);
+    gtk_box_pack_start (GTK_BOX (low_buttons_h_box), left_h_button_box, FALSE,
+                        FALSE, 0);
+
+    right_h_button_box = dlg_button_row_new(GTK_STOCK_OK, GTK_STOCK_APPLY, GTK_STOCK_CANCEL, NULL);
+    gtk_widget_show (right_h_button_box);
+    gtk_box_pack_end (GTK_BOX (low_buttons_h_box), right_h_button_box, FALSE,
+                      FALSE, 0);
+    gtk_button_box_set_layout (GTK_BUTTON_BOX (right_h_button_box),
+                               GTK_BUTTONBOX_END);
+
+    ok_bt = g_object_get_data(G_OBJECT(right_h_button_box), GTK_STOCK_OK);
+    apply_bt = g_object_get_data(G_OBJECT(right_h_button_box), GTK_STOCK_APPLY);
+    cancel_bt = g_object_get_data(G_OBJECT(right_h_button_box), GTK_STOCK_CANCEL);
+
+    /* Connect the callbacks */
+    g_signal_connect (airpcap_advanced_w, "delete_event", G_CALLBACK(window_delete_event_cb), NULL);
+    g_signal_connect (airpcap_advanced_w, "destroy", G_CALLBACK(on_airpcap_advanced_destroy), airpcap_advanced_w);
+
+    if (!airpcap_if_is_any(airpcap_if_selected))
+    {
+        g_signal_connect (blink_bt, "clicked", G_CALLBACK(on_blink_bt_clicked), NULL);
+    }
+    else
+    {
+        g_signal_connect (blink_bt, "clicked", G_CALLBACK(on_what_s_this_bt_clicked), NULL);
+    }
+
+    g_signal_connect (channel_cb, "changed", G_CALLBACK(airpcap_channel_changed_noset_cb), channel_offset_cb);
+    /* We don't attach the channel offset combo because we don't want it changing anything yet. */
+    g_signal_connect (capture_type_cb, "changed", G_CALLBACK(on_capture_type_cb_changed), NULL);
+    g_signal_connect (fcs_ck, "toggled", G_CALLBACK(on_fcs_ck_toggled), NULL);
+    g_signal_connect (fcs_filter_cb, "changed", G_CALLBACK(on_fcs_filter_cb_changed), NULL);
+    g_signal_connect (apply_bt, "clicked", G_CALLBACK(on_advanced_apply_bt_clicked), airpcap_advanced_w);
+    g_signal_connect (ok_bt,"clicked", G_CALLBACK(on_advanced_ok_bt_clicked), airpcap_advanced_w);
+    g_signal_connect (cancel_bt,"clicked", G_CALLBACK(on_advanced_cancel_bt_clicked), airpcap_advanced_w);
+
+    /* Different because the window will be closed ... */
+    /*window_set_cancel_button(airpcap_advanced_w, ok_bt, window_cancel_button_cb);
+    window_set_cancel_button(airpcap_advanced_w, cancel_bt, window_cancel_button_cb);*/
+
+
+    /* Store pointers to all widgets, for use by lookup_widget(). */
+    g_object_set_data (G_OBJECT(airpcap_advanced_w), AIRPCAP_ADVANCED_BLINK_KEY, blink_bt);
+    g_object_set_data (G_OBJECT(airpcap_advanced_w), AIRPCAP_ADVANCED_CHANNEL_KEY,channel_cb);
+    g_object_set_data (G_OBJECT(airpcap_advanced_w), AIRPCAP_ADVANCED_CHANNEL_OFFSET_KEY, channel_offset_cb);
+    g_object_set_data (G_OBJECT(airpcap_advanced_w), AIRPCAP_ADVANCED_LINK_TYPE_KEY,capture_type_cb);
+    g_object_set_data (G_OBJECT(airpcap_advanced_w), AIRPCAP_ADVANCED_FCS_CHECK_KEY, fcs_ck);
+    g_object_set_data (G_OBJECT(airpcap_advanced_w), AIRPCAP_ADVANCED_FCS_FILTER_KEY, fcs_filter_cb);
+    g_object_set_data (G_OBJECT(airpcap_advanced_w), AIRPCAP_ADVANCED_OK_KEY, ok_bt);
+    g_object_set_data (G_OBJECT(airpcap_advanced_w), AIRPCAP_ADVANCED_CANCEL_KEY, cancel_bt);
+
+    /*
+     * I will need the toolbar and the main widget in some callback,
+     * so I will add the toolbar pointer to the airpcap_advanced_w
+     */
+    g_object_set_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_TOOLBAR_KEY,toolbar);
+
+    /* At the end, so that it appears completely all together ... */
+    gtk_widget_show (airpcap_advanced_w);
+}
+
+/*
+ * Callback for the OK button 'clicked' in the Decryption Key Management window.
+ */
+static void
+on_key_management_ok_bt_clicked(GtkWidget *button, gpointer data)
+{
+    /* advanced window */
+    GtkWidget    *key_management_w;
+
+    /* retrieve main window */
+    key_management_w      = GTK_WIDGET(data);
+
+    /* Apply the current decryption preferences */
+    on_key_management_apply_bt_clicked(button, data);
+
+    /* Save the preferences to preferences file!!! */
+    write_prefs_to_file();
+
+    gtk_widget_destroy(key_management_w);
+}
+
+/*
+ * Callback for the CANCEL button 'clicked' in the Decryption Key Management window.
+ */
+static void
+on_key_management_cancel_bt_clicked(GtkWidget *button _U_, gpointer data)
+{
+    /* Retrieve object data */
+    GtkWidget *key_management_w;
+    GtkWidget *cancel_bt;
+    GtkWidget *ok_bt;
+    GtkListStore *key_list_store;
+
+    /* widgets in the toolbar */
+    GtkWidget *toolbar,
+              *toolbar_decryption_ck,
+              *key_management_bt;
+
+    /* Retrieve the GUI object pointers */
+    key_management_w    = GTK_WIDGET(data);
+    cancel_bt           = GTK_WIDGET(g_object_get_data(G_OBJECT(key_management_w),AIRPCAP_ADVANCED_CANCEL_KEY));
+    ok_bt               = GTK_WIDGET(g_object_get_data(G_OBJECT(key_management_w),AIRPCAP_ADVANCED_OK_KEY));
+    key_list_store      = GTK_LIST_STORE(g_object_get_data(G_OBJECT(key_management_w),AIRPCAP_ADVANCED_KEYLIST_KEY));
+    key_management_bt   = GTK_WIDGET(g_object_get_data(G_OBJECT(key_management_w),AIRPCAP_ADVANCED_KEY));
+
+    toolbar = GTK_WIDGET(g_object_get_data(G_OBJECT(key_management_w),AIRPCAP_TOOLBAR_KEY));
+
+    /* retrieve toolbar info */
+    toolbar_decryption_ck    = GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_DECRYPTION_KEY));
+
+    gtk_widget_destroy(key_management_w);
+}
+
+/* Called to create the key management window */
+void
+display_airpcap_key_management_cb(GtkWidget *w _U_, gpointer data)
+{
+    GtkWidget *key_management_w;
+    GtkWidget *main_box;
+    GtkWidget *keys_fr;
+    GtkWidget *keys_al;
+    GtkWidget *keys_h_sub_box;
+    GtkWidget *decryption_mode_tb;
+    GtkWidget *decryption_mode_lb;
+    GtkWidget *decryption_mode_cb;
+    GtkWidget *keys_v_sub_box;
+    GtkWidget *keys_scrolled_w;
+    GtkListStore *key_list_store;
+    GtkWidget *key_list;
+    GtkWidget *key_v_button_box;
+    GtkWidget *add_new_key_bt;
+    GtkWidget *remove_key_bt;
+    GtkWidget *edit_key_bt;
+    GtkWidget *move_key_up_bt;
+    GtkWidget *move_key_down_bt;
+    GtkWidget *keys_frame_lb;
+    GtkWidget *low_buttons_h_box;
+    GtkWidget *left_h_button_box;
+    GtkWidget *right_h_button_box;
+    GtkWidget *ok_bt;
+    GtkWidget *apply_bt;
+    GtkWidget *cancel_bt;
+
+    /* widgets in the toolbar */
+    GtkWidget *toolbar,
+              *toolbar_decryption_ck;
+
+    /* key list */
+    GtkTreeViewColumn *column;
+    GtkCellRenderer   *renderer;
+    GtkTreeSortable   *sortable;
+    GtkTreeSelection  *selection;
+    GtkTreeIter        iter;
+
+    /* Selected row/column structure */
+    airpcap_key_ls_selected_info_t *key_ls_selected_item;
+    key_ls_selected_item = (airpcap_key_ls_selected_info_t*)g_malloc(sizeof(airpcap_key_ls_selected_info_t));
+    key_ls_selected_item->row = NO_ROW_SELECTED;
+
+    /* user data - RETRIEVE pointers of toolbar widgets */
+    toolbar               = GTK_WIDGET(data);
+    toolbar_decryption_ck = GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_DECRYPTION_KEY));
+
+    /* gray out the toolbar */
+    gtk_widget_set_sensitive(toolbar,FALSE);
+
+    /* main window */
+    /* global */
+
+    /* the selected is the active, for now */
+    airpcap_if_selected = airpcap_if_active;
+
+    /* Create the new window */
+    key_management_w = dlg_window_new("Decryption Key Management");  /* transient_for top_level */
+    gtk_window_set_destroy_with_parent (GTK_WINDOW(key_management_w), TRUE);
+
+    gtk_container_set_border_width (GTK_CONTAINER (key_management_w), 5);
+    gtk_window_set_position (GTK_WINDOW (key_management_w),
+                             GTK_WIN_POS_CENTER);
+
+    gtk_window_set_resizable (GTK_WINDOW (key_management_w), FALSE);
+    gtk_window_set_type_hint (GTK_WINDOW (key_management_w), GDK_WINDOW_TYPE_HINT_DIALOG);
+
+    main_box = gtk_vbox_new (FALSE, 0);
+    gtk_widget_set_name (main_box, "main_box");
+    gtk_widget_show (main_box);
+    gtk_container_add (GTK_CONTAINER (key_management_w), main_box);
+
+    keys_fr = gtk_frame_new (NULL);
+    gtk_widget_set_name (keys_fr, "keys_fr");
+    gtk_widget_show (keys_fr);
+    gtk_box_pack_start (GTK_BOX (main_box), keys_fr, FALSE, FALSE, 0);
+    gtk_container_set_border_width (GTK_CONTAINER (keys_fr), 10);
+
+    keys_al = gtk_alignment_new (0.5, 0.5, 1, 1);
+    gtk_widget_set_name (keys_al, "keys_al");
+    gtk_widget_show (keys_al);
+    gtk_container_add (GTK_CONTAINER (keys_fr), keys_al);
+    gtk_container_set_border_width (GTK_CONTAINER (keys_al), 5);
+
+    gtk_alignment_set_padding (GTK_ALIGNMENT (keys_al), 0, 0, 12, 0);
+
+    keys_h_sub_box = gtk_vbox_new (FALSE, 0);
+    gtk_widget_set_name (keys_h_sub_box, "keys_h_sub_box");
+    gtk_widget_show (keys_h_sub_box);
+    gtk_container_add (GTK_CONTAINER (keys_al), keys_h_sub_box);
+
+    decryption_mode_tb = gtk_table_new (1, 2, FALSE);
+    gtk_widget_set_name (decryption_mode_tb, "decryption_mode_tb");
+    gtk_widget_show (decryption_mode_tb);
+    gtk_box_pack_start (GTK_BOX (keys_h_sub_box), decryption_mode_tb, FALSE,
+                        FALSE, 0);
+    gtk_table_set_col_spacings (GTK_TABLE (decryption_mode_tb), 6);
+
+    decryption_mode_lb = gtk_label_new ("Select Decryption Mode");
+    gtk_widget_set_name (decryption_mode_lb, "decryption_mode_lb");
+    gtk_widget_show (decryption_mode_lb);
+    gtk_table_attach (GTK_TABLE (decryption_mode_tb), decryption_mode_lb, 1,
+                      2, 0, 1, (GtkAttachOptions) (GTK_FILL),
+                      (GtkAttachOptions) (0), 0, 0);
+    gtk_misc_set_alignment (GTK_MISC (decryption_mode_lb), 0, 0.5);
+
+    decryption_mode_cb = gtk_combo_box_text_new();
+    update_decryption_mode_list(decryption_mode_cb);
+    gtk_widget_set_name (decryption_mode_cb, "decryption_mode_cb");
+    gtk_widget_show (decryption_mode_cb);
+    gtk_table_attach (GTK_TABLE (decryption_mode_tb), decryption_mode_cb, 0,
+                      1, 0, 1, (GtkAttachOptions) (0), (GtkAttachOptions) (0),
+                      0, 0);
+    gtk_widget_set_size_request (decryption_mode_cb, 83, -1);
+
+    /* Set correct decryption mode!!!! */
+    update_decryption_mode(decryption_mode_cb);
+
+    keys_v_sub_box = gtk_hbox_new (FALSE, 0);
+    gtk_widget_set_name (keys_v_sub_box, "keys_v_sub_box");
+    gtk_widget_show (keys_v_sub_box);
+    gtk_box_pack_start (GTK_BOX (keys_h_sub_box), keys_v_sub_box, TRUE, TRUE, 0);
+
+    keys_scrolled_w = gtk_scrolled_window_new (NULL, NULL);
+    gtk_widget_set_name (keys_scrolled_w, "keys_scrolled_w");
+    gtk_widget_show (keys_scrolled_w);
+    gtk_box_pack_start (GTK_BOX (keys_v_sub_box), keys_scrolled_w, TRUE, TRUE,
+                        0);
+    gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (keys_scrolled_w), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
+
+
+
+    /* Create the store */
+    key_list_store = gtk_list_store_new(KL_NUM_COLS,
+                                        G_TYPE_STRING, /* Type */
+                                        G_TYPE_STRING /* Key */
+                                        , G_TYPE_STRING /* SSID */
+                                       );
+
+    /* Create a view */
+    key_list = gtk_tree_view_new_with_model(GTK_TREE_MODEL(key_list_store));
+
+    sortable = GTK_TREE_SORTABLE(key_list_store);
+
+    /* Speed up the list display */
+    gtk_tree_view_set_fixed_height_mode(GTK_TREE_VIEW(key_list), TRUE);
+
+    /* Setup the sortable columns */
+    gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(key_list), FALSE);
+
+    /* The view now holds a reference.  We can get rid of our own reference */
+    g_object_unref(G_OBJECT(key_list_store));
+
+    /*
+     * Create the first column packet, associating the "text" attribute of the
+     * cell_renderer to the first column of the model
+     */
+    renderer = gtk_cell_renderer_text_new();
+    column = gtk_tree_view_column_new_with_attributes("Type", renderer,
+            "text", KL_COL_TYPE, NULL);
+    gtk_tree_view_column_set_sort_column_id(column, KL_COL_TYPE);
+    gtk_tree_view_column_set_resizable(column, TRUE);
+    gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
+    gtk_tree_view_column_set_min_width(column, 60);
+    gtk_tree_view_column_set_fixed_width(column, 100);
+    /* Add the column to the view. */
+    gtk_tree_view_append_column(GTK_TREE_VIEW(key_list), column);
+
+    /* Key */
+    renderer = gtk_cell_renderer_text_new();
+    column = gtk_tree_view_column_new_with_attributes("Key", renderer,
+            "text", KL_COL_KEY, NULL);
+    gtk_tree_view_column_set_sort_column_id(column, KL_COL_KEY);
+    gtk_tree_view_column_set_resizable(column, TRUE);
+    gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
+    gtk_tree_view_column_set_min_width(column, 120);
+    gtk_tree_view_column_set_fixed_width(column, 200);
+    gtk_tree_view_append_column(GTK_TREE_VIEW(key_list), column);
+
+    /* SSID */
+    renderer = gtk_cell_renderer_text_new();
+    column = gtk_tree_view_column_new_with_attributes("SSID", renderer,
+            "text", KL_COL_SSID,
+            NULL);
+    gtk_tree_view_column_set_sort_column_id(column, KL_COL_SSID);
+    gtk_tree_view_column_set_resizable(column, TRUE);
+    gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
+    gtk_tree_view_column_set_min_width(column, 80);
+    gtk_tree_view_column_set_fixed_width(column, 150);
+    gtk_tree_view_append_column(GTK_TREE_VIEW(key_list), column);
+
+    /* Now enable the sorting of each column */
+    gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(key_list), TRUE);
+    gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(key_list), TRUE);
+
+    /* Setup the selection handler */
+    selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(key_list));
+    gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
+
+    gtk_widget_show (key_list);
+
+    gtk_container_add (GTK_CONTAINER (keys_scrolled_w), key_list);
+
+    key_v_button_box = gtk_vbutton_box_new ();
+    gtk_widget_set_name (key_v_button_box, "key_v_button_box");
+    gtk_widget_show (key_v_button_box);
+    gtk_box_pack_start (GTK_BOX (keys_v_sub_box), key_v_button_box, FALSE, TRUE,
+                        0);
+
+    add_new_key_bt = gtk_button_new_from_stock(GTK_STOCK_NEW);
+    gtk_widget_set_name (add_new_key_bt, "add_new_key_bt");
+    gtk_widget_show (add_new_key_bt);
+    gtk_container_add (GTK_CONTAINER (key_v_button_box), add_new_key_bt);
+#if GTK_CHECK_VERSION(2,18,0)
+    gtk_widget_set_can_default (add_new_key_bt, TRUE);
+#else
+    GTK_WIDGET_SET_FLAGS (add_new_key_bt, GTK_CAN_DEFAULT);
+#endif
+
+    edit_key_bt = gtk_button_new_from_stock(WIRESHARK_STOCK_EDIT);
+    gtk_widget_set_name (edit_key_bt, "edit_key_bt");
+    gtk_widget_show (edit_key_bt);
+    gtk_container_add (GTK_CONTAINER (key_v_button_box), edit_key_bt);
+#if GTK_CHECK_VERSION(2,18,0)
+    gtk_widget_set_can_default (edit_key_bt, TRUE);
+#else
+    GTK_WIDGET_SET_FLAGS (edit_key_bt, GTK_CAN_DEFAULT);
+#endif
+
+    remove_key_bt = gtk_button_new_from_stock(GTK_STOCK_DELETE);
+    gtk_widget_set_name (remove_key_bt, "remove_key_bt");
+    gtk_widget_show (remove_key_bt);
+    gtk_container_add (GTK_CONTAINER (key_v_button_box), remove_key_bt);
+#if GTK_CHECK_VERSION(2,18,0)
+    gtk_widget_set_can_default (remove_key_bt, TRUE);
+#else
+    GTK_WIDGET_SET_FLAGS (remove_key_bt, GTK_CAN_DEFAULT);
+#endif
+
+    move_key_up_bt = gtk_button_new_from_stock(GTK_STOCK_GO_UP);
+    gtk_widget_set_name (move_key_up_bt, "move_key_up_bt");
+    gtk_widget_show (move_key_up_bt);
+    gtk_container_add (GTK_CONTAINER (key_v_button_box), move_key_up_bt);
+#if GTK_CHECK_VERSION(2,18,0)
+    gtk_widget_set_can_default (move_key_up_bt, TRUE);
+#else
+    GTK_WIDGET_SET_FLAGS (move_key_up_bt, GTK_CAN_DEFAULT);
+#endif
+
+    move_key_down_bt = gtk_button_new_from_stock(GTK_STOCK_GO_DOWN);
+    gtk_widget_set_name (move_key_down_bt, "move_key_down_bt");
+    gtk_widget_show (move_key_down_bt);
+    gtk_container_add (GTK_CONTAINER (key_v_button_box), move_key_down_bt);
+#if GTK_CHECK_VERSION(2,18,0)
+    gtk_widget_set_can_default (move_key_down_bt, GTK_CAN_DEFAULT);
+#else
+    GTK_WIDGET_SET_FLAGS (move_key_down_bt, GTK_CAN_DEFAULT);
+#endif
+
+    keys_frame_lb = gtk_label_new ("<b>Decryption Keys</b>");
+    gtk_widget_set_name (keys_frame_lb, "keys_frame_lb");
+    gtk_widget_show (keys_frame_lb);
+
+    gtk_frame_set_label_widget (GTK_FRAME (keys_fr), keys_frame_lb);
+    gtk_label_set_use_markup (GTK_LABEL (keys_frame_lb), TRUE);
+
+    low_buttons_h_box = gtk_hbox_new (FALSE, 0);
+    gtk_widget_set_name (low_buttons_h_box, "low_buttons_h_box");
+    gtk_widget_show (low_buttons_h_box);
+    gtk_box_pack_end (GTK_BOX (main_box), low_buttons_h_box, FALSE, FALSE, 0);
+
+    left_h_button_box = gtk_hbutton_box_new ();
+    gtk_widget_set_name (left_h_button_box, "left_h_button_box");
+    gtk_widget_show (left_h_button_box);
+    gtk_box_pack_start (GTK_BOX (low_buttons_h_box), left_h_button_box, FALSE,
+                        FALSE, 0);
+
+    right_h_button_box = dlg_button_row_new(GTK_STOCK_OK, GTK_STOCK_APPLY, GTK_STOCK_CANCEL, NULL);
+    gtk_widget_set_name (right_h_button_box, "right_h_button_box");
+    gtk_widget_show (right_h_button_box);
+    gtk_box_pack_end (GTK_BOX (low_buttons_h_box), right_h_button_box, FALSE,
+                      FALSE, 0);
+    gtk_button_box_set_layout (GTK_BUTTON_BOX (right_h_button_box),
+                               GTK_BUTTONBOX_END);
+
+    ok_bt = g_object_get_data(G_OBJECT(right_h_button_box), GTK_STOCK_OK);
+    apply_bt = g_object_get_data(G_OBJECT(right_h_button_box), GTK_STOCK_APPLY);
+    cancel_bt = g_object_get_data(G_OBJECT(right_h_button_box), GTK_STOCK_CANCEL);
+
+    /* Connect the callbacks */
+    g_signal_connect (key_management_w, "delete_event", G_CALLBACK(window_delete_event_cb), NULL);
+    g_signal_connect (key_management_w, "destroy", G_CALLBACK(on_key_management_destroy), key_management_w);
+    g_signal_connect (add_new_key_bt, "clicked", G_CALLBACK(on_add_new_key_bt_clicked), key_management_w);
+    g_signal_connect (remove_key_bt, "clicked", G_CALLBACK(on_remove_key_bt_clicked), key_management_w);
+    g_signal_connect (edit_key_bt, "clicked", G_CALLBACK(on_edit_key_bt_clicked), key_management_w);
+    g_signal_connect (move_key_up_bt, "clicked", G_CALLBACK(on_move_key_up_bt_clicked), key_list);
+    g_signal_connect (move_key_down_bt, "clicked", G_CALLBACK(on_move_key_down_bt_clicked), key_list);
+    g_signal_connect (apply_bt, "clicked", G_CALLBACK(on_key_management_apply_bt_clicked), key_management_w);
+    g_signal_connect (ok_bt, "clicked", G_CALLBACK(on_key_management_ok_bt_clicked), key_management_w);
+    g_signal_connect (cancel_bt, "clicked", G_CALLBACK(on_key_management_cancel_bt_clicked), key_management_w);
+    g_signal_connect (selection, "changed", G_CALLBACK(on_key_list_select_row), key_management_w);
+    g_signal_connect (key_list_store, "rows_reordered", G_CALLBACK(on_key_list_reorder), key_management_w);
+
+    /* Different because the window will be closed ... */
+    /*window_set_cancel_button(key_management_w, ok_bt, window_cancel_button_cb);
+    window_set_cancel_button(key_management_w, cancel_bt, window_cancel_button_cb);*/
+
+    g_object_set_data (G_OBJECT(key_management_w), AIRPCAP_ADVANCED_EDIT_KEY_SELECTION_KEY,selection);
+
+    /* Store pointers to all widgets, for use by lookup_widget(). */
+    g_object_set_data (G_OBJECT(key_management_w), AIRPCAP_ADVANCED_DECRYPTION_MODE_KEY, decryption_mode_cb);
+    g_object_set_data (G_OBJECT(key_management_w), AIRPCAP_ADVANCED_KEYLIST_KEY, key_list_store);
+    g_object_set_data (G_OBJECT(key_management_w), AIRPCAP_ADVANCED_OK_KEY, ok_bt);
+    g_object_set_data (G_OBJECT(key_management_w), AIRPCAP_ADVANCED_CANCEL_KEY, cancel_bt);
+
+    /* Enable / disable buttons */
+    g_object_set_data (G_OBJECT(key_management_w), AIRPCAP_KEY_MGMT_NEW_KEY, add_new_key_bt);
+    g_object_set_data (G_OBJECT(key_management_w), AIRPCAP_KEY_MGMT_EDIT_KEY, edit_key_bt);
+    g_object_set_data (G_OBJECT(key_management_w), AIRPCAP_KEY_MGMT_DELETE_KEY, remove_key_bt);
+    g_object_set_data (G_OBJECT(key_management_w), AIRPCAP_KEY_MGMT_UP_KEY, move_key_up_bt);
+    g_object_set_data (G_OBJECT(key_management_w), AIRPCAP_KEY_MGMT_DOWN_KEY, move_key_down_bt);
+
+    /*
+     * I will need the toolbar and the main widget in some callback,
+     * so I will add the toolbar pointer to the key_management_w
+     */
+    g_object_set_data(G_OBJECT(key_management_w),AIRPCAP_TOOLBAR_KEY,toolbar);
+    g_object_set_data (G_OBJECT(key_management_w), AIRPCAP_TOOLBAR_DECRYPTION_KEY, toolbar_decryption_ck);
+
+    /* FIRST OF ALL, CHECK THE KEY COLLECTIONS */
+    /*
+     * This will read the decryption keys from the preferences file, and will store
+     * them into the registry...
+     */
+    if (!airpcap_check_decryption_keys(airpcap_if_list))
+    {
+        /* Ask the user what to do ...*/
+        airpcap_keys_check_w(key_management_w,NULL);
+    }
+    else /* Keys from lists are equals, or Wireshark has got no keys */
+    {
+        airpcap_load_decryption_keys(airpcap_if_list);
+        airpcap_fill_key_list(key_list_store);
+        /* At the end, so that it appears completely all together ... */
+        gtk_widget_show (key_management_w);
+    }
+
+    gtk_tree_model_get_iter_first(GTK_TREE_MODEL(key_list_store), &iter);
+    gtk_tree_selection_select_iter(selection, &iter);
+}
+
+
+static void
+on_keys_check_cancel_bt_clicked (GtkWidget *button _U_, gpointer user_data)
+{
+    GtkWidget *key_management_w;
+    GtkWidget *keys_check_w;
+    GtkListStore *key_list_store;
+
+    keys_check_w = GTK_WIDGET(user_data);
+
+    key_management_w = g_object_get_data(G_OBJECT(keys_check_w),AIRPCAP_CHECK_WINDOW_KEY);
+
+    /* w may be NULL if airpcap_keys_check_w() has been called while Wireshark was loading,
+       and is not NULL if it was called when the Key Management widget has been clicked */
+    if (key_management_w != NULL)
+    {
+        /*  ... */
+        key_list_store = g_object_get_data(G_OBJECT(key_management_w),AIRPCAP_ADVANCED_KEYLIST_KEY);
+        airpcap_fill_key_list(key_list_store);
+        gtk_widget_show (key_management_w);
+    }
+
+    gtk_widget_destroy(keys_check_w);
+}
+
+static void
+on_merge_bt_clicked (GtkWidget* button _U_, gpointer user_data)
+{
+    GtkWidget *key_management_w;
+    GtkWidget *keys_check_w;
+    GtkListStore *key_list_store;
+
+    guint n_adapters = 0;
+    guint n_wireshark_keys = 0;
+    guint n_driver_keys = 0;
+    guint n_curr_adapter_keys = 0;
+    guint n_total_keys = 0;
+    guint n_merged_keys = 0;
+    guint i = 0;
+
+    GList* wireshark_keys=NULL;
+    GList* driver_keys=NULL;
+    GList* current_adapter_keys=NULL;
+    GList* merged_list = NULL;
+    GList* merged_list_tmp = NULL;
+
+    airpcap_if_info_t* curr_adapter;
+
+    keys_check_w = GTK_WIDGET(user_data);
+
+    key_management_w = g_object_get_data(G_OBJECT(keys_check_w),AIRPCAP_CHECK_WINDOW_KEY);
+
+    n_adapters = g_list_length(airpcap_if_list);
+
+    /* Retrieve Wireshark keys */
+    wireshark_keys = get_wireshark_keys();
+    n_wireshark_keys = g_list_length(wireshark_keys);
+    n_total_keys += n_wireshark_keys;
+
+    merged_list = merge_key_list(wireshark_keys,NULL);
+
+    /* Retrieve AirPcap driver's keys */
+    driver_keys = get_airpcap_driver_keys();
+    n_driver_keys = g_list_length(driver_keys);
+    n_total_keys += n_driver_keys;
+
+    merged_list = merge_key_list(merged_list,driver_keys);
+
+    /* NOW wireshark_keys and driver_keys ARE no more needed... at the end, we will have to free them! */
+    for (i = 0; i<n_adapters; i++)
+    {
+        curr_adapter = (airpcap_if_info_t*)g_list_nth_data(airpcap_if_list,i);
+        current_adapter_keys = get_airpcap_device_keys(curr_adapter);
+        n_curr_adapter_keys = g_list_length(current_adapter_keys);
+
+        merged_list_tmp = merged_list;
+        merged_list = merge_key_list(merged_list_tmp,current_adapter_keys);
+        free_key_list(merged_list_tmp);
+
+        n_total_keys += n_curr_adapter_keys;
+    }
+
+    n_merged_keys = g_list_length(merged_list);
+
+    /* Set up this new list as default for Wireshark and Adapters... */
+    airpcap_save_decryption_keys(merged_list,airpcap_if_list);
+
+    /* Write the preferences to the preferences file */
+    write_prefs_to_file();
+
+    free_key_list(wireshark_keys);
+    free_key_list(driver_keys);
+
+    gtk_widget_destroy(keys_check_w);
+
+    /* w may be NULL if airpcap_keys_check_w() has been called while Wireshark was loading,
+       and is not NULL if it was called when the Key Management widget has been clicked */
+    if (key_management_w != NULL)
+    {
+        /*  ... */
+        key_list_store = g_object_get_data(G_OBJECT(key_management_w),AIRPCAP_ADVANCED_KEYLIST_KEY);
+        airpcap_fill_key_list(key_list_store);
+        gtk_widget_show (key_management_w);
+    }
+}
+
+static void
+on_keep_bt_clicked (GtkWidget *button _U_, gpointer user_data)
+{
+    GtkWidget *key_management_w;
+    GtkWidget *keys_check_w;
+    GtkListStore *key_list_store=NULL;
+
+    GList* wireshark_keys=NULL;
+    guint n_wireshark_keys = 0;
+
+    GList* merged_keys=NULL;
+    guint n_merged_keys = 0;
+
+    guint n_adapters=0;
+    guint n_total_keys=0;
+
+    keys_check_w = GTK_WIDGET(user_data);
+
+    key_management_w = g_object_get_data(G_OBJECT(keys_check_w),AIRPCAP_CHECK_WINDOW_KEY);
+
+    n_adapters = g_list_length(airpcap_if_list);
+
+    /* Retrieve Wireshark keys */
+    wireshark_keys = get_wireshark_keys();
+    n_wireshark_keys = g_list_length(wireshark_keys);
+    n_total_keys += n_wireshark_keys;
+
+    merged_keys = merge_key_list(wireshark_keys,NULL);
+    n_merged_keys = g_list_length(merged_keys);
+
+    /* Set up this new list as default for Wireshark and Adapters... */
+    airpcap_save_decryption_keys(merged_keys,airpcap_if_list);
+
+    /* Write the preferences to the preferences file (here is not needed, by the way)*/
+    write_prefs_to_file();
+
+    /* Free the memory */
+    free_key_list(wireshark_keys);
+
+    /* Close the window */
+    gtk_widget_destroy(keys_check_w);
+
+    /* w may be NULL if airpcap_keys_check_w() has been called while Wireshark was loading,
+       and is not NULL if it was called when the Key Management widget has been clicked */
+    if (key_management_w != NULL)
+    {
+        /*  ... */
+        key_list_store = g_object_get_data(G_OBJECT(key_management_w),AIRPCAP_ADVANCED_KEYLIST_KEY);
+        airpcap_fill_key_list(key_list_store);
+        gtk_widget_show (key_management_w);
+    }
+}
+
+static void
+on_import_bt_clicked (GtkWidget* button _U_, gpointer user_data)
+{
+    GtkWidget *key_management_w;
+    GtkWidget *keys_check_w;
+    GtkListStore *key_list_store;
+
+    guint n_adapters = 0;
+    guint n_wireshark_keys = 0;
+    guint n_driver_keys = 0;
+    guint n_curr_adapter_keys = 0;
+    guint n_total_keys = 0;
+    guint n_merged_keys = 0;
+    guint i = 0;
+
+    GList* wireshark_keys=NULL;
+    GList* driver_keys=NULL;
+    GList* current_adapter_keys=NULL;
+    GList* merged_list = NULL;
+    GList* merged_list_tmp = NULL;
+
+    airpcap_if_info_t* curr_adapter;
+
+    keys_check_w = GTK_WIDGET(user_data);
+
+    key_management_w = g_object_get_data(G_OBJECT(keys_check_w),AIRPCAP_CHECK_WINDOW_KEY);
+
+    n_adapters = g_list_length(airpcap_if_list);
+
+    wireshark_keys = get_wireshark_keys();
+    n_wireshark_keys = g_list_length(wireshark_keys);
+    n_total_keys += n_wireshark_keys;
+
+    /* Retrieve AirPcap driver's keys */
+    driver_keys = get_airpcap_driver_keys();
+    n_driver_keys = g_list_length(driver_keys);
+    n_total_keys += n_driver_keys;
+
+    merged_list = merge_key_list(merged_list,driver_keys);
+
+    /* NOW wireshark_keys IS no more needed... at the end, we will have to free it! */
+    for (i = 0; i<n_adapters; i++)
+    {
+        curr_adapter = (airpcap_if_info_t*)g_list_nth_data(airpcap_if_list,i);
+        current_adapter_keys = get_airpcap_device_keys(curr_adapter);
+        n_curr_adapter_keys = g_list_length(current_adapter_keys);
+
+        merged_list_tmp = merged_list;
+        merged_list = merge_key_list(merged_list_tmp,current_adapter_keys);
+        free_key_list(merged_list_tmp);
+
+        n_total_keys += n_curr_adapter_keys;
+    }
+
+    n_merged_keys = g_list_length(merged_list);
+
+    /* Set up this new list as default for Wireshark and Adapters... */
+    airpcap_save_decryption_keys(merged_list,airpcap_if_list);
+
+    /* Write the preferences to the preferences file */
+    write_prefs_to_file();
+
+    free_key_list(wireshark_keys);
+    free_key_list(driver_keys);
+
+    gtk_widget_destroy(keys_check_w);
+
+    /* w may be NULL if airpcap_keys_check_w() has been called while Wireshark was loading,
+       and is not NULL if it was called when the Key Management widget has been clicked */
+    if (key_management_w != NULL)
+    {
+        /*  ... */
+        key_list_store = g_object_get_data(G_OBJECT(key_management_w),AIRPCAP_ADVANCED_KEYLIST_KEY);
+        airpcap_fill_key_list(key_list_store);
+        gtk_widget_show (key_management_w);
+    }
+}
+
+static void
+on_ignore_bt_clicked (GtkWidget* button _U_, gpointer user_data)
+{
+    GtkWidget *key_management_w;
+    GtkWidget *keys_check_w;
+    GtkListStore *key_list_store;
+
+    keys_check_w = GTK_WIDGET(user_data);
+
+    key_management_w = g_object_get_data(G_OBJECT(keys_check_w),AIRPCAP_CHECK_WINDOW_KEY);
+
+    /* w may be NULL if airpcap_keys_check_w() has been called while Wireshark was loading,
+       and is not NULL if it was called when the Key Management widget has been clicked */
+    if (key_management_w != NULL)
+    {
+        /*  ... */
+        key_list_store = g_object_get_data(G_OBJECT(key_management_w),AIRPCAP_ADVANCED_KEYLIST_KEY);
+        airpcap_fill_key_list(key_list_store);
+        gtk_widget_show (key_management_w);
+    }
+
+    gtk_widget_destroy(keys_check_w);
+}
+
+static void
+on_keys_check_ok_bt_clicked (GtkWidget *button _U_, gpointer user_data)
+{
+    GtkWidget *key_management_w;
+    GtkWidget *keys_check_w;
+
+    GtkWidget *merge_rb,
+              *keep_rb,
+              *import_rb,
+              *ignore_rb;
+
+    keys_check_w = GTK_WIDGET(user_data);
+
+    key_management_w = g_object_get_data(G_OBJECT(keys_check_w),AIRPCAP_CHECK_WINDOW_KEY);
+    merge_rb  = g_object_get_data(G_OBJECT(keys_check_w),AIRPCAP_CHECK_WINDOW_RADIO_MERGE_KEY);
+    keep_rb   = g_object_get_data(G_OBJECT(keys_check_w),AIRPCAP_CHECK_WINDOW_RADIO_KEEP_KEY);
+    import_rb = g_object_get_data(G_OBJECT(keys_check_w),AIRPCAP_CHECK_WINDOW_RADIO_IMPORT_KEY);
+    ignore_rb = g_object_get_data(G_OBJECT(keys_check_w),AIRPCAP_CHECK_WINDOW_RADIO_IGNORE_KEY);
+
+    /* Find out which radio button is selected and call the correct function */
+    if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(merge_rb)))
+        on_merge_bt_clicked (merge_rb,keys_check_w);
+    else if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(keep_rb))) 
+        on_keep_bt_clicked (keep_rb,keys_check_w);
+    else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(import_rb))) 
+        on_import_bt_clicked (import_rb,keys_check_w);
+    else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ignore_rb)))
+        on_ignore_bt_clicked (ignore_rb,keys_check_w);
+    else on_keys_check_cancel_bt_clicked(NULL,keys_check_w);
+}
+
+static void
+on_keys_check_w_destroy (GtkWidget *w _U_, gpointer user_data)
+{
+    gtk_widget_set_sensitive(top_level,TRUE);
+    gtk_widget_set_sensitive(GTK_WIDGET(user_data),TRUE);
+}
+
+/*
+ * Dialog box that appears whenever keys are not consistent between Wireshark and AirPcap
+ */
+void
+airpcap_keys_check_w(GtkWidget *w, gpointer data _U_)
+{
+    GtkWidget *keys_check_w;
+    GtkWidget *main_v_box;
+    GtkWidget *warning_lb;
+    GtkWidget *radio_tb;
+    GtkWidget *keep_rb;
+    GSList *radio_bt_group = NULL;
+    GtkWidget *merge_rb;
+    GtkWidget *import_rb;
+    GtkWidget *ignore_rb;
+    GtkWidget *keep_lb;
+    GtkWidget *merge_lb;
+    GtkWidget *import_lb;
+    GtkWidget *ignore_lb;
+    GtkWidget *low_h_button_box;
+    GtkWidget *ok_bt;
+    GtkWidget *cancel_bt;
+
+    keys_check_w = window_new (GTK_WINDOW_TOPLEVEL, "Decryption Key Warning");
+    gtk_widget_set_name (keys_check_w, "keys_check_w");
+    gtk_window_set_resizable (GTK_WINDOW (keys_check_w), FALSE);
+
+    main_v_box = gtk_vbox_new (FALSE, 0);
+    gtk_widget_set_name (main_v_box, "main_v_box");
+    gtk_widget_show (main_v_box);
+    gtk_container_add (GTK_CONTAINER (keys_check_w), main_v_box);
+
+    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:");
+    gtk_label_set_use_markup (GTK_LABEL (warning_lb), TRUE);
+    gtk_widget_set_name (warning_lb, "warning_lb");
+    gtk_widget_show (warning_lb);
+    gtk_box_pack_start (GTK_BOX (main_v_box), warning_lb, FALSE, FALSE, 0);
+    gtk_label_set_justify (GTK_LABEL (warning_lb), GTK_JUSTIFY_CENTER);
+    gtk_label_set_line_wrap (GTK_LABEL (warning_lb), TRUE);
+
+    radio_tb = gtk_table_new (4, 2, FALSE);
+    gtk_widget_set_name (radio_tb, "radio_tb");
+    gtk_widget_show (radio_tb);
+    gtk_box_pack_start (GTK_BOX (main_v_box), radio_tb, TRUE, FALSE, 0);
+    gtk_container_set_border_width (GTK_CONTAINER (radio_tb), 5);
+    gtk_table_set_col_spacings (GTK_TABLE (radio_tb), 8);
+
+    keep_rb = gtk_radio_button_new_with_mnemonic (NULL, "Keep");
+    gtk_widget_set_name (keep_rb, "keep_rb");
+    gtk_widget_show (keep_rb);
+    gtk_table_attach (GTK_TABLE (radio_tb), keep_rb, 0, 1, 0, 1,
+                      (GtkAttachOptions) (GTK_FILL),
+                      (GtkAttachOptions) (0), 0, 0);
+    gtk_radio_button_set_group (GTK_RADIO_BUTTON (keep_rb), radio_bt_group);
+    radio_bt_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (keep_rb));
+
+    merge_rb = gtk_radio_button_new_with_mnemonic (NULL, "Merge");
+    gtk_widget_set_name (merge_rb, "merge_rb");
+    gtk_widget_show (merge_rb);
+    gtk_table_attach (GTK_TABLE (radio_tb), merge_rb, 0, 1, 1, 2,
+                      (GtkAttachOptions) (GTK_FILL),
+                      (GtkAttachOptions) (0), 0, 0);
+    gtk_radio_button_set_group (GTK_RADIO_BUTTON (merge_rb), radio_bt_group);
+    radio_bt_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (merge_rb));
+
+    import_rb = gtk_radio_button_new_with_mnemonic (NULL, "Import");
+    gtk_widget_set_name (import_rb, "import_rb");
+    gtk_widget_show (import_rb);
+    gtk_table_attach (GTK_TABLE (radio_tb), import_rb, 0, 1, 2, 3,
+                      (GtkAttachOptions) (GTK_FILL),
+                      (GtkAttachOptions) (0), 0, 0);
+    gtk_radio_button_set_group (GTK_RADIO_BUTTON (import_rb), radio_bt_group);
+    radio_bt_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (import_rb));
+
+    ignore_rb = gtk_radio_button_new_with_mnemonic (NULL, "Ignore");
+    gtk_widget_set_name (ignore_rb, "ignore_rb");
+    gtk_widget_show (ignore_rb);
+    gtk_table_attach (GTK_TABLE (radio_tb), ignore_rb, 0, 1, 3, 4,
+                      (GtkAttachOptions) (GTK_FILL),
+                      (GtkAttachOptions) (0), 0, 0);
+    gtk_radio_button_set_group (GTK_RADIO_BUTTON (ignore_rb), radio_bt_group);
+    radio_bt_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (ignore_rb));
+
+    keep_lb =
+        gtk_label_new
+        ("Use Wireshark keys, thus overwriting AirPcap adapter(s) ones.");
+    gtk_widget_set_name (keep_lb, "keep_lb");
+    gtk_widget_show (keep_lb);
+    gtk_table_attach (GTK_TABLE (radio_tb), keep_lb, 1, 2, 0, 1,
+                      (GtkAttachOptions) (GTK_FILL),
+                      (GtkAttachOptions) (0), 0, 0);
+    gtk_misc_set_alignment (GTK_MISC (keep_lb), 0, 0.5);
+
+    merge_lb = gtk_label_new ("Merge Wireshark and AirPcap adapter(s) keys.");
+    gtk_widget_set_name (merge_lb, "merge_lb");
+    gtk_widget_show (merge_lb);
+    gtk_table_attach (GTK_TABLE (radio_tb), merge_lb, 1, 2, 1, 2,
+                      (GtkAttachOptions) (GTK_FILL),
+                      (GtkAttachOptions) (0), 0, 0);
+    gtk_misc_set_alignment (GTK_MISC (merge_lb), 0, 0.5);
+
+    import_lb =
+        gtk_label_new
+        ("Use AirPcap adapter(s) keys, thus overwriting Wireshark ones.");
+    gtk_widget_set_name (import_lb, "import_lb");
+    gtk_widget_show (import_lb);
+    gtk_table_attach (GTK_TABLE (radio_tb), import_lb, 1, 2, 2, 3,
+                      (GtkAttachOptions) (GTK_FILL),
+                      (GtkAttachOptions) (0), 0, 0);
+    gtk_misc_set_alignment (GTK_MISC (import_lb), 0, 0.5);
+
+    ignore_lb =
+        gtk_label_new
+        ("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.");
+    gtk_widget_set_name (ignore_lb, "ignore_lb");
+    gtk_widget_show (ignore_lb);
+    gtk_table_attach (GTK_TABLE (radio_tb), ignore_lb, 1, 2, 3, 4,
+                      (GtkAttachOptions) (GTK_FILL),
+                      (GtkAttachOptions) (0), 0, 0);
+    gtk_label_set_line_wrap (GTK_LABEL (ignore_lb), TRUE);
+    gtk_misc_set_alignment (GTK_MISC (ignore_lb), 0, 0.5);
+
+    low_h_button_box = gtk_hbutton_box_new ();
+    gtk_widget_set_name (low_h_button_box, "low_h_button_box");
+    gtk_widget_show (low_h_button_box);
+    gtk_box_pack_start (GTK_BOX (main_v_box), low_h_button_box, FALSE, FALSE,
+                        0);
+    gtk_button_box_set_layout (GTK_BUTTON_BOX (low_h_button_box),
+                               GTK_BUTTONBOX_SPREAD);
+
+    ok_bt = gtk_button_new_with_mnemonic ("OK");
+    gtk_widget_set_name (ok_bt, "ok_bt");
+    gtk_widget_show (ok_bt);
+    gtk_container_add (GTK_CONTAINER (low_h_button_box), ok_bt);
+#if GTK_CHECK_VERSION(2,18,0)
+    gtk_widget_set_can_default (ok_bt, TRUE);
+#else
+    GTK_WIDGET_SET_FLAGS (ok_bt, GTK_CAN_DEFAULT);
+#endif
+
+    cancel_bt = gtk_button_new_with_mnemonic ("Cancel");
+    gtk_widget_set_name (cancel_bt, "cancel_bt");
+    gtk_widget_show (cancel_bt);
+    gtk_container_add (GTK_CONTAINER (low_h_button_box), cancel_bt);
+#if GTK_CHECK_VERSION(2,18,0)
+    gtk_widget_set_can_default (cancel_bt, TRUE);
+#else
+    GTK_WIDGET_SET_FLAGS (cancel_bt, GTK_CAN_DEFAULT);
+#endif
+
+    /* Store pointers to all widgets, for use by lookup_widget(). */
+    g_signal_connect (ok_bt, "clicked", G_CALLBACK(on_keys_check_ok_bt_clicked), keys_check_w);
+    g_signal_connect (cancel_bt, "clicked", G_CALLBACK(on_keys_check_cancel_bt_clicked), keys_check_w);
+    g_signal_connect (keys_check_w, "destroy", G_CALLBACK(on_keys_check_w_destroy), keys_check_w);
+
+    /* Store pointers to all widgets, for use by lookup_widget(). */
+    g_object_set_data(G_OBJECT(keys_check_w),AIRPCAP_CHECK_WINDOW_KEY,w);
+    g_object_set_data(G_OBJECT(keys_check_w),AIRPCAP_CHECK_WINDOW_RADIO_MERGE_KEY,merge_rb);
+    g_object_set_data(G_OBJECT(keys_check_w),AIRPCAP_CHECK_WINDOW_RADIO_KEEP_KEY,keep_rb);
+    g_object_set_data(G_OBJECT(keys_check_w),AIRPCAP_CHECK_WINDOW_RADIO_IMPORT_KEY,import_rb);
+    g_object_set_data(G_OBJECT(keys_check_w),AIRPCAP_CHECK_WINDOW_RADIO_IGNORE_KEY,ignore_rb);
+    g_object_set_data(G_OBJECT(keys_check_w),AIRPCAP_CHECK_WINDOW_RADIO_GROUP_KEY,radio_bt_group);
+
+    gtk_widget_set_sensitive(top_level,FALSE);
+    gtk_widget_show(keys_check_w);
+}
+
+
+#endif /* HAVE_AIRPCAP */
+
+/*
+ * Editor modelines
+ *
+ * Local Variables:
+ * c-basic-offset: 4
+ * tab-width: 8
+ * indent-tabs-mode: nil
+ * End:
+ *
+ * ex: set shiftwidth=4 tabstop=8 expandtab:
+ * :indentSize=4:tabSize=8:noTabs=true:
+ */