1 /* 2 * ndis_events - Receive NdisMIndicateStatus() events using WMI 3 * Copyright (c) 2004-2006, Jouni Malinen <j (at) 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 } 809
