Add support for AirPcap, an upcoming wireless product from CACE. Support

is disabled by default, and can be enabled by setting AIRPCAP_CONFIG
in config.nmake.  The code is currently limited to Windows, but should
be adaptable to other platforms.

The official announcement won't come until next week, so you'll have to
read the source for details.  :)


git-svn-id: http://anonsvn.wireshark.org/wireshark/trunk@18928 f5534014-38df-0310-8fa8-9805f1628bb7

1 files changed, 1872 insertions, 0 deletions

diff --git a/gtk/airpcap_dlg.c b/gtk/airpcap_dlg.c
new file mode 100644
index 0000000000..e177956870
--- /dev/null
+++ b/gtk/airpcap_dlg.c
@@ -0,0 +1,1872 @@
+/* airpcap_dlg.c
+ *
+ * $Id$
+ *
+ * Ulf Lamping <ulf.lamping@web.de>
+ *
+ * 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.h>
+
+#include <string.h>
+
+#include <epan/filesystem.h>
+
+#include "gtk/main.h"
+#include "dlg_utils.h"
+#include "gui_utils.h"
+#include "simple_dialog.h"
+#include "dfilter_expr_dlg.h"
+#include "compat_macros.h"
+#include "gtkglobals.h"
+#include "help_dlg.h"
+
+#include <airpcap.h>
+#include "airpcap_loader.h"
+#include "airpcap_gui_utils.h"
+#include "airpcap_dlg.h"
+
+#include "keys.h"
+
+/* temporary block signals to widgets */
+BOOL block_advanced_signals;
+
+/*
+ * This struct will contain useful data for the selected (actual) airpcap device
+ */
+void
+airpcap_fill_if_combo(GtkWidget *combo, GList* if_list)
+{
+int ifn = 0;
+GList* popdown_if_list = NULL;
+GList* curr = NULL;
+airpcap_if_info_t* if_info = NULL;
+
+	curr = g_list_nth(if_list, ifn);
+	if_info = NULL;
+	if(curr != NULL) if_info = curr->data;
+
+	popdown_if_list = NULL;
+	ifn = g_list_length(if_list) - 1;
+	while(ifn >= 0) /* reverse order */
+		{
+		curr = g_list_nth(if_list, ifn);
+		if_info = NULL;
+		if(curr != NULL)
+			if_info = curr->data;
+		if(if_info != NULL)
+			popdown_if_list = g_list_append( popdown_if_list , if_info->description) ;
+		ifn--;
+		}
+	gtk_combo_set_popdown_strings( GTK_COMBO(combo), popdown_if_list) ;
+
+	if(airpcap_if_selected != NULL)
+		{
+		gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(combo)->entry), airpcap_if_selected->description);
+		}
+	else
+		{
+		gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(combo)->entry), "No Wireless Interfaces Found");
+		}
+}
+
+/*
+ * Callback for the crc chackbox
+ */
+static void
+crc_check_cb(GtkWidget *w, gpointer user_data)
+{
+if( !block_advanced_signals && (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
+wrong_crc_combo_cb(GtkWidget *w, gpointer data)
+{
+const gchar *s;
+
+s = gtk_entry_get_text(GTK_ENTRY(data));
+
+if( !block_advanced_signals && (data != NULL) && (w != NULL) )
+	{
+	if((g_strcasecmp("",s)))
+		{
+		airpcap_if_selected->CrcValidationOn = airpcap_get_validation_type(s);
+		airpcap_if_selected->saved = FALSE;
+		}
+	}
+}
+
+/*
+ * Changed callback for the channel combobox
+ */
+static void
+channel_changed_cb(GtkWidget *w _U_, gpointer data)
+{
+const gchar *s;
+
+  s = gtk_entry_get_text(GTK_ENTRY(data));
+
+if( !block_advanced_signals && (data != NULL) && (w != NULL) )
+	{
+	s = gtk_entry_get_text(GTK_ENTRY(data));
+	if((g_strcasecmp("",s)))
+		{
+		if(airpcap_if_selected != NULL)
+			{
+			airpcap_if_selected->channel = airpcap_get_channel_number(s);
+			airpcap_if_selected->saved = FALSE;
+			}
+		}
+	}
+}
+
+/*
+ * Changed callback for the link layer combobox
+ */
+static void
+link_type_changed_cb(GtkWidget *w _U_, gpointer data)
+{
+const gchar *s;
+
+s = gtk_entry_get_text(GTK_ENTRY(data));
+
+if( !block_advanced_signals && (data != NULL) && (w != NULL) )
+	{
+	if((g_strcasecmp("",s)))
+		{
+		airpcap_if_selected->linkType = airpcap_get_link_type(s);
+		airpcap_if_selected->saved = FALSE;
+		}
+	}
+}
+
+/*
+ * Activate callback for the adapter combobox
+ */
+static void
+combo_if_activate_cb(GtkWidget *entry _U_, gpointer data)
+{
+}
+
+/*
+ * Changed callback for the adapter combobox
+ */
+static void
+airpcap_advanced_combo_if_changed_cb(GtkWidget *w _U_, gpointer data)
+{
+const gchar* s = NULL;
+
+s = gtk_entry_get_text(GTK_ENTRY(w));
+
+if((g_strcasecmp("",s)))
+	{
+  /* We are trying to change the interface to set up...*/
+  /* Check if the current interface settings need to be SAVED! */
+  if( (airpcap_if_selected != NULL) && !block_advanced_signals)
+		{
+		if( (airpcap_if_selected->saved) ) /* Just change interface */
+			{
+			/* No changes for this interface, no need to save anything */
+			airpcap_change_if(w,data);
+			}
+		else
+			{
+			/* Popup a dialog to ask if user wants to save settings for selected
+			 * interface before changing it...
+			 */
+			airpcap_ask_for_save(w,data);
+			}
+		}
+	}
+}
+
+/*
+ * Takes the keys from the GtkList widget, and add them to the interface list
+ */
+void
+airpcap_add_keys_from_list(GtkWidget *keylist, airpcap_if_info_t *if_info)
+{
+GtkWidget	*key_ls;
+
+GString		*new_key;
+
+gchar		*text_entered = NULL;
+
+GtkWidget	*nl_item,*nl_lb;
+
+GList		*list,
+			*children;
+
+/* airpcap stuff */
+UINT i, j;
+gchar s[3];
+PAirpcapKeysCollection KeysCollection;
+ULONG KeysCollectionSize;
+UCHAR KeyByte;
+
+UINT keys_in_list = 0;
+
+key_ls	= keylist;
+
+keys_in_list = (UINT)g_list_length(GTK_LIST(key_ls)->children);
+
+if(keys_in_list > 0)
+{
+	/*
+	 * Save the encryption keys, if we have any of them
+	 */
+	KeysCollectionSize = 0;
+
+	/*
+	 * Calculate the size of the keys collection
+	 */
+	KeysCollectionSize = sizeof(AirpcapKeysCollection) + keys_in_list * sizeof(AirpcapKey);
+
+	/*
+	 * Allocate the collection
+	 * We use malloc so it's easier to reuse the code in C programs
+	 */
+	KeysCollection = (PAirpcapKeysCollection)malloc(KeysCollectionSize);
+	if(!KeysCollection)
+	{
+		/* Simple dialog ERROR */
+		simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"%s","Failed mamory allocation for KeysCollection!");
+		return;
+	}
+
+	/*
+	 * Populate the key collection
+	 */
+	list = GTK_LIST(key_ls)->children;
+	KeysCollection->nKeys = keys_in_list;
+
+	for(i = 0; i < keys_in_list; i++)
+	{
+		KeysCollection->Keys[i].KeyType = AIRPCAP_KEYTYPE_WEP;
+
+		/* Retrieve the Item corresponding to the i-th key */
+		nl_item = g_list_nth_data(list, i);
+		children = gtk_container_children(GTK_CONTAINER(nl_item));
+		nl_lb = g_list_nth_data(children,0);
+		new_key = g_string_new(GTK_LABEL(nl_lb)->label);
+
+		KeysCollection->Keys[i].KeyLen = new_key->len / 2;
+		memset(&KeysCollection->Keys[i].KeyData, 0, sizeof(KeysCollection->Keys[i].KeyData));
+
+		for(j = 0 ; j < new_key->len; j += 2)
+		{
+			s[0] = new_key->str[j];
+			s[1] = new_key->str[j+1];
+			s[2] = '\0';
+			KeyByte = (UCHAR)strtol(s, NULL, 16);
+			KeysCollection->Keys[i].KeyData[j / 2] = KeyByte;
+		}
+	}
+
+	/*
+	 * XXX - Free the old adapter key collection!
+	 */
+	if(airpcap_if_selected->keysCollection != NULL)
+		g_free(airpcap_if_selected->keysCollection);
+
+	/*
+	 * Set this collection ad the new one
+	 */
+	airpcap_if_selected->keysCollection = KeysCollection;
+	airpcap_if_selected->keysCollectionSize = KeysCollectionSize;
+}
+}
+
+
+/*
+ * Pop-up window, used to ask the user if he wants to save the selected interface settings
+ * when closing the window.
+ */
+void
+airpcap_ask_for_save_before_closing(GtkWidget *w _U_, gpointer data)
+{
+	GtkWidget* dialog;
+
+    dialog = simple_dialog(ESD_TYPE_CONFIRMATION, ESD_BTNS_SAVE_DONTSAVE_CANCEL,
+                PRIMARY_TEXT_START "Save settings before closing?" PRIMARY_TEXT_END "\n\n"
+                "If you close the window without saving, changes you made will\nbe discarded.");
+    simple_dialog_set_cb(dialog, airpcap_dialog_save_before_closing_cb, data);
+}
+
+/* user confirmed the "Save settings..." dialog */
+void
+airpcap_dialog_save_before_closing_cb(gpointer dialog _U_, gint btn, gpointer data)
+{
+GtkWidget* interface_combo;
+GtkWidget* key_ls;
+
+/* I need the combo box entry */
+interface_combo		= GTK_WIDGET(OBJECT_GET_DATA(GTK_WIDGET(data),AIRPCAP_ADVANCED_INTERFACE_KEY));
+key_ls				= GTK_WIDGET(OBJECT_GET_DATA(data,AIRPCAP_ADVANCED_KEYLIST_KEY));
+
+    switch(btn) {
+    case(ESD_BTN_SAVE):
+        /* save interface and exit  */
+		airpcap_add_keys_from_list(key_ls,airpcap_if_selected);
+		airpcap_save_selected_if_configuration(airpcap_if_selected);
+		/* Remove gtk timeout */
+		gtk_timeout_remove(airpcap_if_selected->tag);
+        break;
+    case(ESD_BTN_DONT_SAVE):
+        /* exit without saving */
+        break;
+
+    default:
+		break;
+    }
+}
+
+/*
+ * Pop-up window, used to ask the user if he wants to save the selected interface settings
+ * when changing the interface in the advanced dialog box
+ */
+void
+airpcap_ask_for_save(GtkWidget *entry _U_, gpointer data)
+{
+	GtkWidget* dialog;
+
+    dialog = simple_dialog(ESD_TYPE_CONFIRMATION, ESD_BTNS_SAVE_DONTSAVE_CANCEL,
+                PRIMARY_TEXT_START "Save settings before changing interface?" PRIMARY_TEXT_END "\n\n"
+                "If you change interface without saving, changes you made will\nbe discarded.");
+    simple_dialog_set_cb(dialog, airpcap_dialog_save_cb, data);
+
+}
+
+/* user confirmed the "Save settings..." dialog */
+void
+airpcap_dialog_save_cb(GtkWidget* dialog _U_, gint btn, gpointer data)
+{
+GtkWidget* interface_combo;
+GtkWidget* key_ls;
+
+/* I need the combo box entry */
+interface_combo		= GTK_WIDGET(OBJECT_GET_DATA(GTK_WIDGET(data),AIRPCAP_ADVANCED_INTERFACE_KEY));
+key_ls				= GTK_WIDGET(OBJECT_GET_DATA(data,AIRPCAP_ADVANCED_KEYLIST_KEY));
+
+    switch(btn) {
+    case(ESD_BTN_SAVE):
+        /* save interface and change  */
+		airpcap_add_keys_from_list(key_ls,airpcap_if_selected);
+		airpcap_save_selected_if_configuration(airpcap_if_selected);
+		/* Remove gtk timeout */
+		gtk_timeout_remove(airpcap_if_selected->tag);
+		airpcap_change_if(GTK_COMBO(interface_combo)->entry,data);
+        break;
+    case(ESD_BTN_DONT_SAVE):
+        /* change interface without saving */
+		airpcap_change_if(GTK_COMBO(interface_combo)->entry,data);
+        break;
+    case(ESD_BTN_CANCEL):
+		/* don't change interface and don't save */
+        break;
+    default:
+		break;
+    }
+}
+
+/*
+ * Function used to change the selected interface and advanced dialog box
+ */
+void
+airpcap_change_if(GtkWidget *entry _U_, gpointer data)
+{
+  const gchar *s;
+  gchar *channel_s;
+  gchar *capture_s;
+  GtkWidget *main_w;
+
+  GtkWidget *interface_combo;
+  GtkWidget *channel_combo;
+  GtkWidget *capture_combo;
+  GtkWidget *crc_check;
+  GtkWidget *wrong_crc_combo;
+  GtkWidget *blink_bt;
+  GtkWidget *key_ls;
+
+  airpcap_if_info_t *new_if;
+
+  /* Retrieve the GUI object pointers */
+  main_w = GTK_WIDGET(data);
+  interface_combo   = GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_INTERFACE_KEY));
+  channel_combo		= GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_CHANNEL_KEY));
+  capture_combo		= GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_LINK_TYPE_KEY));
+  crc_check			= GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_CRC_KEY));
+  wrong_crc_combo	= GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_WRONG_CRC_KEY));
+  blink_bt			= GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_BLINK_KEY));
+  key_ls			= GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_KEYLIST_KEY));
+
+  s = gtk_entry_get_text(GTK_ENTRY(entry));
+
+  /* Select actual interface*/
+  new_if = get_airpcap_if_from_description(airpcap_if_list, s);
+
+  /* And change the GUI according to it... */
+  /* This should always happen, but it seems that the callback is
+   * called twice, the first time with an 'empty' text... so it
+   * will return NULL!
+   */
+  if(new_if != NULL)
+	{
+	airpcap_if_selected = new_if;
+
+	new_if = NULL;
+	/* I need to 'block' signals to widgets or they will receive a signal now
+	   and will change twice */
+	block_advanced_signals = TRUE;
+
+	/* Blink button */
+	if(airpcap_if_selected->blinking)
+		{
+		#if GTK_MAJOR_VERSION >= 2
+		gtk_button_set_label(GTK_BUTTON(blink_bt),"Stop Blinking");
+		#else
+		gtk_label_set_text(GTK_LABEL(GTK_BIN(blink_bt)->child),"Stop Blinking");
+		#endif
+		}
+	else
+		{
+		#if GTK_MAJOR_VERSION >= 2
+		gtk_button_set_label(GTK_BUTTON(blink_bt),"  Blink Led  ");
+		#else
+		gtk_label_set_text(GTK_LABEL(GTK_BIN(blink_bt)->child),"  Blink Led  ");
+		#endif
+		}
+
+	/* Channel combo */
+	channel_s = g_strdup_printf("%d",airpcap_if_selected->channel);
+	if(channel_combo != NULL) /* this event seems to happen when combo is still NULL */
+		gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(channel_combo)->entry), channel_s);
+
+	/* Link Layer combo */
+	capture_s = NULL;
+	if(airpcap_if_selected->linkType == AIRPCAP_LT_802_11)
+		{
+			capture_s = g_strdup_printf(AIRPCAP_LINK_TYPE_NAME_802_11_ONLY);
+			if(capture_combo != NULL) /* this event seems to happen when combo is still NULL */
+				gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(capture_combo)->entry), capture_s);
+		}
+	else if(airpcap_if_selected->linkType == AIRPCAP_LT_802_11_PLUS_RADIO)
+		{
+			capture_s = g_strdup_printf(AIRPCAP_LINK_TYPE_NAME_802_11_PLUS_RADIO);
+			if(capture_combo != NULL) /* this event seems to happen when combo is still NULL */
+				gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(capture_combo)->entry), capture_s);
+		}
+
+	/* Fcs Presence check box */
+	if(airpcap_if_selected->IsFcsPresent)
+		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(crc_check),TRUE);
+	else
+		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(crc_check),FALSE);
+
+	/* Wrong Crc combo box */
+	if(airpcap_if_selected->CrcValidationOn == AIRPCAP_VT_ACCEPT_EVERYTHING)
+		gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(wrong_crc_combo)->entry),AIRPCAP_VALIDATION_TYPE_NAME_ALL);
+	else if(airpcap_if_selected->CrcValidationOn == AIRPCAP_VT_ACCEPT_CORRECT_FRAMES)
+		gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(wrong_crc_combo)->entry),AIRPCAP_VALIDATION_TYPE_NAME_CORRECT);
+	else if(airpcap_if_selected->CrcValidationOn == AIRPCAP_VT_ACCEPT_CORRUPT_FRAMES)
+		gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(wrong_crc_combo)->entry),AIRPCAP_VALIDATION_TYPE_NAME_CORRUPT);
+
+	/* Remove old keys */
+	gtk_list_remove_items(GTK_LIST(key_ls),GTK_LIST(key_ls)->children);
+	/* Add new keys */
+	airpcap_fill_key_list(key_ls,airpcap_if_selected);
+
+	/* Enable the signals again */
+	block_advanced_signals = FALSE;
+	}
+}
+
+/*
+ * Thread function used to blink the led
+ */
+void update_blink(gpointer data _U_)
+{
+airpcap_if_info_t* sel;
+PAirpcapHandle ad;
+char* ebuf = NULL;
+
+sel = (airpcap_if_info_t*)data;
+
+ad = airpcap_if_open(get_airpcap_name_from_description(airpcap_if_list, sel->description), 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);
+	}
+}
+
+/*
+ * Blink button callback
+ */
+void
+blink_cb( GtkWidget *blink_bt _U_, gpointer if_data )
+{
+PAirpcapHandle ad = NULL;
+char* ebuf = NULL;
+
+if(airpcap_if_selected != NULL)
+	if(!(airpcap_if_selected->blinking))
+		{
+		#if GTK_MAJOR_VERSION >= 2
+		gtk_button_set_label(GTK_BUTTON(blink_bt),"Stop Blinking");
+		#else
+		gtk_label_set_text(GTK_LABEL(GTK_BIN(blink_bt)->child),"Stop Blinking");
+		#endif
+		airpcap_if_selected->tag = gtk_timeout_add(500, (GtkFunction)update_blink,airpcap_if_selected);
+		airpcap_if_selected->blinking = TRUE;
+		}
+	else
+		{
+		#if GTK_MAJOR_VERSION >= 2
+		gtk_button_set_label(GTK_BUTTON(blink_bt),"  Blink Led  ");
+		#else
+		gtk_label_set_text(GTK_LABEL(GTK_BIN(blink_bt)->child),"  Blink Led  ");
+		#endif
+		gtk_timeout_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)
+			{
+			gtk_timeout_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);
+			}
+		}
+}
+
+/* the window was closed, cleanup things */
+static void
+airpcap_if_destroy_cb(GtkWidget *w _U_, gpointer user_data _U_)
+{
+	PAirpcapHandle ad = NULL;
+	char* ebuf = NULL;
+
+	/* Retrieve object data */
+    GtkWidget *main_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;
+	GtkWidget *key_ls;
+
+	/* widgets in the toolbar */
+	GtkWidget	*toolbar,
+				*toolbar_if_lb,
+				*toolbar_channel_cm,
+				*toolbar_wrong_crc_cm,
+				*toolbar_decryption_ck,
+				*advanced_bt;
+
+	gint *from_widget = NULL;
+
+    /* Retrieve the GUI object pointers */
+    main_w = GTK_WIDGET(user_data);
+	interface_combo		= GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_INTERFACE_KEY));
+    channel_combo		= GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_CHANNEL_KEY));
+    capture_combo		= GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_LINK_TYPE_KEY));
+    crc_check			= GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_CRC_KEY));
+    wrong_crc_combo		= GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_WRONG_CRC_KEY));
+    blink_bt			= GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_BLINK_KEY));
+	cancel_bt			= GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_CANCEL_KEY));
+	ok_bt				= GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_OK_KEY));
+	key_ls				= GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_KEYLIST_KEY));
+	advanced_bt			= GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_KEY));
+
+	toolbar = GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_TOOLBAR_KEY));
+
+	/* retrieve toolbar info */
+	toolbar_if_lb			= GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_INTERFACE_KEY));
+	toolbar_channel_cm		= GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_CHANNEL_KEY));
+	toolbar_wrong_crc_cm	= GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_WRONG_CRC_KEY));
+	toolbar_decryption_ck	= GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_DECRYPTION_KEY));
+
+	from_widget	= (gint*)OBJECT_GET_DATA(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);
+
+	/* 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)
+		{
+		gtk_timeout_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);
+		}
+	}
+
+	/* See if the 'Cancel' button was pressed or not
+	 * if button is pressed, don't save configuration!
+	 */
+	if(GTK_BUTTON(cancel_bt)->in_button)
+		{
+		/* 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);
+			}
+
+		/* NULL to everything */
+		main_w = NULL;
+		blink_bt = NULL;
+		channel_combo = NULL;
+		interface_combo = NULL;
+		capture_combo = NULL;
+		crc_check = NULL;
+		wrong_crc_combo = NULL;
+
+		/* ... */
+		/* 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);
+
+		g_free(from_widget);
+		return;
+		}
+	else if(GTK_BUTTON(ok_bt)->in_button)
+		{
+
+		/* ??? - Ask if want to save configuration */
+
+		/* Save the configuration */
+		airpcap_add_keys_from_list(key_ls,airpcap_if_selected);
+		airpcap_save_selected_if_configuration(airpcap_if_selected);
+		/* Remove gtk timeout */
+		gtk_timeout_remove(airpcap_if_selected->tag);
+
+		/* Update toolbar (only if airpcap_if_selected is airpcap_if_active)*/
+		if( g_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_channel_combo_set_by_number(toolbar_channel_cm,airpcap_if_selected->channel);
+			airpcap_validation_type_combo_set_by_type(toolbar_wrong_crc_cm,airpcap_if_selected->CrcValidationOn);
+
+			gtk_signal_handler_block_by_func (GTK_OBJECT(toolbar_decryption_ck),GTK_SIGNAL_FUNC(airpcap_toolbar_encryption_cb), toolbar);
+			if(airpcap_if_active->DecryptionOn == AIRPCAP_DECRYPTION_ON)
+				gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toolbar_decryption_ck),TRUE);
+			else
+				gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toolbar_decryption_ck),FALSE);
+			gtk_signal_handler_unblock_by_func (GTK_OBJECT(toolbar_decryption_ck),GTK_SIGNAL_FUNC(airpcap_toolbar_encryption_cb), toolbar);
+			}
+
+		/* If interface active is airpcap, set sensitive TRUE for airpcap toolbar */
+		if( get_airpcap_if_by_name(airpcap_if_list,airpcap_if_active->description) != NULL)
+			{
+			airpcap_set_toolbar_start_capture(airpcap_if_active);
+			}
+		else
+			{
+			airpcap_set_toolbar_stop_capture(airpcap_if_active);
+			}
+
+			/* NULL to everything */
+			main_w = NULL;
+			blink_bt = NULL;
+			channel_combo = NULL;
+			interface_combo = NULL;
+			capture_combo = NULL;
+			crc_check = NULL;
+			wrong_crc_combo = NULL;
+
+				/* ... */
+		/* gray out the toolbar (if we came here from the toolbar advanced button)*/
+		if( *from_widget == AIRPCAP_ADVANCED_FROM_OPTIONS)
+			gtk_widget_set_sensitive(toolbar,FALSE);
+
+		g_free(from_widget);
+		return;
+		}
+
+		/* 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.
+ */
+static void
+airpcap_advanced_apply_cb(GtkWidget *button, gpointer data _U_)
+{
+	/* advenced window */
+	GtkWidget	*main_w;
+
+	/* widgets in the toolbar */
+	GtkWidget	*toolbar,
+				*toolbar_if_lb,
+				*toolbar_channel_cm,
+				*toolbar_wrong_crc_cm,
+				*toolbar_decryption_ck;
+
+	GtkWidget   *key_ls;
+
+	/* retrieve main window */
+	main_w = GTK_WIDGET(data);
+	key_ls	= GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_KEYLIST_KEY));
+
+	toolbar = GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_TOOLBAR_KEY));
+
+	/* retrieve toolbar info */
+	toolbar_if_lb			= GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_INTERFACE_KEY));
+	toolbar_channel_cm		= GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_CHANNEL_KEY));
+	toolbar_wrong_crc_cm	= GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_WRONG_CRC_KEY));
+	toolbar_decryption_ck	= GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_DECRYPTION_KEY));
+
+	/* Save the configuration */
+	airpcap_add_keys_from_list(key_ls,airpcap_if_selected);
+	airpcap_save_selected_if_configuration(airpcap_if_selected);
+
+	/* Update toolbar (only if airpcap_if_selected is airpcap_if_active)*/
+	if( g_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_channel_combo_set_by_number(toolbar_channel_cm,airpcap_if_selected->channel);
+		airpcap_validation_type_combo_set_by_type(toolbar_wrong_crc_cm,airpcap_if_selected->CrcValidationOn);
+
+     	gtk_signal_handler_block_by_func (GTK_OBJECT(toolbar_decryption_ck),GTK_SIGNAL_FUNC(airpcap_toolbar_encryption_cb), toolbar);
+		if(airpcap_if_active->DecryptionOn == AIRPCAP_DECRYPTION_ON)
+			gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toolbar_decryption_ck),TRUE);
+		else
+			gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toolbar_decryption_ck),FALSE);
+		gtk_signal_handler_unblock_by_func (GTK_OBJECT(toolbar_decryption_ck),GTK_SIGNAL_FUNC(airpcap_toolbar_encryption_cb), toolbar);
+		}
+}
+
+/*
+ * Callback for the 'Ok' button.
+ */
+static void
+airpcap_advanced_ok_cb(GtkWidget *w, gpointer data _U_)
+{
+	/* advenced window */
+	GtkWidget	*main_w;
+
+	/* widgets in the toolbar */
+	GtkWidget	*toolbar,
+				*toolbar_if_lb,
+				*toolbar_channel_cm,
+				*toolbar_wrong_crc_cm,
+				*toolbar_decryption_ck;
+
+	GtkWidget	*key_ls;
+
+	/* retrieve main window */
+	main_w = GTK_WIDGET(data);
+
+	toolbar = GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_TOOLBAR_KEY));
+
+	key_ls	= GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_KEYLIST_KEY));
+
+	/* retrieve toolbar info */
+	toolbar_if_lb			= GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_INTERFACE_KEY));
+	toolbar_channel_cm		= GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_CHANNEL_KEY));
+	toolbar_wrong_crc_cm	= GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_WRONG_CRC_KEY));
+	toolbar_decryption_ck	= GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_DECRYPTION_KEY));
+
+	/* Save the configuration */
+	airpcap_add_keys_from_list(key_ls,airpcap_if_selected);
+	airpcap_save_selected_if_configuration(airpcap_if_selected);
+	/* Remove gtk timeout */
+	gtk_timeout_remove(airpcap_if_selected->tag);
+
+	/* Update toolbar (only if airpcap_if_selected is airpcap_if_active)*/
+	if( g_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_channel_combo_set_by_number(toolbar_channel_cm,airpcap_if_selected->channel);
+		airpcap_validation_type_combo_set_by_type(toolbar_wrong_crc_cm,airpcap_if_selected->CrcValidationOn);
+
+     	gtk_signal_handler_block_by_func (GTK_OBJECT(toolbar_decryption_ck),GTK_SIGNAL_FUNC(airpcap_toolbar_encryption_cb), toolbar);
+		if(airpcap_if_active->DecryptionOn == AIRPCAP_DECRYPTION_ON)
+			gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toolbar_decryption_ck),TRUE);
+		else
+			gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toolbar_decryption_ck),FALSE);
+		gtk_signal_handler_unblock_by_func (GTK_OBJECT(toolbar_decryption_ck),GTK_SIGNAL_FUNC(airpcap_toolbar_encryption_cb), toolbar);
+		}
+}
+
+/*
+ * Callback for the 'Reset Configuration' button.
+ */
+static void
+airpcap_advanced_reset_configuration_cb(GtkWidget *button, gpointer data _U_)
+{
+
+}
+
+/*
+ * Callback for the 'About' button.
+ */
+static void
+airpcap_advanced_about_cb(GtkWidget *button, gpointer data _U_)
+{
+	/* retrieve toolbar info */
+}
+
+/*
+ * Callback used to add a WEP key in the add new key box;
+ */
+static void
+add_key(GtkWidget *widget, gpointer data _U_)
+{
+GtkWidget	*text,
+			*key_ls,
+			*ok_bt;
+
+GString		*new_key;
+
+gchar		*text_entered = NULL;
+
+int keys_in_list = 0;
+unsigned int i;
+
+text	= OBJECT_GET_DATA(GTK_WIDGET(data),AIRPCAP_ADVANCED_ADD_KEY_TEXT_KEY);
+ok_bt	= OBJECT_GET_DATA(GTK_WIDGET(data),AIRPCAP_ADVANCED_ADD_KEY_OK_KEY);
+key_ls	= OBJECT_GET_DATA(GTK_WIDGET(data),AIRPCAP_ADVANCED_KEYLIST_KEY);
+
+keys_in_list = g_list_length(GTK_LIST(key_ls)->children);
+text_entered = g_strdup(gtk_entry_get_text(GTK_ENTRY(text)));
+
+/* Too many keys? */
+if(keys_in_list == MAX_ENCRYPTION_KEYS)
+	{
+	simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"%s","Reached the Wep Keys Limit for this Interface.");
+	return;
+	}
+
+/* Check if key is correct */
+new_key = g_string_new(text_entered);
+
+g_strchug(new_key->str);
+g_strchomp(new_key->str);
+
+if((new_key->len % 2) != 0)
+	{
+	simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"%s","1) A Wep key must is an arbitrary length hexadecimal number.\nThe valid characters are: 0123456789ABCDEF.\nThe number of characters must be even.");
+	return;
+	}
+
+for(i = 0; i < new_key->len; i++)
+	{
+	if(!g_ascii_isxdigit(new_key->str[i]))
+		{
+		simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"%s","2) A Wep key must is an arbitrary length hexadecimal number.\nThe valid characters are: 0123456789ABCDEF.\nThe number of characters must be even.");
+		return;
+		}
+	}
+
+/* If so... Add key */
+airpcap_add_key_to_list(key_ls,new_key->str);
+
+airpcap_if_selected->saved = FALSE;
+
+g_string_free(new_key,TRUE);
+g_free(text_entered);
+
+window_destroy(GTK_WIDGET(data));
+return;
+}
+
+/*
+ * Callback used to add a WEP key in the edit key box;
+ */
+static void
+edit_key(GtkWidget *widget, gpointer data _U_)
+{
+GtkWidget	*text,
+			*key_ls,
+			*ok_bt;
+
+GString		*new_key;
+
+gchar		*text_entered = NULL;
+
+GtkWidget	*label;
+
+
+int keys_in_list = 0;
+unsigned int i;
+
+text	= OBJECT_GET_DATA(GTK_WIDGET(data),AIRPCAP_ADVANCED_EDIT_KEY_TEXT_KEY);
+ok_bt	= OBJECT_GET_DATA(GTK_WIDGET(data),AIRPCAP_ADVANCED_EDIT_KEY_OK_KEY);
+key_ls	= OBJECT_GET_DATA(GTK_WIDGET(data),AIRPCAP_ADVANCED_KEYLIST_KEY);
+label   = OBJECT_GET_DATA(GTK_WIDGET(data),AIRPCAP_ADVANCED_EDIT_KEY_LABEL_KEY);
+
+keys_in_list = g_list_length(GTK_LIST(key_ls)->children);
+text_entered = g_strdup(gtk_entry_get_text(GTK_ENTRY(text)));
+
+/* Check if key is correct */
+new_key = g_string_new(text_entered);
+
+g_strchug(new_key->str);
+g_strchomp(new_key->str);
+
+if((new_key->len % 2) != 0)
+	{
+	simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"%s","1) A Wep key must is an arbitrary length hexadecimal number.\nThe valid characters are: 0123456789ABCDEF.\nThe number of characters must be even.");
+	return;
+	}
+
+for(i = 0; i < new_key->len; i++)
+	{
+	if(!g_ascii_isxdigit(new_key->str[i]))
+		{
+		simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"%s","2) A Wep key must is an arbitrary length hexadecimal number.\nThe valid characters are: 0123456789ABCDEF.\nThe number of characters must be even.");
+		return;
+		}
+	}
+
+/* If so... modify key */
+gtk_label_set_text(GTK_LABEL(label),new_key->str);
+
+airpcap_if_selected->saved = FALSE;
+
+g_string_free(new_key,TRUE);
+g_free(text_entered);
+
+window_destroy(GTK_WIDGET(data));
+return;
+}
+
+/*
+ * Callback for the 'Add Key' button.
+ */
+static void
+airpcap_advanced_add_key_cb(GtkWidget *button, gpointer data _U_)
+{
+/* Window */
+GtkWidget	*add_key_w;
+
+/*  Frame */
+GtkWidget	*add_key_frame;
+
+/* Boxes */
+GtkWidget	*main_box,	/* vertical */
+			*key_box,	/* orizontal */
+			*text_box,  /* orizontal */
+			*button_box;/* orizontal (packed to end)*/
+
+/* Text Entry */
+GtkWidget	*key_text_entry;
+
+/* Buttons */
+GtkWidget	*key_ok_bt,
+			*key_cancel_bt;
+
+/* Key List Widget */
+GtkWidget	*key_ls;
+
+	/* Pop-up a new window */
+	add_key_w = window_new (GTK_WINDOW_TOPLEVEL,"Add a WEP Key");
+
+	/* Connect events */
+    SIGNAL_CONNECT(add_key_w, "delete_event",window_delete_event_cb, add_key_w);
+    SIGNAL_CONNECT(add_key_w, "destroy",add_key_w_destroy_cb, add_key_w);
+
+	/* Sets the border width of the window. */
+	gtk_container_set_border_width (GTK_CONTAINER (add_key_w), 5);
+
+	/* Retrieve the key list widget pointer, and add it to the add_key_w */
+	key_ls = OBJECT_GET_DATA(GTK_WIDGET(data),AIRPCAP_ADVANCED_KEYLIST_KEY);
+	OBJECT_SET_DATA(GTK_WIDGET(add_key_w),AIRPCAP_ADVANCED_KEYLIST_KEY,key_ls);
+	OBJECT_SET_DATA(GTK_WIDGET(add_key_w),AIRPCAP_ADVANCED_KEY,data);
+
+	/* Create boxes */
+	main_box = gtk_vbox_new(FALSE,1);
+	key_box = gtk_hbox_new(FALSE,1);
+	button_box = gtk_hbox_new(FALSE,1);
+	text_box = gtk_hbox_new(TRUE,1);
+
+	/* Add the two sub boxes to the main box */
+	gtk_box_pack_start(GTK_BOX(main_box), key_box, FALSE, FALSE, 1);
+	gtk_box_pack_start(GTK_BOX(main_box), button_box, FALSE, FALSE, 1);
+
+	/* Add the main box to the main window */
+	gtk_container_add(GTK_CONTAINER(add_key_w),main_box);
+
+	/* Crete key frame */
+	add_key_frame = gtk_frame_new("");
+	gtk_frame_set_label(GTK_FRAME(add_key_frame),"Key");
+	#if GTK_MAJOR_VERSION < 2
+	gtk_widget_set_usize( GTK_WIDGET(add_key_frame),
+                                  200,
+                                  -1 );
+	#else
+	gtk_widget_set_size_request( GTK_WIDGET(add_key_frame),
+                                  200,
+                                  -1 );
+    #endif
+
+	gtk_box_pack_start(GTK_BOX(key_box), add_key_frame, FALSE, FALSE, 1);
+
+	/* Create and Add text entry*/
+	key_text_entry = gtk_entry_new();
+	OBJECT_SET_DATA(add_key_w, AIRPCAP_ADVANCED_ADD_KEY_TEXT_KEY, key_text_entry);
+	SIGNAL_CONNECT(key_text_entry, "activate", add_key, add_key_w );
+	gtk_box_pack_start(GTK_BOX(text_box), key_text_entry, FALSE, FALSE, 1);
+	gtk_container_add(GTK_CONTAINER(add_key_frame),text_box);
+	gtk_container_set_border_width (GTK_CONTAINER (text_box), 5);
+
+	/* Create and add buttons */
+	key_ok_bt = gtk_button_new_with_label("OK");
+	SIGNAL_CONNECT(key_ok_bt, "clicked", add_key, add_key_w );
+	OBJECT_SET_DATA(add_key_w, AIRPCAP_ADVANCED_ADD_KEY_OK_KEY, key_ok_bt);
+		#if GTK_MAJOR_VERSION < 2
+	gtk_widget_set_usize( GTK_WIDGET(key_ok_bt),
+                                  50,
+                                  -1 );
+	#else
+	gtk_widget_set_size_request( GTK_WIDGET(key_ok_bt),
+                                  50,
+                                  -1 );
+    #endif
+	key_cancel_bt = gtk_button_new_with_label("Cancel");
+	SIGNAL_CONNECT(key_cancel_bt, "clicked", window_cancel_button_cb, add_key_w );
+		#if GTK_MAJOR_VERSION < 2
+	gtk_widget_set_usize( GTK_WIDGET(key_cancel_bt),
+                                  50,
+                                  -1 );
+	#else
+	gtk_widget_set_size_request( GTK_WIDGET(key_cancel_bt),
+                                  50,
+                                  -1 );
+    #endif
+
+	gtk_box_pack_end(GTK_BOX(button_box), key_cancel_bt, FALSE, FALSE, 1);
+	gtk_box_pack_end(GTK_BOX(button_box), key_ok_bt, FALSE, FALSE, 1);
+
+	/* Show all */
+	gtk_widget_show(key_ok_bt);
+	gtk_widget_show(key_cancel_bt);
+	gtk_widget_show(key_text_entry);
+	gtk_widget_show(add_key_frame);
+	gtk_widget_show(text_box);
+	gtk_widget_show(button_box);
+	gtk_widget_show(key_box);
+	gtk_widget_show(main_box);
+	gtk_widget_show(add_key_w);
+}
+
+/*
+ * Add key window destroy callback
+ */
+static void
+add_key_w_destroy_cb(GtkWidget *button, gpointer data _U_)
+{
+return;
+}
+
+/*
+ * Edit key window destroy callback
+ */
+static void
+edit_key_w_destroy_cb(GtkWidget *button, gpointer data _U_)
+{
+return;
+}
+
+/*
+ * Callback for the 'Remove Key' button.
+ */
+static void
+airpcap_advanced_remove_key_cb(GtkWidget *button, gpointer data _U_)
+{
+GtkList *key_ls;
+GtkWidget *label;
+GList *item = NULL;
+gint n;
+
+/* retrieve key list */
+key_ls = GTK_LIST(data);
+
+/* Remove selected keys*/
+if(key_ls->selection != NULL)
+	{
+	item = g_list_nth(key_ls->selection,0);
+	if(item != NULL)
+		{
+		n = gtk_list_child_position(key_ls,item->data);
+		label = GTK_BIN(item->data)->child;
+		gtk_list_clear_items(key_ls,n,n+1);
+		}
+	}
+
+/* Need to save config... */
+airpcap_if_selected->saved = FALSE;
+}
+
+/*
+ * Callback for the 'Edit Key' button.
+ */
+static void
+airpcap_advanced_edit_key_cb(GtkWidget *button, gpointer data _U_)
+{
+/* Window */
+GtkWidget	*edit_key_w;
+
+/*  Frame */
+GtkWidget	*edit_key_frame;
+
+/* Boxes */
+GtkWidget	*main_box,	/* vertical */
+			*key_box,	/* orizontal */
+			*text_box,  /* orizontal */
+			*button_box;/* orizontal (packed to end)*/
+
+/* Text Entry */
+GtkWidget	*key_text_entry;
+
+/* Buttons */
+GtkWidget	*key_ok_bt,
+			*key_cancel_bt;
+
+/* Key List Widget */
+GtkWidget	*key_ls;
+
+GtkWidget *label;
+GList *item = NULL;
+gint n;
+
+/* Retrieve the key list widget pointer, and add it to the edit_key_w */
+key_ls = OBJECT_GET_DATA(GTK_WIDGET(data),AIRPCAP_ADVANCED_KEYLIST_KEY);
+
+/*
+ * Check if a key has been selected. If not, just do nothing.
+ */
+if(GTK_LIST(key_ls)->selection != NULL)
+    {
+    item = g_list_nth(GTK_LIST(key_ls)->selection,0);
+    if(item != NULL)
+    	{
+    	/* Pop-up a new window */
+    	edit_key_w = window_new (GTK_WINDOW_TOPLEVEL,"Edit a WEP Key");
+
+    	/* Connect events */
+        SIGNAL_CONNECT(edit_key_w, "delete_event",window_delete_event_cb, edit_key_w);
+        SIGNAL_CONNECT(edit_key_w, "destroy",edit_key_w_destroy_cb, edit_key_w);
+
+    	/* Sets the border width of the window. */
+    	gtk_container_set_border_width (GTK_CONTAINER (edit_key_w), 5);
+
+    	OBJECT_SET_DATA(GTK_WIDGET(edit_key_w),AIRPCAP_ADVANCED_KEYLIST_KEY,key_ls);
+    	OBJECT_SET_DATA(GTK_WIDGET(edit_key_w),AIRPCAP_ADVANCED_KEY,data);
+
+    	/* Create boxes */
+    	main_box = gtk_vbox_new(FALSE,1);
+    	key_box = gtk_hbox_new(FALSE,1);
+    	button_box = gtk_hbox_new(FALSE,1);
+    	text_box = gtk_hbox_new(TRUE,1);
+
+    	/* Add the two sub boxes to the main box */
+    	gtk_box_pack_start(GTK_BOX(main_box), key_box, FALSE, FALSE, 1);
+    	gtk_box_pack_start(GTK_BOX(main_box), button_box, FALSE, FALSE, 1);
+
+    	/* Add the main box to the main window */
+    	gtk_container_add(GTK_CONTAINER(edit_key_w),main_box);
+
+    	/* Crete key frame */
+    	edit_key_frame = gtk_frame_new("");
+    	gtk_frame_set_label(GTK_FRAME(edit_key_frame),"Key");
+    	#if GTK_MAJOR_VERSION < 2
+    	gtk_widget_set_usize( GTK_WIDGET(edit_key_frame),
+                                      200,
+                                      -1 );
+    	#else
+    	gtk_widget_set_size_request( GTK_WIDGET(edit_key_frame),
+                                      200,
+                                      -1 );
+        #endif
+
+    	gtk_box_pack_start(GTK_BOX(key_box), edit_key_frame, FALSE, FALSE, 1);
+
+    	/* Create and Add text entry*/
+    	key_text_entry = gtk_entry_new();
+    	/* Retrieve the currently selected entry */
+    	if(GTK_LIST(key_ls)->selection != NULL)
+    		{
+    		item = g_list_nth(GTK_LIST(key_ls)->selection,0);
+    		if(item != NULL)
+    			{
+    			n = gtk_list_child_position(GTK_LIST(key_ls),item->data);
+    			label = GTK_BIN(item->data)->child;
+    			/* Pass the pointer as data */
+    			OBJECT_SET_DATA(edit_key_w,AIRPCAP_ADVANCED_EDIT_KEY_LABEL_KEY,label);
+    			}
+    		}
+    	gtk_entry_set_text(GTK_ENTRY(key_text_entry),GTK_LABEL(label)->label);
+    	OBJECT_SET_DATA(edit_key_w, AIRPCAP_ADVANCED_EDIT_KEY_TEXT_KEY, key_text_entry);
+    	SIGNAL_CONNECT(key_text_entry, "activate", edit_key, edit_key_w );
+    	gtk_box_pack_start(GTK_BOX(text_box), key_text_entry, FALSE, FALSE, 1);
+    	gtk_container_add(GTK_CONTAINER(edit_key_frame),text_box);
+    	gtk_container_set_border_width (GTK_CONTAINER (text_box), 5);
+
+    	/* Create and add buttons */
+    	key_ok_bt = gtk_button_new_with_label("OK");
+    	SIGNAL_CONNECT(key_ok_bt, "clicked", edit_key, edit_key_w );
+    	OBJECT_SET_DATA(edit_key_w, AIRPCAP_ADVANCED_EDIT_KEY_OK_KEY, key_ok_bt);
+    		#if GTK_MAJOR_VERSION < 2
+    	gtk_widget_set_usize( GTK_WIDGET(key_ok_bt),
+                                      50,
+                                      -1 );
+    	#else
+    	gtk_widget_set_size_request( GTK_WIDGET(key_ok_bt),
+                                      50,
+                                      -1 );
+        #endif
+    	key_cancel_bt = gtk_button_new_with_label("Cancel");
+    	SIGNAL_CONNECT(key_cancel_bt, "clicked", window_cancel_button_cb, edit_key_w );
+    		#if GTK_MAJOR_VERSION < 2
+    	gtk_widget_set_usize( GTK_WIDGET(key_cancel_bt),
+                                      50,
+                                      -1 );
+    	#else
+    	gtk_widget_set_size_request( GTK_WIDGET(key_cancel_bt),
+                                      50,
+                                      -1 );
+        #endif
+
+    	gtk_box_pack_end(GTK_BOX(button_box), key_cancel_bt, FALSE, FALSE, 1);
+    	gtk_box_pack_end(GTK_BOX(button_box), key_ok_bt, FALSE, FALSE, 1);
+
+    	/* Show all */
+    	gtk_widget_show(key_ok_bt);
+    	gtk_widget_show(key_cancel_bt);
+    	gtk_widget_show(key_text_entry);
+    	gtk_widget_show(edit_key_frame);
+    	gtk_widget_show(text_box);
+    	gtk_widget_show(button_box);
+    	gtk_widget_show(key_box);
+    	gtk_widget_show(main_box);
+    	gtk_widget_show(edit_key_w);
+        }
+    }
+}
+
+/*
+ * Callback for the 'Move Key Up' button.
+ */
+static void
+airpcap_advanced_move_key_up_cb(GtkWidget *button, gpointer data _U_)
+{
+GtkList *key_ls;
+GtkWidget *label,*nl_lb,*nl_item;
+GList *new_list = NULL;
+GList *item = NULL;
+gint n;
+
+/* retrieve key list */
+key_ls = GTK_LIST(data);
+
+/* Remove selected keys*/
+if(key_ls->selection != NULL)
+	{
+	item = g_list_nth(key_ls->selection,0);
+	if(item != NULL)
+		{
+		n = gtk_list_child_position(key_ls,item->data);
+		if(n>0)
+			{
+			label = GTK_BIN(item->data)->child;
+			nl_lb = gtk_label_new(GTK_LABEL(label)->label);
+			gtk_list_clear_items(key_ls,n,n+1);
+			nl_item = gtk_list_item_new();
+			gtk_misc_set_alignment (GTK_MISC (nl_lb), 0.0, 0.5);
+			gtk_container_add(GTK_CONTAINER(nl_item), nl_lb);
+			gtk_widget_show(nl_lb);
+			gtk_widget_show(nl_item);
+			new_list = g_list_append(new_list,nl_item);
+			gtk_list_insert_items(key_ls,new_list,n-1);
+			gtk_list_select_item(key_ls,n-1);
+			}
+		}
+	}
+
+/* Need to save config... */
+airpcap_if_selected->saved = FALSE;
+}
+
+/*
+ * Callback for the 'Move Key Down' button.
+ */
+static void
+airpcap_advanced_move_key_down_cb(GtkWidget *button, gpointer data _U_)
+{
+GtkList *key_ls;
+GtkWidget *label,*nl_lb,*nl_item;
+GList *new_list = NULL;
+GList *item = NULL;
+unsigned int n;
+
+/* retrieve key list */
+key_ls = GTK_LIST(data);
+
+/* Remove selected keys*/
+if(key_ls->selection != NULL)
+	{
+	item = g_list_nth(key_ls->selection,0);
+	if(item != NULL)
+		{
+		n = gtk_list_child_position(key_ls,item->data);
+		if(n< (g_list_length(key_ls->children)-1))
+			{
+			label = GTK_BIN(item->data)->child;
+			nl_lb = gtk_label_new(GTK_LABEL(label)->label);
+			gtk_list_clear_items(key_ls,n,n+1);
+
+			nl_item = gtk_list_item_new();
+			gtk_misc_set_alignment (GTK_MISC (nl_lb), 0.0, 0.5);
+			gtk_container_add(GTK_CONTAINER(nl_item), nl_lb);
+			gtk_widget_show(nl_lb);
+			gtk_widget_show(nl_item);
+
+			new_list = g_list_append(new_list,nl_item);
+			gtk_list_insert_items(key_ls,new_list,n+1);
+			gtk_list_select_item(key_ls,n+1);
+			}
+		}
+	}
+
+/* Need to save config... */
+airpcap_if_selected->saved = FALSE;
+}
+
+/* Turns the decryption on or off */
+static void
+encryption_check_cb(GtkWidget *w, gpointer data)
+{
+if( !block_advanced_signals && (airpcap_if_selected != NULL))
+	{
+	if(airpcap_if_selected->DecryptionOn == AIRPCAP_DECRYPTION_ON)
+		{
+		airpcap_if_selected->DecryptionOn = AIRPCAP_DECRYPTION_OFF;
+		airpcap_if_selected->saved = FALSE;
+		}
+	else
+		{
+		airpcap_if_selected->DecryptionOn = AIRPCAP_DECRYPTION_ON;
+		airpcap_if_selected->saved = FALSE;
+		}
+	}
+}
+
+
+/* Called to create the airpcap settings' window */
+void
+display_airpcap_advanced_cb(GtkWidget *w, gpointer data)
+{
+	/* Main window */
+	GtkWidget   *airpcap_advanced_w;
+
+	/* Blink button */
+	GtkWidget	*blink_bt,
+				*channel_combo;
+	/* Combos */
+	GtkWidget	*interface_combo,
+				*capture_combo;
+
+	/* check */
+	GtkWidget   *wrong_crc_combo;
+
+	/* key list*/
+	GtkWidget   *key_ls;
+
+	/* frames */
+	GtkWidget   *interface_frame,
+				*basic_frame,
+				*wep_frame;
+	/* boxes */
+	GtkWidget	*main_box,
+				*buttons_box_1,
+				*buttons_box_2,
+				*interface_box,
+				*basic_box,
+				*basic_combo_box,
+				*basic_check_box,
+				*basic_label_box,
+				*basic_wrong_box,
+				*wep_box,
+				*wep_sub_box,
+				*encryption_box,
+				*wep_buttons_box;
+	/* buttons */
+	/* blink button is global */
+	GtkWidget	*add_new_key_bt,
+				*remove_key_bt,
+				*edit_key_bt,
+				*move_key_up_bt,
+				*move_key_down_bt,
+				*reset_configuration_bt,
+				*about_bt,
+				*apply_bt,
+				*ok_bt,
+				*cancel_bt;
+	/* combo */
+
+	/* shortcut to combo entry */
+	GtkWidget	*link_type_te,
+				*wrong_crc_te,
+				*channel_te;
+	/* check */
+	/* global check buttons */
+	GtkWidget   *crc_check,
+				*encryption_check;
+	/* label */
+	GtkWidget	*channel_lb,
+				*wrong_lb,
+				*capture_lb;
+	/* text field */
+	GtkWidget   *key_text;
+
+	/* widgets in the toolbar */
+	GtkWidget	*toolbar,
+				*toolbar_if_lb,
+				*toolbar_channel_cm,
+				*toolbar_wrong_crc_cm;
+
+	/* other stuff */
+	GList				*channel_list,*capture_list;
+	GList				*linktype_list = NULL;
+	gchar				*channel_s,*capture_s;
+
+
+	/* user data - RETRIEVE pointers of toolbar widgets */
+	toolbar				= GTK_WIDGET(data);
+    toolbar_if_lb		= GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_INTERFACE_KEY));
+    toolbar_channel_cm	= GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_CHANNEL_KEY));
+    toolbar_wrong_crc_cm= GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_WRONG_CRC_KEY));
+
+	/* gray out the toolbar */
+	gtk_widget_set_sensitive(toolbar,FALSE);
+
+	/* main window */
+	/* global */
+
+	/* NULL to global widgets */
+	blink_bt = NULL;
+	channel_combo = NULL;
+	block_advanced_signals = FALSE;
+
+	/* the selected is the active, for now */
+	airpcap_if_selected = airpcap_if_active;
+
+	/* Create the new window */
+	airpcap_advanced_w = window_new(GTK_WINDOW_TOPLEVEL, "Advanced Wireless Settings");
+
+	/*
+	 * I will need the toolbar and the main widget in some callback,
+	 * so I will add the toolbar pointer to the airpcap_advanced_w
+	 */
+	OBJECT_SET_DATA(airpcap_advanced_w,AIRPCAP_TOOLBAR_KEY,toolbar);
+
+	/* Connect the callbacks */
+	SIGNAL_CONNECT(airpcap_advanced_w, "delete_event", window_delete_event_cb, airpcap_advanced_w);
+    SIGNAL_CONNECT(airpcap_advanced_w, "destroy", airpcap_if_destroy_cb, airpcap_advanced_w);
+
+	/* Set the size */
+	/* Sets the border width of the window. */
+	gtk_container_set_border_width (GTK_CONTAINER (airpcap_advanced_w), 10);
+
+	/* Create the main box */
+	main_box = gtk_vbox_new(FALSE,0);
+
+	/* Create the button boxes */
+	buttons_box_1 = gtk_hbox_new(FALSE,0);
+	buttons_box_2 = gtk_hbox_new(FALSE,0);
+
+	/* Create the buttons for box 1 */
+	reset_configuration_bt = gtk_button_new_with_label("Reset Configuration");
+	SIGNAL_CONNECT(reset_configuration_bt, "clicked", airpcap_advanced_reset_configuration_cb, toolbar);
+	gtk_widget_show(reset_configuration_bt);
+
+	about_bt = gtk_button_new_with_label("About");
+	SIGNAL_CONNECT(about_bt, "clicked", airpcap_advanced_about_cb, toolbar);
+	gtk_widget_show(about_bt);
+
+	/* Add them to box 1 */
+	gtk_box_pack_start (GTK_BOX (buttons_box_1), reset_configuration_bt, FALSE, FALSE, 1);
+	gtk_box_pack_start (GTK_BOX (buttons_box_1), about_bt, FALSE, FALSE, 1);
+
+    /* Create the buttons for box 2 */
+	apply_bt = gtk_button_new_with_label("Apply");
+	SIGNAL_CONNECT(apply_bt, "clicked", airpcap_advanced_apply_cb, airpcap_advanced_w);
+	gtk_widget_show(apply_bt);
+
+	ok_bt = gtk_button_new_with_label("Ok");
+	OBJECT_SET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_OK_KEY,ok_bt);
+	window_set_cancel_button(airpcap_advanced_w, ok_bt, window_cancel_button_cb);
+	gtk_widget_show(ok_bt);
+
+	cancel_bt = gtk_button_new_with_label("Cancel");
+	OBJECT_SET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_CANCEL_KEY,cancel_bt);
+	window_set_cancel_button(airpcap_advanced_w, cancel_bt, window_cancel_button_cb);
+	gtk_widget_show(cancel_bt);
+
+	/* Add them to box 2 */
+	gtk_box_pack_end (GTK_BOX (buttons_box_2), cancel_bt, FALSE, FALSE, 1);
+	gtk_box_pack_end (GTK_BOX (buttons_box_2), apply_bt,  FALSE, FALSE, 1);
+	gtk_box_pack_end (GTK_BOX (buttons_box_2), ok_bt,     FALSE, FALSE, 1);
+
+	/* Create the three main frames */
+	interface_frame = gtk_frame_new("");
+	gtk_frame_set_label(GTK_FRAME(interface_frame),"Interface");
+
+	basic_frame = gtk_frame_new("");
+	gtk_frame_set_label(GTK_FRAME(basic_frame),"Basic Parameters");
+
+	wep_frame = gtk_frame_new("");
+	gtk_frame_set_label(GTK_FRAME(wep_frame),"WEP Keys");
+
+	/* Create the three sub boxes */
+	interface_box = gtk_hbox_new(FALSE,0);
+	basic_box     = gtk_hbox_new(FALSE,0);
+	wep_box       = gtk_vbox_new(FALSE,0);
+
+	/* Fill the interface_box */
+	if(airpcap_if_active != NULL)
+		{
+		interface_combo = gtk_label_new(airpcap_if_active->description);
+		}
+	else
+		{
+		interface_combo = gtk_label_new("No airpcap interface found!");
+		gtk_widget_set_sensitive(main_box,FALSE);
+		}
+
+	OBJECT_SET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_INTERFACE_KEY,interface_combo);
+	gtk_box_pack_start (GTK_BOX (interface_box), interface_combo, TRUE, TRUE, 0);
+	gtk_widget_show(interface_combo);
+
+	/* blink led button (BEFORE interface_combo, 'cause its callback will need blink_bt)*/
+	blink_bt = gtk_button_new_with_label("  Blink Led  ");
+	OBJECT_SET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_BLINK_KEY,blink_bt);
+	gtk_box_pack_end (GTK_BOX (interface_box), blink_bt, FALSE, FALSE, 0);
+	SIGNAL_CONNECT(blink_bt, "clicked", blink_cb, NULL);
+	gtk_widget_show(blink_bt);
+
+	gtk_container_set_border_width (GTK_CONTAINER (interface_box), 10);
+
+	/* Fill the basic_box */
+	/* Create the two vertical boxes for combo and check */
+	basic_combo_box = gtk_vbox_new(TRUE,0);
+	basic_check_box = gtk_vbox_new(TRUE,0);
+	basic_label_box = gtk_vbox_new(TRUE,0);
+
+	/* Create the Wrong CRC horiziontal box */
+	basic_wrong_box = gtk_hbox_new(FALSE,0);
+
+	/* Fill the label vbox */
+	channel_lb = gtk_label_new("Channel:      ");
+	gtk_label_set_justify(GTK_LABEL(channel_lb),GTK_JUSTIFY_LEFT);
+	gtk_box_pack_start (GTK_BOX (basic_label_box), channel_lb, TRUE, TRUE, 0);
+	gtk_widget_show(channel_lb);
+	capture_lb = gtk_label_new("Capture Type:");
+	gtk_label_set_justify(GTK_LABEL(capture_lb),GTK_JUSTIFY_LEFT);
+	gtk_box_pack_start (GTK_BOX (basic_label_box), capture_lb, TRUE, TRUE, 0);
+	gtk_widget_show(capture_lb);
+
+	/* Create the two combo boxes */
+	channel_combo = gtk_combo_new();
+	OBJECT_SET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_CHANNEL_KEY,channel_combo);
+
+	channel_list = NULL;
+	channel_list = g_list_append(channel_list, "1");
+    channel_list = g_list_append(channel_list, "2");
+    channel_list = g_list_append(channel_list, "3");
+    channel_list = g_list_append(channel_list, "4");
+	channel_list = g_list_append(channel_list, "5");
+	channel_list = g_list_append(channel_list, "6");
+	channel_list = g_list_append(channel_list, "7");
+	channel_list = g_list_append(channel_list, "8");
+	channel_list = g_list_append(channel_list, "9");
+	channel_list = g_list_append(channel_list, "10");
+	channel_list = g_list_append(channel_list, "11");
+	channel_list = g_list_append(channel_list, "12");
+	channel_list = g_list_append(channel_list, "13");
+	channel_list = g_list_append(channel_list, "14");
+	gtk_combo_set_popdown_strings( GTK_COMBO(channel_combo), channel_list) ;
+
+	/* Select the first entry */
+	if(airpcap_if_selected != NULL)
+		{
+		channel_s = g_strdup_printf("%d",airpcap_if_selected->channel);
+		gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(channel_combo)->entry), channel_s);
+		}
+
+	channel_te = GTK_COMBO(channel_combo)->entry;
+	gtk_editable_set_editable(GTK_EDITABLE(channel_te),FALSE);
+    SIGNAL_CONNECT(channel_te, "changed",  channel_changed_cb, channel_te);
+	gtk_box_pack_start (GTK_BOX (basic_combo_box), channel_combo, FALSE, FALSE, 0);
+	gtk_widget_show(channel_combo);
+
+	capture_combo = gtk_combo_new();
+	OBJECT_SET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_LINK_TYPE_KEY,capture_combo);
+	capture_list = NULL;
+	capture_list = g_list_append(capture_list, AIRPCAP_LINK_TYPE_NAME_802_11_ONLY);
+    capture_list = g_list_append(capture_list, AIRPCAP_LINK_TYPE_NAME_802_11_PLUS_RADIO);
+	gtk_combo_set_popdown_strings( GTK_COMBO(capture_combo), capture_list) ;
+
+	capture_s = NULL;
+	if(airpcap_if_selected != NULL)
+		{
+		if(airpcap_if_selected->linkType == AIRPCAP_LT_802_11)
+			capture_s = g_strdup_printf("%s",AIRPCAP_LINK_TYPE_NAME_802_11_ONLY);
+		else if(airpcap_if_selected->linkType == AIRPCAP_LT_802_11_PLUS_RADIO)
+			capture_s = g_strdup_printf("%s",AIRPCAP_LINK_TYPE_NAME_802_11_PLUS_RADIO);
+		if(capture_s != NULL) gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(capture_combo)->entry), capture_s);
+		}
+	g_free(capture_s);
+
+	link_type_te = GTK_COMBO(capture_combo)->entry;
+	gtk_editable_set_editable(GTK_EDITABLE(link_type_te),FALSE);
+    SIGNAL_CONNECT(link_type_te, "changed",  link_type_changed_cb, link_type_te);
+	gtk_box_pack_start (GTK_BOX (basic_combo_box), capture_combo, FALSE, FALSE, 1);
+	gtk_widget_show(capture_combo);
+
+	/* Create the two check boxes */
+	crc_check		= gtk_check_button_new_with_label("Include 802.11 FCS in Frames");
+	OBJECT_SET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_CRC_KEY,crc_check);
+
+	/* Fcs Presence check box */
+	if(airpcap_if_selected != NULL)
+		{
+		if(airpcap_if_selected->IsFcsPresent)
+			gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(crc_check),TRUE);
+		else
+			gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(crc_check),FALSE);
+		}
+
+	SIGNAL_CONNECT(crc_check,"toggled",crc_check_cb,NULL);
+	gtk_box_pack_start (GTK_BOX (basic_check_box), crc_check, FALSE, FALSE, 0);
+	gtk_widget_show(crc_check);
+
+	/* CRC Filter label */
+	wrong_lb = gtk_label_new("FCS Filter:");
+	gtk_box_pack_start (GTK_BOX (basic_wrong_box), wrong_lb, FALSE, FALSE, 0);
+	gtk_widget_show(wrong_lb);
+
+	/* CRC Filter combo */
+	wrong_crc_combo = gtk_combo_new();
+	OBJECT_SET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_WRONG_CRC_KEY,wrong_crc_combo);
+
+	linktype_list = g_list_append(linktype_list, AIRPCAP_VALIDATION_TYPE_NAME_ALL);
+	linktype_list = g_list_append(linktype_list, AIRPCAP_VALIDATION_TYPE_NAME_CORRECT);
+    linktype_list = g_list_append(linktype_list, AIRPCAP_VALIDATION_TYPE_NAME_CORRUPT);
+
+	gtk_combo_set_popdown_strings( GTK_COMBO(wrong_crc_combo), linktype_list) ;
+
+	wrong_crc_te = GTK_COMBO(wrong_crc_combo)->entry;
+
+	if(airpcap_if_selected != NULL)
+		{
+		airpcap_validation_type_combo_set_by_type(wrong_crc_combo,airpcap_if_selected->CrcValidationOn);
+		}
+
+	gtk_editable_set_editable(GTK_EDITABLE(wrong_crc_te),FALSE);
+	SIGNAL_CONNECT(wrong_crc_te,"changed",wrong_crc_combo_cb,wrong_crc_te);
+	gtk_box_pack_start (GTK_BOX (basic_wrong_box), wrong_crc_combo, FALSE, FALSE, 0);
+	gtk_widget_show(wrong_crc_combo);
+
+	gtk_box_pack_start(GTK_BOX(basic_check_box), basic_wrong_box, FALSE, FALSE, 0);
+	gtk_widget_show(basic_wrong_box);
+
+	/* Add the vertical inner boxes to the basic_box */
+	gtk_box_pack_start (GTK_BOX (basic_box), basic_label_box, FALSE, FALSE, 10);
+	gtk_box_pack_start (GTK_BOX (basic_box), basic_combo_box, FALSE, FALSE, 10);
+	gtk_box_pack_start (GTK_BOX (basic_box), basic_check_box, FALSE, FALSE, 10);
+
+	gtk_container_set_border_width (GTK_CONTAINER (basic_box), 10);
+
+	/* Fill the wep_box */
+	wep_sub_box = gtk_hbox_new(FALSE,1);
+	gtk_widget_show(wep_sub_box);
+	encryption_box = gtk_hbox_new(FALSE,1);
+	gtk_widget_show(encryption_box);
+
+	/* encryption enabled box */
+	encryption_check = gtk_check_button_new_with_label("Enable WEP Decryption");
+	OBJECT_SET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_DECRYPTION_KEY,encryption_check);
+
+	/* Fcs Presence check box */
+	if(airpcap_if_selected != NULL)
+		{
+		if(airpcap_if_selected->DecryptionOn == AIRPCAP_DECRYPTION_ON)
+			gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(encryption_check),TRUE);
+		else
+			gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(encryption_check),FALSE);
+		}
+
+	SIGNAL_CONNECT(encryption_check,"toggled",encryption_check_cb,NULL);
+	gtk_box_pack_start (GTK_BOX (encryption_box), encryption_check, FALSE, FALSE, 0);
+	gtk_widget_show(encryption_check);
+
+	/* WEP text box */
+	key_text = scrolled_window_new(NULL, NULL);
+    /* never use a scrollbar in x direction, show the complete relation string */
+    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(key_text),
+                                   GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
+    #if GTK_MAJOR_VERSION >= 2
+    gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(key_text),
+                                   GTK_SHADOW_IN);
+    #endif
+
+	/* add WEP keys if present... */
+    key_ls = gtk_list_new();
+    gtk_list_set_selection_mode(GTK_LIST(key_ls), GTK_SELECTION_SINGLE);
+	OBJECT_SET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_KEYLIST_KEY,key_ls);
+
+	airpcap_fill_key_list(key_ls,airpcap_if_selected);
+	gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(key_text),key_ls);
+	gtk_widget_show(key_ls);
+	gtk_box_pack_start (GTK_BOX (wep_sub_box), key_text, TRUE, TRUE, 0);
+	gtk_widget_show(key_text);
+
+	/* WEP buttons */
+	wep_buttons_box = gtk_vbox_new(FALSE,0);
+
+	/* Create and add buttons */
+	add_new_key_bt = gtk_button_new_with_label("Add New Key");
+	SIGNAL_CONNECT(add_new_key_bt, "clicked", airpcap_advanced_add_key_cb, airpcap_advanced_w);
+	gtk_box_pack_start (GTK_BOX (wep_buttons_box), add_new_key_bt, FALSE, FALSE, 0);
+	gtk_widget_show(add_new_key_bt);
+	remove_key_bt = gtk_button_new_with_label("Remove Key");
+	SIGNAL_CONNECT(remove_key_bt, "clicked", airpcap_advanced_remove_key_cb, key_ls);
+	gtk_box_pack_start (GTK_BOX (wep_buttons_box), remove_key_bt, FALSE, FALSE, 0);
+	gtk_widget_show(remove_key_bt);
+	edit_key_bt = gtk_button_new_with_label("Edit Key");
+	SIGNAL_CONNECT(edit_key_bt, "clicked", airpcap_advanced_edit_key_cb, airpcap_advanced_w);
+	gtk_box_pack_start (GTK_BOX (wep_buttons_box), edit_key_bt, FALSE, FALSE, 0);
+	gtk_widget_show(edit_key_bt);
+	move_key_up_bt = gtk_button_new_with_label("Move Key Up");
+	SIGNAL_CONNECT(move_key_up_bt, "clicked", airpcap_advanced_move_key_up_cb, key_ls);
+	gtk_box_pack_start (GTK_BOX (wep_buttons_box), move_key_up_bt, FALSE, FALSE, 0);
+	gtk_widget_show(move_key_up_bt);
+	move_key_down_bt = gtk_button_new_with_label("Move Key Down");
+	SIGNAL_CONNECT(move_key_down_bt, "clicked", airpcap_advanced_move_key_down_cb, key_ls);
+	gtk_box_pack_start (GTK_BOX (wep_buttons_box), move_key_down_bt, FALSE, FALSE, 0);
+	gtk_widget_show(move_key_down_bt);
+
+	gtk_box_pack_end (GTK_BOX (wep_sub_box), wep_buttons_box, FALSE, FALSE, 0);
+
+	gtk_container_set_border_width (GTK_CONTAINER (wep_sub_box), 10);
+
+	gtk_box_pack_start (GTK_BOX (wep_box), encryption_box, FALSE, FALSE,0);
+	gtk_box_pack_start (GTK_BOX (wep_box), wep_sub_box, FALSE, FALSE,0);
+	gtk_widget_show(wep_sub_box);
+
+	/* Add them to the frames */
+	gtk_container_add(GTK_CONTAINER(interface_frame),interface_box);
+	gtk_container_add(GTK_CONTAINER(basic_frame),basic_box);
+	gtk_container_add(GTK_CONTAINER(wep_frame),wep_box);
+
+	/* Add frames to the main box */
+	gtk_box_pack_start (GTK_BOX (main_box), interface_frame, FALSE, FALSE, 1);
+	gtk_box_pack_start (GTK_BOX (main_box), basic_frame, FALSE, FALSE, 1);
+	gtk_box_pack_start (GTK_BOX (main_box), wep_frame, FALSE, FALSE, 1);
+
+	/* Add buttons' boxes to the main box */
+	gtk_box_pack_start (GTK_BOX (main_box), buttons_box_2, FALSE, FALSE, 1);
+
+	/* Add the main box to the main window */
+	gtk_container_add(GTK_CONTAINER(airpcap_advanced_w),main_box);
+
+	/* SHOW EVERYTHING */
+	/* Show the WEP key buttons */
+	gtk_widget_show (wep_buttons_box);
+
+	/* Show the combo and check boxes */
+	gtk_widget_show (basic_label_box);
+	gtk_widget_show (basic_combo_box);
+	gtk_widget_show (basic_check_box);
+
+	/* Show the button boxes */
+	gtk_widget_show (buttons_box_1);
+	gtk_widget_show (buttons_box_2);
+
+	/* Show the frames */
+	gtk_widget_show (interface_frame);
+	gtk_widget_show (basic_frame);
+	gtk_widget_show (wep_frame);
+
+	/* Show the sub main boxes */
+	gtk_widget_show (interface_box);
+	gtk_widget_show (basic_box);
+	gtk_widget_show (wep_box);
+
+	/* Show the main box */
+	gtk_widget_show (main_box);
+
+	/* Show the window */
+	gtk_widget_show (airpcap_advanced_w);
+}
+
+#endif /* HAVE_AIRPCAP */