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 "capture_ui_utils.h"
  46
  47 #include "simple_dialog.h"
  48
  49 #include <airpcap.h>
  50 #include "airpcap_loader.h"
  51
  52 /* AirPDcap */
  53 #include "../airpdcap/airpdcap_ws.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_string_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) ? tmp->ssid->str : "---");
1575 g_print("\n");
1576 }
1577
1578 g_print("\n*****************************\n\n");
1579 }
1580
1581 /*
1582  * Retrieves a GList of decryption_key_t structures containing infos about the
1583  * keys for the given adapter... returns NULL if no keys are found.
1584  */
1585 GList*
1586 get_airpcap_device_keys(airpcap_if_info_t* info_if)
1587 {
1588 /* tmp vars */
1589 char* tmp_key = NULL;
1590 guint i,keys_in_list = 0;
1591
1592 /* real vars*/
1593 decryption_key_t *new_key  = NULL;
1594 GList            *key_list = NULL;
1595
1596 /* Number of keys in key list */
1597 if(info_if->keysCollectionSize != 0)
1598     keys_in_list = (guint)(info_if->keysCollectionSize -  sizeof(AirpcapKeysCollection))/sizeof(AirpcapKey);
1599 else
1600     keys_in_list = 0;
1601
1602 for(i=0; i<keys_in_list; i++)
1603 {
1604 /* Different things to do depending on the key type  */
1605 if(info_if->keysCollection->Keys[i].KeyType == AIRPDCAP_KEY_TYPE_WEP)
1606     {
1607     /* allocate memory for the new key item */
1608     new_key = (decryption_key_t*)g_malloc(sizeof(decryption_key_t));
1609
1610     /* fill the fields */
1611     /* KEY */
1612     tmp_key = airpcap_get_key_string(info_if->keysCollection->Keys[i]);
1613     new_key->key = g_string_new(tmp_key);
1614     g_free(tmp_key);
1615
1616     /* BITS */
1617     new_key->bits = new_key->key->len *4; /* every char is 4 bits in WEP keys (it is an exadecimal number) */
1618
1619     /* SSID not used in WEP keys */
1620     new_key->ssid = NULL;
1621
1622     /* TYPE (WEP in this case) */
1623     new_key->type = info_if->keysCollection->Keys[i].KeyType;
1624
1625     /* Append the new element in the list */
1626     key_list = g_list_append(key_list,(gpointer)new_key);
1627     }
1628 else if(info_if->keysCollection->Keys[i].KeyType == AIRPDCAP_KEY_TYPE_WPA_PWD)
1629     {
1630     /* XXX - Not supported yet */
1631     }
1632 else if(info_if->keysCollection->Keys[i].KeyType == AIRPDCAP_KEY_TYPE_WPA_PMK)
1633     {
1634     /* XXX - Not supported yet */
1635     }
1636 }
1637
1638 return key_list;
1639 }
1640
1641 /*
1642  * Retrieves a GList of decryption_key_t structures containing infos about the
1643  * keys for the global AirPcap driver... returns NULL if no keys are found.
1644  */
1645 GList*
1646 get_airpcap_driver_keys()
1647 {
1648 /* tmp vars */
1649 char* tmp_key = NULL;
1650 guint i,keys_in_list = 0;
1651
1652 /* real vars*/
1653 decryption_key_t *new_key  = NULL;
1654 GList            *key_list = NULL;
1655
1656 /*
1657  * To read the drivers general settings we need to create and use one airpcap adapter...
1658  * The only way to do that is to instantiate a fake adapter, and then close it and delete it.
1659  */
1660 airpcap_if_info_t* fake_info_if = NULL;
1661
1662 /* Create the fake_info_if from the first adapter of the list */
1663 fake_info_if = airpcap_driver_fake_if_info_new();
1664
1665 if(fake_info_if == NULL)
1666         return NULL;
1667
1668 /* Number of keys in key list */
1669 if(fake_info_if->keysCollectionSize != 0)
1670     keys_in_list = (guint)(fake_info_if->keysCollectionSize -  sizeof(AirpcapKeysCollection))/sizeof(AirpcapKey);
1671 else
1672     keys_in_list = 0;
1673
1674 for(i=0; i<keys_in_list; i++)
1675 {
1676 /* Different things to do depending on the key type  */
1677 if(fake_info_if->keysCollection->Keys[i].KeyType == AIRPDCAP_KEY_TYPE_WEP)
1678     {
1679     /* allocate memory for the new key item */
1680     new_key = (decryption_key_t*)g_malloc(sizeof(decryption_key_t));
1681
1682     /* fill the fields */
1683     /* KEY */
1684     tmp_key = airpcap_get_key_string(fake_info_if->keysCollection->Keys[i]);
1685     new_key->key = g_string_new(tmp_key);
1686     if(tmp_key != NULL) g_free(tmp_key);
1687
1688     /* BITS */
1689     new_key->bits = new_key->key->len *4; /* every char is 4 bits in WEP keys (it is an exadecimal number) */
1690
1691     /* SSID not used in WEP keys */
1692     new_key->ssid = NULL;
1693
1694     /* TYPE (WEP in this case) */
1695     new_key->type = fake_info_if->keysCollection->Keys[i].KeyType;
1696
1697     /* Append the new element in the list */
1698     key_list = g_list_append(key_list,(gpointer)new_key);
1699     }
1700 else if(fake_info_if->keysCollection->Keys[i].KeyType == AIRPDCAP_KEY_TYPE_WPA_PWD)
1701     {
1702     /* XXX - Not supported yet */
1703     }
1704 else if(fake_info_if->keysCollection->Keys[i].KeyType == AIRPDCAP_KEY_TYPE_WPA_PMK)
1705     {
1706     /* XXX - Not supported yet */
1707     }
1708 }
1709
1710 airpcap_if_info_free(fake_info_if);
1711
1712 return key_list;
1713 }
1714
1715 /*
1716  * Returns the list of the decryption keys specified for wireshark, NULL if
1717  * no key is found
1718  */
1719 GList*
1720 get_wireshark_keys()
1721 {
1722 keys_cb_data_t* wep_user_data = NULL;
1723
1724 gchar *tmp = NULL;
1725
1726 GList* final_list = NULL;
1727 GList* wep_final_list = NULL;
1728
1729 /* Retrieve the wlan preferences */
1730 wlan_prefs = prefs_find_module("wlan");
1731
1732 /* Allocate a structure used to keep infos  between the callbacks */
1733 wep_user_data = (keys_cb_data_t*)g_malloc(sizeof(keys_cb_data_t));
1734
1735 /* Fill the structure */
1736 wep_user_data->list = NULL;
1737 wep_user_data->current_index = 0;
1738 wep_user_data->number_of_keys= 0; /* Still unknown */
1739
1740 /* Run the callback on each 802.11 preference */
1741 /* XXX - Right now, only WEP keys will be loaded */
1742 prefs_pref_foreach(wlan_prefs, get_wep_key, (gpointer)wep_user_data);
1743
1744 /* Copy the list field in the user data structure pointer into the final_list */
1745 if(wep_user_data != NULL)  wep_final_list  = wep_user_data->list;
1746
1747 /* XXX - Merge the three lists!!!!! */
1748 final_list = wep_final_list;
1749
1750 /* free the wep_user_data structure */
1751 g_free(wep_user_data);
1752
1753 return final_list;
1754 }
1755
1756 /*
1757  * Merges two lists of keys and return a newly created GList. If a key is
1758  * found multiple times, it will just appear once!
1759  * list1 and list 2 pointer will have to be freed manually if needed!!!
1760  * If the total number of keys exceeeds the maximum number allowed,
1761  * exceeding keys will be discarded...
1762  */
1763 GList*
1764 merge_key_list(GList* list1, GList* list2)
1765 {
1766 guint n1=0,n2=0;
1767 guint i;
1768 decryption_key_t *dk1=NULL,
1769                  *dk2=NULL,
1770                  *new_dk=NULL;
1771
1772 GList* merged_list = NULL;
1773
1774 if( (list1 == NULL) && (list2 == NULL) )
1775     return NULL;
1776
1777 if(list1 == NULL)
1778     {
1779     n1 = 0;
1780     n2 = g_list_length(list2);
1781
1782     for(i=0;i<n2;i++)
1783         {
1784         new_dk = (decryption_key_t*)g_malloc(sizeof(decryption_key_t));
1785         dk2 = (decryption_key_t *)g_list_nth_data(list2,i);
1786
1787         new_dk->bits = dk2->bits;
1788         new_dk->type = dk2->type;
1789         new_dk->key  = g_string_new(dk2->key->str);
1790         if(dk2->ssid != NULL)
1791             new_dk->ssid = g_string_new(dk2->ssid->str);
1792         else
1793             new_dk->ssid = NULL;
1794
1795                 /* Check the total length of the merged list */
1796                 if(g_list_length(merged_list) < MAX_ENCRYPTION_KEYS)
1797                         merged_list = g_list_append(merged_list,(gpointer)new_dk);
1798         }
1799     }
1800 else if(list2 == NULL)
1801     {
1802     n1 = g_list_length(list1);
1803     n2 = 0;
1804
1805     for(i=0;i<n1;i++)
1806         {
1807         new_dk = (decryption_key_t*)g_malloc(sizeof(decryption_key_t));
1808         dk1 = (decryption_key_t*)g_list_nth_data(list1,i);
1809
1810         new_dk->bits = dk1->bits;
1811         new_dk->type = dk1->type;
1812         new_dk->key  = g_string_new(dk1->key->str);
1813         if(dk1->ssid != NULL)
1814             new_dk->ssid = g_string_new(dk1->ssid->str);
1815         else
1816             new_dk->ssid = NULL;
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
1838     if(dk1->ssid != NULL)
1839         new_dk->ssid = g_string_new(dk1->ssid->str);
1840     else
1841         new_dk->ssid = NULL;
1842
1843         /* Check the total length of the merged list */
1844         if(g_list_length(merged_list) < MAX_ENCRYPTION_KEYS)
1845                 merged_list = g_list_append(merged_list,(gpointer)new_dk);
1846     }
1847
1848     /* Look for keys that are present in list2 but aren't in list1 yet...
1849      * Add them to merged_list
1850      */
1851     for(i=0;i<n2;i++)
1852         {
1853         dk2 = (decryption_key_t *)g_list_nth_data(list2,i);
1854
1855         if(!key_is_in_list(dk2,merged_list))
1856             {
1857             new_dk = (decryption_key_t*)g_malloc(sizeof(decryption_key_t));
1858
1859             new_dk->bits = dk2->bits;
1860             new_dk->type = dk2->type;
1861             new_dk->key  = g_string_new(dk2->key->str);
1862             if(dk2->ssid != NULL)
1863                 new_dk->ssid = g_string_new(dk2->ssid->str);
1864             else
1865                 new_dk->ssid = NULL;
1866
1867                         /* Check the total length of the merged list */
1868                         if(g_list_length(merged_list) < MAX_ENCRYPTION_KEYS)
1869                                 merged_list = g_list_append(merged_list,(gpointer)new_dk);
1870             }
1871         }
1872     }
1873
1874 return merged_list;
1875 }
1876
1877 /*
1878  * Use this function to free a key list.
1879  */
1880 void
1881 free_key_list(GList *list)
1882 {
1883 guint i,n;
1884 decryption_key_t *curr_key;
1885
1886 if(list == NULL)
1887     return;
1888
1889 n = g_list_length(list);
1890
1891 for(i = 0; i < n; i++)
1892 {
1893 curr_key = (decryption_key_t*)g_list_nth_data(list,i);
1894
1895 /* Free all the strings */
1896 if(curr_key->key != NULL)
1897     g_string_free(curr_key->key,TRUE);
1898
1899 if(curr_key->ssid != NULL)
1900 g_string_free(curr_key->ssid,TRUE);
1901
1902 /* free the decryption_key_t structure*/
1903 g_free(curr_key);
1904 curr_key = NULL;
1905 }
1906
1907 /* Free the list */
1908 g_list_free(list);
1909
1910 return;
1911 }
1912
1913
1914 /*
1915  * If the given key is contained in the list, returns TRUE.
1916  * Returns FALSE otherwise.
1917  */
1918 gboolean
1919 key_is_in_list(decryption_key_t *dk,GList *list)
1920 {
1921 guint i,n;
1922 decryption_key_t* curr_key = NULL;
1923 gboolean found = FALSE;
1924
1925 if( (list == NULL) || (dk == NULL) )
1926     return FALSE;
1927
1928 n = g_list_length(list);
1929
1930 if(n < 1)
1931     return FALSE;
1932
1933 for(i = 0; i < n; i++)
1934 {
1935 curr_key = (decryption_key_t*)g_list_nth_data(list,i);
1936 if(keys_are_equals(dk,curr_key))
1937     found = TRUE;
1938 }
1939
1940 return found;
1941 }
1942
1943 /*
1944  * Returns TRUE if keys are equals, FALSE otherwise
1945  */
1946 gboolean
1947 keys_are_equals(decryption_key_t *k1,decryption_key_t *k2)
1948 {
1949
1950 if((k1==NULL) || (k2==NULL))
1951     return FALSE;
1952
1953 /* XXX - Remove this check when we will have the WPA/WPA2 decryption in the Driver! */
1954 //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) )
1955 //      return TRUE;
1956
1957 if( g_string_equal(k1->key,k2->key) &&
1958     (k1->bits == k2->bits) && /* If the previous is TRUE, this must be TRUE as well */
1959     k1->type == k2->type)
1960     {
1961     /* Check the ssid... if the key type is WEP, the two fields should be NULL */
1962     if((k1->ssid == NULL) && (k2->ssid == NULL))
1963         return TRUE;
1964
1965     /* Check if one of them is null and one is not... */
1966     if((k1->ssid == NULL) || (k2->ssid == NULL))
1967         return FALSE;
1968
1969     /* If they are not null, they must share the same ssid */
1970     return g_string_equal(k1->ssid,k2->ssid);
1971     }
1972
1973 /* Some field is not equal ... */
1974 return FALSE;
1975 }
1976
1977 /*
1978  * Tests if two collection of keys are equal or not, to be considered equals, they have to
1979  * contain the same keys in the SAME ORDER! (If both lists are NULL, which means empty will
1980  * return TRUE)
1981  */
1982 gboolean
1983 key_lists_are_equal(GList* list1, GList* list2)
1984 {
1985 guint n1=0,n2=0;
1986 /* XXX - Remove */
1987 guint wep_n1=0,wep_n2=0;
1988 GList *wep_list1=NULL;
1989 GList *wep_list2=NULL;
1990 /* XXX - END*/
1991 guint i/*,j*/;
1992 decryption_key_t *dk1=NULL,*dk2=NULL;
1993
1994 n1 = g_list_length(list1);
1995 n2 = g_list_length(list2);
1996
1997 /*
1998  * XXX - START : Retrieve the aublists of WEP keys!!! This is needed only 'till Driver WPA decryption
1999  * is not implemented.
2000  */
2001 for(i=0;i<n1;i++)
2002         {
2003         dk1=(decryption_key_t*)g_list_nth_data(list1,i);
2004         if(dk1->type == AIRPDCAP_KEY_TYPE_WEP)
2005                 {
2006                 wep_list1 = g_list_append(wep_list1,(gpointer)dk1);
2007                 wep_n1++;
2008                 }
2009         }
2010 for(i=0;i<n2;i++)
2011         {
2012         dk2=(decryption_key_t*)g_list_nth_data(list2,i);
2013         if(dk2->type == AIRPDCAP_KEY_TYPE_WEP)
2014                 {
2015                 wep_list2 = g_list_append(wep_list2,(gpointer)dk2);
2016                 wep_n2++;
2017                 }
2018         }
2019
2020 /*
2021  * XXX - END : Remove from START to END when the WPA/WPA2 decryption will be implemented in
2022  * the Driver
2023  */
2024
2025 /*
2026  * Commented, because in the new AirPcap version all the keys will be saved
2027  * into the driver, and all the keys for every specific adapter will be
2028  * removed. This means that this check will always fail... and the user will
2029  * always be asked what to do... and it doesn't make much sense.
2030  */
2031 /* if(n1 != n2) return FALSE; */
2032 if(wep_n1 != wep_n2) return FALSE;
2033
2034 n1 = wep_n1;
2035 n2 = wep_n2;
2036
2037 /*for(i=0;i<n1;i++)
2038 {
2039 dk1=(decryption_key_t*)g_list_nth_data(list1,i);
2040 dk2=(decryption_key_t*)g_list_nth_data(list2,i);
2041
2042 if(!g_string_equal(dk1->key,dk2->key)) return FALSE;
2043 }*/
2044 for(i=0;i<n2;i++)
2045 {
2046 dk2=(decryption_key_t*)g_list_nth_data(wep_list2,i);
2047 if(!key_is_in_list(dk2,wep_list1)) return FALSE;
2048 }
2049
2050 return TRUE;
2051 }
2052
2053 static guint
2054 test_if_on(pref_t *pref, gpointer ud _U_)
2055 {
2056 gboolean *is_on;
2057 gboolean number;
2058
2059 /* Retrieve user data info */
2060 is_on = (gboolean*)ud;
2061
2062
2063 if (g_strncasecmp(pref->name, "enable_decryption", 17) == 0 && pref->type == PREF_BOOL)
2064     {
2065     number = *pref->varp.boolp;
2066
2067     if(number) *is_on = TRUE;
2068     else *is_on = FALSE;
2069
2070     return 1;
2071     }
2072 return 0;
2073 }
2074
2075 /*
2076  * Returns TRUE if the Wireshark decryption is active, false otherwise
2077  */
2078 gboolean
2079 wireshark_decryption_on()
2080 {
2081 gboolean is_on;
2082
2083 /* Retrieve the wlan preferences */
2084 wlan_prefs = prefs_find_module("wlan");
2085
2086 /* Run the callback on each 802.11 preference */
2087 prefs_pref_foreach(wlan_prefs, test_if_on, (gpointer)&is_on);
2088
2089 return is_on;
2090 }
2091
2092 /*
2093  * Returns TRUE if the AirPcap decryption for the current adapter is active, false otherwise
2094  */
2095 gboolean
2096 airpcap_decryption_on()
2097 {
2098 gboolean is_on = FALSE;
2099
2100 airpcap_if_info_t* fake_if_info = NULL;
2101
2102 fake_if_info = airpcap_driver_fake_if_info_new();
2103
2104 if(fake_if_info != NULL)
2105     {
2106         if(fake_if_info->DecryptionOn == AIRPCAP_DECRYPTION_ON)
2107                 is_on = TRUE;
2108         else if(fake_if_info->DecryptionOn == AIRPCAP_DECRYPTION_OFF)
2109                 is_on = FALSE;
2110     }
2111
2112 airpcap_if_info_free(fake_if_info);
2113
2114 return is_on;
2115 }
2116
2117 /*
2118  * Free an instance of airpcap_if_info_t
2119  */
2120 void
2121 airpcap_if_info_free(airpcap_if_info_t *if_info)
2122 {
2123 if(if_info != NULL)
2124         {
2125         if (if_info->name != NULL)
2126                 g_free(if_info->name);
2127
2128         if (if_info->description != NULL)
2129                 g_free(if_info->description);
2130
2131         if(if_info->keysCollection != NULL)
2132                 {
2133                 g_free(if_info->keysCollection);
2134                 if_info->keysCollection = NULL;
2135                 }
2136
2137         if(if_info->ip_addr != NULL)
2138                 {
2139                 g_slist_free(if_info->ip_addr);
2140                 if_info->ip_addr = NULL;
2141                 }
2142
2143         if(if_info != NULL)
2144                 {
2145                 g_free(if_info);
2146                 if_info = NULL;
2147                 }
2148         }
2149 }
2150
2151 static guint
2152 set_on_off(pref_t *pref, gpointer ud _U_)
2153 {
2154 gboolean *is_on;
2155 gboolean number;
2156
2157 /* Retrieve user data info */
2158 is_on = (gboolean*)ud;
2159
2160 if (g_strncasecmp(pref->name, "enable_decryption", 17) == 0 && pref->type == PREF_BOOL)
2161     {
2162     number = *pref->varp.boolp;
2163
2164     g_free((void *)*pref->varp.boolp);
2165     if(*is_on)
2166         *pref->varp.boolp = TRUE;
2167     else
2168         *pref->varp.boolp = FALSE;
2169
2170     return 1;
2171     }
2172 return 0;
2173 }
2174
2175 /*
2176  * Enables decryption for Wireshark if on_off is TRUE, disables it otherwise.
2177  */
2178 void
2179 set_wireshark_decryption(gboolean on_off)
2180 {
2181 gboolean is_on;
2182
2183 is_on = on_off;
2184
2185 /* Retrieve the wlan preferences */
2186 wlan_prefs = prefs_find_module("wlan");
2187
2188 /* Run the callback on each 802.11 preference */
2189 prefs_pref_foreach(wlan_prefs, set_on_off, (gpointer)&is_on);
2190
2191 /*
2192  * Signal that we've changed things, and run the 802.11 dissector's
2193  * callback
2194  */
2195 wlan_prefs->prefs_changed = TRUE;
2196
2197 prefs_apply(wlan_prefs);
2198 }
2199
2200 /*
2201  * Enables decryption for all the adapters if on_off is TRUE, disables it otherwise.
2202  */
2203 gboolean
2204 set_airpcap_decryption(gboolean on_off)
2205 {
2206         /* We need to directly access the .dll functions here... */
2207         gchar ebuf[AIRPCAP_ERRBUF_SIZE];
2208         PAirpcapHandle ad,ad_driver;
2209
2210         gboolean success = TRUE;
2211
2212         gint n = 0;
2213         gint i = 0;
2214         airpcap_if_info_t* curr_if = NULL;
2215         airpcap_if_info_t* fake_if_info = NULL;
2216
2217         fake_if_info = airpcap_driver_fake_if_info_new();
2218
2219         if(fake_if_info == NULL)
2220                 /* We apparently don't have any adapters installed.
2221                  * This isn't a failure, so return TRUE
2222                  */
2223                 return TRUE;
2224
2225         /* Set the driver decryption */
2226         ad_driver = airpcap_if_open(fake_if_info->name, ebuf);
2227         if(ad_driver)
2228                 {
2229                 if(on_off)
2230                         airpcap_if_set_driver_decryption_state(ad_driver,AIRPCAP_DECRYPTION_ON);
2231                 else
2232                         airpcap_if_set_driver_decryption_state(ad_driver,AIRPCAP_DECRYPTION_OFF);
2233
2234                 airpcap_if_close(ad_driver);
2235                 }
2236
2237         airpcap_if_info_free(fake_if_info);
2238
2239         n = g_list_length(airpcap_if_list);
2240
2241         /* Set to FALSE the decryption for all the adapters */
2242         /* Apply this change to all the adapters !!! */
2243         for(i = 0; i < n; i++)
2244             {
2245             curr_if = (airpcap_if_info_t*)g_list_nth_data(airpcap_if_list,i);
2246
2247             if( curr_if != NULL )
2248                 {
2249                 ad = airpcap_if_open(get_airpcap_name_from_description(airpcap_if_list,curr_if->description), ebuf);
2250                         if(ad)
2251                     {
2252                     curr_if->DecryptionOn = (gboolean)AIRPCAP_DECRYPTION_OFF;
2253                         airpcap_if_set_decryption_state(ad,curr_if->DecryptionOn);
2254                         /* Save configuration for the curr_if */
2255                         if(!airpcap_if_store_cur_config_as_adapter_default(ad))
2256                                 {
2257                                 success = FALSE;
2258                                 }
2259                         airpcap_if_close(ad);
2260                     }
2261                 }
2262             }
2263
2264         return success;
2265 }
2266
2267
2268 /* DYNAMIC LIBRARY LOADER */
2269 /*
2270  *  Used to dynamically load the airpcap library in order link it only when
2271  *  it's present on the system
2272  */
2273 int load_airpcap(void)
2274 {
2275 BOOL base_functions = TRUE;
2276 BOOL new_functions = TRUE;
2277
2278  if((AirpcapLib =  LoadLibrary(TEXT("airpcap.dll"))) == NULL)
2279  {
2280   /* Report the error but go on */
2281   return AIRPCAP_DLL_NOT_FOUND;
2282  }
2283  else
2284  {
2285   if((g_PAirpcapGetLastError = (AirpcapGetLastErrorHandler) GetProcAddress(AirpcapLib, "AirpcapGetLastError")) == NULL) base_functions = FALSE;
2286   if((g_PAirpcapGetDeviceList = (AirpcapGetDeviceListHandler) GetProcAddress(AirpcapLib, "AirpcapGetDeviceList")) == NULL) base_functions = FALSE;
2287   if((g_PAirpcapFreeDeviceList = (AirpcapFreeDeviceListHandler) GetProcAddress(AirpcapLib, "AirpcapFreeDeviceList")) == NULL) base_functions = FALSE;
2288   if((g_PAirpcapOpen = (AirpcapOpenHandler) GetProcAddress(AirpcapLib, "AirpcapOpen")) == NULL) base_functions = FALSE;
2289   if((g_PAirpcapClose = (AirpcapCloseHandler) GetProcAddress(AirpcapLib, "AirpcapClose")) == NULL) base_functions = FALSE;
2290   if((g_PAirpcapGetLinkType = (AirpcapGetLinkTypeHandler) GetProcAddress(AirpcapLib, "AirpcapGetLinkType")) == NULL) base_functions = FALSE;
2291   if((g_PAirpcapSetLinkType = (AirpcapSetLinkTypeHandler) GetProcAddress(AirpcapLib, "AirpcapSetLinkType")) == NULL) base_functions = FALSE;
2292   if((g_PAirpcapSetKernelBuffer = (AirpcapSetKernelBufferHandler) GetProcAddress(AirpcapLib, "AirpcapSetKernelBuffer")) == NULL) base_functions = FALSE;
2293   if((g_PAirpcapSetFilter = (AirpcapSetFilterHandler) GetProcAddress(AirpcapLib, "AirpcapSetFilter")) == NULL) base_functions = FALSE;
2294   if((g_PAirpcapGetMacAddress = (AirpcapGetMacAddressHandler) GetProcAddress(AirpcapLib, "AirpcapGetMacAddress")) == NULL) base_functions = FALSE;
2295   if((g_PAirpcapSetMinToCopy = (AirpcapSetMinToCopyHandler) GetProcAddress(AirpcapLib, "AirpcapSetMinToCopy")) == NULL) base_functions = FALSE;
2296   if((g_PAirpcapGetReadEvent = (AirpcapGetReadEventHandler) GetProcAddress(AirpcapLib, "AirpcapGetReadEvent")) == NULL) base_functions = FALSE;
2297   if((g_PAirpcapRead = (AirpcapReadHandler) GetProcAddress(AirpcapLib, "AirpcapRead")) == NULL) base_functions = FALSE;
2298   if((g_PAirpcapGetStats = (AirpcapGetStatsHandler) GetProcAddress(AirpcapLib, "AirpcapGetStats")) == NULL) base_functions = FALSE;
2299   if((g_PAirpcapTurnLedOn = (AirpcapTurnLedOnHandler) GetProcAddress(AirpcapLib, "AirpcapTurnLedOn")) == NULL) base_functions = FALSE;
2300   if((g_PAirpcapTurnLedOff = (AirpcapTurnLedOffHandler) GetProcAddress(AirpcapLib, "AirpcapTurnLedOff")) == NULL) base_functions = FALSE;
2301   if((g_PAirpcapGetDeviceChannel = (AirpcapGetDeviceChannelHandler) GetProcAddress(AirpcapLib, "AirpcapGetDeviceChannel")) == NULL) base_functions = FALSE;
2302   if((g_PAirpcapSetDeviceChannel = (AirpcapSetDeviceChannelHandler) GetProcAddress(AirpcapLib, "AirpcapSetDeviceChannel")) == NULL) base_functions = FALSE;
2303   if((g_PAirpcapGetFcsPresence = (AirpcapGetFcsPresenceHandler) GetProcAddress(AirpcapLib, "AirpcapGetFcsPresence")) == NULL) base_functions = FALSE;
2304   if((g_PAirpcapSetFcsPresence = (AirpcapSetFcsPresenceHandler) GetProcAddress(AirpcapLib, "AirpcapSetFcsPresence")) == NULL) base_functions = FALSE;
2305   if((g_PAirpcapGetFcsValidation = (AirpcapGetFcsValidationHandler) GetProcAddress(AirpcapLib, "AirpcapGetFcsValidation")) == NULL) base_functions = FALSE;
2306   if((g_PAirpcapSetFcsValidation = (AirpcapSetFcsValidationHandler) GetProcAddress(AirpcapLib, "AirpcapSetFcsValidation")) == NULL) base_functions = FALSE;
2307   if((g_PAirpcapGetDeviceKeys = (AirpcapGetDeviceKeysHandler) GetProcAddress(AirpcapLib, "AirpcapGetDeviceKeys")) == NULL) base_functions = FALSE;
2308   if((g_PAirpcapSetDeviceKeys = (AirpcapSetDeviceKeysHandler) GetProcAddress(AirpcapLib, "AirpcapSetDeviceKeys")) == NULL) base_functions = FALSE;
2309   if((g_PAirpcapGetDecryptionState = (AirpcapGetDecryptionStateHandler) GetProcAddress(AirpcapLib, "AirpcapGetDecryptionState")) == NULL) base_functions = FALSE;
2310   if((g_PAirpcapSetDecryptionState = (AirpcapSetDecryptionStateHandler) GetProcAddress(AirpcapLib, "AirpcapSetDecryptionState")) == NULL) base_functions = FALSE;
2311   if((g_PAirpcapStoreCurConfigAsAdapterDefault = (AirpcapStoreCurConfigAsAdapterDefaultHandler) GetProcAddress(AirpcapLib, "AirpcapStoreCurConfigAsAdapterDefault")) == NULL) base_functions = FALSE;
2312   if((g_PAirpcapGetVersion = (AirpcapGetVersionHandler) GetProcAddress(AirpcapLib, "AirpcapGetVersion")) == NULL) base_functions = FALSE;
2313
2314   /* TEST IF WE CAN FIND AIRPCAP NEW DRIVER FEATURES */
2315   if((g_PAirpcapGetDriverDecryptionState = (AirpcapGetDriverDecryptionStateHandler) GetProcAddress(AirpcapLib, "AirpcapGetDriverDecryptionState")) == NULL) new_functions = FALSE;
2316   if((g_PAirpcapSetDriverDecryptionState = (AirpcapSetDriverDecryptionStateHandler) GetProcAddress(AirpcapLib, "AirpcapSetDriverDecryptionState")) == NULL) new_functions = FALSE;
2317   if((g_PAirpcapGetDriverKeys = (AirpcapGetDriverKeysHandler) GetProcAddress(AirpcapLib, "AirpcapGetDriverKeys")) == NULL) new_functions = FALSE;
2318   if((g_PAirpcapSetDriverKeys = (AirpcapSetDriverKeysHandler) GetProcAddress(AirpcapLib, "AirpcapSetDriverKeys")) == NULL) new_functions = FALSE;
2319
2320   if(base_functions)
2321   {
2322           if(new_functions)
2323           {
2324           AirpcapLoaded = TRUE;
2325           return AIRPCAP_DLL_OK;
2326           }
2327           else
2328           {
2329           AirpcapLoaded = TRUE;
2330           return AIRPCAP_DLL_OLD;
2331           }
2332   }
2333   else
2334   {
2335           AirpcapLoaded = FALSE;
2336           return AIRPCAP_DLL_ERROR;
2337   }
2338  }
2339 }
2340
2341 /*
2342  * Append the version of AirPcap with which we were compiled to a GString.
2343  */
2344 void
2345 get_compiled_airpcap_version(GString *str)
2346 {
2347         g_string_append(str, "with AirPcap");
2348 }
2349
2350 /*
2351  * Append the version of AirPcap with which we we're running to a GString.
2352  */
2353 void
2354 get_runtime_airpcap_version(GString *str)
2355 {
2356         guint vmaj, vmin, vrev, build;
2357
2358         /* See if the DLL has been loaded successfully.  Bail if it hasn't */
2359         if (AirpcapLoaded == FALSE) {
2360                 g_string_append(str, "without AirPcap");
2361                 return;
2362         }
2363
2364         g_PAirpcapGetVersion(&vmaj, &vmin, &vrev, &build);
2365         g_string_sprintfa(str, "with AirPcap %d.%d.%d build %d", vmaj, vmin,
2366                 vrev, build);
2367 }
2368
2369 /*
2370  * Returns the decryption_key_t struct given a string describing the key.
2371  * Returns NULL if the key_string cannot be parsed.
2372  */
2373 decryption_key_t*
2374 parse_key_string(gchar* input_string)
2375 {
2376 gchar *type;
2377 gchar *key;
2378 gchar *ssid;
2379
2380 GString *key_string,
2381         *ssid_string;
2382
2383 gchar **tokens;
2384 guint n = 0;
2385 guint i;
2386
2387 decryption_key_t *dk;
2388
2389 if(input_string == NULL)
2390         return NULL;
2391
2392 /*
2393 * Parse the input_string. It should be in the form <key type>:<key data>[:<ssid>]
2394 * XXX - For backward compatibility, the a WEP key can be just a string of hexadecimal
2395 * characters (if WEP key is wrong, null will be returned...).
2396 */
2397 tokens = g_strsplit(input_string,":",0);
2398
2399 /* Tokens is a null termiated array of strings ... */
2400 while(tokens[n] != NULL)
2401         n++;
2402
2403 if(n == 0)
2404 {
2405         /* Free the array of strings */
2406         g_strfreev(tokens);
2407         return NULL;
2408 }
2409
2410 /*
2411 * 'n' contains the number of tokens. If the key string is correct, we should have
2412 * 2 or 3 tokens... If we have 1 token, it can be an 'old style' WEP key... check for it...
2413 */
2414 if(n == 1)
2415 {
2416         /* Maybe it is an 'old style' WEP key */
2417         key = g_strdup(tokens[0]);
2418
2419         /* Create a new string */
2420         key_string = g_string_new(key);
2421
2422         /* Check if it is a correct WEP key */
2423         if( ((key_string->len) > WEP_KEY_MAX_CHAR_SIZE) || ((key_string->len) < WEP_KEY_MIN_CHAR_SIZE))
2424         {
2425                 g_string_free(key_string, TRUE);
2426                 g_free(key);
2427                 /* Free the array of strings */
2428                 g_strfreev(tokens);
2429                 return NULL;
2430         }
2431
2432         if((key_string->len % 2) != 0)
2433         {
2434                 g_string_free(key_string, TRUE);
2435                 g_free(key);
2436                 /* Free the array of strings */
2437                 g_strfreev(tokens);
2438                 return NULL;
2439         }
2440
2441         for(i = 0; i < key_string->len; i++)
2442         {
2443                 if(!g_ascii_isxdigit(key_string->str[i]))
2444                 {
2445                         g_string_free(key_string, TRUE);
2446                         g_free(key);
2447                         /* Free the array of strings */
2448                         g_strfreev(tokens);
2449                         return NULL;
2450                 }
2451         }
2452
2453         /* Key is correct! It was probably an 'old style' WEP key */
2454         /* Create the decryption_key_t structure, fill it and return it*/
2455         dk = g_malloc(sizeof(decryption_key_t));
2456
2457         dk->type = AIRPDCAP_KEY_TYPE_WEP;
2458         dk->key  = g_string_new(key);
2459         dk->bits = dk->key->len * 4;
2460         dk->ssid = NULL;
2461
2462         g_string_free(key_string, TRUE);
2463         g_free(key);
2464
2465         /* Free the array of strings */
2466         g_strfreev(tokens);
2467
2468         return dk;
2469 }
2470
2471 /* There were at least 2 tokens... copy the type value */
2472 type = g_strdup(tokens[0]);
2473
2474 /*
2475 * The second token is the key (right now it doesn't matter
2476 * if it is a passphrase or an hexadecimal one)
2477 */
2478 key = g_strdup(tokens[1]);
2479
2480 /* Lower case... */
2481 g_strdown(type);
2482 g_strdown(key);
2483
2484 /* Maybe there is a third token (an ssid, if everything else is ok) */
2485 if(n >= 3)
2486 {
2487         ssid = g_strdup(tokens[2]);
2488         g_strdown(ssid);
2489 }
2490 else
2491 {
2492         ssid = NULL;
2493 }
2494
2495 /*
2496 * Now the initial key string has been divided in two/three tokens... let's see
2497 * which kind of key it is, and if it is the correct form
2498 */
2499 if(g_strcasecmp(type,STRING_KEY_TYPE_WEP) == 0) /* WEP key */
2500 {
2501         /* Create a new string */
2502         key_string = g_string_new(key);
2503
2504         /* Check if it is a correct WEP key */
2505         if( ((key_string->len) > WEP_KEY_MAX_CHAR_SIZE) || ((key_string->len) < WEP_KEY_MIN_CHAR_SIZE))
2506         {
2507                 g_string_free(key_string, TRUE);
2508                 g_free(key);
2509                 /* Free the array of strings */
2510                 g_strfreev(tokens);
2511                 return NULL;
2512         }
2513
2514         if((key_string->len % 2) != 0)
2515         {
2516                 g_string_free(key_string, TRUE);
2517                 g_free(key);
2518                 /* Free the array of strings */
2519                 g_strfreev(tokens);
2520                 return NULL;
2521         }
2522
2523         for(i = 0; i < key_string->len; i++)
2524         {
2525                 if(!g_ascii_isxdigit(key_string->str[i]))
2526                 {
2527                         g_string_free(key_string, TRUE);
2528                         g_free(key);
2529                         /* Free the array of strings */
2530                         g_strfreev(tokens);
2531                         return NULL;
2532                 }
2533         }
2534
2535         dk =  (decryption_key_t*)g_malloc(sizeof(decryption_key_t));
2536
2537         dk->type = AIRPDCAP_KEY_TYPE_WEP;
2538         dk->key  = g_string_new(key);
2539         dk->bits = dk->key->len * 4;
2540         dk->ssid = NULL;
2541
2542         g_string_free(key_string, TRUE);
2543         g_free(key);
2544
2545         /* Free the array of strings */
2546         g_strfreev(tokens);
2547         return dk;
2548 }
2549 else if(g_strcasecmp(type,STRING_KEY_TYPE_WPA_PSK) == 0) /* WPA key */
2550 {
2551         /* Create a new string */
2552         key_string = g_string_new(key);
2553
2554         /* Two tokens means that the user should have entered a WPA-BIN key ... */
2555         if( ((key_string->len) != WPA_PSK_KEY_CHAR_SIZE))
2556         {
2557                 g_string_free(key_string, TRUE);
2558
2559                 g_free(type);
2560                 g_free(key);
2561                 /* No ssid has been created ... */
2562                 /* Free the array of strings */
2563                 g_strfreev(tokens);
2564                 return NULL;
2565         }
2566
2567         for(i = 0; i < key_string->len; i++)
2568         {
2569                 if(!g_ascii_isxdigit(key_string->str[i]))
2570                 {
2571                         g_string_free(key_string, TRUE);
2572                         /* No ssid_string has been created ... */
2573
2574                         g_free(type);
2575                         g_free(key);
2576                         /* No ssid has been created ... */
2577                         /* Free the array of strings */
2578                         g_strfreev(tokens);
2579                         return NULL;
2580                 }
2581         }
2582
2583         /* Key was correct!!! Create the new decryption_key_t ... */
2584         dk = (decryption_key_t*)g_malloc(sizeof(decryption_key_t));
2585
2586         dk->type = AIRPDCAP_KEY_TYPE_WPA_PMK;
2587         dk->key  = g_string_new(key);
2588         dk->bits = dk->key->len * 4;
2589         dk->ssid = NULL;
2590
2591         g_string_free(key_string, TRUE);
2592         g_free(key);
2593         g_free(type);
2594
2595         /* Free the array of strings */
2596         g_strfreev(tokens);
2597         return dk;
2598 }
2599 else if(g_strcasecmp(type,STRING_KEY_TYPE_WPA_PWD) == 0) /* WPA key *//* If the number of tokens is more than three, we accept the string... if the first three tokens are correct... */
2600 {
2601         /* Create a new string */
2602         key_string = g_string_new(key);
2603         ssid_string = NULL;
2604
2605
2606         /* Three (or more) tokens mean that the user entered a WPA-PWD key ... */
2607         if( ((key_string->len) > WPA_KEY_MAX_CHAR_SIZE) || ((key_string->len) < WPA_KEY_MIN_CHAR_SIZE))
2608         {
2609                 g_string_free(key_string, TRUE);
2610
2611                 g_free(type);
2612                 g_free(key);
2613                 g_free(ssid);
2614
2615                 /* Free the array of strings */
2616                 g_strfreev(tokens);
2617                 return NULL;
2618         }
2619
2620         if(ssid != NULL) /* more than three tokens found, means that the user specified the ssid */
2621         {
2622                 ssid_string = g_string_new(ssid);
2623
2624                 /*
2625                 * XXX - Maybe we need some check on the characters? I'm not sure if only standard ASCII are ok...
2626                 */
2627                 if( ((ssid_string->len) > WPA_SSID_MAX_CHAR_SIZE) || ((ssid_string->len) < WPA_SSID_MIN_CHAR_SIZE))
2628                 {
2629                         g_string_free(key_string, TRUE);
2630                         g_string_free(ssid_string, TRUE);
2631
2632                         g_free(type);
2633                         g_free(key);
2634                         g_free(ssid);
2635
2636                         /* Free the array of strings */
2637                         g_strfreev(tokens);
2638                         return NULL;
2639                 }
2640         }
2641
2642         /* Key was correct!!! Create the new decryption_key_t ... */
2643         dk = (decryption_key_t*)g_malloc(sizeof(decryption_key_t));
2644
2645         dk->type = AIRPDCAP_KEY_TYPE_WPA_PWD;
2646         dk->key  = g_string_new(key);
2647         dk->bits = 256; /* This is the lenght of the array pf bytes that will be generated using key+ssid ...*/
2648         if(ssid != NULL)
2649                 dk->ssid = g_string_new(ssid);
2650         else
2651                 dk->ssid = NULL;
2652
2653         g_string_free(key_string, TRUE);
2654         if(ssid_string != NULL) g_string_free(ssid_string, TRUE);
2655
2656         g_free(type);
2657         g_free(key);
2658         if(ssid != NULL) g_free(ssid);
2659
2660         /* Free the array of strings */
2661         g_strfreev(tokens);
2662         return dk;
2663 }
2664
2665 /* Something was wrong ... free everything */
2666
2667 g_free(type);
2668 g_free(key);
2669 if(ssid != NULL) g_free(ssid); /* It is not always present */
2670 /* Free the array of strings */
2671 g_strfreev(tokens);
2672
2673 return NULL;
2674 }
2675
2676 /*
2677  * Returns a newly allocated string representing the given decryption_key_t struct, or NULL if
2678  * something is wrong...
2679  */
2680 gchar*
2681 get_key_string(decryption_key_t* dk)
2682 {
2683 gchar* output_string = NULL;
2684
2685         if(dk == NULL)
2686                 return NULL;
2687
2688 #ifdef HAVE_AIRPDCAP
2689         if(dk->type == AIRPDCAP_KEY_TYPE_WEP)
2690         {
2691                 if(dk->key == NULL) /* Should NOT happen at all... */
2692                         return NULL;
2693
2694                 output_string = g_strdup_printf("%s:%s",STRING_KEY_TYPE_WEP,dk->key->str);
2695         }
2696         else if(dk->type == AIRPDCAP_KEY_TYPE_WPA_PWD)
2697         {
2698                 if(dk->key == NULL) /* Should NOT happen at all... */
2699                         return NULL;
2700
2701                 if(dk->ssid == NULL)
2702                         output_string = g_strdup_printf("%s:%s",STRING_KEY_TYPE_WPA_PWD,dk->key->str);
2703                 else
2704                         output_string = g_strdup_printf("%s:%s:%s",STRING_KEY_TYPE_WPA_PWD,dk->key->str,dk->ssid->str);
2705         }
2706         else if(dk->type == AIRPDCAP_KEY_TYPE_WPA_PMK)
2707         {
2708                 if(dk->key == NULL) /* Should NOT happen at all... */
2709                         return NULL;
2710
2711                 output_string = g_strdup_printf("%s:%s",STRING_KEY_TYPE_WPA_PSK,dk->key->str);
2712         }
2713         else
2714         {
2715                 return NULL;
2716         }
2717 #else /* not HAVE_AIRPDCAP*/
2718 output_string = g_strdup(dk->key->str);
2719 #endif
2720
2721 return output_string;
2722 }
2723
2724 #endif /* _WIN32 */