]> git.ipfire.org Git - thirdparty/hostap.git/blob - wlantest/wlantest_cli.c
projects / thirdparty / hostap.git / blob
? search:


ae84102e5cfc672847ac51144585d27ce868726d
[thirdparty/hostap.git] / wlantest / wlantest_cli.c
1 /*
2 * wlantest controller
3 * Copyright (c) 2010-2013, 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 #include "utils/includes.h"
10 #include <sys/un.h>
11
12 #include "utils/common.h"
13 #include "utils/eloop.h"
14 #include "utils/edit.h"
15 #include "wlantest_ctrl.h"
16
17
18 static int get_cmd_arg_num(const char *str, int pos)
19 {
20 int arg = 0, i;
21
22 for (i = 0; i <= pos; i++) {
23 if (str[i] != ' ') {
24 arg++;
25 while (i <= pos && str[i] != ' ')
26 i++;
27 }
28 }
29
30 if (arg > 0)
31 arg--;
32 return arg;
33 }
34
35
36 static int get_prev_arg_pos(const char *str, int pos)
37 {
38 while (pos > 0 && str[pos - 1] != ' ')
39 pos--;
40 while (pos > 0 && str[pos - 1] == ' ')
41 pos--;
42 while (pos > 0 && str[pos - 1] != ' ')
43 pos--;
44 return pos;
45 }
46
47
48 static u8 * attr_get(u8 *buf, size_t buflen, enum wlantest_ctrl_attr attr,
49 size_t *len)
50 {
51 u8 *pos = buf;
52
53 while (pos + 8 <= buf + buflen) {
54 enum wlantest_ctrl_attr a;
55 size_t alen;
56 a = WPA_GET_BE32(pos);
57 pos += 4;
58 alen = WPA_GET_BE32(pos);
59 pos += 4;
60 if (pos + alen > buf + buflen) {
61 printf("Invalid control message attribute\n");
62 return NULL;
63 }
64 if (a == attr) {
65 *len = alen;
66 return pos;
67 }
68 pos += alen;
69 }
70
71 return NULL;
72 }
73
74
75 static u8 * attr_hdr_add(u8 *pos, u8 *end, enum wlantest_ctrl_attr attr,
76 size_t len)
77 {
78 if (pos == NULL || end - pos < 8 + len)
79 return NULL;
80 WPA_PUT_BE32(pos, attr);
81 pos += 4;
82 WPA_PUT_BE32(pos, len);
83 pos += 4;
84 return pos;
85 }
86
87
88 static u8 * attr_add_str(u8 *pos, u8 *end, enum wlantest_ctrl_attr attr,
89 const char *str)
90 {
91 size_t len = os_strlen(str);
92
93 if (pos == NULL || end - pos < 8 + len)
94 return NULL;
95 WPA_PUT_BE32(pos, attr);
96 pos += 4;
97 WPA_PUT_BE32(pos, len);
98 pos += 4;
99 os_memcpy(pos, str, len);
100 pos += len;
101 return pos;
102 }
103
104
105 static u8 * attr_add_be32(u8 *pos, u8 *end, enum wlantest_ctrl_attr attr,
106 u32 val)
107 {
108 if (pos == NULL || end - pos < 12)
109 return NULL;
110 WPA_PUT_BE32(pos, attr);
111 pos += 4;
112 WPA_PUT_BE32(pos, 4);
113 pos += 4;
114 WPA_PUT_BE32(pos, val);
115 pos += 4;
116 return pos;
117 }
118
119
120 static int cmd_send_and_recv(int s, const u8 *cmd, size_t cmd_len,
121 u8 *resp, size_t max_resp_len)
122 {
123 int res;
124 enum wlantest_ctrl_cmd cmd_resp;
125
126 if (send(s, cmd, cmd_len, 0) < 0)
127 return -1;
128 res = recv(s, resp, max_resp_len, 0);
129 if (res < 4)
130 return -1;
131
132 cmd_resp = WPA_GET_BE32(resp);
133 if (cmd_resp == WLANTEST_CTRL_SUCCESS)
134 return res;
135
136 if (cmd_resp == WLANTEST_CTRL_UNKNOWN_CMD)
137 printf("Unknown command\n");
138 else if (cmd_resp == WLANTEST_CTRL_INVALID_CMD)
139 printf("Invalid command\n");
140
141 return -1;
142 }
143
144
145 static int cmd_simple(int s, enum wlantest_ctrl_cmd cmd)
146 {
147 u8 buf[4];
148 int res;
149 WPA_PUT_BE32(buf, cmd);
150 res = cmd_send_and_recv(s, buf, sizeof(buf), buf, sizeof(buf));
151 return res < 0 ? -1 : 0;
152 }
153
154
155 static char ** get_bssid_list(int s)
156 {
157 u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
158 u8 buf[4];
159 u8 *bssid;
160 size_t len;
161 int rlen, i;
162 char **res;
163
164 WPA_PUT_BE32(buf, WLANTEST_CTRL_LIST_BSS);
165 rlen = cmd_send_and_recv(s, buf, sizeof(buf), resp, sizeof(resp));
166 if (rlen < 0)
167 return NULL;
168
169 bssid = attr_get(resp + 4, rlen - 4, WLANTEST_ATTR_BSSID, &len);
170 if (bssid == NULL)
171 return NULL;
172
173 res = os_calloc(len / ETH_ALEN + 1, sizeof(char *));
174 if (res == NULL)
175 return NULL;
176 for (i = 0; i < len / ETH_ALEN; i++) {
177 res[i] = os_zalloc(18);
178 if (res[i] == NULL)
179 break;
180 os_snprintf(res[i], 18, MACSTR, MAC2STR(bssid + ETH_ALEN * i));
181 }
182
183 return res;
184 }
185
186
187 static char ** get_sta_list(int s, const u8 *bssid, int add_bcast)
188 {
189 u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
190 u8 buf[100], *pos, *end;
191 u8 *addr;
192 size_t len;
193 int rlen, i;
194 char **res;
195
196 pos = buf;
197 end = buf + sizeof(buf);
198 WPA_PUT_BE32(pos, WLANTEST_CTRL_LIST_STA);
199 pos += 4;
200 pos = attr_hdr_add(pos, end, WLANTEST_ATTR_BSSID, ETH_ALEN);
201 os_memcpy(pos, bssid, ETH_ALEN);
202 pos += ETH_ALEN;
203 rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
204 if (rlen < 0)
205 return NULL;
206
207 addr = attr_get(resp + 4, rlen - 4, WLANTEST_ATTR_STA_ADDR, &len);
208 if (addr == NULL)
209 return NULL;
210
211 res = os_calloc(len / ETH_ALEN + 1 + add_bcast, sizeof(char *));
212 if (res == NULL)
213 return NULL;
214 for (i = 0; i < len / ETH_ALEN; i++) {
215 res[i] = os_zalloc(18);
216 if (res[i] == NULL)
217 break;
218 os_snprintf(res[i], 18, MACSTR, MAC2STR(addr + ETH_ALEN * i));
219 }
220 if (add_bcast)
221 res[i] = os_strdup("ff:ff:ff:ff:ff:ff");
222
223 return res;
224 }
225
226
227 static int cmd_ping(int s, int argc, char *argv[])
228 {
229 int res = cmd_simple(s, WLANTEST_CTRL_PING);
230 if (res == 0)
231 printf("PONG\n");
232 return res == 0;
233 }
234
235
236 static int cmd_terminate(int s, int argc, char *argv[])
237 {
238 return cmd_simple(s, WLANTEST_CTRL_TERMINATE);
239 }
240
241
242 static int cmd_list_bss(int s, int argc, char *argv[])
243 {
244 u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
245 u8 buf[4];
246 u8 *bssid;
247 size_t len;
248 int rlen, i;
249
250 WPA_PUT_BE32(buf, WLANTEST_CTRL_LIST_BSS);
251 rlen = cmd_send_and_recv(s, buf, sizeof(buf), resp, sizeof(resp));
252 if (rlen < 0)
253 return -1;
254
255 bssid = attr_get(resp + 4, rlen - 4, WLANTEST_ATTR_BSSID, &len);
256 if (bssid == NULL)
257 return -1;
258
259 for (i = 0; i < len / ETH_ALEN; i++)
260 printf(MACSTR " ", MAC2STR(bssid + ETH_ALEN * i));
261 printf("\n");
262
263 return 0;
264 }
265
266
267 static int cmd_list_sta(int s, int argc, char *argv[])
268 {
269 u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
270 u8 buf[100], *pos;
271 u8 *addr;
272 size_t len;
273 int rlen, i;
274
275 if (argc < 1) {
276 printf("list_sta needs one argument: BSSID\n");
277 return -1;
278 }
279
280 pos = buf;
281 WPA_PUT_BE32(pos, WLANTEST_CTRL_LIST_STA);
282 pos += 4;
283 WPA_PUT_BE32(pos, WLANTEST_ATTR_BSSID);
284 pos += 4;
285 WPA_PUT_BE32(pos, ETH_ALEN);
286 pos += 4;
287 if (hwaddr_aton(argv[0], pos) < 0) {
288 printf("Invalid BSSID '%s'\n", argv[0]);
289 return -1;
290 }
291 pos += ETH_ALEN;
292
293 rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
294 if (rlen < 0)
295 return -1;
296
297 addr = attr_get(resp + 4, rlen - 4, WLANTEST_ATTR_STA_ADDR, &len);
298 if (addr == NULL)
299 return -1;
300
301 for (i = 0; i < len / ETH_ALEN; i++)
302 printf(MACSTR " ", MAC2STR(addr + ETH_ALEN * i));
303 printf("\n");
304
305 return 0;
306 }
307
308
309 static char ** complete_list_sta(int s, const char *str, int pos)
310 {
311 if (get_cmd_arg_num(str, pos) == 1)
312 return get_bssid_list(s);
313 return NULL;
314 }
315
316
317 static int cmd_flush(int s, int argc, char *argv[])
318 {
319 return cmd_simple(s, WLANTEST_CTRL_FLUSH);
320 }
321
322
323 static int cmd_clear_sta_counters(int s, int argc, char *argv[])
324 {
325 u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
326 u8 buf[100], *pos;
327 int rlen;
328
329 if (argc < 2) {
330 printf("clear_sta_counters needs two arguments: BSSID and "
331 "STA address\n");
332 return -1;
333 }
334
335 pos = buf;
336 WPA_PUT_BE32(pos, WLANTEST_CTRL_CLEAR_STA_COUNTERS);
337 pos += 4;
338 WPA_PUT_BE32(pos, WLANTEST_ATTR_BSSID);
339 pos += 4;
340 WPA_PUT_BE32(pos, ETH_ALEN);
341 pos += 4;
342 if (hwaddr_aton(argv[0], pos) < 0) {
343 printf("Invalid BSSID '%s'\n", argv[0]);
344 return -1;
345 }
346 pos += ETH_ALEN;
347
348 WPA_PUT_BE32(pos, WLANTEST_ATTR_STA_ADDR);
349 pos += 4;
350 WPA_PUT_BE32(pos, ETH_ALEN);
351 pos += 4;
352 if (hwaddr_aton(argv[1], pos) < 0) {
353 printf("Invalid STA address '%s'\n", argv[1]);
354 return -1;
355 }
356 pos += ETH_ALEN;
357
358 rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
359 if (rlen < 0)
360 return -1;
361 printf("OK\n");
362 return 0;
363 }
364
365
366 static char ** complete_clear_sta_counters(int s, const char *str, int pos)
367 {
368 int arg = get_cmd_arg_num(str, pos);
369 char **res = NULL;
370 u8 addr[ETH_ALEN];
371
372 switch (arg) {
373 case 1:
374 res = get_bssid_list(s);
375 break;
376 case 2:
377 if (hwaddr_aton(&str[get_prev_arg_pos(str, pos)], addr) < 0)
378 break;
379 res = get_sta_list(s, addr, 0);
380 break;
381 }
382
383 return res;
384 }
385
386
387 static int cmd_clear_bss_counters(int s, int argc, char *argv[])
388 {
389 u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
390 u8 buf[100], *pos;
391 int rlen;
392
393 if (argc < 1) {
394 printf("clear_bss_counters needs one argument: BSSID\n");
395 return -1;
396 }
397
398 pos = buf;
399 WPA_PUT_BE32(pos, WLANTEST_CTRL_CLEAR_BSS_COUNTERS);
400 pos += 4;
401 WPA_PUT_BE32(pos, WLANTEST_ATTR_BSSID);
402 pos += 4;
403 WPA_PUT_BE32(pos, ETH_ALEN);
404 pos += 4;
405 if (hwaddr_aton(argv[0], pos) < 0) {
406 printf("Invalid BSSID '%s'\n", argv[0]);
407 return -1;
408 }
409 pos += ETH_ALEN;
410
411 rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
412 if (rlen < 0)
413 return -1;
414 printf("OK\n");
415 return 0;
416 }
417
418
419 static char ** complete_clear_bss_counters(int s, const char *str, int pos)
420 {
421 if (get_cmd_arg_num(str, pos) == 1)
422 return get_bssid_list(s);
423 return NULL;
424 }
425
426
427 static int cmd_clear_tdls_counters(int s, int argc, char *argv[])
428 {
429 u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
430 u8 buf[100], *pos;
431 int rlen;
432
433 if (argc < 3) {
434 printf("clear_tdls_counters needs three arguments: BSSID, "
435 "STA1 address, STA2 address\n");
436 return -1;
437 }
438
439 pos = buf;
440 WPA_PUT_BE32(pos, WLANTEST_CTRL_CLEAR_TDLS_COUNTERS);
441 pos += 4;
442 WPA_PUT_BE32(pos, WLANTEST_ATTR_BSSID);
443 pos += 4;
444 WPA_PUT_BE32(pos, ETH_ALEN);
445 pos += 4;
446 if (hwaddr_aton(argv[0], pos) < 0) {
447 printf("Invalid BSSID '%s'\n", argv[0]);
448 return -1;
449 }
450 pos += ETH_ALEN;
451
452 WPA_PUT_BE32(pos, WLANTEST_ATTR_STA_ADDR);
453 pos += 4;
454 WPA_PUT_BE32(pos, ETH_ALEN);
455 pos += 4;
456 if (hwaddr_aton(argv[1], pos) < 0) {
457 printf("Invalid STA1 address '%s'\n", argv[1]);
458 return -1;
459 }
460 pos += ETH_ALEN;
461
462 WPA_PUT_BE32(pos, WLANTEST_ATTR_STA2_ADDR);
463 pos += 4;
464 WPA_PUT_BE32(pos, ETH_ALEN);
465 pos += 4;
466 if (hwaddr_aton(argv[2], pos) < 0) {
467 printf("Invalid STA2 address '%s'\n", argv[2]);
468 return -1;
469 }
470 pos += ETH_ALEN;
471
472 rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
473 if (rlen < 0)
474 return -1;
475 printf("OK\n");
476 return 0;
477 }
478
479
480 static char ** complete_clear_tdls_counters(int s, const char *str, int pos)
481 {
482 int arg = get_cmd_arg_num(str, pos);
483 char **res = NULL;
484 u8 addr[ETH_ALEN];
485
486 switch (arg) {
487 case 1:
488 res = get_bssid_list(s);
489 break;
490 case 2:
491 case 3:
492 if (hwaddr_aton(&str[get_prev_arg_pos(str, pos)], addr) < 0)
493 break;
494 res = get_sta_list(s, addr, 0);
495 break;
496 }
497
498 return res;
499 }
500
501
502 struct sta_counters {
503 const char *name;
504 enum wlantest_sta_counter num;
505 };
506
507 static const struct sta_counters sta_counters[] = {
508 { "auth_tx", WLANTEST_STA_COUNTER_AUTH_TX },
509 { "auth_rx", WLANTEST_STA_COUNTER_AUTH_RX },
510 { "assocreq_tx", WLANTEST_STA_COUNTER_ASSOCREQ_TX },
511 { "reassocreq_tx", WLANTEST_STA_COUNTER_REASSOCREQ_TX },
512 { "ptk_learned", WLANTEST_STA_COUNTER_PTK_LEARNED },
513 { "valid_deauth_tx", WLANTEST_STA_COUNTER_VALID_DEAUTH_TX },
514 { "valid_deauth_rx", WLANTEST_STA_COUNTER_VALID_DEAUTH_RX },
515 { "invalid_deauth_tx", WLANTEST_STA_COUNTER_INVALID_DEAUTH_TX },
516 { "invalid_deauth_rx", WLANTEST_STA_COUNTER_INVALID_DEAUTH_RX },
517 { "valid_disassoc_tx", WLANTEST_STA_COUNTER_VALID_DISASSOC_TX },
518 { "valid_disassoc_rx", WLANTEST_STA_COUNTER_VALID_DISASSOC_RX },
519 { "invalid_disassoc_tx", WLANTEST_STA_COUNTER_INVALID_DISASSOC_TX },
520 { "invalid_disassoc_rx", WLANTEST_STA_COUNTER_INVALID_DISASSOC_RX },
521 { "valid_saqueryreq_tx", WLANTEST_STA_COUNTER_VALID_SAQUERYREQ_TX },
522 { "valid_saqueryreq_rx", WLANTEST_STA_COUNTER_VALID_SAQUERYREQ_RX },
523 { "invalid_saqueryreq_tx",
524 WLANTEST_STA_COUNTER_INVALID_SAQUERYREQ_TX },
525 { "invalid_saqueryreq_rx",
526 WLANTEST_STA_COUNTER_INVALID_SAQUERYREQ_RX },
527 { "valid_saqueryresp_tx", WLANTEST_STA_COUNTER_VALID_SAQUERYRESP_TX },
528 { "valid_saqueryresp_rx", WLANTEST_STA_COUNTER_VALID_SAQUERYRESP_RX },
529 { "invalid_saqueryresp_tx",
530 WLANTEST_STA_COUNTER_INVALID_SAQUERYRESP_TX },
531 { "invalid_saqueryresp_rx",
532 WLANTEST_STA_COUNTER_INVALID_SAQUERYRESP_RX },
533 { "ping_ok", WLANTEST_STA_COUNTER_PING_OK },
534 { "assocresp_comeback", WLANTEST_STA_COUNTER_ASSOCRESP_COMEBACK },
535 { "reassocresp_comeback", WLANTEST_STA_COUNTER_REASSOCRESP_COMEBACK },
536 { "ping_ok_first_assoc", WLANTEST_STA_COUNTER_PING_OK_FIRST_ASSOC },
537 { "valid_deauth_rx_ack", WLANTEST_STA_COUNTER_VALID_DEAUTH_RX_ACK },
538 { "valid_disassoc_rx_ack",
539 WLANTEST_STA_COUNTER_VALID_DISASSOC_RX_ACK },
540 { "invalid_deauth_rx_ack",
541 WLANTEST_STA_COUNTER_INVALID_DEAUTH_RX_ACK },
542 { "invalid_disassoc_rx_ack",
543 WLANTEST_STA_COUNTER_INVALID_DISASSOC_RX_ACK },
544 { "deauth_rx_asleep", WLANTEST_STA_COUNTER_DEAUTH_RX_ASLEEP },
545 { "deauth_rx_awake", WLANTEST_STA_COUNTER_DEAUTH_RX_AWAKE },
546 { "disassoc_rx_asleep", WLANTEST_STA_COUNTER_DISASSOC_RX_ASLEEP },
547 { "disassoc_rx_awake", WLANTEST_STA_COUNTER_DISASSOC_RX_AWAKE },
548 { "prot_data_tx", WLANTEST_STA_COUNTER_PROT_DATA_TX },
549 { "deauth_rx_rc6", WLANTEST_STA_COUNTER_DEAUTH_RX_RC6 },
550 { "deauth_rx_rc7", WLANTEST_STA_COUNTER_DEAUTH_RX_RC7 },
551 { "disassoc_rx_rc6", WLANTEST_STA_COUNTER_DISASSOC_RX_RC6 },
552 { "disassoc_rx_rc7", WLANTEST_STA_COUNTER_DISASSOC_RX_RC7 },
553 { NULL, 0 }
554 };
555
556 static int cmd_get_sta_counter(int s, int argc, char *argv[])
557 {
558 u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
559 u8 buf[100], *end, *pos;
560 int rlen, i;
561 size_t len;
562
563 if (argc != 3) {
564 printf("get_sta_counter needs at three arguments: "
565 "counter name, BSSID, and STA address\n");
566 return -1;
567 }
568
569 pos = buf;
570 end = buf + sizeof(buf);
571 WPA_PUT_BE32(pos, WLANTEST_CTRL_GET_STA_COUNTER);
572 pos += 4;
573
574 for (i = 0; sta_counters[i].name; i++) {
575 if (os_strcasecmp(sta_counters[i].name, argv[0]) == 0)
576 break;
577 }
578 if (sta_counters[i].name == NULL) {
579 printf("Unknown STA counter '%s'\n", argv[0]);
580 printf("Counters:");
581 for (i = 0; sta_counters[i].name; i++)
582 printf(" %s", sta_counters[i].name);
583 printf("\n");
584 return -1;
585 }
586
587 pos = attr_add_be32(pos, end, WLANTEST_ATTR_STA_COUNTER,
588 sta_counters[i].num);
589 pos = attr_hdr_add(pos, end, WLANTEST_ATTR_BSSID, ETH_ALEN);
590 if (hwaddr_aton(argv[1], pos) < 0) {
591 printf("Invalid BSSID '%s'\n", argv[1]);
592 return -1;
593 }
594 pos += ETH_ALEN;
595
596 pos = attr_hdr_add(pos, end, WLANTEST_ATTR_STA_ADDR, ETH_ALEN);
597 if (hwaddr_aton(argv[2], pos) < 0) {
598 printf("Invalid STA address '%s'\n", argv[2]);
599 return -1;
600 }
601 pos += ETH_ALEN;
602
603 rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
604 if (rlen < 0)
605 return -1;
606
607 pos = attr_get(resp + 4, rlen - 4, WLANTEST_ATTR_COUNTER, &len);
608 if (pos == NULL || len != 4)
609 return -1;
610 printf("%u\n", WPA_GET_BE32(pos));
611 return 0;
612 }
613
614
615 static char ** complete_get_sta_counter(int s, const char *str, int pos)
616 {
617 int arg = get_cmd_arg_num(str, pos);
618 char **res = NULL;
619 int i, count;
620 u8 addr[ETH_ALEN];
621
622 switch (arg) {
623 case 1:
624 /* counter list */
625 count = ARRAY_SIZE(sta_counters);
626 res = os_calloc(count, sizeof(char *));
627 if (res == NULL)
628 return NULL;
629 for (i = 0; sta_counters[i].name; i++) {
630 res[i] = os_strdup(sta_counters[i].name);
631 if (res[i] == NULL)
632 break;
633 }
634 break;
635 case 2:
636 res = get_bssid_list(s);
637 break;
638 case 3:
639 if (hwaddr_aton(&str[get_prev_arg_pos(str, pos)], addr) < 0)
640 break;
641 res = get_sta_list(s, addr, 0);
642 break;
643 }
644
645 return res;
646 }
647
648
649 struct bss_counters {
650 const char *name;
651 enum wlantest_bss_counter num;
652 };
653
654 static const struct bss_counters bss_counters[] = {
655 { "valid_bip_mmie", WLANTEST_BSS_COUNTER_VALID_BIP_MMIE },
656 { "invalid_bip_mmie", WLANTEST_BSS_COUNTER_INVALID_BIP_MMIE },
657 { "missing_bip_mmie", WLANTEST_BSS_COUNTER_MISSING_BIP_MMIE },
658 { "bip_deauth", WLANTEST_BSS_COUNTER_BIP_DEAUTH },
659 { "bip_disassoc", WLANTEST_BSS_COUNTER_BIP_DISASSOC },
660 { NULL, 0 }
661 };
662
663 static int cmd_get_bss_counter(int s, int argc, char *argv[])
664 {
665 u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
666 u8 buf[100], *end, *pos;
667 int rlen, i;
668 size_t len;
669
670 if (argc != 2) {
671 printf("get_bss_counter needs at two arguments: "
672 "counter name and BSSID\n");
673 return -1;
674 }
675
676 pos = buf;
677 end = buf + sizeof(buf);
678 WPA_PUT_BE32(pos, WLANTEST_CTRL_GET_BSS_COUNTER);
679 pos += 4;
680
681 for (i = 0; bss_counters[i].name; i++) {
682 if (os_strcasecmp(bss_counters[i].name, argv[0]) == 0)
683 break;
684 }
685 if (bss_counters[i].name == NULL) {
686 printf("Unknown BSS counter '%s'\n", argv[0]);
687 printf("Counters:");
688 for (i = 0; bss_counters[i].name; i++)
689 printf(" %s", bss_counters[i].name);
690 printf("\n");
691 return -1;
692 }
693
694 pos = attr_add_be32(pos, end, WLANTEST_ATTR_BSS_COUNTER,
695 bss_counters[i].num);
696 pos = attr_hdr_add(pos, end, WLANTEST_ATTR_BSSID, ETH_ALEN);
697 if (hwaddr_aton(argv[1], pos) < 0) {
698 printf("Invalid BSSID '%s'\n", argv[1]);
699 return -1;
700 }
701 pos += ETH_ALEN;
702
703 rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
704 if (rlen < 0)
705 return -1;
706
707 pos = attr_get(resp + 4, rlen - 4, WLANTEST_ATTR_COUNTER, &len);
708 if (pos == NULL || len != 4)
709 return -1;
710 printf("%u\n", WPA_GET_BE32(pos));
711 return 0;
712 }
713
714
715 static char ** complete_get_bss_counter(int s, const char *str, int pos)
716 {
717 int arg = get_cmd_arg_num(str, pos);
718 char **res = NULL;
719 int i, count;
720
721 switch (arg) {
722 case 1:
723 /* counter list */
724 count = ARRAY_SIZE(bss_counters);
725 res = os_calloc(count, sizeof(char *));
726 if (res == NULL)
727 return NULL;
728 for (i = 0; bss_counters[i].name; i++) {
729 res[i] = os_strdup(bss_counters[i].name);
730 if (res[i] == NULL)
731 break;
732 }
733 break;
734 case 2:
735 res = get_bssid_list(s);
736 break;
737 }
738
739 return res;
740 }
741
742
743 static int cmd_relog(int s, int argc, char *argv[])
744 {
745 return cmd_simple(s, WLANTEST_CTRL_RELOG);
746 }
747
748
749 struct tdls_counters {
750 const char *name;
751 enum wlantest_tdls_counter num;
752 };
753
754 static const struct tdls_counters tdls_counters[] = {
755 { "valid_direct_link", WLANTEST_TDLS_COUNTER_VALID_DIRECT_LINK },
756 { "invalid_direct_link", WLANTEST_TDLS_COUNTER_INVALID_DIRECT_LINK },
757 { "valid_ap_path", WLANTEST_TDLS_COUNTER_VALID_AP_PATH },
758 { "invalid_ap_path", WLANTEST_TDLS_COUNTER_INVALID_AP_PATH },
759 { "setup_req", WLANTEST_TDLS_COUNTER_SETUP_REQ },
760 { "setup_resp_ok", WLANTEST_TDLS_COUNTER_SETUP_RESP_OK },
761 { "setup_resp_fail", WLANTEST_TDLS_COUNTER_SETUP_RESP_FAIL },
762 { "setup_conf_ok", WLANTEST_TDLS_COUNTER_SETUP_CONF_OK },
763 { "setup_conf_fail", WLANTEST_TDLS_COUNTER_SETUP_CONF_FAIL },
764 { "teardown", WLANTEST_TDLS_COUNTER_TEARDOWN },
765 { NULL, 0 }
766 };
767
768 static int cmd_get_tdls_counter(int s, int argc, char *argv[])
769 {
770 u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
771 u8 buf[100], *end, *pos;
772 int rlen, i;
773 size_t len;
774
775 if (argc != 4) {
776 printf("get_tdls_counter needs four arguments: "
777 "counter name, BSSID, STA1 address, STA2 address\n");
778 return -1;
779 }
780
781 pos = buf;
782 end = buf + sizeof(buf);
783 WPA_PUT_BE32(pos, WLANTEST_CTRL_GET_TDLS_COUNTER);
784 pos += 4;
785
786 for (i = 0; tdls_counters[i].name; i++) {
787 if (os_strcasecmp(tdls_counters[i].name, argv[0]) == 0)
788 break;
789 }
790 if (tdls_counters[i].name == NULL) {
791 printf("Unknown TDLS counter '%s'\n", argv[0]);
792 printf("Counters:");
793 for (i = 0; tdls_counters[i].name; i++)
794 printf(" %s", tdls_counters[i].name);
795 printf("\n");
796 return -1;
797 }
798
799 pos = attr_add_be32(pos, end, WLANTEST_ATTR_TDLS_COUNTER,
800 tdls_counters[i].num);
801 pos = attr_hdr_add(pos, end, WLANTEST_ATTR_BSSID, ETH_ALEN);
802 if (hwaddr_aton(argv[1], pos) < 0) {
803 printf("Invalid BSSID '%s'\n", argv[1]);
804 return -1;
805 }
806 pos += ETH_ALEN;
807
808 pos = attr_hdr_add(pos, end, WLANTEST_ATTR_STA_ADDR, ETH_ALEN);
809 if (hwaddr_aton(argv[2], pos) < 0) {
810 printf("Invalid STA1 address '%s'\n", argv[2]);
811 return -1;
812 }
813 pos += ETH_ALEN;
814
815 pos = attr_hdr_add(pos, end, WLANTEST_ATTR_STA2_ADDR, ETH_ALEN);
816 if (hwaddr_aton(argv[3], pos) < 0) {
817 printf("Invalid STA2 address '%s'\n", argv[3]);
818 return -1;
819 }
820 pos += ETH_ALEN;
821
822 rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
823 if (rlen < 0)
824 return -1;
825
826 pos = attr_get(resp + 4, rlen - 4, WLANTEST_ATTR_COUNTER, &len);
827 if (pos == NULL || len != 4)
828 return -1;
829 printf("%u\n", WPA_GET_BE32(pos));
830 return 0;
831 }
832
833
834 static char ** complete_get_tdls_counter(int s, const char *str, int pos)
835 {
836 int arg = get_cmd_arg_num(str, pos);
837 char **res = NULL;
838 int i, count;
839 u8 addr[ETH_ALEN];
840
841 switch (arg) {
842 case 1:
843 /* counter list */
844 count = ARRAY_SIZE(tdls_counters);
845 res = os_calloc(count, sizeof(char *));
846 if (res == NULL)
847 return NULL;
848 for (i = 0; tdls_counters[i].name; i++) {
849 res[i] = os_strdup(tdls_counters[i].name);
850 if (res[i] == NULL)
851 break;
852 }
853 break;
854 case 2:
855 res = get_bssid_list(s);
856 break;
857 case 3:
858 case 4:
859 if (hwaddr_aton(&str[get_prev_arg_pos(str, pos)], addr) < 0)
860 break;
861 res = get_sta_list(s, addr, 0);
862 break;
863 }
864
865 return res;
866 }
867
868
869 struct inject_frames {
870 const char *name;
871 enum wlantest_inject_frame frame;
872 };
873
874 static const struct inject_frames inject_frames[] = {
875 { "auth", WLANTEST_FRAME_AUTH },
876 { "assocreq", WLANTEST_FRAME_ASSOCREQ },
877 { "reassocreq", WLANTEST_FRAME_REASSOCREQ },
878 { "deauth", WLANTEST_FRAME_DEAUTH },
879 { "disassoc", WLANTEST_FRAME_DISASSOC },
880 { "saqueryreq", WLANTEST_FRAME_SAQUERYREQ },
881 { NULL, 0 }
882 };
883
884 static int cmd_inject(int s, int argc, char *argv[])
885 {
886 u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
887 u8 buf[100], *end, *pos;
888 int rlen, i;
889 enum wlantest_inject_protection prot;
890
891 /* <frame> <prot> <sender> <BSSID> <STA/ff:ff:ff:ff:ff:ff> */
892
893 if (argc < 5) {
894 printf("inject needs five arguments: frame, protection, "
895 "sender, BSSID, STA/ff:ff:ff:ff:ff:ff\n");
896 return -1;
897 }
898
899 pos = buf;
900 end = buf + sizeof(buf);
901 WPA_PUT_BE32(pos, WLANTEST_CTRL_INJECT);
902 pos += 4;
903
904 for (i = 0; inject_frames[i].name; i++) {
905 if (os_strcasecmp(inject_frames[i].name, argv[0]) == 0)
906 break;
907 }
908 if (inject_frames[i].name == NULL) {
909 printf("Unknown inject frame '%s'\n", argv[0]);
910 printf("Frames:");
911 for (i = 0; inject_frames[i].name; i++)
912 printf(" %s", inject_frames[i].name);
913 printf("\n");
914 return -1;
915 }
916
917 pos = attr_add_be32(pos, end, WLANTEST_ATTR_INJECT_FRAME,
918 inject_frames[i].frame);
919
920 if (os_strcasecmp(argv[1], "normal") == 0)
921 prot = WLANTEST_INJECT_NORMAL;
922 else if (os_strcasecmp(argv[1], "protected") == 0)
923 prot = WLANTEST_INJECT_PROTECTED;
924 else if (os_strcasecmp(argv[1], "unprotected") == 0)
925 prot = WLANTEST_INJECT_UNPROTECTED;
926 else if (os_strcasecmp(argv[1], "incorrect") == 0)
927 prot = WLANTEST_INJECT_INCORRECT_KEY;
928 else {
929 printf("Unknown protection type '%s'\n", argv[1]);
930 printf("Protection types: normal protected unprotected "
931 "incorrect\n");
932 return -1;
933 }
934 pos = attr_add_be32(pos, end, WLANTEST_ATTR_INJECT_PROTECTION, prot);
935
936 if (os_strcasecmp(argv[2], "ap") == 0) {
937 pos = attr_add_be32(pos, end, WLANTEST_ATTR_INJECT_SENDER_AP,
938 1);
939 } else if (os_strcasecmp(argv[2], "sta") == 0) {
940 pos = attr_add_be32(pos, end, WLANTEST_ATTR_INJECT_SENDER_AP,
941 0);
942 } else {
943 printf("Unknown sender '%s'\n", argv[2]);
944 printf("Sender types: ap sta\n");
945 return -1;
946 }
947
948 pos = attr_hdr_add(pos, end, WLANTEST_ATTR_BSSID, ETH_ALEN);
949 if (hwaddr_aton(argv[3], pos) < 0) {
950 printf("Invalid BSSID '%s'\n", argv[3]);
951 return -1;
952 }
953 pos += ETH_ALEN;
954
955 pos = attr_hdr_add(pos, end, WLANTEST_ATTR_STA_ADDR, ETH_ALEN);
956 if (hwaddr_aton(argv[4], pos) < 0) {
957 printf("Invalid STA '%s'\n", argv[4]);
958 return -1;
959 }
960 pos += ETH_ALEN;
961
962 rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
963 if (rlen < 0)
964 return -1;
965 printf("OK\n");
966 return 0;
967 }
968
969
970 static char ** complete_inject(int s, const char *str, int pos)
971 {
972 int arg = get_cmd_arg_num(str, pos);
973 char **res = NULL;
974 int i, count;
975 u8 addr[ETH_ALEN];
976
977 switch (arg) {
978 case 1:
979 /* frame list */
980 count = ARRAY_SIZE(inject_frames);
981 res = os_calloc(count, sizeof(char *));
982 if (res == NULL)
983 break;
984 for (i = 0; inject_frames[i].name; i++) {
985 res[i] = os_strdup(inject_frames[i].name);
986 if (res[i] == NULL)
987 break;
988 }
989 break;
990 case 2:
991 res = os_calloc(5, sizeof(char *));
992 if (res == NULL)
993 break;
994 res[0] = os_strdup("normal");
995 if (res[0] == NULL)
996 break;
997 res[1] = os_strdup("protected");
998 if (res[1] == NULL)
999 break;
1000 res[2] = os_strdup("unprotected");
1001 if (res[2] == NULL)
1002 break;
1003 res[3] = os_strdup("incorrect");
1004 if (res[3] == NULL)
1005 break;
1006 break;
1007 case 3:
1008 res = os_calloc(3, sizeof(char *));
1009 if (res == NULL)
1010 break;
1011 res[0] = os_strdup("ap");
1012 if (res[0] == NULL)
1013 break;
1014 res[1] = os_strdup("sta");
1015 if (res[1] == NULL)
1016 break;
1017 break;
1018 case 4:
1019 res = get_bssid_list(s);
1020 break;
1021 case 5:
1022 if (hwaddr_aton(&str[get_prev_arg_pos(str, pos)], addr) < 0)
1023 break;
1024 res = get_sta_list(s, addr, 1);
1025 break;
1026 }
1027
1028 return res;
1029 }
1030
1031
1032 static u8 * add_hex(u8 *pos, u8 *end, const char *str)
1033 {
1034 const char *s;
1035 int val;
1036
1037 s = str;
1038 while (*s) {
1039 while (*s == ' ' || *s == '\t' || *s == '\r' || *s == '\n' ||
1040 *s == ':')
1041 s++;
1042 if (*s == '\0')
1043 break;
1044 if (*s == '#') {
1045 while (*s != '\0' && *s != '\r' && *s != '\n')
1046 s++;
1047 continue;
1048 }
1049
1050 val = hex2byte(s);
1051 if (val < 0) {
1052 printf("Invalid hex encoding '%s'\n", s);
1053 return NULL;
1054 }
1055 if (pos == end) {
1056 printf("Too long frame\n");
1057 return NULL;
1058 }
1059 *pos++ = val;
1060 s += 2;
1061 }
1062
1063 return pos;
1064 }
1065
1066
1067 static int cmd_send(int s, int argc, char *argv[])
1068 {
1069 u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
1070 u8 buf[WLANTEST_CTRL_MAX_CMD_LEN], *end, *pos, *len_pos;
1071 int rlen;
1072 enum wlantest_inject_protection prot;
1073 int arg;
1074
1075 /* <prot> <raw frame as hex dump> */
1076
1077 if (argc < 2) {
1078 printf("send needs two arguments: protected/unprotected, "
1079 "raw frame as hex dump\n");
1080 return -1;
1081 }
1082
1083 pos = buf;
1084 end = buf + sizeof(buf);
1085 WPA_PUT_BE32(pos, WLANTEST_CTRL_SEND);
1086 pos += 4;
1087
1088 if (os_strcasecmp(argv[0], "normal") == 0)
1089 prot = WLANTEST_INJECT_NORMAL;
1090 else if (os_strcasecmp(argv[0], "protected") == 0)
1091 prot = WLANTEST_INJECT_PROTECTED;
1092 else if (os_strcasecmp(argv[0], "unprotected") == 0)
1093 prot = WLANTEST_INJECT_UNPROTECTED;
1094 else if (os_strcasecmp(argv[0], "incorrect") == 0)
1095 prot = WLANTEST_INJECT_INCORRECT_KEY;
1096 else {
1097 printf("Unknown protection type '%s'\n", argv[1]);
1098 printf("Protection types: normal protected unprotected "
1099 "incorrect\n");
1100 return -1;
1101 }
1102 pos = attr_add_be32(pos, end, WLANTEST_ATTR_INJECT_PROTECTION, prot);
1103
1104 WPA_PUT_BE32(pos, WLANTEST_ATTR_FRAME);
1105 pos += 4;
1106 len_pos = pos;
1107 pos += 4;
1108
1109 for (arg = 1; pos && arg < argc; arg++)
1110 pos = add_hex(pos, end, argv[arg]);
1111 if (pos == NULL)
1112 return -1;
1113
1114 WPA_PUT_BE32(len_pos, pos - len_pos - 4);
1115
1116 rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
1117 if (rlen < 0)
1118 return -1;
1119 printf("OK\n");
1120 return 0;
1121 }
1122
1123
1124 static char ** complete_send(int s, const char *str, int pos)
1125 {
1126 int arg = get_cmd_arg_num(str, pos);
1127 char **res = NULL;
1128
1129 switch (arg) {
1130 case 1:
1131 res = os_calloc(5, sizeof(char *));
1132 if (res == NULL)
1133 break;
1134 res[0] = os_strdup("normal");
1135 if (res[0] == NULL)
1136 break;
1137 res[1] = os_strdup("protected");
1138 if (res[1] == NULL)
1139 break;
1140 res[2] = os_strdup("unprotected");
1141 if (res[2] == NULL)
1142 break;
1143 res[3] = os_strdup("incorrect");
1144 if (res[3] == NULL)
1145 break;
1146 break;
1147 }
1148
1149 return res;
1150 }
1151
1152
1153 static int cmd_version(int s, int argc, char *argv[])
1154 {
1155 u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
1156 u8 buf[4];
1157 char *version;
1158 size_t len;
1159 int rlen, i;
1160
1161 WPA_PUT_BE32(buf, WLANTEST_CTRL_VERSION);
1162 rlen = cmd_send_and_recv(s, buf, sizeof(buf), resp, sizeof(resp));
1163 if (rlen < 0)
1164 return -1;
1165
1166 version = (char *) attr_get(resp + 4, rlen - 4, WLANTEST_ATTR_VERSION,
1167 &len);
1168 if (version == NULL)
1169 return -1;
1170
1171 for (i = 0; i < len; i++)
1172 putchar(version[i]);
1173 printf("\n");
1174
1175 return 0;
1176 }
1177
1178
1179 static int cmd_add_passphrase(int s, int argc, char *argv[])
1180 {
1181 u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
1182 u8 buf[100], *pos, *end;
1183 size_t len;
1184 int rlen;
1185
1186 if (argc < 1) {
1187 printf("add_passphrase needs one argument: passphrase\n");
1188 return -1;
1189 }
1190
1191 len = os_strlen(argv[0]);
1192 if (len < 8 || len > 63) {
1193 printf("Invalid passphrase '%s'\n", argv[0]);
1194 return -1;
1195 }
1196 pos = buf;
1197 end = buf + sizeof(buf);
1198 WPA_PUT_BE32(pos, WLANTEST_CTRL_ADD_PASSPHRASE);
1199 pos += 4;
1200 pos = attr_add_str(pos, end, WLANTEST_ATTR_PASSPHRASE,
1201 argv[0]);
1202 if (argc > 1) {
1203 pos = attr_hdr_add(pos, end, WLANTEST_ATTR_BSSID, ETH_ALEN);
1204 if (hwaddr_aton(argv[1], pos) < 0) {
1205 printf("Invalid BSSID '%s'\n", argv[3]);
1206 return -1;
1207 }
1208 pos += ETH_ALEN;
1209 }
1210
1211 rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
1212 if (rlen < 0)
1213 return -1;
1214 return 0;
1215 }
1216
1217
1218 static int cmd_add_wepkey(int s, int argc, char *argv[])
1219 {
1220 u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
1221 u8 buf[100], *pos, *end;
1222 int rlen;
1223
1224 if (argc < 1) {
1225 printf("add_wepkey needs one argument: WEP key\n");
1226 return -1;
1227 }
1228
1229 pos = buf;
1230 end = buf + sizeof(buf);
1231 WPA_PUT_BE32(pos, WLANTEST_CTRL_ADD_PASSPHRASE);
1232 pos += 4;
1233 pos = attr_add_str(pos, end, WLANTEST_ATTR_WEPKEY, argv[0]);
1234
1235 rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
1236 if (rlen < 0)
1237 return -1;
1238 return 0;
1239 }
1240
1241
1242 struct sta_infos {
1243 const char *name;
1244 enum wlantest_sta_info num;
1245 };
1246
1247 static const struct sta_infos sta_infos[] = {
1248 { "proto", WLANTEST_STA_INFO_PROTO },
1249 { "pairwise", WLANTEST_STA_INFO_PAIRWISE },
1250 { "key_mgmt", WLANTEST_STA_INFO_KEY_MGMT },
1251 { "rsn_capab", WLANTEST_STA_INFO_RSN_CAPAB },
1252 { "state", WLANTEST_STA_INFO_STATE },
1253 { "gtk", WLANTEST_STA_INFO_GTK },
1254 { NULL, 0 }
1255 };
1256
1257 static int cmd_info_sta(int s, int argc, char *argv[])
1258 {
1259 u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
1260 u8 buf[100], *end, *pos;
1261 int rlen, i;
1262 size_t len;
1263 char info[100];
1264
1265 if (argc != 3) {
1266 printf("sta_info needs at three arguments: "
1267 "counter name, BSSID, and STA address\n");
1268 return -1;
1269 }
1270
1271 pos = buf;
1272 end = buf + sizeof(buf);
1273 WPA_PUT_BE32(pos, WLANTEST_CTRL_INFO_STA);
1274 pos += 4;
1275
1276 for (i = 0; sta_infos[i].name; i++) {
1277 if (os_strcasecmp(sta_infos[i].name, argv[0]) == 0)
1278 break;
1279 }
1280 if (sta_infos[i].name == NULL) {
1281 printf("Unknown STA info '%s'\n", argv[0]);
1282 printf("Info fields:");
1283 for (i = 0; sta_infos[i].name; i++)
1284 printf(" %s", sta_infos[i].name);
1285 printf("\n");
1286 return -1;
1287 }
1288
1289 pos = attr_add_be32(pos, end, WLANTEST_ATTR_STA_INFO,
1290 sta_infos[i].num);
1291 pos = attr_hdr_add(pos, end, WLANTEST_ATTR_BSSID, ETH_ALEN);
1292 if (hwaddr_aton(argv[1], pos) < 0) {
1293 printf("Invalid BSSID '%s'\n", argv[1]);
1294 return -1;
1295 }
1296 pos += ETH_ALEN;
1297
1298 pos = attr_hdr_add(pos, end, WLANTEST_ATTR_STA_ADDR, ETH_ALEN);
1299 if (hwaddr_aton(argv[2], pos) < 0) {
1300 printf("Invalid STA address '%s'\n", argv[2]);
1301 return -1;
1302 }
1303 pos += ETH_ALEN;
1304
1305 rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
1306 if (rlen < 0)
1307 return -1;
1308
1309 pos = attr_get(resp + 4, rlen - 4, WLANTEST_ATTR_INFO, &len);
1310 if (pos == NULL)
1311 return -1;
1312 if (len >= sizeof(info))
1313 len = sizeof(info) - 1;
1314 os_memcpy(info, pos, len);
1315 info[len] = '\0';
1316 printf("%s\n", info);
1317 return 0;
1318 }
1319
1320
1321 static char ** complete_info_sta(int s, const char *str, int pos)
1322 {
1323 int arg = get_cmd_arg_num(str, pos);
1324 char **res = NULL;
1325 int i, count;
1326 u8 addr[ETH_ALEN];
1327
1328 switch (arg) {
1329 case 1:
1330 /* counter list */
1331 count = ARRAY_SIZE(sta_infos);
1332 res = os_calloc(count, sizeof(char *));
1333 if (res == NULL)
1334 return NULL;
1335 for (i = 0; sta_infos[i].name; i++) {
1336 res[i] = os_strdup(sta_infos[i].name);
1337 if (res[i] == NULL)
1338 break;
1339 }
1340 break;
1341 case 2:
1342 res = get_bssid_list(s);
1343 break;
1344 case 3:
1345 if (hwaddr_aton(&str[get_prev_arg_pos(str, pos)], addr) < 0)
1346 break;
1347 res = get_sta_list(s, addr, 0);
1348 break;
1349 }
1350
1351 return res;
1352 }
1353
1354
1355 struct bss_infos {
1356 const char *name;
1357 enum wlantest_bss_info num;
1358 };
1359
1360 static const struct bss_infos bss_infos[] = {
1361 { "proto", WLANTEST_BSS_INFO_PROTO },
1362 { "pairwise", WLANTEST_BSS_INFO_PAIRWISE },
1363 { "group", WLANTEST_BSS_INFO_GROUP },
1364 { "group_mgmt", WLANTEST_BSS_INFO_GROUP_MGMT },
1365 { "key_mgmt", WLANTEST_BSS_INFO_KEY_MGMT },
1366 { "rsn_capab", WLANTEST_BSS_INFO_RSN_CAPAB },
1367 { NULL, 0 }
1368 };
1369
1370 static int cmd_info_bss(int s, int argc, char *argv[])
1371 {
1372 u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
1373 u8 buf[100], *end, *pos;
1374 int rlen, i;
1375 size_t len;
1376 char info[100];
1377
1378 if (argc != 2) {
1379 printf("bss_info needs at two arguments: "
1380 "field name and BSSID\n");
1381 return -1;
1382 }
1383
1384 pos = buf;
1385 end = buf + sizeof(buf);
1386 WPA_PUT_BE32(pos, WLANTEST_CTRL_INFO_BSS);
1387 pos += 4;
1388
1389 for (i = 0; bss_infos[i].name; i++) {
1390 if (os_strcasecmp(bss_infos[i].name, argv[0]) == 0)
1391 break;
1392 }
1393 if (bss_infos[i].name == NULL) {
1394 printf("Unknown BSS info '%s'\n", argv[0]);
1395 printf("Info fields:");
1396 for (i = 0; bss_infos[i].name; i++)
1397 printf(" %s", bss_infos[i].name);
1398 printf("\n");
1399 return -1;
1400 }
1401
1402 pos = attr_add_be32(pos, end, WLANTEST_ATTR_BSS_INFO,
1403 bss_infos[i].num);
1404 pos = attr_hdr_add(pos, end, WLANTEST_ATTR_BSSID, ETH_ALEN);
1405 if (hwaddr_aton(argv[1], pos) < 0) {
1406 printf("Invalid BSSID '%s'\n", argv[1]);
1407 return -1;
1408 }
1409 pos += ETH_ALEN;
1410
1411 rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
1412 if (rlen < 0)
1413 return -1;
1414
1415 pos = attr_get(resp + 4, rlen - 4, WLANTEST_ATTR_INFO, &len);
1416 if (pos == NULL)
1417 return -1;
1418 if (len >= sizeof(info))
1419 len = sizeof(info) - 1;
1420 os_memcpy(info, pos, len);
1421 info[len] = '\0';
1422 printf("%s\n", info);
1423 return 0;
1424 }
1425
1426
1427 static char ** complete_info_bss(int s, const char *str, int pos)
1428 {
1429 int arg = get_cmd_arg_num(str, pos);
1430 char **res = NULL;
1431 int i, count;
1432
1433 switch (arg) {
1434 case 1:
1435 /* counter list */
1436 count = ARRAY_SIZE(bss_infos);
1437 res = os_calloc(count, sizeof(char *));
1438 if (res == NULL)
1439 return NULL;
1440 for (i = 0; bss_infos[i].name; i++) {
1441 res[i] = os_strdup(bss_infos[i].name);
1442 if (res[i] == NULL)
1443 break;
1444 }
1445 break;
1446 case 2:
1447 res = get_bssid_list(s);
1448 break;
1449 }
1450
1451 return res;
1452 }
1453
1454
1455 static int cmd_get_tx_tid(int s, int argc, char *argv[])
1456 {
1457 u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
1458 u8 buf[100], *end, *pos;
1459 int rlen;
1460 size_t len;
1461
1462 if (argc != 3) {
1463 printf("get_tx_tid needs three arguments: "
1464 "BSSID, STA address, and TID\n");
1465 return -1;
1466 }
1467
1468 pos = buf;
1469 end = buf + sizeof(buf);
1470 WPA_PUT_BE32(pos, WLANTEST_CTRL_GET_TX_TID);
1471 pos += 4;
1472
1473 pos = attr_hdr_add(pos, end, WLANTEST_ATTR_BSSID, ETH_ALEN);
1474 if (hwaddr_aton(argv[0], pos) < 0) {
1475 printf("Invalid BSSID '%s'\n", argv[0]);
1476 return -1;
1477 }
1478 pos += ETH_ALEN;
1479
1480 pos = attr_hdr_add(pos, end, WLANTEST_ATTR_STA_ADDR, ETH_ALEN);
1481 if (hwaddr_aton(argv[1], pos) < 0) {
1482 printf("Invalid STA address '%s'\n", argv[1]);
1483 return -1;
1484 }
1485 pos += ETH_ALEN;
1486
1487 pos = attr_add_be32(pos, end, WLANTEST_ATTR_TID, atoi(argv[2]));
1488
1489 rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
1490 if (rlen < 0)
1491 return -1;
1492
1493 pos = attr_get(resp + 4, rlen - 4, WLANTEST_ATTR_COUNTER, &len);
1494 if (pos == NULL || len != 4)
1495 return -1;
1496 printf("%u\n", WPA_GET_BE32(pos));
1497 return 0;
1498 }
1499
1500
1501 static int cmd_get_rx_tid(int s, int argc, char *argv[])
1502 {
1503 u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
1504 u8 buf[100], *end, *pos;
1505 int rlen;
1506 size_t len;
1507
1508 if (argc != 3) {
1509 printf("get_tx_tid needs three arguments: "
1510 "BSSID, STA address, and TID\n");
1511 return -1;
1512 }
1513
1514 pos = buf;
1515 end = buf + sizeof(buf);
1516 WPA_PUT_BE32(pos, WLANTEST_CTRL_GET_RX_TID);
1517 pos += 4;
1518
1519 pos = attr_hdr_add(pos, end, WLANTEST_ATTR_BSSID, ETH_ALEN);
1520 if (hwaddr_aton(argv[0], pos) < 0) {
1521 printf("Invalid BSSID '%s'\n", argv[0]);
1522 return -1;
1523 }
1524 pos += ETH_ALEN;
1525
1526 pos = attr_hdr_add(pos, end, WLANTEST_ATTR_STA_ADDR, ETH_ALEN);
1527 if (hwaddr_aton(argv[1], pos) < 0) {
1528 printf("Invalid STA address '%s'\n", argv[1]);
1529 return -1;
1530 }
1531 pos += ETH_ALEN;
1532
1533 pos = attr_add_be32(pos, end, WLANTEST_ATTR_TID, atoi(argv[2]));
1534
1535 rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
1536 if (rlen < 0)
1537 return -1;
1538
1539 pos = attr_get(resp + 4, rlen - 4, WLANTEST_ATTR_COUNTER, &len);
1540 if (pos == NULL || len != 4)
1541 return -1;
1542 printf("%u\n", WPA_GET_BE32(pos));
1543 return 0;
1544 }
1545
1546
1547 static char ** complete_get_tid(int s, const char *str, int pos)
1548 {
1549 int arg = get_cmd_arg_num(str, pos);
1550 char **res = NULL;
1551 u8 addr[ETH_ALEN];
1552
1553 switch (arg) {
1554 case 1:
1555 res = get_bssid_list(s);
1556 break;
1557 case 2:
1558 if (hwaddr_aton(&str[get_prev_arg_pos(str, pos)], addr) < 0)
1559 break;
1560 res = get_sta_list(s, addr, 0);
1561 break;
1562 }
1563
1564 return res;
1565 }
1566
1567
1568 struct wlantest_cli_cmd {
1569 const char *cmd;
1570 int (*handler)(int s, int argc, char *argv[]);
1571 const char *usage;
1572 char ** (*complete)(int s, const char *str, int pos);
1573 };
1574
1575 static const struct wlantest_cli_cmd wlantest_cli_commands[] = {
1576 { "ping", cmd_ping, "= test connection to wlantest", NULL },
1577 { "terminate", cmd_terminate, "= terminate wlantest", NULL },
1578 { "list_bss", cmd_list_bss, "= get BSS list", NULL },
1579 { "list_sta", cmd_list_sta, "<BSSID> = get STA list",
1580 complete_list_sta },
1581 { "flush", cmd_flush, "= drop all collected BSS data", NULL },
1582 { "clear_sta_counters", cmd_clear_sta_counters,
1583 "<BSSID> <STA> = clear STA counters", complete_clear_sta_counters },
1584 { "clear_bss_counters", cmd_clear_bss_counters,
1585 "<BSSID> = clear BSS counters", complete_clear_bss_counters },
1586 { "get_sta_counter", cmd_get_sta_counter,
1587 "<counter> <BSSID> <STA> = get STA counter value",
1588 complete_get_sta_counter },
1589 { "get_bss_counter", cmd_get_bss_counter,
1590 "<counter> <BSSID> = get BSS counter value",
1591 complete_get_bss_counter },
1592 { "inject", cmd_inject,
1593 "<frame> <prot> <sender> <BSSID> <STA/ff:ff:ff:ff:ff:ff>",
1594 complete_inject },
1595 { "send", cmd_send,
1596 "<prot> <raw frame as hex dump>",
1597 complete_send },
1598 { "version", cmd_version, "= get wlantest version", NULL },
1599 { "add_passphrase", cmd_add_passphrase,
1600 "<passphrase> = add a known passphrase", NULL },
1601 { "add_wepkey", cmd_add_wepkey,
1602 "<WEP key> = add a known WEP key", NULL },
1603 { "info_sta", cmd_info_sta,
1604 "<field> <BSSID> <STA> = get STA information",
1605 complete_info_sta },
1606 { "info_bss", cmd_info_bss,
1607 "<field> <BSSID> = get BSS information",
1608 complete_info_bss },
1609 { "clear_tdls_counters", cmd_clear_tdls_counters,
1610 "<BSSID> <STA1> <STA2> = clear TDLS counters",
1611 complete_clear_tdls_counters },
1612 { "get_tdls_counter", cmd_get_tdls_counter,
1613 "<counter> <BSSID> <STA1> <STA2> = get TDLS counter value",
1614 complete_get_tdls_counter },
1615 { "get_bss_counter", cmd_get_bss_counter,
1616 "<counter> <BSSID> = get BSS counter value",
1617 complete_get_bss_counter },
1618 { "relog", cmd_relog, "= re-open log-file (allow rolling logs)", NULL },
1619 { "get_tx_tid", cmd_get_tx_tid,
1620 "<BSSID> <STA> <TID> = get STA TX TID counter value",
1621 complete_get_tid },
1622 { "get_rx_tid", cmd_get_rx_tid,
1623 "<BSSID> <STA> <TID> = get STA RX TID counter value",
1624 complete_get_tid },
1625 { NULL, NULL, NULL, NULL }
1626 };
1627
1628
1629 static int ctrl_command(int s, int argc, char *argv[])
1630 {
1631 const struct wlantest_cli_cmd *cmd, *match = NULL;
1632 int count = 0;
1633 int ret = 0;
1634
1635 for (cmd = wlantest_cli_commands; cmd->cmd; cmd++) {
1636 if (os_strncasecmp(cmd->cmd, argv[0], os_strlen(argv[0])) == 0)
1637 {
1638 match = cmd;
1639 if (os_strcasecmp(cmd->cmd, argv[0]) == 0) {
1640 /* exact match */
1641 count = 1;
1642 break;
1643 }
1644 count++;
1645 }
1646 }
1647
1648 if (count > 1) {
1649 printf("Ambiguous command '%s'; possible commands:", argv[0]);
1650 for (cmd = wlantest_cli_commands; cmd->cmd; cmd++) {
1651 if (os_strncasecmp(cmd->cmd, argv[0],
1652 os_strlen(argv[0])) == 0) {
1653 printf(" %s", cmd->cmd);
1654 }
1655 }
1656 printf("\n");
1657 ret = 1;
1658 } else if (count == 0) {
1659 printf("Unknown command '%s'\n", argv[0]);
1660 ret = 1;
1661 } else {
1662 ret = match->handler(s, argc - 1, &argv[1]);
1663 }
1664
1665 return ret;
1666 }
1667
1668
1669 struct wlantest_cli {
1670 int s;
1671 };
1672
1673
1674 #define max_args 10
1675
1676 static int tokenize_cmd(char *cmd, char *argv[])
1677 {
1678 char *pos;
1679 int argc = 0;
1680
1681 pos = cmd;
1682 for (;;) {
1683 while (*pos == ' ')
1684 pos++;
1685 if (*pos == '\0')
1686 break;
1687 argv[argc] = pos;
1688 argc++;
1689 if (argc == max_args)
1690 break;
1691 if (*pos == '"') {
1692 char *pos2 = os_strrchr(pos, '"');
1693 if (pos2)
1694 pos = pos2 + 1;
1695 }
1696 while (*pos != '\0' && *pos != ' ')
1697 pos++;
1698 if (*pos == ' ')
1699 *pos++ = '\0';
1700 }
1701
1702 return argc;
1703 }
1704
1705
1706 static void wlantest_cli_edit_cmd_cb(void *ctx, char *cmd)
1707 {
1708 struct wlantest_cli *cli = ctx;
1709 char *argv[max_args];
1710 int argc;
1711 argc = tokenize_cmd(cmd, argv);
1712 if (argc) {
1713 int ret = ctrl_command(cli->s, argc, argv);
1714 if (ret < 0)
1715 printf("FAIL\n");
1716 }
1717 }
1718
1719
1720 static void wlantest_cli_eloop_terminate(int sig, void *signal_ctx)
1721 {
1722 eloop_terminate();
1723 }
1724
1725
1726 static void wlantest_cli_edit_eof_cb(void *ctx)
1727 {
1728 eloop_terminate();
1729 }
1730
1731
1732 static char ** wlantest_cli_cmd_list(void)
1733 {
1734 char **res;
1735 int i;
1736
1737 res = os_calloc(ARRAY_SIZE(wlantest_cli_commands), sizeof(char *));
1738 if (res == NULL)
1739 return NULL;
1740
1741 for (i = 0; wlantest_cli_commands[i].cmd; i++) {
1742 res[i] = os_strdup(wlantest_cli_commands[i].cmd);
1743 if (res[i] == NULL)
1744 break;
1745 }
1746
1747 return res;
1748 }
1749
1750
1751 static char ** wlantest_cli_cmd_completion(struct wlantest_cli *cli,
1752 const char *cmd, const char *str,
1753 int pos)
1754 {
1755 int i;
1756
1757 for (i = 0; wlantest_cli_commands[i].cmd; i++) {
1758 const struct wlantest_cli_cmd *c = &wlantest_cli_commands[i];
1759 if (os_strcasecmp(c->cmd, cmd) == 0) {
1760 edit_clear_line();
1761 printf("\r%s\n", c->usage);
1762 edit_redraw();
1763 if (c->complete)
1764 return c->complete(cli->s, str, pos);
1765 break;
1766 }
1767 }
1768
1769 return NULL;
1770 }
1771
1772
1773 static char ** wlantest_cli_edit_completion_cb(void *ctx, const char *str,
1774 int pos)
1775 {
1776 struct wlantest_cli *cli = ctx;
1777 char **res;
1778 const char *end;
1779 char *cmd;
1780
1781 end = os_strchr(str, ' ');
1782 if (end == NULL || str + pos < end)
1783 return wlantest_cli_cmd_list();
1784
1785 cmd = os_malloc(pos + 1);
1786 if (cmd == NULL)
1787 return NULL;
1788 os_memcpy(cmd, str, pos);
1789 cmd[end - str] = '\0';
1790 res = wlantest_cli_cmd_completion(cli, cmd, str, pos);
1791 os_free(cmd);
1792 return res;
1793 }
1794
1795
1796 static void wlantest_cli_interactive(int s)
1797 {
1798 struct wlantest_cli cli;
1799 char *home, *hfile = NULL;
1800
1801 if (eloop_init())
1802 return;
1803
1804 home = getenv("HOME");
1805 if (home) {
1806 const char *fname = ".wlantest_cli_history";
1807 int hfile_len = os_strlen(home) + 1 + os_strlen(fname) + 1;
1808 hfile = os_malloc(hfile_len);
1809 if (hfile)
1810 os_snprintf(hfile, hfile_len, "%s/%s", home, fname);
1811 }
1812
1813 cli.s = s;
1814 eloop_register_signal_terminate(wlantest_cli_eloop_terminate, &cli);
1815 edit_init(wlantest_cli_edit_cmd_cb, wlantest_cli_edit_eof_cb,
1816 wlantest_cli_edit_completion_cb, &cli, hfile, NULL);
1817
1818 eloop_run();
1819
1820 edit_deinit(hfile, NULL);
1821 os_free(hfile);
1822 eloop_destroy();
1823 }
1824
1825
1826 int main(int argc, char *argv[])
1827 {
1828 int s;
1829 struct sockaddr_un addr;
1830 int ret = 0;
1831
1832 if (os_program_init())
1833 return -1;
1834
1835 s = socket(AF_UNIX, SOCK_SEQPACKET, 0);
1836 if (s < 0) {
1837 perror("socket");
1838 return -1;
1839 }
1840
1841 os_memset(&addr, 0, sizeof(addr));
1842 addr.sun_family = AF_UNIX;
1843 os_strlcpy(addr.sun_path + 1, WLANTEST_SOCK_NAME,
1844 sizeof(addr.sun_path) - 1);
1845 if (connect(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
1846 perror("connect");
1847 close(s);
1848 return -1;
1849 }
1850
1851 if (argc > 1) {
1852 ret = ctrl_command(s, argc - 1, &argv[1]);
1853 if (ret < 0)
1854 printf("FAIL\n");
1855 } else {
1856 wlantest_cli_interactive(s);
1857 }
1858
1859 close(s);
1860
1861 os_program_deinit();
1862
1863 return ret;
1864 }
Unnamed repository; edit this file 'description' to name the repository.