ndis_events.c

Go to the documentation of this file.

/*
 * ndis_events - Receive NdisMIndicateStatus() events using WMI
 * Copyright (c) 2004-2006, Jouni Malinen <j@w1.fi>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * Alternatively, this software may be distributed under the terms of BSD
 * license.
 *
 * See README and COPYING for more details.
 */

#define _WIN32_WINNT    0x0400

#include "includes.h"

#ifndef COBJMACROS
#define COBJMACROS
#endif /* COBJMACROS */
#include <wbemidl.h>

#include "common.h"


static int wmi_refcnt = 0;
static int wmi_first = 1;

struct ndis_events_data {
        IWbemObjectSink sink;
        IWbemObjectSinkVtbl sink_vtbl;

        IWbemServices *pSvc;
        IWbemLocator *pLoc;

        HANDLE read_pipe, write_pipe, event_avail;
        UINT ref;
        int terminating;
        char *ifname; /* {GUID..} */
        WCHAR *adapter_desc;
};

#define BstrAlloc(x) (x) ? SysAllocString(x) : NULL
#define BstrFree(x) if (x) SysFreeString(x)

/* WBEM / WMI wrapper functions, to perform in-place conversion of WCHARs to
 * BSTRs */
HRESULT STDMETHODCALLTYPE call_IWbemServices_ExecQuery(
        IWbemServices *pSvc, LPCWSTR strQueryLanguage, LPCWSTR strQuery,
        long lFlags, IWbemContext *pCtx, IEnumWbemClassObject **ppEnum)
{
        BSTR bsQueryLanguage, bsQuery;
        HRESULT hr;

        bsQueryLanguage = BstrAlloc(strQueryLanguage);
        bsQuery = BstrAlloc(strQuery);

        hr = IWbemServices_ExecQuery(pSvc, bsQueryLanguage, bsQuery, lFlags,
                                     pCtx, ppEnum);

        BstrFree(bsQueryLanguage);
        BstrFree(bsQuery);

        return hr;
}


HRESULT STDMETHODCALLTYPE call_IWbemServices_ExecNotificationQueryAsync(
        IWbemServices *pSvc, LPCWSTR strQueryLanguage, LPCWSTR strQuery,
        long lFlags, IWbemContext *pCtx, IWbemObjectSink *pResponseHandler)
{
        BSTR bsQueryLanguage, bsQuery;
        HRESULT hr;

        bsQueryLanguage = BstrAlloc(strQueryLanguage);
        bsQuery = BstrAlloc(strQuery);

        hr = IWbemServices_ExecNotificationQueryAsync(pSvc, bsQueryLanguage,
                                                      bsQuery, lFlags, pCtx,
                                                      pResponseHandler);

        BstrFree(bsQueryLanguage);
        BstrFree(bsQuery);

        return hr;
}


HRESULT STDMETHODCALLTYPE call_IWbemLocator_ConnectServer(
        IWbemLocator *pLoc, LPCWSTR strNetworkResource, LPCWSTR strUser,
        LPCWSTR strPassword, LPCWSTR strLocale, long lSecurityFlags,
        LPCWSTR strAuthority, IWbemContext *pCtx, IWbemServices **ppNamespace)
{
        BSTR bsNetworkResource, bsUser, bsPassword, bsLocale, bsAuthority;
        HRESULT hr;

        bsNetworkResource = BstrAlloc(strNetworkResource);
        bsUser = BstrAlloc(strUser);
        bsPassword = BstrAlloc(strPassword);
        bsLocale = BstrAlloc(strLocale);
        bsAuthority = BstrAlloc(strAuthority);

        hr = IWbemLocator_ConnectServer(pLoc, bsNetworkResource, bsUser,
                                        bsPassword, bsLocale, lSecurityFlags,
                                        bsAuthority, pCtx, ppNamespace);

        BstrFree(bsNetworkResource);
        BstrFree(bsUser);
        BstrFree(bsPassword);
        BstrFree(bsLocale);
        BstrFree(bsAuthority);

        return hr;
}


enum event_types { EVENT_CONNECT, EVENT_DISCONNECT, EVENT_MEDIA_SPECIFIC,
                   EVENT_ADAPTER_ARRIVAL, EVENT_ADAPTER_REMOVAL };

