2006-08-16 18:01:25 +00:00
/* airpcap_loader.c
*
* $ Id $
*
2006-08-21 19:22:33 +00:00
* Giorgio Tino < giorgio . tino @ cacetech . com >
* Copyright ( c ) CACE Technologies , LLC 2006
2006-08-16 18:01:25 +00:00
*
* Wireshark - Network traffic analyzer
* By Gerald Combs < gerald @ wireshark . org >
* Copyright 2000 Gerald Combs
*
* This program is free software ; you can redistribute it and / or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation ; either version 2
* of the License , or ( at your option ) any later version .
*
* This program is distributed in the hope that it will be useful ,
* but WITHOUT ANY WARRANTY ; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the
* GNU General Public License for more details .
*
* You should have received a copy of the GNU General Public License
* along with this program ; if not , write to the Free Software
* Foundation , Inc . , 59 Temple Place - Suite 330 , Boston , MA 02111 - 1307 , USA .
*/
# ifdef _WIN32
# ifdef HAVE_CONFIG_H
# include "config.h"
# endif
# ifdef HAVE_LIBPCAP
# include <glib.h>
# include <gmodule.h>
# include <wtap.h>
# include <pcap.h>
# endif
2006-10-19 00:48:03 +00:00
# include <epan/packet.h>
2006-08-16 18:01:25 +00:00
# include <epan/prefs.h>
2006-10-19 00:48:03 +00:00
# include <epan/prefs-int.h>
2006-12-27 23:05:55 +00:00
# include <epan/crypt/wep-wpadefs.h>
2006-12-28 17:22:12 +00:00
# include <epan/crypt/airpdcap_ws.h>
2007-01-11 02:42:34 +00:00
# include <epan/strutil.h>
2006-10-19 00:48:03 +00:00
# include "capture_ui_utils.h"
2006-08-16 18:01:25 +00:00
# include "simple_dialog.h"
# include <airpcap.h>
# include "airpcap_loader.h"
/*
2007-01-26 06:45:12 +00:00
* We load dynamically the dag library in order link it only when
2006-08-16 18:01:25 +00:00
* it ' s present on the system
*/
2006-10-19 22:43:38 +00:00
static HMODULE AirpcapLib = NULL ;
2006-08-16 18:01:25 +00:00
2006-10-26 21:53:30 +00:00
/*
* Set to TRUE if the DLL was successfully loaded AND all functions
* are present .
*/
static gboolean AirpcapLoaded = FALSE ;
2006-08-16 18:01:25 +00:00
static AirpcapGetLastErrorHandler g_PAirpcapGetLastError ;
static AirpcapGetDeviceListHandler g_PAirpcapGetDeviceList ;
static AirpcapFreeDeviceListHandler g_PAirpcapFreeDeviceList ;
static AirpcapOpenHandler g_PAirpcapOpen ;
static AirpcapCloseHandler g_PAirpcapClose ;
static AirpcapGetLinkTypeHandler g_PAirpcapGetLinkType ;
static AirpcapSetLinkTypeHandler g_PAirpcapSetLinkType ;
static AirpcapSetKernelBufferHandler g_PAirpcapSetKernelBuffer ;
static AirpcapSetFilterHandler g_PAirpcapSetFilter ;
static AirpcapGetMacAddressHandler g_PAirpcapGetMacAddress ;
static AirpcapSetMinToCopyHandler g_PAirpcapSetMinToCopy ;
static AirpcapGetReadEventHandler g_PAirpcapGetReadEvent ;
static AirpcapReadHandler g_PAirpcapRead ;
static AirpcapGetStatsHandler g_PAirpcapGetStats ;
static AirpcapTurnLedOnHandler g_PAirpcapTurnLedOn ;
static AirpcapTurnLedOffHandler g_PAirpcapTurnLedOff ;
static AirpcapGetDeviceChannelHandler g_PAirpcapGetDeviceChannel ;
static AirpcapSetDeviceChannelHandler g_PAirpcapSetDeviceChannel ;
static AirpcapGetFcsPresenceHandler g_PAirpcapGetFcsPresence ;
static AirpcapSetFcsPresenceHandler g_PAirpcapSetFcsPresence ;
static AirpcapGetFcsValidationHandler g_PAirpcapGetFcsValidation ;
static AirpcapSetFcsValidationHandler g_PAirpcapSetFcsValidation ;
static AirpcapGetDeviceKeysHandler g_PAirpcapGetDeviceKeys ;
static AirpcapSetDeviceKeysHandler g_PAirpcapSetDeviceKeys ;
2006-10-30 06:34:31 +00:00
static AirpcapGetDriverKeysHandler g_PAirpcapGetDriverKeys ;
static AirpcapSetDriverKeysHandler g_PAirpcapSetDriverKeys ;
2006-08-16 18:01:25 +00:00
static AirpcapGetDecryptionStateHandler g_PAirpcapGetDecryptionState ;
static AirpcapSetDecryptionStateHandler g_PAirpcapSetDecryptionState ;
2006-10-30 06:34:31 +00:00
static AirpcapGetDriverDecryptionStateHandler g_PAirpcapGetDriverDecryptionState ;
static AirpcapSetDriverDecryptionStateHandler g_PAirpcapSetDriverDecryptionState ;
2006-08-16 18:01:25 +00:00
static AirpcapStoreCurConfigAsAdapterDefaultHandler g_PAirpcapStoreCurConfigAsAdapterDefault ;
2006-10-19 22:43:38 +00:00
static AirpcapGetVersionHandler g_PAirpcapGetVersion ;
2006-08-16 18:01:25 +00:00
/* Airpcap interface list */
GList * airpcap_if_list = NULL ;
/* Airpcap current selected interface */
airpcap_if_info_t * airpcap_if_selected = NULL ;
/* Airpcap current active interface */
airpcap_if_info_t * airpcap_if_active = NULL ;
2006-10-19 00:48:03 +00:00
/* WLAN preferences pointer */
module_t * wlan_prefs = NULL ;
2006-12-27 23:05:55 +00:00
/*
* Callback used by the load_wlan_keys ( ) routine in order to read a WEP decryption key
2006-12-05 19:24:25 +00:00
*/
2006-10-19 00:48:03 +00:00
static guint
get_wep_key ( pref_t * pref , gpointer ud _U_ )
{
2007-01-11 02:42:34 +00:00
gchar * my_string = NULL ;
keys_cb_data_t * user_data ;
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
decryption_key_t * new_key ;
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
/* Retrieve user data info */
user_data = ( keys_cb_data_t * ) ud ;
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
if ( g_strncasecmp ( pref - > name , " wep_key " , 7 ) = = 0 & & pref - > type = = PREF_STRING )
2007-01-24 01:17:48 +00:00
{
2007-01-11 02:42:34 +00:00
my_string = g_strdup ( * pref - > varp . string ) ;
2006-10-26 21:53:30 +00:00
2007-01-11 02:42:34 +00:00
/* Here we have the string describing the key... */
new_key = parse_key_string ( my_string ) ;
2006-12-05 19:24:25 +00:00
2007-01-11 02:42:34 +00:00
if ( new_key ! = NULL )
2007-01-24 01:17:48 +00:00
{
2007-01-11 02:42:34 +00:00
/* Key is added only if not null ... */
2007-01-24 01:17:48 +00:00
user_data - > list = g_list_append ( user_data - > list , new_key ) ;
user_data - > number_of_keys + + ;
user_data - > current_index + + ;
}
}
2007-01-11 02:42:34 +00:00
return 0 ;
2006-10-19 00:48:03 +00:00
}
/* Returs TRUE if the WEP key is valid, false otherwise */
gboolean
wep_key_is_valid ( char * key )
{
2007-01-11 02:42:34 +00:00
GString * new_key_string ;
guint i = 0 ;
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
if ( key = = NULL )
2007-01-24 01:17:48 +00:00
return FALSE ;
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
new_key_string = g_string_new ( key ) ;
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
if ( ( ( new_key_string - > len ) > WEP_KEY_MAX_CHAR_SIZE ) | | ( ( new_key_string - > len ) < 2 ) )
2007-01-24 01:17:48 +00:00
{
g_string_free ( new_key_string , FALSE ) ;
return FALSE ;
}
2007-01-11 02:42:34 +00:00
if ( ( new_key_string - > len % 2 ) ! = 0 )
2007-01-24 01:17:48 +00:00
{
g_string_free ( new_key_string , FALSE ) ;
return FALSE ;
}
for ( i = 0 ; i < new_key_string - > len ; i + + )
{
if ( ! g_ascii_isxdigit ( new_key_string - > str [ i ] ) )
{
2007-01-11 02:42:34 +00:00
g_string_free ( new_key_string , FALSE ) ;
return FALSE ;
2007-01-24 01:17:48 +00:00
}
}
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
g_string_free ( new_key_string , FALSE ) ;
return TRUE ;
2006-10-19 00:48:03 +00:00
}
/* Callback used by the save_wlan_keys() routine in order to write a decryption key */
static guint
set_wep_key ( pref_t * pref , gpointer ud _U_ )
{
2007-01-11 02:42:34 +00:00
gchar * my_string = NULL ;
keys_cb_data_t * user_data ;
gint wep_key_number = 0 ;
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
decryption_key_t * new_key ;
2006-12-05 19:24:25 +00:00
2007-01-11 02:42:34 +00:00
/* Retrieve user data info */
user_data = ( keys_cb_data_t * ) ud ;
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
if ( g_strncasecmp ( pref - > name , " wep_key " , 7 ) = = 0 & & pref - > type = = PREF_STRING )
2007-01-24 01:17:48 +00:00
{
2007-01-11 02:42:34 +00:00
/* Ok, the pref we're gonna set is a wep_key ... but what number? */
sscanf ( pref - > name , " wep_key%d " , & wep_key_number ) ;
if ( user_data - > current_index < user_data - > number_of_keys )
2007-01-24 01:17:48 +00:00
{
2007-01-11 02:42:34 +00:00
if ( wep_key_number = = ( user_data - > current_index + 1 ) )
2007-01-24 01:17:48 +00:00
{
/* Retrieve the nth decryption_key_t structure pointer */
new_key = ( decryption_key_t * ) g_list_nth_data ( user_data - > list , user_data - > current_index ) ;
2007-01-11 02:42:34 +00:00
2007-01-24 01:17:48 +00:00
/* Free the old key string */
g_free ( ( void * ) * pref - > varp . string ) ;
2007-01-11 02:42:34 +00:00
2007-01-24 01:17:48 +00:00
/* Create the new string describing the decryption key */
my_string = get_key_string ( new_key ) ;
2006-10-19 00:48:03 +00:00
2007-01-24 01:17:48 +00:00
/* Duplicate the string, and assign it to the variable pointer */
* pref - > varp . string = ( void * ) g_strdup ( my_string ) ;
2007-01-11 02:42:34 +00:00
2007-01-24 01:17:48 +00:00
/* Free the previously allocated string */
2007-01-11 02:42:34 +00:00
g_free ( my_string ) ;
}
2007-01-24 01:17:48 +00:00
}
2007-01-11 02:42:34 +00:00
else /* If the number of keys has been reduced somehow, we need to delete all the other keys
* ( remember that the new ones have been probably overwritten )
*/
2007-01-24 01:17:48 +00:00
{
2007-01-11 02:42:34 +00:00
g_free ( ( void * ) * pref - > varp . string ) ;
* pref - > varp . string = ( void * ) g_strdup ( " " ) ; /* Do not just free memory!!! Put an 'empty' string! */
}
2007-01-24 01:17:48 +00:00
user_data - > current_index + + ;
}
2007-01-11 02:42:34 +00:00
return 0 ;
2006-10-19 00:48:03 +00:00
}
2006-10-30 06:34:31 +00:00
/*
* Function used to read the Decryption Keys from the preferences and store them
* properly into the airpcap adapter .
*/
BOOL
load_wlan_driver_wep_keys ( )
{
2007-01-11 02:42:34 +00:00
keys_cb_data_t * user_data ;
guint i ;
gchar * tmp = NULL ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
/* Retrieve the wlan preferences */
wlan_prefs = prefs_find_module ( " wlan " ) ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
/* Allocate a structure used to keep infos between the callbacks */
user_data = ( keys_cb_data_t * ) g_malloc ( sizeof ( keys_cb_data_t ) ) ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
/* Fill the structure */
user_data - > list = NULL ;
user_data - > current_index = 0 ;
user_data - > number_of_keys = 0 ; /* Still unknown */
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
/* Run the callback on each 802.11 preference */
prefs_pref_foreach ( wlan_prefs , get_wep_key , ( gpointer ) user_data ) ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
/* Now the key list should be filled */
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
/*
* Signal that we ' ve changed things , and run the 802.11 dissector ' s
* callback
*/
wlan_prefs - > prefs_changed = TRUE ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
prefs_apply ( wlan_prefs ) ;
2006-10-30 06:34:31 +00:00
2007-01-26 06:45:12 +00:00
write_wlan_driver_wep_keys_to_registry ( user_data - > list ) ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
/* FREE MEMORY */
/* free the WEP key string */
for ( i = 0 ; i < g_list_length ( user_data - > list ) ; i + + )
2007-01-24 01:17:48 +00:00
{
2007-01-11 02:42:34 +00:00
g_free ( g_list_nth ( user_data - > list , i ) - > data ) ;
2007-01-24 01:17:48 +00:00
}
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
/* free the (empty) list */
g_list_free ( user_data - > list ) ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
/* free the user_data structure */
g_free ( user_data ) ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
/* airpcap_if_info_free(fake_info_if); */
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
return TRUE ;
2006-10-30 06:34:31 +00:00
}
2006-10-19 00:48:03 +00:00
/*
* This function will tell the airpcap driver the key list to use
* This will be stored into the registry . . .
*/
BOOL
2007-01-26 06:45:12 +00:00
write_wlan_wep_keys_to_registry ( airpcap_if_info_t * info_if , GList * key_list )
2006-10-19 00:48:03 +00:00
{
2007-01-11 02:42:34 +00:00
UINT i , j ;
GString * new_key ;
gchar s [ 3 ] ;
PAirpcapKeysCollection KeysCollection ;
ULONG KeysCollectionSize ;
UCHAR KeyByte ;
UINT keys_in_list = 0 ;
decryption_key_t * key_item = NULL ;
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
keys_in_list = g_list_length ( key_list ) ;
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
/*
* Save the encryption keys , if we have any of them
*/
KeysCollectionSize = 0 ;
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
/*
* Calculate the size of the keys collection
*/
KeysCollectionSize = sizeof ( AirpcapKeysCollection ) + keys_in_list * sizeof ( AirpcapKey ) ;
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
/*
* Allocate the collection
*/
KeysCollection = ( PAirpcapKeysCollection ) g_malloc ( KeysCollectionSize ) ;
if ( ! KeysCollection )
{
2007-01-24 01:17:48 +00:00
return FALSE ;
2007-01-11 02:42:34 +00:00
}
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
/*
* Populate the key collection
*/
KeysCollection - > nKeys = keys_in_list ;
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
for ( i = 0 ; i < keys_in_list ; i + + )
{
KeysCollection - > Keys [ i ] . KeyType = AIRPDCAP_KEY_TYPE_WEP ;
2006-10-19 00:48:03 +00:00
2007-01-24 01:17:48 +00:00
/* Retrieve the Item corresponding to the i-th key */
key_item = ( decryption_key_t * ) g_list_nth_data ( key_list , i ) ;
new_key = g_string_new ( key_item - > key - > str ) ;
2006-10-26 21:53:30 +00:00
2007-01-24 01:17:48 +00:00
KeysCollection - > Keys [ i ] . KeyLen = new_key - > len / 2 ;
memset ( & KeysCollection - > Keys [ i ] . KeyData , 0 , sizeof ( KeysCollection - > Keys [ i ] . KeyData ) ) ;
2006-10-19 00:48:03 +00:00
2007-01-24 01:17:48 +00:00
for ( j = 0 ; j < new_key - > len ; j + = 2 )
{
s [ 0 ] = new_key - > str [ j ] ;
s [ 1 ] = new_key - > str [ j + 1 ] ;
s [ 2 ] = ' \0 ' ;
KeyByte = ( UCHAR ) strtol ( s , NULL , 16 ) ;
KeysCollection - > Keys [ i ] . KeyData [ j / 2 ] = KeyByte ;
}
2006-10-26 21:53:30 +00:00
2007-01-24 01:17:48 +00:00
g_string_free ( new_key , TRUE ) ;
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
}
/*
* Free the old adapter key collection !
*/
if ( info_if - > keysCollection ! = NULL )
2007-01-24 01:17:48 +00:00
g_free ( info_if - > keysCollection ) ;
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
/*
* Set this collection ad the new one
*/
info_if - > keysCollection = KeysCollection ;
info_if - > keysCollectionSize = KeysCollectionSize ;
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
/*
* Configuration must be saved
*/
info_if - > saved = FALSE ;
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
/*
* Write down the changes to the registry
*/
airpcap_save_selected_if_configuration ( info_if ) ;
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
return TRUE ;
2006-10-19 00:48:03 +00:00
}
2006-10-30 06:34:31 +00:00
/*
* This function will tell the airpcap driver the key list to use
* This will be stored into the registry . . .
*/
BOOL
2007-01-26 06:45:12 +00:00
write_wlan_driver_wep_keys_to_registry ( GList * key_list )
2006-10-30 06:34:31 +00:00
{
2007-01-11 02:42:34 +00:00
UINT i , j , k , n , y ;
GString * new_key ;
gchar s [ 3 ] ;
PAirpcapKeysCollection KeysCollection ;
ULONG KeysCollectionSize ;
UCHAR KeyByte ;
UINT keys_in_list = 0 ;
decryption_key_t * key_item = NULL ;
airpcap_if_info_t * fake_info_if = NULL ;
/* Create the fake_info_if from the first adapter of the list */
fake_info_if = airpcap_driver_fake_if_info_new ( ) ;
if ( fake_info_if = = NULL )
2007-01-24 01:17:48 +00:00
return FALSE ;
2007-01-11 02:42:34 +00:00
/*
* XXX - When WPA will be supported , change this to : keys_in_list = g_list_length ( key_list ) ;
* but right now we will have to count only the WEP keys ( or we will have a malloc - mess : - ) )
*/
n = g_list_length ( key_list ) ;
for ( k = 0 ; k < n ; k + + )
2007-01-24 01:17:48 +00:00
if ( ( ( decryption_key_t * ) g_list_nth_data ( key_list , k ) ) - > type = = AIRPDCAP_KEY_TYPE_WEP )
keys_in_list + + ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
/*
* Save the encryption keys , if we have any of them
*/
KeysCollectionSize = 0 ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
/*
* Calculate the size of the keys collection
*/
KeysCollectionSize = sizeof ( AirpcapKeysCollection ) + keys_in_list * sizeof ( AirpcapKey ) ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
/*
* Allocate the collection
*/
KeysCollection = ( PAirpcapKeysCollection ) g_malloc ( KeysCollectionSize ) ;
if ( ! KeysCollection )
{
2007-01-24 01:17:48 +00:00
return FALSE ;
2007-01-11 02:42:34 +00:00
}
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
/*
* Populate the key collection
*/
KeysCollection - > nKeys = keys_in_list ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
/*
* XXX - If we have , let ' s say , six keys , the first three are WEP , then two are WPA , and the
* last is WEP , we have to scroll the whole list ( n ) but increment the array counter only
* when a WEP key is found ( y ) . . When WPA will be supported by the driver , I ' ll have to change
* this
*/
y = 0 ; /* Current position in the key list */
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
for ( i = 0 ; i < n ; i + + )
{
2006-10-30 06:34:31 +00:00
/* Retrieve the Item corresponding to the i-th key */
key_item = ( decryption_key_t * ) g_list_nth_data ( key_list , i ) ;
2006-12-27 23:05:55 +00:00
2006-12-05 19:24:25 +00:00
/*
* XXX - The AIRPDCAP_KEY_TYPE_WEP is the only supportd right now !
* We will have to modify the AirpcapKey structure in order to
* support the other two types ! What happens now , is that simply the
* not supported keys will just be discarded ( they will be saved in wireshark though )
*/
if ( key_item - > type = = AIRPDCAP_KEY_TYPE_WEP )
{
2007-01-11 02:42:34 +00:00
KeysCollection - > Keys [ y ] . KeyType = AIRPDCAP_KEY_TYPE_WEP ;
2006-12-05 19:24:25 +00:00
2007-01-11 02:42:34 +00:00
new_key = g_string_new ( key_item - > key - > str ) ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
KeysCollection - > Keys [ y ] . KeyLen = new_key - > len / 2 ;
memset ( & KeysCollection - > Keys [ y ] . KeyData , 0 , sizeof ( KeysCollection - > Keys [ y ] . KeyData ) ) ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
for ( j = 0 ; j < new_key - > len ; j + = 2 )
{
2006-10-30 06:34:31 +00:00
s [ 0 ] = new_key - > str [ j ] ;
s [ 1 ] = new_key - > str [ j + 1 ] ;
s [ 2 ] = ' \0 ' ;
KeyByte = ( UCHAR ) strtol ( s , NULL , 16 ) ;
2006-12-05 19:24:25 +00:00
KeysCollection - > Keys [ y ] . KeyData [ j / 2 ] = KeyByte ;
2007-01-11 02:42:34 +00:00
}
/* XXX - Change when WPA will be supported!!! */
y + + ;
g_string_free ( new_key , TRUE ) ;
2006-10-30 06:34:31 +00:00
}
2006-12-05 19:24:25 +00:00
else if ( key_item - > type = = AIRPDCAP_KEY_TYPE_WPA_PWD )
{
2007-01-24 01:17:48 +00:00
/* XXX - The driver cannot deal with this kind of key yet... */
2006-12-05 19:24:25 +00:00
}
else if ( key_item - > type = = AIRPDCAP_KEY_TYPE_WPA_PMK )
{
2007-01-24 01:17:48 +00:00
/* XXX - The driver cannot deal with this kind of key yet... */
2006-12-05 19:24:25 +00:00
}
2007-01-11 02:42:34 +00:00
}
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
/*
* Free the old adapter key collection !
*/
if ( fake_info_if - > keysCollection ! = NULL )
2007-01-24 01:17:48 +00:00
g_free ( fake_info_if - > keysCollection ) ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
/*
* Set this collection ad the new one
*/
fake_info_if - > keysCollection = KeysCollection ;
fake_info_if - > keysCollectionSize = KeysCollectionSize ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
/*
* Configuration must be saved
*/
fake_info_if - > saved = FALSE ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
/*
* Write down the changes to the registry
*/
airpcap_save_driver_if_configuration ( fake_info_if ) ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
airpcap_if_info_free ( fake_info_if ) ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
return TRUE ;
2006-10-30 06:34:31 +00:00
}
/*
* Function used to save to the preference file the Decryption Keys .
*/
int
save_wlan_driver_wep_keys ( )
{
2007-01-11 02:42:34 +00:00
GList * key_list = NULL ;
char * tmp_key = NULL ;
guint keys_in_list , i ;
keys_cb_data_t * user_data ;
airpcap_if_info_t * fake_info_if = NULL ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
/* Create the fake_info_if from the first adapter of the list */
fake_info_if = airpcap_driver_fake_if_info_new ( ) ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
if ( fake_info_if = = NULL )
2007-01-24 01:17:48 +00:00
return FALSE ;
2006-12-05 19:24:25 +00:00
2007-01-11 02:42:34 +00:00
/* Retrieve the wlan preferences */
wlan_prefs = prefs_find_module ( " wlan " ) ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
/* Allocate a structure used to keep infos between the callbacks */
user_data = ( keys_cb_data_t * ) g_malloc ( sizeof ( keys_cb_data_t ) ) ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
/* Number of keys in key list */
/* Number of keys in key list */
if ( fake_info_if - > keysCollectionSize ! = 0 )
keys_in_list = ( guint ) ( fake_info_if - > keysCollectionSize - sizeof ( AirpcapKeysCollection ) ) / sizeof ( AirpcapKey ) ;
else
keys_in_list = 0 ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
for ( i = 0 ; i < keys_in_list ; i + + )
2006-10-30 06:34:31 +00:00
{
2007-01-11 02:42:34 +00:00
/* Only if it is a WEP key... */
2007-01-24 01:17:48 +00:00
if ( fake_info_if - > keysCollection - > Keys [ i ] . KeyType = = AIRPDCAP_KEY_TYPE_WEP )
2007-01-11 02:42:34 +00:00
{
2007-01-24 01:17:48 +00:00
tmp_key = airpcap_get_key_string ( fake_info_if - > keysCollection - > Keys [ i ] ) ;
key_list = g_list_append ( key_list , g_strdup ( tmp_key ) ) ;
g_free ( tmp_key ) ;
2007-01-11 02:42:34 +00:00
}
2006-10-30 06:34:31 +00:00
}
2007-01-11 02:42:34 +00:00
/* Now we know the exact number of WEP keys in the list, so store it ... */
keys_in_list = g_list_length ( key_list ) ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
/* Fill the structure */
user_data - > list = key_list ;
user_data - > current_index = 0 ;
user_data - > number_of_keys = keys_in_list ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
/* Retrieve the wlan preferences */
wlan_prefs = prefs_find_module ( " wlan " ) ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
/* Run the callback on each 802.11 preference */
prefs_pref_foreach ( wlan_prefs , set_wep_key , ( gpointer ) user_data ) ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
/* Signal that we've changed things, and run the 802.11 dissector's
* callback */
wlan_prefs - > prefs_changed = TRUE ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
/* Apply changes for the specified preference */
prefs_apply ( wlan_prefs ) ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
/* FREE MEMORY */
/* free the WEP key string */
for ( i = 0 ; i < g_list_length ( user_data - > list ) ; i + + )
2007-01-24 01:17:48 +00:00
{
2007-01-11 02:42:34 +00:00
g_free ( g_list_nth ( user_data - > list , i ) - > data ) ;
2007-01-24 01:17:48 +00:00
}
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
/* free the (empty) list */
g_list_free ( user_data - > list ) ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
/* free the user_data structure */
g_free ( user_data ) ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
airpcap_if_info_free ( fake_info_if ) ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
return keys_in_list ;
2006-10-30 06:34:31 +00:00
}
/*
* Function used to save to the preference file the Decryption Keys .
*/
int
save_wlan_wireshark_wep_keys ( GList * key_ls )
{
2007-01-11 02:42:34 +00:00
GList * key_list = NULL ;
char * tmp_key = NULL ;
guint keys_in_list , i ;
keys_cb_data_t * user_data ;
airpcap_if_info_t * fake_info_if = NULL ;
decryption_key_t * tmp_dk ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
/* Retrieve the wlan preferences */
wlan_prefs = prefs_find_module ( " wlan " ) ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
/* Allocate a structure used to keep infos between the callbacks */
user_data = ( keys_cb_data_t * ) g_malloc ( sizeof ( keys_cb_data_t ) ) ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
keys_in_list = g_list_length ( key_ls ) ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
key_list = key_ls ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
/* Fill the structure */
user_data - > list = key_list ;
user_data - > current_index = 0 ;
user_data - > number_of_keys = keys_in_list ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
/* Retrieve the wlan preferences */
wlan_prefs = prefs_find_module ( " wlan " ) ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
/* Run the callback on each 802.11 preference */
prefs_pref_foreach ( wlan_prefs , set_wep_key , ( gpointer ) user_data ) ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
/* Signal that we've changed things, and run the 802.11 dissector's
* callback */
wlan_prefs - > prefs_changed = TRUE ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
/* Apply changes for the specified preference */
prefs_apply ( wlan_prefs ) ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
/* FREE MEMORY */
/* free the WEP key string */
for ( i = 0 ; i < g_list_length ( user_data - > list ) ; i + + )
2007-01-24 01:17:48 +00:00
{
tmp_dk = ( decryption_key_t * ) g_list_nth ( user_data - > list , i ) - > data ;
g_string_free ( tmp_dk - > key , TRUE ) ;
if ( tmp_dk - > ssid ! = NULL ) g_byte_array_free ( tmp_dk - > ssid , TRUE ) ;
}
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
/* free the (empty) list */
g_list_free ( user_data - > list ) ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
/* free the user_data structure */
g_free ( user_data ) ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
return keys_in_list ;
2006-10-30 06:34:31 +00:00
}
2006-08-16 18:01:25 +00:00
/*
* Get an error message string for a CANT_GET_INTERFACE_LIST error from
* " get_airpcap_interface_list() " .
*/
2007-01-21 23:45:36 +00:00
static gchar *
2006-08-16 18:01:25 +00:00
cant_get_airpcap_if_list_error_message ( const char * err_str )
{
2007-01-24 01:17:48 +00:00
return g_strdup_printf ( " Can't get list of Wireless interfaces: %s " , err_str ) ;
2006-08-16 18:01:25 +00:00
}
/*
* Airpcap wrapper , used to store the current settings for the selected adapter
*/
BOOL
airpcap_if_store_cur_config_as_adapter_default ( PAirpcapHandle ah )
{
2007-01-24 01:17:48 +00:00
if ( ! AirpcapLoaded ) return FALSE ;
return g_PAirpcapStoreCurConfigAsAdapterDefault ( ah ) ;
2006-08-16 18:01:25 +00:00
}
/*
* Airpcap wrapper , used to open an airpcap adapter
*/
PAirpcapHandle
airpcap_if_open ( PCHAR name , PCHAR err )
{
2007-01-24 01:17:48 +00:00
if ( ! AirpcapLoaded ) return NULL ;
if ( name = = NULL ) return NULL ;
return g_PAirpcapOpen ( name , err ) ;
2006-08-16 18:01:25 +00:00
}
/*
* Airpcap wrapper , used to close an airpcap adapter
*/
VOID
airpcap_if_close ( PAirpcapHandle handle )
{
2007-01-24 01:17:48 +00:00
if ( ! AirpcapLoaded ) return ;
g_PAirpcapClose ( handle ) ;
2006-08-16 18:01:25 +00:00
}
/*
* Airpcap wrapper , used to turn on the led of an airpcap adapter
*/
BOOL
airpcap_if_turn_led_on ( PAirpcapHandle AdapterHandle , UINT LedNumber )
{
2007-01-24 01:17:48 +00:00
if ( ! AirpcapLoaded ) return FALSE ;
return g_PAirpcapTurnLedOn ( AdapterHandle , LedNumber ) ;
2006-08-16 18:01:25 +00:00
}
/*
* Airpcap wrapper , used to turn off the led of an airpcap adapter
*/
BOOL
airpcap_if_turn_led_off ( PAirpcapHandle AdapterHandle , UINT LedNumber )
{
2007-01-24 01:17:48 +00:00
if ( ! AirpcapLoaded ) return FALSE ;
return g_PAirpcapTurnLedOff ( AdapterHandle , LedNumber ) ;
2006-08-16 18:01:25 +00:00
}
/*
* Airpcap wrapper , used to get the channel of an airpcap adapter
*/
BOOL
airpcap_if_get_device_channel ( PAirpcapHandle ah , PUINT ch )
{
2007-01-24 01:17:48 +00:00
if ( ! AirpcapLoaded ) return FALSE ;
return g_PAirpcapGetDeviceChannel ( ah , ch ) ;
2006-08-16 18:01:25 +00:00
}
/*
* Airpcap wrapper , used to set the channel of an airpcap adapter
*/
BOOL
airpcap_if_set_device_channel ( PAirpcapHandle ah , UINT ch )
{
2007-01-24 01:17:48 +00:00
if ( ! AirpcapLoaded ) return FALSE ;
return g_PAirpcapSetDeviceChannel ( ah , ch ) ;
2006-08-16 18:01:25 +00:00
}
/*
* Airpcap wrapper , used to get the link type of an airpcap adapter
*/
BOOL
airpcap_if_get_link_type ( PAirpcapHandle ah , PAirpcapLinkType lt )
{
2007-01-24 01:17:48 +00:00
if ( ! AirpcapLoaded ) return FALSE ;
return g_PAirpcapGetLinkType ( ah , lt ) ;
2006-08-16 18:01:25 +00:00
}
/*
* Airpcap wrapper , used to set the link type of an airpcap adapter
*/
BOOL
airpcap_if_set_link_type ( PAirpcapHandle ah , AirpcapLinkType lt )
{
2007-01-24 01:17:48 +00:00
if ( ! AirpcapLoaded ) return FALSE ;
return g_PAirpcapSetLinkType ( ah , lt ) ;
2006-08-16 18:01:25 +00:00
}
/*
* Airpcap wrapper , used to get the fcs presence of an airpcap adapter
*/
BOOL
airpcap_if_get_fcs_presence ( PAirpcapHandle ah , PBOOL fcs )
{
2007-01-24 01:17:48 +00:00
if ( ! AirpcapLoaded ) return FALSE ;
return g_PAirpcapGetFcsPresence ( ah , fcs ) ;
2006-08-16 18:01:25 +00:00
}
/*
* Airpcap wrapper , used to set the fcs presence of an airpcap adapter
*/
BOOL
airpcap_if_set_fcs_presence ( PAirpcapHandle ah , BOOL fcs )
{
2007-01-24 01:17:48 +00:00
if ( ! AirpcapLoaded ) return FALSE ;
return g_PAirpcapSetFcsPresence ( ah , fcs ) ;
2006-08-16 18:01:25 +00:00
}
/*
* Airpcap wrapper , used to get the decryption enabling of an airpcap adapter
*/
BOOL
airpcap_if_get_decryption_state ( PAirpcapHandle ah , PAirpcapDecryptionState PEnable )
{
2007-01-24 01:17:48 +00:00
if ( ! AirpcapLoaded ) return FALSE ;
return g_PAirpcapGetDecryptionState ( ah , PEnable ) ;
2006-08-16 18:01:25 +00:00
}
/*
* Airpcap wrapper , used to set the decryption enabling of an airpcap adapter
*/
BOOL
airpcap_if_set_decryption_state ( PAirpcapHandle ah , AirpcapDecryptionState Enable )
{
2007-01-24 01:17:48 +00:00
if ( ! AirpcapLoaded ) return FALSE ;
return g_PAirpcapSetDecryptionState ( ah , Enable ) ;
2006-08-16 18:01:25 +00:00
}
2006-10-30 06:34:31 +00:00
/*
* Airpcap wrapper , used to get the decryption enabling of an airpcap driver
*/
BOOL
airpcap_if_get_driver_decryption_state ( PAirpcapHandle ah , PAirpcapDecryptionState PEnable )
{
2007-01-24 01:17:48 +00:00
if ( ! AirpcapLoaded | | ( g_PAirpcapGetDriverDecryptionState = = NULL ) ) return FALSE ;
return g_PAirpcapGetDriverDecryptionState ( ah , PEnable ) ;
2006-10-30 06:34:31 +00:00
}
/*
* Airpcap wrapper , used to set the decryption enabling of an airpcap driver
*/
BOOL
airpcap_if_set_driver_decryption_state ( PAirpcapHandle ah , AirpcapDecryptionState Enable )
{
2007-01-24 01:17:48 +00:00
if ( ! AirpcapLoaded | | ( g_PAirpcapSetDriverDecryptionState = = NULL ) ) return FALSE ;
return g_PAirpcapSetDriverDecryptionState ( ah , Enable ) ;
2006-10-30 06:34:31 +00:00
}
2006-08-16 18:01:25 +00:00
/*
* Airpcap wrapper , used to get the fcs validation of an airpcap adapter
*/
BOOL
airpcap_if_get_fcs_validation ( PAirpcapHandle ah , PAirpcapValidationType val )
{
2007-01-24 01:17:48 +00:00
if ( ! AirpcapLoaded ) return FALSE ;
return g_PAirpcapGetFcsValidation ( ah , val ) ;
2006-08-16 18:01:25 +00:00
}
/*
* Airpcap wrapper , used to set the fcs validation of an airpcap adapter
*/
BOOL
airpcap_if_set_fcs_validation ( PAirpcapHandle ah , AirpcapValidationType val )
{
2007-01-24 01:17:48 +00:00
if ( ! AirpcapLoaded ) return FALSE ;
return g_PAirpcapSetFcsValidation ( ah , val ) ;
2006-08-16 18:01:25 +00:00
}
/*
* Airpcap wrapper , used to save the settings for the selected_if
*/
BOOL
airpcap_if_set_device_keys ( PAirpcapHandle AdapterHandle , PAirpcapKeysCollection KeysCollection )
{
2007-01-24 01:17:48 +00:00
if ( ! AirpcapLoaded ) return FALSE ;
return g_PAirpcapSetDeviceKeys ( AdapterHandle , KeysCollection ) ;
2006-08-16 18:01:25 +00:00
}
/*
* Airpcap wrapper , used to save the settings for the selected_if
*/
BOOL
airpcap_if_get_device_keys ( PAirpcapHandle AdapterHandle , PAirpcapKeysCollection KeysCollection , PUINT PKeysCollectionSize )
2006-10-26 21:53:30 +00:00
{
2007-01-24 01:17:48 +00:00
if ( ! AirpcapLoaded ) return FALSE ;
return g_PAirpcapGetDeviceKeys ( AdapterHandle , KeysCollection , PKeysCollectionSize ) ;
2006-08-16 18:01:25 +00:00
}
2006-10-30 06:34:31 +00:00
/*
* Airpcap wrapper , used to save the driver ' s set of keys
*/
BOOL
airpcap_if_set_driver_keys ( PAirpcapHandle AdapterHandle , PAirpcapKeysCollection KeysCollection )
{
2007-01-24 01:17:48 +00:00
if ( ! AirpcapLoaded | | ( g_PAirpcapSetDriverKeys = = NULL ) ) return FALSE ;
return g_PAirpcapSetDriverKeys ( AdapterHandle , KeysCollection ) ;
2006-10-30 06:34:31 +00:00
}
/*
* Airpcap wrapper , used to load the driver ' s set of keys
*/
BOOL
airpcap_if_get_driver_keys ( PAirpcapHandle AdapterHandle , PAirpcapKeysCollection KeysCollection , PUINT PKeysCollectionSize )
{
2007-01-24 01:17:48 +00:00
if ( ! AirpcapLoaded | | ( g_PAirpcapGetDriverKeys = = NULL ) ) return FALSE ;
return g_PAirpcapGetDriverKeys ( AdapterHandle , KeysCollection , PKeysCollectionSize ) ;
2006-10-30 06:34:31 +00:00
}
2006-08-16 18:01:25 +00:00
/*
* This function will create a new airpcap_if_info_t using a name and a description
*/
airpcap_if_info_t *
airpcap_if_info_new ( char * name , char * description )
{
2007-01-24 01:17:48 +00:00
PAirpcapHandle ad ;
gchar ebuf [ AIRPCAP_ERRBUF_SIZE ] ;
2006-08-16 18:01:25 +00:00
2007-01-24 01:17:48 +00:00
airpcap_if_info_t * if_info = NULL ;
2006-08-16 18:01:25 +00:00
2007-01-24 01:17:48 +00:00
/* Probably I have to switch on the leds!!! */
ad = airpcap_if_open ( name , ebuf ) ;
if ( ad )
{
2006-08-16 18:01:25 +00:00
if_info = g_malloc ( sizeof ( airpcap_if_info_t ) ) ;
if_info - > name = g_strdup ( name ) ;
if ( description = = NULL )
2007-01-24 01:17:48 +00:00
if_info - > description = NULL ;
2006-08-16 18:01:25 +00:00
else
2007-01-24 01:17:48 +00:00
if_info - > description = g_strdup ( description ) ;
2006-08-16 18:01:25 +00:00
if_info - > ip_addr = NULL ;
if_info - > loopback = FALSE ;
2007-01-24 01:17:48 +00:00
airpcap_if_get_fcs_validation ( ad , & ( if_info - > CrcValidationOn ) ) ;
airpcap_if_get_fcs_presence ( ad , & ( if_info - > IsFcsPresent ) ) ;
airpcap_if_get_link_type ( ad , & ( if_info - > linkType ) ) ;
airpcap_if_get_device_channel ( ad , & ( if_info - > channel ) ) ;
airpcap_if_turn_led_on ( ad , 0 ) ;
airpcap_if_get_decryption_state ( ad , & ( if_info - > DecryptionOn ) ) ;
if_info - > led = TRUE ;
if_info - > blinking = FALSE ;
if_info - > saved = TRUE ; /* NO NEED TO BE SAVED */
/* get the keys, if everything is ok, close the adapter */
if ( airpcap_if_load_keys ( ad , if_info ) )
{
airpcap_if_close ( ad ) ;
}
}
return if_info ;
2006-08-16 18:01:25 +00:00
}
2006-10-30 06:34:31 +00:00
/*
* This function will create a new fake drivers ' interface , to load global keys . . .
*/
airpcap_if_info_t *
airpcap_driver_fake_if_info_new ( )
{
2007-01-24 01:17:48 +00:00
PAirpcapHandle ad ;
gchar ebuf [ AIRPCAP_ERRBUF_SIZE ] ;
2006-10-30 06:34:31 +00:00
2007-01-24 01:17:48 +00:00
airpcap_if_info_t * if_info = NULL ;
airpcap_if_info_t * fake_if_info = NULL ;
2006-10-30 06:34:31 +00:00
2007-01-24 01:17:48 +00:00
/* Maybe for some reason no airpcap adapter is found */
if ( airpcap_if_list = = NULL )
return NULL ;
2006-12-05 19:24:25 +00:00
2007-01-24 01:17:48 +00:00
/*
* Retrieve the first AirPcap adapter available . If no interface is found ,
* it is not possible to retrieve the driver ' s settings , so return NULL .
*/
if_info = g_list_nth_data ( airpcap_if_list , 0 ) ;
if ( if_info = = NULL )
return NULL ;
2006-10-30 06:34:31 +00:00
2007-01-24 01:17:48 +00:00
/* Open the 'fake' adapter */
ad = airpcap_if_open ( if_info - > name , ebuf ) ;
if ( ad )
{
2006-10-30 06:34:31 +00:00
fake_if_info = g_malloc ( sizeof ( airpcap_if_info_t ) ) ;
fake_if_info - > name = g_strdup ( if_info - > name ) ;
fake_if_info - > description = g_strdup ( if_info - > description ) ;
fake_if_info - > loopback = FALSE ;
fake_if_info - > ip_addr = NULL ;
2007-01-24 01:17:48 +00:00
airpcap_if_get_driver_decryption_state ( ad , & ( fake_if_info - > DecryptionOn ) ) ;
airpcap_if_get_fcs_validation ( ad , & ( fake_if_info - > CrcValidationOn ) ) ;
airpcap_if_get_fcs_presence ( ad , & ( fake_if_info - > IsFcsPresent ) ) ;
airpcap_if_get_link_type ( ad , & ( fake_if_info - > linkType ) ) ;
airpcap_if_get_device_channel ( ad , & ( fake_if_info - > channel ) ) ;
airpcap_if_turn_led_on ( ad , 0 ) ;
fake_if_info - > led = TRUE ;
fake_if_info - > blinking = FALSE ;
fake_if_info - > saved = TRUE ; /* NO NEED TO BE SAVED */
/* get the keys, if everything is ok, close the adapter */
if ( airpcap_if_load_driver_keys ( ad , fake_if_info ) )
{
airpcap_if_close ( ad ) ;
}
}
2006-10-30 06:34:31 +00:00
2007-01-24 01:17:48 +00:00
return fake_if_info ;
2006-10-30 06:34:31 +00:00
}
/*
* USED FOR DEBUG ONLY . . . PRINTS AN AirPcap ADAPTER STRUCTURE in a fancy way .
*/
void
airpcap_if_info_print ( airpcap_if_info_t * if_info )
{
2007-01-11 02:42:34 +00:00
if ( if_info = = NULL )
2007-01-24 01:17:48 +00:00
{
g_print ( " \n WARNING : AirPcap Interface pointer is NULL! \n " ) ;
return ;
}
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
g_print ( " \n ----------------- AirPcap Interface \n " ) ;
g_print ( " NAME: %s \n " , if_info - > name ) ;
g_print ( " DESCRIPTION: %s \n " , if_info - > description ) ;
g_print ( " BLINKING: %s \n " , if_info - > blinking ? " TRUE " : " FALSE " ) ;
g_print ( " CHANNEL: %2u \n " , if_info - > channel ) ;
g_print ( " CRCVALIDATION: %s \n " , if_info - > CrcValidationOn ? " ON " : " OFF " ) ;
g_print ( " DECRYPTION: %s \n " , if_info - > DecryptionOn ? " ON " : " OFF " ) ;
g_print ( " IP ADDR: %s \n " , if_info - > ip_addr ! = NULL ? " NOT NULL " : " NULL " ) ;
g_print ( " FCSPRESENT: %s \n " , if_info - > IsFcsPresent ? " TRUE " : " FALSE " ) ;
g_print ( " KEYSCOLLECTION: %s \n " , if_info - > keysCollection ! = NULL ? " NOT NULL " : " NULL " ) ;
g_print ( " KEYSCOLLECTIONSIZE: %u \n " , if_info - > keysCollectionSize ) ;
g_print ( " LED: %s \n " , if_info - > led ? " ON " : " OFF " ) ;
g_print ( " LINKTYPE: %d \n " , if_info - > linkType ) ;
g_print ( " LOOPBACK: %s \n " , if_info - > loopback ? " YES " : " NO " ) ;
g_print ( " (GTK) TAG: %d \n " , if_info - > tag ) ;
g_print ( " \n \n " ) ;
2006-10-30 06:34:31 +00:00
}
2006-08-16 18:01:25 +00:00
/*
* Function used to load the WEP keys for a selected interface
*/
BOOL
airpcap_if_load_keys ( PAirpcapHandle ad , airpcap_if_info_t * if_info )
{
2007-01-11 02:42:34 +00:00
if ( ! if_info ) return FALSE ;
2006-08-16 18:01:25 +00:00
2007-01-11 02:42:34 +00:00
if_info - > keysCollectionSize = 0 ;
if_info - > keysCollection = NULL ;
2006-08-16 18:01:25 +00:00
2007-01-11 02:42:34 +00:00
if ( ! airpcap_if_get_device_keys ( ad , NULL , & ( if_info - > keysCollectionSize ) ) )
2007-01-24 01:17:48 +00:00
{
if ( if_info - > keysCollectionSize = = 0 )
{
if_info - > keysCollection = NULL ;
airpcap_if_close ( ad ) ;
return FALSE ;
}
2006-08-16 18:01:25 +00:00
2007-01-24 01:17:48 +00:00
if_info - > keysCollection = ( PAirpcapKeysCollection ) g_malloc ( if_info - > keysCollectionSize ) ;
if ( ! if_info - > keysCollection )
{
if_info - > keysCollectionSize = 0 ;
if_info - > keysCollection = NULL ;
airpcap_if_close ( ad ) ;
return FALSE ;
}
2006-10-26 21:53:30 +00:00
2007-01-24 01:17:48 +00:00
airpcap_if_get_device_keys ( ad , if_info - > keysCollection , & ( if_info - > keysCollectionSize ) ) ;
return TRUE ;
}
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
airpcap_if_close ( ad ) ;
return FALSE ;
2006-10-30 06:34:31 +00:00
}
/*
* Function used to load the WEP keys for a selected interface
*/
BOOL
airpcap_if_load_driver_keys ( PAirpcapHandle ad , airpcap_if_info_t * if_info )
{
2007-01-11 02:42:34 +00:00
if_info - > keysCollectionSize = 0 ;
if_info - > keysCollection = NULL ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
if ( ! airpcap_if_get_driver_keys ( ad , NULL , & ( if_info - > keysCollectionSize ) ) )
2007-01-24 01:17:48 +00:00
{
if ( if_info - > keysCollectionSize = = 0 )
{
if_info - > keysCollection = NULL ;
airpcap_if_close ( ad ) ;
return FALSE ;
}
2006-10-30 06:34:31 +00:00
2007-01-24 01:17:48 +00:00
if_info - > keysCollection = ( PAirpcapKeysCollection ) g_malloc ( if_info - > keysCollectionSize ) ;
if ( ! if_info - > keysCollection )
{
if_info - > keysCollectionSize = 0 ;
if_info - > keysCollection = NULL ;
airpcap_if_close ( ad ) ;
return FALSE ;
}
2006-10-30 06:34:31 +00:00
2007-01-24 01:17:48 +00:00
airpcap_if_get_driver_keys ( ad , if_info - > keysCollection , & ( if_info - > keysCollectionSize ) ) ;
return TRUE ;
}
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
airpcap_if_close ( ad ) ;
return FALSE ;
2006-08-16 18:01:25 +00:00
}
/*
* Function used to save the WEP keys for a selected interface
*/
void
airpcap_if_save_keys ( PAirpcapHandle ad , airpcap_if_info_t * if_info )
{
2007-01-24 01:17:48 +00:00
if ( ! if_info | | ! AirpcapLoaded ) return ;
2006-10-26 21:53:30 +00:00
2007-01-24 01:17:48 +00:00
if ( if_info - > keysCollection ! = NULL )
g_PAirpcapSetDeviceKeys ( ad , if_info - > keysCollection ) ;
2006-08-16 18:01:25 +00:00
}
2006-10-30 06:34:31 +00:00
/*
* Function used to save the WEP keys for a selected interface
*/
void
airpcap_if_save_driver_keys ( PAirpcapHandle ad , airpcap_if_info_t * if_info )
{
2007-01-24 01:17:48 +00:00
if ( if_info - > keysCollection ! = NULL )
airpcap_if_set_driver_keys ( ad , if_info - > keysCollection ) ;
2006-10-30 06:34:31 +00:00
}
2006-08-16 18:01:25 +00:00
/*
* Callback used to free an instance of airpcap_if_info_t
*/
static void
free_airpcap_if_cb ( gpointer data , gpointer user_data _U_ )
{
2007-01-24 01:17:48 +00:00
airpcap_if_info_t * if_info = data ;
2006-08-16 18:01:25 +00:00
2007-01-24 01:17:48 +00:00
if ( if_info - > name ! = NULL )
g_free ( if_info - > name ) ;
2006-08-16 18:01:25 +00:00
2007-01-24 01:17:48 +00:00
if ( if_info - > description ! = NULL )
g_free ( if_info - > description ) ;
2006-08-16 18:01:25 +00:00
2007-01-24 01:17:48 +00:00
/* XXX - FREE THE WEP KEY LIST HERE!!!*/
if ( if_info - > keysCollection ! = NULL )
{
g_free ( if_info - > keysCollection ) ;
if_info - > keysCollection = NULL ;
}
2006-08-16 18:01:25 +00:00
2007-01-24 01:17:48 +00:00
if ( if_info - > ip_addr ! = NULL )
g_slist_free ( if_info - > ip_addr ) ;
2006-08-16 18:01:25 +00:00
2007-01-24 01:17:48 +00:00
if ( if_info ! = NULL )
g_free ( if_info ) ;
2006-08-16 18:01:25 +00:00
}
/*
* Function used to free the airpcap interface list
*/
void
free_airpcap_interface_list ( GList * if_list )
{
2007-01-24 01:17:48 +00:00
g_list_foreach ( if_list , free_airpcap_if_cb , NULL ) ;
g_list_free ( if_list ) ;
if_list = NULL ;
2006-08-16 18:01:25 +00:00
}
/*
* This function will use the airpcap . dll to find all the airpcap devices .
* Will return null if no device is found .
*/
GList *
2007-01-21 23:45:36 +00:00
get_airpcap_interface_list ( int * err , char * * err_str )
2006-08-16 18:01:25 +00:00
{
2007-01-11 02:42:34 +00:00
GList * il = NULL ;
airpcap_if_info_t * if_info ;
int i , n_adapts ;
2006-10-30 06:34:31 +00:00
AirpcapDeviceDescription * devsList , * adListEntry ;
2007-01-21 23:45:36 +00:00
char errbuf [ PCAP_ERRBUF_SIZE ] ;
2006-10-26 21:53:30 +00:00
2007-01-24 01:17:48 +00:00
if ( ! AirpcapLoaded )
return il ;
if ( ! g_PAirpcapGetDeviceList ( & devsList , errbuf ) )
2007-01-11 02:42:34 +00:00
{
2007-01-24 01:17:48 +00:00
/* No interfaces, return il = NULL; */
* err = CANT_GET_AIRPCAP_INTERFACE_LIST ;
if ( err_str ! = NULL )
* err_str = cant_get_airpcap_if_list_error_message ( errbuf ) ;
return il ;
2007-01-11 02:42:34 +00:00
}
2006-08-16 18:01:25 +00:00
2007-01-11 02:42:34 +00:00
/*
* Count the adapters
*/
adListEntry = devsList ;
n_adapts = 0 ;
while ( adListEntry )
{
2007-01-24 01:17:48 +00:00
n_adapts + + ;
adListEntry = adListEntry - > next ;
2007-01-11 02:42:34 +00:00
}
2006-08-16 18:01:25 +00:00
2007-01-11 02:42:34 +00:00
if ( n_adapts = = 0 )
{
2007-01-24 01:17:48 +00:00
/* No interfaces, return il= NULL */
g_PAirpcapFreeDeviceList ( devsList ) ;
* err = NO_AIRPCAP_INTERFACES_FOUND ;
if ( err_str ! = NULL )
* err_str = NULL ;
return il ;
2007-01-11 02:42:34 +00:00
}
2006-08-16 18:01:25 +00:00
2007-01-11 02:42:34 +00:00
/*
* Insert the adapters in our list
*/
adListEntry = devsList ;
for ( i = 0 ; i < n_adapts ; i + + )
{
2007-01-24 01:17:48 +00:00
if_info = airpcap_if_info_new ( adListEntry - > Name , adListEntry - > Description ) ;
il = g_list_append ( il , if_info ) ;
2006-08-16 18:01:25 +00:00
2007-01-24 01:17:48 +00:00
adListEntry = adListEntry - > next ;
2007-01-11 02:42:34 +00:00
}
2006-08-16 18:01:25 +00:00
2007-01-11 02:42:34 +00:00
g_PAirpcapFreeDeviceList ( devsList ) ;
2006-08-16 18:01:25 +00:00
2007-01-21 23:45:36 +00:00
* err = 0 ;
2007-01-11 02:42:34 +00:00
return il ;
2006-08-16 18:01:25 +00:00
}
/*
* Used to retrieve the name of the interface given the description
* ( the name is used in AirpcapOpen , the description is put in the combo box )
*/
gchar * get_airpcap_name_from_description ( GList * if_list , gchar * description )
{
2007-01-11 02:42:34 +00:00
unsigned int ifn ;
GList * curr ;
airpcap_if_info_t * if_info ;
2006-08-16 18:01:25 +00:00
2007-01-11 02:42:34 +00:00
ifn = 0 ;
if ( if_list ! = NULL )
{
2006-10-30 06:34:31 +00:00
while ( ifn < g_list_length ( if_list ) )
2007-01-11 02:42:34 +00:00
{
curr = g_list_nth ( if_list , ifn ) ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
if_info = NULL ;
if ( curr ! = NULL )
if_info = curr - > data ;
if ( if_info ! = NULL )
2007-01-24 01:17:48 +00:00
{
if ( g_ascii_strcasecmp ( if_info - > description , description ) = = 0 )
{
return if_info - > name ;
}
}
2007-01-11 02:42:34 +00:00
ifn + + ;
2006-10-30 06:34:31 +00:00
}
2007-01-11 02:42:34 +00:00
}
return NULL ;
2006-08-16 18:01:25 +00:00
}
/*
* Used to retrieve the interface given the name
* ( the name is used in AirpcapOpen )
*/
airpcap_if_info_t * get_airpcap_if_by_name ( GList * if_list , const gchar * name )
{
2007-01-11 02:42:34 +00:00
unsigned int ifn ;
GList * curr ;
airpcap_if_info_t * if_info ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
ifn = 0 ;
if ( if_list ! = NULL )
2007-01-24 01:17:48 +00:00
{
while ( ifn < g_list_length ( if_list ) )
{
curr = g_list_nth ( if_list , ifn ) ;
if_info = NULL ;
if ( curr ! = NULL )
if_info = curr - > data ;
if ( if_info ! = NULL )
2007-01-11 02:42:34 +00:00
{
2007-01-24 01:17:48 +00:00
if ( g_ascii_strcasecmp ( if_info - > name , name ) = = 0 )
{
return if_info ;
}
2007-01-11 02:42:34 +00:00
}
2007-01-24 01:17:48 +00:00
ifn + + ;
}
}
2007-01-11 02:42:34 +00:00
return NULL ;
2006-08-16 18:01:25 +00:00
}
/*
2006-10-02 23:44:10 +00:00
* Returns the ASCII string of a key given the key bytes
2006-08-16 18:01:25 +00:00
*/
gchar *
airpcap_get_key_string ( AirpcapKey key )
{
2007-01-11 02:42:34 +00:00
unsigned int j = 0 ;
unsigned int l = 0 ;
gchar * dst , * src ;
2006-08-16 18:01:25 +00:00
2007-01-11 02:42:34 +00:00
dst = NULL ;
src = NULL ;
2006-08-16 18:01:25 +00:00
2007-01-11 02:42:34 +00:00
if ( key . KeyType = = AIRPDCAP_KEY_TYPE_WEP )
2007-01-24 01:17:48 +00:00
{
if ( key . KeyLen ! = 0 )
{
2007-01-11 02:42:34 +00:00
/* Allocate the string used to store the ASCII representation of the WEP key */
dst = ( gchar * ) g_malloc ( sizeof ( gchar ) * WEP_KEY_MAX_CHAR_SIZE + 1 ) ;
/* Make sure that the first char is '\0' in order to make g_strlcat() work */
dst [ 0 ] = ' \0 ' ;
2006-10-30 06:34:31 +00:00
2007-01-24 01:17:48 +00:00
for ( j = 0 ; j < key . KeyLen ; j + + )
{
src = g_strdup_printf ( " %.2x \0 " , key . KeyData [ j ] ) ;
/*
* XXX - use g_strconcat ( ) or GStrings instead ? ? ?
*/
l = g_strlcat ( dst , src , WEP_KEY_MAX_CHAR_SIZE + 1 ) ;
2007-01-11 02:42:34 +00:00
}
2007-01-24 01:17:48 +00:00
g_free ( src ) ;
}
}
2007-01-11 02:42:34 +00:00
else if ( key . KeyType = = AIRPDCAP_KEY_TYPE_WPA_PWD )
2007-01-24 01:17:48 +00:00
{
2007-01-11 02:42:34 +00:00
/* XXX - Add code here */
2007-01-24 01:17:48 +00:00
}
2007-01-11 02:42:34 +00:00
else if ( key . KeyType = = AIRPDCAP_KEY_TYPE_WPA_PMK )
2007-01-24 01:17:48 +00:00
{
2007-01-11 02:42:34 +00:00
/* XXX - Add code here */
2007-01-24 01:17:48 +00:00
}
2007-01-11 02:42:34 +00:00
else
2007-01-24 01:17:48 +00:00
{
2007-01-11 02:42:34 +00:00
/* XXX - Add code here */
2007-01-24 01:17:48 +00:00
}
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
return dst ;
2006-10-30 06:34:31 +00:00
}
/*
* Clear keys and decryption status for the specified interface
*/
void
airpcap_if_clear_decryption_settings ( airpcap_if_info_t * info_if )
{
2007-01-11 02:42:34 +00:00
if ( info_if ! = NULL )
{
2006-10-30 06:34:31 +00:00
if ( info_if - > keysCollection ! = NULL )
2007-01-11 02:42:34 +00:00
{
2007-01-24 01:17:48 +00:00
g_free ( info_if - > keysCollection ) ;
info_if - > keysCollection = NULL ;
2007-01-11 02:42:34 +00:00
}
2006-10-02 23:44:10 +00:00
2006-10-30 06:34:31 +00:00
info_if - > keysCollectionSize = 0 ;
info_if - > DecryptionOn = FALSE ;
info_if - > saved = FALSE ;
2007-01-11 02:42:34 +00:00
}
2006-08-16 18:01:25 +00:00
}
/*
* Used to retrieve the airpcap_if_info_t of the selected interface given the
* description ( that is the entry of the combo box ) .
*/
gpointer get_airpcap_if_from_description ( GList * if_list , const gchar * description )
{
2007-01-11 02:42:34 +00:00
unsigned int ifn ;
GList * curr ;
airpcap_if_info_t * if_info ;
2006-08-16 18:01:25 +00:00
2007-01-11 02:42:34 +00:00
ifn = 0 ;
if ( if_list ! = NULL )
2007-01-24 01:17:48 +00:00
{
while ( ifn < g_list_length ( if_list ) )
{
curr = g_list_nth ( if_list , ifn ) ;
if_info = NULL ;
if ( curr ! = NULL )
if_info = curr - > data ;
if ( if_info ! = NULL )
2007-01-11 02:42:34 +00:00
{
2007-01-24 01:17:48 +00:00
if ( g_ascii_strcasecmp ( if_info - > description , description ) = = 0 )
{
return if_info ;
}
2007-01-11 02:42:34 +00:00
}
2007-01-24 01:17:48 +00:00
ifn + + ;
}
}
2007-01-11 02:42:34 +00:00
return NULL ;
2006-08-16 18:01:25 +00:00
}
/*
* Used to retrieve the two chars string from interface
*/
gchar *
airpcap_get_if_string_number ( airpcap_if_info_t * if_info )
{
2007-01-24 01:17:48 +00:00
gchar * number ;
guint n ;
int a ;
2006-08-16 18:01:25 +00:00
2007-01-24 01:17:48 +00:00
a = sscanf ( if_info - > name , AIRPCAP_DEVICE_NUMBER_EXTRACT_STRING , & n ) ;
2006-10-26 21:53:30 +00:00
2006-10-02 23:44:10 +00:00
/* If sscanf() returned 1, it means that has read a number, so interface is not "Any"
* Otherwise , check if it is the " Any " adapter . . .
*/
2007-01-24 01:17:48 +00:00
if ( a = = 0 )
{
if ( g_strcasecmp ( if_info - > name , AIRPCAP_DEVICE_ANY_EXTRACT_STRING ) ! = 0 )
number = g_strdup_printf ( " ?? " ) ;
else
number = g_strdup_printf ( AIRPCAP_CHANNEL_ANY_NAME ) ;
}
else
{
number = g_strdup_printf ( " %.2u \0 " , n ) ;
}
2006-08-16 18:01:25 +00:00
2007-01-24 01:17:48 +00:00
return number ;
2006-08-16 18:01:25 +00:00
}
/*
* Used to retrieve the two chars string from interface
*/
gchar *
airpcap_get_if_string_number_from_description ( gchar * description )
{
2007-01-24 01:17:48 +00:00
gchar * number ;
gchar * pointer ;
2006-08-16 18:01:25 +00:00
2007-01-24 01:17:48 +00:00
number = ( gchar * ) g_malloc ( sizeof ( gchar ) * 3 ) ;
2006-08-16 18:01:25 +00:00
2007-01-24 01:17:48 +00:00
pointer = g_strrstr ( description , " # \0 " ) ;
2006-08-16 18:01:25 +00:00
2007-01-24 01:17:48 +00:00
number [ 0 ] = * ( pointer + 1 ) ;
number [ 1 ] = * ( pointer + 2 ) ;
number [ 2 ] = ' \0 ' ;
2006-08-16 18:01:25 +00:00
2007-01-24 01:17:48 +00:00
return number ;
2006-08-16 18:01:25 +00:00
}
/*
* Returns the default airpcap interface of a list , NULL if list is empty
*/
airpcap_if_info_t *
airpcap_get_default_if ( GList * airpcap_if_list )
{
2007-01-24 01:17:48 +00:00
int ifn = 0 ;
GList * popdown_if_list = NULL ;
GList * curr = NULL ;
2006-08-16 18:01:25 +00:00
2007-01-24 01:17:48 +00:00
gchar * s ;
airpcap_if_info_t * if_info = NULL ;
2006-08-16 18:01:25 +00:00
2006-10-30 06:34:31 +00:00
if ( prefs . capture_device ! = NULL )
{
s = g_strdup ( get_if_name ( prefs . capture_device ) ) ;
if_info = get_airpcap_if_by_name ( airpcap_if_list , g_strdup ( get_if_name ( prefs . capture_device ) ) ) ;
g_free ( s ) ;
}
2007-01-24 01:17:48 +00:00
return if_info ;
2006-08-16 18:01:25 +00:00
}
/*
* Load the configuration for the specified interface
*/
void
airpcap_load_selected_if_configuration ( airpcap_if_info_t * if_info )
{
2007-01-11 02:42:34 +00:00
gchar ebuf [ AIRPCAP_ERRBUF_SIZE ] ;
PAirpcapHandle ad ;
2006-08-16 18:01:25 +00:00
2007-01-11 02:42:34 +00:00
if ( if_info ! = NULL )
2007-01-24 01:17:48 +00:00
{
2006-10-30 06:34:31 +00:00
ad = airpcap_if_open ( get_airpcap_name_from_description ( airpcap_if_list , if_info - > description ) , ebuf ) ;
2006-08-16 18:01:25 +00:00
2006-10-30 06:34:31 +00:00
if ( ad )
2007-01-24 01:17:48 +00:00
{
/* Stop blinking (if it was blinkig!)*/
if ( if_info - > blinking )
{
/* Turn on the light (if it was off) */
if ( ! ( if_info - > led ) ) airpcap_if_turn_led_on ( ad , 0 ) ;
}
/* Apply settings... */
airpcap_if_get_device_channel ( ad , & ( if_info - > channel ) ) ;
airpcap_if_get_fcs_validation ( ad , & ( if_info - > CrcValidationOn ) ) ;
airpcap_if_get_fcs_presence ( ad , & ( if_info - > IsFcsPresent ) ) ;
airpcap_if_get_link_type ( ad , & ( if_info - > linkType ) ) ;
airpcap_if_get_decryption_state ( ad , & ( if_info - > DecryptionOn ) ) ;
/* get the keys, if everything is ok, close the adapter */
if ( airpcap_if_load_keys ( ad , if_info ) )
airpcap_if_close ( ad ) ;
if_info - > saved = TRUE ;
}
2006-10-30 06:34:31 +00:00
else
2007-01-24 01:17:48 +00:00
{
simple_dialog ( ESD_TYPE_ERROR , ESD_BTN_OK , " Error in opening adapter for %s " , if_info - > description ) ;
2006-10-30 06:34:31 +00:00
}
2007-01-24 01:17:48 +00:00
}
2006-08-16 18:01:25 +00:00
}
/*
* Save the configuration for the specified interface
*/
void
airpcap_save_selected_if_configuration ( airpcap_if_info_t * if_info )
{
2007-01-11 02:42:34 +00:00
gchar ebuf [ AIRPCAP_ERRBUF_SIZE ] ;
PAirpcapHandle ad ;
2006-08-16 18:01:25 +00:00
2007-01-11 02:42:34 +00:00
if ( if_info ! = NULL )
{
2006-10-30 06:34:31 +00:00
ad = airpcap_if_open ( get_airpcap_name_from_description ( airpcap_if_list , if_info - > description ) , ebuf ) ;
2006-10-26 21:53:30 +00:00
2006-10-30 06:34:31 +00:00
if ( ad )
2007-01-24 01:17:48 +00:00
{
/* Stop blinking (if it was blinkig!)*/
if ( if_info - > blinking )
{
/* Turn on the light (if it was off) */
if ( ! ( if_info - > led ) ) airpcap_if_turn_led_on ( ad , 0 ) ;
}
/* Apply settings... */
airpcap_if_set_device_channel ( ad , if_info - > channel ) ;
airpcap_if_set_fcs_validation ( ad , if_info - > CrcValidationOn ) ;
airpcap_if_set_fcs_presence ( ad , if_info - > IsFcsPresent ) ;
airpcap_if_set_link_type ( ad , if_info - > linkType ) ;
airpcap_if_set_decryption_state ( ad , if_info - > DecryptionOn ) ;
airpcap_if_save_keys ( ad , if_info ) ;
/* ... and save them */
if ( ! airpcap_if_store_cur_config_as_adapter_default ( ad ) )
{
simple_dialog ( ESD_TYPE_ERROR , ESD_BTN_OK , " Cannot save Wireless configuration!!! \n Remember 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. " ) ;
if_info - > saved = FALSE ;
2006-10-30 06:34:31 +00:00
airpcap_if_close ( ad ) ;
2007-01-24 01:17:48 +00:00
return ;
}
if_info - > saved = TRUE ;
airpcap_if_close ( ad ) ;
}
2006-10-30 06:34:31 +00:00
else
2007-01-24 01:17:48 +00:00
{
simple_dialog ( ESD_TYPE_ERROR , ESD_BTN_OK , " Error in opening adapter for %s " , if_info - > description ) ;
}
2007-01-11 02:42:34 +00:00
}
2006-10-30 06:34:31 +00:00
}
/*
* Save the configuration for the specified interface
*/
void
airpcap_save_driver_if_configuration ( airpcap_if_info_t * fake_if_info )
{
2007-01-11 02:42:34 +00:00
gchar ebuf [ AIRPCAP_ERRBUF_SIZE ] ;
PAirpcapHandle ad ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
if ( fake_if_info ! = NULL )
{
2006-10-30 06:34:31 +00:00
ad = airpcap_if_open ( fake_if_info - > name , ebuf ) ;
if ( ad )
2007-01-24 01:17:48 +00:00
{
/* Apply decryption settings... */
airpcap_if_set_driver_decryption_state ( ad , fake_if_info - > DecryptionOn ) ;
airpcap_if_save_driver_keys ( ad , fake_if_info ) ;
airpcap_if_close ( ad ) ;
}
2006-10-30 06:34:31 +00:00
else
2007-01-24 01:17:48 +00:00
{
simple_dialog ( ESD_TYPE_ERROR , ESD_BTN_OK , " Error in opening adapter for %s " , fake_if_info - > description ) ;
}
2007-01-11 02:42:34 +00:00
}
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
return ;
2006-08-16 18:01:25 +00:00
}
2006-10-19 00:48:03 +00:00
/*
* DECRYPTION KEYS FUNCTIONS
*/
/*
* This function is used for DEBUG POURPOSES ONLY ! ! !
*/
void
print_key_list ( GList * key_list )
{
2007-01-11 02:42:34 +00:00
gint n , i ;
decryption_key_t * tmp ;
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
if ( key_list = = NULL )
{
2007-01-24 01:17:48 +00:00
g_print ( " \n \n ******* KEY LIST NULL ******* \n \n " ) ;
return ;
2007-01-11 02:42:34 +00:00
}
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
n = g_list_length ( key_list ) ;
2006-10-26 21:53:30 +00:00
2007-01-11 02:42:34 +00:00
g_print ( " \n \n ********* KEY LIST ********** \n \n " ) ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
g_print ( " NUMBER OF KEYS IN LIST : %d \n \n " , n ) ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
for ( i = 0 ; i < n ; i + + )
{
2007-01-24 01:17:48 +00:00
g_print ( " [%d] : \n " , i + 1 ) ;
tmp = ( decryption_key_t * ) ( g_list_nth_data ( key_list , i ) ) ;
g_print ( " KEY : %s \n " , tmp - > key - > str ) ;
g_print ( " BITS: %d \n " , tmp - > bits ) ;
if ( tmp - > type = = AIRPDCAP_KEY_TYPE_WEP )
g_print ( " TYPE: %s \n " , AIRPCAP_WEP_KEY_STRING ) ;
else if ( tmp - > type = = AIRPDCAP_KEY_TYPE_WPA_PWD )
g_print ( " TYPE: %s \n " , AIRPCAP_WPA_PWD_KEY_STRING ) ;
else if ( tmp - > type = = AIRPDCAP_KEY_TYPE_WPA_PMK )
g_print ( " TYPE: %s \n " , AIRPCAP_WPA_BIN_KEY_STRING ) ;
else
g_print ( " TYPE: %s \n " , " ??? " ) ;
2006-10-30 06:34:31 +00:00
2007-01-24 01:17:48 +00:00
g_print ( " SSID: %s \n " , ( tmp - > ssid ! = NULL ) ?
format_text ( ( guchar * ) tmp - > ssid - > data , tmp - > ssid - > len ) : " --- " ) ;
g_print ( " \n " ) ;
2007-01-11 02:42:34 +00:00
}
2006-10-26 21:53:30 +00:00
2007-01-11 02:42:34 +00:00
g_print ( " \n ***************************** \n \n " ) ;
2006-10-19 00:48:03 +00:00
}
/*
* Retrieves a GList of decryption_key_t structures containing infos about the
* keys for the given adapter . . . returns NULL if no keys are found .
*/
GList *
get_airpcap_device_keys ( airpcap_if_info_t * info_if )
{
2007-01-11 02:42:34 +00:00
/* tmp vars */
char * tmp_key = NULL ;
guint i , keys_in_list = 0 ;
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
/* real vars*/
decryption_key_t * new_key = NULL ;
GList * key_list = NULL ;
2006-10-26 21:53:30 +00:00
2007-01-11 02:42:34 +00:00
/* Number of keys in key list */
if ( info_if - > keysCollectionSize ! = 0 )
keys_in_list = ( guint ) ( info_if - > keysCollectionSize - sizeof ( AirpcapKeysCollection ) ) / sizeof ( AirpcapKey ) ;
else
keys_in_list = 0 ;
2006-10-26 21:53:30 +00:00
2007-01-11 02:42:34 +00:00
for ( i = 0 ; i < keys_in_list ; i + + )
2006-10-30 06:34:31 +00:00
{
2007-01-24 01:17:48 +00:00
/* Different things to do depending on the key type */
if ( info_if - > keysCollection - > Keys [ i ] . KeyType = = AIRPDCAP_KEY_TYPE_WEP )
2007-01-11 02:42:34 +00:00
{
2007-01-24 01:17:48 +00:00
/* allocate memory for the new key item */
new_key = ( decryption_key_t * ) g_malloc ( sizeof ( decryption_key_t ) ) ;
2006-10-26 21:53:30 +00:00
2007-01-24 01:17:48 +00:00
/* fill the fields */
/* KEY */
tmp_key = airpcap_get_key_string ( info_if - > keysCollection - > Keys [ i ] ) ;
new_key - > key = g_string_new ( tmp_key ) ;
g_free ( tmp_key ) ;
2006-10-26 21:53:30 +00:00
2007-01-24 01:17:48 +00:00
/* BITS */
new_key - > bits = new_key - > key - > len * 4 ; /* every char is 4 bits in WEP keys (it is an exadecimal number) */
2006-10-26 21:53:30 +00:00
2007-01-24 01:17:48 +00:00
/* SSID not used in WEP keys */
new_key - > ssid = NULL ;
2006-10-26 21:53:30 +00:00
2007-01-24 01:17:48 +00:00
/* TYPE (WEP in this case) */
new_key - > type = info_if - > keysCollection - > Keys [ i ] . KeyType ;
2006-10-26 21:53:30 +00:00
2007-01-24 01:17:48 +00:00
/* Append the new element in the list */
key_list = g_list_append ( key_list , ( gpointer ) new_key ) ;
2007-01-11 02:42:34 +00:00
}
2007-01-24 01:17:48 +00:00
else if ( info_if - > keysCollection - > Keys [ i ] . KeyType = = AIRPDCAP_KEY_TYPE_WPA_PWD )
2007-01-11 02:42:34 +00:00
{
2007-01-24 01:17:48 +00:00
/* XXX - Not supported yet */
2007-01-11 02:42:34 +00:00
}
2007-01-24 01:17:48 +00:00
else if ( info_if - > keysCollection - > Keys [ i ] . KeyType = = AIRPDCAP_KEY_TYPE_WPA_PMK )
2007-01-11 02:42:34 +00:00
{
2007-01-24 01:17:48 +00:00
/* XXX - Not supported yet */
2007-01-11 02:42:34 +00:00
}
2006-10-30 06:34:31 +00:00
}
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
return key_list ;
2006-10-19 00:48:03 +00:00
}
/*
2006-10-30 06:34:31 +00:00
* Retrieves a GList of decryption_key_t structures containing infos about the
* keys for the global AirPcap driver . . . returns NULL if no keys are found .
2006-10-19 00:48:03 +00:00
*/
GList *
2006-10-30 06:34:31 +00:00
get_airpcap_driver_keys ( )
2006-10-19 00:48:03 +00:00
{
2007-01-11 02:42:34 +00:00
/* tmp vars */
char * tmp_key = NULL ;
guint i , keys_in_list = 0 ;
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
/* real vars*/
decryption_key_t * new_key = NULL ;
GList * key_list = NULL ;
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
/*
* To read the drivers general settings we need to create and use one airpcap adapter . . .
* The only way to do that is to instantiate a fake adapter , and then close it and delete it .
*/
airpcap_if_info_t * fake_info_if = NULL ;
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
/* Create the fake_info_if from the first adapter of the list */
fake_info_if = airpcap_driver_fake_if_info_new ( ) ;
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
if ( fake_info_if = = NULL )
2007-01-24 01:17:48 +00:00
return NULL ;
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
/* Number of keys in key list */
if ( fake_info_if - > keysCollectionSize ! = 0 )
keys_in_list = ( guint ) ( fake_info_if - > keysCollectionSize - sizeof ( AirpcapKeysCollection ) ) / sizeof ( AirpcapKey ) ;
else
keys_in_list = 0 ;
2006-10-26 21:53:30 +00:00
2007-01-11 02:42:34 +00:00
for ( i = 0 ; i < keys_in_list ; i + + )
2006-10-30 06:34:31 +00:00
{
2007-01-24 01:17:48 +00:00
/* Different things to do depending on the key type */
if ( fake_info_if - > keysCollection - > Keys [ i ] . KeyType = = AIRPDCAP_KEY_TYPE_WEP )
2007-01-11 02:42:34 +00:00
{
2007-01-24 01:17:48 +00:00
/* allocate memory for the new key item */
new_key = ( decryption_key_t * ) g_malloc ( sizeof ( decryption_key_t ) ) ;
2006-10-26 21:53:30 +00:00
2007-01-24 01:17:48 +00:00
/* fill the fields */
/* KEY */
tmp_key = airpcap_get_key_string ( fake_info_if - > keysCollection - > Keys [ i ] ) ;
new_key - > key = g_string_new ( tmp_key ) ;
if ( tmp_key ! = NULL ) g_free ( tmp_key ) ;
2006-10-30 06:34:31 +00:00
2007-01-24 01:17:48 +00:00
/* BITS */
new_key - > bits = new_key - > key - > len * 4 ; /* every char is 4 bits in WEP keys (it is an exadecimal number) */
2006-10-30 06:34:31 +00:00
2007-01-24 01:17:48 +00:00
/* SSID not used in WEP keys */
new_key - > ssid = NULL ;
2006-10-30 06:34:31 +00:00
2007-01-24 01:17:48 +00:00
/* TYPE (WEP in this case) */
new_key - > type = fake_info_if - > keysCollection - > Keys [ i ] . KeyType ;
2006-10-26 21:53:30 +00:00
2007-01-24 01:17:48 +00:00
/* Append the new element in the list */
key_list = g_list_append ( key_list , ( gpointer ) new_key ) ;
2007-01-11 02:42:34 +00:00
}
2007-01-24 01:17:48 +00:00
else if ( fake_info_if - > keysCollection - > Keys [ i ] . KeyType = = AIRPDCAP_KEY_TYPE_WPA_PWD )
2007-01-11 02:42:34 +00:00
{
2007-01-24 01:17:48 +00:00
/* XXX - Not supported yet */
2007-01-11 02:42:34 +00:00
}
2007-01-24 01:17:48 +00:00
else if ( fake_info_if - > keysCollection - > Keys [ i ] . KeyType = = AIRPDCAP_KEY_TYPE_WPA_PMK )
2007-01-11 02:42:34 +00:00
{
2007-01-24 01:17:48 +00:00
/* XXX - Not supported yet */
2007-01-11 02:42:34 +00:00
}
2006-10-30 06:34:31 +00:00
}
2006-10-26 21:53:30 +00:00
2007-01-11 02:42:34 +00:00
airpcap_if_info_free ( fake_info_if ) ;
2006-10-26 21:53:30 +00:00
2007-01-11 02:42:34 +00:00
return key_list ;
2006-10-30 06:34:31 +00:00
}
/*
* Returns the list of the decryption keys specified for wireshark , NULL if
* no key is found
*/
GList *
get_wireshark_keys ( )
{
2007-01-11 02:42:34 +00:00
keys_cb_data_t * wep_user_data = NULL ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
gchar * tmp = NULL ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
GList * final_list = NULL ;
GList * wep_final_list = NULL ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
/* Retrieve the wlan preferences */
wlan_prefs = prefs_find_module ( " wlan " ) ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
/* Allocate a structure used to keep infos between the callbacks */
wep_user_data = ( keys_cb_data_t * ) g_malloc ( sizeof ( keys_cb_data_t ) ) ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
/* Fill the structure */
wep_user_data - > list = NULL ;
wep_user_data - > current_index = 0 ;
wep_user_data - > number_of_keys = 0 ; /* Still unknown */
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
/* Run the callback on each 802.11 preference */
/* XXX - Right now, only WEP keys will be loaded */
prefs_pref_foreach ( wlan_prefs , get_wep_key , ( gpointer ) wep_user_data ) ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
/* Copy the list field in the user data structure pointer into the final_list */
if ( wep_user_data ! = NULL ) wep_final_list = wep_user_data - > list ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
/* XXX - Merge the three lists!!!!! */
final_list = wep_final_list ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
/* free the wep_user_data structure */
g_free ( wep_user_data ) ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
return final_list ;
2006-10-19 00:48:03 +00:00
}
/*
2006-10-26 21:53:30 +00:00
* Merges two lists of keys and return a newly created GList . If a key is
2006-10-19 00:48:03 +00:00
* found multiple times , it will just appear once !
2006-10-26 21:53:30 +00:00
* list1 and list 2 pointer will have to be freed manually if needed ! ! !
* If the total number of keys exceeeds the maximum number allowed ,
2006-10-19 00:48:03 +00:00
* exceeding keys will be discarded . . .
*/
GList *
merge_key_list ( GList * list1 , GList * list2 )
{
2007-01-11 02:42:34 +00:00
guint n1 = 0 , n2 = 0 ;
guint i ;
decryption_key_t * dk1 = NULL ,
2007-01-24 01:17:48 +00:00
* dk2 = NULL ,
* new_dk = NULL ;
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
GList * merged_list = NULL ;
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
if ( ( list1 = = NULL ) & & ( list2 = = NULL ) )
return NULL ;
2006-10-26 21:53:30 +00:00
2007-01-11 02:42:34 +00:00
if ( list1 = = NULL )
2006-10-30 06:34:31 +00:00
{
2007-01-11 02:42:34 +00:00
n1 = 0 ;
n2 = g_list_length ( list2 ) ;
2006-10-26 21:53:30 +00:00
2007-01-11 02:42:34 +00:00
for ( i = 0 ; i < n2 ; i + + )
{
new_dk = ( decryption_key_t * ) g_malloc ( sizeof ( decryption_key_t ) ) ;
dk2 = ( decryption_key_t * ) g_list_nth_data ( list2 , i ) ;
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
new_dk - > bits = dk2 - > bits ;
new_dk - > type = dk2 - > type ;
new_dk - > key = g_string_new ( dk2 - > key - > str ) ;
new_dk - > ssid = byte_array_dup ( dk2 - > ssid ) ;
2006-10-26 21:53:30 +00:00
2007-01-11 02:42:34 +00:00
/* Check the total length of the merged list */
if ( g_list_length ( merged_list ) < MAX_ENCRYPTION_KEYS )
merged_list = g_list_append ( merged_list , ( gpointer ) new_dk ) ;
}
2006-10-30 06:34:31 +00:00
}
2007-01-11 02:42:34 +00:00
else if ( list2 = = NULL )
2006-10-30 06:34:31 +00:00
{
2007-01-11 02:42:34 +00:00
n1 = g_list_length ( list1 ) ;
n2 = 0 ;
2006-10-26 21:53:30 +00:00
2007-01-11 02:42:34 +00:00
for ( i = 0 ; i < n1 ; i + + )
{
new_dk = ( decryption_key_t * ) g_malloc ( sizeof ( decryption_key_t ) ) ;
dk1 = ( decryption_key_t * ) g_list_nth_data ( list1 , i ) ;
2006-10-26 21:53:30 +00:00
2007-01-11 02:42:34 +00:00
new_dk - > bits = dk1 - > bits ;
new_dk - > type = dk1 - > type ;
new_dk - > key = g_string_new ( dk1 - > key - > str ) ;
new_dk - > ssid = byte_array_dup ( dk1 - > ssid ) ;
2006-10-26 21:53:30 +00:00
2007-01-11 02:42:34 +00:00
/* Check the total length of the merged list */
if ( g_list_length ( merged_list ) < MAX_ENCRYPTION_KEYS )
2007-01-24 01:17:48 +00:00
merged_list = g_list_append ( merged_list , ( gpointer ) new_dk ) ;
2007-01-11 02:42:34 +00:00
}
}
2006-10-30 06:34:31 +00:00
else
2007-01-11 02:42:34 +00:00
{
n1 = g_list_length ( list1 ) ;
n2 = g_list_length ( list2 ) ;
/* Copy the whole list1 into merged_list */
for ( i = 0 ; i < n1 ; i + + )
{
new_dk = ( decryption_key_t * ) g_malloc ( sizeof ( decryption_key_t ) ) ;
dk1 = ( decryption_key_t * ) g_list_nth_data ( list1 , i ) ;
2006-10-26 21:53:30 +00:00
2007-01-11 02:42:34 +00:00
new_dk - > bits = dk1 - > bits ;
new_dk - > type = dk1 - > type ;
new_dk - > key = g_string_new ( dk1 - > key - > str ) ;
2007-01-11 07:56:37 +00:00
new_dk - > ssid = byte_array_dup ( dk1 - > ssid ) ;
2007-01-11 02:42:34 +00:00
/* Check the total length of the merged list */
if ( g_list_length ( merged_list ) < MAX_ENCRYPTION_KEYS )
2006-10-30 06:34:31 +00:00
merged_list = g_list_append ( merged_list , ( gpointer ) new_dk ) ;
2007-01-11 02:42:34 +00:00
}
2006-10-26 21:53:30 +00:00
2007-01-11 02:42:34 +00:00
/* Look for keys that are present in list2 but aren't in list1 yet...
* Add them to merged_list
*/
for ( i = 0 ; i < n2 ; i + + )
{
dk2 = ( decryption_key_t * ) g_list_nth_data ( list2 , i ) ;
if ( ! key_is_in_list ( dk2 , merged_list ) )
{
new_dk = ( decryption_key_t * ) g_malloc ( sizeof ( decryption_key_t ) ) ;
new_dk - > bits = dk2 - > bits ;
new_dk - > type = dk2 - > type ;
new_dk - > key = g_string_new ( dk2 - > key - > str ) ;
new_dk - > ssid = byte_array_dup ( dk2 - > ssid ) ;
/* Check the total length of the merged list */
if ( g_list_length ( merged_list ) < MAX_ENCRYPTION_KEYS )
2007-01-24 01:17:48 +00:00
merged_list = g_list_append ( merged_list , ( gpointer ) new_dk ) ;
2007-01-11 02:42:34 +00:00
}
}
2006-10-30 06:34:31 +00:00
}
2006-10-26 21:53:30 +00:00
2007-01-11 02:42:34 +00:00
return merged_list ;
2006-10-19 00:48:03 +00:00
}
/*
2006-10-26 21:53:30 +00:00
* Use this function to free a key list .
2006-10-19 00:48:03 +00:00
*/
void
free_key_list ( GList * list )
{
2007-01-11 02:42:34 +00:00
guint i , n ;
decryption_key_t * curr_key ;
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
if ( list = = NULL )
return ;
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
n = g_list_length ( list ) ;
2006-10-26 21:53:30 +00:00
2007-01-11 02:42:34 +00:00
for ( i = 0 ; i < n ; i + + )
{
curr_key = ( decryption_key_t * ) g_list_nth_data ( list , i ) ;
2006-10-26 21:53:30 +00:00
2007-01-11 02:42:34 +00:00
/* Free all the strings */
if ( curr_key - > key ! = NULL )
g_string_free ( curr_key - > key , TRUE ) ;
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
if ( curr_key - > ssid ! = NULL )
g_byte_array_free ( curr_key - > ssid , TRUE ) ;
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
/* free the decryption_key_t structure*/
g_free ( curr_key ) ;
curr_key = NULL ;
}
2006-10-26 21:53:30 +00:00
2007-01-11 02:42:34 +00:00
/* Free the list */
g_list_free ( list ) ;
2006-10-26 21:53:30 +00:00
2007-01-11 02:42:34 +00:00
return ;
2006-10-19 00:48:03 +00:00
}
/*
* If the given key is contained in the list , returns TRUE .
2006-10-26 21:53:30 +00:00
* Returns FALSE otherwise .
2006-10-19 00:48:03 +00:00
*/
gboolean
key_is_in_list ( decryption_key_t * dk , GList * list )
{
2007-01-11 02:42:34 +00:00
guint i , n ;
decryption_key_t * curr_key = NULL ;
gboolean found = FALSE ;
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
if ( ( list = = NULL ) | | ( dk = = NULL ) )
return FALSE ;
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
n = g_list_length ( list ) ;
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
if ( n < 1 )
return FALSE ;
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
for ( i = 0 ; i < n ; i + + )
{
2007-01-24 01:17:48 +00:00
curr_key = ( decryption_key_t * ) g_list_nth_data ( list , i ) ;
if ( keys_are_equals ( dk , curr_key ) )
found = TRUE ;
2007-01-11 02:42:34 +00:00
}
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
return found ;
2006-10-19 00:48:03 +00:00
}
/*
* Returns TRUE if keys are equals , FALSE otherwise
*/
gboolean
keys_are_equals ( decryption_key_t * k1 , decryption_key_t * k2 )
{
2007-01-11 02:42:34 +00:00
if ( ( k1 = = NULL ) | | ( k2 = = NULL ) )
return FALSE ;
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
/* XXX - Remove this check when we will have the WPA/WPA2 decryption in the Driver! */
2007-02-19 21:45:27 +00:00
/** //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) ) **/
/** // return TRUE; **/
2006-12-05 19:24:25 +00:00
2007-01-11 02:42:34 +00:00
if ( g_string_equal ( k1 - > key , k2 - > key ) & &
( k1 - > bits = = k2 - > bits ) & & /* If the previous is TRUE, this must be TRUE as well */
k1 - > type = = k2 - > type )
2006-10-30 06:34:31 +00:00
{
2007-01-11 02:42:34 +00:00
/* Check the ssid... if the key type is WEP, the two fields should be NULL */
if ( ( k1 - > ssid = = NULL ) & & ( k2 - > ssid = = NULL ) )
return TRUE ;
2006-10-26 21:53:30 +00:00
2007-01-11 02:42:34 +00:00
/* If they are not null, they must share the same ssid */
return byte_array_equal ( k1 - > ssid , k2 - > ssid ) ;
2006-10-30 06:34:31 +00:00
}
2007-01-11 02:42:34 +00:00
/* Some field is not equal ... */
return FALSE ;
2006-10-19 00:48:03 +00:00
}
/*
* Tests if two collection of keys are equal or not , to be considered equals , they have to
* contain the same keys in the SAME ORDER ! ( If both lists are NULL , which means empty will
* return TRUE )
*/
gboolean
key_lists_are_equal ( GList * list1 , GList * list2 )
{
2007-01-11 02:42:34 +00:00
guint n1 = 0 , n2 = 0 ;
/* XXX - Remove */
guint wep_n1 = 0 , wep_n2 = 0 ;
GList * wep_list1 = NULL ;
GList * wep_list2 = NULL ;
/* XXX - END*/
guint i /*,j*/ ;
decryption_key_t * dk1 = NULL , * dk2 = NULL ;
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
n1 = g_list_length ( list1 ) ;
n2 = g_list_length ( list2 ) ;
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
/*
* XXX - START : Retrieve the aublists of WEP keys ! ! ! This is needed only ' till Driver WPA decryption
* is not implemented .
*/
for ( i = 0 ; i < n1 ; i + + )
2007-01-24 01:17:48 +00:00
{
dk1 = ( decryption_key_t * ) g_list_nth_data ( list1 , i ) ;
if ( dk1 - > type = = AIRPDCAP_KEY_TYPE_WEP )
{
wep_list1 = g_list_append ( wep_list1 , ( gpointer ) dk1 ) ;
wep_n1 + + ;
}
}
2007-01-11 02:42:34 +00:00
for ( i = 0 ; i < n2 ; i + + )
2007-01-24 01:17:48 +00:00
{
dk2 = ( decryption_key_t * ) g_list_nth_data ( list2 , i ) ;
if ( dk2 - > type = = AIRPDCAP_KEY_TYPE_WEP )
{
wep_list2 = g_list_append ( wep_list2 , ( gpointer ) dk2 ) ;
wep_n2 + + ;
}
}
2006-12-05 19:24:25 +00:00
2007-01-11 02:42:34 +00:00
/*
* XXX - END : Remove from START to END when the WPA / WPA2 decryption will be implemented in
* the Driver
*/
2006-12-05 19:24:25 +00:00
2007-01-11 02:42:34 +00:00
/*
* Commented , because in the new AirPcap version all the keys will be saved
* into the driver , and all the keys for every specific adapter will be
* removed . This means that this check will always fail . . . and the user will
* always be asked what to do . . . and it doesn ' t make much sense .
*/
/* if(n1 != n2) return FALSE; */
if ( wep_n1 ! = wep_n2 ) return FALSE ;
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
n1 = wep_n1 ;
n2 = wep_n2 ;
2006-12-05 19:24:25 +00:00
2007-01-11 02:42:34 +00:00
/*for(i=0;i<n1;i++)
{
dk1 = ( decryption_key_t * ) g_list_nth_data ( list1 , i ) ;
dk2 = ( decryption_key_t * ) g_list_nth_data ( list2 , i ) ;
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
if ( ! g_string_equal ( dk1 - > key , dk2 - > key ) ) return FALSE ;
} */
for ( i = 0 ; i < n2 ; i + + )
{
2007-01-24 01:17:48 +00:00
dk2 = ( decryption_key_t * ) g_list_nth_data ( wep_list2 , i ) ;
if ( ! key_is_in_list ( dk2 , wep_list1 ) ) return FALSE ;
2007-01-11 02:42:34 +00:00
}
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
return TRUE ;
2006-10-19 00:48:03 +00:00
}
static guint
test_if_on ( pref_t * pref , gpointer ud _U_ )
{
2007-01-11 02:42:34 +00:00
gboolean * is_on ;
gboolean number ;
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
/* Retrieve user data info */
is_on = ( gboolean * ) ud ;
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
if ( g_strncasecmp ( pref - > name , " enable_decryption " , 17 ) = = 0 & & pref - > type = = PREF_BOOL )
2007-01-24 01:17:48 +00:00
{
2007-01-11 02:42:34 +00:00
number = * pref - > varp . boolp ;
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
if ( number ) * is_on = TRUE ;
else * is_on = FALSE ;
2006-10-26 21:53:30 +00:00
2007-01-11 02:42:34 +00:00
return 1 ;
2007-01-24 01:17:48 +00:00
}
2007-01-11 02:42:34 +00:00
return 0 ;
2006-10-19 00:48:03 +00:00
}
/*
* Returns TRUE if the Wireshark decryption is active , false otherwise
*/
gboolean
wireshark_decryption_on ( )
{
2007-01-11 02:42:34 +00:00
gboolean is_on ;
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
/* Retrieve the wlan preferences */
wlan_prefs = prefs_find_module ( " wlan " ) ;
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
/* Run the callback on each 802.11 preference */
prefs_pref_foreach ( wlan_prefs , test_if_on , ( gpointer ) & is_on ) ;
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
return is_on ;
2006-10-19 00:48:03 +00:00
}
/*
2006-10-30 06:34:31 +00:00
* Returns TRUE if the AirPcap decryption for the current adapter is active , false otherwise
2006-10-19 00:48:03 +00:00
*/
gboolean
airpcap_decryption_on ( )
{
2007-01-11 02:42:34 +00:00
gboolean is_on = FALSE ;
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
airpcap_if_info_t * fake_if_info = NULL ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
fake_if_info = airpcap_driver_fake_if_info_new ( ) ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
if ( fake_if_info ! = NULL )
2007-01-24 01:17:48 +00:00
{
if ( fake_if_info - > DecryptionOn = = AIRPCAP_DECRYPTION_ON )
is_on = TRUE ;
else if ( fake_if_info - > DecryptionOn = = AIRPCAP_DECRYPTION_OFF )
is_on = FALSE ;
}
2006-10-26 21:53:30 +00:00
2007-01-11 02:42:34 +00:00
airpcap_if_info_free ( fake_if_info ) ;
2006-10-30 06:34:31 +00:00
2007-01-11 02:42:34 +00:00
return is_on ;
2006-10-30 06:34:31 +00:00
}
/*
* Free an instance of airpcap_if_info_t
*/
void
airpcap_if_info_free ( airpcap_if_info_t * if_info )
{
2007-01-11 02:42:34 +00:00
if ( if_info ! = NULL )
{
2006-10-30 06:34:31 +00:00
if ( if_info - > name ! = NULL )
2007-01-24 01:17:48 +00:00
g_free ( if_info - > name ) ;
2006-10-30 06:34:31 +00:00
if ( if_info - > description ! = NULL )
2007-01-24 01:17:48 +00:00
g_free ( if_info - > description ) ;
2006-10-30 06:34:31 +00:00
if ( if_info - > keysCollection ! = NULL )
2007-01-24 01:17:48 +00:00
{
g_free ( if_info - > keysCollection ) ;
if_info - > keysCollection = NULL ;
}
2006-10-30 06:34:31 +00:00
if ( if_info - > ip_addr ! = NULL )
2007-01-24 01:17:48 +00:00
{
g_slist_free ( if_info - > ip_addr ) ;
if_info - > ip_addr = NULL ;
}
2006-10-30 06:34:31 +00:00
if ( if_info ! = NULL )
2007-01-24 01:17:48 +00:00
{
g_free ( if_info ) ;
if_info = NULL ;
}
2007-01-11 02:42:34 +00:00
}
2006-10-19 00:48:03 +00:00
}
static guint
set_on_off ( pref_t * pref , gpointer ud _U_ )
{
2007-01-11 02:42:34 +00:00
gboolean * is_on ;
gboolean number ;
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
/* Retrieve user data info */
is_on = ( gboolean * ) ud ;
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
if ( g_strncasecmp ( pref - > name , " enable_decryption " , 17 ) = = 0 & & pref - > type = = PREF_BOOL )
2007-01-24 01:17:48 +00:00
{
2007-01-11 02:42:34 +00:00
number = * pref - > varp . boolp ;
2006-10-26 21:53:30 +00:00
2007-01-11 02:42:34 +00:00
g_free ( ( void * ) * pref - > varp . boolp ) ;
if ( * is_on )
* pref - > varp . boolp = TRUE ;
else
* pref - > varp . boolp = FALSE ;
2006-10-26 21:53:30 +00:00
2007-01-11 02:42:34 +00:00
return 1 ;
2007-01-24 01:17:48 +00:00
}
2007-01-11 02:42:34 +00:00
return 0 ;
2006-10-19 00:48:03 +00:00
}
/*
* Enables decryption for Wireshark if on_off is TRUE , disables it otherwise .
*/
void
set_wireshark_decryption ( gboolean on_off )
{
2007-01-11 02:42:34 +00:00
gboolean is_on ;
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
is_on = on_off ;
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
/* Retrieve the wlan preferences */
wlan_prefs = prefs_find_module ( " wlan " ) ;
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
/* Run the callback on each 802.11 preference */
prefs_pref_foreach ( wlan_prefs , set_on_off , ( gpointer ) & is_on ) ;
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
/*
* Signal that we ' ve changed things , and run the 802.11 dissector ' s
* callback
*/
wlan_prefs - > prefs_changed = TRUE ;
2006-10-19 00:48:03 +00:00
2007-01-11 02:42:34 +00:00
prefs_apply ( wlan_prefs ) ;
2006-10-19 00:48:03 +00:00
}
/*
* Enables decryption for all the adapters if on_off is TRUE , disables it otherwise .
*/
gboolean
set_airpcap_decryption ( gboolean on_off )
{
2007-01-24 01:17:48 +00:00
/* We need to directly access the .dll functions here... */
gchar ebuf [ AIRPCAP_ERRBUF_SIZE ] ;
PAirpcapHandle ad , ad_driver ;
2006-10-19 00:48:03 +00:00
2007-01-24 01:17:48 +00:00
gboolean success = TRUE ;
2006-10-19 00:48:03 +00:00
2007-01-24 01:17:48 +00:00
gint n = 0 ;
gint i = 0 ;
airpcap_if_info_t * curr_if = NULL ;
airpcap_if_info_t * fake_if_info = NULL ;
2006-10-30 06:34:31 +00:00
2007-01-24 01:17:48 +00:00
fake_if_info = airpcap_driver_fake_if_info_new ( ) ;
2006-10-30 06:34:31 +00:00
2007-01-24 01:17:48 +00:00
if ( fake_if_info = = NULL )
/* We apparently don't have any adapters installed.
* This isn ' t a failure , so return TRUE
*/
return TRUE ;
2006-10-30 06:34:31 +00:00
/* Set the driver decryption */
ad_driver = airpcap_if_open ( fake_if_info - > name , ebuf ) ;
2006-11-01 23:22:13 +00:00
if ( ad_driver )
2007-01-24 01:17:48 +00:00
{
if ( on_off )
airpcap_if_set_driver_decryption_state ( ad_driver , AIRPCAP_DECRYPTION_ON ) ;
else
airpcap_if_set_driver_decryption_state ( ad_driver , AIRPCAP_DECRYPTION_OFF ) ;
2006-10-30 06:34:31 +00:00
2007-01-24 01:17:48 +00:00
airpcap_if_close ( ad_driver ) ;
}
2006-10-30 06:34:31 +00:00
airpcap_if_info_free ( fake_if_info ) ;
2006-10-19 00:48:03 +00:00
2006-10-26 21:53:30 +00:00
n = g_list_length ( airpcap_if_list ) ;
2006-10-19 00:48:03 +00:00
2006-10-30 06:34:31 +00:00
/* Set to FALSE the decryption for all the adapters */
2006-10-26 21:53:30 +00:00
/* Apply this change to all the adapters !!! */
for ( i = 0 ; i < n ; i + + )
2007-01-24 01:17:48 +00:00
{
2006-10-26 21:53:30 +00:00
curr_if = ( airpcap_if_info_t * ) g_list_nth_data ( airpcap_if_list , i ) ;
if ( curr_if ! = NULL )
2007-01-24 01:17:48 +00:00
{
2006-10-26 21:53:30 +00:00
ad = airpcap_if_open ( get_airpcap_name_from_description ( airpcap_if_list , curr_if - > description ) , ebuf ) ;
2007-01-24 01:17:48 +00:00
if ( ad )
{
2006-10-30 06:34:31 +00:00
curr_if - > DecryptionOn = ( gboolean ) AIRPCAP_DECRYPTION_OFF ;
2007-01-24 01:17:48 +00:00
airpcap_if_set_decryption_state ( ad , curr_if - > DecryptionOn ) ;
/* Save configuration for the curr_if */
if ( ! airpcap_if_store_cur_config_as_adapter_default ( ad ) )
{
success = FALSE ;
2006-10-26 21:53:30 +00:00
}
2007-01-24 01:17:48 +00:00
airpcap_if_close ( ad ) ;
2006-10-26 21:53:30 +00:00
}
}
2007-01-24 01:17:48 +00:00
}
2006-10-19 00:48:03 +00:00
2006-10-26 21:53:30 +00:00
return success ;
2006-10-19 00:48:03 +00:00
}
2006-10-26 21:53:30 +00:00
/* DYNAMIC LIBRARY LOADER */
2006-08-16 18:01:25 +00:00
/*
2006-10-26 21:53:30 +00:00
* Used to dynamically load the airpcap library in order link it only when
2006-08-16 18:01:25 +00:00
* it ' s present on the system
*/
2006-10-30 06:34:31 +00:00
int load_airpcap ( void )
2006-08-16 18:01:25 +00:00
{
2007-01-24 01:17:48 +00:00
BOOL base_functions = TRUE ;
BOOL new_functions = TRUE ;
if ( ( AirpcapLib = LoadLibrary ( TEXT ( " airpcap.dll " ) ) ) = = NULL )
{
/* Report the error but go on */
return AIRPCAP_DLL_NOT_FOUND ;
}
else
{
if ( ( g_PAirpcapGetLastError = ( AirpcapGetLastErrorHandler ) GetProcAddress ( AirpcapLib , " AirpcapGetLastError " ) ) = = NULL ) base_functions = FALSE ;
if ( ( g_PAirpcapGetDeviceList = ( AirpcapGetDeviceListHandler ) GetProcAddress ( AirpcapLib , " AirpcapGetDeviceList " ) ) = = NULL ) base_functions = FALSE ;
if ( ( g_PAirpcapFreeDeviceList = ( AirpcapFreeDeviceListHandler ) GetProcAddress ( AirpcapLib , " AirpcapFreeDeviceList " ) ) = = NULL ) base_functions = FALSE ;
if ( ( g_PAirpcapOpen = ( AirpcapOpenHandler ) GetProcAddress ( AirpcapLib , " AirpcapOpen " ) ) = = NULL ) base_functions = FALSE ;
if ( ( g_PAirpcapClose = ( AirpcapCloseHandler ) GetProcAddress ( AirpcapLib , " AirpcapClose " ) ) = = NULL ) base_functions = FALSE ;
if ( ( g_PAirpcapGetLinkType = ( AirpcapGetLinkTypeHandler ) GetProcAddress ( AirpcapLib , " AirpcapGetLinkType " ) ) = = NULL ) base_functions = FALSE ;
if ( ( g_PAirpcapSetLinkType = ( AirpcapSetLinkTypeHandler ) GetProcAddress ( AirpcapLib , " AirpcapSetLinkType " ) ) = = NULL ) base_functions = FALSE ;
if ( ( g_PAirpcapSetKernelBuffer = ( AirpcapSetKernelBufferHandler ) GetProcAddress ( AirpcapLib , " AirpcapSetKernelBuffer " ) ) = = NULL ) base_functions = FALSE ;
if ( ( g_PAirpcapSetFilter = ( AirpcapSetFilterHandler ) GetProcAddress ( AirpcapLib , " AirpcapSetFilter " ) ) = = NULL ) base_functions = FALSE ;
if ( ( g_PAirpcapGetMacAddress = ( AirpcapGetMacAddressHandler ) GetProcAddress ( AirpcapLib , " AirpcapGetMacAddress " ) ) = = NULL ) base_functions = FALSE ;
if ( ( g_PAirpcapSetMinToCopy = ( AirpcapSetMinToCopyHandler ) GetProcAddress ( AirpcapLib , " AirpcapSetMinToCopy " ) ) = = NULL ) base_functions = FALSE ;
if ( ( g_PAirpcapGetReadEvent = ( AirpcapGetReadEventHandler ) GetProcAddress ( AirpcapLib , " AirpcapGetReadEvent " ) ) = = NULL ) base_functions = FALSE ;
if ( ( g_PAirpcapRead = ( AirpcapReadHandler ) GetProcAddress ( AirpcapLib , " AirpcapRead " ) ) = = NULL ) base_functions = FALSE ;
if ( ( g_PAirpcapGetStats = ( AirpcapGetStatsHandler ) GetProcAddress ( AirpcapLib , " AirpcapGetStats " ) ) = = NULL ) base_functions = FALSE ;
if ( ( g_PAirpcapTurnLedOn = ( AirpcapTurnLedOnHandler ) GetProcAddress ( AirpcapLib , " AirpcapTurnLedOn " ) ) = = NULL ) base_functions = FALSE ;
if ( ( g_PAirpcapTurnLedOff = ( AirpcapTurnLedOffHandler ) GetProcAddress ( AirpcapLib , " AirpcapTurnLedOff " ) ) = = NULL ) base_functions = FALSE ;
if ( ( g_PAirpcapGetDeviceChannel = ( AirpcapGetDeviceChannelHandler ) GetProcAddress ( AirpcapLib , " AirpcapGetDeviceChannel " ) ) = = NULL ) base_functions = FALSE ;
if ( ( g_PAirpcapSetDeviceChannel = ( AirpcapSetDeviceChannelHandler ) GetProcAddress ( AirpcapLib , " AirpcapSetDeviceChannel " ) ) = = NULL ) base_functions = FALSE ;
if ( ( g_PAirpcapGetFcsPresence = ( AirpcapGetFcsPresenceHandler ) GetProcAddress ( AirpcapLib , " AirpcapGetFcsPresence " ) ) = = NULL ) base_functions = FALSE ;
if ( ( g_PAirpcapSetFcsPresence = ( AirpcapSetFcsPresenceHandler ) GetProcAddress ( AirpcapLib , " AirpcapSetFcsPresence " ) ) = = NULL ) base_functions = FALSE ;
if ( ( g_PAirpcapGetFcsValidation = ( AirpcapGetFcsValidationHandler ) GetProcAddress ( AirpcapLib , " AirpcapGetFcsValidation " ) ) = = NULL ) base_functions = FALSE ;
if ( ( g_PAirpcapSetFcsValidation = ( AirpcapSetFcsValidationHandler ) GetProcAddress ( AirpcapLib , " AirpcapSetFcsValidation " ) ) = = NULL ) base_functions = FALSE ;
if ( ( g_PAirpcapGetDeviceKeys = ( AirpcapGetDeviceKeysHandler ) GetProcAddress ( AirpcapLib , " AirpcapGetDeviceKeys " ) ) = = NULL ) base_functions = FALSE ;
if ( ( g_PAirpcapSetDeviceKeys = ( AirpcapSetDeviceKeysHandler ) GetProcAddress ( AirpcapLib , " AirpcapSetDeviceKeys " ) ) = = NULL ) base_functions = FALSE ;
if ( ( g_PAirpcapGetDecryptionState = ( AirpcapGetDecryptionStateHandler ) GetProcAddress ( AirpcapLib , " AirpcapGetDecryptionState " ) ) = = NULL ) base_functions = FALSE ;
if ( ( g_PAirpcapSetDecryptionState = ( AirpcapSetDecryptionStateHandler ) GetProcAddress ( AirpcapLib , " AirpcapSetDecryptionState " ) ) = = NULL ) base_functions = FALSE ;
if ( ( g_PAirpcapStoreCurConfigAsAdapterDefault = ( AirpcapStoreCurConfigAsAdapterDefaultHandler ) GetProcAddress ( AirpcapLib , " AirpcapStoreCurConfigAsAdapterDefault " ) ) = = NULL ) base_functions = FALSE ;
if ( ( g_PAirpcapGetVersion = ( AirpcapGetVersionHandler ) GetProcAddress ( AirpcapLib , " AirpcapGetVersion " ) ) = = NULL ) base_functions = FALSE ;
/* TEST IF WE CAN FIND AIRPCAP NEW DRIVER FEATURES */
if ( ( g_PAirpcapGetDriverDecryptionState = ( AirpcapGetDriverDecryptionStateHandler ) GetProcAddress ( AirpcapLib , " AirpcapGetDriverDecryptionState " ) ) = = NULL ) new_functions = FALSE ;
if ( ( g_PAirpcapSetDriverDecryptionState = ( AirpcapSetDriverDecryptionStateHandler ) GetProcAddress ( AirpcapLib , " AirpcapSetDriverDecryptionState " ) ) = = NULL ) new_functions = FALSE ;
if ( ( g_PAirpcapGetDriverKeys = ( AirpcapGetDriverKeysHandler ) GetProcAddress ( AirpcapLib , " AirpcapGetDriverKeys " ) ) = = NULL ) new_functions = FALSE ;
if ( ( g_PAirpcapSetDriverKeys = ( AirpcapSetDriverKeysHandler ) GetProcAddress ( AirpcapLib , " AirpcapSetDriverKeys " ) ) = = NULL ) new_functions = FALSE ;
if ( base_functions )
{
if ( new_functions )
{
AirpcapLoaded = TRUE ;
return AIRPCAP_DLL_OK ;
}
else
{
AirpcapLoaded = TRUE ;
return AIRPCAP_DLL_OLD ;
}
}
else
{
AirpcapLoaded = FALSE ;
return AIRPCAP_DLL_ERROR ;
}
}
2006-08-16 18:01:25 +00:00
}
2006-10-19 22:43:38 +00:00
/*
* Append the version of AirPcap with which we were compiled to a GString .
*/
void
get_compiled_airpcap_version ( GString * str )
{
2007-01-24 01:17:48 +00:00
g_string_append ( str , " with AirPcap " ) ;
2006-10-19 22:43:38 +00:00
}
/*
* Append the version of AirPcap with which we we ' re running to a GString .
*/
void
get_runtime_airpcap_version ( GString * str )
{
2007-01-24 01:17:48 +00:00
guint vmaj , vmin , vrev , build ;
2006-10-19 22:43:38 +00:00
2007-01-24 01:17:48 +00:00
/* See if the DLL has been loaded successfully. Bail if it hasn't */
if ( AirpcapLoaded = = FALSE ) {
g_string_append ( str , " without AirPcap " ) ;
return ;
}
2006-10-19 22:43:38 +00:00
2007-01-24 01:17:48 +00:00
g_PAirpcapGetVersion ( & vmaj , & vmin , & vrev , & build ) ;
g_string_sprintfa ( str , " with AirPcap %d.%d.%d build %d " , vmaj , vmin ,
vrev , build ) ;
2006-10-19 22:43:38 +00:00
}
2006-08-16 18:01:25 +00:00
# endif /* _WIN32 */