wifi.cpp

Wince下通过ndisuio使用wifi卡的示例

#include "StdAfx.h"
#include "Windev.h"
#include "Wifi.h"

//-----------------------------[ CAvailableAPList ]------------------------------

wifi::CAvailableAPList::CAvailableAPList(void)
{
    this->Clear();
}

wifi::CAvailableAPList::CAvailableAPList(const LPBYTE lpByte)
{
    this->ParseFrom(lpByte);
}

wifi::CAvailableAPList::CAvailableAPList(const wifi::CAvailableAPList &wlan)
{
    this->m_bssidList.NumberOfItems = wlan.m_bssidList.NumberOfItems;
    this->m_vectBssid = wlan.m_vectBssid;
}

wifi::CAvailableAPList  wifi::CAvailableAPList::operator = (const wifi::CAvailableAPList &wlan)
{
    this->m_bssidList.NumberOfItems = wlan.m_bssidList.NumberOfItems;
    this->m_vectBssid = wlan.m_vectBssid;

    return *this;
}

void            wifi::CAvailableAPList::Clear()
{
    this->m_bssidList.NumberOfItems = 0;
    this->m_vectBssid.clear();
}

BOOL            wifi::CAvailableAPList::ParseFrom(const LPBYTE lpByte)
{
    this->Clear();
    if (lpByte)
    {
        this->m_bssidList.NumberOfItems = *(DWORD*)lpByte;
        int nOffset = LengthOffset;
        for (UINT i = 0; i < this->m_bssidList.NumberOfItems; i++)
        {
            NDIS_WLAN_BSSID bssid;
            if (get_NDIS_WLAN_BSSID(&lpByte[nOffset], &bssid))
            {
                nOffset += bssid.Length;
                this->m_vectBssid.push_back(bssid);
            }
            else break;
        }
    }

    return TRUE;
}

BOOL            wifi::CAvailableAPList::get_NDIS_WLAN_BSSID(const LPBYTE lpByte, PNDIS_WLAN_BSSID pBssid)
{
    BOOL    bRet = TRUE;

    if (lpByte == NULL || pBssid == NULL)
    {
        this->m_strErr.assign(_T("[CAvailableAPList] lpByte is null or pBssid is null."));
        return FALSE;
    }

    pBssid->Length = *(DWORD*)lpByte;
    memcpy(pBssid->MacAddress, &lpByte[MacAddressOffset], 6);
    memcpy(pBssid->Reserved, &lpByte[ReservedOffset], 2);
    pBssid->Ssid.SsidLength = *(DWORD*)&lpByte[SsidOffset];
    memcpy(pBssid->Ssid.Ssid, &lpByte[SsidOffset + 4], 32);
    if (pBssid->Ssid.SsidLength < 32) pBssid->Ssid.Ssid[pBssid->Ssid.SsidLength] = 0;
    pBssid->Privacy = *(DWORD*)&lpByte[PrivacyOffset];
    pBssid->NetworkTypeInUse = (NDIS_802_11_NETWORK_TYPE)*(DWORD*)&lpByte[NetworkTypeInUseOffset];
    if (!this->get_NDIS_802_11_CONFIGURATION(&lpByte[ConfigurationOffset], &pBssid->Configuration))
        return FALSE;
    pBssid->InfrastructureMode = (NDIS_802_11_NETWORK_INFRASTRUCTURE)*(DWORD*)&lpByte[InfrastructureModeOffset];
    memcpy(pBssid->SupportedRates, &lpByte[SupportedRatesOffset], 8);

    return  bRet;
}

BOOL            wifi::CAvailableAPList::get_NDIS_802_11_CONFIGURATION(const LPBYTE lpByte, PNDIS_802_11_CONFIGURATION pConfig)
{
    BOOL    bRet = TRUE;

    if (lpByte == NULL || pConfig == NULL)
    {
        this->m_strErr.assign(_T("[CAvailableAPList] lpByte is null or pConfig is null."));
        return FALSE;
    }

    pConfig->Length = *(DWORD*)lpByte;
    pConfig->BeaconPeriod = *(DWORD*)&lpByte[4];
    pConfig->ATIMWindow = *(DWORD*)&lpByte[8];
    pConfig->DSConfig = *(DWORD*)&lpByte[12];
    bRet = this->get_NDIS_802_11_CONFIGURATION_FH(&lpByte[16], &pConfig->FHConfig);

    return  bRet;
}

