workbench/network/WirelessManager/src/drivers/ndis_events.c

   1 /*
   2  * ndis_events - Receive NdisMIndicateStatus() events using WMI
   3  * Copyright (c) 2004-2006, Jouni Malinen <j@w1.fi>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License version 2 as
   7  * published by the Free Software Foundation.
   8  *
   9  * Alternatively, this software may be distributed under the terms of BSD
  10  * license.
  11  *
  12  * See README and COPYING for more details.
  13  */
  14
  15 #define _WIN32_WINNT    0x0400
  16
  17 #include "includes.h"
  18
  19 #ifndef COBJMACROS
  20 #define COBJMACROS
  21 #endif /* COBJMACROS */
  22 #include <wbemidl.h>
  23
  24 #include "common.h"
  25
  26
  27 static int wmi_refcnt = 0;
  28 static int wmi_first = 1;
  29
  30 struct ndis_events_data {
  31         IWbemObjectSink sink;
  32         IWbemObjectSinkVtbl sink_vtbl;
  33
  34         IWbemServices *pSvc;
  35         IWbemLocator *pLoc;
  36
  37         HANDLE read_pipe, write_pipe, event_avail;
  38         UINT ref;
  39         int terminating;
  40         char *ifname; /* {GUID..} */
  41         WCHAR *adapter_desc;
  42 };
  43
  44 #define BstrAlloc(x) (x) ? SysAllocString(x) : NULL
  45 #define BstrFree(x) if (x) SysFreeString(x)
  46
  47 /* WBEM / WMI wrapper functions, to perform in-place conversion of WCHARs to
  48  * BSTRs */
  49 HRESULT STDMETHODCALLTYPE call_IWbemServices_ExecQuery(
  50         IWbemServices *pSvc, LPCWSTR strQueryLanguage, LPCWSTR strQuery,
  51         long lFlags, IWbemContext *pCtx, IEnumWbemClassObject **ppEnum)
  52 {
  53         BSTR bsQueryLanguage, bsQuery;
  54         HRESULT hr;
  55
  56         bsQueryLanguage = BstrAlloc(strQueryLanguage);
  57         bsQuery = BstrAlloc(strQuery);
  58
  59         hr = IWbemServices_ExecQuery(pSvc, bsQueryLanguage, bsQuery, lFlags,
  60                                      pCtx, ppEnum);
  61
  62         BstrFree(bsQueryLanguage);
  63         BstrFree(bsQuery);
  64
  65         return hr;
  66 }
  67
  68
  69 HRESULT STDMETHODCALLTYPE call_IWbemServices_ExecNotificationQueryAsync(
  70         IWbemServices *pSvc, LPCWSTR strQueryLanguage, LPCWSTR strQuery,
  71         long lFlags, IWbemContext *pCtx, IWbemObjectSink *pResponseHandler)
  72 {
  73         BSTR bsQueryLanguage, bsQuery;
  74         HRESULT hr;
  75
  76         bsQueryLanguage = BstrAlloc(strQueryLanguage);
  77         bsQuery = BstrAlloc(strQuery);
  78
  79         hr = IWbemServices_ExecNotificationQueryAsync(pSvc, bsQueryLanguage,
  80                                                       bsQuery, lFlags, pCtx,
  81                                                       pResponseHandler);
  82
  83         BstrFree(bsQueryLanguage);
  84         BstrFree(bsQuery);
  85
  86         return hr;
  87 }
  88
  89
  90 HRESULT STDMETHODCALLTYPE call_IWbemLocator_ConnectServer(
  91         IWbemLocator *pLoc, LPCWSTR strNetworkResource, LPCWSTR strUser,
  92         LPCWSTR strPassword, LPCWSTR strLocale, long lSecurityFlags,
  93         LPCWSTR strAuthority, IWbemContext *pCtx, IWbemServices **ppNamespace)
  94 {
  95         BSTR bsNetworkResource, bsUser, bsPassword, bsLocale, bsAuthority;
  96         HRESULT hr;
  97
  98         bsNetworkResource = BstrAlloc(strNetworkResource);
  99         bsUser = BstrAlloc(strUser);
 100         bsPassword = BstrAlloc(strPassword);
 101         bsLocale = BstrAlloc(strLocale);
 102         bsAuthority = BstrAlloc(strAuthority);
 103
 104         hr = IWbemLocator_ConnectServer(pLoc, bsNetworkResource, bsUser,
 105                                         bsPassword, bsLocale, lSecurityFlags,
 106                                         bsAuthority, pCtx, ppNamespace);
 107
 108         BstrFree(bsNetworkResource);
 109         BstrFree(bsUser);
 110         BstrFree(bsPassword);
 111         BstrFree(bsLocale);
 112         BstrFree(bsAuthority);
 113
 114         return hr;
 115 }
 116
 117
 118 enum event_types { EVENT_CONNECT, EVENT_DISCONNECT, EVENT_MEDIA_SPECIFIC,
 119                    EVENT_ADAPTER_ARRIVAL, EVENT_ADAPTER_REMOVAL };
 120
 121 static int ndis_events_get_adapter(struct ndis_events_data *events,
 122                                    const char *ifname, const char *desc);
 123
 124
 125 static int ndis_events_constructor(struct ndis_events_data *events)
 126 {
 127         events->ref = 1;
 128
 129         if (!CreatePipe(&events->read_pipe, &events->write_pipe, NULL, 512)) {
 130                 wpa_printf(MSG_ERROR, "CreatePipe() failed: %d",
 131                            (int) GetLastError());
 132                 return -1;
 133         }
 134         events->event_avail = CreateEvent(NULL, TRUE, FALSE, NULL);
 135         if (events->event_avail == NULL) {
 136                 wpa_printf(MSG_ERROR, "CreateEvent() failed: %d",
 137                            (int) GetLastError());
 138                 CloseHandle(events->read_pipe);
 139                 CloseHandle(events->write_pipe);
 140                 return -1;
 141         }
 142
 143         return 0;
 144 }
 145
 146
 147 static void ndis_events_destructor(struct ndis_events_data *events)
 148 {
 149         CloseHandle(events->read_pipe);
 150         CloseHandle(events->write_pipe);
 151         CloseHandle(events->event_avail);
 152         IWbemServices_Release(events->pSvc);
 153         IWbemLocator_Release(events->pLoc);
 154         if (--wmi_refcnt == 0)
 155                 CoUninitialize();
 156 }
 157
 158
 159 static HRESULT STDMETHODCALLTYPE
 160 ndis_events_query_interface(IWbemObjectSink *this, REFIID riid, void **obj)
 161 {
 162         *obj = NULL;
 163
 164         if (IsEqualIID(riid, &IID_IUnknown) ||
 165             IsEqualIID(riid, &IID_IWbemObjectSink)) {
 166                 *obj = this;
 167                 IWbemObjectSink_AddRef(this);
 168                 return NOERROR;
 169         }
 170
 171         return E_NOINTERFACE;
 172 }
 173
 174
 175 static ULONG STDMETHODCALLTYPE ndis_events_add_ref(IWbemObjectSink *this)
 176 {
 177         struct ndis_events_data *events = (struct ndis_events_data *) this;
 178         return ++events->ref;
 179 }
 180
 181
 182 static ULONG STDMETHODCALLTYPE ndis_events_release(IWbemObjectSink *this)
 183 {
 184         struct ndis_events_data *events = (struct ndis_events_data *) this;
 185
 186         if (--events->ref != 0)
 187                 return events->ref;
 188
 189         ndis_events_destructor(events);
 190         wpa_printf(MSG_DEBUG, "ndis_events: terminated");
 191         os_free(events->adapter_desc);
 192         os_free(events->ifname);
 193         os_free(events);
 194         return 0;
 195 }
 196
 197
 198 static int ndis_events_send_event(struct ndis_events_data *events,
 199                                   enum event_types type,
 200                                   char *data, size_t data_len)
 201 {
 202         char buf[512], *pos, *end;
 203         int _type;
 204         DWORD written;
 205
 206         end = buf + sizeof(buf);
 207         _type = (int) type;
 208         os_memcpy(buf, &_type, sizeof(_type));
 209         pos = buf + sizeof(_type);
 210
 211         if (data) {
 212                 if (2 + data_len > (size_t) (end - pos)) {
 213                         wpa_printf(MSG_DEBUG, "Not enough room for send_event "
 214                                    "data (%d)", data_len);
 215                         return -1;
 216                 }
 217                 *pos++ = data_len >> 8;
 218                 *pos++ = data_len & 0xff;
 219                 os_memcpy(pos, data, data_len);
 220                 pos += data_len;
 221         }
 222
 223         if (WriteFile(events->write_pipe, buf, pos - buf, &written, NULL)) {
 224                 SetEvent(events->event_avail);
 225                 return 0;
 226         }
 227         wpa_printf(MSG_INFO, "WriteFile() failed: %d", (int) GetLastError());
 228         return -1;
 229 }
 230
 231
 232 static void ndis_events_media_connect(struct ndis_events_data *events)
 233 {
 234         wpa_printf(MSG_DEBUG, "MSNdis_StatusMediaConnect");
 235         ndis_events_send_event(events, EVENT_CONNECT, NULL, 0);
 236 }
 237
 238
 239 static void ndis_events_media_disconnect(struct ndis_events_data *events)
 240 {
 241         wpa_printf(MSG_DEBUG, "MSNdis_StatusMediaDisconnect");
 242         ndis_events_send_event(events, EVENT_DISCONNECT, NULL, 0);
 243 }
 244
 245
 246 static void ndis_events_media_specific(struct ndis_events_data *events,
 247                                        IWbemClassObject *pObj)
 248 {
 249         VARIANT vt;
 250         HRESULT hr;
 251         LONG lower, upper, k;
 252         UCHAR ch;
 253         char *data, *pos;
 254         size_t data_len;
 255
 256         wpa_printf(MSG_DEBUG, "MSNdis_StatusMediaSpecificIndication");
 257
 258         /* This is the StatusBuffer from NdisMIndicateStatus() call */
 259         hr = IWbemClassObject_Get(pObj, L"NdisStatusMediaSpecificIndication",
 260                                   0, &vt, NULL, NULL);
 261         if (FAILED(hr)) {
 262                 wpa_printf(MSG_DEBUG, "Could not get "
 263                            "NdisStatusMediaSpecificIndication from "
 264                            "the object?!");
 265                 return;
 266         }
 267
 268         SafeArrayGetLBound(V_ARRAY(&vt), 1, &lower);
 269         SafeArrayGetUBound(V_ARRAY(&vt), 1, &upper);
 270         data_len = upper - lower + 1;
 271         data = os_malloc(data_len);
 272         if (data == NULL) {
 273                 wpa_printf(MSG_DEBUG, "Failed to allocate buffer for event "
 274                            "data");
 275                 VariantClear(&vt);
 276                 return;
 277         }
 278
 279         pos = data;
 280         for (k = lower; k <= upper; k++) {
 281                 SafeArrayGetElement(V_ARRAY(&vt), &k, &ch);
 282                 *pos++ = ch;
 283         }
 284         wpa_hexdump(MSG_DEBUG, "MediaSpecificEvent", (u8 *) data, data_len);
 285
 286         VariantClear(&vt);
 287
 288         ndis_events_send_event(events, EVENT_MEDIA_SPECIFIC, data, data_len);
 289
 290         os_free(data);
 291 }
 292
 293
 294 static void ndis_events_adapter_arrival(struct ndis_events_data *events)
 295 {
 296         wpa_printf(MSG_DEBUG, "MSNdis_NotifyAdapterArrival");
 297         ndis_events_send_event(events, EVENT_ADAPTER_ARRIVAL, NULL, 0);
 298 }
 299
 300
 301 static void ndis_events_adapter_removal(struct ndis_events_data *events)
 302 {
 303         wpa_printf(MSG_DEBUG, "MSNdis_NotifyAdapterRemoval");
 304         ndis_events_send_event(events, EVENT_ADAPTER_REMOVAL, NULL, 0);
 305 }
 306
 307
 308 static HRESULT STDMETHODCALLTYPE
 309 ndis_events_indicate(IWbemObjectSink *this, long lObjectCount,
 310                      IWbemClassObject __RPC_FAR *__RPC_FAR *ppObjArray)
 311 {
 312         struct ndis_events_data *events = (struct ndis_events_data *) this;
 313         long i;
 314
 315         if (events->terminating) {
 316                 wpa_printf(MSG_DEBUG, "ndis_events_indicate: Ignore "
 317                            "indication - terminating");
 318                 return WBEM_NO_ERROR;
 319         }
 320         /* wpa_printf(MSG_DEBUG, "Notification received - %d object(s)",
 321            lObjectCount); */
 322
 323         for (i = 0; i < lObjectCount; i++) {
 324                 IWbemClassObject *pObj = ppObjArray[i];
 325                 HRESULT hr;
 326                 VARIANT vtClass, vt;
 327
 328                 hr = IWbemClassObject_Get(pObj, L"__CLASS", 0, &vtClass, NULL,
 329                                           NULL);
 330                 if (FAILED(hr)) {
 331                         wpa_printf(MSG_DEBUG, "Failed to get __CLASS from "
 332                                    "event.");
 333                         break;
 334                 }
 335                 /* wpa_printf(MSG_DEBUG, "CLASS: '%S'", vtClass.bstrVal); */
 336
 337                 hr = IWbemClassObject_Get(pObj, L"InstanceName", 0, &vt, NULL,
 338                                           NULL);
 339                 if (FAILED(hr)) {
 340                         wpa_printf(MSG_DEBUG, "Failed to get InstanceName "
 341                                    "from event.");
 342                         VariantClear(&vtClass);
 343                         break;
 344                 }
 345
 346                 if (wcscmp(vtClass.bstrVal,
 347                            L"MSNdis_NotifyAdapterArrival") == 0) {
 348                         wpa_printf(MSG_DEBUG, "ndis_events_indicate: Try to "
 349                                    "update adapter description since it may "
 350                                    "have changed with new adapter instance");
 351                         ndis_events_get_adapter(events, events->ifname, NULL);
 352                 }
 353
 354                 if (wcscmp(events->adapter_desc, vt.bstrVal) != 0) {
 355                         wpa_printf(MSG_DEBUG, "ndis_events_indicate: Ignore "
 356                                    "indication for foreign adapter: "
 357                                    "InstanceName: '%S' __CLASS: '%S'",
 358                                    vt.bstrVal, vtClass.bstrVal);
 359                         VariantClear(&vtClass);
 360                         VariantClear(&vt);
 361                         continue;
 362                 }
 363                 VariantClear(&vt);
 364
 365                 if (wcscmp(vtClass.bstrVal,
 366                            L"MSNdis_StatusMediaSpecificIndication") == 0) {
 367                         ndis_events_media_specific(events, pObj);
 368                 } else if (wcscmp(vtClass.bstrVal,
 369                                   L"MSNdis_StatusMediaConnect") == 0) {
 370                         ndis_events_media_connect(events);
 371                 } else if (wcscmp(vtClass.bstrVal,
 372                                   L"MSNdis_StatusMediaDisconnect") == 0) {
 373                         ndis_events_media_disconnect(events);
 374                 } else if (wcscmp(vtClass.bstrVal,
 375                                   L"MSNdis_NotifyAdapterArrival") == 0) {
 376                         ndis_events_adapter_arrival(events);
 377                 } else if (wcscmp(vtClass.bstrVal,
 378                                   L"MSNdis_NotifyAdapterRemoval") == 0) {
 379                         ndis_events_adapter_removal(events);
 380                 } else {
 381                         wpa_printf(MSG_DEBUG, "Unepected event - __CLASS: "
 382                                    "'%S'", vtClass.bstrVal);
 383                 }
 384
 385                 VariantClear(&vtClass);
 386         }
 387
 388         return WBEM_NO_ERROR;
 389 }
 390
 391
 392 static HRESULT STDMETHODCALLTYPE
 393 ndis_events_set_status(IWbemObjectSink *this, long lFlags, HRESULT hResult,
 394                        BSTR strParam, IWbemClassObject __RPC_FAR *pObjParam)
 395 {
 396         return WBEM_NO_ERROR;
 397 }
 398
 399
 400 static int notification_query(IWbemObjectSink *pDestSink,
 401                               IWbemServices *pSvc, const char *class_name)
 402 {
 403         HRESULT hr;
 404         WCHAR query[256];
 405
 406         _snwprintf(query, 256,
 407                   L"SELECT * FROM %S", class_name);
 408         wpa_printf(MSG_DEBUG, "ndis_events: WMI: %S", query);
 409         hr = call_IWbemServices_ExecNotificationQueryAsync(
 410                 pSvc, L"WQL", query, 0, 0, pDestSink);
 411         if (FAILED(hr)) {
 412                 wpa_printf(MSG_DEBUG, "ExecNotificationQueryAsync for %s "
 413                            "failed with hresult of 0x%x",
 414                            class_name, (int) hr);
 415                 return -1;
 416         }
 417
 418         return 0;
 419 }
 420
 421
 422 static int register_async_notification(IWbemObjectSink *pDestSink,
 423                                        IWbemServices *pSvc)
 424 {
 425         int i;
 426         const char *class_list[] = {
 427                 "MSNdis_StatusMediaConnect",
 428                 "MSNdis_StatusMediaDisconnect",
 429                 "MSNdis_StatusMediaSpecificIndication",
 430                 "MSNdis_NotifyAdapterArrival",
 431                 "MSNdis_NotifyAdapterRemoval",
 432                 NULL
 433         };
 434
 435         for (i = 0; class_list[i]; i++) {
 436                 if (notification_query(pDestSink, pSvc, class_list[i]) < 0)
 437                         return -1;
 438         }
 439
 440         return 0;
 441 }
 442
 443
 444 void ndis_events_deinit(struct ndis_events_data *events)
 445 {
 446         events->terminating = 1;
 447         IWbemServices_CancelAsyncCall(events->pSvc, &events->sink);
 448         IWbemObjectSink_Release(&events->sink);
 449         /*
 450          * Rest of deinitialization is done in ndis_events_destructor() once
 451          * all reference count drops to zero.
 452          */
 453 }
 454
 455
 456 static int ndis_events_use_desc(struct ndis_events_data *events,
 457                                 const char *desc)
 458 {
 459         char *tmp, *pos;
 460         size_t len;
 461
 462         if (desc == NULL) {
 463                 if (events->adapter_desc == NULL)
 464                         return -1;
 465                 /* Continue using old description */
 466                 return 0;
 467         }
 468
 469         tmp = os_strdup(desc);
 470         if (tmp == NULL)
 471                 return -1;
 472
 473         pos = os_strstr(tmp, " (Microsoft's Packet Scheduler)");
 474         if (pos)
 475                 *pos = '\0';
 476
 477         len = os_strlen(tmp);
 478         events->adapter_desc = os_malloc((len + 1) * sizeof(WCHAR));
 479         if (events->adapter_desc == NULL) {
 480                 os_free(tmp);
 481                 return -1;
 482         }
 483         _snwprintf(events->adapter_desc, len + 1, L"%S", tmp);
 484         os_free(tmp);
 485         return 0;
 486 }
 487
 488
 489 static int ndis_events_get_adapter(struct ndis_events_data *events,
 490                                    const char *ifname, const char *desc)
 491 {
 492         HRESULT hr;
 493         IWbemServices *pSvc;
 494 #define MAX_QUERY_LEN 256
 495         WCHAR query[MAX_QUERY_LEN];
 496         IEnumWbemClassObject *pEnumerator;
 497         IWbemClassObject *pObj;
 498         ULONG uReturned;
 499         VARIANT vt;
 500         int len, pos;
 501
 502         /*
 503          * Try to get adapter descriptor through WMI CIMv2 Win32_NetworkAdapter
 504          * to have better probability of matching with InstanceName from
 505          * MSNdis events. If this fails, use the provided description.
 506          */
 507
 508         os_free(events->adapter_desc);
 509         events->adapter_desc = NULL;
 510
 511         hr = call_IWbemLocator_ConnectServer(
 512                 events->pLoc, L"ROOT\\CIMV2", NULL, NULL, 0, 0, 0, 0, &pSvc);
 513         if (FAILED(hr)) {
 514                 wpa_printf(MSG_ERROR, "ndis_events: Could not connect to WMI "
 515                            "server (ROOT\\CIMV2) - error 0x%x", (int) hr);
 516                 return ndis_events_use_desc(events, desc);
 517         }
 518         wpa_printf(MSG_DEBUG, "ndis_events: Connected to ROOT\\CIMV2.");
 519
 520         _snwprintf(query, MAX_QUERY_LEN,
 521                   L"SELECT Index FROM Win32_NetworkAdapterConfiguration "
 522                   L"WHERE SettingID='%S'", ifname);
 523         wpa_printf(MSG_DEBUG, "ndis_events: WMI: %S", query);
 524
 525         hr = call_IWbemServices_ExecQuery(
 526                 pSvc, L"WQL", query,
 527                 WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
 528                 NULL, &pEnumerator);
 529         if (!SUCCEEDED(hr)) {
 530                 wpa_printf(MSG_DEBUG, "ndis_events: Failed to query interface "
 531                            "GUID from Win32_NetworkAdapterConfiguration: "
 532                            "0x%x", (int) hr);
 533                 IWbemServices_Release(pSvc);
 534                 return ndis_events_use_desc(events, desc);
 535         }
 536
 537         uReturned = 0;
 538         hr = IEnumWbemClassObject_Next(pEnumerator, WBEM_INFINITE, 1,
 539                                        &pObj, &uReturned);
 540         if (!SUCCEEDED(hr) || uReturned == 0) {
 541                 wpa_printf(MSG_DEBUG, "ndis_events: Failed to find interface "
 542                            "GUID from Win32_NetworkAdapterConfiguration: "
 543                            "0x%x", (int) hr);
 544                 IEnumWbemClassObject_Release(pEnumerator);
 545                 IWbemServices_Release(pSvc);
 546                 return ndis_events_use_desc(events, desc);
 547         }
 548         IEnumWbemClassObject_Release(pEnumerator);
 549
 550         VariantInit(&vt);
 551         hr = IWbemClassObject_Get(pObj, L"Index", 0, &vt, NULL, NULL);
 552         if (!SUCCEEDED(hr)) {
 553                 wpa_printf(MSG_DEBUG, "ndis_events: Failed to get Index from "
 554                            "Win32_NetworkAdapterConfiguration: 0x%x",
 555                            (int) hr);
 556                 IWbemServices_Release(pSvc);
 557                 return ndis_events_use_desc(events, desc);
 558         }
 559
 560         _snwprintf(query, MAX_QUERY_LEN,
 561                   L"SELECT Name,PNPDeviceID FROM Win32_NetworkAdapter WHERE "
 562                   L"Index=%d",
 563                   vt.uintVal);
 564         wpa_printf(MSG_DEBUG, "ndis_events: WMI: %S", query);
 565         VariantClear(&vt);
 566         IWbemClassObject_Release(pObj);
 567
 568         hr = call_IWbemServices_ExecQuery(
 569                 pSvc, L"WQL", query,
 570                 WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
 571                 NULL, &pEnumerator);
 572         if (!SUCCEEDED(hr)) {
 573                 wpa_printf(MSG_DEBUG, "ndis_events: Failed to query interface "
 574                            "from Win32_NetworkAdapter: 0x%x", (int) hr);
 575                 IWbemServices_Release(pSvc);
 576                 return ndis_events_use_desc(events, desc);
 577         }
 578
 579         uReturned = 0;
 580         hr = IEnumWbemClassObject_Next(pEnumerator, WBEM_INFINITE, 1,
 581                                        &pObj, &uReturned);
 582         if (!SUCCEEDED(hr) || uReturned == 0) {
 583                 wpa_printf(MSG_DEBUG, "ndis_events: Failed to find interface "
 584                            "from Win32_NetworkAdapter: 0x%x", (int) hr);
 585                 IEnumWbemClassObject_Release(pEnumerator);
 586                 IWbemServices_Release(pSvc);
 587                 return ndis_events_use_desc(events, desc);
 588         }
 589         IEnumWbemClassObject_Release(pEnumerator);
 590
 591         hr = IWbemClassObject_Get(pObj, L"Name", 0, &vt, NULL, NULL);
 592         if (!SUCCEEDED(hr)) {
 593                 wpa_printf(MSG_DEBUG, "ndis_events: Failed to get Name from "
 594                            "Win32_NetworkAdapter: 0x%x", (int) hr);
 595                 IWbemClassObject_Release(pObj);
 596                 IWbemServices_Release(pSvc);
 597                 return ndis_events_use_desc(events, desc);
 598         }
 599
 600         wpa_printf(MSG_DEBUG, "ndis_events: Win32_NetworkAdapter::Name='%S'",
 601                    vt.bstrVal);
 602         events->adapter_desc = _wcsdup(vt.bstrVal);
 603         VariantClear(&vt);
 604
 605         /*
 606          * Try to get even better candidate for matching with InstanceName
 607          * from Win32_PnPEntity. This is needed at least for some USB cards
 608          * that can change the InstanceName whenever being unplugged and
 609          * plugged again.
 610          */
 611
 612         hr = IWbemClassObject_Get(pObj, L"PNPDeviceID", 0, &vt, NULL, NULL);
 613         if (!SUCCEEDED(hr)) {
 614                 wpa_printf(MSG_DEBUG, "ndis_events: Failed to get PNPDeviceID "
 615                            "from Win32_NetworkAdapter: 0x%x", (int) hr);
 616                 IWbemClassObject_Release(pObj);
 617                 IWbemServices_Release(pSvc);
 618                 if (events->adapter_desc == NULL)
 619                         return ndis_events_use_desc(events, desc);
 620                 return 0; /* use Win32_NetworkAdapter::Name */
 621         }
 622
 623         wpa_printf(MSG_DEBUG, "ndis_events: Win32_NetworkAdapter::PNPDeviceID="
 624                    "'%S'", vt.bstrVal);
 625
 626         len = _snwprintf(query, MAX_QUERY_LEN,
 627                         L"SELECT Name FROM Win32_PnPEntity WHERE DeviceID='");
 628         if (len < 0 || len >= MAX_QUERY_LEN - 1) {
 629                 VariantClear(&vt);
 630                 IWbemClassObject_Release(pObj);
 631                 IWbemServices_Release(pSvc);
 632                 if (events->adapter_desc == NULL)
 633                         return ndis_events_use_desc(events, desc);
 634                 return 0; /* use Win32_NetworkAdapter::Name */
 635         }
 636
 637         /* Escape \ as \\ */
 638         for (pos = 0; vt.bstrVal[pos] && len < MAX_QUERY_LEN - 2; pos++) {
 639                 if (vt.bstrVal[pos] == '\\') {
 640                         if (len >= MAX_QUERY_LEN - 3)
 641                                 break;
 642                         query[len++] = '\\';
 643                 }
 644                 query[len++] = vt.bstrVal[pos];
 645         }
 646         query[len++] = L'\'';
 647         query[len] = L'\0';
 648         VariantClear(&vt);
 649         IWbemClassObject_Release(pObj);
 650         wpa_printf(MSG_DEBUG, "ndis_events: WMI: %S", query);
 651
 652         hr = call_IWbemServices_ExecQuery(
 653                 pSvc, L"WQL", query,
 654                 WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
 655                 NULL, &pEnumerator);
 656         if (!SUCCEEDED(hr)) {
 657                 wpa_printf(MSG_DEBUG, "ndis_events: Failed to query interface "
 658                            "Name from Win32_PnPEntity: 0x%x", (int) hr);
 659                 IWbemServices_Release(pSvc);
 660                 if (events->adapter_desc == NULL)
 661                         return ndis_events_use_desc(events, desc);
 662                 return 0; /* use Win32_NetworkAdapter::Name */
 663         }
 664
 665         uReturned = 0;
 666         hr = IEnumWbemClassObject_Next(pEnumerator, WBEM_INFINITE, 1,
 667                                        &pObj, &uReturned);
 668         if (!SUCCEEDED(hr) || uReturned == 0) {
 669                 wpa_printf(MSG_DEBUG, "ndis_events: Failed to find interface "
 670                            "from Win32_PnPEntity: 0x%x", (int) hr);
 671                 IEnumWbemClassObject_Release(pEnumerator);
 672                 IWbemServices_Release(pSvc);
 673                 if (events->adapter_desc == NULL)
 674                         return ndis_events_use_desc(events, desc);
 675                 return 0; /* use Win32_NetworkAdapter::Name */
 676         }
 677         IEnumWbemClassObject_Release(pEnumerator);
 678
 679         hr = IWbemClassObject_Get(pObj, L"Name", 0, &vt, NULL, NULL);
 680         if (!SUCCEEDED(hr)) {
 681                 wpa_printf(MSG_DEBUG, "ndis_events: Failed to get Name from "
 682                            "Win32_PnPEntity: 0x%x", (int) hr);
 683                 IWbemClassObject_Release(pObj);
 684                 IWbemServices_Release(pSvc);
 685                 if (events->adapter_desc == NULL)
 686                         return ndis_events_use_desc(events, desc);
 687                 return 0; /* use Win32_NetworkAdapter::Name */
 688         }
 689
 690         wpa_printf(MSG_DEBUG, "ndis_events: Win32_PnPEntity::Name='%S'",
 691                    vt.bstrVal);
 692         os_free(events->adapter_desc);
 693         events->adapter_desc = _wcsdup(vt.bstrVal);
 694         VariantClear(&vt);
 695
 696         IWbemClassObject_Release(pObj);
 697
 698         IWbemServices_Release(pSvc);
 699
 700         if (events->adapter_desc == NULL)
 701                 return ndis_events_use_desc(events, desc);
 702
 703         return 0;
 704 }
 705
 706
 707 struct ndis_events_data *
 708 ndis_events_init(HANDLE *read_pipe, HANDLE *event_avail,
 709                  const char *ifname, const char *desc)
 710 {
 711         HRESULT hr;
 712         IWbemObjectSink *pSink;
 713         struct ndis_events_data *events;
 714
 715         events = os_zalloc(sizeof(*events));
 716         if (events == NULL) {
 717                 wpa_printf(MSG_ERROR, "Could not allocate sink for events.");
 718                 return NULL;
 719         }
 720         events->ifname = os_strdup(ifname);
 721         if (events->ifname == NULL) {
 722                 os_free(events);
 723                 return NULL;
 724         }
 725
 726         if (wmi_refcnt++ == 0) {
 727                 hr = CoInitializeEx(0, COINIT_MULTITHREADED);
 728                 if (FAILED(hr)) {
 729                         wpa_printf(MSG_ERROR, "CoInitializeEx() failed - "
 730                                    "returned 0x%x", (int) hr);
 731                         os_free(events);
 732                         return NULL;
 733                 }
 734         }
 735
 736         if (wmi_first) {
 737                 /* CoInitializeSecurity() must be called once and only once
 738                  * per process, so let's use wmi_first flag to protect against
 739                  * multiple calls. */
 740                 wmi_first = 0;
 741
 742                 hr = CoInitializeSecurity(NULL, -1, NULL, NULL,
 743                                           RPC_C_AUTHN_LEVEL_PKT_PRIVACY,
 744                                           RPC_C_IMP_LEVEL_IMPERSONATE,
 745                                           NULL, EOAC_SECURE_REFS, NULL);
 746                 if (FAILED(hr)) {
 747                         wpa_printf(MSG_ERROR, "CoInitializeSecurity() failed "
 748                                    "- returned 0x%x", (int) hr);
 749                         os_free(events);
 750                         return NULL;
 751                 }
 752         }
 753
 754         hr = CoCreateInstance(&CLSID_WbemLocator, 0, CLSCTX_INPROC_SERVER,
 755                               &IID_IWbemLocator,
 756                               (LPVOID *) (void *) &events->pLoc);
 757         if (FAILED(hr)) {
 758                 wpa_printf(MSG_ERROR, "CoCreateInstance() failed - returned "
 759                            "0x%x", (int) hr);
 760                 CoUninitialize();
 761                 os_free(events);
 762                 return NULL;
 763         }
 764
 765         if (ndis_events_get_adapter(events, ifname, desc) < 0) {
 766                 CoUninitialize();
 767                 os_free(events);
 768                 return NULL;
 769         }
 770         wpa_printf(MSG_DEBUG, "ndis_events: use adapter descriptor '%S'",
 771                    events->adapter_desc);
 772
 773         hr = call_IWbemLocator_ConnectServer(
 774                 events->pLoc, L"ROOT\\WMI", NULL, NULL,
 775                 0, 0, 0, 0, &events->pSvc);
 776         if (FAILED(hr)) {
 777                 wpa_printf(MSG_ERROR, "Could not connect to server - error "
 778                            "0x%x", (int) hr);
 779                 CoUninitialize();
 780                 os_free(events->adapter_desc);
 781                 os_free(events);
 782                 return NULL;
 783         }
 784         wpa_printf(MSG_DEBUG, "Connected to ROOT\\WMI.");
 785
 786         ndis_events_constructor(events);
 787         pSink = &events->sink;
 788         pSink->lpVtbl = &events->sink_vtbl;
 789         events->sink_vtbl.QueryInterface = ndis_events_query_interface;
 790         events->sink_vtbl.AddRef = ndis_events_add_ref;
 791         events->sink_vtbl.Release = ndis_events_release;
 792         events->sink_vtbl.Indicate = ndis_events_indicate;
 793         events->sink_vtbl.SetStatus = ndis_events_set_status;
 794
 795         if (register_async_notification(pSink, events->pSvc) < 0) {
 796                 wpa_printf(MSG_DEBUG, "Failed to register async "
 797                            "notifications");
 798                 ndis_events_destructor(events);
 799                 os_free(events->adapter_desc);
 800                 os_free(events);
 801                 return NULL;
 802         }
 803
 804         *read_pipe = events->read_pipe;
 805         *event_avail = events->event_avail;
 806
 807         return events;
 808 }