gtk/main_airpcap_toolbar.c

   1 /* main_airpcap_toolbar.c
   2  * The airpcap toolbar
   3  *
   4  * $Id$
   5  *
   6  * Wireshark - Network traffic analyzer
   7  * By Gerald Combs <gerald@wireshark.org>
   8  * Copyright 1998 Gerald Combs
   9  *
  10  * This program is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU General Public License
  12  * as published by the Free Software Foundation; either version 2
  13  * of the License, or (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  23  */
  24
  25 /*
  26  * This file implements the wireless toolbar for Wireshark.
  27  */
  28
  29 #ifdef HAVE_CONFIG_H
  30 # include "config.h"
  31 #endif
  32
  33 #ifdef HAVE_AIRPCAP
  34
  35 #include <gtk/gtk.h>
  36
  37 #include <epan/epan.h>
  38 #include <epan/frequency-utils.h>
  39
  40 #include "simple_dialog.h"
  41 #include "main.h"
  42 #include "main_airpcap_toolbar.h"
  43
  44 #include "recent.h"
  45 #include "keys.h"
  46
  47 #include <airpcap.h>
  48 #include "airpcap_loader.h"
  49 #include "airpcap_dlg.h"
  50 #include "airpcap_gui_utils.h"
  51
  52 #ifdef  HAVE_AIRPDCAP
  53 #include <epan/crypt/airpdcap_ws.h>
  54 #endif
  55
  56
  57 gboolean block_toolbar_signals = FALSE;
  58 static GtkWidget *driver_warning_dialog;
  59
  60
  61
  62 /*
  63  * Changed callback for the channel combobox
  64  */
  65 static void
  66 airpcap_toolbar_channel_changed_cb(GtkWidget *w, gpointer data)
  67 {
  68   const gchar *s;
  69   ULONG ch_freq;
  70
  71   if ((data != NULL) && (w != NULL) && change_airpcap_settings) {
  72         s = gtk_entry_get_text(GTK_ENTRY(w));
  73     if ((g_ascii_strcasecmp("",s))) {
  74       ch_freq = airpcap_get_frequency_from_str(s);
  75       if (airpcap_if_active != NULL) {
  76                 airpcap_if_active->channelInfo.Frequency = ch_freq;
  77                 airpcap_update_channel_offset_cb(airpcap_if_active, ch_freq, GTK_WIDGET(data));
  78       }
  79     }
  80   }
  81 }
  82
  83 /*
  84  * Changed callback for the channel offset combobox
  85  */
  86 static void
  87 on_channel_offset_cb_changed(GtkWidget *w, gpointer data)
  88 {
  89     const gchar *s;
  90     int offset;
  91
  92     if (w == NULL || GTK_WIDGET_SENSITIVE(w)) {
  93         return;
  94     }
  95
  96     if (data != NULL && change_airpcap_settings)
  97     {
  98         s = gtk_entry_get_text(GTK_ENTRY(w));
  99         if ((g_ascii_strcasecmp("",s)))
 100         {
 101             if (airpcap_if_active != NULL)
 102             {
 103                 sscanf(s,"%d",&offset);
 104                 airpcap_if_active->channelInfo.ExtChannel = offset;
 105                 if (change_airpcap_settings != NULL)
 106                 {
 107                     airpcap_update_frequency_and_offset(airpcap_if_active);
 108                 }
 109             }
 110         }
 111     }
 112 }
 113
 114 /*
 115  * Callback for the wrong crc combo
 116  */
 117 static void
 118 airpcap_toolbar_wrong_crc_combo_cb(GtkWidget *entry, gpointer user_data)
 119 {
 120   gchar ebuf[AIRPCAP_ERRBUF_SIZE];
 121   PAirpcapHandle ad;
 122
 123   if( !block_toolbar_signals && (airpcap_if_active != NULL)) {
 124     ad = airpcap_if_open(airpcap_if_active->name, ebuf);
 125
 126     if (ad) {
 127       airpcap_if_active->CrcValidationOn = airpcap_get_validation_type(gtk_entry_get_text(GTK_ENTRY(entry)));
 128       airpcap_if_set_fcs_validation(ad,airpcap_if_active->CrcValidationOn);
 129       /* Save configuration */
 130       airpcap_if_store_cur_config_as_adapter_default(ad);
 131       airpcap_if_close(ad);
 132     }
 133   }
 134 }
 135
 136 void
 137 airpcap_toolbar_encryption_cb(GtkWidget *entry, gpointer user_data)
 138 {
 139   /* We need to directly access the .dll functions here... */
 140   gchar ebuf[AIRPCAP_ERRBUF_SIZE];
 141   PAirpcapHandle ad;
 142
 143   gint n = 0;
 144   gint i = 0;
 145   airpcap_if_info_t* curr_if = NULL;
 146
 147   /* Apply changes to the current adapter */
 148   if( (airpcap_if_active != NULL)) {
 149     ad = airpcap_if_open(airpcap_if_active->name, ebuf);
 150
 151     if(ad) {
 152       if(airpcap_if_active->DecryptionOn == AIRPCAP_DECRYPTION_ON) {
 153         airpcap_if_active->DecryptionOn = AIRPCAP_DECRYPTION_OFF;
 154         airpcap_if_set_decryption_state(ad,airpcap_if_active->DecryptionOn);
 155         /* Save configuration */
 156         if(!airpcap_if_store_cur_config_as_adapter_default(ad)) {
 157           simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "Cannot save configuration!!!\nRemember that in order to store the configuration in the registry you have to:\n\n- Close all the airpcap-based applications.\n- Be sure to have administrative privileges.");
 158         }
 159         airpcap_if_close(ad);
 160       } else {
 161         airpcap_if_active->DecryptionOn = AIRPCAP_DECRYPTION_ON;
 162         airpcap_if_set_decryption_state(ad,airpcap_if_active->DecryptionOn);
 163         /* Save configuration */
 164         if(!airpcap_if_store_cur_config_as_adapter_default(ad)) {
 165           simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "Cannot save configuration!!!\nRemember that in order to store the configuration in the registry you have to:\n\n- Close all the airpcap-based applications.\n- Be sure to have administrative privileges.");
 166         }
 167         airpcap_if_close(ad);
 168       }
 169     }
 170   } else {
 171     simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "No active AirPcap Adapter selected!");
 172     return;
 173   }
 174
 175   if (!(airpcap_if_list == NULL)){
 176   n = g_list_length(airpcap_if_list);
 177
 178   /* The same kind of settings should be propagated to all the adapters */
 179   /* Apply this change to all the adapters !!! */
 180   for(i = 0; i < n; i++) {
 181     curr_if = (airpcap_if_info_t*)g_list_nth_data(airpcap_if_list,i);
 182
 183     if( (curr_if != NULL) && (curr_if != airpcap_if_selected) ) {
 184       ad = airpcap_if_open(curr_if->name, ebuf);
 185       if(ad) {
 186         curr_if->DecryptionOn = airpcap_if_selected->DecryptionOn;
 187         airpcap_if_set_decryption_state(ad,curr_if->DecryptionOn);
 188         /* Save configuration for the curr_if */
 189         if(!airpcap_if_store_cur_config_as_adapter_default(ad)) {
 190           simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "Cannot save configuration!!!\nRemember that in order to store the configuration in the registry you have to:\n\n- Close all the airpcap-based applications.\n- Be sure to have administrative privileges.");
 191         }
 192         airpcap_if_close(ad);
 193       }
 194     }
 195   }
 196   } else {
 197     simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "AirPcap Adapter Error!");
 198     return;
 199   }
 200 }
 201
 202 /*
 203  * Callback for the Advanced Wireless Settings button
 204  */
 205 static void
 206 toolbar_display_airpcap_advanced_cb(GtkWidget *w, gpointer data)
 207 {
 208     int *from_widget;
 209
 210     from_widget = (gint*)g_malloc(sizeof(gint));
 211     *from_widget = AIRPCAP_ADVANCED_FROM_TOOLBAR;
 212     g_object_set_data(G_OBJECT(airpcap_tb),AIRPCAP_ADVANCED_FROM_KEY,from_widget);
 213
 214     display_airpcap_advanced_cb(w,data);
 215 }
 216
 217 /*
 218  * Callback for the Decryption Key Management button
 219  */
 220 static void
 221 toolbar_display_airpcap_key_management_cb(GtkWidget *w, gpointer data)
 222 {
 223     int *from_widget;
 224
 225     from_widget = (gint*)g_malloc(sizeof(gint));
 226     *from_widget = AIRPCAP_ADVANCED_FROM_TOOLBAR;
 227     g_object_set_data(G_OBJECT(airpcap_tb),AIRPCAP_ADVANCED_FROM_KEY,from_widget);
 228
 229     display_airpcap_key_management_cb(w,data);
 230 }
 231
 232 GtkWidget *airpcap_toolbar_new()
 233 {
 234     GtkWidget     *key_management_bt = NULL,
 235                   *advanced_bt = NULL,
 236                   *channel_lb = NULL,
 237                   *channel_cm = NULL,
 238                   *channel_offset_lb = NULL,
 239                   *channel_offset_cb = NULL,
 240                   *wrong_crc_lb = NULL,
 241                   *wrong_crc_cm = NULL;
 242     GtkWidget     *airpcap_tb;
 243
 244     GtkWidget     *enable_decryption_lb;
 245     GtkWidget     *enable_decryption_cb;
 246     GList         *enable_decryption_cb_items = NULL;
 247     GtkWidget     *enable_decryption_en;
 248
 249     GList         *channel_list = NULL;
 250     GList         *linktype_list = NULL;
 251     GList         *link_list = NULL;
 252     GtkTooltips   *airpcap_tooltips;
 253     /* gchar      *if_label_text; */
 254     gint          *from_widget = NULL;
 255     gchar         *chan_str;
 256
 257     /* airpcap toolbar */
 258     airpcap_tooltips = gtk_tooltips_new();
 259     airpcap_tb = gtk_toolbar_new();
 260     gtk_toolbar_set_orientation(GTK_TOOLBAR(airpcap_tb),
 261                                 GTK_ORIENTATION_HORIZONTAL);
 262
 263     /* Interface Label */
 264     /*if(airpcap_if_active != NULL) {
 265         if_label_text = g_strdup_printf("%s %s\t","Current Wireless Interface: #",airpcap_get_if_string_number(airpcap_if_active));
 266         interface_lb = gtk_label_new(if_label_text);
 267         g_free(if_label_text);
 268     } else {
 269         interface_lb = gtk_label_new("No Wireless Interface Found  ");
 270     }*/
 271
 272     /* Add the label to the toolbar */
 273     /*gtk_toolbar_append_widget(GTK_TOOLBAR(airpcap_tb), interface_lb,
 274                               "Current Wireless Interface", "Private");
 275     g_object_set_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_INTERFACE_KEY,interface_lb);
 276     gtk_widget_show(interface_lb);
 277     gtk_toolbar_insert_space(GTK_TOOLBAR(airpcap_tb),1);*/
 278
 279
 280     /* Create the "802.11 Channel:" label */
 281     channel_lb = gtk_label_new("802.11 Channel: ");
 282     g_object_set_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_CHANNEL_LABEL_KEY,channel_lb);
 283     gtk_toolbar_append_widget(GTK_TOOLBAR(airpcap_tb), channel_lb,
 284                               "Current 802.11 Channel", "Private");
 285     gtk_widget_show(channel_lb);
 286
 287     gtk_widget_set_size_request(channel_lb, 85, 28);
 288
 289     /* Create the channel combo box */
 290     channel_cm = gtk_combo_new();
 291     gtk_editable_set_editable(GTK_EDITABLE(GTK_COMBO(channel_cm)->entry),FALSE);
 292     g_object_set_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_CHANNEL_KEY,channel_cm);
 293
 294     if (airpcap_if_active != NULL && airpcap_if_active->pSupportedChannels != NULL && airpcap_if_active->numSupportedChannels > 0){
 295         guint i = 0;
 296         for (; i<airpcap_if_active->numSupportedChannels; i++){
 297             channel_list = g_list_append(channel_list, ieee80211_mhz_to_str(airpcap_if_active->pSupportedChannels[i].Frequency));
 298         }
 299         gtk_combo_set_popdown_strings( GTK_COMBO(channel_cm), channel_list);
 300         airpcap_free_channel_combo_list(channel_list);
 301     }
 302
 303     gtk_tooltips_set_tip(airpcap_tooltips, GTK_WIDGET(GTK_COMBO(channel_cm)->entry),
 304                 "Change the 802.11 RF channel", NULL);
 305
 306     gtk_widget_set_size_request(channel_cm, 120, 28);
 307
 308     if(airpcap_if_active != NULL) {
 309         chan_str = ieee80211_mhz_to_str(airpcap_if_active->channelInfo.Frequency);
 310         gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(channel_cm)->entry), chan_str);
 311         g_free(chan_str);
 312     }
 313     else {
 314         gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(channel_cm)->entry),"");
 315     }
 316     gtk_widget_show(channel_cm);
 317
 318     gtk_toolbar_append_widget(GTK_TOOLBAR(airpcap_tb), channel_cm,
 319                               "802.11 Channel", "Private");
 320
 321     /* gtk_toolbar_append_space(GTK_TOOLBAR(airpcap_tb)); */
 322
 323     /* Create the "Channel Offset:" label */
 324     channel_offset_lb = gtk_label_new("Channel Offset: ");
 325     g_object_set_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_CHANNEL_OFFSET_LABEL_KEY,channel_offset_lb);
 326     gtk_toolbar_append_widget(GTK_TOOLBAR(airpcap_tb), channel_offset_lb,
 327                               "Current 802.11 Channel Offset", "Private");
 328     gtk_widget_show(channel_offset_lb);
 329
 330     gtk_widget_set_size_request(channel_offset_lb, 80, 28);
 331
 332     /* Start: Channel offset combo box */
 333     channel_offset_cb = gtk_combo_new();
 334     gtk_editable_set_editable(GTK_EDITABLE(GTK_COMBO(channel_offset_cb)->entry),FALSE);
 335     g_object_set_data(G_OBJECT(airpcap_tb), AIRPCAP_TOOLBAR_CHANNEL_OFFSET_KEY, channel_offset_cb);
 336
 337     if(airpcap_if_active != NULL){
 338                 airpcap_update_channel_offset_cb(airpcap_if_active, airpcap_if_active->channelInfo.Frequency, channel_offset_cb);
 339                 airpcap_update_channel_offset_combo_entry(channel_offset_cb, airpcap_if_active->channelInfo.ExtChannel);
 340     } else {
 341         gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(channel_offset_cb)->entry),"");
 342     }
 343
 344     gtk_tooltips_set_tip(airpcap_tooltips, GTK_WIDGET(GTK_COMBO(channel_offset_cb)->entry),
 345                 "Change channel offset", NULL);
 346
 347     gtk_widget_set_size_request(channel_offset_cb, 50, 28);
 348
 349     gtk_widget_show(channel_offset_cb);
 350
 351     gtk_toolbar_append_widget(GTK_TOOLBAR(airpcap_tb), channel_offset_cb,
 352                               "802.11 Channel Offset", "Private");
 353
 354     gtk_toolbar_append_space(GTK_TOOLBAR(airpcap_tb));
 355
 356     /* callback for channel combo box */
 357     g_signal_connect(GTK_COMBO(channel_cm)->entry,"changed", G_CALLBACK(airpcap_toolbar_channel_changed_cb), channel_offset_cb);
 358     /* callback for channel offset combo box */
 359     g_signal_connect(GTK_COMBO(channel_offset_cb)->entry,"changed", G_CALLBACK(on_channel_offset_cb_changed), channel_offset_cb);
 360     /* End: Channel offset combo box */
 361
 362     /* Wrong CRC Label */
 363     wrong_crc_lb = gtk_label_new(" FCS Filter: ");
 364     g_object_set_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_FCS_FILTER_LABEL_KEY,wrong_crc_lb);
 365     gtk_toolbar_append_widget(GTK_TOOLBAR(airpcap_tb), wrong_crc_lb,
 366                               "", "Private");
 367     gtk_widget_show(wrong_crc_lb);
 368
 369     /* Wrong CRC combo */
 370     wrong_crc_cm = gtk_combo_new();
 371     gtk_editable_set_editable(GTK_EDITABLE(GTK_COMBO(wrong_crc_cm)->entry),FALSE);
 372     g_object_set_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_FCS_FILTER_KEY,wrong_crc_cm);
 373     gtk_toolbar_append_widget(GTK_TOOLBAR(airpcap_tb), wrong_crc_cm,
 374                               "", "Private");
 375
 376     gtk_widget_set_size_request(wrong_crc_cm, 100, -1);
 377
 378     linktype_list = g_list_append(linktype_list, AIRPCAP_VALIDATION_TYPE_NAME_ALL);
 379     linktype_list = g_list_append(linktype_list, AIRPCAP_VALIDATION_TYPE_NAME_CORRECT);
 380     linktype_list = g_list_append(linktype_list, AIRPCAP_VALIDATION_TYPE_NAME_CORRUPT);
 381
 382     gtk_combo_set_popdown_strings( GTK_COMBO(wrong_crc_cm), linktype_list) ;
 383     g_list_free(linktype_list);
 384     gtk_tooltips_set_tip(airpcap_tooltips, GTK_WIDGET(GTK_COMBO(wrong_crc_cm)->entry),
 385         "Select the 802.11 FCS filter that the wireless adapter will apply.",
 386         NULL);
 387
 388     if(airpcap_if_active != NULL)
 389         gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(wrong_crc_cm)->entry), airpcap_get_validation_name(airpcap_if_active->CrcValidationOn));
 390     else
 391         gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(wrong_crc_cm)->entry),"");
 392
 393     g_signal_connect(GTK_COMBO(wrong_crc_cm)->entry,"changed",G_CALLBACK(airpcap_toolbar_wrong_crc_combo_cb),airpcap_tb);
 394     gtk_widget_show(wrong_crc_cm);
 395
 396     gtk_toolbar_append_space(GTK_TOOLBAR(airpcap_tb));
 397
 398     /* Decryption mode combo box */
 399     enable_decryption_lb = gtk_label_new ("Decryption Mode: ");
 400     g_object_set_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_DECRYPTION_LABEL_KEY,enable_decryption_lb);
 401     gtk_widget_set_name (enable_decryption_lb, "enable_decryption_lb");
 402     gtk_widget_show (enable_decryption_lb);
 403     gtk_toolbar_append_widget(GTK_TOOLBAR(airpcap_tb), enable_decryption_lb,
 404         NULL, "Private");
 405
 406     enable_decryption_cb = gtk_combo_new ();
 407     gtk_widget_set_name (enable_decryption_cb, "enable_decryption_cb");
 408     gtk_widget_show (enable_decryption_cb);
 409     gtk_widget_set_size_request(enable_decryption_cb, 83, -1);
 410     update_decryption_mode_list(enable_decryption_cb);
 411
 412     enable_decryption_en = GTK_COMBO (enable_decryption_cb)->entry;
 413     gtk_widget_set_name (enable_decryption_en, "enable_decryption_en");
 414     gtk_widget_show (enable_decryption_en);
 415     gtk_editable_set_editable (GTK_EDITABLE (enable_decryption_en), FALSE);
 416     GTK_WIDGET_UNSET_FLAGS (enable_decryption_en, GTK_CAN_FOCUS);
 417
 418     gtk_toolbar_append_widget(GTK_TOOLBAR(airpcap_tb), enable_decryption_cb,
 419         "Choose a Decryption Mode", "Private");
 420
 421     /* Set current decryption mode!!!! */
 422     update_decryption_mode_cm(enable_decryption_cb);
 423     g_signal_connect(enable_decryption_en, "changed", G_CALLBACK(on_enable_decryption_en_changed), airpcap_tb);
 424     g_object_set_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_DECRYPTION_KEY,enable_decryption_cb);
 425
 426     gtk_toolbar_append_space(GTK_TOOLBAR(airpcap_tb));
 427
 428     /* Advanced button */
 429     advanced_bt = gtk_button_new_with_label("Wireless Settings...");
 430     g_object_set_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_ADVANCED_KEY,advanced_bt);
 431
 432     g_signal_connect(advanced_bt, "clicked", G_CALLBACK(toolbar_display_airpcap_advanced_cb), airpcap_tb);
 433     gtk_toolbar_append_widget(GTK_TOOLBAR(airpcap_tb), advanced_bt,
 434         "Set Advanced Wireless Settings", "Private");
 435
 436
 437     gtk_widget_show(advanced_bt);
 438
 439     /* Key Management button */
 440     key_management_bt = gtk_button_new_with_label("Decryption Keys...");
 441     g_object_set_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_KEY_MANAGEMENT_KEY,key_management_bt);
 442
 443     g_signal_connect(key_management_bt, "clicked", G_CALLBACK(toolbar_display_airpcap_key_management_cb), airpcap_tb);
 444     gtk_toolbar_append_widget(GTK_TOOLBAR(airpcap_tb), key_management_bt,
 445                               "Manage Decryption Keys", "Private");
 446     gtk_widget_show(key_management_bt);
 447
 448     /* If no airpcap interface is present, gray everything */
 449     if(airpcap_if_active == NULL) {
 450         if(airpcap_if_list == NULL || g_list_length(airpcap_if_list) == 0) {
 451             /* No airpcap device found */
 452             airpcap_enable_toolbar_widgets(airpcap_tb,FALSE);
 453             /* recent.airpcap_toolbar_show = TRUE; */
 454         } else {
 455             /* default adapter is not airpcap... or is airpcap but is not found*/
 456             airpcap_set_toolbar_stop_capture(airpcap_if_active);
 457             airpcap_enable_toolbar_widgets(airpcap_tb,FALSE);
 458             /* recent.airpcap_toolbar_show = TRUE; */
 459         }
 460     } else {
 461         airpcap_set_toolbar_stop_capture(airpcap_if_active);
 462         /* recent.airpcap_toolbar_show = TRUE; */
 463     }
 464
 465     return airpcap_tb;
 466 }
 467
 468 static void
 469 driver_warning_dialog_cb(gpointer dialog, gint btn _U_, gpointer data _U_)
 470 {
 471     gboolean r;
 472
 473     r = simple_dialog_check_get(dialog);
 474     recent.airpcap_driver_check_show = !r;
 475 }
 476
 477 void airpcap_toolbar_show(GtkWidget *airpcap_tb)
 478 {
 479   /*
 480    * This will read the decryption keys from the preferences file, and will
 481    * store them into the registry...
 482    */
 483   if(airpcap_if_list != NULL && g_list_length(airpcap_if_list) > 0){
 484     if (!airpcap_check_decryption_keys(airpcap_if_list)) {
 485       /* Ask the user what to do ...*/
 486       airpcap_keys_check_w(NULL,NULL);
 487     } else {
 488       /* Keys from lists are equals, or Wireshark has got no keys */
 489       airpcap_load_decryption_keys(airpcap_if_list);
 490     }
 491   }
 492
 493   switch (airpcap_dll_ret_val) {
 494
 495   case AIRPCAP_DLL_OK:
 496     break;
 497
 498   case AIRPCAP_DLL_OLD:
 499     if(recent.airpcap_driver_check_show) {
 500       driver_warning_dialog = simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s",
 501                         "WARNING: The version of AirPcap on this system\n"
 502                         "does not support driver-level decryption.  Please\n"
 503                         "download a more recent version from\n" "http://www.cacetech.com/support/downloads.htm \n");
 504       simple_dialog_check_set(driver_warning_dialog,"Don't show this message again.");
 505       simple_dialog_set_cb(driver_warning_dialog, driver_warning_dialog_cb, NULL);
 506     }
 507     break;
 508
 509 #if 0
 510   /*
 511    * XXX - Maybe we need to warn the user if one of the following happens???
 512    */
 513   case AIRPCAP_DLL_ERROR:
 514     simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s","AIRPCAP_DLL_ERROR\n");
 515     break;
 516
 517   case AIRPCAP_DLL_NOT_FOUND:
 518     simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s","AIRPCAP_DDL_NOT_FOUND\n");
 519     break;
 520 #endif
 521   }
 522 }
 523
 524 #endif /* HAVE_AIRPCAP */