gtk/airpcap_dlg.c

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