gtk/airpcap_dlg.c

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