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


ee8114fbd9b8452d7bfb0dcf46865177c52b4ffc
[thirdparty/hostap.git] / hostapd / hostapd_cli.c
1 /*
2 * hostapd - command line interface for hostapd daemon
3 * Copyright (c) 2004-2016, 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 "includes.h"
10 #include <dirent.h>
11
12 #include "common/wpa_ctrl.h"
13 #include "common/ieee802_11_defs.h"
14 #include "utils/common.h"
15 #include "utils/eloop.h"
16 #include "utils/edit.h"
17 #include "common/version.h"
18 #include "common/cli.h"
19
20 #ifndef CONFIG_NO_CTRL_IFACE
21
22 static const char *const hostapd_cli_version =
23 "hostapd_cli v" VERSION_STR "\n"
24 "Copyright (c) 2004-2016, Jouni Malinen <j@w1.fi> and contributors";
25
26 static struct wpa_ctrl *ctrl_conn;
27 static int hostapd_cli_quit = 0;
28 static int hostapd_cli_attached = 0;
29
30 #ifndef CONFIG_CTRL_IFACE_DIR
31 #define CONFIG_CTRL_IFACE_DIR "/var/run/hostapd"
32 #endif /* CONFIG_CTRL_IFACE_DIR */
33 static const char *ctrl_iface_dir = CONFIG_CTRL_IFACE_DIR;
34 static const char *client_socket_dir = NULL;
35
36 static char *ctrl_ifname = NULL;
37 static const char *pid_file = NULL;
38 static const char *action_file = NULL;
39 static int ping_interval = 5;
40 static int interactive = 0;
41 static int event_handler_registered = 0;
42
43 static DEFINE_DL_LIST(stations); /* struct cli_txt_entry */
44
45 static void print_help(FILE *stream, const char *cmd);
46 static char ** list_cmd_list(void);
47 static void hostapd_cli_receive(int sock, void *eloop_ctx, void *sock_ctx);
48 static void update_stations(struct wpa_ctrl *ctrl);
49 static void cli_event(const char *str);
50
51
52 static void usage(void)
53 {
54 fprintf(stderr, "%s\n", hostapd_cli_version);
55 fprintf(stderr,
56 "\n"
57 "usage: hostapd_cli [-p<path>] [-i<ifname>] [-hvB] "
58 "[-a<path>] \\\n"
59 " [-P<pid file>] [-G<ping interval>] [command..]\n"
60 "\n"
61 "Options:\n"
62 " -h help (show this usage text)\n"
63 " -v shown version information\n"
64 " -p<path> path to find control sockets (default: "
65 "/var/run/hostapd)\n"
66 " -s<dir_path> dir path to open client sockets (default: "
67 CONFIG_CTRL_IFACE_DIR ")\n"
68 " -a<file> run in daemon mode executing the action file "
69 "based on events\n"
70 " from hostapd\n"
71 " -B run a daemon in the background\n"
72 " -i<ifname> Interface to listen on (default: first "
73 "interface found in the\n"
74 " socket path)\n\n");
75 print_help(stderr, NULL);
76 }
77
78
79 static void register_event_handler(struct wpa_ctrl *ctrl)
80 {
81 if (!ctrl_conn)
82 return;
83 if (interactive) {
84 event_handler_registered =
85 !eloop_register_read_sock(wpa_ctrl_get_fd(ctrl),
86 hostapd_cli_receive,
87 NULL, NULL);
88 }
89 }
90
91
92 static void unregister_event_handler(struct wpa_ctrl *ctrl)
93 {
94 if (!ctrl_conn)
95 return;
96 if (interactive && event_handler_registered) {
97 eloop_unregister_read_sock(wpa_ctrl_get_fd(ctrl));
98 event_handler_registered = 0;
99 }
100 }
101
102
103 static struct wpa_ctrl * hostapd_cli_open_connection(const char *ifname)
104 {
105 #ifndef CONFIG_CTRL_IFACE_UDP
106 char *cfile;
107 int flen;
108 #endif /* !CONFIG_CTRL_IFACE_UDP */
109
110 if (ifname == NULL)
111 return NULL;
112
113 #ifdef CONFIG_CTRL_IFACE_UDP
114 ctrl_conn = wpa_ctrl_open(ifname);
115 return ctrl_conn;
116 #else /* CONFIG_CTRL_IFACE_UDP */
117 flen = strlen(ctrl_iface_dir) + strlen(ifname) + 2;
118 cfile = malloc(flen);
119 if (cfile == NULL)
120 return NULL;
121 snprintf(cfile, flen, "%s/%s", ctrl_iface_dir, ifname);
122
123 if (client_socket_dir && client_socket_dir[0] &&
124 access(client_socket_dir, F_OK) < 0) {
125 perror(client_socket_dir);
126 free(cfile);
127 return NULL;
128 }
129
130 ctrl_conn = wpa_ctrl_open2(cfile, client_socket_dir);
131 free(cfile);
132 return ctrl_conn;
133 #endif /* CONFIG_CTRL_IFACE_UDP */
134 }
135
136
137 static void hostapd_cli_close_connection(void)
138 {
139 if (ctrl_conn == NULL)
140 return;
141
142 unregister_event_handler(ctrl_conn);
143 if (hostapd_cli_attached) {
144 wpa_ctrl_detach(ctrl_conn);
145 hostapd_cli_attached = 0;
146 }
147 wpa_ctrl_close(ctrl_conn);
148 ctrl_conn = NULL;
149 }
150
151
152 static int hostapd_cli_reconnect(const char *ifname)
153 {
154 char *next_ctrl_ifname;
155
156 hostapd_cli_close_connection();
157
158 if (!ifname)
159 return -1;
160
161 next_ctrl_ifname = os_strdup(ifname);
162 os_free(ctrl_ifname);
163 ctrl_ifname = next_ctrl_ifname;
164 if (!ctrl_ifname)
165 return -1;
166
167 ctrl_conn = hostapd_cli_open_connection(ctrl_ifname);
168 if (!ctrl_conn)
169 return -1;
170 if (!interactive && !action_file)
171 return 0;
172 if (wpa_ctrl_attach(ctrl_conn) == 0) {
173 hostapd_cli_attached = 1;
174 register_event_handler(ctrl_conn);
175 update_stations(ctrl_conn);
176 } else {
177 printf("Warning: Failed to attach to hostapd.\n");
178 }
179 return 0;
180 }
181
182
183 static void hostapd_cli_msg_cb(char *msg, size_t len)
184 {
185 cli_event(msg);
186 printf("%s\n", msg);
187 }
188
189
190 static int _wpa_ctrl_command(struct wpa_ctrl *ctrl, const char *cmd, int print)
191 {
192 char buf[4096];
193 size_t len;
194 int ret;
195
196 if (ctrl_conn == NULL) {
197 printf("Not connected to hostapd - command dropped.\n");
198 return -1;
199 }
200 len = sizeof(buf) - 1;
201 ret = wpa_ctrl_request(ctrl, cmd, strlen(cmd), buf, &len,
202 hostapd_cli_msg_cb);
203 if (ret == -2) {
204 printf("'%s' command timed out.\n", cmd);
205 return -2;
206 } else if (ret < 0) {
207 printf("'%s' command failed.\n", cmd);
208 return -1;
209 }
210 if (print) {
211 buf[len] = '\0';
212 printf("%s", buf);
213 }
214 return 0;
215 }
216
217
218 static inline int wpa_ctrl_command(struct wpa_ctrl *ctrl, const char *cmd)
219 {
220 return _wpa_ctrl_command(ctrl, cmd, 1);
221 }
222
223
224 static int hostapd_cli_cmd(struct wpa_ctrl *ctrl, const char *cmd,
225 int min_args, int argc, char *argv[])
226 {
227 char buf[4096];
228
229 if (argc < min_args) {
230 printf("Invalid %s command - at least %d argument%s required.\n",
231 cmd, min_args, min_args > 1 ? "s are" : " is");
232 return -1;
233 }
234 if (write_cmd(buf, sizeof(buf), cmd, argc, argv) < 0)
235 return -1;
236 return wpa_ctrl_command(ctrl, buf);
237 }
238
239
240 static int hostapd_cli_cmd_ping(struct wpa_ctrl *ctrl, int argc, char *argv[])
241 {
242 return wpa_ctrl_command(ctrl, "PING");
243 }
244
245
246 static int hostapd_cli_cmd_relog(struct wpa_ctrl *ctrl, int argc, char *argv[])
247 {
248 return wpa_ctrl_command(ctrl, "RELOG");
249 }
250
251
252 static int hostapd_cli_cmd_status(struct wpa_ctrl *ctrl, int argc, char *argv[])
253 {
254 if (argc > 0 && os_strcmp(argv[0], "driver") == 0)
255 return wpa_ctrl_command(ctrl, "STATUS-DRIVER");
256 return wpa_ctrl_command(ctrl, "STATUS");
257 }
258
259
260 static int hostapd_cli_cmd_mib(struct wpa_ctrl *ctrl, int argc, char *argv[])
261 {
262 if (argc > 0) {
263 char buf[100];
264 os_snprintf(buf, sizeof(buf), "MIB %s", argv[0]);
265 return wpa_ctrl_command(ctrl, buf);
266 }
267 return wpa_ctrl_command(ctrl, "MIB");
268 }
269
270
271 static int hostapd_cli_exec(const char *program, const char *arg1,
272 const char *arg2)
273 {
274 char *arg;
275 size_t len;
276 int res;
277
278 len = os_strlen(arg1) + os_strlen(arg2) + 2;
279 arg = os_malloc(len);
280 if (arg == NULL)
281 return -1;
282 os_snprintf(arg, len, "%s %s", arg1, arg2);
283 res = os_exec(program, arg, 1);
284 os_free(arg);
285
286 return res;
287 }
288
289
290 static void hostapd_cli_action_process(char *msg, size_t len)
291 {
292 const char *pos;
293
294 pos = msg;
295 if (*pos == '<') {
296 pos = os_strchr(pos, '>');
297 if (pos)
298 pos++;
299 else
300 pos = msg;
301 }
302
303 hostapd_cli_exec(action_file, ctrl_ifname, pos);
304 }
305
306
307 static int hostapd_cli_cmd_sta(struct wpa_ctrl *ctrl, int argc, char *argv[])
308 {
309 char buf[64];
310 if (argc < 1) {
311 printf("Invalid 'sta' command - at least one argument, STA "
312 "address, is required.\n");
313 return -1;
314 }
315 if (argc > 1)
316 snprintf(buf, sizeof(buf), "STA %s %s", argv[0], argv[1]);
317 else
318 snprintf(buf, sizeof(buf), "STA %s", argv[0]);
319 return wpa_ctrl_command(ctrl, buf);
320 }
321
322
323 static char ** hostapd_complete_stations(const char *str, int pos)
324 {
325 int arg = get_cmd_arg_num(str, pos);
326 char **res = NULL;
327
328 switch (arg) {
329 case 1:
330 res = cli_txt_list_array(&stations);
331 break;
332 }
333
334 return res;
335 }
336
337
338 static int hostapd_cli_cmd_new_sta(struct wpa_ctrl *ctrl, int argc,
339 char *argv[])
340 {
341 char buf[64];
342 if (argc != 1) {
343 printf("Invalid 'new_sta' command - exactly one argument, STA "
344 "address, is required.\n");
345 return -1;
346 }
347 snprintf(buf, sizeof(buf), "NEW_STA %s", argv[0]);
348 return wpa_ctrl_command(ctrl, buf);
349 }
350
351
352 static int hostapd_cli_cmd_deauthenticate(struct wpa_ctrl *ctrl, int argc,
353 char *argv[])
354 {
355 char buf[64];
356 if (argc < 1) {
357 printf("Invalid 'deauthenticate' command - exactly one "
358 "argument, STA address, is required.\n");
359 return -1;
360 }
361 if (argc > 1)
362 os_snprintf(buf, sizeof(buf), "DEAUTHENTICATE %s %s",
363 argv[0], argv[1]);
364 else
365 os_snprintf(buf, sizeof(buf), "DEAUTHENTICATE %s", argv[0]);
366 return wpa_ctrl_command(ctrl, buf);
367 }
368
369
370 static int hostapd_cli_cmd_disassociate(struct wpa_ctrl *ctrl, int argc,
371 char *argv[])
372 {
373 char buf[64];
374 if (argc < 1) {
375 printf("Invalid 'disassociate' command - exactly one "
376 "argument, STA address, is required.\n");
377 return -1;
378 }
379 if (argc > 1)
380 os_snprintf(buf, sizeof(buf), "DISASSOCIATE %s %s",
381 argv[0], argv[1]);
382 else
383 os_snprintf(buf, sizeof(buf), "DISASSOCIATE %s", argv[0]);
384 return wpa_ctrl_command(ctrl, buf);
385 }
386
387
388 #ifdef CONFIG_TAXONOMY
389 static int hostapd_cli_cmd_signature(struct wpa_ctrl *ctrl, int argc,
390 char *argv[])
391 {
392 char buf[64];
393
394 if (argc != 1) {
395 printf("Invalid 'signature' command - exactly one argument, STA address, is required.\n");
396 return -1;
397 }
398 os_snprintf(buf, sizeof(buf), "SIGNATURE %s", argv[0]);
399 return wpa_ctrl_command(ctrl, buf);
400 }
401 #endif /* CONFIG_TAXONOMY */
402
403
404 #ifdef CONFIG_IEEE80211W
405 static int hostapd_cli_cmd_sa_query(struct wpa_ctrl *ctrl, int argc,
406 char *argv[])
407 {
408 char buf[64];
409 if (argc != 1) {
410 printf("Invalid 'sa_query' command - exactly one argument, "
411 "STA address, is required.\n");
412 return -1;
413 }
414 snprintf(buf, sizeof(buf), "SA_QUERY %s", argv[0]);
415 return wpa_ctrl_command(ctrl, buf);
416 }
417 #endif /* CONFIG_IEEE80211W */
418
419
420 #ifdef CONFIG_WPS
421 static int hostapd_cli_cmd_wps_pin(struct wpa_ctrl *ctrl, int argc,
422 char *argv[])
423 {
424 char buf[256];
425 if (argc < 2) {
426 printf("Invalid 'wps_pin' command - at least two arguments, "
427 "UUID and PIN, are required.\n");
428 return -1;
429 }
430 if (argc > 3)
431 snprintf(buf, sizeof(buf), "WPS_PIN %s %s %s %s",
432 argv[0], argv[1], argv[2], argv[3]);
433 else if (argc > 2)
434 snprintf(buf, sizeof(buf), "WPS_PIN %s %s %s",
435 argv[0], argv[1], argv[2]);
436 else
437 snprintf(buf, sizeof(buf), "WPS_PIN %s %s", argv[0], argv[1]);
438 return wpa_ctrl_command(ctrl, buf);
439 }
440
441
442 static int hostapd_cli_cmd_wps_check_pin(struct wpa_ctrl *ctrl, int argc,
443 char *argv[])
444 {
445 char cmd[256];
446 int res;
447
448 if (argc != 1 && argc != 2) {
449 printf("Invalid WPS_CHECK_PIN command: needs one argument:\n"
450 "- PIN to be verified\n");
451 return -1;
452 }
453
454 if (argc == 2)
455 res = os_snprintf(cmd, sizeof(cmd), "WPS_CHECK_PIN %s %s",
456 argv[0], argv[1]);
457 else
458 res = os_snprintf(cmd, sizeof(cmd), "WPS_CHECK_PIN %s",
459 argv[0]);
460 if (os_snprintf_error(sizeof(cmd), res)) {
461 printf("Too long WPS_CHECK_PIN command.\n");
462 return -1;
463 }
464 return wpa_ctrl_command(ctrl, cmd);
465 }
466
467
468 static int hostapd_cli_cmd_wps_pbc(struct wpa_ctrl *ctrl, int argc,
469 char *argv[])
470 {
471 return wpa_ctrl_command(ctrl, "WPS_PBC");
472 }
473
474
475 static int hostapd_cli_cmd_wps_cancel(struct wpa_ctrl *ctrl, int argc,
476 char *argv[])
477 {
478 return wpa_ctrl_command(ctrl, "WPS_CANCEL");
479 }
480
481
482 #ifdef CONFIG_WPS_NFC
483 static int hostapd_cli_cmd_wps_nfc_tag_read(struct wpa_ctrl *ctrl, int argc,
484 char *argv[])
485 {
486 int ret;
487 char *buf;
488 size_t buflen;
489
490 if (argc != 1) {
491 printf("Invalid 'wps_nfc_tag_read' command - one argument "
492 "is required.\n");
493 return -1;
494 }
495
496 buflen = 18 + os_strlen(argv[0]);
497 buf = os_malloc(buflen);
498 if (buf == NULL)
499 return -1;
500 os_snprintf(buf, buflen, "WPS_NFC_TAG_READ %s", argv[0]);
501
502 ret = wpa_ctrl_command(ctrl, buf);
503 os_free(buf);
504
505 return ret;
506 }
507
508
509 static int hostapd_cli_cmd_wps_nfc_config_token(struct wpa_ctrl *ctrl,
510 int argc, char *argv[])
511 {
512 char cmd[64];
513 int res;
514
515 if (argc != 1) {
516 printf("Invalid 'wps_nfc_config_token' command - one argument "
517 "is required.\n");
518 return -1;
519 }
520
521 res = os_snprintf(cmd, sizeof(cmd), "WPS_NFC_CONFIG_TOKEN %s",
522 argv[0]);
523 if (os_snprintf_error(sizeof(cmd), res)) {
524 printf("Too long WPS_NFC_CONFIG_TOKEN command.\n");
525 return -1;
526 }
527 return wpa_ctrl_command(ctrl, cmd);
528 }
529
530
531 static int hostapd_cli_cmd_wps_nfc_token(struct wpa_ctrl *ctrl,
532 int argc, char *argv[])
533 {
534 char cmd[64];
535 int res;
536
537 if (argc != 1) {
538 printf("Invalid 'wps_nfc_token' command - one argument is "
539 "required.\n");
540 return -1;
541 }
542
543 res = os_snprintf(cmd, sizeof(cmd), "WPS_NFC_TOKEN %s", argv[0]);
544 if (os_snprintf_error(sizeof(cmd), res)) {
545 printf("Too long WPS_NFC_TOKEN command.\n");
546 return -1;
547 }
548 return wpa_ctrl_command(ctrl, cmd);
549 }
550
551
552 static int hostapd_cli_cmd_nfc_get_handover_sel(struct wpa_ctrl *ctrl,
553 int argc, char *argv[])
554 {
555 char cmd[64];
556 int res;
557
558 if (argc != 2) {
559 printf("Invalid 'nfc_get_handover_sel' command - two arguments "
560 "are required.\n");
561 return -1;
562 }
563
564 res = os_snprintf(cmd, sizeof(cmd), "NFC_GET_HANDOVER_SEL %s %s",
565 argv[0], argv[1]);
566 if (os_snprintf_error(sizeof(cmd), res)) {
567 printf("Too long NFC_GET_HANDOVER_SEL command.\n");
568 return -1;
569 }
570 return wpa_ctrl_command(ctrl, cmd);
571 }
572
573 #endif /* CONFIG_WPS_NFC */
574
575
576 static int hostapd_cli_cmd_wps_ap_pin(struct wpa_ctrl *ctrl, int argc,
577 char *argv[])
578 {
579 char buf[64];
580 if (argc < 1) {
581 printf("Invalid 'wps_ap_pin' command - at least one argument "
582 "is required.\n");
583 return -1;
584 }
585 if (argc > 2)
586 snprintf(buf, sizeof(buf), "WPS_AP_PIN %s %s %s",
587 argv[0], argv[1], argv[2]);
588 else if (argc > 1)
589 snprintf(buf, sizeof(buf), "WPS_AP_PIN %s %s",
590 argv[0], argv[1]);
591 else
592 snprintf(buf, sizeof(buf), "WPS_AP_PIN %s", argv[0]);
593 return wpa_ctrl_command(ctrl, buf);
594 }
595
596
597 static int hostapd_cli_cmd_wps_get_status(struct wpa_ctrl *ctrl, int argc,
598 char *argv[])
599 {
600 return wpa_ctrl_command(ctrl, "WPS_GET_STATUS");
601 }
602
603
604 static int hostapd_cli_cmd_wps_config(struct wpa_ctrl *ctrl, int argc,
605 char *argv[])
606 {
607 char buf[256];
608 char ssid_hex[2 * SSID_MAX_LEN + 1];
609 char key_hex[2 * 64 + 1];
610 int i;
611
612 if (argc < 1) {
613 printf("Invalid 'wps_config' command - at least two arguments "
614 "are required.\n");
615 return -1;
616 }
617
618 ssid_hex[0] = '\0';
619 for (i = 0; i < SSID_MAX_LEN; i++) {
620 if (argv[0][i] == '\0')
621 break;
622 os_snprintf(&ssid_hex[i * 2], 3, "%02x", argv[0][i]);
623 }
624
625 key_hex[0] = '\0';
626 if (argc > 3) {
627 for (i = 0; i < 64; i++) {
628 if (argv[3][i] == '\0')
629 break;
630 os_snprintf(&key_hex[i * 2], 3, "%02x",
631 argv[3][i]);
632 }
633 }
634
635 if (argc > 3)
636 snprintf(buf, sizeof(buf), "WPS_CONFIG %s %s %s %s",
637 ssid_hex, argv[1], argv[2], key_hex);
638 else if (argc > 2)
639 snprintf(buf, sizeof(buf), "WPS_CONFIG %s %s %s",
640 ssid_hex, argv[1], argv[2]);
641 else
642 snprintf(buf, sizeof(buf), "WPS_CONFIG %s %s",
643 ssid_hex, argv[1]);
644 return wpa_ctrl_command(ctrl, buf);
645 }
646 #endif /* CONFIG_WPS */
647
648
649 static int hostapd_cli_cmd_disassoc_imminent(struct wpa_ctrl *ctrl, int argc,
650 char *argv[])
651 {
652 char buf[300];
653 int res;
654
655 if (argc < 2) {
656 printf("Invalid 'disassoc_imminent' command - two arguments "
657 "(STA addr and Disassociation Timer) are needed\n");
658 return -1;
659 }
660
661 res = os_snprintf(buf, sizeof(buf), "DISASSOC_IMMINENT %s %s",
662 argv[0], argv[1]);
663 if (os_snprintf_error(sizeof(buf), res))
664 return -1;
665 return wpa_ctrl_command(ctrl, buf);
666 }
667
668
669 static int hostapd_cli_cmd_ess_disassoc(struct wpa_ctrl *ctrl, int argc,
670 char *argv[])
671 {
672 char buf[300];
673 int res;
674
675 if (argc < 3) {
676 printf("Invalid 'ess_disassoc' command - three arguments (STA "
677 "addr, disassoc timer, and URL) are needed\n");
678 return -1;
679 }
680
681 res = os_snprintf(buf, sizeof(buf), "ESS_DISASSOC %s %s %s",
682 argv[0], argv[1], argv[2]);
683 if (os_snprintf_error(sizeof(buf), res))
684 return -1;
685 return wpa_ctrl_command(ctrl, buf);
686 }
687
688
689 static int hostapd_cli_cmd_bss_tm_req(struct wpa_ctrl *ctrl, int argc,
690 char *argv[])
691 {
692 char buf[2000], *tmp;
693 int res, i, total;
694
695 if (argc < 1) {
696 printf("Invalid 'bss_tm_req' command - at least one argument (STA addr) is needed\n");
697 return -1;
698 }
699
700 res = os_snprintf(buf, sizeof(buf), "BSS_TM_REQ %s", argv[0]);
701 if (os_snprintf_error(sizeof(buf), res))
702 return -1;
703
704 total = res;
705 for (i = 1; i < argc; i++) {
706 tmp = &buf[total];
707 res = os_snprintf(tmp, sizeof(buf) - total, " %s", argv[i]);
708 if (os_snprintf_error(sizeof(buf) - total, res))
709 return -1;
710 total += res;
711 }
712 return wpa_ctrl_command(ctrl, buf);
713 }
714
715
716 static int hostapd_cli_cmd_get_config(struct wpa_ctrl *ctrl, int argc,
717 char *argv[])
718 {
719 return wpa_ctrl_command(ctrl, "GET_CONFIG");
720 }
721
722
723 static int wpa_ctrl_command_sta(struct wpa_ctrl *ctrl, const char *cmd,
724 char *addr, size_t addr_len, int print)
725 {
726 char buf[4096], *pos;
727 size_t len;
728 int ret;
729
730 if (ctrl_conn == NULL) {
731 printf("Not connected to hostapd - command dropped.\n");
732 return -1;
733 }
734 len = sizeof(buf) - 1;
735 ret = wpa_ctrl_request(ctrl, cmd, strlen(cmd), buf, &len,
736 hostapd_cli_msg_cb);
737 if (ret == -2) {
738 printf("'%s' command timed out.\n", cmd);
739 return -2;
740 } else if (ret < 0) {
741 printf("'%s' command failed.\n", cmd);
742 return -1;
743 }
744
745 buf[len] = '\0';
746 if (memcmp(buf, "FAIL", 4) == 0)
747 return -1;
748 if (print)
749 printf("%s", buf);
750
751 pos = buf;
752 while (*pos != '\0' && *pos != '\n')
753 pos++;
754 *pos = '\0';
755 os_strlcpy(addr, buf, addr_len);
756 return 0;
757 }
758
759
760 static int hostapd_cli_cmd_all_sta(struct wpa_ctrl *ctrl, int argc,
761 char *argv[])
762 {
763 char addr[32], cmd[64];
764
765 if (wpa_ctrl_command_sta(ctrl, "STA-FIRST", addr, sizeof(addr), 1))
766 return 0;
767 do {
768 snprintf(cmd, sizeof(cmd), "STA-NEXT %s", addr);
769 } while (wpa_ctrl_command_sta(ctrl, cmd, addr, sizeof(addr), 1) == 0);
770
771 return -1;
772 }
773
774
775 static int hostapd_cli_cmd_list_sta(struct wpa_ctrl *ctrl, int argc,
776 char *argv[])
777 {
778 char addr[32], cmd[64];
779
780 if (wpa_ctrl_command_sta(ctrl, "STA-FIRST", addr, sizeof(addr), 0))
781 return 0;
782 do {
783 if (os_strcmp(addr, "") != 0)
784 printf("%s\n", addr);
785 os_snprintf(cmd, sizeof(cmd), "STA-NEXT %s", addr);
786 } while (wpa_ctrl_command_sta(ctrl, cmd, addr, sizeof(addr), 0) == 0);
787
788 return 0;
789 }
790
791
792 static int hostapd_cli_cmd_help(struct wpa_ctrl *ctrl, int argc, char *argv[])
793 {
794 print_help(stdout, argc > 0 ? argv[0] : NULL);
795 return 0;
796 }
797
798
799 static char ** hostapd_cli_complete_help(const char *str, int pos)
800 {
801 int arg = get_cmd_arg_num(str, pos);
802 char **res = NULL;
803
804 switch (arg) {
805 case 1:
806 res = list_cmd_list();
807 break;
808 }
809
810 return res;
811 }
812
813
814 static int hostapd_cli_cmd_license(struct wpa_ctrl *ctrl, int argc,
815 char *argv[])
816 {
817 printf("%s\n\n%s\n", hostapd_cli_version, cli_full_license);
818 return 0;
819 }
820
821
822 static int hostapd_cli_cmd_set_qos_map_set(struct wpa_ctrl *ctrl,
823 int argc, char *argv[])
824 {
825 char buf[200];
826 int res;
827
828 if (argc != 1) {
829 printf("Invalid 'set_qos_map_set' command - "
830 "one argument (comma delimited QoS map set) "
831 "is needed\n");
832 return -1;
833 }
834
835 res = os_snprintf(buf, sizeof(buf), "SET_QOS_MAP_SET %s", argv[0]);
836 if (os_snprintf_error(sizeof(buf), res))
837 return -1;
838 return wpa_ctrl_command(ctrl, buf);
839 }
840
841
842 static int hostapd_cli_cmd_send_qos_map_conf(struct wpa_ctrl *ctrl,
843 int argc, char *argv[])
844 {
845 char buf[50];
846 int res;
847
848 if (argc != 1) {
849 printf("Invalid 'send_qos_map_conf' command - "
850 "one argument (STA addr) is needed\n");
851 return -1;
852 }
853
854 res = os_snprintf(buf, sizeof(buf), "SEND_QOS_MAP_CONF %s", argv[0]);
855 if (os_snprintf_error(sizeof(buf), res))
856 return -1;
857 return wpa_ctrl_command(ctrl, buf);
858 }
859
860
861 static int hostapd_cli_cmd_hs20_wnm_notif(struct wpa_ctrl *ctrl, int argc,
862 char *argv[])
863 {
864 char buf[300];
865 int res;
866
867 if (argc < 2) {
868 printf("Invalid 'hs20_wnm_notif' command - two arguments (STA "
869 "addr and URL) are needed\n");
870 return -1;
871 }
872
873 res = os_snprintf(buf, sizeof(buf), "HS20_WNM_NOTIF %s %s",
874 argv[0], argv[1]);
875 if (os_snprintf_error(sizeof(buf), res))
876 return -1;
877 return wpa_ctrl_command(ctrl, buf);
878 }
879
880
881 static int hostapd_cli_cmd_hs20_deauth_req(struct wpa_ctrl *ctrl, int argc,
882 char *argv[])
883 {
884 char buf[300];
885 int res;
886
887 if (argc < 3) {
888 printf("Invalid 'hs20_deauth_req' command - at least three arguments (STA addr, Code, Re-auth Delay) are needed\n");
889 return -1;
890 }
891
892 if (argc > 3)
893 res = os_snprintf(buf, sizeof(buf),
894 "HS20_DEAUTH_REQ %s %s %s %s",
895 argv[0], argv[1], argv[2], argv[3]);
896 else
897 res = os_snprintf(buf, sizeof(buf),
898 "HS20_DEAUTH_REQ %s %s %s",
899 argv[0], argv[1], argv[2]);
900 if (os_snprintf_error(sizeof(buf), res))
901 return -1;
902 return wpa_ctrl_command(ctrl, buf);
903 }
904
905
906 static int hostapd_cli_cmd_quit(struct wpa_ctrl *ctrl, int argc, char *argv[])
907 {
908 hostapd_cli_quit = 1;
909 if (interactive)
910 eloop_terminate();
911 return 0;
912 }
913
914
915 static int hostapd_cli_cmd_level(struct wpa_ctrl *ctrl, int argc, char *argv[])
916 {
917 char cmd[256];
918 if (argc != 1) {
919 printf("Invalid LEVEL command: needs one argument (debug "
920 "level)\n");
921 return 0;
922 }
923 snprintf(cmd, sizeof(cmd), "LEVEL %s", argv[0]);
924 return wpa_ctrl_command(ctrl, cmd);
925 }
926
927
928 static void update_stations(struct wpa_ctrl *ctrl)
929 {
930 char addr[32], cmd[64];
931
932 if (!ctrl || !interactive)
933 return;
934
935 cli_txt_list_flush(&stations);
936
937 if (wpa_ctrl_command_sta(ctrl, "STA-FIRST", addr, sizeof(addr), 0))
938 return;
939 do {
940 if (os_strcmp(addr, "") != 0)
941 cli_txt_list_add(&stations, addr);
942 os_snprintf(cmd, sizeof(cmd), "STA-NEXT %s", addr);
943 } while (wpa_ctrl_command_sta(ctrl, cmd, addr, sizeof(addr), 0) == 0);
944 }
945
946
947 static void hostapd_cli_get_interfaces(struct wpa_ctrl *ctrl,
948 struct dl_list *interfaces)
949 {
950 struct dirent *dent;
951 DIR *dir;
952
953 if (!ctrl || !interfaces)
954 return;
955 dir = opendir(ctrl_iface_dir);
956 if (dir == NULL)
957 return;
958
959 while ((dent = readdir(dir))) {
960 if (strcmp(dent->d_name, ".") == 0 ||
961 strcmp(dent->d_name, "..") == 0)
962 continue;
963 cli_txt_list_add(interfaces, dent->d_name);
964 }
965 closedir(dir);
966 }
967
968
969 static void hostapd_cli_list_interfaces(struct wpa_ctrl *ctrl)
970 {
971 struct dirent *dent;
972 DIR *dir;
973
974 dir = opendir(ctrl_iface_dir);
975 if (dir == NULL) {
976 printf("Control interface directory '%s' could not be "
977 "openned.\n", ctrl_iface_dir);
978 return;
979 }
980
981 printf("Available interfaces:\n");
982 while ((dent = readdir(dir))) {
983 if (strcmp(dent->d_name, ".") == 0 ||
984 strcmp(dent->d_name, "..") == 0)
985 continue;
986 printf("%s\n", dent->d_name);
987 }
988 closedir(dir);
989 }
990
991
992 static int hostapd_cli_cmd_interface(struct wpa_ctrl *ctrl, int argc,
993 char *argv[])
994 {
995 if (argc < 1) {
996 hostapd_cli_list_interfaces(ctrl);
997 return 0;
998 }
999 if (hostapd_cli_reconnect(argv[0]) != 0) {
1000 printf("Could not connect to interface '%s' - re-trying\n",
1001 ctrl_ifname);
1002 }
1003 return 0;
1004 }
1005
1006
1007 static char ** hostapd_complete_interface(const char *str, int pos)
1008 {
1009 int arg = get_cmd_arg_num(str, pos);
1010 char **res = NULL;
1011 DEFINE_DL_LIST(interfaces);
1012
1013 switch (arg) {
1014 case 1:
1015 hostapd_cli_get_interfaces(ctrl_conn, &interfaces);
1016 res = cli_txt_list_array(&interfaces);
1017 cli_txt_list_flush(&interfaces);
1018 break;
1019 }
1020
1021 return res;
1022 }
1023
1024
1025 static int hostapd_cli_cmd_set(struct wpa_ctrl *ctrl, int argc, char *argv[])
1026 {
1027 char cmd[256];
1028 int res;
1029
1030 if (argc != 2) {
1031 printf("Invalid SET command: needs two arguments (variable "
1032 "name and value)\n");
1033 return -1;
1034 }
1035
1036 res = os_snprintf(cmd, sizeof(cmd), "SET %s %s", argv[0], argv[1]);
1037 if (os_snprintf_error(sizeof(cmd), res)) {
1038 printf("Too long SET command.\n");
1039 return -1;
1040 }
1041 return wpa_ctrl_command(ctrl, cmd);
1042 }
1043
1044
1045 static int hostapd_cli_cmd_get(struct wpa_ctrl *ctrl, int argc, char *argv[])
1046 {
1047 char cmd[256];
1048 int res;
1049
1050 if (argc != 1) {
1051 printf("Invalid GET command: needs one argument (variable "
1052 "name)\n");
1053 return -1;
1054 }
1055
1056 res = os_snprintf(cmd, sizeof(cmd), "GET %s", argv[0]);
1057 if (os_snprintf_error(sizeof(cmd), res)) {
1058 printf("Too long GET command.\n");
1059 return -1;
1060 }
1061 return wpa_ctrl_command(ctrl, cmd);
1062 }
1063
1064
1065 #ifdef CONFIG_FST
1066 static int hostapd_cli_cmd_fst(struct wpa_ctrl *ctrl, int argc, char *argv[])
1067 {
1068 char cmd[256];
1069 int res;
1070 int i;
1071 int total;
1072
1073 if (argc <= 0) {
1074 printf("FST command: parameters are required.\n");
1075 return -1;
1076 }
1077
1078 total = os_snprintf(cmd, sizeof(cmd), "FST-MANAGER");
1079
1080 for (i = 0; i < argc; i++) {
1081 res = os_snprintf(cmd + total, sizeof(cmd) - total, " %s",
1082 argv[i]);
1083 if (os_snprintf_error(sizeof(cmd) - total, res)) {
1084 printf("Too long fst command.\n");
1085 return -1;
1086 }
1087 total += res;
1088 }
1089 return wpa_ctrl_command(ctrl, cmd);
1090 }
1091 #endif /* CONFIG_FST */
1092
1093
1094 static int hostapd_cli_cmd_chan_switch(struct wpa_ctrl *ctrl,
1095 int argc, char *argv[])
1096 {
1097 char cmd[256];
1098 int res;
1099 int i;
1100 char *tmp;
1101 int total;
1102
1103 if (argc < 2) {
1104 printf("Invalid chan_switch command: needs at least two "
1105 "arguments (count and freq)\n"
1106 "usage: <cs_count> <freq> [sec_channel_offset=] "
1107 "[center_freq1=] [center_freq2=] [bandwidth=] "
1108 "[blocktx] [ht|vht]\n");
1109 return -1;
1110 }
1111
1112 res = os_snprintf(cmd, sizeof(cmd), "CHAN_SWITCH %s %s",
1113 argv[0], argv[1]);
1114 if (os_snprintf_error(sizeof(cmd), res)) {
1115 printf("Too long CHAN_SWITCH command.\n");
1116 return -1;
1117 }
1118
1119 total = res;
1120 for (i = 2; i < argc; i++) {
1121 tmp = cmd + total;
1122 res = os_snprintf(tmp, sizeof(cmd) - total, " %s", argv[i]);
1123 if (os_snprintf_error(sizeof(cmd) - total, res)) {
1124 printf("Too long CHAN_SWITCH command.\n");
1125 return -1;
1126 }
1127 total += res;
1128 }
1129 return wpa_ctrl_command(ctrl, cmd);
1130 }
1131
1132
1133 static int hostapd_cli_cmd_enable(struct wpa_ctrl *ctrl, int argc,
1134 char *argv[])
1135 {
1136 return wpa_ctrl_command(ctrl, "ENABLE");
1137 }
1138
1139
1140 static int hostapd_cli_cmd_reload(struct wpa_ctrl *ctrl, int argc,
1141 char *argv[])
1142 {
1143 return wpa_ctrl_command(ctrl, "RELOAD");
1144 }
1145
1146
1147 static int hostapd_cli_cmd_disable(struct wpa_ctrl *ctrl, int argc,
1148 char *argv[])
1149 {
1150 return wpa_ctrl_command(ctrl, "DISABLE");
1151 }
1152
1153
1154 static int hostapd_cli_cmd_vendor(struct wpa_ctrl *ctrl, int argc, char *argv[])
1155 {
1156 char cmd[256];
1157 int res;
1158
1159 if (argc < 2 || argc > 3) {
1160 printf("Invalid vendor command\n"
1161 "usage: <vendor id> <command id> [<hex formatted command argument>]\n");
1162 return -1;
1163 }
1164
1165 res = os_snprintf(cmd, sizeof(cmd), "VENDOR %s %s %s", argv[0], argv[1],
1166 argc == 3 ? argv[2] : "");
1167 if (os_snprintf_error(sizeof(cmd), res)) {
1168 printf("Too long VENDOR command.\n");
1169 return -1;
1170 }
1171 return wpa_ctrl_command(ctrl, cmd);
1172 }
1173
1174
1175 static int hostapd_cli_cmd_erp_flush(struct wpa_ctrl *ctrl, int argc,
1176 char *argv[])
1177 {
1178 return wpa_ctrl_command(ctrl, "ERP_FLUSH");
1179 }
1180
1181
1182 static int hostapd_cli_cmd_log_level(struct wpa_ctrl *ctrl, int argc,
1183 char *argv[])
1184 {
1185 char cmd[256];
1186 int res;
1187
1188 res = os_snprintf(cmd, sizeof(cmd), "LOG_LEVEL%s%s%s%s",
1189 argc >= 1 ? " " : "",
1190 argc >= 1 ? argv[0] : "",
1191 argc == 2 ? " " : "",
1192 argc == 2 ? argv[1] : "");
1193 if (os_snprintf_error(sizeof(cmd), res)) {
1194 printf("Too long option\n");
1195 return -1;
1196 }
1197 return wpa_ctrl_command(ctrl, cmd);
1198 }
1199
1200
1201 static int hostapd_cli_cmd_raw(struct wpa_ctrl *ctrl, int argc, char *argv[])
1202 {
1203 if (argc == 0)
1204 return -1;
1205 return hostapd_cli_cmd(ctrl, argv[0], 0, argc - 1, &argv[1]);
1206 }
1207
1208
1209 static int hostapd_cli_cmd_pmksa(struct wpa_ctrl *ctrl, int argc, char *argv[])
1210 {
1211 return wpa_ctrl_command(ctrl, "PMKSA");
1212 }
1213
1214
1215 static int hostapd_cli_cmd_pmksa_flush(struct wpa_ctrl *ctrl, int argc,
1216 char *argv[])
1217 {
1218 return wpa_ctrl_command(ctrl, "PMKSA_FLUSH");
1219 }
1220
1221
1222 static int hostapd_cli_cmd_set_neighbor(struct wpa_ctrl *ctrl, int argc,
1223 char *argv[])
1224 {
1225 char cmd[2048];
1226 int res;
1227
1228 if (argc < 3 || argc > 6) {
1229 printf("Invalid set_neighbor command: needs 3-6 arguments\n");
1230 return -1;
1231 }
1232
1233 res = os_snprintf(cmd, sizeof(cmd), "SET_NEIGHBOR %s %s %s %s %s %s",
1234 argv[0], argv[1], argv[2], argc >= 4 ? argv[3] : "",
1235 argc >= 5 ? argv[4] : "", argc == 6 ? argv[5] : "");
1236 if (os_snprintf_error(sizeof(cmd), res)) {
1237 printf("Too long SET_NEIGHBOR command.\n");
1238 return -1;
1239 }
1240 return wpa_ctrl_command(ctrl, cmd);
1241 }
1242
1243
1244 static int hostapd_cli_cmd_remove_neighbor(struct wpa_ctrl *ctrl, int argc,
1245 char *argv[])
1246 {
1247 char cmd[400];
1248 int res;
1249
1250 if (argc != 2) {
1251 printf("Invalid remove_neighbor command: needs 2 arguments\n");
1252 return -1;
1253 }
1254
1255 res = os_snprintf(cmd, sizeof(cmd), "REMOVE_NEIGHBOR %s %s",
1256 argv[0], argv[1]);
1257 if (os_snprintf_error(sizeof(cmd), res)) {
1258 printf("Too long REMOVE_NEIGHBOR command.\n");
1259 return -1;
1260 }
1261 return wpa_ctrl_command(ctrl, cmd);
1262 }
1263
1264
1265 static int hostapd_cli_cmd_req_lci(struct wpa_ctrl *ctrl, int argc,
1266 char *argv[])
1267 {
1268 char cmd[256];
1269 int res;
1270
1271 if (argc != 1) {
1272 printf("Invalid req_lci command - requires destination address\n");
1273 return -1;
1274 }
1275
1276 res = os_snprintf(cmd, sizeof(cmd), "REQ_LCI %s", argv[0]);
1277 if (os_snprintf_error(sizeof(cmd), res)) {
1278 printf("Too long REQ_LCI command.\n");
1279 return -1;
1280 }
1281 return wpa_ctrl_command(ctrl, cmd);
1282 }
1283
1284
1285 static int hostapd_cli_cmd_req_range(struct wpa_ctrl *ctrl, int argc,
1286 char *argv[])
1287 {
1288 if (argc < 4) {
1289 printf("Invalid req_range command: needs at least 4 arguments - dest address, randomization interval, min AP count, and 1 to 16 AP addresses\n");
1290 return -1;
1291 }
1292
1293 return hostapd_cli_cmd(ctrl, "REQ_RANGE", 4, argc, argv);
1294 }
1295
1296
1297 static int hostapd_cli_cmd_driver_flags(struct wpa_ctrl *ctrl, int argc,
1298 char *argv[])
1299 {
1300 return wpa_ctrl_command(ctrl, "DRIVER_FLAGS");
1301 }
1302
1303
1304 struct hostapd_cli_cmd {
1305 const char *cmd;
1306 int (*handler)(struct wpa_ctrl *ctrl, int argc, char *argv[]);
1307 char ** (*completion)(const char *str, int pos);
1308 const char *usage;
1309 };
1310
1311 static const struct hostapd_cli_cmd hostapd_cli_commands[] = {
1312 { "ping", hostapd_cli_cmd_ping, NULL,
1313 "= pings hostapd" },
1314 { "mib", hostapd_cli_cmd_mib, NULL,
1315 "= get MIB variables (dot1x, dot11, radius)" },
1316 { "relog", hostapd_cli_cmd_relog, NULL,
1317 "= reload/truncate debug log output file" },
1318 { "status", hostapd_cli_cmd_status, NULL,
1319 "= show interface status info" },
1320 { "sta", hostapd_cli_cmd_sta, hostapd_complete_stations,
1321 "<addr> = get MIB variables for one station" },
1322 { "all_sta", hostapd_cli_cmd_all_sta, NULL,
1323 "= get MIB variables for all stations" },
1324 { "list_sta", hostapd_cli_cmd_list_sta, NULL,
1325 "= list all stations" },
1326 { "new_sta", hostapd_cli_cmd_new_sta, NULL,
1327 "<addr> = add a new station" },
1328 { "deauthenticate", hostapd_cli_cmd_deauthenticate,
1329 hostapd_complete_stations,
1330 "<addr> = deauthenticate a station" },
1331 { "disassociate", hostapd_cli_cmd_disassociate,
1332 hostapd_complete_stations,
1333 "<addr> = disassociate a station" },
1334 #ifdef CONFIG_TAXONOMY
1335 { "signature", hostapd_cli_cmd_signature, hostapd_complete_stations,
1336 "<addr> = get taxonomy signature for a station" },
1337 #endif /* CONFIG_TAXONOMY */
1338 #ifdef CONFIG_IEEE80211W
1339 { "sa_query", hostapd_cli_cmd_sa_query, hostapd_complete_stations,
1340 "<addr> = send SA Query to a station" },
1341 #endif /* CONFIG_IEEE80211W */
1342 #ifdef CONFIG_WPS
1343 { "wps_pin", hostapd_cli_cmd_wps_pin, NULL,
1344 "<uuid> <pin> [timeout] [addr] = add WPS Enrollee PIN" },
1345 { "wps_check_pin", hostapd_cli_cmd_wps_check_pin, NULL,
1346 "<PIN> = verify PIN checksum" },
1347 { "wps_pbc", hostapd_cli_cmd_wps_pbc, NULL,
1348 "= indicate button pushed to initiate PBC" },
1349 { "wps_cancel", hostapd_cli_cmd_wps_cancel, NULL,
1350 "= cancel the pending WPS operation" },
1351 #ifdef CONFIG_WPS_NFC
1352 { "wps_nfc_tag_read", hostapd_cli_cmd_wps_nfc_tag_read, NULL,
1353 "<hexdump> = report read NFC tag with WPS data" },
1354 { "wps_nfc_config_token", hostapd_cli_cmd_wps_nfc_config_token, NULL,
1355 "<WPS/NDEF> = build NFC configuration token" },
1356 { "wps_nfc_token", hostapd_cli_cmd_wps_nfc_token, NULL,
1357 "<WPS/NDEF/enable/disable> = manager NFC password token" },
1358 { "nfc_get_handover_sel", hostapd_cli_cmd_nfc_get_handover_sel, NULL,
1359 NULL },
1360 #endif /* CONFIG_WPS_NFC */
1361 { "wps_ap_pin", hostapd_cli_cmd_wps_ap_pin, NULL,
1362 "<cmd> [params..] = enable/disable AP PIN" },
1363 { "wps_config", hostapd_cli_cmd_wps_config, NULL,
1364 "<SSID> <auth> <encr> <key> = configure AP" },
1365 { "wps_get_status", hostapd_cli_cmd_wps_get_status, NULL,
1366 "= show current WPS status" },
1367 #endif /* CONFIG_WPS */
1368 { "disassoc_imminent", hostapd_cli_cmd_disassoc_imminent, NULL,
1369 "= send Disassociation Imminent notification" },
1370 { "ess_disassoc", hostapd_cli_cmd_ess_disassoc, NULL,
1371 "= send ESS Dissassociation Imminent notification" },
1372 { "bss_tm_req", hostapd_cli_cmd_bss_tm_req, NULL,
1373 "= send BSS Transition Management Request" },
1374 { "get_config", hostapd_cli_cmd_get_config, NULL,
1375 "= show current configuration" },
1376 { "help", hostapd_cli_cmd_help, hostapd_cli_complete_help,
1377 "= show this usage help" },
1378 { "interface", hostapd_cli_cmd_interface, hostapd_complete_interface,
1379 "[ifname] = show interfaces/select interface" },
1380 #ifdef CONFIG_FST
1381 { "fst", hostapd_cli_cmd_fst, NULL,
1382 "<params...> = send FST-MANAGER control interface command" },
1383 #endif /* CONFIG_FST */
1384 { "raw", hostapd_cli_cmd_raw, NULL,
1385 "<params..> = send unprocessed command" },
1386 { "level", hostapd_cli_cmd_level, NULL,
1387 "<debug level> = change debug level" },
1388 { "license", hostapd_cli_cmd_license, NULL,
1389 "= show full hostapd_cli license" },
1390 { "quit", hostapd_cli_cmd_quit, NULL,
1391 "= exit hostapd_cli" },
1392 { "set", hostapd_cli_cmd_set, NULL,
1393 "<name> <value> = set runtime variables" },
1394 { "get", hostapd_cli_cmd_get, NULL,
1395 "<name> = get runtime info" },
1396 { "set_qos_map_set", hostapd_cli_cmd_set_qos_map_set, NULL,
1397 "<arg,arg,...> = set QoS Map set element" },
1398 { "send_qos_map_conf", hostapd_cli_cmd_send_qos_map_conf,
1399 hostapd_complete_stations,
1400 "<addr> = send QoS Map Configure frame" },
1401 { "chan_switch", hostapd_cli_cmd_chan_switch, NULL,
1402 "<cs_count> <freq> [sec_channel_offset=] [center_freq1=]\n"
1403 " [center_freq2=] [bandwidth=] [blocktx] [ht|vht]\n"
1404 " = initiate channel switch announcement" },
1405 { "hs20_wnm_notif", hostapd_cli_cmd_hs20_wnm_notif, NULL,
1406 "<addr> <url>\n"
1407 " = send WNM-Notification Subscription Remediation Request" },
1408 { "hs20_deauth_req", hostapd_cli_cmd_hs20_deauth_req, NULL,
1409 "<addr> <code (0/1)> <Re-auth-Delay(sec)> [url]\n"
1410 " = send WNM-Notification imminent deauthentication indication" },
1411 { "vendor", hostapd_cli_cmd_vendor, NULL,
1412 "<vendor id> <sub command id> [<hex formatted data>]\n"
1413 " = send vendor driver command" },
1414 { "enable", hostapd_cli_cmd_enable, NULL,
1415 "= enable hostapd on current interface" },
1416 { "reload", hostapd_cli_cmd_reload, NULL,
1417 "= reload configuration for current interface" },
1418 { "disable", hostapd_cli_cmd_disable, NULL,
1419 "= disable hostapd on current interface" },
1420 { "erp_flush", hostapd_cli_cmd_erp_flush, NULL,
1421 "= drop all ERP keys"},
1422 { "log_level", hostapd_cli_cmd_log_level, NULL,
1423 "[level] = show/change log verbosity level" },
1424 { "pmksa", hostapd_cli_cmd_pmksa, NULL,
1425 " = show PMKSA cache entries" },
1426 { "pmksa_flush", hostapd_cli_cmd_pmksa_flush, NULL,
1427 " = flush PMKSA cache" },
1428 { "set_neighbor", hostapd_cli_cmd_set_neighbor, NULL,
1429 "<addr> <ssid=> <nr=> [lci=] [civic=] [stat]\n"
1430 " = add AP to neighbor database" },
1431 { "remove_neighbor", hostapd_cli_cmd_remove_neighbor, NULL,
1432 "<addr> <ssid=> = remove AP from neighbor database" },
1433 { "req_lci", hostapd_cli_cmd_req_lci, hostapd_complete_stations,
1434 "<addr> = send LCI request to a station"},
1435 { "req_range", hostapd_cli_cmd_req_range, NULL,
1436 " = send FTM range request"},
1437 { "driver_flags", hostapd_cli_cmd_driver_flags, NULL,
1438 " = show supported driver flags"},
1439 { NULL, NULL, NULL, NULL }
1440 };
1441
1442
1443 /*
1444 * Prints command usage, lines are padded with the specified string.
1445 */
1446 static void print_cmd_help(FILE *stream, const struct hostapd_cli_cmd *cmd,
1447 const char *pad)
1448 {
1449 char c;
1450 size_t n;
1451
1452 if (cmd->usage == NULL)
1453 return;
1454 fprintf(stream, "%s%s ", pad, cmd->cmd);
1455 for (n = 0; (c = cmd->usage[n]); n++) {
1456 fprintf(stream, "%c", c);
1457 if (c == '\n')
1458 fprintf(stream, "%s", pad);
1459 }
1460 fprintf(stream, "\n");
1461 }
1462
1463
1464 static void print_help(FILE *stream, const char *cmd)
1465 {
1466 int n;
1467
1468 fprintf(stream, "commands:\n");
1469 for (n = 0; hostapd_cli_commands[n].cmd; n++) {
1470 if (cmd == NULL || str_starts(hostapd_cli_commands[n].cmd, cmd))
1471 print_cmd_help(stream, &hostapd_cli_commands[n], " ");
1472 }
1473 }
1474
1475
1476 static void wpa_request(struct wpa_ctrl *ctrl, int argc, char *argv[])
1477 {
1478 const struct hostapd_cli_cmd *cmd, *match = NULL;
1479 int count;
1480
1481 count = 0;
1482 cmd = hostapd_cli_commands;
1483 while (cmd->cmd) {
1484 if (strncasecmp(cmd->cmd, argv[0], strlen(argv[0])) == 0) {
1485 match = cmd;
1486 if (os_strcasecmp(cmd->cmd, argv[0]) == 0) {
1487 /* we have an exact match */
1488 count = 1;
1489 break;
1490 }
1491 count++;
1492 }
1493 cmd++;
1494 }
1495
1496 if (count > 1) {
1497 printf("Ambiguous command '%s'; possible commands:", argv[0]);
1498 cmd = hostapd_cli_commands;
1499 while (cmd->cmd) {
1500 if (strncasecmp(cmd->cmd, argv[0], strlen(argv[0])) ==
1501 0) {
1502 printf(" %s", cmd->cmd);
1503 }
1504 cmd++;
1505 }
1506 printf("\n");
1507 } else if (count == 0) {
1508 printf("Unknown command '%s'\n", argv[0]);
1509 } else {
1510 match->handler(ctrl, argc - 1, &argv[1]);
1511 }
1512 }
1513
1514
1515 static void cli_event(const char *str)
1516 {
1517 const char *start, *s;
1518
1519 start = os_strchr(str, '>');
1520 if (start == NULL)
1521 return;
1522
1523 start++;
1524
1525 if (str_starts(start, AP_STA_CONNECTED)) {
1526 s = os_strchr(start, ' ');
1527 if (s == NULL)
1528 return;
1529 cli_txt_list_add(&stations, s + 1);
1530 return;
1531 }
1532
1533 if (str_starts(start, AP_STA_DISCONNECTED)) {
1534 s = os_strchr(start, ' ');
1535 if (s == NULL)
1536 return;
1537 cli_txt_list_del_addr(&stations, s + 1);
1538 return;
1539 }
1540 }
1541
1542
1543 static void hostapd_cli_recv_pending(struct wpa_ctrl *ctrl, int in_read,
1544 int action_monitor)
1545 {
1546 int first = 1;
1547 if (ctrl_conn == NULL)
1548 return;
1549 while (wpa_ctrl_pending(ctrl)) {
1550 char buf[256];
1551 size_t len = sizeof(buf) - 1;
1552 if (wpa_ctrl_recv(ctrl, buf, &len) == 0) {
1553 buf[len] = '\0';
1554 if (action_monitor)
1555 hostapd_cli_action_process(buf, len);
1556 else {
1557 cli_event(buf);
1558 if (in_read && first)
1559 printf("\n");
1560 first = 0;
1561 printf("%s\n", buf);
1562 }
1563 } else {
1564 printf("Could not read pending message.\n");
1565 break;
1566 }
1567 }
1568 }
1569
1570
1571 static void hostapd_cli_receive(int sock, void *eloop_ctx, void *sock_ctx)
1572 {
1573 hostapd_cli_recv_pending(ctrl_conn, 0, 0);
1574 }
1575
1576
1577 static void hostapd_cli_ping(void *eloop_ctx, void *timeout_ctx)
1578 {
1579 if (ctrl_conn && _wpa_ctrl_command(ctrl_conn, "PING", 0)) {
1580 printf("Connection to hostapd lost - trying to reconnect\n");
1581 hostapd_cli_close_connection();
1582 }
1583 if (!ctrl_conn && hostapd_cli_reconnect(ctrl_ifname) == 0)
1584 printf("Connection to hostapd re-established\n");
1585 if (ctrl_conn)
1586 hostapd_cli_recv_pending(ctrl_conn, 1, 0);
1587 eloop_register_timeout(ping_interval, 0, hostapd_cli_ping, NULL, NULL);
1588 }
1589
1590
1591 static void hostapd_cli_eloop_terminate(int sig, void *signal_ctx)
1592 {
1593 eloop_terminate();
1594 }
1595
1596
1597 static void hostapd_cli_edit_cmd_cb(void *ctx, char *cmd)
1598 {
1599 char *argv[max_args];
1600 int argc;
1601 argc = tokenize_cmd(cmd, argv);
1602 if (argc)
1603 wpa_request(ctrl_conn, argc, argv);
1604 }
1605
1606
1607 static void hostapd_cli_edit_eof_cb(void *ctx)
1608 {
1609 eloop_terminate();
1610 }
1611
1612
1613 static char ** list_cmd_list(void)
1614 {
1615 char **res;
1616 int i, count;
1617
1618 count = ARRAY_SIZE(hostapd_cli_commands);
1619 res = os_calloc(count + 1, sizeof(char *));
1620 if (res == NULL)
1621 return NULL;
1622
1623 for (i = 0; hostapd_cli_commands[i].cmd; i++) {
1624 res[i] = os_strdup(hostapd_cli_commands[i].cmd);
1625 if (res[i] == NULL)
1626 break;
1627 }
1628
1629 return res;
1630 }
1631
1632
1633 static char ** hostapd_cli_cmd_completion(const char *cmd, const char *str,
1634 int pos)
1635 {
1636 int i;
1637
1638 for (i = 0; hostapd_cli_commands[i].cmd; i++) {
1639 if (os_strcasecmp(hostapd_cli_commands[i].cmd, cmd) != 0)
1640 continue;
1641 if (hostapd_cli_commands[i].completion)
1642 return hostapd_cli_commands[i].completion(str, pos);
1643 if (!hostapd_cli_commands[i].usage)
1644 return NULL;
1645 edit_clear_line();
1646 printf("\r%s\n", hostapd_cli_commands[i].usage);
1647 edit_redraw();
1648 break;
1649 }
1650
1651 return NULL;
1652 }
1653
1654
1655 static char ** hostapd_cli_edit_completion_cb(void *ctx, const char *str,
1656 int pos)
1657 {
1658 char **res;
1659 const char *end;
1660 char *cmd;
1661
1662 end = os_strchr(str, ' ');
1663 if (end == NULL || str + pos < end)
1664 return list_cmd_list();
1665
1666 cmd = os_malloc(pos + 1);
1667 if (cmd == NULL)
1668 return NULL;
1669 os_memcpy(cmd, str, pos);
1670 cmd[end - str] = '\0';
1671 res = hostapd_cli_cmd_completion(cmd, str, pos);
1672 os_free(cmd);
1673 return res;
1674 }
1675
1676
1677 static void hostapd_cli_interactive(void)
1678 {
1679 char *hfile = NULL;
1680 char *home;
1681
1682 printf("\nInteractive mode\n\n");
1683
1684 #ifdef CONFIG_HOSTAPD_CLI_HISTORY_DIR
1685 home = CONFIG_HOSTAPD_CLI_HISTORY_DIR;
1686 #else /* CONFIG_HOSTAPD_CLI_HISTORY_DIR */
1687 home = getenv("HOME");
1688 #endif /* CONFIG_HOSTAPD_CLI_HISTORY_DIR */
1689 if (home) {
1690 const char *fname = ".hostapd_cli_history";
1691 int hfile_len = os_strlen(home) + 1 + os_strlen(fname) + 1;
1692 hfile = os_malloc(hfile_len);
1693 if (hfile)
1694 os_snprintf(hfile, hfile_len, "%s/%s", home, fname);
1695 }
1696
1697 eloop_register_signal_terminate(hostapd_cli_eloop_terminate, NULL);
1698 edit_init(hostapd_cli_edit_cmd_cb, hostapd_cli_edit_eof_cb,
1699 hostapd_cli_edit_completion_cb, NULL, hfile, NULL);
1700 eloop_register_timeout(ping_interval, 0, hostapd_cli_ping, NULL, NULL);
1701
1702 eloop_run();
1703
1704 cli_txt_list_flush(&stations);
1705 edit_deinit(hfile, NULL);
1706 os_free(hfile);
1707 eloop_cancel_timeout(hostapd_cli_ping, NULL, NULL);
1708 }
1709
1710
1711 static void hostapd_cli_cleanup(void)
1712 {
1713 hostapd_cli_close_connection();
1714 if (pid_file)
1715 os_daemonize_terminate(pid_file);
1716
1717 os_program_deinit();
1718 }
1719
1720
1721 static void hostapd_cli_action(struct wpa_ctrl *ctrl)
1722 {
1723 fd_set rfds;
1724 int fd, res;
1725 struct timeval tv;
1726 char buf[256];
1727 size_t len;
1728
1729 fd = wpa_ctrl_get_fd(ctrl);
1730
1731 while (!hostapd_cli_quit) {
1732 FD_ZERO(&rfds);
1733 FD_SET(fd, &rfds);
1734 tv.tv_sec = ping_interval;
1735 tv.tv_usec = 0;
1736 res = select(fd + 1, &rfds, NULL, NULL, &tv);
1737 if (res < 0 && errno != EINTR) {
1738 perror("select");
1739 break;
1740 }
1741
1742 if (FD_ISSET(fd, &rfds))
1743 hostapd_cli_recv_pending(ctrl, 0, 1);
1744 else {
1745 len = sizeof(buf) - 1;
1746 if (wpa_ctrl_request(ctrl, "PING", 4, buf, &len,
1747 hostapd_cli_action_process) < 0 ||
1748 len < 4 || os_memcmp(buf, "PONG", 4) != 0) {
1749 printf("hostapd did not reply to PING "
1750 "command - exiting\n");
1751 break;
1752 }
1753 }
1754 }
1755 }
1756
1757
1758 int main(int argc, char *argv[])
1759 {
1760 int warning_displayed = 0;
1761 int c;
1762 int daemonize = 0;
1763
1764 if (os_program_init())
1765 return -1;
1766
1767 for (;;) {
1768 c = getopt(argc, argv, "a:BhG:i:p:P:s:v");
1769 if (c < 0)
1770 break;
1771 switch (c) {
1772 case 'a':
1773 action_file = optarg;
1774 break;
1775 case 'B':
1776 daemonize = 1;
1777 break;
1778 case 'G':
1779 ping_interval = atoi(optarg);
1780 break;
1781 case 'h':
1782 usage();
1783 return 0;
1784 case 'v':
1785 printf("%s\n", hostapd_cli_version);
1786 return 0;
1787 case 'i':
1788 os_free(ctrl_ifname);
1789 ctrl_ifname = os_strdup(optarg);
1790 break;
1791 case 'p':
1792 ctrl_iface_dir = optarg;
1793 break;
1794 case 'P':
1795 pid_file = optarg;
1796 break;
1797 case 's':
1798 client_socket_dir = optarg;
1799 break;
1800 default:
1801 usage();
1802 return -1;
1803 }
1804 }
1805
1806 interactive = (argc == optind) && (action_file == NULL);
1807
1808 if (interactive) {
1809 printf("%s\n\n%s\n\n", hostapd_cli_version, cli_license);
1810 }
1811
1812 if (eloop_init())
1813 return -1;
1814
1815 for (;;) {
1816 if (ctrl_ifname == NULL) {
1817 struct dirent *dent;
1818 DIR *dir = opendir(ctrl_iface_dir);
1819 if (dir) {
1820 while ((dent = readdir(dir))) {
1821 if (os_strcmp(dent->d_name, ".") == 0
1822 ||
1823 os_strcmp(dent->d_name, "..") == 0)
1824 continue;
1825 printf("Selected interface '%s'\n",
1826 dent->d_name);
1827 ctrl_ifname = os_strdup(dent->d_name);
1828 break;
1829 }
1830 closedir(dir);
1831 }
1832 }
1833 hostapd_cli_reconnect(ctrl_ifname);
1834 if (ctrl_conn) {
1835 if (warning_displayed)
1836 printf("Connection established.\n");
1837 break;
1838 }
1839
1840 if (!interactive) {
1841 perror("Failed to connect to hostapd - "
1842 "wpa_ctrl_open");
1843 return -1;
1844 }
1845
1846 if (!warning_displayed) {
1847 printf("Could not connect to hostapd - re-trying\n");
1848 warning_displayed = 1;
1849 }
1850 os_sleep(1, 0);
1851 continue;
1852 }
1853
1854 if (action_file && !hostapd_cli_attached)
1855 return -1;
1856 if (daemonize && os_daemonize(pid_file) && eloop_sock_requeue())
1857 return -1;
1858
1859 if (interactive)
1860 hostapd_cli_interactive();
1861 else if (action_file)
1862 hostapd_cli_action(ctrl_conn);
1863 else
1864 wpa_request(ctrl_conn, argc - optind, &argv[optind]);
1865
1866 unregister_event_handler(ctrl_conn);
1867 os_free(ctrl_ifname);
1868 eloop_destroy();
1869 hostapd_cli_cleanup();
1870 return 0;
1871 }
1872
1873 #else /* CONFIG_NO_CTRL_IFACE */
1874
1875 int main(int argc, char *argv[])
1876 {
1877 return -1;
1878 }
1879
1880 #endif /* CONFIG_NO_CTRL_IFACE */
Unnamed repository; edit this file 'description' to name the repository.