osmith
/
wireshark
forked from osmocom/wireshark
1
0
Fork 0
Code Pull Requests Releases Wiki Activity
wireshark/gtk/airpcap_dlg.c

1891 lines
57 KiB
C
Raw Blame History

/* 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.h>
#include <glib/gprintf.h>
#include <string.h>
#include <epan/filesystem.h>
#include <pcap.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
*/
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;
}
}
/*
* 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;
}
return;
}
/*
* 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;
gchar ebuf[AIRPCAP_ERRBUF_SIZE];
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;
gchar ebuf[AIRPCAP_ERRBUF_SIZE];
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;
gchar ebuf[AIRPCAP_ERRBUF_SIZE];
/* 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_update_channel_combo(GTK_WIDGET(toolbar_channel_cm),airpcap_if_selected);
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_update_channel_combo(GTK_WIDGET(toolbar_channel_cm),airpcap_if_selected);
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_update_channel_combo(GTK_WIDGET(toolbar_channel_cm),airpcap_if_selected);
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) > WEP_KEY_MAX_CHAR_SIZE)
{
simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"WEP key size out of range!\nValid key size range is 2-%d characters (8-%d bits).",WEP_KEY_MAX_CHAR_SIZE,WEP_KEY_MAX_SIZE*8);
return;
}
if((new_key->len % 2) != 0)
{
simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"Wrong WEP key!\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,"Wrong WEP key!\nA WEP key must be an hexadecimal number.\nThe valid characters are: 0123456789ABCDEF.");
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) > WEP_KEY_MAX_CHAR_SIZE)
{
simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"WEP key size out of range!\nValid key size range is 2-%d characters (8-%d bits).",WEP_KEY_MAX_CHAR_SIZE,WEP_KEY_MAX_SIZE*8);
return;
}
if((new_key->len % 2) != 0)
{
simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"Wrong WEP key!\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,"Wrong WEP key!\nA WEP key must be an hexadecimal number.\nThe valid characters are: 0123456789ABCDEF.");
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
wep_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 *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)
{
airpcap_update_channel_combo(GTK_WIDGET(channel_combo), airpcap_if_selected);
}
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_WEP_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",wep_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 */
View Git Blame Copy Permalink