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