BOOL            wifi::CAvailableAPList::get_NDIS_802_11_CONFIGURATION_FH(const LPBYTE lpByte, PNDIS_802_11_CONFIGURATION_FH pConfigFH)
{
    BOOL    bRet = TRUE;

    if (lpByte == NULL || pConfigFH)
    {
        this->m_strErr.assign(_T("[CAvailableAPList] lpByte is null or pConfigFH is null."));
        return FALSE;
    }

    pConfigFH->Length = *(DWORD*)lpByte;
    pConfigFH->HopPattern = *(DWORD*)&lpByte[4];
    pConfigFH->HopSet = *(DWORD*)&lpByte[8];
    pConfigFH->DwellTime = *(DWORD*)&lpByte[12];

    return  bRet;
}

wifi::CAvailableAPList::~CAvailableAPList(void)
{
}

//-------------------------------------------------------------------------------
//-----------------------------[ CPreferredAPList ]------------------------------

wifi::CPreferredAPList::CPreferredAPList(void)
{
    this->Clear();
}

wifi::CPreferredAPList::CPreferredAPList(const LPBYTE lpByte)
{
    this->ParseFrom(lpByte);
}

wifi::CPreferredAPList::CPreferredAPList(const wifi::CPreferredAPList &wlan)
{
    this->m_stSsidList.NumberOfItems = wlan.m_stSsidList.NumberOfItems;
    this->m_vectStSsid = wlan.m_vectStSsid;
}

wifi::CPreferredAPList  wifi::CPreferredAPList::operator = (const wifi::CPreferredAPList &wlan)
{
    this->m_stSsidList.NumberOfItems = wlan.m_stSsidList.NumberOfItems;
    this->m_vectStSsid = wlan.m_vectStSsid;

    return *this;
}

void            wifi::CPreferredAPList::Clear()
{
    this->m_stSsidList.NumberOfItems = 0;
    this->m_vectStSsid.clear();
}

BOOL            wifi::CPreferredAPList::ParseFrom(const LPBYTE lpByte)
{
    this->Clear();
    if (lpByte)
    {
        AfxMessageBox(_T("[ParseFrom] OK-001"));
        this->m_stSsidList.NumberOfItems = *(DWORD*)lpByte;
        AfxMessageBox(_T("[ParseFrom] OK-002"));
        this->m_stSsidList.Index = *(DWORD*)&lpByte[BaseIndexOffset];
        int nOffset = ConfigOffset;
        for (UINT i = 0; i < this->m_stSsidList.NumberOfItems; i++)
        {
            AfxMessageBox(_T("[ParseFrom] OK-002-01"));
            WZC_WLAN_CONFIG wzc;
            if (get_WZC_WLAN_CONFIG(&lpByte[nOffset], &wzc))
            {
                nOffset += wzc.Length;
                this->m_vectStSsid.push_back(wzc);
            }
            else break;
        }
        AfxMessageBox(_T("[ParseFrom] OK-003"));
    }

    return TRUE;
}

BOOL            wifi::CPreferredAPList::get_WZC_WLAN_CONFIG(const LPBYTE lpByte, PWZC_WLAN_CONFIG pConfig)
{
    BOOL    bRet = TRUE;

    if (lpByte == NULL || pConfig == NULL)
    {
        this->m_strErr.assign(_T("[CPreferredAPList] lpByte is null or pConfig is null[%d]."));
        return FALSE;
    }

    AfxMessageBox(_T("[get_WZC_WLAN_CONFIG] OK-001"));
    pConfig->Length = *(DWORD*)lpByte;
    pConfig->dwCtlFlags = *(DWORD*)&lpByte[4];
    memcpy(pConfig->MacAddress, &lpByte[8], 6);
    memcpy(pConfig->Reserved, &lpByte[14], 2);
    pConfig->Ssid.SsidLength = *(DWORD*)&lpByte[16];
    memcpy(pConfig->Ssid.Ssid, &lpByte[20], 32);
    AfxMessageBox(_T("[get_WZC_WLAN_CONFIG] OK-002"));
    UINT nLen = (pConfig->Ssid.SsidLength > 31) ? 31 : pConfig->Ssid.SsidLength; 
    pConfig->Ssid.Ssid[nLen] = 0;
    pConfig->Privacy = *(DWORD*)&lpByte[52];
    pConfig->Rssi = *(DWORD*)&lpByte[56];
    pConfig->NetworkTypeInUse = (NDIS_802_11_NETWORK_TYPE)*(DWORD*)&lpByte[60];
    pConfig->InfrastructureMode = (NDIS_802_11_NETWORK_INFRASTRUCTURE)*(DWORD*)&lpByte[96];
    AfxMessageBox(_T("[get_WZC_WLAN_CONFIG] OK-003"));
    memcpy(pConfig->SupportedRates, &lpByte[100], 8);
    pConfig->KeyIndex = *(DWORD*)&lpByte[108];
    pConfig->KeyLength = *(DWORD*)&lpByte[112];
    memcpy(pConfig->KeyMaterial, &lpByte[116], pConfig->KeyLength);
    pConfig->KeyMaterial[pConfig->KeyLength] = 0;
    pConfig->AuthenticationMode = (NDIS_802_11_AUTHENTICATION_MODE)*(DWORD*)&lpByte[148];
    AfxMessageBox(_T("[get_WZC_WLAN_CONFIG] OK-004"));

    return  bRet;
}

