gtk/airpcap_dlg.c

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