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