wifi::CPreferredAPList::~CPreferredAPList(void)
{
}

//-------------------------------------------------------------------------------
//-----------------------------[ CWirelessUtil    ]------------------------------

#define NDISUIO_DEVICE_NAME TEXT("UIO1:")

#define STA_MAX_QUALITY     (255)   ///< From wlclient.h
#define STA_MIN_QUALITY     (0)     ///< From wlclient.h

wifi::CWirelessUtil::CWirelessUtil() : m_hNdisUio(NULL), m_bInit(FALSE)
{
}

BOOL            wifi::CWirelessUtil::Init()
{
    ///< Open NDISUIO Device
    if (m_hNdisUio == NULL)
    {
        m_hNdisUio = ::CreateFile(
                               NDISUIO_DEVICE_NAME,                         // Object name.
                               0x00,                                        // Desired access.
                               0x00,                                        // Share Mode.
                               NULL,                                        // Security Attr
                               OPEN_EXISTING,                               // Creation Disposition.
                               FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED,// Flag and Attributes..
                               (HANDLE)INVALID_HANDLE_VALUE);

        if (m_hNdisUio == INVALID_HANDLE_VALUE)
        {
            DWORD   dwErr = GetLastError();
            TCHAR   szErr[100] = _T("");
            _stprintf(szErr, _T("[CWirelessUtil] CreateFile failed, ErrorCode : %d"), dwErr);
            this->m_strErr.assign(szErr);

            return FALSE;
        }
    }

    ///< EnumInterfaces
    DWORD   dwRet = WZCEnumInterfaces(NULL, &m_keyTable);
    if (dwRet != ERROR_SUCCESS)
    {
        DWORD   dwErr = GetLastError();
        TCHAR   szErr[100] = _T("");
        _stprintf(szErr, _T("[CWirelessUtil] WZCEnumInterfaces failed, ErrorCode : %d"), dwErr);
        this->m_strErr.assign(szErr);

        return FALSE;
    }
    if (m_keyTable.dwNumIntfs <= 0)
    {
        this->m_strErr.assign(_T("[CWirelessUtil] There is no wireless NIC interface."));

        return FALSE;
    }
    this->m_bInit = TRUE;

    return TRUE;
}

LPCWSTR         wifi::CWirelessUtil::GetFirstDeviceName()
{
    if (this->m_keyTable.dwNumIntfs > 0)
        return (LPCWSTR)this->m_keyTable.pIntfs[0].wszGuid;

    return  NULL;
}

BOOL            wifi::CWirelessUtil::IsNativeWifiDevice(LPCTSTR ptcDeviceName, INT *piSignalStrength)
{
    NATIVEWIFI_STATISTICS   NwifiStatistics = {0};
    DWORD                   dwBytesWritten = 0;
    BOOL                    fWireless = FALSE;

    NwifiStatistics.ptcDeviceName = (PTCHAR)ptcDeviceName;

    if (DeviceIoControl(
            m_hNdisUio,
            IOCTL_NDISUIO_NATIVEWIFI_STATISTICS,
            NULL,
            0,
            &NwifiStatistics,
            sizeof(NATIVEWIFI_STATISTICS),
            &dwBytesWritten,
            NULL))
    {
        if (NwifiStatistics.PhysicalMediaType == NdisPhysicalMediumNativeWifi && NwifiStatistics.bStationMode)
        {
            DWORD   dwSignalLevel;
            
            fWireless = TRUE;

            RETAILMSG (1, (TEXT("Nwifi Strength = [%d]\r\n"),
                NwifiStatistics.ulRSSI));            

            dwSignalLevel = ((NwifiStatistics.ulRSSI - STA_MIN_QUALITY) * 5 ) / (STA_MAX_QUALITY - STA_MIN_QUALITY);

            if (piSignalStrength)
                *piSignalStrength = MapWirelessSignalStrengthToRSSI(dwSignalLevel);
        }
    }

    return fWireless;