static int ndis_events_get_adapter(struct ndis_events_data *events,
                                   const char *ifname, const char *desc);


static int ndis_events_constructor(struct ndis_events_data *events)
{
        events->ref = 1;

        if (!CreatePipe(&events->read_pipe, &events->write_pipe, NULL, 512)) {
                wpa_printf(MSG_ERROR, "CreatePipe() failed: %d",
                           (int) GetLastError());
                return -1;
        }
        events->event_avail = CreateEvent(NULL, TRUE, FALSE, NULL);
        if (events->event_avail == NULL) {
                wpa_printf(MSG_ERROR, "CreateEvent() failed: %d",
                           (int) GetLastError());
                CloseHandle(events->read_pipe);
                CloseHandle(events->write_pipe);
                return -1;
        }

        return 0;
}


static void ndis_events_destructor(struct ndis_events_data *events)
{
        CloseHandle(events->read_pipe);
        CloseHandle(events->write_pipe);
        CloseHandle(events->event_avail);
        IWbemServices_Release(events->pSvc);
        IWbemLocator_Release(events->pLoc);
        if (--wmi_refcnt == 0)
                CoUninitialize();
}


static HRESULT STDMETHODCALLTYPE
ndis_events_query_interface(IWbemObjectSink *this, REFIID riid, void **obj)
{
        *obj = NULL;

        if (IsEqualIID(riid, &IID_IUnknown) ||
            IsEqualIID(riid, &IID_IWbemObjectSink)) {
                *obj = this;
                IWbemObjectSink_AddRef(this);
                return NOERROR;
        }

        return E_NOINTERFACE;
}


static ULONG STDMETHODCALLTYPE ndis_events_add_ref(IWbemObjectSink *this)
{
        struct ndis_events_data *events = (struct ndis_events_data *) this;
        return ++events->ref;
}


static ULONG STDMETHODCALLTYPE ndis_events_release(IWbemObjectSink *this)
{
        struct ndis_events_data *events = (struct ndis_events_data *) this;

        if (--events->ref != 0)
                return events->ref;

        ndis_events_destructor(events);
        wpa_printf(MSG_DEBUG, "ndis_events: terminated");
        os_free(events->adapter_desc);
        os_free(events->ifname);
        os_free(events);
        return 0;
}


static int ndis_events_send_event(struct ndis_events_data *events,
                                  enum event_types type,
                                  char *data, size_t data_len)
{
        char buf[512], *pos, *end;
        int _type;
        DWORD written;

        end = buf + sizeof(buf);
        _type = (int) type;
        os_memcpy(buf, &_type, sizeof(_type));
        pos = buf + sizeof(_type);

        if (data) {
                if (2 + data_len > (size_t) (end - pos)) {
                        wpa_printf(MSG_DEBUG, "Not enough room for send_event "
                                   "data (%d)", data_len);
                        return -1;
                }
                *pos++ = data_len >> 8;
                *pos++ = data_len & 0xff;
                os_memcpy(pos, data, data_len);
                pos += data_len;
        }

        if (WriteFile(events->write_pipe, buf, pos - buf, &written, NULL)) {
                SetEvent(events->event_avail);
                return 0;
        }
        wpa_printf(MSG_INFO, "WriteFile() failed: %d", (int) GetLastError());
        return -1;
}


static void ndis_events_media_connect(struct ndis_events_data *events)
{
        wpa_printf(MSG_DEBUG, "MSNdis_StatusMediaConnect");
        ndis_events_send_event(events, EVENT_CONNECT, NULL, 0);
}


static void ndis_events_media_disconnect(struct ndis_events_data *events)
{
        wpa_printf(MSG_DEBUG, "MSNdis_StatusMediaDisconnect");
        ndis_events_send_event(events, EVENT_DISCONNECT, NULL, 0);
}


