[NDISUIO]
[reactos.git] / base / applications / network / wlanconf / wlanconf.c
1 /*
2 * PROJECT: ReactOS WLAN command-line configuration utility
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: base/applications/network/wlanconf/wlanconf.c
5 * PURPOSE: Allows WLAN configuration via the command prompt
6 * COPYRIGHT: Copyright 2012 Cameron Gutman (cameron.gutman@reactos.org)
7 */
8
9 #include <windows.h>
10 #include <tchar.h>
11 #include <stdio.h>
12 #include <stdlib.h>
13 #include <ntddndis.h>
14 #include <nuiouser.h>
15
16 BOOL bScan = FALSE;
17
18 BOOL bConnect = FALSE;
19 char* sSsid = NULL;
20 char* sWepKey = NULL;
21 BOOL bAdhoc = FALSE;
22
23 BOOL bDisconnect = FALSE;
24
25 DWORD DoFormatMessage(DWORD ErrorCode)
26 {
27 LPVOID lpMsgBuf;
28 DWORD RetVal;
29
30 if ((RetVal = FormatMessage(
31 FORMAT_MESSAGE_ALLOCATE_BUFFER |
32 FORMAT_MESSAGE_FROM_SYSTEM |
33 FORMAT_MESSAGE_IGNORE_INSERTS,
34 NULL,
35 ErrorCode,
36 MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), /* Default language */
37 (LPTSTR) &lpMsgBuf,
38 0,
39 NULL )))
40 {
41 _tprintf(_T("%s"), (LPTSTR)lpMsgBuf);
42
43 LocalFree(lpMsgBuf);
44
45 /* return number of TCHAR's stored in output buffer
46 * excluding '\0' - as FormatMessage does*/
47 return RetVal;
48 }
49 else
50 return 0;
51 }
52
53 HANDLE
54 OpenDriverHandle(VOID)
55 {
56 HANDLE hDriver;
57 DWORD dwBytesReturned;
58 BOOL bSuccess;
59
60 /* Open a handle to the NDISUIO driver */
61 hDriver = CreateFileW(NDISUIO_DEVICE_NAME,
62 GENERIC_READ | GENERIC_WRITE,
63 0,
64 NULL,
65 OPEN_EXISTING,
66 FILE_ATTRIBUTE_NORMAL,
67 NULL);
68 if (hDriver == INVALID_HANDLE_VALUE)
69 return INVALID_HANDLE_VALUE;
70
71 /* Wait for binds */
72 bSuccess = DeviceIoControl(hDriver,
73 IOCTL_NDISUIO_BIND_WAIT,
74 NULL,
75 0,
76 NULL,
77 0,
78 &dwBytesReturned,
79 NULL);
80 if (!bSuccess)
81 {
82 CloseHandle(hDriver);
83 return INVALID_HANDLE_VALUE;
84 }
85
86 return hDriver;
87 }
88
89 BOOL
90 IsWlanAdapter(HANDLE hAdapter)
91 {
92 BOOL bSuccess;
93 DWORD dwBytesReturned;
94 NDISUIO_QUERY_OID QueryOid;
95
96 /* NDIS 5.1 WLAN drivers must support this OID */
97 QueryOid.Oid = OID_GEN_PHYSICAL_MEDIUM;
98
99 bSuccess = DeviceIoControl(hAdapter,
100 IOCTL_NDISUIO_QUERY_OID_VALUE,
101 &QueryOid,
102 sizeof(QueryOid),
103 &QueryOid,
104 sizeof(QueryOid),
105 &dwBytesReturned,
106 NULL);
107 if (!bSuccess || *(PULONG)QueryOid.Data != NdisPhysicalMediumWirelessLan)
108 return FALSE;
109
110 return TRUE;
111 }
112
113 HANDLE
114 OpenAdapterHandle(DWORD Index)
115 {
116 HANDLE hDriver;
117 BOOL bSuccess;
118 DWORD dwBytesReturned;
119 DWORD QueryBindingSize = sizeof(NDISUIO_QUERY_BINDING) + (1024 * sizeof(WCHAR));
120 PNDISUIO_QUERY_BINDING QueryBinding;
121
122 /* Open the driver handle */
123 hDriver = OpenDriverHandle();
124 if (hDriver == INVALID_HANDLE_VALUE)
125 return INVALID_HANDLE_VALUE;
126
127 /* Allocate the binding struct */
128 QueryBinding = HeapAlloc(GetProcessHeap(), 0, QueryBindingSize);
129 if (!QueryBinding)
130 {
131 CloseHandle(hDriver);
132 return INVALID_HANDLE_VALUE;
133 }
134
135 /* Query for bindable adapters */
136 QueryBinding->BindingIndex = 0;
137 do {
138 bSuccess = DeviceIoControl(hDriver,
139 IOCTL_NDISUIO_QUERY_BINDING,
140 QueryBinding,
141 QueryBindingSize,
142 QueryBinding,
143 QueryBindingSize,
144 &dwBytesReturned,
145 NULL);
146 if (QueryBinding->BindingIndex == Index)
147 break;
148 QueryBinding->BindingIndex++;
149 } while (bSuccess);
150
151 if (!bSuccess)
152 {
153 HeapFree(GetProcessHeap(), 0, QueryBinding);
154 CloseHandle(hDriver);
155 return INVALID_HANDLE_VALUE;
156 }
157
158 /* Bind to the adapter */
159 bSuccess = DeviceIoControl(hDriver,
160 IOCTL_NDISUIO_OPEN_DEVICE,
161 (PUCHAR)QueryBinding + QueryBinding->DeviceNameOffset,
162 QueryBinding->DeviceNameLength,
163 NULL,
164 0,
165 &dwBytesReturned,
166 NULL);
167 HeapFree(GetProcessHeap(), 0, QueryBinding);
168
169 if (!bSuccess)
170 {
171 CloseHandle(hDriver);
172 return INVALID_HANDLE_VALUE;
173 }
174
175 return hDriver;
176 }
177
178 /* Only works with the first adapter for now */
179 HANDLE
180 OpenWlanAdapter(VOID)
181 {
182 DWORD dwCurrentIndex;
183 HANDLE hCurrentAdapter;
184
185 for (dwCurrentIndex = 0; ; dwCurrentIndex++)
186 {
187 hCurrentAdapter = OpenAdapterHandle(dwCurrentIndex);
188 if (hCurrentAdapter == INVALID_HANDLE_VALUE)
189 break;
190
191 if (IsWlanAdapter(hCurrentAdapter))
192 return hCurrentAdapter;
193 else
194 CloseHandle(hCurrentAdapter);
195 }
196
197 return INVALID_HANDLE_VALUE;
198 }
199
200 BOOL
201 WlanDisconnect(HANDLE hAdapter)
202 {
203 BOOL bSuccess;
204 DWORD dwBytesReturned;
205 NDISUIO_SET_OID SetOid;
206
207 SetOid.Oid = OID_802_11_DISASSOCIATE;
208
209 bSuccess = DeviceIoControl(hAdapter,
210 IOCTL_NDISUIO_SET_OID_VALUE,
211 &SetOid,
212 sizeof(SetOid),
213 NULL,
214 0,
215 &dwBytesReturned,
216 NULL);
217
218 return bSuccess;
219 }
220
221 static
222 UCHAR
223 CharToHex(CHAR Char)
224 {
225 Char = toupper(Char);
226
227 switch (Char)
228 {
229 case '0':
230 return 0x0;
231 case '1':
232 return 0x1;
233 case '2':
234 return 0x2;
235 case '3':
236 return 0x3;
237 case '4':
238 return 0x4;
239 case '5':
240 return 0x5;
241 case '6':
242 return 0x6;
243 case '7':
244 return 0x7;
245 case '8':
246 return 0x8;
247 case '9':
248 return 0x9;
249 case 'A':
250 return 0xA;
251 case 'B':
252 return 0xB;
253 case 'C':
254 return 0xC;
255 case 'D':
256 return 0xD;
257 case 'E':
258 return 0xE;
259 case 'F':
260 return 0xF;
261 default:
262 return 0;
263 }
264 }
265
266 BOOL
267 WlanConnect(HANDLE hAdapter)
268 {
269 BOOL bSuccess;
270 DWORD dwBytesReturned, SetOidSize;
271 PNDISUIO_SET_OID SetOid;
272 PNDIS_802_11_SSID Ssid;
273 DWORD i;
274
275 SetOidSize = sizeof(NDISUIO_SET_OID);
276 SetOid = HeapAlloc(GetProcessHeap(), 0, SetOidSize);
277 if (!SetOid)
278 return FALSE;
279
280 /* Set the network mode */
281 SetOid->Oid = OID_802_11_INFRASTRUCTURE_MODE;
282 *(PULONG)SetOid->Data = bAdhoc ? Ndis802_11IBSS : Ndis802_11Infrastructure;
283
284 bSuccess = DeviceIoControl(hAdapter,
285 IOCTL_NDISUIO_SET_OID_VALUE,
286 SetOid,
287 SetOidSize,
288 NULL,
289 0,
290 &dwBytesReturned,
291 NULL);
292 if (!bSuccess)
293 {
294 HeapFree(GetProcessHeap(), 0, SetOid);
295 return FALSE;
296 }
297
298 /* Set the authentication mode */
299 SetOid->Oid = OID_802_11_AUTHENTICATION_MODE;
300 *(PULONG)SetOid->Data = sWepKey ? Ndis802_11AuthModeShared : Ndis802_11AuthModeOpen;
301
302 bSuccess = DeviceIoControl(hAdapter,
303 IOCTL_NDISUIO_SET_OID_VALUE,
304 SetOid,
305 SetOidSize,
306 NULL,
307 0,
308 &dwBytesReturned,
309 NULL);
310 if (!bSuccess)
311 {
312 HeapFree(GetProcessHeap(), 0, SetOid);
313 return FALSE;
314 }
315
316 if (sWepKey)
317 {
318 PNDIS_802_11_WEP WepData;
319
320 HeapFree(GetProcessHeap(), 0, SetOid);
321
322 SetOidSize = sizeof(NDISUIO_SET_OID) + FIELD_OFFSET(NDIS_802_11_WEP, KeyMaterial) +
323 (strlen(sWepKey) >> 2);
324 SetOid = HeapAlloc(GetProcessHeap(), 0, SetOidSize);
325 if (!SetOid)
326 return FALSE;
327
328 /* Add the WEP key */
329 SetOid->Oid = OID_802_11_ADD_WEP;
330 WepData = (PNDIS_802_11_WEP)SetOid->Data;
331
332 WepData->KeyIndex = 0x80000000;
333 WepData->KeyLength = strlen(sWepKey) >> 2;
334 WepData->Length = FIELD_OFFSET(NDIS_802_11_WEP, KeyMaterial) + WepData->KeyLength;
335
336 /* Assemble the hex key */
337 i = 0;
338 while (sWepKey[i << 2] != '\0')
339 {
340 WepData->KeyMaterial[i] = CharToHex(sWepKey[i << 2]) << 4;
341 WepData->KeyMaterial[i] |= CharToHex(sWepKey[(i << 2) + 1]);
342 i++;
343 }
344
345 bSuccess = DeviceIoControl(hAdapter,
346 IOCTL_NDISUIO_SET_OID_VALUE,
347 SetOid,
348 SetOidSize,
349 NULL,
350 0,
351 &dwBytesReturned,
352 NULL);
353 if (!bSuccess)
354 {
355 HeapFree(GetProcessHeap(), 0, SetOid);
356 return FALSE;
357 }
358 }
359
360 /* Set the encryption status */
361 SetOid->Oid = OID_802_11_WEP_STATUS;
362 *(PULONG)SetOid->Data = sWepKey ? Ndis802_11WEPEnabled : Ndis802_11WEPDisabled;
363
364 bSuccess = DeviceIoControl(hAdapter,
365 IOCTL_NDISUIO_SET_OID_VALUE,
366 SetOid,
367 SetOidSize,
368 NULL,
369 0,
370 &dwBytesReturned,
371 NULL);
372 if (!bSuccess)
373 {
374 HeapFree(GetProcessHeap(), 0, SetOid);
375 return FALSE;
376 }
377
378 HeapFree(GetProcessHeap(), 0, SetOid);
379 SetOidSize = sizeof(NDISUIO_SET_OID) + sizeof(NDIS_802_11_MAC_ADDRESS);
380 SetOid = HeapAlloc(GetProcessHeap(), 0, SetOidSize);
381 if (!SetOid)
382 return FALSE;
383
384 /* Set the BSSID */
385 SetOid->Oid = OID_802_11_BSSID;
386 RtlFillMemory(SetOid->Data, sizeof(NDIS_802_11_MAC_ADDRESS), 0xFF);
387
388 bSuccess = DeviceIoControl(hAdapter,
389 IOCTL_NDISUIO_SET_OID_VALUE,
390 SetOid,
391 SetOidSize,
392 NULL,
393 0,
394 &dwBytesReturned,
395 NULL);
396 if (!bSuccess)
397 {
398 HeapFree(GetProcessHeap(), 0, SetOid);
399 return FALSE;
400 }
401
402 HeapFree(GetProcessHeap(), 0, SetOid);
403 SetOidSize = sizeof(NDISUIO_SET_OID) + sizeof(NDIS_802_11_SSID);
404 SetOid = HeapAlloc(GetProcessHeap(), 0, SetOidSize);
405 if (!SetOid)
406 return FALSE;
407
408 /* Finally, set the SSID */
409 SetOid->Oid = OID_802_11_SSID;
410 Ssid = (PNDIS_802_11_SSID)SetOid->Data;
411
412 RtlCopyMemory(Ssid->Ssid, sSsid, strlen(sSsid));
413 Ssid->SsidLength = strlen(sSsid);
414
415 bSuccess = DeviceIoControl(hAdapter,
416 IOCTL_NDISUIO_SET_OID_VALUE,
417 SetOid,
418 SetOidSize,
419 NULL,
420 0,
421 &dwBytesReturned,
422 NULL);
423
424 HeapFree(GetProcessHeap(), 0, SetOid);
425
426 return bSuccess;
427 }
428
429 BOOL
430 WlanScan(HANDLE hAdapter)
431 {
432 BOOL bSuccess;
433 DWORD dwBytesReturned;
434 NDISUIO_SET_OID SetOid;
435 PNDISUIO_QUERY_OID QueryOid;
436 DWORD QueryOidSize;
437 PNDIS_802_11_BSSID_LIST BssidList;
438 DWORD i, j;
439
440 SetOid.Oid = OID_802_11_BSSID_LIST_SCAN;
441
442 /* Send the scan OID */
443 bSuccess = DeviceIoControl(hAdapter,
444 IOCTL_NDISUIO_SET_OID_VALUE,
445 &SetOid,
446 sizeof(SetOid),
447 NULL,
448 0,
449 &dwBytesReturned,
450 NULL);
451 if (!bSuccess)
452 return FALSE;
453
454 /* Allocate space for 15 networks to be returned */
455 QueryOidSize = sizeof(NDISUIO_QUERY_OID) + (sizeof(NDIS_WLAN_BSSID) * 15);
456 QueryOid = HeapAlloc(GetProcessHeap(), 0, QueryOidSize);
457 if (!QueryOid)
458 return FALSE;
459
460 QueryOid->Oid = OID_802_11_BSSID_LIST;
461 BssidList = (PNDIS_802_11_BSSID_LIST)QueryOid->Data;
462
463 bSuccess = DeviceIoControl(hAdapter,
464 IOCTL_NDISUIO_QUERY_OID_VALUE,
465 QueryOid,
466 QueryOidSize,
467 QueryOid,
468 QueryOidSize,
469 &dwBytesReturned,
470 NULL);
471 if (!bSuccess)
472 {
473 HeapFree(GetProcessHeap(), 0, QueryOid);
474 return FALSE;
475 }
476
477 if (BssidList->NumberOfItems == 0)
478 {
479 _tprintf(_T("No networks found in range\n"));
480 }
481 else
482 {
483 PNDIS_WLAN_BSSID BssidInfo = BssidList->Bssid;
484 for (i = 0; i < BssidList->NumberOfItems; i++)
485 {
486 PNDIS_802_11_SSID Ssid = &BssidInfo->Ssid;
487 NDIS_802_11_RSSI Rssi = BssidInfo->Rssi;
488 NDIS_802_11_NETWORK_INFRASTRUCTURE NetworkType = BssidInfo->InfrastructureMode;
489 CHAR SsidBuffer[NDIS_802_11_LENGTH_SSID + 1];
490
491 /* SSID member is a non-null terminated ASCII string */
492 RtlCopyMemory(SsidBuffer, Ssid->Ssid, Ssid->SsidLength);
493 SsidBuffer[Ssid->SsidLength] = 0;
494
495 _tprintf(_T("\nSSID: %s\n"
496 "Encrypted: %s"
497 "Network Type: %s\n"
498 "RSSI: %i dBm\n"
499 "Supported Rates (Mbps): "),
500 SsidBuffer,
501 BssidInfo->Privacy == 0 ? "No" : "Yes",
502 NetworkType == Ndis802_11IBSS ? "Adhoc" : "Infrastructure",
503 (int)Rssi);
504
505 for (j = 0; j < NDIS_802_11_LENGTH_RATES; j++)
506 {
507 if (BssidInfo->SupportedRates[j] != 0)
508 {
509 /* SupportedRates are in units of .5 */
510 _tprintf(_T("%d "), (BssidInfo->SupportedRates[j] << 2));
511 }
512 }
513 _tprintf(_T("\n"));
514
515 /* Move to the next entry */
516 BssidInfo = (PNDIS_WLAN_BSSID)((PUCHAR)BssidInfo + BssidInfo->Length);
517 }
518 }
519
520 HeapFree(GetProcessHeap(), 0, QueryOid);
521
522 return bSuccess;
523 }
524
525 VOID Usage()
526 {
527 _tprintf(_T("\nConfigures a WLAN adapter.\n\n"
528 "WLANCONF [-c SSID [-w WEP] [-a]] [-d] [-s]\n\n"
529 " -c SSID Connects to a supplied SSID.\n"
530 " -w WEP Specifies a WEP key to use.\n"
531 " -a Specifies the target network is ad-hoc\n"
532 " -d Disconnects from the current AP.\n"
533 " -s Scans and displays a list of access points in range.\n"));
534 }
535
536
537 BOOL ParseCmdline(int argc, char* argv[])
538 {
539 INT i;
540
541 for (i = 1; i < argc; i++)
542 {
543 if ((argc > 1) && (argv[i][0] == '-'))
544 {
545 TCHAR c;
546
547 while ((c = *++argv[i]) != '\0')
548 {
549 switch (c)
550 {
551 case 's':
552 bScan = TRUE;
553 break;
554 case 'd':
555 bDisconnect = TRUE;
556 break;
557 case 'c':
558 bConnect = TRUE;
559 sSsid = argv[++i];
560 break;
561 case 'w':
562 sWepKey = argv[++i];
563 break;
564 case 'a':
565 bAdhoc = TRUE;
566 break;
567 default :
568 Usage();
569 return FALSE;
570 }
571 }
572 }
573 }
574
575 if (!bScan && !bDisconnect && !bConnect)
576 {
577 Usage();
578 return FALSE;
579 }
580
581 return TRUE;
582 }
583
584 int main(int argc, char* argv[])
585 {
586 HANDLE hAdapter;
587
588 if (!ParseCmdline(argc, argv))
589 return -1;
590
591 hAdapter = OpenWlanAdapter();
592 if (hAdapter == INVALID_HANDLE_VALUE)
593 {
594 DoFormatMessage(GetLastError());
595 return -1;
596 }
597
598 if (bScan)
599 {
600 if (!WlanScan(hAdapter))
601 {
602 DoFormatMessage(GetLastError());
603 CloseHandle(hAdapter);
604 return -1;
605 }
606 }
607 else if (bDisconnect)
608 {
609 if (!WlanDisconnect(hAdapter))
610 {
611 DoFormatMessage(GetLastError());
612 CloseHandle(hAdapter);
613 return -1;
614 }
615 }
616 else
617 {
618 if (!WlanConnect(hAdapter))
619 {
620 DoFormatMessage(GetLastError());
621 CloseHandle(hAdapter);
622 return -1;
623 }
624 }
625
626 CloseHandle(hAdapter);
627 return 0;
628 }