xref: /reactos/base/services/wlansvc/rpcserver.c (revision 84ccccab) 
1 /*
2  * PROJECT:     ReactOS WLAN Service
3  * LICENSE:     GPL - See COPYING in the top level directory
4  * FILE:        base/services/wlansvc/rpcserver.c
5  * PURPOSE:     RPC server interface
6  * COPYRIGHT:   Copyright 2009 Christoph von Wittich
7  */
8 
9 #include "precomp.h"
10 
11 #define NDEBUG
12 #include <debug.h>
13 //#define GET_IF_ENTRY2_IMPLEMENTED 1
14 
15 LIST_ENTRY WlanSvcHandleListHead;
16 
17 DWORD WINAPI RpcThreadRoutine(LPVOID lpParameter)
18 {
19     RPC_STATUS Status;
20 
21     InitializeListHead(&WlanSvcHandleListHead);
22 
23     Status = RpcServerUseProtseqEpW(L"ncalrpc", 20, L"wlansvc", NULL);
24     if (Status != RPC_S_OK)
25     {
26         DPRINT("RpcServerUseProtseqEpW() failed (Status %lx)\n", Status);
27         return 0;
28     }
29 
30     Status = RpcServerRegisterIf(wlansvc_interface_v1_0_s_ifspec, NULL, NULL);
31     if (Status != RPC_S_OK)
32     {
33         DPRINT("RpcServerRegisterIf() failed (Status %lx)\n", Status);
34         return 0;
35     }
36 
37     Status = RpcServerListen(1, RPC_C_LISTEN_MAX_CALLS_DEFAULT, 0);
38     if (Status != RPC_S_OK)
39     {
40         DPRINT("RpcServerListen() failed (Status %lx)\n", Status);
41     }
42 
43     DPRINT("RpcServerListen finished\n");
44     return 0;
45 }
46 
47 PWLANSVCHANDLE WlanSvcGetHandleEntry(LPWLANSVC_RPC_HANDLE ClientHandle)
48 {
49     PLIST_ENTRY CurrentEntry;
50     PWLANSVCHANDLE lpWlanSvcHandle;
51 
52     CurrentEntry = WlanSvcHandleListHead.Flink;
53     while (CurrentEntry != &WlanSvcHandleListHead)
54     {
55         lpWlanSvcHandle = CONTAINING_RECORD(CurrentEntry,
56                                         WLANSVCHANDLE,
57                                         WlanSvcHandleListEntry);
58         CurrentEntry = CurrentEntry->Flink;
59 
60         if (lpWlanSvcHandle == (PWLANSVCHANDLE) ClientHandle)
61             return lpWlanSvcHandle;
62     }
63 
64     return NULL;
65 }
66 
67 DWORD _RpcOpenHandle(
68     wchar_t *arg_1,
69     DWORD dwClientVersion,
70     DWORD *pdwNegotiatedVersion,
71     LPWLANSVC_RPC_HANDLE phClientHandle)
72 {
73     PWLANSVCHANDLE lpWlanSvcHandle;
74 
75     lpWlanSvcHandle = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WLANSVCHANDLE));
76     if (lpWlanSvcHandle == NULL)
77     {
78         DPRINT1("Failed to allocate Heap!\n");
79         return ERROR_NOT_ENOUGH_MEMORY;
80     }
81 
82     if (dwClientVersion > 2)
83         dwClientVersion = 2;
84 
85     if (dwClientVersion < 1)
86         dwClientVersion = 1;
87 
88     lpWlanSvcHandle->dwClientVersion = dwClientVersion;
89     *pdwNegotiatedVersion = dwClientVersion;
90 
91     InsertTailList(&WlanSvcHandleListHead, &lpWlanSvcHandle->WlanSvcHandleListEntry);
92     *phClientHandle = lpWlanSvcHandle;
93 
94     return ERROR_SUCCESS;
95 }
96 
97 DWORD _RpcCloseHandle(
98     LPWLANSVC_RPC_HANDLE phClientHandle)
99 {
100     PWLANSVCHANDLE lpWlanSvcHandle;
101 
102     lpWlanSvcHandle = WlanSvcGetHandleEntry(*phClientHandle);
103     if (!lpWlanSvcHandle)
104     {
105         return ERROR_INVALID_HANDLE;
106     }
107 
108     RemoveEntryList(&lpWlanSvcHandle->WlanSvcHandleListEntry);
109     HeapFree(GetProcessHeap(), 0, lpWlanSvcHandle);
110 
111     return ERROR_SUCCESS;
112 }
113 
114 DWORD _RpcEnumInterfaces(
115     WLANSVC_RPC_HANDLE hClientHandle,
116     PWLAN_INTERFACE_INFO_LIST *ppInterfaceList)
117 {
118 #if GET_IF_ENTRY2_IMPLEMENTED
119     DWORD dwNumInterfaces;
120     DWORD dwResult, dwSize;
121     DWORD dwIndex;
122     MIB_IF_ROW2 IfRow;
123     PWLAN_INTERFACE_INFO_LIST InterfaceList;
124 
125     dwResult = GetNumberOfInterfaces(&dwNumInterfaces);
126     dwSize = sizeof(WLAN_INTERFACE_INFO_LIST);
127     if (dwResult != NO_ERROR)
128     {
129         /* set num interfaces to zero when an error occurs */
130         dwNumInterfaces = 0;
131     }
132     else
133     {
134         if (dwNumInterfaces > 1)
135         {
136             /* add extra size for interface */
137             dwSize += (dwNumInterfaces-1) * sizeof(WLAN_INTERFACE_INFO);
138         }
139     }
140 
141     /* allocate interface list */
142     InterfaceList = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwSize);
143     if (!InterfaceList)
144     {
145         return ERROR_NOT_ENOUGH_MEMORY;
146     }
147 
148     *ppInterfaceList = InterfaceList;
149     if (!dwNumInterfaces)
150     {
151         return ERROR_SUCCESS;
152     }
153 
154     for(dwIndex = 0; dwIndex < dwNumInterfaces; dwIndex++)
155     {
156         ZeroMemory(&IfRow, sizeof(MIB_IF_ROW2));
157         IfRow.InterfaceIndex = dwIndex;
158 
159         dwResult = GetIfEntry2(&IfRow);
160         if (dwResult == NO_ERROR)
161         {
162             if (IfRow.Type == IF_TYPE_IEEE80211 && IfRow.InterfaceAndOperStatusFlags.HardwareInterface)
163             {
164                 RtlMoveMemory(&InterfaceList->InterfaceInfo[InterfaceList->dwNumberOfItems].InterfaceGuid, &IfRow.InterfaceGuid, sizeof(GUID));
165                 wcscpy(InterfaceList->InterfaceInfo[InterfaceList->dwNumberOfItems].strInterfaceDescription, IfRow.Description);
166                 //FIXME set state
167                 InterfaceList->dwNumberOfItems++;
168             }
169         }
170     }
171 
172     return ERROR_SUCCESS;
173 #else
174     UNIMPLEMENTED;
175     return ERROR_CALL_NOT_IMPLEMENTED;
176 #endif
177 }
178 
179 DWORD _RpcSetAutoConfigParameter(
180     WLANSVC_RPC_HANDLE hClientHandle,
181     long OpCode,
182     DWORD dwDataSize,
183     LPBYTE pData)
184 {
185     UNIMPLEMENTED;
186     return ERROR_CALL_NOT_IMPLEMENTED;
187 }
188 
189 DWORD _RpcQueryAutoConfigParameter(
190     WLANSVC_RPC_HANDLE hClientHandle,
191     DWORD OpCode,
192     LPDWORD pdwDataSize,
193     char **ppData,
194     DWORD *pWlanOpcodeValueType)
195 {
196     UNIMPLEMENTED;
197     return ERROR_CALL_NOT_IMPLEMENTED;
198 }
199 
200 DWORD _RpcGetInterfaceCapability(
201     WLANSVC_RPC_HANDLE hClientHandle,
202     const GUID *pInterfaceGuid,
203     PWLAN_INTERFACE_CAPABILITY *ppCapability)
204 {
205     PWLANSVCHANDLE lpWlanSvcHandle;
206 
207     lpWlanSvcHandle = WlanSvcGetHandleEntry(hClientHandle);
208     if (!lpWlanSvcHandle)
209     {
210         return ERROR_INVALID_HANDLE;
211     }
212 
213     UNIMPLEMENTED;
214     return ERROR_CALL_NOT_IMPLEMENTED;
215 }
216 
217 DWORD _RpcSetInterface(
218     WLANSVC_RPC_HANDLE hClientHandle,
219     const GUID *pInterfaceGuid,
220     DWORD OpCode,
221     DWORD dwDataSize,
222     LPBYTE pData)
223 {
224     UNIMPLEMENTED;
225     return ERROR_CALL_NOT_IMPLEMENTED;
226 }
227 
228 DWORD _RpcQueryInterface(
229     WLANSVC_RPC_HANDLE hClientHandle,
230     const GUID *pInterfaceGuid,
231     long OpCode,
232     LPDWORD pdwDataSize,
233     LPBYTE *ppData,
234     LPDWORD pWlanOpcodeValueType)
235 {
236     UNIMPLEMENTED;
237     return ERROR_CALL_NOT_IMPLEMENTED;
238 }
239 
240 DWORD _RpcIhvControl(
241     WLANSVC_RPC_HANDLE hClientHandle,
242     const GUID *pInterfaceGuid,
243     DWORD Type,
244     DWORD dwInBufferSize,
245     LPBYTE pInBuffer,
246     DWORD dwOutBufferSize,
247     LPBYTE pOutBuffer,
248     LPDWORD pdwBytesReturned)
249 {
250     UNIMPLEMENTED;
251     return ERROR_CALL_NOT_IMPLEMENTED;
252 }
253 
254 DWORD _RpcScan(
255     WLANSVC_RPC_HANDLE hClientHandle,
256     const GUID *pInterfaceGuid,
257     PDOT11_SSID pDot11Ssid,
258     PWLAN_RAW_DATA pIeData)
259 {
260     PWLANSVCHANDLE lpWlanSvcHandle;
261 
262     lpWlanSvcHandle = WlanSvcGetHandleEntry(hClientHandle);
263     if (!lpWlanSvcHandle)
264     {
265         return ERROR_INVALID_HANDLE;
266     }
267 
268     /*
269     DWORD dwBytesReturned;
270     HANDLE hDevice;
271     ULONG OidCode = OID_802_11_BSSID_LIST_SCAN;
272     PNDIS_802_11_BSSID_LIST pBssIDList;
273 
274     DeviceIoControl(hDevice,
275                     IOCTL_NDIS_QUERY_GLOBAL_STATS,
276                     &OidCode,
277                     sizeof(ULONG),
278                     NULL,
279                     0,
280                     &dwBytesReturned,
281                     NULL);
282 */
283     UNIMPLEMENTED;
284     return ERROR_CALL_NOT_IMPLEMENTED;
285 }
286 
287 DWORD _RpcGetAvailableNetworkList(
288     WLANSVC_RPC_HANDLE hClientHandle,
289     const GUID *pInterfaceGuid,
290     DWORD dwFlags,
291     WLAN_AVAILABLE_NETWORK_LIST **ppAvailableNetworkList)
292 {
293     UNIMPLEMENTED;
294     return ERROR_CALL_NOT_IMPLEMENTED;
295 }
296 
297 DWORD _RpcGetNetworkBssList(
298     WLANSVC_RPC_HANDLE hClientHandle,
299     const GUID *pInterfaceGuid,
300     PDOT11_SSID pDot11Ssid,
301     short dot11BssType,
302     DWORD bSecurityEnabled,
303     LPDWORD dwBssListSize,
304     LPBYTE *ppWlanBssList)
305 {
306     UNIMPLEMENTED;
307     return ERROR_CALL_NOT_IMPLEMENTED;
308 }
309 
310 DWORD _RpcConnect(
311     WLANSVC_RPC_HANDLE hClientHandle,
312     const GUID *pInterfaceGuid,
313     const PWLAN_CONNECTION_PARAMETERS *pConnectionParameters)
314 {
315     UNIMPLEMENTED;
316     return ERROR_CALL_NOT_IMPLEMENTED;
317 }
318 
319 DWORD _RpcDisconnect(
320     WLANSVC_RPC_HANDLE hClientHandle,
321     const GUID *pInterfaceGUID)
322 {
323     UNIMPLEMENTED;
324     return ERROR_CALL_NOT_IMPLEMENTED;
325 }
326 
327 DWORD _RpcRegisterNotification(
328     WLANSVC_RPC_HANDLE hClientHandle,
329     DWORD arg_2,
330     LPDWORD pdwPrevNotifSource)
331 {
332     UNIMPLEMENTED;
333     return ERROR_CALL_NOT_IMPLEMENTED;
334 }
335 
336 DWORD _RpcAsyncGetNotification(
337     WLANSVC_RPC_HANDLE hClientHandle,
338     PWLAN_NOTIFICATION_DATA *NotificationData)
339 {
340     UNIMPLEMENTED;
341     return ERROR_CALL_NOT_IMPLEMENTED;
342 }
343 
344 DWORD _RpcSetProfileEapUserData(
345     WLANSVC_RPC_HANDLE hClientHandle,
346     const GUID *pInterfaceGuid,
347     wchar_t *strProfileName,
348     EAP_METHOD_TYPE MethodType,
349     DWORD dwFlags,
350     DWORD dwEapUserDataSize,
351     LPBYTE pbEapUserData)
352 {
353     UNIMPLEMENTED;
354     return ERROR_CALL_NOT_IMPLEMENTED;
355 }
356 
357 DWORD _RpcSetProfile(
358     WLANSVC_RPC_HANDLE hClientHandle,
359     const GUID *pInterfaceGuid,
360     DWORD dwFlags,
361     wchar_t *strProfileXml,
362     wchar_t *strAllUserProfileSecurity,
363     BOOL bOverwrite,
364     LPDWORD pdwReasonCode)
365 {
366     UNIMPLEMENTED;
367     return ERROR_CALL_NOT_IMPLEMENTED;
368 }
369 
370 DWORD _RpcGetProfile(
371     WLANSVC_RPC_HANDLE hClientHandle,
372     const GUID *pInterfaceGuid,
373     wchar_t *strProfileName,
374     wchar_t **pstrProfileXml,
375     LPDWORD pdwFlags,
376     LPDWORD pdwGrantedAccess)
377 {
378     UNIMPLEMENTED;
379     return ERROR_CALL_NOT_IMPLEMENTED;
380 }
381 
382 DWORD _RpcDeleteProfile(
383     WLANSVC_RPC_HANDLE hClientHandle,
384     const GUID *pInterfaceGuid,
385     const wchar_t *strProfileName)
386 {
387     UNIMPLEMENTED;
388     return ERROR_CALL_NOT_IMPLEMENTED;
389 }
390 
391 DWORD _RpcRenameProfile(
392     WLANSVC_RPC_HANDLE hClientHandle,
393     const GUID *pInterfaceGuid,
394     const wchar_t *strOldProfileName,
395     const wchar_t *strNewProfileName)
396 {
397     UNIMPLEMENTED;
398     return ERROR_CALL_NOT_IMPLEMENTED;
399 }
400 
401 DWORD _RpcSetProfileList(
402     WLANSVC_RPC_HANDLE hClientHandle,
403     const GUID *pInterfaceGuid,
404     DWORD dwItems,
405     BYTE **strProfileNames)
406 {
407     UNIMPLEMENTED;
408     return ERROR_CALL_NOT_IMPLEMENTED;
409 }
410 
411 DWORD _RpcGetProfileList(
412     WLANSVC_RPC_HANDLE hClientHandle,
413     const GUID *pInterfaceGuid,
414     PWLAN_PROFILE_INFO_LIST *ppProfileList)
415 {
416     UNIMPLEMENTED;
417     return ERROR_CALL_NOT_IMPLEMENTED;
418 }
419 
420 DWORD _RpcSetProfilePosition(
421     WLANSVC_RPC_HANDLE hClientHandle,
422     const GUID *pInterfaceGuid,
423     wchar_t *strProfileName,
424     DWORD dwPosition)
425 {
426     UNIMPLEMENTED;
427     return ERROR_CALL_NOT_IMPLEMENTED;
428 }
429 
430 DWORD _RpcSetProfileCustomUserData(
431     WLANSVC_RPC_HANDLE hClientHandle,
432     const GUID *pInterfaceGuid,
433     wchar_t *strProfileName,
434     DWORD dwDataSize,
435     LPBYTE pData)
436 {
437     UNIMPLEMENTED;
438     return ERROR_CALL_NOT_IMPLEMENTED;
439 }
440 
441 DWORD _RpcGetProfileCustomUserData(
442     WLANSVC_RPC_HANDLE hClientHandle,
443     const GUID *pInterfaceGuid,
444     wchar_t *strProfileName,
445     LPDWORD dwDataSize,
446     LPBYTE *pData)
447 {
448     UNIMPLEMENTED;
449     return ERROR_CALL_NOT_IMPLEMENTED;
450 }
451 
452 DWORD _RpcSetFilterList(
453     WLANSVC_RPC_HANDLE hClientHandle,
454     short wlanFilterListType,
455     PDOT11_NETWORK_LIST pNetworkList)
456 {
457     UNIMPLEMENTED;
458     return ERROR_CALL_NOT_IMPLEMENTED;
459 }
460 
461 DWORD _RpcGetFilterList(
462     WLANSVC_RPC_HANDLE hClientHandle,
463     short wlanFilterListType,
464     PDOT11_NETWORK_LIST *pNetworkList)
465 {
466     UNIMPLEMENTED;
467     return ERROR_CALL_NOT_IMPLEMENTED;
468 }
469 
470 DWORD _RpcSetPsdIEDataList(
471     WLANSVC_RPC_HANDLE hClientHandle,
472     wchar_t *strFormat,
473     DWORD dwDataListSize,
474     LPBYTE pPsdIEDataList)
475 {
476     UNIMPLEMENTED;
477     return ERROR_CALL_NOT_IMPLEMENTED;
478 }
479 
480 DWORD _RpcSaveTemporaryProfile(
481     WLANSVC_RPC_HANDLE hClientHandle,
482     const GUID *pInterfaceGuid,
483     wchar_t *strProfileName,
484     wchar_t *strAllUserProfileSecurity,
485     DWORD dwFlags,
486     BOOL bOverWrite)
487 {
488     UNIMPLEMENTED;
489     return ERROR_CALL_NOT_IMPLEMENTED;
490 }
491 
492 DWORD _RpcIsUIRequestPending(
493     wchar_t *arg_1,
494     const GUID *pInterfaceGuid,
495     struct_C *arg_3,
496     LPDWORD arg_4)
497 {
498     UNIMPLEMENTED;
499     return ERROR_CALL_NOT_IMPLEMENTED;
500 }
501 
502 DWORD _RpcSetUIForwardingNetworkList(
503     wchar_t *arg_1,
504     GUID *arg_2,
505     DWORD dwSize,
506     GUID *arg_4)
507 {
508     UNIMPLEMENTED;
509     return ERROR_CALL_NOT_IMPLEMENTED;
510 }
511 
512 DWORD _RpcIsNetworkSuppressed(
513     wchar_t *arg_1,
514     DWORD arg_2,
515     const GUID *pInterfaceGuid,
516     LPDWORD arg_4)
517 {
518     UNIMPLEMENTED;
519     return ERROR_CALL_NOT_IMPLEMENTED;
520 }
521 
522 DWORD _RpcRemoveUIForwardingNetworkList(
523     wchar_t *arg_1,
524     const GUID *pInterfaceGuid)
525 {
526     UNIMPLEMENTED;
527     return ERROR_CALL_NOT_IMPLEMENTED;
528 }
529 
530 DWORD _RpcQueryExtUIRequest(
531     wchar_t *arg_1,
532     GUID *arg_2,
533     GUID *arg_3,
534     short arg_4,
535     GUID *pInterfaceGuid,
536     struct_C **arg_6)
537 {
538     UNIMPLEMENTED;
539     return ERROR_CALL_NOT_IMPLEMENTED;
540 }
541 
542 DWORD _RpcUIResponse(
543     wchar_t *arg_1,
544     struct_C *arg_2,
545     struct_D *arg_3)
546 {
547     UNIMPLEMENTED;
548     return ERROR_CALL_NOT_IMPLEMENTED;
549 }
550 
551 DWORD _RpcGetProfileKeyInfo(
552     wchar_t *arg_1,
553     DWORD arg_2,
554     const GUID *pInterfaceGuid,
555     wchar_t *arg_4,
556     DWORD arg_5,
557     LPDWORD arg_6,
558     char *arg_7,
559     LPDWORD arg_8)
560 {
561     UNIMPLEMENTED;
562     return ERROR_CALL_NOT_IMPLEMENTED;
563 }
564 
565 DWORD _RpcAsyncDoPlap(
566     wchar_t *arg_1,
567     const GUID *pInterfaceGuid,
568     wchar_t *arg_3,
569     DWORD dwSize,
570     struct_E arg_5[])
571 {
572     UNIMPLEMENTED;
573     return ERROR_CALL_NOT_IMPLEMENTED;
574 }
575 
576 DWORD _RpcQueryPlapCredentials(
577     wchar_t *arg_1,
578     LPDWORD dwSize,
579     struct_E **arg_3,
580     wchar_t **arg_4,
581     GUID *pInterfaceGuid,
582     LPDWORD arg_6,
583     LPDWORD arg_7,
584     LPDWORD arg_8,
585     LPDWORD arg_9)
586 {
587     UNIMPLEMENTED;
588     return ERROR_CALL_NOT_IMPLEMENTED;
589 }
590 
591 DWORD _RpcCancelPlap(
592     wchar_t *arg_1,
593     const GUID *pInterfaceGuid)
594 {
595     UNIMPLEMENTED;
596     return ERROR_CALL_NOT_IMPLEMENTED;
597 }
598 
599 DWORD _RpcSetSecuritySettings(
600     WLANSVC_RPC_HANDLE hClientHandle,
601     WLAN_SECURABLE_OBJECT SecurableObject,
602     const wchar_t *strModifiedSDDL)
603 {
604     UNIMPLEMENTED;
605     return ERROR_CALL_NOT_IMPLEMENTED;
606 }
607 
608 DWORD _RpcGetSecuritySettings(
609     WLANSVC_RPC_HANDLE hClientHandle,
610     WLAN_SECURABLE_OBJECT SecurableObject,
611     WLAN_OPCODE_VALUE_TYPE *pValueType,
612     wchar_t **pstrCurrentSDDL,
613     LPDWORD pdwGrantedAccess)
614 {
615     UNIMPLEMENTED;
616     return ERROR_CALL_NOT_IMPLEMENTED;
617 }
618 
619 void __RPC_FAR * __RPC_USER midl_user_allocate(SIZE_T len)
620 {
621     return HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len);
622 }
623 
624 
625 void __RPC_USER midl_user_free(void __RPC_FAR * ptr)
626 {
627     HeapFree(GetProcessHeap(), 0, ptr);
628 }
629 
630 
631 void __RPC_USER WLANSVC_RPC_HANDLE_rundown(WLANSVC_RPC_HANDLE hClientHandle)
632 {
633 }
634 
635