static void ndis_events_media_specific(struct ndis_events_data *events,
                                       IWbemClassObject *pObj)
{
        VARIANT vt;
        HRESULT hr;
        LONG lower, upper, k;
        UCHAR ch;
        char *data, *pos;
        size_t data_len;

        wpa_printf(MSG_DEBUG, "MSNdis_StatusMediaSpecificIndication");

        /* This is the StatusBuffer from NdisMIndicateStatus() call */
        hr = IWbemClassObject_Get(pObj, L"NdisStatusMediaSpecificIndication",
                                  0, &vt, NULL, NULL);
        if (FAILED(hr)) {
                wpa_printf(MSG_DEBUG, "Could not get "
                           "NdisStatusMediaSpecificIndication from "
                           "the object?!");
                return;
        }

        SafeArrayGetLBound(V_ARRAY(&vt), 1, &lower);
        SafeArrayGetUBound(V_ARRAY(&vt), 1, &upper);
        data_len = upper - lower + 1;
        data = os_malloc(data_len);
        if (data == NULL) {
                wpa_printf(MSG_DEBUG, "Failed to allocate buffer for event "
                           "data");
                VariantClear(&vt);
                return;
        }

        pos = data;
        for (k = lower; k <= upper; k++) {
                SafeArrayGetElement(V_ARRAY(&vt), &k, &ch);
                *pos++ = ch;
        }
        wpa_hexdump(MSG_DEBUG, "MediaSpecificEvent", (u8 *) data, data_len);

        VariantClear(&vt);

        ndis_events_send_event(events, EVENT_MEDIA_SPECIFIC, data, data_len);

        os_free(data);
}


static void ndis_events_adapter_arrival(struct ndis_events_data *events)
{
        wpa_printf(MSG_DEBUG, "MSNdis_NotifyAdapterArrival");
        ndis_events_send_event(events, EVENT_ADAPTER_ARRIVAL, NULL, 0);
}


static void ndis_events_adapter_removal(struct ndis_events_data *events)
{
        wpa_printf(MSG_DEBUG, "MSNdis_NotifyAdapterRemoval");
        ndis_events_send_event(events, EVENT_ADAPTER_REMOVAL, NULL, 0);
}


static HRESULT STDMETHODCALLTYPE
ndis_events_indicate(IWbemObjectSink *this, long lObjectCount,
                     IWbemClassObject __RPC_FAR *__RPC_FAR *ppObjArray)
{
        struct ndis_events_data *events = (struct ndis_events_data *) this;
        long i;

        if (events->terminating) {
                wpa_printf(MSG_DEBUG, "ndis_events_indicate: Ignore "
                           "indication - terminating");
                return WBEM_NO_ERROR;
        }
        /* wpa_printf(MSG_DEBUG, "Notification received - %d object(s)",
           lObjectCount); */

        for (i = 0; i < lObjectCount; i++) {
                IWbemClassObject *pObj = ppObjArray[i];
                HRESULT hr;
                VARIANT vtClass, vt;

                hr = IWbemClassObject_Get(pObj, L"__CLASS", 0, &vtClass, NULL,
                                          NULL);
                if (FAILED(hr)) {
                        wpa_printf(MSG_DEBUG, "Failed to get __CLASS from "
                                   "event.");
                        break;
                }
                /* wpa_printf(MSG_DEBUG, "CLASS: '%S'", vtClass.bstrVal); */

                hr = IWbemClassObject_Get(pObj, L"InstanceName", 0, &vt, NULL,
                                          NULL);
                if (FAILED(hr)) {
                        wpa_printf(MSG_DEBUG, "Failed to get InstanceName "
                                   "from event.");
                        VariantClear(&vtClass);
                        break;
                }

                if (wcscmp(vtClass.bstrVal,
                           L"MSNdis_NotifyAdapterArrival") == 0) {
                        wpa_printf(MSG_DEBUG, "ndis_events_indicate: Try to "
                                   "update adapter description since it may "
                                   "have changed with new adapter instance");
                        ndis_events_get_adapter(events, events->ifname, NULL);
                }

                if (wcscmp(events->adapter_desc, vt.bstrVal) != 0) {
                        wpa_printf(MSG_DEBUG, "ndis_events_indicate: Ignore "
                                   "indication for foreign adapter: "
                                   "InstanceName: '%S' __CLASS: '%S'",
                                   vt.bstrVal, vtClass.bstrVal);
                        VariantClear(&vtClass);
                        VariantClear(&vt);
                        continue;
                }
                VariantClear(&vt);

                if (wcscmp(vtClass.bstrVal,
                           L"MSNdis_StatusMediaSpecificIndication") == 0) {
                        ndis_events_media_specific(events, pObj);
                } else if (wcscmp(vtClass.bstrVal,
                                  L"MSNdis_StatusMediaConnect") == 0) {
                        ndis_events_media_connect(events);
                } else if (wcscmp(vtClass.bstrVal,
                                  L"MSNdis_StatusMediaDisconnect") == 0) {
                        ndis_events_media_disconnect(events);
                } else if (wcscmp(vtClass.bstrVal,
                                  L"MSNdis_NotifyAdapterArrival") == 0) {
                        ndis_events_adapter_arrival(events);
                } else if (wcscmp(vtClass.bstrVal,
                                  L"MSNdis_NotifyAdapterRemoval") == 0) {
                        ndis_events_adapter_removal(events);
                } else {
                        wpa_printf(MSG_DEBUG, "Unepected event - __CLASS: "
                                   "'%S'", vtClass.bstrVal);
                }

                VariantClear(&vtClass);
        }

        return WBEM_NO_ERROR;
}


