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