void wififriend_scan_network(GtkWidget* Widget, gpointer Data)
{
DWORD Error = ERROR_SUCCESS;
PWLAN_AVAILABLE_NETWORK_LIST Network = NULL;
t_wifi St;
int I;
GtkWidget *WinScan = NULL;
GtkWidget *ListOfWifi = NULL;
I = 1;
St = wififriend_create_handle();
St = wififriend_retrieve_config(St);
if((WlanGetAvailableNetworkList(St.MyHandle, &St.MyGuid, 0x00000001, NULL, &Network)) != ERROR_SUCCESS)
error_scan(0);
else
{
WinScan = create_window(236, 27, "Wifi scan");
ListOfWifi = gtk_combo_box_new_text();
while(I != Network->dwNumberOfItems)
{
gtk_combo_box_prepend_text(GTK_COMBO_BOX(ListOfWifi), (const gchar *)Network->Network[I].dot11Ssid.ucSSID);
I++;
}
gtk_combo_box_set_active(GTK_COMBO_BOX(ListOfWifi), 0);
gtk_container_add(GTK_CONTAINER(WinScan), ListOfWifi);
g_signal_connect(G_OBJECT(ListOfWifi), "changed", G_CALLBACK(wififriend_connect_to_unsecure_network), (gpointer)ListOfWifi);
display_interface(WinScan);
WlanCloseHandle(St.MyHandle, NULL);
}
}
bool Wlan::IsNetAvailable( const char * ssid )
{
bool result = false;
if (OpenHandle()) {
PWLAN_INTERFACE_INFO_LIST wlanInterfaces;
if (WlanEnumInterfaces( m_handle, NULL, &wlanInterfaces ) == ERROR_SUCCESS) {
for (int i = 0; i < wlanInterfaces->dwNumberOfItems; i++) {
if (wlanInterfaces->InterfaceInfo[i].isState == wlan_interface_state_connected) {
PWLAN_AVAILABLE_NETWORK_LIST wlanNetworks;
if (WlanGetAvailableNetworkList( m_handle, &wlanInterfaces->InterfaceInfo[i].InterfaceGuid, 0, NULL, &wlanNetworks ) == ERROR_SUCCESS) {
for (int j = 0; j < wlanNetworks->dwNumberOfItems; j++) {
if (_strnicmp( (const char *) wlanNetworks->Network[j].dot11Ssid.ucSSID, ssid, strlen(ssid) ) == 0) {
result = true;
break;
}
}
WlanFreeMemory( wlanNetworks );
}
}
}
WlanFreeMemory( wlanInterfaces );
}
}
return result;
}
/*
* Get the index of the first available network in the list on an interface
*/
DWORD GetIfaceAvailableSSID (HANDLE h,
const GUID *iface,
const wchar_t *ifname,
WLANKEY *keys,
int *index,
WLAN_REASON_CODE *reason){
WLAN_AVAILABLE_NETWORK_LIST *netlist = NULL;
DWORD status;
int i;
int j;
int k;
wchar_t det_ssid[65];
fwprintf (stderr, L"Getting available networks on interface \"%s\"\n", ifname);
status = WlanGetAvailableNetworkList(h, iface, 0, NULL, &netlist);
if (netlist != NULL){
fwprintf (stderr, L"%d networks in NetList\n", netlist->dwNumberOfItems);
for (j = 0; j < netlist->dwNumberOfItems; j++){
for (k = 0; k < netlist->Network[j].dot11Ssid.uSSIDLength; k++){
det_ssid[k] = netlist->Network[j].dot11Ssid.ucSSID[k];
}
det_ssid[k] = 0;
fwprintf (stderr, L"Network %d: SSID=%ls\n", j, det_ssid);
}
for (i = 0; keys[i].ssid[0] != 0; i++){
for (j = 0; j < netlist->dwNumberOfItems; j++){
for (k = 0; k < netlist->Network[j].dot11Ssid.uSSIDLength; k++){
det_ssid[k] = netlist->Network[j].dot11Ssid.ucSSID[k];
}
det_ssid[k] = 0;
if (wcscmp(keys[i].ssid, det_ssid) == 0){
fwprintf (stderr, L"Network %d is in the profile list\n", j);
*index = i;
WlanFreeMemory(netlist);
return status;
}
}
}
fwprintf (stderr, L"No detected networks are in the profile list\n");
WlanFreeMemory(netlist);
} else {
fwprintf (stderr, L"NetList is NULL\n");
}
return status;
}
PLUGIN_EXPORT double Update(void* data)
{
if (g_pInterface == nullptr) return 0;
MeasureData* measure = (MeasureData*)data;
double value = 0;
if (measure->type != UNKNOWN)
{
if (measure->type == LIST)
{
PWLAN_AVAILABLE_NETWORK_LIST pwnl = nullptr;
DWORD dwErr = WlanGetAvailableNetworkList(g_hClient, &g_pInterface->InterfaceGuid, 0, nullptr, &pwnl);
if (ERROR_SUCCESS != dwErr)
{
measure->statusString = L"Error";
}
else
{
// Size of network name can be up to 64 chars, set to 80 to add room for delimiters
measure->statusString.clear();
measure->statusString.reserve(80 * measure->listMax);
UINT printed = 0; // count of how many networks have been printed already
// Check all items in WLAN NETWORK LIST
for (size_t i = 0; i < pwnl->dwNumberOfItems ; ++i)
{
if (printed == measure->listMax) break;
// SSID is in UCHAR, convert to WCHAR
std::wstring ssid = ConvertToWide((LPCSTR)pwnl->Network[i].dot11Ssid.ucSSID, (int)pwnl->Network[i].dot11Ssid.uSSIDLength);
// Prevent duplicates that result from profiles, check using SSID
if (!ssid.empty() && ssid[0] && wcsstr(measure->statusString.c_str(), ssid.c_str()) == nullptr)
{
++printed;
measure->statusString += ssid;
if (measure->listStyle > 0)
{
if (measure->listStyle == 1 || measure->listStyle == 3)
{
// ADD PHY type
measure->statusString += L" @";
measure->statusString += ToString(pwnl->Network[i].dot11PhyTypes[0]);
}
if (measure->listStyle == 2 || measure->listStyle == 3)
{
// ADD cipher and authentication
measure->statusString += L" (";
measure->statusString += ToString(pwnl->Network[i].dot11DefaultCipherAlgorithm);
measure->statusString += L':';
measure->statusString += ToString(pwnl->Network[i].dot11DefaultAuthAlgorithm);
measure->statusString += L')';
}
}
measure->statusString += L'\n';
}
}
WlanFreeMemory(pwnl);
}
}
else if (measure->type == TXRATE)
{
DWORD dwErr = getAdapterAddresses(&g_pAddresses);
if (NO_ERROR != dwErr) {
measure->statusString = L"Error";
value = (double)-1;
}
else
{
PIP_ADAPTER_ADDRESSES pCurrAddresses = g_pAddresses;
value = (double)-1;
while(pCurrAddresses)
{
// Doesn't work - not sure how to compare the 2 GUIDs
// if (pCurrAddresses->NetworkGuid != g_pInterface->InterfaceGuid)
// Ignores the interface index parameter - whoops.
if (IF_TYPE_IEEE80211 != pCurrAddresses->IfType)
{
pCurrAddresses = pCurrAddresses->Next;
continue;
}
value = (double)pCurrAddresses->TransmitLinkSpeed;
break;
}
}
if (g_pAddresses != nullptr)
{
FREE(g_pAddresses);
}
}
else
{
ULONG outsize = 0;
PWLAN_CONNECTION_ATTRIBUTES wlan_cattr = nullptr;
DWORD dwErr = WlanQueryInterface(g_hClient, &g_pInterface->InterfaceGuid, wlan_intf_opcode_current_connection, nullptr, &outsize, (PVOID*)&wlan_cattr, nullptr);
if (ERROR_SUCCESS != dwErr)
{
switch (measure->type)
{
case SSID:
case PHY:
case ENCRYPTION:
case AUTH:
measure->statusString = L"-1";
break;
}
}
else
{
switch (measure->type)
{
// This rate is currently bogus, sadly :-(
// case TXRATE:
// value = (double)wlan_cattr->wlanAssociationAttributes.ulTxRate;
// break;
case QUALITY:
value = (double)wlan_cattr->wlanAssociationAttributes.wlanSignalQuality;
break;
case SSID:
// Need to convert ucSSID to wchar from uchar
measure->statusString = ConvertToWide((LPCSTR)wlan_cattr->wlanAssociationAttributes.dot11Ssid.ucSSID, (int)wlan_cattr->wlanAssociationAttributes.dot11Ssid.uSSIDLength);
// If not connected yet add current status
measure->statusString += ToString(wlan_cattr->isState);
break;
case PHY:
measure->statusString = ToString(wlan_cattr->wlanAssociationAttributes.dot11PhyType);
break;
case ENCRYPTION:
measure->statusString = ToString(wlan_cattr->wlanSecurityAttributes.dot11CipherAlgorithm);
break;
case AUTH:
measure->statusString = ToString(wlan_cattr->wlanSecurityAttributes.dot11AuthAlgorithm);
break;
default: // Invalid type
measure->statusString.clear();
break;
}
WlanFreeMemory(wlan_cattr);
}
}
}
return value;
}
int main(int argc, char *argv[])
{
HANDLE hWlan = NULL;
DWORD dwError = 0;
DWORD dwSupportedVersion = 0;
DWORD dwClientVersion = (IsVistaOrHigher() ? 2 : 1);
GUID guidInterface; ZeroMemory(&guidInterface, sizeof(GUID));
WLAN_INTERFACE_INFO_LIST *wlanInterfaceList = (WLAN_INTERFACE_INFO_LIST*)WlanAllocateMemory(sizeof(WLAN_INTERFACE_INFO_LIST));
ZeroMemory(wlanInterfaceList, sizeof(WLAN_INTERFACE_INFO_LIST));
WLAN_AVAILABLE_NETWORK_LIST *wlanNetworkList = (WLAN_AVAILABLE_NETWORK_LIST*)WlanAllocateMemory(sizeof(WLAN_AVAILABLE_NETWORK_LIST));
ZeroMemory(wlanNetworkList, sizeof(WLAN_AVAILABLE_NETWORK_LIST));
try
{
if(dwError = WlanOpenHandle(dwClientVersion, NULL, &dwSupportedVersion, &hWlan) != ERROR_SUCCESS)
throw("[x] Unable access wireless interface");
if(dwError = WlanEnumInterfaces(hWlan, NULL, &wlanInterfaceList) != ERROR_SUCCESS)
throw("[x] Unable to enum wireless interfaces");
wprintf(L"[!] Found adapter %s\n", wlanInterfaceList->InterfaceInfo[0].strInterfaceDescription);
if(dwError = wlanInterfaceList->InterfaceInfo[0].isState != wlan_interface_state_not_ready)
{
if(wlanInterfaceList->dwNumberOfItems > 1)
{
// TODO: Add processing for multiple wireless cards here
printf("[!] Detected multiple wireless adapters, using default\n");
guidInterface = wlanInterfaceList->InterfaceInfo[0].InterfaceGuid;
}
else
{
guidInterface = wlanInterfaceList->InterfaceInfo[0].InterfaceGuid;
}
}
else
throw("[x] Default wireless adapter disabled");
DWORD dwPrevNotif = 0;
// Scan takes awhile so we need to register a callback
if(dwError = WlanRegisterNotification(hWlan, WLAN_NOTIFICATION_SOURCE_ACM, TRUE,
(WLAN_NOTIFICATION_CALLBACK)WlanNotification, NULL, NULL, &dwPrevNotif) != ERROR_SUCCESS)
throw("[x] Unable to register for notifications");
printf("[i] Scanning for nearby networks...\n");
if(dwError = WlanScan(hWlan, &guidInterface, NULL, NULL, NULL) != ERROR_SUCCESS)
throw("[x] Scan failed, check adapter is enabled");
// Yawn...
while(bWait)
Sleep(100);
// Unregister callback, don't care if it succeeds or not
WlanRegisterNotification(hWlan, WLAN_NOTIFICATION_SOURCE_NONE, TRUE, NULL, NULL, NULL, &dwPrevNotif);
if(dwError = WlanGetAvailableNetworkList(hWlan, &guidInterface, NULL, NULL, &wlanNetworkList) != ERROR_SUCCESS)
throw("[x] Unable to obtain network list");
for(unsigned int i = 0; i < wlanNetworkList->dwNumberOfItems; i++)
{
printf("\nSSID:\t\t\t%s\nSIGNAL:\t\t\t%d%%\n",
wlanNetworkList->Network[i].dot11Ssid.ucSSID,
wlanNetworkList->Network[i].wlanSignalQuality);
printf("SECURITY:\t\t");
switch(wlanNetworkList->Network[i].dot11DefaultAuthAlgorithm)
{
case DOT11_AUTH_ALGO_80211_OPEN:
case DOT11_AUTH_ALGO_80211_SHARED_KEY:
printf("WEP");
break;
case DOT11_AUTH_ALGO_WPA:
case DOT11_AUTH_ALGO_WPA_PSK:
case DOT11_AUTH_ALGO_WPA_NONE:
printf("WPA");
break;
case DOT11_AUTH_ALGO_RSNA:
case DOT11_AUTH_ALGO_RSNA_PSK:
printf("WPA2");
break;
default:
printf("UNKNOWN");
break;
}
printf("\n");
}
}
catch(char *szError)
{
printf("%s (0x%X)\nQuitting...\n", szError);
}
if(wlanNetworkList)
WlanFreeMemory(wlanNetworkList);
if(wlanInterfaceList)
WlanFreeMemory(wlanInterfaceList);
if(hWlan)
WlanCloseHandle(hWlan, NULL);
return dwError;
}
int _tmain(int argc, _TCHAR* argv[])
{
bool first_run=true;
DWORD dwRetVal = 0;
while(1)
{
/*Test per funzione di errore*/
std::map<std::string, int> lMacAddress_TEST;
// Declare and initialize variables.
HANDLE hClient = NULL; //Handle del client utilizzato nella sessione corrente
DWORD dwMaxClient = 2; //E' una costante che va inserita in WlanOpenHandle (1->Win XP SP2/3 | 2->Win Vista/Server 2008)
DWORD dwCurVersion = 0; //Versione della WLAN API attualmente utilizzata da inserire nella WlanOpenHandle
DWORD dwResult = 0;
int iRet = 0;
WCHAR GuidString[39] = {0}; //Conterrà un GUID sottoforma di stringa di caratteri
unsigned int i, j, k;
/* variables used for WlanEnumInterfaces */
PWLAN_INTERFACE_INFO_LIST pIfList = NULL; //Contiene un array di NIC con relative informazioni
PWLAN_INTERFACE_INFO pIfInfo = NULL; //Contiene le informazioni relative ad una NIC (ID, Descrizione, Stato)
PWLAN_AVAILABLE_NETWORK_LIST pBssList = NULL; //Contiene un array di reti con relative informazioni
PWLAN_AVAILABLE_NETWORK pBssEntry = NULL; //Contiene info relative ad una rete raggiungibile (es. SSID, qualità segnale, algoritmo cifratura)
int iRSSI = 0;
dwResult = WlanOpenHandle(dwMaxClient, NULL, &dwCurVersion, &hClient); //Apre una connessione con il server
if (dwResult != ERROR_SUCCESS)
{
wprintf(L"WlanOpenHandle failed with error: %u\n", dwResult);
return 1;
// You can use FormatMessage here to find out why the function failed
}
dwResult = WlanEnumInterfaces(hClient, NULL, &pIfList); //Inserisce in pIfList l'elenco delle NIC abilitate sul pc
if (dwResult != ERROR_SUCCESS)
{
wprintf(L"WlanEnumInterfaces failed with error: %u\n", dwResult);
return 1;
// You can use FormatMessage here to find out why the function failed
}
else
{
wprintf(L"Num Entries: %lu\n", pIfList->dwNumberOfItems); //Numero NIC trovate
wprintf(L"Current Index: %lu\n", pIfList->dwIndex); //Indice NIC corrente
for (i = 0; i < (int) pIfList->dwNumberOfItems; i++)
{
pIfInfo = (WLAN_INTERFACE_INFO *) &pIfList->InterfaceInfo[i]; //pIfInfo punta alla struttura con le informazioni relative alla NIC corrente
wprintf(L" Interface Index[%u]:\t %lu\n", i, i);
iRet = StringFromGUID2(pIfInfo->InterfaceGuid, (LPOLESTR) &GuidString, //Trasforma un GUID in stringa di caratteri
sizeof(GuidString)/sizeof(*GuidString)); //Numero di caratteri massimo per la stringa finale
// For c rather than C++ source code, the above line needs to be
// iRet = StringFromGUID2(&pIfInfo->InterfaceGuid, (LPOLESTR) &GuidString,
// sizeof(GuidString)/sizeof(*GuidString));
if (iRet == 0) //Se StringFromGUID2 fallisce ritorna 0
wprintf(L"StringFromGUID2 failed\n");
else
{ //Altrimenti il numero di caratteri della stringa
wprintf(L" InterfaceGUID[%d]: %ws\n",i, GuidString);
}
wprintf(L" Interface Description[%d]: %ws", i, pIfInfo->strInterfaceDescription);
wprintf(L"\n");
wprintf(L" Interface State[%d]:\t ", i);
switch (pIfInfo->isState)
{
case wlan_interface_state_not_ready:
wprintf(L"Not ready\n");
break;
case wlan_interface_state_connected:
wprintf(L"Connected\n");
break;
case wlan_interface_state_ad_hoc_network_formed:
wprintf(L"First node in a ad hoc network\n");
break;
case wlan_interface_state_disconnecting:
wprintf(L"Disconnecting\n");
break;
case wlan_interface_state_disconnected:
wprintf(L"Not connected\n");
break;
case wlan_interface_state_associating:
wprintf(L"Attempting to associate with a network\n");
break;
case wlan_interface_state_discovering:
wprintf(L"Auto configuration is discovering settings for the network\n");
break;
case wlan_interface_state_authenticating:
wprintf(L"In process of authenticating\n");
break;
default:
wprintf(L"Unknown state %ld\n", pIfInfo->isState);
break;
}
wprintf(L"\n");
//Inserisce in pBssList i dati delle reti disponibili
dwResult = WlanGetAvailableNetworkList(hClient, //Client handle ottenuto all'inizio
&pIfInfo->InterfaceGuid, //Interface GUID
0,
NULL,
&pBssList); //Puntatore alla lista delle entry trovate
if (dwResult != ERROR_SUCCESS)
{
wprintf(L"WlanGetAvailableNetworkList failed with error: %u\n", dwResult);
dwRetVal = 1;
// You can use FormatMessage to find out why the function failed
}
else
{
wprintf(L"WLAN_AVAILABLE_NETWORK_LIST for this interface\n");
wprintf(L" Num Entries: %lu\n\n", pBssList->dwNumberOfItems);
for (j = 0; j < pBssList->dwNumberOfItems; j++)
{
pBssEntry = (WLAN_AVAILABLE_NETWORK *) & pBssList->Network[j]; //pBssEntry punta alla struttura di informazioni relative alla rete corrente
wprintf(L" Profile Name[%u]: %ws\n", j, pBssEntry->strProfileName);
wprintf(L" SSID[%u]:\t\t ", j);
if (pBssEntry->dot11Ssid.uSSIDLength == 0) //Se l'SSID ha lunghezza nulla va a capo
wprintf(L"\n");
else
{
for (k = 0; k < pBssEntry->dot11Ssid.uSSIDLength; k++)
{
wprintf(L"%c", (int) pBssEntry->dot11Ssid.ucSSID[k]); //Scrittura a video dell SSID
}
wprintf(L"\n");
}
//Prova per ottenere il MAC Address-----------------------------------------------
//--------------------------------------------------------------------------------
PWLAN_BSS_LIST pWlanBssList=NULL;
DWORD uscita=0;
DOT11_SSID Dot11Ssid=pBssEntry->dot11Ssid;
WlanGetNetworkBssList(
hClient, //Client inizializzato precedentemente
&(pIfInfo->InterfaceGuid), //Interfaccia sul quale si fanno le misurazioni
&(pBssEntry->dot11Ssid), //Struttura del SSID correntemente analizzato
dot11_BSS_type_infrastructure, //Cerca tra le interfacce di infrastruttura
pBssEntry->bSecurityEnabled, //Security policy dell'interfaccia corrente
NULL, //DEVE ESSERE NULL
&pWlanBssList //Struttura che sarà riempita con info opportune
);
if(uscita==ERROR_SUCCESS)
wprintf(L"\n GOOD Exit status Bss\n");
wprintf(L"\n Number of Bss entries: %u\n", pWlanBssList->dwNumberOfItems);
//for(int z=0; z<(int)pWlanBssList->dwNumberOfItems;z++)
//{
PWLAN_BSS_ENTRY px = (WLAN_BSS_ENTRY *) & pWlanBssList->wlanBssEntries;
std::string sMACAddress = PrintMACaddress(px->dot11Bssid);
//}
//std::cout << sMACAddress;
/*----------------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------------*/
wprintf(L" BSS Network type[%u]:\t ", j);
switch (pBssEntry->dot11BssType)
{
case dot11_BSS_type_infrastructure :
wprintf(L"Infrastructure (%u)\n", pBssEntry->dot11BssType);
break;
case dot11_BSS_type_independent:
wprintf(L"Infrastructure (%u)\n", pBssEntry->dot11BssType);
break;
default:
wprintf(L"Other (%lu)\n", pBssEntry->dot11BssType);
break;
}
wprintf(L" Number of BSSIDs[%u]:\t %u\n", j, pBssEntry->uNumberOfBssids);
wprintf(L" Connectable[%u]:\t ", j);
if (pBssEntry->bNetworkConnectable)
wprintf(L"Yes\n");
else
{
wprintf(L"No\n");
wprintf(L" Not connectable WLAN_REASON_CODE value[%u]:\t %u\n", j, pBssEntry->wlanNotConnectableReason);
}
wprintf(L" Number of PHY types supported[%u]:\t %u\n", j, pBssEntry->uNumberOfPhyTypes);
if (pBssEntry->wlanSignalQuality == 0)
iRSSI = -100;
else if (pBssEntry->wlanSignalQuality == 100)
iRSSI = -50;
else
iRSSI = -100 + (pBssEntry->wlanSignalQuality/2);
wprintf(L" Signal Quality[%u]:\t %u (RSSI: %i dBm)\n", j, pBssEntry->wlanSignalQuality, iRSSI);
//Prova con memorizzazione dei MAC
lMacAddress_TEST.insert(std::make_pair(sMACAddress,iRSSI));
if (first_run==true)
{
luogo.InsertElement(sMACAddress,iRSSI);
}
wprintf(L" Security Enabled[%u]:\t ", j);
if (pBssEntry->bSecurityEnabled)
wprintf(L"Yes\n");
else
wprintf(L"No\n");
wprintf(L" Default AuthAlgorithm[%u]: ", j);
switch (pBssEntry->dot11DefaultAuthAlgorithm)
{
case DOT11_AUTH_ALGO_80211_OPEN:
wprintf(L"802.11 Open (%u)\n", pBssEntry->dot11DefaultAuthAlgorithm);
break;
case DOT11_AUTH_ALGO_80211_SHARED_KEY:
wprintf(L"802.11 Shared (%u)\n", pBssEntry->dot11DefaultAuthAlgorithm);
break;
case DOT11_AUTH_ALGO_WPA:
wprintf(L"WPA (%u)\n", pBssEntry->dot11DefaultAuthAlgorithm);
break;
case DOT11_AUTH_ALGO_WPA_PSK:
wprintf(L"WPA-PSK (%u)\n", pBssEntry->dot11DefaultAuthAlgorithm);
break;
case DOT11_AUTH_ALGO_WPA_NONE:
wprintf(L"WPA-None (%u)\n", pBssEntry->dot11DefaultAuthAlgorithm);
break;
case DOT11_AUTH_ALGO_RSNA:
wprintf(L"RSNA (%u)\n", pBssEntry->dot11DefaultAuthAlgorithm);
break;
case DOT11_AUTH_ALGO_RSNA_PSK:
wprintf(L"RSNA with PSK(%u)\n", pBssEntry->dot11DefaultAuthAlgorithm);
break;
default:
wprintf(L"Other (%lu)\n", pBssEntry->dot11DefaultAuthAlgorithm);
break;
}
wprintf(L" Default CipherAlgorithm[%u]: ", j);
switch (pBssEntry->dot11DefaultCipherAlgorithm)
{
case DOT11_CIPHER_ALGO_NONE:
wprintf(L"None (0x%x)\n", pBssEntry->dot11DefaultCipherAlgorithm);
break;
case DOT11_CIPHER_ALGO_WEP40:
wprintf(L"WEP-40 (0x%x)\n", pBssEntry->dot11DefaultCipherAlgorithm);
break;
case DOT11_CIPHER_ALGO_TKIP:
wprintf(L"TKIP (0x%x)\n", pBssEntry->dot11DefaultCipherAlgorithm);
break;
case DOT11_CIPHER_ALGO_CCMP:
wprintf(L"CCMP (0x%x)\n", pBssEntry->dot11DefaultCipherAlgorithm);
break;
case DOT11_CIPHER_ALGO_WEP104:
wprintf(L"WEP-104 (0x%x)\n", pBssEntry->dot11DefaultCipherAlgorithm);
break;
case DOT11_CIPHER_ALGO_WEP:
wprintf(L"WEP (0x%x)\n", pBssEntry->dot11DefaultCipherAlgorithm);
break;
default:
wprintf(L"Other (0x%x)\n", pBssEntry->dot11DefaultCipherAlgorithm);
break;
}
wprintf(L" Flags[%u]:\t 0x%x", j, pBssEntry->dwFlags);
if (pBssEntry->dwFlags)
{
if (pBssEntry->dwFlags & WLAN_AVAILABLE_NETWORK_CONNECTED)
wprintf(L" - Currently connected");
if (pBssEntry->dwFlags & WLAN_AVAILABLE_NETWORK_HAS_PROFILE)
wprintf(L" - Has profile");
}
wprintf(L"\n");
wprintf(L"\n");
if (pWlanBssList!=NULL)
{
WlanFreeMemory(pWlanBssList); //Libera la zona di memoria preposta alla lista di reti disponibili appena utilizzata
pWlanBssList = NULL;
}
}
}
}
}
if (pBssList != NULL)
{
WlanFreeMemory(pBssList); //Libera la zona di memoria preposta alla lista di reti disponibili appena utilizzata
pBssList = NULL;
}
if (pIfList != NULL)
{
WlanFreeMemory(pIfList); //Libera la zona di memoria preposta alla lista di NIC appena utilizzata
pIfList = NULL;
}
if (first_run==true)
{
first_run=false;
}
else
{
float error;
error=luogo.ErrorValue(lMacAddress_TEST);
wprintf(L"Errore con i dati memorizzati: %f\n\n", error);
}
WlanCloseHandle(hClient, NULL);
system("pause");
}
return dwRetVal;
}