static HRESULT STDMETHODCALLTYPE
ndis_events_set_status(IWbemObjectSink *this, long lFlags, HRESULT hResult,
                       BSTR strParam, IWbemClassObject __RPC_FAR *pObjParam)
{
        return WBEM_NO_ERROR;
}


static int notification_query(IWbemObjectSink *pDestSink,
                              IWbemServices *pSvc, const char *class_name)
{
        HRESULT hr;
        WCHAR query[256];

        _snwprintf(query, 256,
                  L"SELECT * FROM %S", class_name);
        wpa_printf(MSG_DEBUG, "ndis_events: WMI: %S", query);
        hr = call_IWbemServices_ExecNotificationQueryAsync(
                pSvc, L"WQL", query, 0, 0, pDestSink);
        if (FAILED(hr)) {
                wpa_printf(MSG_DEBUG, "ExecNotificationQueryAsync for %s "
                           "failed with hresult of 0x%x",
                           class_name, (int) hr);
                return -1;
        }

        return 0;
}


static int register_async_notification(IWbemObjectSink *pDestSink,
                                       IWbemServices *pSvc)
{
        int i;
        const char *class_list[] = {
                "MSNdis_StatusMediaConnect",
                "MSNdis_StatusMediaDisconnect",
                "MSNdis_StatusMediaSpecificIndication",
                "MSNdis_NotifyAdapterArrival",
                "MSNdis_NotifyAdapterRemoval",
                NULL
        };

        for (i = 0; class_list[i]; i++) {
                if (notification_query(pDestSink, pSvc, class_list[i]) < 0)
                        return -1;
        }

        return 0;
}


void ndis_events_deinit(struct ndis_events_data *events)
{
        events->terminating = 1;
        IWbemServices_CancelAsyncCall(events->pSvc, &events->sink);
        IWbemObjectSink_Release(&events->sink);
        /*
         * Rest of deinitialization is done in ndis_events_destructor() once
         * all reference count drops to zero.
         */
}


static int ndis_events_use_desc(struct ndis_events_data *events,
                                const char *desc)
{
        char *tmp, *pos;
        size_t len;

        if (desc == NULL) {
                if (events->adapter_desc == NULL)
                        return -1;
                /* Continue using old description */
                return 0;
        }

        tmp = os_strdup(desc);
        if (tmp == NULL)
                return -1;

        pos = os_strstr(tmp, " (Microsoft's Packet Scheduler)");
        if (pos)
                *pos = '\0';

        len = os_strlen(tmp);
        events->adapter_desc = os_malloc((len + 1) * sizeof(WCHAR));
        if (events->adapter_desc == NULL) {
                os_free(tmp);
                return -1;
        }
        _snwprintf(events->adapter_desc, len + 1, L"%S", tmp);
        os_free(tmp);
        return 0;
}


