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 static 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     char errbuf[PCAP_ERRBUF_SIZE];
1135
1136     if(!AirpcapLoaded || !g_PAirpcapGetDeviceList(&devsList, errbuf))
1137     {
1138             /* No interfaces, return il = NULL; */
1139             *err = CANT_GET_AIRPCAP_INTERFACE_LIST;
1140             if (err_str != NULL)
1141                 *err_str = cant_get_airpcap_if_list_error_message(errbuf);
1142             return il;
1143     }
1144
1145     /*
1146      * Count the adapters
1147      */
1148     adListEntry = devsList;
1149     n_adapts = 0;
1150     while(adListEntry)
1151     {
1152             n_adapts++;
1153             adListEntry = adListEntry->next;
1154     }
1155
1156     if(n_adapts == 0)
1157     {
1158             /* No interfaces, return il= NULL */
1159             g_PAirpcapFreeDeviceList(devsList);
1160             *err = NO_AIRPCAP_INTERFACES_FOUND;
1161             if (err_str != NULL)
1162                 *err_str = NULL;
1163             return il;
1164     }
1165
1166     /*
1167      * Insert the adapters in our list
1168      */
1169     adListEntry = devsList;
1170     for(i = 0; i < n_adapts; i++)
1171     {
1172       if_info = airpcap_if_info_new(adListEntry->Name, adListEntry->Description);
1173       il = g_list_append(il, if_info);
1174
1175       adListEntry = adListEntry->next;
1176     }
1177
1178     g_PAirpcapFreeDeviceList(devsList);
1179
1180     *err = 0;
1181     return il;
1182 }
1183
1184 /*
1185  * Used to retrieve the name of the interface given the description
1186  * (the name is used in AirpcapOpen, the description is put in the combo box)
1187  */
1188 gchar* get_airpcap_name_from_description(GList* if_list, gchar* description)
1189 {
1190     unsigned int ifn;
1191     GList* curr;
1192     airpcap_if_info_t* if_info;
1193
1194     ifn = 0;
1195     if(if_list != NULL)
1196     {
1197         while( ifn < g_list_length(if_list) )
1198         {
1199             curr = g_list_nth(if_list, ifn);
1200
1201             if_info = NULL;
1202             if(curr != NULL)
1203                     if_info = curr->data;
1204             if(if_info != NULL)
1205                     if ( g_ascii_strcasecmp(if_info->description,description) == 0)
1206                     {
1207                         return if_info->name;
1208                     }
1209             ifn++;
1210         }
1211     }
1212     return NULL;
1213 }
1214
1215 /*
1216  * Used to retrieve the interface given the name
1217  * (the name is used in AirpcapOpen)
1218  */
1219 airpcap_if_info_t* get_airpcap_if_by_name(GList* if_list, const gchar* name)
1220 {
1221     unsigned int ifn;
1222     GList* curr;
1223     airpcap_if_info_t* if_info;
1224
1225     ifn = 0;
1226     if(if_list != NULL)
1227             {
1228             while( ifn < g_list_length(if_list) )
1229                     {
1230                     curr = g_list_nth(if_list, ifn);
1231
1232                     if_info = NULL;
1233                     if(curr != NULL)
1234                             if_info = curr->data;
1235                     if(if_info != NULL)
1236                             if ( g_ascii_strcasecmp(if_info->name,name) == 0)
1237                                     {
1238                                     return if_info;
1239                                     }
1240                     ifn++;
1241                     }
1242             }
1243     return NULL;
1244 }
1245
1246 /*
1247  * Returns the ASCII string of a key given the key bytes
1248  */
1249 gchar*
1250 airpcap_get_key_string(AirpcapKey key)
1251 {
1252     unsigned int j = 0;
1253     unsigned int l = 0;
1254     gchar *dst,*src;
1255
1256     dst = NULL;
1257     src = NULL;
1258
1259     if(key.KeyType == AIRPDCAP_KEY_TYPE_WEP)
1260             {
1261             if(key.KeyLen != 0)
1262                 {
1263             /* Allocate the string used to store the ASCII representation of the WEP key */
1264             dst = (gchar*)g_malloc(sizeof(gchar)*WEP_KEY_MAX_CHAR_SIZE + 1);
1265             /* Make sure that the first char is '\0' in order to make g_strlcat() work */
1266             dst[0]='\0';
1267
1268                 for(j = 0; j < key.KeyLen; j++)
1269                         {
1270                         src = g_strdup_printf("%.2x\0", key.KeyData[j]);
1271                             /*
1272                              * XXX - use g_strconcat() or GStrings instead ???
1273                              */
1274                     l = g_strlcat(dst,src,WEP_KEY_MAX_CHAR_SIZE+1);
1275                     }
1276             g_free(src);
1277             }
1278             }
1279     else if(key.KeyType == AIRPDCAP_KEY_TYPE_WPA_PWD)
1280         {
1281         /* XXX - Add code here */
1282         }
1283     else if(key.KeyType == AIRPDCAP_KEY_TYPE_WPA_PMK)
1284         {
1285         /* XXX - Add code here */
1286         }
1287     else
1288         {
1289         /* XXX - Add code here */
1290         }
1291
1292     return dst;
1293 }
1294
1295 /*
1296  * Clear keys and decryption status for the specified interface
1297  */
1298 void
1299 airpcap_if_clear_decryption_settings(airpcap_if_info_t* info_if)
1300 {
1301     if(info_if != NULL)
1302     {
1303         if(info_if->keysCollection != NULL)
1304         {
1305                 g_free(info_if->keysCollection);
1306                 info_if->keysCollection = NULL;
1307         }
1308
1309         info_if->keysCollectionSize = 0;
1310
1311         info_if->DecryptionOn = FALSE;
1312         info_if->saved = FALSE;
1313     }
1314 }
1315
1316 /*
1317  * Used to retrieve the airpcap_if_info_t of the selected interface given the
1318  * description (that is the entry of the combo box).
1319  */
1320 gpointer get_airpcap_if_from_description(GList* if_list, const gchar* description)
1321 {
1322     unsigned int ifn;
1323     GList* curr;
1324     airpcap_if_info_t* if_info;
1325
1326     ifn = 0;
1327     if(if_list != NULL)
1328             {
1329             while( ifn < g_list_length(if_list) )
1330                     {
1331                     curr = g_list_nth(if_list, ifn);
1332
1333                     if_info = NULL;
1334                     if(curr != NULL)
1335                             if_info = curr->data;
1336                     if(if_info != NULL)
1337                             if ( g_ascii_strcasecmp(if_info->description,description) == 0)
1338                                     {
1339                                     return if_info;
1340                                     }
1341                     ifn++;
1342                     }
1343             }
1344     return NULL;
1345 }
1346
1347 /*
1348  * Used to retrieve the two chars string from interface
1349  */
1350 gchar*
1351 airpcap_get_if_string_number(airpcap_if_info_t* if_info)
1352 {
1353         gchar* number;
1354         guint n;
1355         int a;
1356
1357         a = sscanf(if_info->name,AIRPCAP_DEVICE_NUMBER_EXTRACT_STRING,&n);
1358
1359     /* If sscanf() returned 1, it means that has read a number, so interface is not "Any"
1360      * Otherwise, check if it is the "Any" adapter...
1361      */
1362      if(a == 0)
1363           {
1364           if(g_strcasecmp(if_info->name,AIRPCAP_DEVICE_ANY_EXTRACT_STRING)!=0)
1365                number = g_strdup_printf("??");
1366           else
1367                number = g_strdup_printf(AIRPCAP_CHANNEL_ANY_NAME);
1368           }
1369      else
1370           {
1371           number = g_strdup_printf("%.2u\0",n);
1372           }
1373
1374         return number;
1375 }
1376
1377 /*
1378  * Used to retrieve the two chars string from interface
1379  */
1380 gchar*
1381 airpcap_get_if_string_number_from_description(gchar* description)
1382 {
1383         gchar* number;
1384         gchar* pointer;
1385
1386         number = (gchar*)g_malloc(sizeof(gchar)*3);
1387
1388         pointer = g_strrstr(description,"#\0");
1389
1390         number[0] = *(pointer+1);
1391         number[1] = *(pointer+2);
1392         number[2] = '\0';
1393
1394         return number;
1395 }
1396
1397 /*
1398  * Returns the default airpcap interface of a list, NULL if list is empty
1399  */
1400 airpcap_if_info_t*
1401 airpcap_get_default_if(GList* airpcap_if_list)
1402 {
1403 int ifn = 0;
1404 GList* popdown_if_list = NULL;
1405 GList* curr = NULL;
1406
1407         gchar* s;
1408         airpcap_if_info_t* if_info = NULL;
1409
1410     if(prefs.capture_device != NULL)
1411     {
1412         s = g_strdup(get_if_name(prefs.capture_device));
1413         if_info = get_airpcap_if_by_name(airpcap_if_list,g_strdup(get_if_name(prefs.capture_device)));
1414         g_free(s);
1415     }
1416         return if_info;
1417 }
1418
1419 /*
1420  * Load the configuration for the specified interface
1421  */
1422 void
1423 airpcap_load_selected_if_configuration(airpcap_if_info_t* if_info)
1424 {
1425     gchar ebuf[AIRPCAP_ERRBUF_SIZE];
1426     PAirpcapHandle ad;
1427
1428     if(if_info != NULL)
1429         {
1430         ad = airpcap_if_open(get_airpcap_name_from_description(airpcap_if_list, if_info->description), ebuf);
1431
1432         if(ad)
1433                 {
1434                 /* Stop blinking (if it was blinkig!)*/
1435                 if(if_info->blinking)
1436                         {
1437                         /* Turn on the light (if it was off) */
1438                         if(!(if_info->led)) airpcap_if_turn_led_on(ad, 0);
1439                         }
1440
1441                 /* Apply settings... */
1442                 airpcap_if_get_device_channel(ad,&(if_info->channel));
1443                 airpcap_if_get_fcs_validation(ad,&(if_info->CrcValidationOn));
1444                 airpcap_if_get_fcs_presence(ad,&(if_info->IsFcsPresent));
1445                 airpcap_if_get_link_type(ad,&(if_info->linkType));
1446                 airpcap_if_get_decryption_state(ad, &(if_info->DecryptionOn));
1447                 /* get the keys, if everything is ok, close the adapter */
1448                 if(airpcap_if_load_keys(ad,if_info))
1449                         airpcap_if_close(ad);
1450
1451                 if_info->saved = TRUE;
1452                 }
1453         else
1454                 {
1455                 simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, " Error in opening adapter for %s",if_info->description);
1456                 }
1457         }
1458 }
1459
1460 /*
1461  * Save the configuration for the specified interface
1462  */
1463 void
1464 airpcap_save_selected_if_configuration(airpcap_if_info_t* if_info)
1465 {
1466     gchar ebuf[AIRPCAP_ERRBUF_SIZE];
1467     PAirpcapHandle ad;
1468
1469     if(if_info != NULL)
1470     {
1471         ad = airpcap_if_open(get_airpcap_name_from_description(airpcap_if_list, if_info->description), ebuf);
1472
1473         if(ad)
1474                 {
1475                 /* Stop blinking (if it was blinkig!)*/
1476                 if(if_info->blinking)
1477                         {
1478                         /* Turn on the light (if it was off) */
1479                         if(!(if_info->led)) airpcap_if_turn_led_on(ad, 0);
1480                         }
1481
1482                 /* Apply settings... */
1483                 airpcap_if_set_device_channel(ad,if_info->channel);
1484                 airpcap_if_set_fcs_validation(ad,if_info->CrcValidationOn);
1485                 airpcap_if_set_fcs_presence(ad,if_info->IsFcsPresent);
1486                 airpcap_if_set_link_type(ad,if_info->linkType);
1487                 airpcap_if_set_decryption_state(ad, if_info->DecryptionOn);
1488                 airpcap_if_save_keys(ad,if_info);
1489
1490                 /* ... and save them */
1491                 if(!airpcap_if_store_cur_config_as_adapter_default(ad))
1492                         {
1493                         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.");
1494                         if_info->saved = FALSE;
1495                         airpcap_if_close(ad);
1496                         return;
1497                         }
1498
1499                 if_info->saved = TRUE;
1500                 airpcap_if_close(ad);
1501                 }
1502         else
1503                 {
1504                 simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, " Error in opening adapter for %s",if_info->description);
1505                 }
1506     }
1507 }
1508
1509 /*
1510  * Save the configuration for the specified interface
1511  */
1512 void
1513 airpcap_save_driver_if_configuration(airpcap_if_info_t* fake_if_info)
1514 {
1515     gchar ebuf[AIRPCAP_ERRBUF_SIZE];
1516     PAirpcapHandle ad;
1517
1518     if(fake_if_info != NULL)
1519     {
1520         ad = airpcap_if_open(fake_if_info->name, ebuf);
1521
1522         if(ad)
1523                 {
1524                 /* Apply decryption settings... */
1525                 airpcap_if_set_driver_decryption_state(ad, fake_if_info->DecryptionOn);
1526                 airpcap_if_save_driver_keys(ad,fake_if_info);
1527                 airpcap_if_close(ad);
1528                 }
1529         else
1530                 {
1531                 simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, " Error in opening adapter for %s",fake_if_info->description);
1532                 }
1533     }
1534
1535     return;
1536 }
1537
1538 /*
1539  * DECRYPTION KEYS FUNCTIONS
1540  */
1541 /*
1542  * This function is used for DEBUG POURPOSES ONLY!!!
1543  */
1544 void
1545 print_key_list(GList* key_list)
1546 {
1547     gint n,i;
1548     decryption_key_t* tmp;
1549
1550     if(key_list == NULL)
1551     {
1552     g_print("\n\n******* KEY LIST NULL *******\n\n");
1553     return;
1554     }
1555
1556     n = g_list_length(key_list);
1557
1558     g_print("\n\n********* KEY LIST **********\n\n");
1559
1560     g_print("NUMBER OF KEYS IN LIST : %d\n\n",n);
1561
1562     for(i =0; i < n; i++)
1563     {
1564     g_print("[%d] :\n",i+1);
1565     tmp = (decryption_key_t*)(g_list_nth_data(key_list,i));
1566     g_print("KEY : %s\n",tmp->key->str);
1567
1568     g_print("BITS: %d\n",tmp->bits);
1569
1570     if(tmp->type == AIRPDCAP_KEY_TYPE_WEP)
1571         g_print("TYPE: %s\n",AIRPCAP_WEP_KEY_STRING);
1572     else if(tmp->type == AIRPDCAP_KEY_TYPE_WPA_PWD)
1573         g_print("TYPE: %s\n",AIRPCAP_WPA_PWD_KEY_STRING);
1574     else if(tmp->type == AIRPDCAP_KEY_TYPE_WPA_PMK)
1575         g_print("TYPE: %s\n",AIRPCAP_WPA_BIN_KEY_STRING);
1576     else
1577         g_print("TYPE: %s\n","???");
1578
1579     g_print("SSID: %s\n",(tmp->ssid != NULL) ?
1580             format_text((guchar *)tmp->ssid->data, tmp->ssid->len) : "---");
1581     g_print("\n");
1582     }
1583
1584     g_print("\n*****************************\n\n");
1585 }
1586
1587 /*
1588  * Retrieves a GList of decryption_key_t structures containing infos about the
1589  * keys for the given adapter... returns NULL if no keys are found.
1590  */
1591 GList*
1592 get_airpcap_device_keys(airpcap_if_info_t* info_if)
1593 {
1594     /* tmp vars */
1595     char* tmp_key = NULL;
1596     guint i,keys_in_list = 0;
1597
1598     /* real vars*/
1599     decryption_key_t *new_key  = NULL;
1600     GList            *key_list = NULL;
1601
1602     /* Number of keys in key list */
1603     if(info_if->keysCollectionSize != 0)
1604         keys_in_list = (guint)(info_if->keysCollectionSize -  sizeof(AirpcapKeysCollection))/sizeof(AirpcapKey);
1605     else
1606         keys_in_list = 0;
1607
1608     for(i=0; i<keys_in_list; i++)
1609     {
1610     /* Different things to do depending on the key type  */
1611     if(info_if->keysCollection->Keys[i].KeyType == AIRPDCAP_KEY_TYPE_WEP)
1612         {
1613         /* allocate memory for the new key item */
1614         new_key = (decryption_key_t*)g_malloc(sizeof(decryption_key_t));
1615
1616         /* fill the fields */
1617         /* KEY */
1618         tmp_key = airpcap_get_key_string(info_if->keysCollection->Keys[i]);
1619         new_key->key = g_string_new(tmp_key);
1620         g_free(tmp_key);
1621
1622         /* BITS */
1623         new_key->bits = new_key->key->len *4; /* every char is 4 bits in WEP keys (it is an exadecimal number) */
1624
1625         /* SSID not used in WEP keys */
1626         new_key->ssid = NULL;
1627
1628         /* TYPE (WEP in this case) */
1629         new_key->type = info_if->keysCollection->Keys[i].KeyType;
1630
1631         /* Append the new element in the list */
1632         key_list = g_list_append(key_list,(gpointer)new_key);
1633         }
1634     else if(info_if->keysCollection->Keys[i].KeyType == AIRPDCAP_KEY_TYPE_WPA_PWD)
1635         {
1636         /* XXX - Not supported yet */
1637         }
1638     else if(info_if->keysCollection->Keys[i].KeyType == AIRPDCAP_KEY_TYPE_WPA_PMK)
1639         {
1640         /* XXX - Not supported yet */
1641         }
1642     }
1643
1644     return key_list;
1645 }
1646
1647 /*
1648  * Retrieves a GList of decryption_key_t structures containing infos about the
1649  * keys for the global AirPcap driver... returns NULL if no keys are found.
1650  */
1651 GList*
1652 get_airpcap_driver_keys()
1653 {
1654     /* tmp vars */
1655     char* tmp_key = NULL;
1656     guint i,keys_in_list = 0;
1657
1658     /* real vars*/
1659     decryption_key_t *new_key  = NULL;
1660     GList            *key_list = NULL;
1661
1662     /*
1663      * To read the drivers general settings we need to create and use one airpcap adapter...
1664      * The only way to do that is to instantiate a fake adapter, and then close it and delete it.
1665      */
1666     airpcap_if_info_t* fake_info_if = NULL;
1667
1668     /* Create the fake_info_if from the first adapter of the list */
1669     fake_info_if = airpcap_driver_fake_if_info_new();
1670
1671     if(fake_info_if == NULL)
1672             return NULL;
1673
1674     /* Number of keys in key list */
1675     if(fake_info_if->keysCollectionSize != 0)
1676         keys_in_list = (guint)(fake_info_if->keysCollectionSize -  sizeof(AirpcapKeysCollection))/sizeof(AirpcapKey);
1677     else
1678         keys_in_list = 0;
1679
1680     for(i=0; i<keys_in_list; i++)
1681     {
1682     /* Different things to do depending on the key type  */
1683     if(fake_info_if->keysCollection->Keys[i].KeyType == AIRPDCAP_KEY_TYPE_WEP)
1684         {
1685         /* allocate memory for the new key item */
1686         new_key = (decryption_key_t*)g_malloc(sizeof(decryption_key_t));
1687
1688         /* fill the fields */
1689         /* KEY */
1690         tmp_key = airpcap_get_key_string(fake_info_if->keysCollection->Keys[i]);
1691         new_key->key = g_string_new(tmp_key);
1692         if(tmp_key != NULL) g_free(tmp_key);
1693
1694         /* BITS */
1695         new_key->bits = new_key->key->len *4; /* every char is 4 bits in WEP keys (it is an exadecimal number) */
1696
1697         /* SSID not used in WEP keys */
1698         new_key->ssid = NULL;
1699
1700         /* TYPE (WEP in this case) */
1701         new_key->type = fake_info_if->keysCollection->Keys[i].KeyType;
1702
1703         /* Append the new element in the list */
1704         key_list = g_list_append(key_list,(gpointer)new_key);
1705         }
1706     else if(fake_info_if->keysCollection->Keys[i].KeyType == AIRPDCAP_KEY_TYPE_WPA_PWD)
1707         {
1708         /* XXX - Not supported yet */
1709         }
1710     else if(fake_info_if->keysCollection->Keys[i].KeyType == AIRPDCAP_KEY_TYPE_WPA_PMK)
1711         {
1712         /* XXX - Not supported yet */
1713         }
1714     }
1715
1716     airpcap_if_info_free(fake_info_if);
1717
1718     return key_list;
1719 }
1720
1721 /*
1722  * Returns the list of the decryption keys specified for wireshark, NULL if
1723  * no key is found
1724  */
1725 GList*
1726 get_wireshark_keys()
1727 {
1728     keys_cb_data_t* wep_user_data = NULL;
1729
1730     gchar *tmp = NULL;
1731
1732     GList* final_list = NULL;
1733     GList* wep_final_list = NULL;
1734
1735     /* Retrieve the wlan preferences */
1736     wlan_prefs = prefs_find_module("wlan");
1737
1738     /* Allocate a structure used to keep infos  between the callbacks */
1739     wep_user_data = (keys_cb_data_t*)g_malloc(sizeof(keys_cb_data_t));
1740
1741     /* Fill the structure */
1742     wep_user_data->list = NULL;
1743     wep_user_data->current_index = 0;
1744     wep_user_data->number_of_keys= 0; /* Still unknown */
1745
1746     /* Run the callback on each 802.11 preference */
1747     /* XXX - Right now, only WEP keys will be loaded */
1748     prefs_pref_foreach(wlan_prefs, get_wep_key, (gpointer)wep_user_data);
1749
1750     /* Copy the list field in the user data structure pointer into the final_list */
1751     if(wep_user_data != NULL)  wep_final_list  = wep_user_data->list;
1752
1753     /* XXX - Merge the three lists!!!!! */
1754     final_list = wep_final_list;
1755
1756     /* free the wep_user_data structure */
1757     g_free(wep_user_data);
1758
1759     return final_list;
1760 }
1761
1762 /*
1763  * Merges two lists of keys and return a newly created GList. If a key is
1764  * found multiple times, it will just appear once!
1765  * list1 and list 2 pointer will have to be freed manually if needed!!!
1766  * If the total number of keys exceeeds the maximum number allowed,
1767  * exceeding keys will be discarded...
1768  */
1769 GList*
1770 merge_key_list(GList* list1, GList* list2)
1771 {
1772     guint n1=0,n2=0;
1773     guint i;
1774     decryption_key_t *dk1=NULL,
1775                      *dk2=NULL,
1776                      *new_dk=NULL;
1777
1778     GList* merged_list = NULL;
1779
1780     if( (list1 == NULL) && (list2 == NULL) )
1781         return NULL;
1782
1783     if(list1 == NULL)
1784     {
1785         n1 = 0;
1786         n2 = g_list_length(list2);
1787
1788         for(i=0;i<n2;i++)
1789         {
1790             new_dk = (decryption_key_t*)g_malloc(sizeof(decryption_key_t));
1791             dk2 = (decryption_key_t *)g_list_nth_data(list2,i);
1792
1793             new_dk->bits = dk2->bits;
1794             new_dk->type = dk2->type;
1795             new_dk->key  = g_string_new(dk2->key->str);
1796             new_dk->ssid = byte_array_dup(dk2->ssid);
1797
1798             /* Check the total length of the merged list */
1799             if(g_list_length(merged_list) < MAX_ENCRYPTION_KEYS)
1800                 merged_list = g_list_append(merged_list,(gpointer)new_dk);
1801         }
1802     }
1803     else if(list2 == NULL)
1804     {
1805         n1 = g_list_length(list1);
1806         n2 = 0;
1807
1808         for(i=0;i<n1;i++)
1809         {
1810             new_dk = (decryption_key_t*)g_malloc(sizeof(decryption_key_t));
1811             dk1 = (decryption_key_t*)g_list_nth_data(list1,i);
1812
1813             new_dk->bits = dk1->bits;
1814             new_dk->type = dk1->type;
1815             new_dk->key  = g_string_new(dk1->key->str);
1816             new_dk->ssid = byte_array_dup(dk1->ssid);
1817
1818             /* Check the total length of the merged list */
1819             if(g_list_length(merged_list) < MAX_ENCRYPTION_KEYS)
1820                     merged_list = g_list_append(merged_list,(gpointer)new_dk);
1821         }
1822     }
1823     else
1824     {
1825         n1 = g_list_length(list1);
1826         n2 = g_list_length(list2);
1827
1828         /* Copy the whole list1 into merged_list */
1829         for(i=0;i<n1;i++)
1830         {
1831             new_dk = (decryption_key_t*)g_malloc(sizeof(decryption_key_t));
1832             dk1 = (decryption_key_t *)g_list_nth_data(list1,i);
1833
1834             new_dk->bits = dk1->bits;
1835             new_dk->type = dk1->type;
1836             new_dk->key  = g_string_new(dk1->key->str);
1837             new_dk->ssid = byte_array_dup(dk1->ssid);
1838
1839             /* Check the total length of the merged list */
1840             if(g_list_length(merged_list) < MAX_ENCRYPTION_KEYS)
1841                 merged_list = g_list_append(merged_list,(gpointer)new_dk);
1842         }
1843
1844         /* Look for keys that are present in list2 but aren't in list1 yet...
1845          * Add them to merged_list
1846          */
1847         for(i=0;i<n2;i++)
1848         {
1849             dk2 = (decryption_key_t *)g_list_nth_data(list2,i);
1850
1851             if(!key_is_in_list(dk2,merged_list))
1852             {
1853                 new_dk = (decryption_key_t*)g_malloc(sizeof(decryption_key_t));
1854
1855                 new_dk->bits = dk2->bits;
1856                 new_dk->type = dk2->type;
1857                 new_dk->key  = g_string_new(dk2->key->str);
1858                 new_dk->ssid = byte_array_dup(dk2->ssid);
1859
1860                 /* Check the total length of the merged list */
1861                 if(g_list_length(merged_list) < MAX_ENCRYPTION_KEYS)
1862                         merged_list = g_list_append(merged_list,(gpointer)new_dk);
1863             }
1864         }
1865     }
1866
1867     return merged_list;
1868 }
1869
1870 /*
1871  * Use this function to free a key list.
1872  */
1873 void
1874 free_key_list(GList *list)
1875 {
1876     guint i,n;
1877     decryption_key_t *curr_key;
1878
1879     if(list == NULL)
1880         return;
1881
1882     n = g_list_length(list);
1883
1884     for(i = 0; i < n; i++)
1885     {
1886         curr_key = (decryption_key_t*)g_list_nth_data(list,i);
1887
1888         /* Free all the strings */
1889         if(curr_key->key != NULL)
1890             g_string_free(curr_key->key, TRUE);
1891
1892         if(curr_key->ssid != NULL)
1893         g_byte_array_free(curr_key->ssid, TRUE);
1894
1895         /* free the decryption_key_t structure*/
1896         g_free(curr_key);
1897         curr_key = NULL;
1898     }
1899
1900     /* Free the list */
1901     g_list_free(list);
1902
1903     return;
1904 }
1905
1906
1907 /*
1908  * If the given key is contained in the list, returns TRUE.
1909  * Returns FALSE otherwise.
1910  */
1911 gboolean
1912 key_is_in_list(decryption_key_t *dk,GList *list)
1913 {
1914     guint i,n;
1915     decryption_key_t* curr_key = NULL;
1916     gboolean found = FALSE;
1917
1918     if( (list == NULL) || (dk == NULL) )
1919         return FALSE;
1920
1921     n = g_list_length(list);
1922
1923     if(n < 1)
1924         return FALSE;
1925
1926     for(i = 0; i < n; i++)
1927     {
1928     curr_key = (decryption_key_t*)g_list_nth_data(list,i);
1929     if(keys_are_equals(dk,curr_key))
1930         found = TRUE;
1931     }
1932
1933     return found;
1934 }
1935
1936 /*
1937  * Returns TRUE if keys are equals, FALSE otherwise
1938  */
1939 gboolean
1940 keys_are_equals(decryption_key_t *k1,decryption_key_t *k2)
1941 {
1942
1943     if((k1==NULL) || (k2==NULL))
1944         return FALSE;
1945
1946     /* XXX - Remove this check when we will have the WPA/WPA2 decryption in the Driver! */
1947     //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) )
1948     //  return TRUE;
1949
1950     if( g_string_equal(k1->key,k2->key) &&
1951         (k1->bits == k2->bits) && /* If the previous is TRUE, this must be TRUE as well */
1952         k1->type == k2->type)
1953     {
1954         /* Check the ssid... if the key type is WEP, the two fields should be NULL */
1955         if((k1->ssid == NULL) && (k2->ssid == NULL))
1956             return TRUE;
1957
1958         /* If they are not null, they must share the same ssid */
1959         return byte_array_equal(k1->ssid,k2->ssid);
1960     }
1961
1962     /* Some field is not equal ... */
1963     return FALSE;
1964 }
1965
1966 /*
1967  * Tests if two collection of keys are equal or not, to be considered equals, they have to
1968  * contain the same keys in the SAME ORDER! (If both lists are NULL, which means empty will
1969  * return TRUE)
1970  */
1971 gboolean
1972 key_lists_are_equal(GList* list1, GList* list2)
1973 {
1974     guint n1=0,n2=0;
1975     /* XXX - Remove */
1976     guint wep_n1=0,wep_n2=0;
1977     GList *wep_list1=NULL;
1978     GList *wep_list2=NULL;
1979     /* XXX - END*/
1980     guint i/*,j*/;
1981     decryption_key_t *dk1=NULL,*dk2=NULL;
1982
1983     n1 = g_list_length(list1);
1984     n2 = g_list_length(list2);
1985
1986     /*
1987      * XXX - START : Retrieve the aublists of WEP keys!!! This is needed only 'till Driver WPA decryption
1988      * is not implemented.
1989      */
1990     for(i=0;i<n1;i++)
1991             {
1992             dk1=(decryption_key_t*)g_list_nth_data(list1,i);
1993             if(dk1->type == AIRPDCAP_KEY_TYPE_WEP)
1994                     {
1995                     wep_list1 = g_list_append(wep_list1,(gpointer)dk1);
1996                     wep_n1++;
1997                     }
1998             }
1999     for(i=0;i<n2;i++)
2000             {
2001             dk2=(decryption_key_t*)g_list_nth_data(list2,i);
2002             if(dk2->type == AIRPDCAP_KEY_TYPE_WEP)
2003                     {
2004                     wep_list2 = g_list_append(wep_list2,(gpointer)dk2);
2005                     wep_n2++;
2006                     }
2007             }
2008
2009     /*
2010      * XXX - END : Remove from START to END when the WPA/WPA2 decryption will be implemented in
2011      * the Driver
2012      */
2013
2014     /*
2015      * Commented, because in the new AirPcap version all the keys will be saved
2016      * into the driver, and all the keys for every specific adapter will be
2017      * removed. This means that this check will always fail... and the user will
2018      * always be asked what to do... and it doesn't make much sense.
2019      */
2020     /* if(n1 != n2) return FALSE; */
2021     if(wep_n1 != wep_n2) return FALSE;
2022
2023     n1 = wep_n1;
2024     n2 = wep_n2;
2025
2026     /*for(i=0;i<n1;i++)
2027     {
2028     dk1=(decryption_key_t*)g_list_nth_data(list1,i);
2029     dk2=(decryption_key_t*)g_list_nth_data(list2,i);
2030
2031     if(!g_string_equal(dk1->key,dk2->key)) return FALSE;
2032     }*/
2033     for(i=0;i<n2;i++)
2034     {
2035     dk2=(decryption_key_t*)g_list_nth_data(wep_list2,i);
2036     if(!key_is_in_list(dk2,wep_list1)) return FALSE;
2037     }
2038
2039     return TRUE;
2040 }
2041
2042 static guint
2043 test_if_on(pref_t *pref, gpointer ud _U_)
2044 {
2045     gboolean *is_on;
2046     gboolean number;
2047
2048     /* Retrieve user data info */
2049     is_on = (gboolean*)ud;
2050
2051
2052     if (g_strncasecmp(pref->name, "enable_decryption", 17) == 0 && pref->type == PREF_BOOL)
2053         {
2054         number = *pref->varp.boolp;
2055
2056         if(number) *is_on = TRUE;
2057         else *is_on = FALSE;
2058
2059         return 1;
2060         }
2061     return 0;
2062 }
2063
2064 /*
2065  * Returns TRUE if the Wireshark decryption is active, false otherwise
2066  */
2067 gboolean
2068 wireshark_decryption_on()
2069 {
2070     gboolean is_on;
2071
2072     /* Retrieve the wlan preferences */
2073     wlan_prefs = prefs_find_module("wlan");
2074
2075     /* Run the callback on each 802.11 preference */
2076     prefs_pref_foreach(wlan_prefs, test_if_on, (gpointer)&is_on);
2077
2078     return is_on;
2079 }
2080
2081 /*
2082  * Returns TRUE if the AirPcap decryption for the current adapter is active, false otherwise
2083  */
2084 gboolean
2085 airpcap_decryption_on()
2086 {
2087     gboolean is_on = FALSE;
2088
2089     airpcap_if_info_t* fake_if_info = NULL;
2090
2091     fake_if_info = airpcap_driver_fake_if_info_new();
2092
2093     if(fake_if_info != NULL)
2094         {
2095             if(fake_if_info->DecryptionOn == AIRPCAP_DECRYPTION_ON)
2096                     is_on = TRUE;
2097             else if(fake_if_info->DecryptionOn == AIRPCAP_DECRYPTION_OFF)
2098                     is_on = FALSE;
2099         }
2100
2101     airpcap_if_info_free(fake_if_info);
2102
2103     return is_on;
2104 }
2105
2106 /*
2107  * Free an instance of airpcap_if_info_t
2108  */
2109 void
2110 airpcap_if_info_free(airpcap_if_info_t *if_info)
2111 {
2112     if(if_info != NULL)
2113     {
2114         if (if_info->name != NULL)
2115                 g_free(if_info->name);
2116
2117         if (if_info->description != NULL)
2118                 g_free(if_info->description);
2119
2120         if(if_info->keysCollection != NULL)
2121                 {
2122                 g_free(if_info->keysCollection);
2123                 if_info->keysCollection = NULL;
2124                 }
2125
2126         if(if_info->ip_addr != NULL)
2127                 {
2128                 g_slist_free(if_info->ip_addr);
2129                 if_info->ip_addr = NULL;
2130                 }
2131
2132         if(if_info != NULL)
2133                 {
2134                 g_free(if_info);
2135                 if_info = NULL;
2136                 }
2137     }
2138 }
2139
2140 static guint
2141 set_on_off(pref_t *pref, gpointer ud _U_)
2142 {
2143     gboolean *is_on;
2144     gboolean number;
2145
2146     /* Retrieve user data info */
2147     is_on = (gboolean*)ud;
2148
2149     if (g_strncasecmp(pref->name, "enable_decryption", 17) == 0 && pref->type == PREF_BOOL)
2150         {
2151         number = *pref->varp.boolp;
2152
2153         g_free((void *)*pref->varp.boolp);
2154         if(*is_on)
2155             *pref->varp.boolp = TRUE;
2156         else
2157             *pref->varp.boolp = FALSE;
2158
2159         return 1;
2160         }
2161     return 0;
2162 }
2163
2164 /*
2165  * Enables decryption for Wireshark if on_off is TRUE, disables it otherwise.
2166  */
2167 void
2168 set_wireshark_decryption(gboolean on_off)
2169 {
2170     gboolean is_on;
2171
2172     is_on = on_off;
2173
2174     /* Retrieve the wlan preferences */
2175     wlan_prefs = prefs_find_module("wlan");
2176
2177     /* Run the callback on each 802.11 preference */
2178     prefs_pref_foreach(wlan_prefs, set_on_off, (gpointer)&is_on);
2179
2180     /*
2181      * Signal that we've changed things, and run the 802.11 dissector's
2182      * callback
2183      */
2184     wlan_prefs->prefs_changed = TRUE;
2185
2186     prefs_apply(wlan_prefs);
2187 }
2188
2189 /*
2190  * Enables decryption for all the adapters if on_off is TRUE, disables it otherwise.
2191  */
2192 gboolean
2193 set_airpcap_decryption(gboolean on_off)
2194 {
2195         /* We need to directly access the .dll functions here... */
2196         gchar ebuf[AIRPCAP_ERRBUF_SIZE];
2197         PAirpcapHandle ad,ad_driver;
2198
2199         gboolean success = TRUE;
2200
2201         gint n = 0;
2202         gint i = 0;
2203         airpcap_if_info_t* curr_if = NULL;
2204         airpcap_if_info_t* fake_if_info = NULL;
2205
2206         fake_if_info = airpcap_driver_fake_if_info_new();
2207
2208         if(fake_if_info == NULL)
2209                 /* We apparently don't have any adapters installed.
2210                  * This isn't a failure, so return TRUE
2211                  */
2212                 return TRUE;
2213
2214         /* Set the driver decryption */
2215         ad_driver = airpcap_if_open(fake_if_info->name, ebuf);
2216         if(ad_driver)
2217                 {
2218                 if(on_off)
2219                         airpcap_if_set_driver_decryption_state(ad_driver,AIRPCAP_DECRYPTION_ON);
2220                 else
2221                         airpcap_if_set_driver_decryption_state(ad_driver,AIRPCAP_DECRYPTION_OFF);
2222
2223                 airpcap_if_close(ad_driver);
2224                 }
2225
2226         airpcap_if_info_free(fake_if_info);
2227
2228         n = g_list_length(airpcap_if_list);
2229
2230         /* Set to FALSE the decryption for all the adapters */
2231         /* Apply this change to all the adapters !!! */
2232         for(i = 0; i < n; i++)
2233             {
2234             curr_if = (airpcap_if_info_t*)g_list_nth_data(airpcap_if_list,i);
2235
2236             if( curr_if != NULL )
2237                 {
2238                 ad = airpcap_if_open(get_airpcap_name_from_description(airpcap_if_list,curr_if->description), ebuf);
2239                         if(ad)
2240                     {
2241                     curr_if->DecryptionOn = (gboolean)AIRPCAP_DECRYPTION_OFF;
2242                         airpcap_if_set_decryption_state(ad,curr_if->DecryptionOn);
2243                         /* Save configuration for the curr_if */
2244                         if(!airpcap_if_store_cur_config_as_adapter_default(ad))
2245                                 {
2246                                 success = FALSE;
2247                                 }
2248                         airpcap_if_close(ad);
2249                     }
2250                 }
2251             }
2252
2253         return success;
2254 }
2255
2256
2257 /* DYNAMIC LIBRARY LOADER */
2258 /*
2259  *  Used to dynamically load the airpcap library in order link it only when
2260  *  it's present on the system
2261  */
2262 int load_airpcap(void)
2263 {
2264 BOOL base_functions = TRUE;
2265 BOOL new_functions = TRUE;
2266
2267  if((AirpcapLib =  LoadLibrary(TEXT("airpcap.dll"))) == NULL)
2268  {
2269   /* Report the error but go on */
2270   return AIRPCAP_DLL_NOT_FOUND;
2271  }
2272  else
2273  {
2274   if((g_PAirpcapGetLastError = (AirpcapGetLastErrorHandler) GetProcAddress(AirpcapLib, "AirpcapGetLastError")) == NULL) base_functions = FALSE;
2275   if((g_PAirpcapGetDeviceList = (AirpcapGetDeviceListHandler) GetProcAddress(AirpcapLib, "AirpcapGetDeviceList")) == NULL) base_functions = FALSE;
2276   if((g_PAirpcapFreeDeviceList = (AirpcapFreeDeviceListHandler) GetProcAddress(AirpcapLib, "AirpcapFreeDeviceList")) == NULL) base_functions = FALSE;
2277   if((g_PAirpcapOpen = (AirpcapOpenHandler) GetProcAddress(AirpcapLib, "AirpcapOpen")) == NULL) base_functions = FALSE;
2278   if((g_PAirpcapClose = (AirpcapCloseHandler) GetProcAddress(AirpcapLib, "AirpcapClose")) == NULL) base_functions = FALSE;
2279   if((g_PAirpcapGetLinkType = (AirpcapGetLinkTypeHandler) GetProcAddress(AirpcapLib, "AirpcapGetLinkType")) == NULL) base_functions = FALSE;
2280   if((g_PAirpcapSetLinkType = (AirpcapSetLinkTypeHandler) GetProcAddress(AirpcapLib, "AirpcapSetLinkType")) == NULL) base_functions = FALSE;
2281   if((g_PAirpcapSetKernelBuffer = (AirpcapSetKernelBufferHandler) GetProcAddress(AirpcapLib, "AirpcapSetKernelBuffer")) == NULL) base_functions = FALSE;
2282   if((g_PAirpcapSetFilter = (AirpcapSetFilterHandler) GetProcAddress(AirpcapLib, "AirpcapSetFilter")) == NULL) base_functions = FALSE;
2283   if((g_PAirpcapGetMacAddress = (AirpcapGetMacAddressHandler) GetProcAddress(AirpcapLib, "AirpcapGetMacAddress")) == NULL) base_functions = FALSE;
2284   if((g_PAirpcapSetMinToCopy = (AirpcapSetMinToCopyHandler) GetProcAddress(AirpcapLib, "AirpcapSetMinToCopy")) == NULL) base_functions = FALSE;
2285   if((g_PAirpcapGetReadEvent = (AirpcapGetReadEventHandler) GetProcAddress(AirpcapLib, "AirpcapGetReadEvent")) == NULL) base_functions = FALSE;
2286   if((g_PAirpcapRead = (AirpcapReadHandler) GetProcAddress(AirpcapLib, "AirpcapRead")) == NULL) base_functions = FALSE;
2287   if((g_PAirpcapGetStats = (AirpcapGetStatsHandler) GetProcAddress(AirpcapLib, "AirpcapGetStats")) == NULL) base_functions = FALSE;
2288   if((g_PAirpcapTurnLedOn = (AirpcapTurnLedOnHandler) GetProcAddress(AirpcapLib, "AirpcapTurnLedOn")) == NULL) base_functions = FALSE;
2289   if((g_PAirpcapTurnLedOff = (AirpcapTurnLedOffHandler) GetProcAddress(AirpcapLib, "AirpcapTurnLedOff")) == NULL) base_functions = FALSE;
2290   if((g_PAirpcapGetDeviceChannel = (AirpcapGetDeviceChannelHandler) GetProcAddress(AirpcapLib, "AirpcapGetDeviceChannel")) == NULL) base_functions = FALSE;
2291   if((g_PAirpcapSetDeviceChannel = (AirpcapSetDeviceChannelHandler) GetProcAddress(AirpcapLib, "AirpcapSetDeviceChannel")) == NULL) base_functions = FALSE;
2292   if((g_PAirpcapGetFcsPresence = (AirpcapGetFcsPresenceHandler) GetProcAddress(AirpcapLib, "AirpcapGetFcsPresence")) == NULL) base_functions = FALSE;
2293   if((g_PAirpcapSetFcsPresence = (AirpcapSetFcsPresenceHandler) GetProcAddress(AirpcapLib, "AirpcapSetFcsPresence")) == NULL) base_functions = FALSE;
2294   if((g_PAirpcapGetFcsValidation = (AirpcapGetFcsValidationHandler) GetProcAddress(AirpcapLib, "AirpcapGetFcsValidation")) == NULL) base_functions = FALSE;
2295   if((g_PAirpcapSetFcsValidation = (AirpcapSetFcsValidationHandler) GetProcAddress(AirpcapLib, "AirpcapSetFcsValidation")) == NULL) base_functions = FALSE;
2296   if((g_PAirpcapGetDeviceKeys = (AirpcapGetDeviceKeysHandler) GetProcAddress(AirpcapLib, "AirpcapGetDeviceKeys")) == NULL) base_functions = FALSE;
2297   if((g_PAirpcapSetDeviceKeys = (AirpcapSetDeviceKeysHandler) GetProcAddress(AirpcapLib, "AirpcapSetDeviceKeys")) == NULL) base_functions = FALSE;
2298   if((g_PAirpcapGetDecryptionState = (AirpcapGetDecryptionStateHandler) GetProcAddress(AirpcapLib, "AirpcapGetDecryptionState")) == NULL) base_functions = FALSE;
2299   if((g_PAirpcapSetDecryptionState = (AirpcapSetDecryptionStateHandler) GetProcAddress(AirpcapLib, "AirpcapSetDecryptionState")) == NULL) base_functions = FALSE;
2300   if((g_PAirpcapStoreCurConfigAsAdapterDefault = (AirpcapStoreCurConfigAsAdapterDefaultHandler) GetProcAddress(AirpcapLib, "AirpcapStoreCurConfigAsAdapterDefault")) == NULL) base_functions = FALSE;
2301   if((g_PAirpcapGetVersion = (AirpcapGetVersionHandler) GetProcAddress(AirpcapLib, "AirpcapGetVersion")) == NULL) base_functions = FALSE;
2302
2303   /* TEST IF WE CAN FIND AIRPCAP NEW DRIVER FEATURES */
2304   if((g_PAirpcapGetDriverDecryptionState = (AirpcapGetDriverDecryptionStateHandler) GetProcAddress(AirpcapLib, "AirpcapGetDriverDecryptionState")) == NULL) new_functions = FALSE;
2305   if((g_PAirpcapSetDriverDecryptionState = (AirpcapSetDriverDecryptionStateHandler) GetProcAddress(AirpcapLib, "AirpcapSetDriverDecryptionState")) == NULL) new_functions = FALSE;
2306   if((g_PAirpcapGetDriverKeys = (AirpcapGetDriverKeysHandler) GetProcAddress(AirpcapLib, "AirpcapGetDriverKeys")) == NULL) new_functions = FALSE;
2307   if((g_PAirpcapSetDriverKeys = (AirpcapSetDriverKeysHandler) GetProcAddress(AirpcapLib, "AirpcapSetDriverKeys")) == NULL) new_functions = FALSE;
2308
2309   if(base_functions)
2310   {
2311           if(new_functions)
2312           {
2313           AirpcapLoaded = TRUE;
2314           return AIRPCAP_DLL_OK;
2315           }
2316           else
2317           {
2318           AirpcapLoaded = TRUE;
2319           return AIRPCAP_DLL_OLD;
2320           }
2321   }
2322   else
2323   {
2324           AirpcapLoaded = FALSE;
2325           return AIRPCAP_DLL_ERROR;
2326   }
2327  }
2328 }
2329
2330 /*
2331  * Append the version of AirPcap with which we were compiled to a GString.
2332  */
2333 void
2334 get_compiled_airpcap_version(GString *str)
2335 {
2336         g_string_append(str, "with AirPcap");
2337 }
2338
2339 /*
2340  * Append the version of AirPcap with which we we're running to a GString.
2341  */
2342 void
2343 get_runtime_airpcap_version(GString *str)
2344 {
2345         guint vmaj, vmin, vrev, build;
2346
2347         /* See if the DLL has been loaded successfully.  Bail if it hasn't */
2348         if (AirpcapLoaded == FALSE) {
2349                 g_string_append(str, "without AirPcap");
2350                 return;
2351         }
2352
2353         g_PAirpcapGetVersion(&vmaj, &vmin, &vrev, &build);
2354         g_string_sprintfa(str, "with AirPcap %d.%d.%d build %d", vmaj, vmin,
2355                 vrev, build);
2356 }
2357
2358 #endif /* _WIN32 */