airpcap_loader.c

   1 /* airpcap_loader.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 #ifdef _WIN32
  28
  29 #ifdef HAVE_CONFIG_H
  30 # include "config.h"
  31 #endif
  32
  33 #ifdef HAVE_LIBPCAP
  34 #include <glib.h>
  35 #include <gmodule.h>
  36
  37
  38 #include <wtap.h>
  39 #include <pcap.h>
  40 #endif
  41
  42 #include <epan/packet.h>
  43 #include <epan/prefs.h>
  44 #include <epan/prefs-int.h>
  45 #include <epan/crypt/wep-wpadefs.h>
  46 #include <epan/crypt/airpdcap_ws.h>
  47 #include <epan/strutil.h>
  48 #include "capture_ui_utils.h"
  49
  50 #include "simple_dialog.h"
  51
  52 #include <airpcap.h>
  53 #include "airpcap_loader.h"
  54
  55 /*
  56  * We load dinamically the dag library in order link it only when
  57  * it's present on the system
  58  */
  59 static HMODULE AirpcapLib = NULL;
  60
  61 /*
  62  * Set to TRUE if the DLL was successfully loaded AND all functions
  63  * are present.
  64  */
  65 static gboolean AirpcapLoaded = FALSE;
  66
  67 static AirpcapGetLastErrorHandler g_PAirpcapGetLastError;
  68 static AirpcapGetDeviceListHandler g_PAirpcapGetDeviceList;
  69 static AirpcapFreeDeviceListHandler g_PAirpcapFreeDeviceList;
  70 static AirpcapOpenHandler g_PAirpcapOpen;
  71 static AirpcapCloseHandler g_PAirpcapClose;
  72 static AirpcapGetLinkTypeHandler g_PAirpcapGetLinkType;
  73 static AirpcapSetLinkTypeHandler g_PAirpcapSetLinkType;
  74 static AirpcapSetKernelBufferHandler g_PAirpcapSetKernelBuffer;
  75 static AirpcapSetFilterHandler g_PAirpcapSetFilter;
  76 static AirpcapGetMacAddressHandler g_PAirpcapGetMacAddress;
  77 static AirpcapSetMinToCopyHandler g_PAirpcapSetMinToCopy;
  78 static AirpcapGetReadEventHandler g_PAirpcapGetReadEvent;
  79 static AirpcapReadHandler g_PAirpcapRead;
  80 static AirpcapGetStatsHandler g_PAirpcapGetStats;
  81 static AirpcapTurnLedOnHandler g_PAirpcapTurnLedOn;
  82 static AirpcapTurnLedOffHandler g_PAirpcapTurnLedOff;
  83 static AirpcapGetDeviceChannelHandler g_PAirpcapGetDeviceChannel;
  84 static AirpcapSetDeviceChannelHandler g_PAirpcapSetDeviceChannel;
  85 static AirpcapGetFcsPresenceHandler g_PAirpcapGetFcsPresence;
  86 static AirpcapSetFcsPresenceHandler g_PAirpcapSetFcsPresence;
  87 static AirpcapGetFcsValidationHandler g_PAirpcapGetFcsValidation;
  88 static AirpcapSetFcsValidationHandler g_PAirpcapSetFcsValidation;
  89 static AirpcapGetDeviceKeysHandler g_PAirpcapGetDeviceKeys;
  90 static AirpcapSetDeviceKeysHandler g_PAirpcapSetDeviceKeys;
  91 static AirpcapGetDriverKeysHandler g_PAirpcapGetDriverKeys;
  92 static AirpcapSetDriverKeysHandler g_PAirpcapSetDriverKeys;
  93 static AirpcapGetDecryptionStateHandler g_PAirpcapGetDecryptionState;
  94 static AirpcapSetDecryptionStateHandler g_PAirpcapSetDecryptionState;
  95 static AirpcapGetDriverDecryptionStateHandler g_PAirpcapGetDriverDecryptionState;
  96 static AirpcapSetDriverDecryptionStateHandler g_PAirpcapSetDriverDecryptionState;
  97 static AirpcapStoreCurConfigAsAdapterDefaultHandler g_PAirpcapStoreCurConfigAsAdapterDefault;
  98 static AirpcapGetVersionHandler g_PAirpcapGetVersion;
  99
 100 /* Airpcap interface list */
 101 GList *airpcap_if_list = NULL;
 102
 103 /* Airpcap current selected interface */
 104 airpcap_if_info_t *airpcap_if_selected = NULL;
 105
 106 /* Airpcap current active interface */
 107 airpcap_if_info_t *airpcap_if_active = NULL;
 108
 109 /* WLAN preferences pointer */
 110 module_t *wlan_prefs = NULL;
 111
 112 /*
 113  * Callback used by the load_wlan_keys() routine in order to read a WEP decryption key
 114  */
 115 static guint
 116 get_wep_key(pref_t *pref, gpointer ud _U_)
 117 {
 118     gchar *my_string = NULL;
 119     keys_cb_data_t* user_data;
 120
 121     decryption_key_t* new_key;
 122
 123     /* Retrieve user data info */
 124     user_data = (keys_cb_data_t*)ud;
 125
 126     if (g_strncasecmp(pref->name, "wep_key", 7) == 0 && pref->type == PREF_STRING)
 127         {
 128         my_string = g_strdup(*pref->varp.string);
 129
 130             /* Here we have the string describing the key... */
 131             new_key = parse_key_string(my_string);
 132
 133         if( new_key != NULL)
 134             {
 135             /* Key is added only if not null ... */
 136                 user_data->list = g_list_append(user_data->list,new_key);
 137                 user_data->number_of_keys++;
 138                 user_data->current_index++;
 139                 }
 140             }
 141     return 0;
 142 }
 143
 144 /* Returs TRUE if the WEP key is valid, false otherwise */
 145 gboolean
 146 wep_key_is_valid(char* key)
 147 {
 148     GString *new_key_string;
 149     guint i=0;
 150
 151     if(key == NULL)
 152             return FALSE;
 153
 154     new_key_string = g_string_new(key);
 155
 156     if( ((new_key_string->len) > WEP_KEY_MAX_CHAR_SIZE) || ((new_key_string->len) < 2))
 157             {
 158             g_string_free(new_key_string,FALSE);
 159             return FALSE;
 160             }
 161     if((new_key_string->len % 2) != 0)
 162             {
 163             g_string_free(new_key_string,FALSE);
 164             return FALSE;
 165             }
 166     for(i = 0; i < new_key_string->len; i++)
 167             {
 168             if(!g_ascii_isxdigit(new_key_string->str[i]))
 169                     {
 170                     g_string_free(new_key_string,FALSE);
 171                     return FALSE;
 172                     }
 173             }
 174
 175     g_string_free(new_key_string,FALSE);
 176     return TRUE;
 177 }
 178
 179 /* Callback used by the save_wlan_keys() routine in order to write a decryption key */
 180 static guint
 181 set_wep_key(pref_t *pref, gpointer ud _U_)
 182 {
 183     gchar *my_string = NULL;
 184     keys_cb_data_t* user_data;
 185     gint wep_key_number = 0;
 186
 187     decryption_key_t* new_key;
 188
 189     /* Retrieve user data info */
 190     user_data = (keys_cb_data_t*)ud;
 191
 192     if (g_strncasecmp(pref->name, "wep_key", 7) == 0 && pref->type == PREF_STRING)
 193         {
 194         /* Ok, the pref we're gonna set is a wep_key ... but what number? */
 195         sscanf(pref->name,"wep_key%d",&wep_key_number);
 196
 197         if(user_data->current_index < user_data->number_of_keys)
 198             {
 199             if(wep_key_number == (user_data->current_index+1))
 200                 {
 201                             /* Retrieve the nth decryption_key_t structure pointer */
 202                             new_key = (decryption_key_t*)g_list_nth_data(user_data->list,user_data->current_index);
 203
 204                             /* Free the old key string */
 205                             g_free((void *)*pref->varp.string);
 206
 207                             /* Create the new string describing the decryption key */
 208                             my_string = get_key_string(new_key);
 209
 210                             /* Duplicate the string, and assign it to the variable pointer */
 211                             *pref->varp.string = (void *)g_strdup(my_string);
 212
 213                             /* Free the previously allocated string */
 214                 g_free(my_string);
 215                 }
 216             }
 217         else /* If the number of keys has been reduced somehow, we need to delete all the other keys
 218               * (remember that the new ones have been probably overwritten)
 219               */
 220             {
 221             g_free((void *)*pref->varp.string);
 222             *pref->varp.string = (void *)g_strdup("");  /* Do not just free memory!!! Put an 'empty' string! */
 223             }
 224         user_data->current_index++;
 225         }
 226
 227     return 0;
 228 }
 229
 230 /*
 231  * Function used to read the Decryption Keys from the preferences and store them
 232  * properly into the airpcap adapter.
 233  */
 234 BOOL
 235 load_wlan_driver_wep_keys()
 236 {
 237     keys_cb_data_t* user_data;
 238     guint i;
 239     gchar *tmp = NULL;
 240
 241     /* Retrieve the wlan preferences */
 242     wlan_prefs = prefs_find_module("wlan");
 243
 244     /* Allocate a structure used to keep infos  between the callbacks */
 245     user_data = (keys_cb_data_t*)g_malloc(sizeof(keys_cb_data_t));
 246
 247     /* Fill the structure */
 248     user_data->list = NULL;
 249     user_data->current_index = 0;
 250     user_data->number_of_keys= 0; /* Still unknown */
 251
 252     /* Run the callback on each 802.11 preference */
 253     prefs_pref_foreach(wlan_prefs, get_wep_key, (gpointer)user_data);
 254
 255     /* Now the key list should be filled */
 256
 257     /*
 258      * Signal that we've changed things, and run the 802.11 dissector's
 259      * callback
 260      */
 261     wlan_prefs->prefs_changed = TRUE;
 262
 263     prefs_apply(wlan_prefs);
 264
 265     write_wlan_driver_wep_keys_to_regitry(user_data->list);
 266
 267     /* FREE MEMORY */
 268     /* free the WEP key string */
 269     for(i=0;i<g_list_length(user_data->list);i++)
 270         {
 271         g_free(g_list_nth(user_data->list,i)->data);
 272         }
 273
 274     /* free the (empty) list */
 275     g_list_free(user_data->list);
 276
 277     /* free the user_data structure */
 278     g_free(user_data);
 279
 280     /* airpcap_if_info_free(fake_info_if); */
 281
 282     return TRUE;
 283 }
 284
 285 /*
 286  * This function will tell the airpcap driver the key list to use
 287  * This will be stored into the registry...
 288  */
 289 BOOL
 290 write_wlan_wep_keys_to_regitry(airpcap_if_info_t* info_if, GList* key_list)
 291 {
 292     UINT i,j;
 293     GString *new_key;
 294     gchar s[3];
 295     PAirpcapKeysCollection KeysCollection;
 296     ULONG KeysCollectionSize;
 297     UCHAR KeyByte;
 298     UINT keys_in_list = 0;
 299     decryption_key_t* key_item = NULL;
 300
 301     keys_in_list = g_list_length(key_list);
 302
 303     /*
 304      * Save the encryption keys, if we have any of them
 305      */
 306     KeysCollectionSize = 0;
 307
 308     /*
 309      * Calculate the size of the keys collection
 310      */
 311     KeysCollectionSize = sizeof(AirpcapKeysCollection) + keys_in_list * sizeof(AirpcapKey);
 312
 313     /*
 314      * Allocate the collection
 315      */
 316     KeysCollection = (PAirpcapKeysCollection)g_malloc(KeysCollectionSize);
 317     if(!KeysCollection)
 318     {
 319             return FALSE;
 320     }
 321
 322     /*
 323      * Populate the key collection
 324      */
 325     KeysCollection->nKeys = keys_in_list;
 326
 327     for(i = 0; i < keys_in_list; i++)
 328     {
 329         KeysCollection->Keys[i].KeyType = AIRPDCAP_KEY_TYPE_WEP;
 330
 331             /* Retrieve the Item corresponding to the i-th key */
 332             key_item = (decryption_key_t*)g_list_nth_data(key_list,i);
 333             new_key = g_string_new(key_item->key->str);
 334
 335             KeysCollection->Keys[i].KeyLen = new_key->len / 2;
 336             memset(&KeysCollection->Keys[i].KeyData, 0, sizeof(KeysCollection->Keys[i].KeyData));
 337
 338             for(j = 0 ; j < new_key->len; j += 2)
 339             {
 340                     s[0] = new_key->str[j];
 341                     s[1] = new_key->str[j+1];
 342                     s[2] = '\0';
 343                     KeyByte = (UCHAR)strtol(s, NULL, 16);
 344                     KeysCollection->Keys[i].KeyData[j / 2] = KeyByte;
 345             }
 346
 347             g_string_free(new_key,TRUE);
 348
 349     }
 350     /*
 351      * Free the old adapter key collection!
 352      */
 353     if(info_if->keysCollection != NULL)
 354             g_free(info_if->keysCollection);
 355
 356     /*
 357      * Set this collection ad the new one
 358      */
 359     info_if->keysCollection = KeysCollection;
 360     info_if->keysCollectionSize = KeysCollectionSize;
 361
 362     /*
 363      * Configuration must be saved
 364      */
 365     info_if->saved = FALSE;
 366
 367     /*
 368      * Write down the changes to the registry
 369      */
 370     airpcap_save_selected_if_configuration(info_if);
 371
 372     return TRUE;
 373 }
 374
 375 /*
 376  * This function will tell the airpcap driver the key list to use
 377  * This will be stored into the registry...
 378  */
 379 BOOL
 380 write_wlan_driver_wep_keys_to_regitry(GList* key_list)
 381 {
 382     UINT i,j,k,n,y;
 383     GString *new_key;
 384     gchar s[3];
 385     PAirpcapKeysCollection KeysCollection;
 386     ULONG KeysCollectionSize;
 387     UCHAR KeyByte;
 388     UINT keys_in_list = 0;
 389     decryption_key_t* key_item = NULL;
 390     airpcap_if_info_t* fake_info_if = NULL;
 391
 392     /* Create the fake_info_if from the first adapter of the list */
 393     fake_info_if = airpcap_driver_fake_if_info_new();
 394
 395     if(fake_info_if == NULL)
 396             return FALSE;
 397
 398     /*
 399      * XXX - When WPA will be supported, change this to: keys_in_list = g_list_length(key_list);
 400      * but right now we will have to count only the WEP keys (or we will have a malloc-mess :-) )
 401      */
 402     n = g_list_length(key_list);
 403     for(k = 0; k < n; k++ )
 404             if(((decryption_key_t*)g_list_nth_data(key_list,k))->type == AIRPDCAP_KEY_TYPE_WEP)
 405                     keys_in_list++;
 406
 407     /*
 408      * Save the encryption keys, if we have any of them
 409      */
 410     KeysCollectionSize = 0;
 411
 412     /*
 413      * Calculate the size of the keys collection
 414      */
 415     KeysCollectionSize = sizeof(AirpcapKeysCollection) + keys_in_list * sizeof(AirpcapKey);
 416
 417     /*
 418      * Allocate the collection
 419      */
 420     KeysCollection = (PAirpcapKeysCollection)g_malloc(KeysCollectionSize);
 421     if(!KeysCollection)
 422     {
 423             return FALSE;
 424     }
 425
 426     /*
 427      * Populate the key collection
 428      */
 429     KeysCollection->nKeys = keys_in_list;
 430
 431     /*
 432      * XXX - If we have, let's say, six keys, the first three are WEP, then two are WPA, and the
 433      * last is WEP, we have to scroll the whole list (n) but increment the array counter only
 434      * when a WEP key is found (y) .. When WPA will be supported by the driver, I'll have to change
 435      * this
 436      */
 437     y = 0; /* Current position in the key list */
 438
 439     for(i = 0; i < n; i++)
 440     {
 441         /* Retrieve the Item corresponding to the i-th key */
 442         key_item = (decryption_key_t*)g_list_nth_data(key_list,i);
 443
 444         /*
 445          * XXX - The AIRPDCAP_KEY_TYPE_WEP is the only supportd right now!
 446          * We will have to modify the AirpcapKey structure in order to
 447          * support the other two types! What happens now, is that simply the
 448          * not supported keys will just be discarded (they will be saved in wireshark though)
 449          */
 450         if(key_item->type == AIRPDCAP_KEY_TYPE_WEP)
 451         {
 452             KeysCollection->Keys[y].KeyType = AIRPDCAP_KEY_TYPE_WEP;
 453
 454             new_key = g_string_new(key_item->key->str);
 455
 456             KeysCollection->Keys[y].KeyLen = new_key->len / 2;
 457             memset(&KeysCollection->Keys[y].KeyData, 0, sizeof(KeysCollection->Keys[y].KeyData));
 458
 459             for(j = 0 ; j < new_key->len; j += 2)
 460             {
 461                 s[0] = new_key->str[j];
 462                 s[1] = new_key->str[j+1];
 463                 s[2] = '\0';
 464                 KeyByte = (UCHAR)strtol(s, NULL, 16);
 465                 KeysCollection->Keys[y].KeyData[j / 2] = KeyByte;
 466             }
 467             /* XXX - Change when WPA will be supported!!! */
 468             y++;
 469             g_string_free(new_key,TRUE);
 470         }
 471         else if(key_item->type == AIRPDCAP_KEY_TYPE_WPA_PWD)
 472         {
 473                 /* XXX - The driver cannot deal with this kind of key yet... */
 474         }
 475         else if(key_item->type == AIRPDCAP_KEY_TYPE_WPA_PMK)
 476         {
 477                 /* XXX - The driver cannot deal with this kind of key yet... */
 478         }
 479     }
 480
 481     /*
 482      * Free the old adapter key collection!
 483      */
 484     if(fake_info_if->keysCollection != NULL)
 485             g_free(fake_info_if->keysCollection);
 486
 487     /*
 488      * Set this collection ad the new one
 489      */
 490     fake_info_if->keysCollection = KeysCollection;
 491     fake_info_if->keysCollectionSize = KeysCollectionSize;
 492
 493     /*
 494      * Configuration must be saved
 495      */
 496     fake_info_if->saved = FALSE;
 497
 498     /*
 499      * Write down the changes to the registry
 500      */
 501     airpcap_save_driver_if_configuration(fake_info_if);
 502
 503     airpcap_if_info_free(fake_info_if);
 504
 505     return TRUE;
 506 }
 507
 508 /*
 509  *  Function used to save to the preference file the Decryption Keys.
 510  */
 511 int
 512 save_wlan_driver_wep_keys()
 513 {
 514     GList* key_list = NULL;
 515     char* tmp_key = NULL;
 516     guint keys_in_list,i;
 517     keys_cb_data_t* user_data;
 518     airpcap_if_info_t* fake_info_if = NULL;
 519
 520     /* Create the fake_info_if from the first adapter of the list */
 521     fake_info_if = airpcap_driver_fake_if_info_new();
 522
 523     if(fake_info_if == NULL)
 524             return FALSE;
 525
 526     /* Retrieve the wlan preferences */
 527     wlan_prefs = prefs_find_module("wlan");
 528
 529     /* Allocate a structure used to keep infos  between the callbacks */
 530     user_data = (keys_cb_data_t*)g_malloc(sizeof(keys_cb_data_t));
 531
 532     /* Number of keys in key list */
 533     /* Number of keys in key list */
 534     if(fake_info_if->keysCollectionSize != 0)
 535         keys_in_list = (guint)(fake_info_if->keysCollectionSize -  sizeof(AirpcapKeysCollection))/sizeof(AirpcapKey);
 536     else
 537         keys_in_list = 0;
 538
 539     for(i=0; i<keys_in_list; i++)
 540     {
 541     /* Only if it is a WEP key... */
 542     if(fake_info_if->keysCollection->Keys[i].KeyType == AIRPDCAP_KEY_TYPE_WEP)
 543         {
 544         tmp_key = airpcap_get_key_string(fake_info_if->keysCollection->Keys[i]);
 545         key_list = g_list_append(key_list,g_strdup(tmp_key));
 546         g_free(tmp_key);
 547         }
 548     }
 549
 550     /* Now we know the exact number of WEP keys in the list, so store it ... */
 551     keys_in_list = g_list_length(key_list);
 552
 553     /* Fill the structure */
 554     user_data->list = key_list;
 555     user_data->current_index = 0;
 556     user_data->number_of_keys= keys_in_list;
 557
 558     /* Retrieve the wlan preferences */
 559     wlan_prefs = prefs_find_module("wlan");
 560
 561     /* Run the callback on each 802.11 preference */
 562     prefs_pref_foreach(wlan_prefs, set_wep_key,  (gpointer)user_data);
 563
 564     /* Signal that we've changed things, and run the 802.11 dissector's
 565      * callback */
 566     wlan_prefs->prefs_changed = TRUE;
 567
 568     /* Apply changes for the specified preference */
 569     prefs_apply(wlan_prefs);
 570
 571     /* FREE MEMORY */
 572     /* free the WEP key string */
 573     for(i=0;i<g_list_length(user_data->list);i++)
 574         {
 575         g_free(g_list_nth(user_data->list,i)->data);
 576         }
 577
 578     /* free the (empty) list */
 579     g_list_free(user_data->list);
 580
 581     /* free the user_data structure */
 582     g_free(user_data);
 583
 584     airpcap_if_info_free(fake_info_if);
 585
 586     return keys_in_list;
 587 }
 588
 589 /*
 590  *  Function used to save to the preference file the Decryption Keys.
 591  */
 592 int
 593 save_wlan_wireshark_wep_keys(GList* key_ls)
 594 {
 595     GList* key_list = NULL;
 596     char* tmp_key = NULL;
 597     guint keys_in_list,i;
 598     keys_cb_data_t* user_data;
 599     airpcap_if_info_t* fake_info_if = NULL;
 600     decryption_key_t* tmp_dk;
 601
 602     /* Retrieve the wlan preferences */
 603     wlan_prefs = prefs_find_module("wlan");
 604
 605     /* Allocate a structure used to keep infos  between the callbacks */
 606     user_data = (keys_cb_data_t*)g_malloc(sizeof(keys_cb_data_t));
 607
 608     keys_in_list = g_list_length(key_ls);
 609
 610     key_list = key_ls;
 611
 612     /* Fill the structure */
 613     user_data->list = key_list;
 614     user_data->current_index = 0;
 615     user_data->number_of_keys= keys_in_list;
 616
 617     /* Retrieve the wlan preferences */
 618     wlan_prefs = prefs_find_module("wlan");
 619
 620     /* Run the callback on each 802.11 preference */
 621     prefs_pref_foreach(wlan_prefs, set_wep_key,  (gpointer)user_data);
 622
 623     /* Signal that we've changed things, and run the 802.11 dissector's
 624      * callback */
 625     wlan_prefs->prefs_changed = TRUE;
 626
 627     /* Apply changes for the specified preference */
 628     prefs_apply(wlan_prefs);
 629
 630     /* FREE MEMORY */
 631     /* free the WEP key string */
 632     for(i=0;i<g_list_length(user_data->list);i++)
 633         {
 634             tmp_dk = (decryption_key_t*)g_list_nth(user_data->list,i)->data;
 635             g_string_free(tmp_dk->key,TRUE);
 636             if(tmp_dk->ssid != NULL) g_byte_array_free(tmp_dk->ssid,TRUE);
 637         }
 638
 639     /* free the (empty) list */
 640     g_list_free(user_data->list);
 641
 642     /* free the user_data structure */
 643     g_free(user_data);
 644
 645     return keys_in_list;
 646 }
 647
 648 /*
 649  * Get an error message string for a CANT_GET_INTERFACE_LIST error from
 650  * "get_airpcap_interface_list()".
 651  */
 652 gchar *
 653 cant_get_airpcap_if_list_error_message(const char *err_str)
 654 {
 655         return g_strdup_printf("Can't get list of Wireless interfaces: %s", err_str);
 656 }
 657
 658 /*
 659  * Airpcap wrapper, used to store the current settings for the selected adapter
 660  */
 661 BOOL
 662 airpcap_if_store_cur_config_as_adapter_default(PAirpcapHandle ah)
 663 {
 664         if (!AirpcapLoaded) return FALSE;
 665         return g_PAirpcapStoreCurConfigAsAdapterDefault(ah);
 666 }
 667
 668 /*
 669  * Airpcap wrapper, used to open an airpcap adapter
 670  */
 671 PAirpcapHandle
 672 airpcap_if_open(PCHAR name, PCHAR err)
 673 {
 674         if (!AirpcapLoaded) return NULL;
 675         if (name == NULL) return NULL;
 676         return g_PAirpcapOpen(name,err);
 677 }
 678
 679 /*
 680  * Airpcap wrapper, used to close an airpcap adapter
 681  */
 682 VOID
 683 airpcap_if_close(PAirpcapHandle handle)
 684 {
 685         if (!AirpcapLoaded) return;
 686         g_PAirpcapClose(handle);
 687 }
 688
 689 /*
 690  * Airpcap wrapper, used to turn on the led of an airpcap adapter
 691  */
 692 BOOL
 693 airpcap_if_turn_led_on(PAirpcapHandle AdapterHandle, UINT LedNumber)
 694 {
 695         if (!AirpcapLoaded) return FALSE;
 696         return g_PAirpcapTurnLedOn(AdapterHandle,LedNumber);
 697 }
 698
 699 /*
 700  * Airpcap wrapper, used to turn off the led of an airpcap adapter
 701  */
 702 BOOL
 703 airpcap_if_turn_led_off(PAirpcapHandle AdapterHandle, UINT LedNumber)
 704 {
 705         if (!AirpcapLoaded) return FALSE;
 706         return g_PAirpcapTurnLedOff(AdapterHandle,LedNumber);
 707 }
 708
 709 /*
 710  * Airpcap wrapper, used to get the channel of an airpcap adapter
 711  */
 712 BOOL
 713 airpcap_if_get_device_channel(PAirpcapHandle ah, PUINT ch)
 714 {
 715         if (!AirpcapLoaded) return FALSE;
 716         return g_PAirpcapGetDeviceChannel(ah,ch);
 717 }
 718
 719 /*
 720  * Airpcap wrapper, used to set the channel of an airpcap adapter
 721  */
 722 BOOL
 723 airpcap_if_set_device_channel(PAirpcapHandle ah, UINT ch)
 724 {
 725         if (!AirpcapLoaded) return FALSE;
 726         return g_PAirpcapSetDeviceChannel(ah,ch);
 727 }
 728
 729 /*
 730  * Airpcap wrapper, used to get the link type of an airpcap adapter
 731  */
 732 BOOL
 733 airpcap_if_get_link_type(PAirpcapHandle ah, PAirpcapLinkType lt)
 734 {
 735         if (!AirpcapLoaded) return FALSE;
 736         return g_PAirpcapGetLinkType(ah,lt);
 737 }
 738
 739 /*
 740  * Airpcap wrapper, used to set the link type of an airpcap adapter
 741  */
 742 BOOL
 743 airpcap_if_set_link_type(PAirpcapHandle ah, AirpcapLinkType lt)
 744 {
 745         if (!AirpcapLoaded) return FALSE;
 746         return g_PAirpcapSetLinkType(ah,lt);
 747 }
 748
 749 /*
 750  * Airpcap wrapper, used to get the fcs presence of an airpcap adapter
 751  */
 752 BOOL
 753 airpcap_if_get_fcs_presence(PAirpcapHandle ah, PBOOL fcs)
 754 {
 755         if (!AirpcapLoaded) return FALSE;
 756         return g_PAirpcapGetFcsPresence(ah,fcs);
 757 }
 758
 759 /*
 760  * Airpcap wrapper, used to set the fcs presence of an airpcap adapter
 761  */
 762 BOOL
 763 airpcap_if_set_fcs_presence(PAirpcapHandle ah, BOOL fcs)
 764 {
 765         if (!AirpcapLoaded) return FALSE;
 766         return g_PAirpcapSetFcsPresence(ah,fcs);
 767 }
 768
 769 /*
 770  * Airpcap wrapper, used to get the decryption enabling of an airpcap adapter
 771  */
 772 BOOL
 773 airpcap_if_get_decryption_state(PAirpcapHandle ah, PAirpcapDecryptionState PEnable)
 774 {
 775         if (!AirpcapLoaded) return FALSE;
 776         return g_PAirpcapGetDecryptionState(ah,PEnable);
 777 }
 778
 779 /*
 780  * Airpcap wrapper, used to set the decryption enabling of an airpcap adapter
 781  */
 782 BOOL
 783 airpcap_if_set_decryption_state(PAirpcapHandle ah, AirpcapDecryptionState Enable)
 784 {
 785         if (!AirpcapLoaded) return FALSE;
 786         return g_PAirpcapSetDecryptionState(ah,Enable);
 787 }
 788
 789 /*
 790  * Airpcap wrapper, used to get the decryption enabling of an airpcap driver
 791  */
 792 BOOL
 793 airpcap_if_get_driver_decryption_state(PAirpcapHandle ah, PAirpcapDecryptionState PEnable)
 794 {
 795         if (!AirpcapLoaded || (g_PAirpcapGetDriverDecryptionState==NULL)) return FALSE;
 796         return g_PAirpcapGetDriverDecryptionState(ah,PEnable);
 797 }
 798
 799 /*
 800  * Airpcap wrapper, used to set the decryption enabling of an airpcap driver
 801  */
 802 BOOL
 803 airpcap_if_set_driver_decryption_state(PAirpcapHandle ah, AirpcapDecryptionState Enable)
 804 {
 805         if (!AirpcapLoaded || (g_PAirpcapSetDriverDecryptionState==NULL)) return FALSE;
 806         return g_PAirpcapSetDriverDecryptionState(ah,Enable);
 807 }
 808
 809 /*
 810  * Airpcap wrapper, used to get the fcs validation of an airpcap adapter
 811  */
 812 BOOL
 813 airpcap_if_get_fcs_validation(PAirpcapHandle ah, PAirpcapValidationType val)
 814 {
 815         if (!AirpcapLoaded) return FALSE;
 816         return g_PAirpcapGetFcsValidation(ah,val);
 817 }
 818
 819 /*
 820  * Airpcap wrapper, used to set the fcs validation of an airpcap adapter
 821  */
 822 BOOL
 823 airpcap_if_set_fcs_validation(PAirpcapHandle ah, AirpcapValidationType val)
 824 {
 825         if (!AirpcapLoaded) return FALSE;
 826         return g_PAirpcapSetFcsValidation(ah,val);
 827 }
 828
 829 /*
 830  * Airpcap wrapper, used to save the settings for the selected_if
 831  */
 832 BOOL
 833 airpcap_if_set_device_keys(PAirpcapHandle AdapterHandle, PAirpcapKeysCollection KeysCollection)
 834 {
 835         if (!AirpcapLoaded) return FALSE;
 836         return g_PAirpcapSetDeviceKeys(AdapterHandle,KeysCollection);
 837 }
 838
 839 /*
 840  * Airpcap wrapper, used to save the settings for the selected_if
 841  */
 842 BOOL
 843 airpcap_if_get_device_keys(PAirpcapHandle AdapterHandle, PAirpcapKeysCollection KeysCollection, PUINT PKeysCollectionSize)
 844 {
 845         if (!AirpcapLoaded) return FALSE;
 846         return g_PAirpcapGetDeviceKeys(AdapterHandle,KeysCollection,PKeysCollectionSize);
 847 }
 848
 849 /*
 850  * Airpcap wrapper, used to save the driver's set of keys
 851  */
 852 BOOL
 853 airpcap_if_set_driver_keys(PAirpcapHandle AdapterHandle, PAirpcapKeysCollection KeysCollection)
 854 {
 855         if (!AirpcapLoaded || (g_PAirpcapSetDriverKeys==NULL)) return FALSE;
 856         return g_PAirpcapSetDriverKeys(AdapterHandle,KeysCollection);
 857 }
 858
 859 /*
 860  * Airpcap wrapper, used to load the driver's set of keys
 861  */
 862 BOOL
 863 airpcap_if_get_driver_keys(PAirpcapHandle AdapterHandle, PAirpcapKeysCollection KeysCollection, PUINT PKeysCollectionSize)
 864 {
 865         if (!AirpcapLoaded || (g_PAirpcapGetDriverKeys==NULL)) return FALSE;
 866         return g_PAirpcapGetDriverKeys(AdapterHandle,KeysCollection,PKeysCollectionSize);
 867 }
 868
 869 /*
 870  * This function will create a new airpcap_if_info_t using a name and a description
 871  */
 872 airpcap_if_info_t *
 873 airpcap_if_info_new(char *name, char *description)
 874 {
 875 PAirpcapHandle ad;
 876 gchar ebuf[AIRPCAP_ERRBUF_SIZE];
 877
 878         airpcap_if_info_t *if_info = NULL;
 879
 880         /* Probably I have to switch on the leds!!! */
 881         ad = airpcap_if_open(name, ebuf);
 882         if(ad)
 883                 {
 884         if_info = g_malloc(sizeof (airpcap_if_info_t));
 885         if_info->name = g_strdup(name);
 886         if (description == NULL)
 887                 if_info->description = NULL;
 888         else
 889                 if_info->description = g_strdup(description);
 890         if_info->ip_addr = NULL;
 891         if_info->loopback = FALSE;
 892                 airpcap_if_get_fcs_validation(ad,&(if_info->CrcValidationOn));
 893                 airpcap_if_get_fcs_presence(ad,&(if_info->IsFcsPresent));
 894                 airpcap_if_get_link_type(ad,&(if_info->linkType));
 895                 airpcap_if_get_device_channel(ad,&(if_info->channel));
 896                 airpcap_if_turn_led_on(ad, 0);
 897                 airpcap_if_get_decryption_state(ad, &(if_info->DecryptionOn));
 898                 if_info->led = TRUE;
 899                 if_info->blinking = FALSE;
 900                 if_info->saved = TRUE; /* NO NEED TO BE SAVED */
 901
 902                 /* get the keys, if everything is ok, close the adapter */
 903                 if(airpcap_if_load_keys(ad,if_info))
 904                         airpcap_if_close(ad);
 905                 }
 906         return if_info;
 907 }
 908
 909 /*
 910  * This function will create a new fake drivers' interface, to load global keys...
 911  */
 912 airpcap_if_info_t*
 913 airpcap_driver_fake_if_info_new()
 914 {
 915         PAirpcapHandle ad;
 916         gchar ebuf[AIRPCAP_ERRBUF_SIZE];
 917
 918         airpcap_if_info_t *if_info = NULL;
 919         airpcap_if_info_t *fake_if_info = NULL;
 920
 921         /* Maybe for some reason no airpcap adapter is found */
 922         if(airpcap_if_list == NULL)
 923                 return NULL;
 924
 925         /*
 926          * Retrieve the first AirPcap adapter available. If no interface is found,
 927          * it is not possible to retrieve the driver's settings, so return NULL.
 928          */
 929         if_info = g_list_nth_data(airpcap_if_list,0);
 930         if(if_info == NULL)
 931                 return NULL;
 932
 933         /* Open the 'fake' adapter */
 934         ad = airpcap_if_open(if_info->name, ebuf);
 935         if(ad)
 936                 {
 937         fake_if_info = g_malloc(sizeof (airpcap_if_info_t));
 938         fake_if_info->name = g_strdup(if_info->name);
 939         fake_if_info->description = g_strdup(if_info->description);
 940         fake_if_info->loopback = FALSE;
 941         fake_if_info->ip_addr = NULL;
 942                 airpcap_if_get_driver_decryption_state(ad, &(fake_if_info->DecryptionOn));
 943                 airpcap_if_get_fcs_validation(ad,&(fake_if_info->CrcValidationOn));
 944                 airpcap_if_get_fcs_presence(ad,&(fake_if_info->IsFcsPresent));
 945                 airpcap_if_get_link_type(ad,&(fake_if_info->linkType));
 946                 airpcap_if_get_device_channel(ad,&(fake_if_info->channel));
 947                 airpcap_if_turn_led_on(ad, 0);
 948                 fake_if_info->led = TRUE;
 949                 fake_if_info->blinking = FALSE;
 950                 fake_if_info->saved = TRUE; /* NO NEED TO BE SAVED */
 951
 952                 /* get the keys, if everything is ok, close the adapter */
 953                 if(airpcap_if_load_driver_keys(ad,fake_if_info))
 954                         airpcap_if_close(ad);
 955                 }
 956
 957         return fake_if_info;
 958 }
 959
 960 /*
 961  * USED FOR DEBUG ONLY... PRINTS AN AirPcap ADAPTER STRUCTURE in a fancy way.
 962  */
 963 void
 964 airpcap_if_info_print(airpcap_if_info_t* if_info)
 965 {
 966     if(if_info == NULL)
 967             {
 968             g_print("\nWARNING : AirPcap Interface pointer is NULL!\n");
 969             return;
 970             }
 971
 972     g_print("\n----------------- AirPcap Interface \n");
 973     g_print("              NAME: %s\n",if_info->name);
 974     g_print("       DESCRIPTION: %s\n",if_info->description);
 975     g_print("          BLINKING: %s\n",if_info->blinking ? "TRUE" : "FALSE");
 976     g_print("           CHANNEL: %2u\n",if_info->channel);
 977     g_print("     CRCVALIDATION: %s\n",if_info->CrcValidationOn ? "ON" : "OFF");
 978     g_print("        DECRYPTION: %s\n",if_info->DecryptionOn ? "ON" : "OFF");
 979     g_print("           IP ADDR: %s\n",if_info->ip_addr!=NULL ? "NOT NULL" : "NULL");
 980     g_print("        FCSPRESENT: %s\n",if_info->IsFcsPresent ? "TRUE" : "FALSE");
 981     g_print("    KEYSCOLLECTION: %s\n",if_info->keysCollection!=NULL ? "NOT NULL" : "NULL");
 982     g_print("KEYSCOLLECTIONSIZE: %u\n",if_info->keysCollectionSize);
 983     g_print("               LED: %s\n",if_info->led ? "ON" : "OFF");
 984     g_print("          LINKTYPE: %d\n",if_info->linkType);
 985     g_print("          LOOPBACK: %s\n",if_info->loopback ? "YES" : "NO");
 986     g_print("         (GTK) TAG: %d\n",if_info->tag);
 987     g_print("\n\n");
 988 }
 989
 990 /*
 991  * Function used to load the WEP keys for a selected interface
 992  */
 993 BOOL
 994 airpcap_if_load_keys(PAirpcapHandle ad, airpcap_if_info_t *if_info)
 995 {
 996     if(!if_info) return FALSE;
 997
 998     if_info->keysCollectionSize = 0;
 999     if_info->keysCollection = NULL;
1000
1001     if(!airpcap_if_get_device_keys(ad, NULL, &(if_info->keysCollectionSize)))
1002             {
1003             if(if_info->keysCollectionSize == 0)
1004                     {
1005                     if_info->keysCollection = NULL;
1006                     airpcap_if_close(ad);
1007                     return FALSE;
1008                     }
1009
1010             if_info->keysCollection = (PAirpcapKeysCollection)g_malloc(if_info->keysCollectionSize);
1011             if(!if_info->keysCollection)
1012                     {
1013                     if_info->keysCollectionSize = 0;
1014                     if_info->keysCollection = NULL;
1015                     airpcap_if_close(ad);
1016                     return FALSE;
1017                     }
1018
1019             airpcap_if_get_device_keys(ad, if_info->keysCollection, &(if_info->keysCollectionSize));
1020             return TRUE;
1021             }
1022
1023     airpcap_if_close(ad);
1024     return FALSE;
1025 }
1026
1027 /*
1028  * Function used to load the WEP keys for a selected interface
1029  */
1030 BOOL
1031 airpcap_if_load_driver_keys(PAirpcapHandle ad, airpcap_if_info_t *if_info)
1032 {
1033     if_info->keysCollectionSize = 0;
1034     if_info->keysCollection = NULL;
1035
1036     if(!airpcap_if_get_driver_keys(ad, NULL, &(if_info->keysCollectionSize)))
1037             {
1038             if(if_info->keysCollectionSize == 0)
1039                     {
1040                     if_info->keysCollection = NULL;
1041                     airpcap_if_close(ad);
1042                     return FALSE;
1043                     }
1044
1045             if_info->keysCollection = (PAirpcapKeysCollection)g_malloc(if_info->keysCollectionSize);
1046             if(!if_info->keysCollection)
1047                     {
1048                     if_info->keysCollectionSize = 0;
1049                     if_info->keysCollection = NULL;
1050                     airpcap_if_close(ad);
1051                     return FALSE;
1052                     }
1053
1054             airpcap_if_get_driver_keys(ad, if_info->keysCollection, &(if_info->keysCollectionSize));
1055             return TRUE;
1056             }
1057
1058     airpcap_if_close(ad);
1059     return FALSE;
1060 }
1061
1062 /*
1063  * Function used to save the WEP keys for a selected interface
1064  */
1065 void
1066 airpcap_if_save_keys(PAirpcapHandle ad, airpcap_if_info_t *if_info)
1067 {
1068         if(!if_info || !AirpcapLoaded) return;
1069
1070         if(if_info->keysCollection != NULL)
1071                 g_PAirpcapSetDeviceKeys(ad,if_info->keysCollection);
1072 }
1073
1074 /*
1075  * Function used to save the WEP keys for a selected interface
1076  */
1077 void
1078 airpcap_if_save_driver_keys(PAirpcapHandle ad, airpcap_if_info_t *if_info)
1079 {
1080         if(if_info->keysCollection != NULL)
1081                 airpcap_if_set_driver_keys(ad,if_info->keysCollection);
1082 }
1083
1084 /*
1085  * Callback used to free an instance of airpcap_if_info_t
1086  */
1087 static void
1088 free_airpcap_if_cb(gpointer data, gpointer user_data _U_)
1089 {
1090         airpcap_if_info_t *if_info = data;
1091
1092         if (if_info->name != NULL)
1093                 g_free(if_info->name);
1094
1095         if (if_info->description != NULL)
1096                 g_free(if_info->description);
1097
1098         /* XXX - FREE THE WEP KEY LIST HERE!!!*/
1099         if(if_info->keysCollection != NULL)
1100                 {
1101                 g_free(if_info->keysCollection);
1102                 if_info->keysCollection = NULL;
1103                 }
1104
1105         if(if_info->ip_addr != NULL)
1106                 g_slist_free(if_info->ip_addr);
1107
1108         if(if_info != NULL)
1109                 g_free(if_info);
1110 }
1111
1112 /*
1113  * Function used to free the airpcap interface list
1114  */
1115 void
1116 free_airpcap_interface_list(GList *if_list)
1117 {
1118         g_list_foreach(if_list, free_airpcap_if_cb, NULL);
1119         g_list_free(if_list);
1120         if_list = NULL;
1121 }
1122
1123 /*
1124  * This function will use the airpcap.dll to find all the airpcap devices.
1125  * Will return null if no device is found.
1126  */
1127 GList*
1128 get_airpcap_interface_list(int *err, char *err_str)
1129 {
1130     GList  *il = NULL;
1131     airpcap_if_info_t *if_info;
1132     int i, n_adapts;
1133     AirpcapDeviceDescription *devsList, *adListEntry;
1134
1135     if (err)
1136             *err = NO_AIRPCAP_INTERFACES_FOUND;
1137
1138     if(!AirpcapLoaded || !g_PAirpcapGetDeviceList(&devsList, err_str))
1139     {
1140             /* No interfaces, return il = NULL; */
1141             return il;
1142     }
1143
1144     /*
1145      * Count the adapters
1146      */
1147     adListEntry = devsList;
1148     n_adapts = 0;
1149     while(adListEntry)
1150     {
1151             n_adapts++;
1152             adListEntry = adListEntry->next;
1153     }
1154
1155     if(n_adapts == 0)
1156     {
1157             /* No interfaces, return il= NULL */
1158             g_PAirpcapFreeDeviceList(devsList);
1159             return il;
1160     }
1161
1162     /*
1163      * Insert the adapters in our list
1164      */
1165     adListEntry = devsList;
1166     for(i = 0; i < n_adapts; i++)
1167     {
1168             if_info = airpcap_if_info_new(adListEntry->Name, adListEntry->Description);
1169     il = g_list_append(il, if_info);
1170
1171             adListEntry = adListEntry->next;
1172     }
1173
1174     g_PAirpcapFreeDeviceList(devsList);
1175
1176     return il;
1177 }
1178
1179 /*
1180  * Used to retrieve the name of the interface given the description
1181  * (the name is used in AirpcapOpen, the description is put in the combo box)
1182  */
1183 gchar* get_airpcap_name_from_description(GList* if_list, gchar* description)
1184 {
1185     unsigned int ifn;
1186     GList* curr;
1187     airpcap_if_info_t* if_info;
1188
1189     ifn = 0;
1190     if(if_list != NULL)
1191     {
1192         while( ifn < g_list_length(if_list) )
1193         {
1194             curr = g_list_nth(if_list, ifn);
1195
1196             if_info = NULL;
1197             if(curr != NULL)
1198                     if_info = curr->data;
1199             if(if_info != NULL)
1200                     if ( g_ascii_strcasecmp(if_info->description,description) == 0)
1201                     {
1202                         return if_info->name;
1203                     }
1204             ifn++;
1205         }
1206     }
1207     return NULL;
1208 }
1209
1210 /*
1211  * Used to retrieve the interface given the name
1212  * (the name is used in AirpcapOpen)
1213  */
1214 airpcap_if_info_t* get_airpcap_if_by_name(GList* if_list, const gchar* name)
1215 {
1216     unsigned int ifn;
1217     GList* curr;
1218     airpcap_if_info_t* if_info;
1219
1220     ifn = 0;
1221     if(if_list != NULL)
1222             {
1223             while( ifn < g_list_length(if_list) )
1224                     {
1225                     curr = g_list_nth(if_list, ifn);
1226
1227                     if_info = NULL;
1228                     if(curr != NULL)
1229                             if_info = curr->data;
1230                     if(if_info != NULL)
1231                             if ( g_ascii_strcasecmp(if_info->name,name) == 0)
1232                                     {
1233                                     return if_info;
1234                                     }
1235                     ifn++;
1236                     }
1237             }
1238     return NULL;
1239 }
1240
1241 /*
1242  * Returns the ASCII string of a key given the key bytes
1243  */
1244 gchar*
1245 airpcap_get_key_string(AirpcapKey key)
1246 {
1247     unsigned int j = 0;
1248     unsigned int l = 0;
1249     gchar *dst,*src;
1250
1251     dst = NULL;
1252     src = NULL;
1253
1254     if(key.KeyType == AIRPDCAP_KEY_TYPE_WEP)
1255             {
1256             if(key.KeyLen != 0)
1257                 {
1258             /* Allocate the string used to store the ASCII representation of the WEP key */
1259             dst = (gchar*)g_malloc(sizeof(gchar)*WEP_KEY_MAX_CHAR_SIZE + 1);
1260             /* Make sure that the first char is '\0' in order to make g_strlcat() work */
1261             dst[0]='\0';
1262
1263                 for(j = 0; j < key.KeyLen; j++)
1264                         {
1265                         src = g_strdup_printf("%.2x\0", key.KeyData[j]);
1266                             /*
1267                              * XXX - use g_strconcat() or GStrings instead ???
1268                              */
1269                     l = g_strlcat(dst,src,WEP_KEY_MAX_CHAR_SIZE+1);
1270                     }
1271             g_free(src);
1272             }
1273             }
1274     else if(key.KeyType == AIRPDCAP_KEY_TYPE_WPA_PWD)
1275         {
1276         /* XXX - Add code here */
1277         }
1278     else if(key.KeyType == AIRPDCAP_KEY_TYPE_WPA_PMK)
1279         {
1280         /* XXX - Add code here */
1281         }
1282     else
1283         {
1284         /* XXX - Add code here */
1285         }
1286
1287     return dst;
1288 }
1289
1290 /*
1291  * Clear keys and decryption status for the specified interface
1292  */
1293 void
1294 airpcap_if_clear_decryption_settings(airpcap_if_info_t* info_if)
1295 {
1296     if(info_if != NULL)
1297     {
1298         if(info_if->keysCollection != NULL)
1299         {
1300                 g_free(info_if->keysCollection);
1301                 info_if->keysCollection = NULL;
1302         }
1303
1304         info_if->keysCollectionSize = 0;
1305
1306         info_if->DecryptionOn = FALSE;
1307         info_if->saved = FALSE;
1308     }
1309 }
1310
1311 /*
1312  * Used to retrieve the airpcap_if_info_t of the selected interface given the
1313  * description (that is the entry of the combo box).
1314  */
1315 gpointer get_airpcap_if_from_description(GList* if_list, const gchar* description)
1316 {
1317     unsigned int ifn;
1318     GList* curr;
1319     airpcap_if_info_t* if_info;
1320
1321     ifn = 0;
1322     if(if_list != NULL)
1323             {
1324             while( ifn < g_list_length(if_list) )
1325                     {
1326                     curr = g_list_nth(if_list, ifn);
1327
1328                     if_info = NULL;
1329                     if(curr != NULL)
1330                             if_info = curr->data;
1331                     if(if_info != NULL)
1332                             if ( g_ascii_strcasecmp(if_info->description,description) == 0)
1333                                     {
1334                                     return if_info;
1335                                     }
1336                     ifn++;
1337                     }
1338             }
1339     return NULL;
1340 }
1341
1342 /*
1343  * Used to retrieve the two chars string from interface
1344  */
1345 gchar*
1346 airpcap_get_if_string_number(airpcap_if_info_t* if_info)
1347 {
1348         gchar* number;
1349         guint n;
1350         int a;
1351
1352         a = sscanf(if_info->name,AIRPCAP_DEVICE_NUMBER_EXTRACT_STRING,&n);
1353
1354     /* If sscanf() returned 1, it means that has read a number, so interface is not "Any"
1355      * Otherwise, check if it is the "Any" adapter...
1356      */
1357      if(a == 0)
1358           {
1359           if(g_strcasecmp(if_info->name,AIRPCAP_DEVICE_ANY_EXTRACT_STRING)!=0)
1360                number = g_strdup_printf("??");
1361           else
1362                number = g_strdup_printf(AIRPCAP_CHANNEL_ANY_NAME);
1363           }
1364      else
1365           {
1366           number = g_strdup_printf("%.2u\0",n);
1367           }
1368
1369         return number;
1370 }
1371
1372 /*
1373  * Used to retrieve the two chars string from interface
1374  */
1375 gchar*
1376 airpcap_get_if_string_number_from_description(gchar* description)
1377 {
1378         gchar* number;
1379         gchar* pointer;
1380
1381         number = (gchar*)g_malloc(sizeof(gchar)*3);
1382
1383         pointer = g_strrstr(description,"#\0");
1384
1385         number[0] = *(pointer+1);
1386         number[1] = *(pointer+2);
1387         number[2] = '\0';
1388
1389         return number;
1390 }
1391
1392 /*
1393  * Returns the default airpcap interface of a list, NULL if list is empty
1394  */
1395 airpcap_if_info_t*
1396 airpcap_get_default_if(GList* airpcap_if_list)
1397 {
1398 int ifn = 0;
1399 GList* popdown_if_list = NULL;
1400 GList* curr = NULL;
1401
1402         gchar* s;
1403         airpcap_if_info_t* if_info = NULL;
1404
1405     if(prefs.capture_device != NULL)
1406     {
1407         s = g_strdup(get_if_name(prefs.capture_device));
1408         if_info = get_airpcap_if_by_name(airpcap_if_list,g_strdup(get_if_name(prefs.capture_device)));
1409         g_free(s);
1410     }
1411         return if_info;
1412 }
1413
1414 /*
1415  * Load the configuration for the specified interface
1416  */
1417 void
1418 airpcap_load_selected_if_configuration(airpcap_if_info_t* if_info)
1419 {
1420     gchar ebuf[AIRPCAP_ERRBUF_SIZE];
1421     PAirpcapHandle ad;
1422
1423     if(if_info != NULL)
1424         {
1425         ad = airpcap_if_open(get_airpcap_name_from_description(airpcap_if_list, if_info->description), ebuf);
1426
1427         if(ad)
1428                 {
1429                 /* Stop blinking (if it was blinkig!)*/
1430                 if(if_info->blinking)
1431                         {
1432                         /* Turn on the light (if it was off) */
1433                         if(!(if_info->led)) airpcap_if_turn_led_on(ad, 0);
1434                         }
1435
1436                 /* Apply settings... */
1437                 airpcap_if_get_device_channel(ad,&(if_info->channel));
1438                 airpcap_if_get_fcs_validation(ad,&(if_info->CrcValidationOn));
1439                 airpcap_if_get_fcs_presence(ad,&(if_info->IsFcsPresent));
1440                 airpcap_if_get_link_type(ad,&(if_info->linkType));
1441                 airpcap_if_get_decryption_state(ad, &(if_info->DecryptionOn));
1442                 /* get the keys, if everything is ok, close the adapter */
1443                 if(airpcap_if_load_keys(ad,if_info))
1444                         airpcap_if_close(ad);
1445
1446                 if_info->saved = TRUE;
1447                 }
1448         else
1449                 {
1450                 simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, " Error in opening adapter for %s",if_info->description);
1451                 }
1452         }
1453 }
1454
1455 /*
1456  * Save the configuration for the specified interface
1457  */
1458 void
1459 airpcap_save_selected_if_configuration(airpcap_if_info_t* if_info)
1460 {
1461     gchar ebuf[AIRPCAP_ERRBUF_SIZE];
1462     PAirpcapHandle ad;
1463
1464     if(if_info != NULL)
1465     {
1466         ad = airpcap_if_open(get_airpcap_name_from_description(airpcap_if_list, if_info->description), ebuf);
1467
1468         if(ad)
1469                 {
1470                 /* Stop blinking (if it was blinkig!)*/
1471                 if(if_info->blinking)
1472                         {
1473                         /* Turn on the light (if it was off) */
1474                         if(!(if_info->led)) airpcap_if_turn_led_on(ad, 0);
1475                         }
1476
1477                 /* Apply settings... */
1478                 airpcap_if_set_device_channel(ad,if_info->channel);
1479                 airpcap_if_set_fcs_validation(ad,if_info->CrcValidationOn);
1480                 airpcap_if_set_fcs_presence(ad,if_info->IsFcsPresent);
1481                 airpcap_if_set_link_type(ad,if_info->linkType);
1482                 airpcap_if_set_decryption_state(ad, if_info->DecryptionOn);
1483                 airpcap_if_save_keys(ad,if_info);
1484
1485                 /* ... and save them */
1486                 if(!airpcap_if_store_cur_config_as_adapter_default(ad))
1487                         {
1488                         simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "Cannot save Wireless 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.");
1489                         if_info->saved = FALSE;
1490                         airpcap_if_close(ad);
1491                         return;
1492                         }
1493
1494                 if_info->saved = TRUE;
1495                 airpcap_if_close(ad);
1496                 }
1497         else
1498                 {
1499                 simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, " Error in opening adapter for %s",if_info->description);
1500                 }
1501     }
1502 }
1503
1504 /*
1505  * Save the configuration for the specified interface
1506  */
1507 void
1508 airpcap_save_driver_if_configuration(airpcap_if_info_t* fake_if_info)
1509 {
1510     gchar ebuf[AIRPCAP_ERRBUF_SIZE];
1511     PAirpcapHandle ad;
1512
1513     if(fake_if_info != NULL)
1514     {
1515         ad = airpcap_if_open(fake_if_info->name, ebuf);
1516
1517         if(ad)
1518                 {
1519                 /* Apply decryption settings... */
1520                 airpcap_if_set_driver_decryption_state(ad, fake_if_info->DecryptionOn);
1521                 airpcap_if_save_driver_keys(ad,fake_if_info);
1522                 airpcap_if_close(ad);
1523                 }
1524         else
1525                 {
1526                 simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, " Error in opening adapter for %s",fake_if_info->description);
1527                 }
1528     }
1529
1530     return;
1531 }
1532
1533 /*
1534  * DECRYPTION KEYS FUNCTIONS
1535  */
1536 /*
1537  * This function is used for DEBUG POURPOSES ONLY!!!
1538  */
1539 void
1540 print_key_list(GList* key_list)
1541 {
1542     gint n,i;
1543     decryption_key_t* tmp;
1544
1545     if(key_list == NULL)
1546     {
1547     g_print("\n\n******* KEY LIST NULL *******\n\n");
1548     return;
1549     }
1550
1551     n = g_list_length(key_list);
1552
1553     g_print("\n\n********* KEY LIST **********\n\n");
1554
1555     g_print("NUMBER OF KEYS IN LIST : %d\n\n",n);
1556
1557     for(i =0; i < n; i++)
1558     {
1559     g_print("[%d] :\n",i+1);
1560     tmp = (decryption_key_t*)(g_list_nth_data(key_list,i));
1561     g_print("KEY : %s\n",tmp->key->str);
1562
1563     g_print("BITS: %d\n",tmp->bits);
1564
1565     if(tmp->type == AIRPDCAP_KEY_TYPE_WEP)
1566         g_print("TYPE: %s\n",AIRPCAP_WEP_KEY_STRING);
1567     else if(tmp->type == AIRPDCAP_KEY_TYPE_WPA_PWD)
1568         g_print("TYPE: %s\n",AIRPCAP_WPA_PWD_KEY_STRING);
1569     else if(tmp->type == AIRPDCAP_KEY_TYPE_WPA_PMK)
1570         g_print("TYPE: %s\n",AIRPCAP_WPA_BIN_KEY_STRING);
1571     else
1572         g_print("TYPE: %s\n","???");
1573
1574     g_print("SSID: %s\n",(tmp->ssid != NULL) ?
1575             format_text((guchar *)tmp->ssid->data, tmp->ssid->len) : "---");
1576     g_print("\n");
1577     }
1578
1579     g_print("\n*****************************\n\n");
1580 }
1581
1582 /*
1583  * Retrieves a GList of decryption_key_t structures containing infos about the
1584  * keys for the given adapter... returns NULL if no keys are found.
1585  */
1586 GList*
1587 get_airpcap_device_keys(airpcap_if_info_t* info_if)
1588 {
1589     /* tmp vars */
1590     char* tmp_key = NULL;
1591     guint i,keys_in_list = 0;
1592
1593     /* real vars*/
1594     decryption_key_t *new_key  = NULL;
1595     GList            *key_list = NULL;
1596
1597     /* Number of keys in key list */
1598     if(info_if->keysCollectionSize != 0)
1599         keys_in_list = (guint)(info_if->keysCollectionSize -  sizeof(AirpcapKeysCollection))/sizeof(AirpcapKey);
1600     else
1601         keys_in_list = 0;
1602
1603     for(i=0; i<keys_in_list; i++)
1604     {
1605     /* Different things to do depending on the key type  */
1606     if(info_if->keysCollection->Keys[i].KeyType == AIRPDCAP_KEY_TYPE_WEP)
1607         {
1608         /* allocate memory for the new key item */
1609         new_key = (decryption_key_t*)g_malloc(sizeof(decryption_key_t));
1610
1611         /* fill the fields */
1612         /* KEY */
1613         tmp_key = airpcap_get_key_string(info_if->keysCollection->Keys[i]);
1614         new_key->key = g_string_new(tmp_key);
1615         g_free(tmp_key);
1616
1617         /* BITS */
1618         new_key->bits = new_key->key->len *4; /* every char is 4 bits in WEP keys (it is an exadecimal number) */
1619
1620         /* SSID not used in WEP keys */
1621         new_key->ssid = NULL;
1622
1623         /* TYPE (WEP in this case) */
1624         new_key->type = info_if->keysCollection->Keys[i].KeyType;
1625
1626         /* Append the new element in the list */
1627         key_list = g_list_append(key_list,(gpointer)new_key);
1628         }
1629     else if(info_if->keysCollection->Keys[i].KeyType == AIRPDCAP_KEY_TYPE_WPA_PWD)
1630         {
1631         /* XXX - Not supported yet */
1632         }
1633     else if(info_if->keysCollection->Keys[i].KeyType == AIRPDCAP_KEY_TYPE_WPA_PMK)
1634         {
1635         /* XXX - Not supported yet */
1636         }
1637     }
1638
1639     return key_list;
1640 }
1641
1642 /*
1643  * Retrieves a GList of decryption_key_t structures containing infos about the
1644  * keys for the global AirPcap driver... returns NULL if no keys are found.
1645  */
1646 GList*
1647 get_airpcap_driver_keys()
1648 {
1649     /* tmp vars */
1650     char* tmp_key = NULL;
1651     guint i,keys_in_list = 0;
1652
1653     /* real vars*/
1654     decryption_key_t *new_key  = NULL;
1655     GList            *key_list = NULL;
1656
1657     /*
1658      * To read the drivers general settings we need to create and use one airpcap adapter...
1659      * The only way to do that is to instantiate a fake adapter, and then close it and delete it.
1660      */
1661     airpcap_if_info_t* fake_info_if = NULL;
1662
1663     /* Create the fake_info_if from the first adapter of the list */
1664     fake_info_if = airpcap_driver_fake_if_info_new();
1665
1666     if(fake_info_if == NULL)
1667             return NULL;
1668
1669     /* Number of keys in key list */
1670     if(fake_info_if->keysCollectionSize != 0)
1671         keys_in_list = (guint)(fake_info_if->keysCollectionSize -  sizeof(AirpcapKeysCollection))/sizeof(AirpcapKey);
1672     else
1673         keys_in_list = 0;
1674
1675     for(i=0; i<keys_in_list; i++)
1676     {
1677     /* Different things to do depending on the key type  */
1678     if(fake_info_if->keysCollection->Keys[i].KeyType == AIRPDCAP_KEY_TYPE_WEP)
1679         {
1680         /* allocate memory for the new key item */
1681         new_key = (decryption_key_t*)g_malloc(sizeof(decryption_key_t));
1682
1683         /* fill the fields */
1684         /* KEY */
1685         tmp_key = airpcap_get_key_string(fake_info_if->keysCollection->Keys[i]);
1686         new_key->key = g_string_new(tmp_key);
1687         if(tmp_key != NULL) g_free(tmp_key);
1688
1689         /* BITS */
1690         new_key->bits = new_key->key->len *4; /* every char is 4 bits in WEP keys (it is an exadecimal number) */
1691
1692         /* SSID not used in WEP keys */
1693         new_key->ssid = NULL;
1694
1695         /* TYPE (WEP in this case) */
1696         new_key->type = fake_info_if->keysCollection->Keys[i].KeyType;
1697
1698         /* Append the new element in the list */
1699         key_list = g_list_append(key_list,(gpointer)new_key);
1700         }
1701     else if(fake_info_if->keysCollection->Keys[i].KeyType == AIRPDCAP_KEY_TYPE_WPA_PWD)
1702         {
1703         /* XXX - Not supported yet */
1704         }
1705     else if(fake_info_if->keysCollection->Keys[i].KeyType == AIRPDCAP_KEY_TYPE_WPA_PMK)
1706         {
1707         /* XXX - Not supported yet */
1708         }
1709     }
1710
1711     airpcap_if_info_free(fake_info_if);
1712
1713     return key_list;
1714 }
1715
1716 /*
1717  * Returns the list of the decryption keys specified for wireshark, NULL if
1718  * no key is found
1719  */
1720 GList*
1721 get_wireshark_keys()
1722 {
1723     keys_cb_data_t* wep_user_data = NULL;
1724
1725     gchar *tmp = NULL;
1726
1727     GList* final_list = NULL;
1728     GList* wep_final_list = NULL;
1729
1730     /* Retrieve the wlan preferences */
1731     wlan_prefs = prefs_find_module("wlan");
1732
1733     /* Allocate a structure used to keep infos  between the callbacks */
1734     wep_user_data = (keys_cb_data_t*)g_malloc(sizeof(keys_cb_data_t));
1735
1736     /* Fill the structure */
1737     wep_user_data->list = NULL;
1738     wep_user_data->current_index = 0;
1739     wep_user_data->number_of_keys= 0; /* Still unknown */
1740
1741     /* Run the callback on each 802.11 preference */
1742     /* XXX - Right now, only WEP keys will be loaded */
1743     prefs_pref_foreach(wlan_prefs, get_wep_key, (gpointer)wep_user_data);
1744
1745     /* Copy the list field in the user data structure pointer into the final_list */
1746     if(wep_user_data != NULL)  wep_final_list  = wep_user_data->list;
1747
1748     /* XXX - Merge the three lists!!!!! */
1749     final_list = wep_final_list;
1750
1751     /* free the wep_user_data structure */
1752     g_free(wep_user_data);
1753
1754     return final_list;
1755 }
1756
1757 /*
1758  * Merges two lists of keys and return a newly created GList. If a key is
1759  * found multiple times, it will just appear once!
1760  * list1 and list 2 pointer will have to be freed manually if needed!!!
1761  * If the total number of keys exceeeds the maximum number allowed,
1762  * exceeding keys will be discarded...
1763  */
1764 GList*
1765 merge_key_list(GList* list1, GList* list2)
1766 {
1767     guint n1=0,n2=0;
1768     guint i;
1769     decryption_key_t *dk1=NULL,
1770                      *dk2=NULL,
1771                      *new_dk=NULL;
1772
1773     GList* merged_list = NULL;
1774
1775     if( (list1 == NULL) && (list2 == NULL) )
1776         return NULL;
1777
1778     if(list1 == NULL)
1779     {
1780         n1 = 0;
1781         n2 = g_list_length(list2);
1782
1783         for(i=0;i<n2;i++)
1784         {
1785             new_dk = (decryption_key_t*)g_malloc(sizeof(decryption_key_t));
1786             dk2 = (decryption_key_t *)g_list_nth_data(list2,i);
1787
1788             new_dk->bits = dk2->bits;
1789             new_dk->type = dk2->type;
1790             new_dk->key  = g_string_new(dk2->key->str);
1791             new_dk->ssid = byte_array_dup(dk2->ssid);
1792
1793             /* Check the total length of the merged list */
1794             if(g_list_length(merged_list) < MAX_ENCRYPTION_KEYS)
1795                 merged_list = g_list_append(merged_list,(gpointer)new_dk);
1796         }
1797     }
1798     else if(list2 == NULL)
1799     {
1800         n1 = g_list_length(list1);
1801         n2 = 0;
1802
1803         for(i=0;i<n1;i++)
1804         {
1805             new_dk = (decryption_key_t*)g_malloc(sizeof(decryption_key_t));
1806             dk1 = (decryption_key_t*)g_list_nth_data(list1,i);
1807
1808             new_dk->bits = dk1->bits;
1809             new_dk->type = dk1->type;
1810             new_dk->key  = g_string_new(dk1->key->str);
1811             new_dk->ssid = byte_array_dup(dk1->ssid);
1812
1813             /* Check the total length of the merged list */
1814             if(g_list_length(merged_list) < MAX_ENCRYPTION_KEYS)
1815                     merged_list = g_list_append(merged_list,(gpointer)new_dk);
1816         }
1817     }
1818     else
1819     {
1820         n1 = g_list_length(list1);
1821         n2 = g_list_length(list2);
1822
1823         /* Copy the whole list1 into merged_list */
1824         for(i=0;i<n1;i++)
1825         {
1826             new_dk = (decryption_key_t*)g_malloc(sizeof(decryption_key_t));
1827             dk1 = (decryption_key_t *)g_list_nth_data(list1,i);
1828
1829             new_dk->bits = dk1->bits;
1830             new_dk->type = dk1->type;
1831             new_dk->key  = g_string_new(dk1->key->str);
1832             new_dk->ssid = byte_array_dup(dk1->ssid);
1833
1834             /* Check the total length of the merged list */
1835             if(g_list_length(merged_list) < MAX_ENCRYPTION_KEYS)
1836                 merged_list = g_list_append(merged_list,(gpointer)new_dk);
1837         }
1838
1839         /* Look for keys that are present in list2 but aren't in list1 yet...
1840          * Add them to merged_list
1841          */
1842         for(i=0;i<n2;i++)
1843         {
1844             dk2 = (decryption_key_t *)g_list_nth_data(list2,i);
1845
1846             if(!key_is_in_list(dk2,merged_list))
1847             {
1848                 new_dk = (decryption_key_t*)g_malloc(sizeof(decryption_key_t));
1849
1850                 new_dk->bits = dk2->bits;
1851                 new_dk->type = dk2->type;
1852                 new_dk->key  = g_string_new(dk2->key->str);
1853                 new_dk->ssid = byte_array_dup(dk2->ssid);
1854
1855                 /* Check the total length of the merged list */
1856                 if(g_list_length(merged_list) < MAX_ENCRYPTION_KEYS)
1857                         merged_list = g_list_append(merged_list,(gpointer)new_dk);
1858             }
1859         }
1860     }
1861
1862     return merged_list;
1863 }
1864
1865 /*
1866  * Use this function to free a key list.
1867  */
1868 void
1869 free_key_list(GList *list)
1870 {
1871     guint i,n;
1872     decryption_key_t *curr_key;
1873
1874     if(list == NULL)
1875         return;
1876
1877     n = g_list_length(list);
1878
1879     for(i = 0; i < n; i++)
1880     {
1881         curr_key = (decryption_key_t*)g_list_nth_data(list,i);
1882
1883         /* Free all the strings */
1884         if(curr_key->key != NULL)
1885             g_string_free(curr_key->key, TRUE);
1886
1887         if(curr_key->ssid != NULL)
1888         g_byte_array_free(curr_key->ssid, TRUE);
1889
1890         /* free the decryption_key_t structure*/
1891         g_free(curr_key);
1892         curr_key = NULL;
1893     }
1894
1895     /* Free the list */
1896     g_list_free(list);
1897
1898     return;
1899 }
1900
1901
1902 /*
1903  * If the given key is contained in the list, returns TRUE.
1904  * Returns FALSE otherwise.
1905  */
1906 gboolean
1907 key_is_in_list(decryption_key_t *dk,GList *list)
1908 {
1909     guint i,n;
1910     decryption_key_t* curr_key = NULL;
1911     gboolean found = FALSE;
1912
1913     if( (list == NULL) || (dk == NULL) )
1914         return FALSE;
1915
1916     n = g_list_length(list);
1917
1918     if(n < 1)
1919         return FALSE;
1920
1921     for(i = 0; i < n; i++)
1922     {
1923     curr_key = (decryption_key_t*)g_list_nth_data(list,i);
1924     if(keys_are_equals(dk,curr_key))
1925         found = TRUE;
1926     }
1927
1928     return found;
1929 }
1930
1931 /*
1932  * Returns TRUE if keys are equals, FALSE otherwise
1933  */
1934 gboolean
1935 keys_are_equals(decryption_key_t *k1,decryption_key_t *k2)
1936 {
1937
1938     if((k1==NULL) || (k2==NULL))
1939         return FALSE;
1940
1941     /* XXX - Remove this check when we will have the WPA/WPA2 decryption in the Driver! */
1942     //if( (k1->type == AIRPDCAP_KEY_TYPE_WPA_PWD) || (k2->type == AIRPDCAP_KEY_TYPE_WPA_PWD) || (k1->type == AIRPDCAP_KEY_TYPE_WPA_PMK) || (k2->type == AIRPDCAP_KEY_TYPE_WPA_PMK) )
1943     //  return TRUE;
1944
1945     if( g_string_equal(k1->key,k2->key) &&
1946         (k1->bits == k2->bits) && /* If the previous is TRUE, this must be TRUE as well */
1947         k1->type == k2->type)
1948     {
1949         /* Check the ssid... if the key type is WEP, the two fields should be NULL */
1950         if((k1->ssid == NULL) && (k2->ssid == NULL))
1951             return TRUE;
1952
1953         /* If they are not null, they must share the same ssid */
1954         return byte_array_equal(k1->ssid,k2->ssid);
1955     }
1956
1957     /* Some field is not equal ... */
1958     return FALSE;
1959 }
1960
1961 /*
1962  * Tests if two collection of keys are equal or not, to be considered equals, they have to
1963  * contain the same keys in the SAME ORDER! (If both lists are NULL, which means empty will
1964  * return TRUE)
1965  */
1966 gboolean
1967 key_lists_are_equal(GList* list1, GList* list2)
1968 {
1969     guint n1=0,n2=0;
1970     /* XXX - Remove */
1971     guint wep_n1=0,wep_n2=0;
1972     GList *wep_list1=NULL;
1973     GList *wep_list2=NULL;
1974     /* XXX - END*/
1975     guint i/*,j*/;
1976     decryption_key_t *dk1=NULL,*dk2=NULL;
1977
1978     n1 = g_list_length(list1);
1979     n2 = g_list_length(list2);
1980
1981     /*
1982      * XXX - START : Retrieve the aublists of WEP keys!!! This is needed only 'till Driver WPA decryption
1983      * is not implemented.
1984      */
1985     for(i=0;i<n1;i++)
1986             {
1987             dk1=(decryption_key_t*)g_list_nth_data(list1,i);
1988             if(dk1->type == AIRPDCAP_KEY_TYPE_WEP)
1989                     {
1990                     wep_list1 = g_list_append(wep_list1,(gpointer)dk1);
1991                     wep_n1++;
1992                     }
1993             }
1994     for(i=0;i<n2;i++)
1995             {
1996             dk2=(decryption_key_t*)g_list_nth_data(list2,i);
1997             if(dk2->type == AIRPDCAP_KEY_TYPE_WEP)
1998                     {
1999                     wep_list2 = g_list_append(wep_list2,(gpointer)dk2);
2000                     wep_n2++;
2001                     }
2002             }
2003
2004     /*
2005      * XXX - END : Remove from START to END when the WPA/WPA2 decryption will be implemented in
2006      * the Driver
2007      */
2008
2009     /*
2010      * Commented, because in the new AirPcap version all the keys will be saved
2011      * into the driver, and all the keys for every specific adapter will be
2012      * removed. This means that this check will always fail... and the user will
2013      * always be asked what to do... and it doesn't make much sense.
2014      */
2015     /* if(n1 != n2) return FALSE; */
2016     if(wep_n1 != wep_n2) return FALSE;
2017
2018     n1 = wep_n1;
2019     n2 = wep_n2;
2020
2021     /*for(i=0;i<n1;i++)
2022     {
2023     dk1=(decryption_key_t*)g_list_nth_data(list1,i);
2024     dk2=(decryption_key_t*)g_list_nth_data(list2,i);
2025
2026     if(!g_string_equal(dk1->key,dk2->key)) return FALSE;
2027     }*/
2028     for(i=0;i<n2;i++)
2029     {
2030     dk2=(decryption_key_t*)g_list_nth_data(wep_list2,i);
2031     if(!key_is_in_list(dk2,wep_list1)) return FALSE;
2032     }
2033
2034     return TRUE;
2035 }
2036
2037 static guint
2038 test_if_on(pref_t *pref, gpointer ud _U_)
2039 {
2040     gboolean *is_on;
2041     gboolean number;
2042
2043     /* Retrieve user data info */
2044     is_on = (gboolean*)ud;
2045
2046
2047     if (g_strncasecmp(pref->name, "enable_decryption", 17) == 0 && pref->type == PREF_BOOL)
2048         {
2049         number = *pref->varp.boolp;
2050
2051         if(number) *is_on = TRUE;
2052         else *is_on = FALSE;
2053
2054         return 1;
2055         }
2056     return 0;
2057 }
2058
2059 /*
2060  * Returns TRUE if the Wireshark decryption is active, false otherwise
2061  */
2062 gboolean
2063 wireshark_decryption_on()
2064 {
2065     gboolean is_on;
2066
2067     /* Retrieve the wlan preferences */
2068     wlan_prefs = prefs_find_module("wlan");
2069
2070     /* Run the callback on each 802.11 preference */
2071     prefs_pref_foreach(wlan_prefs, test_if_on, (gpointer)&is_on);
2072
2073     return is_on;
2074 }
2075
2076 /*
2077  * Returns TRUE if the AirPcap decryption for the current adapter is active, false otherwise
2078  */
2079 gboolean
2080 airpcap_decryption_on()
2081 {
2082     gboolean is_on = FALSE;
2083
2084     airpcap_if_info_t* fake_if_info = NULL;
2085
2086     fake_if_info = airpcap_driver_fake_if_info_new();
2087
2088     if(fake_if_info != NULL)
2089         {
2090             if(fake_if_info->DecryptionOn == AIRPCAP_DECRYPTION_ON)
2091                     is_on = TRUE;
2092             else if(fake_if_info->DecryptionOn == AIRPCAP_DECRYPTION_OFF)
2093                     is_on = FALSE;
2094         }
2095
2096     airpcap_if_info_free(fake_if_info);
2097
2098     return is_on;
2099 }
2100
2101 /*
2102  * Free an instance of airpcap_if_info_t
2103  */
2104 void
2105 airpcap_if_info_free(airpcap_if_info_t *if_info)
2106 {
2107     if(if_info != NULL)
2108     {
2109         if (if_info->name != NULL)
2110                 g_free(if_info->name);
2111
2112         if (if_info->description != NULL)
2113                 g_free(if_info->description);
2114
2115         if(if_info->keysCollection != NULL)
2116                 {
2117                 g_free(if_info->keysCollection);
2118                 if_info->keysCollection = NULL;
2119                 }
2120
2121         if(if_info->ip_addr != NULL)
2122                 {
2123                 g_slist_free(if_info->ip_addr);
2124                 if_info->ip_addr = NULL;
2125                 }
2126
2127         if(if_info != NULL)
2128                 {
2129                 g_free(if_info);
2130                 if_info = NULL;
2131                 }
2132     }
2133 }
2134
2135 static guint
2136 set_on_off(pref_t *pref, gpointer ud _U_)
2137 {
2138     gboolean *is_on;
2139     gboolean number;
2140
2141     /* Retrieve user data info */
2142     is_on = (gboolean*)ud;
2143
2144     if (g_strncasecmp(pref->name, "enable_decryption", 17) == 0 && pref->type == PREF_BOOL)
2145         {
2146         number = *pref->varp.boolp;
2147
2148         g_free((void *)*pref->varp.boolp);
2149         if(*is_on)
2150             *pref->varp.boolp = TRUE;
2151         else
2152             *pref->varp.boolp = FALSE;
2153
2154         return 1;
2155         }
2156     return 0;
2157 }
2158
2159 /*
2160  * Enables decryption for Wireshark if on_off is TRUE, disables it otherwise.
2161  */
2162 void
2163 set_wireshark_decryption(gboolean on_off)
2164 {
2165     gboolean is_on;
2166
2167     is_on = on_off;
2168
2169     /* Retrieve the wlan preferences */
2170     wlan_prefs = prefs_find_module("wlan");
2171
2172     /* Run the callback on each 802.11 preference */
2173     prefs_pref_foreach(wlan_prefs, set_on_off, (gpointer)&is_on);
2174
2175     /*
2176      * Signal that we've changed things, and run the 802.11 dissector's
2177      * callback
2178      */
2179     wlan_prefs->prefs_changed = TRUE;
2180
2181     prefs_apply(wlan_prefs);
2182 }
2183
2184 /*
2185  * Enables decryption for all the adapters if on_off is TRUE, disables it otherwise.
2186  */
2187 gboolean
2188 set_airpcap_decryption(gboolean on_off)
2189 {
2190         /* We need to directly access the .dll functions here... */
2191         gchar ebuf[AIRPCAP_ERRBUF_SIZE];
2192         PAirpcapHandle ad,ad_driver;
2193
2194         gboolean success = TRUE;
2195
2196         gint n = 0;
2197         gint i = 0;
2198         airpcap_if_info_t* curr_if = NULL;
2199         airpcap_if_info_t* fake_if_info = NULL;
2200
2201         fake_if_info = airpcap_driver_fake_if_info_new();
2202
2203         if(fake_if_info == NULL)
2204                 /* We apparently don't have any adapters installed.
2205                  * This isn't a failure, so return TRUE
2206                  */
2207                 return TRUE;
2208
2209         /* Set the driver decryption */
2210         ad_driver = airpcap_if_open(fake_if_info->name, ebuf);
2211         if(ad_driver)
2212                 {
2213                 if(on_off)
2214                         airpcap_if_set_driver_decryption_state(ad_driver,AIRPCAP_DECRYPTION_ON);
2215                 else
2216                         airpcap_if_set_driver_decryption_state(ad_driver,AIRPCAP_DECRYPTION_OFF);
2217
2218                 airpcap_if_close(ad_driver);
2219                 }
2220
2221         airpcap_if_info_free(fake_if_info);
2222
2223         n = g_list_length(airpcap_if_list);
2224
2225         /* Set to FALSE the decryption for all the adapters */
2226         /* Apply this change to all the adapters !!! */
2227         for(i = 0; i < n; i++)
2228             {
2229             curr_if = (airpcap_if_info_t*)g_list_nth_data(airpcap_if_list,i);
2230
2231             if( curr_if != NULL )
2232                 {
2233                 ad = airpcap_if_open(get_airpcap_name_from_description(airpcap_if_list,curr_if->description), ebuf);
2234                         if(ad)
2235                     {
2236                     curr_if->DecryptionOn = (gboolean)AIRPCAP_DECRYPTION_OFF;
2237                         airpcap_if_set_decryption_state(ad,curr_if->DecryptionOn);
2238                         /* Save configuration for the curr_if */
2239                         if(!airpcap_if_store_cur_config_as_adapter_default(ad))
2240                                 {
2241                                 success = FALSE;
2242                                 }
2243                         airpcap_if_close(ad);
2244                     }
2245                 }
2246             }
2247
2248         return success;
2249 }
2250
2251
2252 /* DYNAMIC LIBRARY LOADER */
2253 /*
2254  *  Used to dynamically load the airpcap library in order link it only when
2255  *  it's present on the system
2256  */
2257 int load_airpcap(void)
2258 {
2259 BOOL base_functions = TRUE;
2260 BOOL new_functions = TRUE;
2261
2262  if((AirpcapLib =  LoadLibrary(TEXT("airpcap.dll"))) == NULL)
2263  {
2264   /* Report the error but go on */
2265   return AIRPCAP_DLL_NOT_FOUND;
2266  }
2267  else
2268  {
2269   if((g_PAirpcapGetLastError = (AirpcapGetLastErrorHandler) GetProcAddress(AirpcapLib, "AirpcapGetLastError")) == NULL) base_functions = FALSE;
2270   if((g_PAirpcapGetDeviceList = (AirpcapGetDeviceListHandler) GetProcAddress(AirpcapLib, "AirpcapGetDeviceList")) == NULL) base_functions = FALSE;
2271   if((g_PAirpcapFreeDeviceList = (AirpcapFreeDeviceListHandler) GetProcAddress(AirpcapLib, "AirpcapFreeDeviceList")) == NULL) base_functions = FALSE;
2272   if((g_PAirpcapOpen = (AirpcapOpenHandler) GetProcAddress(AirpcapLib, "AirpcapOpen")) == NULL) base_functions = FALSE;
2273   if((g_PAirpcapClose = (AirpcapCloseHandler) GetProcAddress(AirpcapLib, "AirpcapClose")) == NULL) base_functions = FALSE;
2274   if((g_PAirpcapGetLinkType = (AirpcapGetLinkTypeHandler) GetProcAddress(AirpcapLib, "AirpcapGetLinkType")) == NULL) base_functions = FALSE;
2275   if((g_PAirpcapSetLinkType = (AirpcapSetLinkTypeHandler) GetProcAddress(AirpcapLib, "AirpcapSetLinkType")) == NULL) base_functions = FALSE;
2276   if((g_PAirpcapSetKernelBuffer = (AirpcapSetKernelBufferHandler) GetProcAddress(AirpcapLib, "AirpcapSetKernelBuffer")) == NULL) base_functions = FALSE;
2277   if((g_PAirpcapSetFilter = (AirpcapSetFilterHandler) GetProcAddress(AirpcapLib, "AirpcapSetFilter")) == NULL) base_functions = FALSE;
2278   if((g_PAirpcapGetMacAddress = (AirpcapGetMacAddressHandler) GetProcAddress(AirpcapLib, "AirpcapGetMacAddress")) == NULL) base_functions = FALSE;
2279   if((g_PAirpcapSetMinToCopy = (AirpcapSetMinToCopyHandler) GetProcAddress(AirpcapLib, "AirpcapSetMinToCopy")) == NULL) base_functions = FALSE;
2280   if((g_PAirpcapGetReadEvent = (AirpcapGetReadEventHandler) GetProcAddress(AirpcapLib, "AirpcapGetReadEvent")) == NULL) base_functions = FALSE;
2281   if((g_PAirpcapRead = (AirpcapReadHandler) GetProcAddress(AirpcapLib, "AirpcapRead")) == NULL) base_functions = FALSE;
2282   if((g_PAirpcapGetStats = (AirpcapGetStatsHandler) GetProcAddress(AirpcapLib, "AirpcapGetStats")) == NULL) base_functions = FALSE;
2283   if((g_PAirpcapTurnLedOn = (AirpcapTurnLedOnHandler) GetProcAddress(AirpcapLib, "AirpcapTurnLedOn")) == NULL) base_functions = FALSE;
2284   if((g_PAirpcapTurnLedOff = (AirpcapTurnLedOffHandler) GetProcAddress(AirpcapLib, "AirpcapTurnLedOff")) == NULL) base_functions = FALSE;
2285   if((g_PAirpcapGetDeviceChannel = (AirpcapGetDeviceChannelHandler) GetProcAddress(AirpcapLib, "AirpcapGetDeviceChannel")) == NULL) base_functions = FALSE;
2286   if((g_PAirpcapSetDeviceChannel = (AirpcapSetDeviceChannelHandler) GetProcAddress(AirpcapLib, "AirpcapSetDeviceChannel")) == NULL) base_functions = FALSE;
2287   if((g_PAirpcapGetFcsPresence = (AirpcapGetFcsPresenceHandler) GetProcAddress(AirpcapLib, "AirpcapGetFcsPresence")) == NULL) base_functions = FALSE;
2288   if((g_PAirpcapSetFcsPresence = (AirpcapSetFcsPresenceHandler) GetProcAddress(AirpcapLib, "AirpcapSetFcsPresence")) == NULL) base_functions = FALSE;
2289   if((g_PAirpcapGetFcsValidation = (AirpcapGetFcsValidationHandler) GetProcAddress(AirpcapLib, "AirpcapGetFcsValidation")) == NULL) base_functions = FALSE;
2290   if((g_PAirpcapSetFcsValidation = (AirpcapSetFcsValidationHandler) GetProcAddress(AirpcapLib, "AirpcapSetFcsValidation")) == NULL) base_functions = FALSE;
2291   if((g_PAirpcapGetDeviceKeys = (AirpcapGetDeviceKeysHandler) GetProcAddress(AirpcapLib, "AirpcapGetDeviceKeys")) == NULL) base_functions = FALSE;
2292   if((g_PAirpcapSetDeviceKeys = (AirpcapSetDeviceKeysHandler) GetProcAddress(AirpcapLib, "AirpcapSetDeviceKeys")) == NULL) base_functions = FALSE;
2293   if((g_PAirpcapGetDecryptionState = (AirpcapGetDecryptionStateHandler) GetProcAddress(AirpcapLib, "AirpcapGetDecryptionState")) == NULL) base_functions = FALSE;
2294   if((g_PAirpcapSetDecryptionState = (AirpcapSetDecryptionStateHandler) GetProcAddress(AirpcapLib, "AirpcapSetDecryptionState")) == NULL) base_functions = FALSE;
2295   if((g_PAirpcapStoreCurConfigAsAdapterDefault = (AirpcapStoreCurConfigAsAdapterDefaultHandler) GetProcAddress(AirpcapLib, "AirpcapStoreCurConfigAsAdapterDefault")) == NULL) base_functions = FALSE;
2296   if((g_PAirpcapGetVersion = (AirpcapGetVersionHandler) GetProcAddress(AirpcapLib, "AirpcapGetVersion")) == NULL) base_functions = FALSE;
2297
2298   /* TEST IF WE CAN FIND AIRPCAP NEW DRIVER FEATURES */
2299   if((g_PAirpcapGetDriverDecryptionState = (AirpcapGetDriverDecryptionStateHandler) GetProcAddress(AirpcapLib, "AirpcapGetDriverDecryptionState")) == NULL) new_functions = FALSE;
2300   if((g_PAirpcapSetDriverDecryptionState = (AirpcapSetDriverDecryptionStateHandler) GetProcAddress(AirpcapLib, "AirpcapSetDriverDecryptionState")) == NULL) new_functions = FALSE;
2301   if((g_PAirpcapGetDriverKeys = (AirpcapGetDriverKeysHandler) GetProcAddress(AirpcapLib, "AirpcapGetDriverKeys")) == NULL) new_functions = FALSE;
2302   if((g_PAirpcapSetDriverKeys = (AirpcapSetDriverKeysHandler) GetProcAddress(AirpcapLib, "AirpcapSetDriverKeys")) == NULL) new_functions = FALSE;
2303
2304   if(base_functions)
2305   {
2306           if(new_functions)
2307           {
2308           AirpcapLoaded = TRUE;
2309           return AIRPCAP_DLL_OK;
2310           }
2311           else
2312           {
2313           AirpcapLoaded = TRUE;
2314           return AIRPCAP_DLL_OLD;
2315           }
2316   }
2317   else
2318   {
2319           AirpcapLoaded = FALSE;
2320           return AIRPCAP_DLL_ERROR;
2321   }
2322  }
2323 }
2324
2325 /*
2326  * Append the version of AirPcap with which we were compiled to a GString.
2327  */
2328 void
2329 get_compiled_airpcap_version(GString *str)
2330 {
2331         g_string_append(str, "with AirPcap");
2332 }
2333
2334 /*
2335  * Append the version of AirPcap with which we we're running to a GString.
2336  */
2337 void
2338 get_runtime_airpcap_version(GString *str)
2339 {
2340         guint vmaj, vmin, vrev, build;
2341
2342         /* See if the DLL has been loaded successfully.  Bail if it hasn't */
2343         if (AirpcapLoaded == FALSE) {
2344                 g_string_append(str, "without AirPcap");
2345                 return;
2346         }
2347
2348         g_PAirpcapGetVersion(&vmaj, &vmin, &vrev, &build);
2349         g_string_sprintfa(str, "with AirPcap %d.%d.%d build %d", vmaj, vmin,
2350                 vrev, build);
2351 }
2352
2353 #endif /* _WIN32 */