static int ndis_events_get_adapter(struct ndis_events_data *events,
                                   const char *ifname, const char *desc)
{
        HRESULT hr;
        IWbemServices *pSvc;
#define MAX_QUERY_LEN 256
        WCHAR query[MAX_QUERY_LEN];
        IEnumWbemClassObject *pEnumerator;
        IWbemClassObject *pObj;
        ULONG uReturned;
        VARIANT vt;
        int len, pos;

        /*
         * Try to get adapter descriptor through WMI CIMv2 Win32_NetworkAdapter
         * to have better probability of matching with InstanceName from
         * MSNdis events. If this fails, use the provided description.
         */

        os_free(events->adapter_desc);
        events->adapter_desc = NULL;

        hr = call_IWbemLocator_ConnectServer(
                events->pLoc, L"ROOT\\CIMV2", NULL, NULL, 0, 0, 0, 0, &pSvc);
        if (FAILED(hr)) {
                wpa_printf(MSG_ERROR, "ndis_events: Could not connect to WMI "
                           "server (ROOT\\CIMV2) - error 0x%x", (int) hr);
                return ndis_events_use_desc(events, desc);
        }
        wpa_printf(MSG_DEBUG, "ndis_events: Connected to ROOT\\CIMV2.");

        _snwprintf(query, MAX_QUERY_LEN,
                  L"SELECT Index FROM Win32_NetworkAdapterConfiguration "
                  L"WHERE SettingID='%S'", ifname);
        wpa_printf(MSG_DEBUG, "ndis_events: WMI: %S", query);

        hr = call_IWbemServices_ExecQuery(
                pSvc, L"WQL", query,
                WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
                NULL, &pEnumerator);
        if (!SUCCEEDED(hr)) {
                wpa_printf(MSG_DEBUG, "ndis_events: Failed to query interface "
                           "GUID from Win32_NetworkAdapterConfiguration: "
                           "0x%x", (int) hr);
                IWbemServices_Release(pSvc);
                return ndis_events_use_desc(events, desc);
        }

        uReturned = 0;
        hr = IEnumWbemClassObject_Next(pEnumerator, WBEM_INFINITE, 1,
                                       &pObj, &uReturned);
        if (!SUCCEEDED(hr) || uReturned == 0) {
                wpa_printf(MSG_DEBUG, "ndis_events: Failed to find interface "
                           "GUID from Win32_NetworkAdapterConfiguration: "
                           "0x%x", (int) hr);
                IEnumWbemClassObject_Release(pEnumerator);
                IWbemServices_Release(pSvc);
                return ndis_events_use_desc(events, desc);
        }
        IEnumWbemClassObject_Release(pEnumerator);

        VariantInit(&vt);
        hr = IWbemClassObject_Get(pObj, L"Index", 0, &vt, NULL, NULL);
        if (!SUCCEEDED(hr)) {
                wpa_printf(MSG_DEBUG, "ndis_events: Failed to get Index from "
                           "Win32_NetworkAdapterConfiguration: 0x%x",
                           (int) hr);
                IWbemServices_Release(pSvc);
                return ndis_events_use_desc(events, desc);
        }

        _snwprintf(query, MAX_QUERY_LEN,
                  L"SELECT Name,PNPDeviceID FROM Win32_NetworkAdapter WHERE "
                  L"Index=%d",
                  vt.uintVal);
        wpa_printf(MSG_DEBUG, "ndis_events: WMI: %S", query);
        VariantClear(&vt);
        IWbemClassObject_Release(pObj);

        hr = call_IWbemServices_ExecQuery(
                pSvc, L"WQL", query,
                WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
                NULL, &pEnumerator);
        if (!SUCCEEDED(hr)) {
                wpa_printf(MSG_DEBUG, "ndis_events: Failed to query interface "
                           "from Win32_NetworkAdapter: 0x%x", (int) hr);
                IWbemServices_Release(pSvc);
                return ndis_events_use_desc(events, desc);
        }

        uReturned = 0;
        hr = IEnumWbemClassObject_Next(pEnumerator, WBEM_INFINITE, 1,
                                       &pObj, &uReturned);
        if (!SUCCEEDED(hr) || uReturned == 0) {
                wpa_printf(MSG_DEBUG, "ndis_events: Failed to find interface "
                           "from Win32_NetworkAdapter: 0x%x", (int) hr);
                IEnumWbemClassObject_Release(pEnumerator);
                IWbemServices_Release(pSvc);
                return ndis_events_use_desc(events, desc);
        }
        IEnumWbemClassObject_Release(pEnumerator);

        hr = IWbemClassObject_Get(pObj, L"Name", 0, &vt, NULL, NULL);
        if (!SUCCEEDED(hr)) {
                wpa_printf(MSG_DEBUG, "ndis_events: Failed to get Name from "
                           "Win32_NetworkAdapter: 0x%x", (int) hr);
                IWbemClassObject_Release(pObj);
                IWbemServices_Release(pSvc);
                return ndis_events_use_desc(events, desc);
        }

        wpa_printf(MSG_DEBUG, "ndis_events: Win32_NetworkAdapter::Name='%S'",
                   vt.bstrVal);
        events->adapter_desc = _wcsdup(vt.bstrVal);
        VariantClear(&vt);

        /*
         * Try to get even better candidate for matching with InstanceName
         * from Win32_PnPEntity. This is needed at least for some USB cards
         * that can change the InstanceName whenever being unplugged and
         * plugged again.
         */

        hr = IWbemClassObject_Get(pObj, L"PNPDeviceID", 0, &vt, NULL, NULL);
        if (!SUCCEEDED(hr)) {
                wpa_printf(MSG_DEBUG, "ndis_events: Failed to get PNPDeviceID "
                           "from Win32_NetworkAdapter: 0x%x", (int) hr);
                IWbemClassObject_Release(pObj);
                IWbemServices_Release(pSvc);
                if (events->adapter_desc == NULL)
                        return ndis_events_use_desc(events, desc);
                return 0; /* use Win32_NetworkAdapter::Name */
        }

        wpa_printf(MSG_DEBUG, "ndis_events: Win32_NetworkAdapter::PNPDeviceID="
                   "'%S'", vt.bstrVal);

        len = _snwprintf(query, MAX_QUERY_LEN,
                        L"SELECT Name FROM Win32_PnPEntity WHERE DeviceID='");
        if (len < 0 || len >= MAX_QUERY_LEN - 1) {
                VariantClear(&vt);
                IWbemClassObject_Release(pObj);
                IWbemServices_Release(pSvc);
                if (events->adapter_desc == NULL)
                        return ndis_events_use_desc(events, desc);
                return 0; /* use Win32_NetworkAdapter::Name */
        }

        /* Escape \ as \\ */
        for (pos = 0; vt.bstrVal[pos] && len < MAX_QUERY_LEN - 2; pos++) {
                if (vt.bstrVal[pos] == '\\') {
                        if (len >= MAX_QUERY_LEN - 3)
                                break;
                        query[len++] = '\\';
                }
                query[len++] = vt.bstrVal[pos];
        }
        query[len++] = L'\'';
        query[len] = L'\0';
        VariantClear(&vt);
        IWbemClassObject_Release(pObj);
        wpa_printf(MSG_DEBUG, "ndis_events: WMI: %S", query);

        hr = call_IWbemServices_ExecQuery(
                pSvc, L"WQL", query,
                WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
                NULL, &pEnumerator);
        if (!SUCCEEDED(hr)) {
                wpa_printf(MSG_DEBUG, "ndis_events: Failed to query interface "
                           "Name from Win32_PnPEntity: 0x%x", (int) hr);
                IWbemServices_Release(pSvc);
                if (events->adapter_desc == NULL)
                        return ndis_events_use_desc(events, desc);
                return 0; /* use Win32_NetworkAdapter::Name */
        }

        uReturned = 0;
        hr = IEnumWbemClassObject_Next(pEnumerator, WBEM_INFINITE, 1,
                                       &pObj, &uReturned);
        if (!SUCCEEDED(hr) || uReturned == 0) {
                wpa_printf(MSG_DEBUG, "ndis_events: Failed to find interface "
                           "from Win32_PnPEntity: 0x%x", (int) hr);
                IEnumWbemClassObject_Release(pEnumerator);
                IWbemServices_Release(pSvc);
                if (events->adapter_desc == NULL)
                        return ndis_events_use_desc(events, desc);
                return 0; /* use Win32_NetworkAdapter::Name */
        }
        IEnumWbemClassObject_Release(pEnumerator);

        hr = IWbemClassObject_Get(pObj, L"Name", 0, &vt, NULL, NULL);
        if (!SUCCEEDED(hr)) {
                wpa_printf(MSG_DEBUG, "ndis_events: Failed to get Name from "
                           "Win32_PnPEntity: 0x%x", (int) hr);
                IWbemClassObject_Release(pObj);
                IWbemServices_Release(pSvc);
                if (events->adapter_desc == NULL)
                        return ndis_events_use_desc(events, desc);
                return 0; /* use Win32_NetworkAdapter::Name */
        }

        wpa_printf(MSG_DEBUG, "ndis_events: Win32_PnPEntity::Name='%S'",
                   vt.bstrVal);
        os_free(events->adapter_desc);
        events->adapter_desc = _wcsdup(vt.bstrVal);
        VariantClear(&vt);

        IWbemClassObject_Release(pObj);

        IWbemServices_Release(pSvc);

        if (events->adapter_desc == NULL)
                return ndis_events_use_desc(events, desc);

        return 0;
}


