WLAN.h

/*
    SPDX-License-Identifier: MIT
    Copyright © 1991-2024 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)
{
    SIZE_T sSize = 0;
 
    if (!::pfnWlanReasonCodeToString)
        return ERROR_CALL_NOT_IMPLEMENTED;
 
    for (;;) {
        // Increment size and allocate buffer.
        sSize = SIZETAdd(sSize, 1024);
        if (sSize > DWORD_MAX)
            throw std::runtime_error("Data too big");
        sValue.resize(sSize - 1);
 
        // Try!
        DWORD dwResult = ::pfnWlanReasonCodeToString(dwReasonCode, static_cast<DWORD>(sSize), &sValue[0], pReserved);
        if (dwResult == ERROR_SUCCESS) {
            SIZE_T sLength = wcsnlen(&sValue[0], sSize);
            if (sLength < sSize - 1) {
                // Buffer was long enough.
                sValue.resize(sLength);
                return ERROR_SUCCESS;
            }
        } else {
            // Return error code.
            return dwResult;
        }
    }
}
static DWORD WlanReasonCodeToString(_In_ DWORD dwReasonCode, _Inout_ std::basic_string<wchar_t, _Traits, _Ax> &sValue, __reserved PVOID pReserved) {…}
 
 
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);
        }
        void operator()(_Ty *_Ptr) const {…}
    };
    template <class _Ty> struct WlanFreeMemory_delete {…};
 
    template <class _Ty> struct WlanFreeMemory_delete<_Ty[]>
    {
        typedef WlanFreeMemory_delete<_Ty> _Myt; 
 
        WlanFreeMemory_delete() {}
 
        void operator()(_Ty *_Ptr) const
        {
            WlanFreeMemory(_Ptr);
        }
        void operator()(_Ty *_Ptr) const {…}
 
        template<class _Other>
        void operator()(_Other *) const
        {
            WlanFreeMemory(_Ptr);
        }
        void operator()(_Other *) const {…}
    };
    template <class _Ty> struct WlanFreeMemory_delete<_Ty[]> {…};
 
    class wlan_handle : public handle<HANDLE, NULL>
    {
        WINSTD_HANDLE_IMPL(wlan_handle, HANDLE, NULL)
 
    public:
        virtual ~wlan_handle()
        {
            if (m_h != invalid)
                free_internal();
        }
        virtual ~wlan_handle() {…}
 
    protected:
        void free_internal() noexcept override
        {
            WlanCloseHandle(m_h, NULL);
        }
        void free_internal() noexcept override {…}
    };
    class wlan_handle : public handle<HANDLE, 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;
}
static DWORD WlanOpenHandle( {…}