Merge branch 'vendor/HOSTAPD'
[dragonfly.git] / contrib / hostapd / 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 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 }