struct ndis_events_data *
ndis_events_init(HANDLE *read_pipe, HANDLE *event_avail,
                 const char *ifname, const char *desc)
{
        HRESULT hr;
        IWbemObjectSink *pSink;
        struct ndis_events_data *events;

        events = os_zalloc(sizeof(*events));
        if (events == NULL) {
                wpa_printf(MSG_ERROR, "Could not allocate sink for events.");
                return NULL;
        }
        events->ifname = os_strdup(ifname);
        if (events->ifname == NULL) {
                os_free(events);
                return NULL;
        }

        if (wmi_refcnt++ == 0) {
                hr = CoInitializeEx(0, COINIT_MULTITHREADED);
                if (FAILED(hr)) {
                        wpa_printf(MSG_ERROR, "CoInitializeEx() failed - "
                                   "returned 0x%x", (int) hr);
                        os_free(events);
                        return NULL;
                }
        }

        if (wmi_first) {
                /* CoInitializeSecurity() must be called once and only once
                 * per process, so let's use wmi_first flag to protect against
                 * multiple calls. */
                wmi_first = 0;

                hr = CoInitializeSecurity(NULL, -1, NULL, NULL,
                                          RPC_C_AUTHN_LEVEL_PKT_PRIVACY,
                                          RPC_C_IMP_LEVEL_IMPERSONATE,
                                          NULL, EOAC_SECURE_REFS, NULL);
                if (FAILED(hr)) {
                        wpa_printf(MSG_ERROR, "CoInitializeSecurity() failed "
                                   "- returned 0x%x", (int) hr);
                        os_free(events);
                        return NULL;
                }
        }

        hr = CoCreateInstance(&CLSID_WbemLocator, 0, CLSCTX_INPROC_SERVER,
                              &IID_IWbemLocator,
                              (LPVOID *) (void *) &events->pLoc);
        if (FAILED(hr)) {
                wpa_printf(MSG_ERROR, "CoCreateInstance() failed - returned "
                           "0x%x", (int) hr);
                CoUninitialize();
                os_free(events);
                return NULL;
        }

        if (ndis_events_get_adapter(events, ifname, desc) < 0) {
                CoUninitialize();
                os_free(events);
                return NULL;
        }
        wpa_printf(MSG_DEBUG, "ndis_events: use adapter descriptor '%S'",
                   events->adapter_desc);

        hr = call_IWbemLocator_ConnectServer(
                events->pLoc, L"ROOT\\WMI", NULL, NULL,
                0, 0, 0, 0, &events->pSvc);
        if (FAILED(hr)) {
                wpa_printf(MSG_ERROR, "Could not connect to server - error "
                           "0x%x", (int) hr);
                CoUninitialize();
                os_free(events->adapter_desc);
                os_free(events);
                return NULL;
        }
        wpa_printf(MSG_DEBUG, "Connected to ROOT\\WMI.");

        ndis_events_constructor(events);
        pSink = &events->sink;
        pSink->lpVtbl = &events->sink_vtbl;
        events->sink_vtbl.QueryInterface = ndis_events_query_interface;
        events->sink_vtbl.AddRef = ndis_events_add_ref;
        events->sink_vtbl.Release = ndis_events_release;
        events->sink_vtbl.Indicate = ndis_events_indicate;
        events->sink_vtbl.SetStatus = ndis_events_set_status;

        if (register_async_notification(pSink, events->pSvc) < 0) {
                wpa_printf(MSG_DEBUG, "Failed to register async "
                           "notifications");
                ndis_events_destructor(events);
                os_free(events->adapter_desc);
                os_free(events);
                return NULL;
        }

        *read_pipe = events->read_pipe;
        *event_avail = events->event_avail;

        return events;
}