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