WLAN.h

/*
    SPDX-License-Identifier: MIT
    Copyright © 1991-2022 Amebis
    Copyright © 2016 GÉANT
*/
 
#pragma once
 
#include "Common.h"
#include <wlanapi.h>
#include <string>
 
// Must not statically link to Wlanapi.dll as it is not available on Windows
// without a WLAN interface.
extern DWORD (WINAPI *pfnWlanReasonCodeToString)(__in DWORD dwReasonCode, __in DWORD dwBufferSize, __in_ecount(dwBufferSize) PWCHAR pStringBuffer, __reserved PVOID pReserved);
 
 
template<class _Traits, class _Ax>
static DWORD WlanReasonCodeToString(_In_ DWORD dwReasonCode, _Inout_ std::basic_string<wchar_t, _Traits, _Ax> &sValue, __reserved PVOID pReserved)
{
    DWORD dwSize = 0;
 
    if (!::pfnWlanReasonCodeToString)
        return ERROR_CALL_NOT_IMPLEMENTED;
 
    for (;;) {
        // Increment size and allocate buffer.
        dwSize += 1024;
        std::unique_ptr<wchar_t[]> szBuffer(new wchar_t[dwSize]);
 
        // Try!
        DWORD dwResult = ::pfnWlanReasonCodeToString(dwReasonCode, dwSize, szBuffer.get(), pReserved);
        if (dwResult == ERROR_SUCCESS) {
            DWORD dwLength = (DWORD)wcsnlen(szBuffer.get(), dwSize);
            if (dwLength < dwSize - 1) {
                // Buffer was long enough.
                sValue.assign(szBuffer.get(), dwLength);
                return ERROR_SUCCESS;
            }
        } else {
            // Return error code.
            return dwResult;
        }
    }
}
 
 
namespace winstd
{
 
    template <class _Ty> struct WlanFreeMemory_delete
    {
        typedef WlanFreeMemory_delete<_Ty> _Myt; 
 
        WlanFreeMemory_delete() {}
 
        template <class _Ty2> WlanFreeMemory_delete(const WlanFreeMemory_delete<_Ty2>&) {}
 
        void operator()(_Ty *_Ptr) const
        {
            WlanFreeMemory(_Ptr);
        }
    };
 
    template <class _Ty> struct WlanFreeMemory_delete<_Ty[]>
    {
        typedef WlanFreeMemory_delete<_Ty> _Myt; 
 
        WlanFreeMemory_delete() {}
 
        void operator()(_Ty *_Ptr) const
        {
            WlanFreeMemory(_Ptr);
        }
 
        template<class _Other>
        void operator()(_Other *) const
        {
            WlanFreeMemory(_Ptr);
        }
    };
 
    class wlan_handle : public handle<HANDLE, NULL>
    {
        WINSTD_HANDLE_IMPL(wlan_handle, NULL)
 
    public:
        virtual ~wlan_handle()
        {
            if (m_h != invalid)
                free_internal();
        }
 
        __declspec(deprecated("Use WlanOpenHandle - mind it returns error number rather than SetLastError"))
        bool open(_In_ DWORD dwClientVersion, _Out_ PDWORD pdwNegotiatedVersion) noexcept
        {
            handle_type h;
            const DWORD dwResult = WlanOpenHandle(dwClientVersion, 0, pdwNegotiatedVersion, &h);
            if (dwResult == ERROR_SUCCESS) {
                attach(h);
                return true;
            } else {
                SetLastError(dwResult);
                return false;
            }
        }
 
    protected:
        void free_internal() noexcept override
        {
            WlanCloseHandle(m_h, NULL);
        }
    };
 
}
 
 
#pragma warning(suppress: 4505) // Don't warn on unused code
static DWORD WlanOpenHandle(
    _In_ DWORD dwClientVersion,
    _Reserved_ PVOID pReserved,
    _Out_ PDWORD pdwNegotiatedVersion,
    _Inout_ winstd::wlan_handle &handle)
{
    HANDLE h;
    DWORD dwResult = WlanOpenHandle(dwClientVersion, pReserved, pdwNegotiatedVersion, &h);
    if (dwResult == ERROR_SUCCESS)
        handle.attach(h);
    return dwResult;
}