2 * WPA Supplicant - command line interface for wpa_supplicant daemon
3 * Copyright (c) 2004-2012, Jouni Malinen <j@w1.fi>
5 * This software may be distributed under the terms of the BSD license.
6 * See README for more details.
11 #ifdef CONFIG_CTRL_IFACE
13 #ifdef CONFIG_CTRL_IFACE_UNIX
15 #endif /* CONFIG_CTRL_IFACE_UNIX */
17 #include "common/wpa_ctrl.h"
18 #include "utils/common.h"
19 #include "utils/eloop.h"
20 #include "utils/edit.h"
21 #include "utils/list.h"
22 #include "common/version.h"
23 #include "common/ieee802_11_defs.h"
25 #include <cutils/properties.h>
29 static const char *wpa_cli_version =
30 "wpa_cli v" VERSION_STR "\n"
31 "Copyright (c) 2004-2012, Jouni Malinen <j@w1.fi> and contributors";
34 static const char *wpa_cli_license =
35 "This software may be distributed under the terms of the BSD license.\n"
36 "See README for more details.\n";
38 static const char *wpa_cli_full_license =
39 "This software may be distributed under the terms of the BSD license.\n"
41 "Redistribution and use in source and binary forms, with or without\n"
42 "modification, are permitted provided that the following conditions are\n"
45 "1. Redistributions of source code must retain the above copyright\n"
46 " notice, this list of conditions and the following disclaimer.\n"
48 "2. Redistributions in binary form must reproduce the above copyright\n"
49 " notice, this list of conditions and the following disclaimer in the\n"
50 " documentation and/or other materials provided with the distribution.\n"
52 "3. Neither the name(s) of the above-listed copyright holder(s) nor the\n"
53 " names of its contributors may be used to endorse or promote products\n"
54 " derived from this software without specific prior written permission.\n"
56 "THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n"
57 "\"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n"
58 "LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n"
59 "A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n"
60 "OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n"
61 "SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n"
62 "LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n"
63 "DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n"
64 "THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n"
65 "(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n"
66 "OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n"
69 static struct wpa_ctrl *ctrl_conn;
70 static struct wpa_ctrl *mon_conn;
71 static int wpa_cli_quit = 0;
72 static int wpa_cli_attached = 0;
73 static int wpa_cli_connected = 0;
74 static int wpa_cli_last_id = 0;
75 #ifndef CONFIG_CTRL_IFACE_DIR
76 #define CONFIG_CTRL_IFACE_DIR "/var/run/wpa_supplicant"
77 #endif /* CONFIG_CTRL_IFACE_DIR */
78 static const char *ctrl_iface_dir = CONFIG_CTRL_IFACE_DIR;
79 static char *ctrl_ifname = NULL;
80 static const char *pid_file = NULL;
81 static const char *action_file = NULL;
82 static int ping_interval = 5;
83 static int interactive = 0;
85 struct cli_txt_entry {
90 static DEFINE_DL_LIST(bsses); /* struct cli_txt_entry */
91 static DEFINE_DL_LIST(p2p_peers); /* struct cli_txt_entry */
92 static DEFINE_DL_LIST(p2p_groups); /* struct cli_txt_entry */
95 static void print_help(const char *cmd);
96 static void wpa_cli_mon_receive(int sock, void *eloop_ctx, void *sock_ctx);
97 static void wpa_cli_close_connection(void);
98 static char * wpa_cli_get_default_ifname(void);
99 static char ** wpa_list_cmd_list(void);
102 static void usage(void)
104 printf("wpa_cli [-p<path to ctrl sockets>] [-i<ifname>] [-hvB] "
105 "[-a<action file>] \\\n"
106 " [-P<pid file>] [-g<global ctrl>] [-G<ping interval>] "
108 " -h = help (show this usage text)\n"
109 " -v = shown version information\n"
110 " -a = run in daemon mode executing the action file based on "
113 " -B = run a daemon in the background\n"
114 " default path: " CONFIG_CTRL_IFACE_DIR "\n"
115 " default interface: first interface found in socket path\n");
120 static void cli_txt_list_free(struct cli_txt_entry *e)
122 dl_list_del(&e->list);
128 static void cli_txt_list_flush(struct dl_list *list)
130 struct cli_txt_entry *e;
131 while ((e = dl_list_first(list, struct cli_txt_entry, list)))
132 cli_txt_list_free(e);
136 static struct cli_txt_entry * cli_txt_list_get(struct dl_list *txt_list,
139 struct cli_txt_entry *e;
140 dl_list_for_each(e, txt_list, struct cli_txt_entry, list) {
141 if (os_strcmp(e->txt, txt) == 0)
148 static void cli_txt_list_del(struct dl_list *txt_list, const char *txt)
150 struct cli_txt_entry *e;
151 e = cli_txt_list_get(txt_list, txt);
153 cli_txt_list_free(e);
157 static void cli_txt_list_del_addr(struct dl_list *txt_list, const char *txt)
161 if (hwaddr_aton(txt, addr) < 0)
163 os_snprintf(buf, sizeof(buf), MACSTR, MAC2STR(addr));
164 cli_txt_list_del(txt_list, buf);
169 static void cli_txt_list_del_word(struct dl_list *txt_list, const char *txt)
173 end = os_strchr(txt, ' ');
175 end = txt + os_strlen(txt);
176 buf = os_malloc(end - txt + 1);
179 os_memcpy(buf, txt, end - txt);
180 buf[end - txt] = '\0';
181 cli_txt_list_del(txt_list, buf);
184 #endif /* CONFIG_P2P */
187 static int cli_txt_list_add(struct dl_list *txt_list, const char *txt)
189 struct cli_txt_entry *e;
190 e = cli_txt_list_get(txt_list, txt);
193 e = os_zalloc(sizeof(*e));
196 e->txt = os_strdup(txt);
197 if (e->txt == NULL) {
201 dl_list_add(txt_list, &e->list);
207 static int cli_txt_list_add_addr(struct dl_list *txt_list, const char *txt)
211 if (hwaddr_aton(txt, addr) < 0)
213 os_snprintf(buf, sizeof(buf), MACSTR, MAC2STR(addr));
214 return cli_txt_list_add(txt_list, buf);
218 static int cli_txt_list_add_word(struct dl_list *txt_list, const char *txt)
223 end = os_strchr(txt, ' ');
225 end = txt + os_strlen(txt);
226 buf = os_malloc(end - txt + 1);
229 os_memcpy(buf, txt, end - txt);
230 buf[end - txt] = '\0';
231 ret = cli_txt_list_add(txt_list, buf);
235 #endif /* CONFIG_P2P */
238 static char ** cli_txt_list_array(struct dl_list *txt_list)
240 unsigned int i, count = dl_list_len(txt_list);
242 struct cli_txt_entry *e;
244 res = os_calloc(count + 1, sizeof(char *));
249 dl_list_for_each(e, txt_list, struct cli_txt_entry, list) {
250 res[i] = os_strdup(e->txt);
260 static int get_cmd_arg_num(const char *str, int pos)
264 for (i = 0; i <= pos; i++) {
267 while (i <= pos && str[i] != ' ')
278 static int str_starts(const char *src, const char *match)
280 return os_strncmp(src, match, os_strlen(match)) == 0;
284 static int wpa_cli_show_event(const char *event)
288 start = os_strchr(event, '>');
294 * Skip BSS added/removed events since they can be relatively frequent
295 * and are likely of not much use for an interactive user.
297 if (str_starts(start, WPA_EVENT_BSS_ADDED) ||
298 str_starts(start, WPA_EVENT_BSS_REMOVED))
305 static int wpa_cli_open_connection(const char *ifname, int attach)
307 #if defined(CONFIG_CTRL_IFACE_UDP) || defined(CONFIG_CTRL_IFACE_NAMED_PIPE)
308 ctrl_conn = wpa_ctrl_open(ifname);
309 if (ctrl_conn == NULL)
312 if (attach && interactive)
313 mon_conn = wpa_ctrl_open(ifname);
316 #else /* CONFIG_CTRL_IFACE_UDP || CONFIG_CTRL_IFACE_NAMED_PIPE */
324 if (access(ctrl_iface_dir, F_OK) < 0) {
325 cfile = os_strdup(ifname);
332 flen = os_strlen(ctrl_iface_dir) + os_strlen(ifname) + 2;
333 cfile = os_malloc(flen);
336 res = os_snprintf(cfile, flen, "%s/%s", ctrl_iface_dir,
338 if (res < 0 || res >= flen) {
344 ctrl_conn = wpa_ctrl_open(cfile);
345 if (ctrl_conn == NULL) {
350 if (attach && interactive)
351 mon_conn = wpa_ctrl_open(cfile);
355 #endif /* CONFIG_CTRL_IFACE_UDP || CONFIG_CTRL_IFACE_NAMED_PIPE */
358 if (wpa_ctrl_attach(mon_conn) == 0) {
359 wpa_cli_attached = 1;
361 eloop_register_read_sock(
362 wpa_ctrl_get_fd(mon_conn),
363 wpa_cli_mon_receive, NULL, NULL);
365 printf("Warning: Failed to attach to "
366 "wpa_supplicant.\n");
367 wpa_cli_close_connection();
376 static void wpa_cli_close_connection(void)
378 if (ctrl_conn == NULL)
381 if (wpa_cli_attached) {
382 wpa_ctrl_detach(interactive ? mon_conn : ctrl_conn);
383 wpa_cli_attached = 0;
385 wpa_ctrl_close(ctrl_conn);
388 eloop_unregister_read_sock(wpa_ctrl_get_fd(mon_conn));
389 wpa_ctrl_close(mon_conn);
395 static void wpa_cli_msg_cb(char *msg, size_t len)
401 static int _wpa_ctrl_command(struct wpa_ctrl *ctrl, char *cmd, int print)
407 if (ctrl_conn == NULL) {
408 printf("Not connected to wpa_supplicant - command dropped.\n");
411 len = sizeof(buf) - 1;
412 ret = wpa_ctrl_request(ctrl, cmd, os_strlen(cmd), buf, &len,
415 printf("'%s' command timed out.\n", cmd);
417 } else if (ret < 0) {
418 printf("'%s' command failed.\n", cmd);
424 if (interactive && len > 0 && buf[len - 1] != '\n')
431 static int wpa_ctrl_command(struct wpa_ctrl *ctrl, char *cmd)
433 return _wpa_ctrl_command(ctrl, cmd, 1);
437 static int write_cmd(char *buf, size_t buflen, const char *cmd, int argc,
446 res = os_snprintf(pos, end - pos, "%s", cmd);
447 if (res < 0 || res >= end - pos)
451 for (i = 0; i < argc; i++) {
452 res = os_snprintf(pos, end - pos, " %s", argv[i]);
453 if (res < 0 || res >= end - pos)
458 buf[buflen - 1] = '\0';
462 printf("Too long command\n");
467 static int wpa_cli_cmd(struct wpa_ctrl *ctrl, const char *cmd, int min_args,
468 int argc, char *argv[])
471 if (argc < min_args) {
472 printf("Invalid %s command - at least %d argument%s "
473 "required.\n", cmd, min_args,
474 min_args > 1 ? "s are" : " is");
477 if (write_cmd(buf, sizeof(buf), cmd, argc, argv) < 0)
479 return wpa_ctrl_command(ctrl, buf);
483 static int wpa_cli_cmd_ifname(struct wpa_ctrl *ctrl, int argc, char *argv[])
485 return wpa_ctrl_command(ctrl, "IFNAME");
489 static int wpa_cli_cmd_status(struct wpa_ctrl *ctrl, int argc, char *argv[])
491 if (argc > 0 && os_strcmp(argv[0], "verbose") == 0)
492 return wpa_ctrl_command(ctrl, "STATUS-VERBOSE");
493 if (argc > 0 && os_strcmp(argv[0], "wps") == 0)
494 return wpa_ctrl_command(ctrl, "STATUS-WPS");
495 return wpa_ctrl_command(ctrl, "STATUS");
499 static int wpa_cli_cmd_ping(struct wpa_ctrl *ctrl, int argc, char *argv[])
501 return wpa_ctrl_command(ctrl, "PING");
505 static int wpa_cli_cmd_relog(struct wpa_ctrl *ctrl, int argc, char *argv[])
507 return wpa_ctrl_command(ctrl, "RELOG");
511 static int wpa_cli_cmd_note(struct wpa_ctrl *ctrl, int argc, char *argv[])
513 return wpa_cli_cmd(ctrl, "NOTE", 1, argc, argv);
517 static int wpa_cli_cmd_mib(struct wpa_ctrl *ctrl, int argc, char *argv[])
519 return wpa_ctrl_command(ctrl, "MIB");
523 static int wpa_cli_cmd_pmksa(struct wpa_ctrl *ctrl, int argc, char *argv[])
525 return wpa_ctrl_command(ctrl, "PMKSA");
529 static int wpa_cli_cmd_help(struct wpa_ctrl *ctrl, int argc, char *argv[])
531 print_help(argc > 0 ? argv[0] : NULL);
536 static char ** wpa_cli_complete_help(const char *str, int pos)
538 int arg = get_cmd_arg_num(str, pos);
543 res = wpa_list_cmd_list();
551 static int wpa_cli_cmd_license(struct wpa_ctrl *ctrl, int argc, char *argv[])
553 printf("%s\n\n%s\n", wpa_cli_version, wpa_cli_full_license);
558 static int wpa_cli_cmd_quit(struct wpa_ctrl *ctrl, int argc, char *argv[])
567 static void wpa_cli_show_variables(void)
569 printf("set variables:\n"
570 " EAPOL::heldPeriod (EAPOL state machine held period, "
572 " EAPOL::authPeriod (EAPOL state machine authentication "
573 "period, in seconds)\n"
574 " EAPOL::startPeriod (EAPOL state machine start period, in "
576 " EAPOL::maxStart (EAPOL state machine maximum start "
578 printf(" dot11RSNAConfigPMKLifetime (WPA/WPA2 PMK lifetime in "
580 " dot11RSNAConfigPMKReauthThreshold (WPA/WPA2 reauthentication"
581 " threshold\n\tpercentage)\n"
582 " dot11RSNAConfigSATimeout (WPA/WPA2 timeout for completing "
583 "security\n\tassociation in seconds)\n");
587 static int wpa_cli_cmd_set(struct wpa_ctrl *ctrl, int argc, char *argv[])
593 wpa_cli_show_variables();
597 if (argc != 1 && argc != 2) {
598 printf("Invalid SET command: needs two arguments (variable "
599 "name and value)\n");
604 res = os_snprintf(cmd, sizeof(cmd), "SET %s ", argv[0]);
606 res = os_snprintf(cmd, sizeof(cmd), "SET %s %s",
608 if (res < 0 || (size_t) res >= sizeof(cmd) - 1) {
609 printf("Too long SET command.\n");
612 return wpa_ctrl_command(ctrl, cmd);
616 static int wpa_cli_cmd_get(struct wpa_ctrl *ctrl, int argc, char *argv[])
618 return wpa_cli_cmd(ctrl, "GET", 1, argc, argv);
622 static int wpa_cli_cmd_logoff(struct wpa_ctrl *ctrl, int argc, char *argv[])
624 return wpa_ctrl_command(ctrl, "LOGOFF");
628 static int wpa_cli_cmd_logon(struct wpa_ctrl *ctrl, int argc, char *argv[])
630 return wpa_ctrl_command(ctrl, "LOGON");
634 static int wpa_cli_cmd_reassociate(struct wpa_ctrl *ctrl, int argc,
637 return wpa_ctrl_command(ctrl, "REASSOCIATE");
641 static int wpa_cli_cmd_preauthenticate(struct wpa_ctrl *ctrl, int argc,
644 return wpa_cli_cmd(ctrl, "PREAUTH", 1, argc, argv);
648 static int wpa_cli_cmd_ap_scan(struct wpa_ctrl *ctrl, int argc, char *argv[])
650 return wpa_cli_cmd(ctrl, "AP_SCAN", 1, argc, argv);
654 static int wpa_cli_cmd_scan_interval(struct wpa_ctrl *ctrl, int argc,
657 return wpa_cli_cmd(ctrl, "SCAN_INTERVAL", 1, argc, argv);
661 static int wpa_cli_cmd_bss_expire_age(struct wpa_ctrl *ctrl, int argc,
664 return wpa_cli_cmd(ctrl, "BSS_EXPIRE_AGE", 1, argc, argv);
668 static int wpa_cli_cmd_bss_expire_count(struct wpa_ctrl *ctrl, int argc,
671 return wpa_cli_cmd(ctrl, "BSS_EXPIRE_COUNT", 1, argc, argv);
675 static int wpa_cli_cmd_bss_flush(struct wpa_ctrl *ctrl, int argc, char *argv[])
681 res = os_snprintf(cmd, sizeof(cmd), "BSS_FLUSH 0");
683 res = os_snprintf(cmd, sizeof(cmd), "BSS_FLUSH %s", argv[0]);
684 if (res < 0 || (size_t) res >= sizeof(cmd) - 1) {
685 printf("Too long BSS_FLUSH command.\n");
688 return wpa_ctrl_command(ctrl, cmd);
692 static int wpa_cli_cmd_stkstart(struct wpa_ctrl *ctrl, int argc,
695 return wpa_cli_cmd(ctrl, "STKSTART", 1, argc, argv);
699 static int wpa_cli_cmd_ft_ds(struct wpa_ctrl *ctrl, int argc, char *argv[])
701 return wpa_cli_cmd(ctrl, "FT_DS", 1, argc, argv);
705 static int wpa_cli_cmd_wps_pbc(struct wpa_ctrl *ctrl, int argc, char *argv[])
707 return wpa_cli_cmd(ctrl, "WPS_PBC", 0, argc, argv);
711 static int wpa_cli_cmd_wps_pin(struct wpa_ctrl *ctrl, int argc, char *argv[])
714 printf("Invalid WPS_PIN command: need one or two arguments:\n"
715 "- BSSID: use 'any' to select any\n"
716 "- PIN: optional, used only with devices that have no "
721 return wpa_cli_cmd(ctrl, "WPS_PIN", 1, argc, argv);
725 static int wpa_cli_cmd_wps_check_pin(struct wpa_ctrl *ctrl, int argc,
728 return wpa_cli_cmd(ctrl, "WPS_CHECK_PIN", 1, argc, argv);
732 static int wpa_cli_cmd_wps_cancel(struct wpa_ctrl *ctrl, int argc,
735 return wpa_ctrl_command(ctrl, "WPS_CANCEL");
739 #ifdef CONFIG_WPS_NFC
741 static int wpa_cli_cmd_wps_nfc(struct wpa_ctrl *ctrl, int argc, char *argv[])
743 return wpa_cli_cmd(ctrl, "WPS_NFC", 0, argc, argv);
747 static int wpa_cli_cmd_wps_nfc_token(struct wpa_ctrl *ctrl, int argc,
750 return wpa_cli_cmd(ctrl, "WPS_NFC_TOKEN", 1, argc, argv);
754 static int wpa_cli_cmd_wps_nfc_tag_read(struct wpa_ctrl *ctrl, int argc,
762 printf("Invalid 'wps_nfc_tag_read' command - one argument "
767 buflen = 18 + os_strlen(argv[0]);
768 buf = os_malloc(buflen);
771 os_snprintf(buf, buflen, "WPS_NFC_TAG_READ %s", argv[0]);
773 ret = wpa_ctrl_command(ctrl, buf);
780 static int wpa_cli_cmd_nfc_get_handover_req(struct wpa_ctrl *ctrl, int argc,
783 return wpa_cli_cmd(ctrl, "NFC_GET_HANDOVER_REQ", 2, argc, argv);
787 static int wpa_cli_cmd_nfc_get_handover_sel(struct wpa_ctrl *ctrl, int argc,
790 return wpa_cli_cmd(ctrl, "NFC_GET_HANDOVER_SEL", 2, argc, argv);
794 static int wpa_cli_cmd_nfc_rx_handover_req(struct wpa_ctrl *ctrl, int argc,
802 printf("Invalid 'nfc_rx_handover_req' command - one argument "
807 buflen = 21 + os_strlen(argv[0]);
808 buf = os_malloc(buflen);
811 os_snprintf(buf, buflen, "NFC_RX_HANDOVER_REQ %s", argv[0]);
813 ret = wpa_ctrl_command(ctrl, buf);
820 static int wpa_cli_cmd_nfc_rx_handover_sel(struct wpa_ctrl *ctrl, int argc,
828 printf("Invalid 'nfc_rx_handover_sel' command - one argument "
833 buflen = 21 + os_strlen(argv[0]);
834 buf = os_malloc(buflen);
837 os_snprintf(buf, buflen, "NFC_RX_HANDOVER_SEL %s", argv[0]);
839 ret = wpa_ctrl_command(ctrl, buf);
845 #endif /* CONFIG_WPS_NFC */
848 static int wpa_cli_cmd_wps_reg(struct wpa_ctrl *ctrl, int argc, char *argv[])
854 res = os_snprintf(cmd, sizeof(cmd), "WPS_REG %s %s",
856 else if (argc == 5 || argc == 6) {
857 char ssid_hex[2 * 32 + 1];
858 char key_hex[2 * 64 + 1];
862 for (i = 0; i < 32; i++) {
863 if (argv[2][i] == '\0')
865 os_snprintf(&ssid_hex[i * 2], 3, "%02x", argv[2][i]);
870 for (i = 0; i < 64; i++) {
871 if (argv[5][i] == '\0')
873 os_snprintf(&key_hex[i * 2], 3, "%02x",
878 res = os_snprintf(cmd, sizeof(cmd),
879 "WPS_REG %s %s %s %s %s %s",
880 argv[0], argv[1], ssid_hex, argv[3], argv[4],
883 printf("Invalid WPS_REG command: need two arguments:\n"
884 "- BSSID of the target AP\n"
886 printf("Alternatively, six arguments can be used to "
887 "reconfigure the AP:\n"
888 "- BSSID of the target AP\n"
891 "- new auth (OPEN, WPAPSK, WPA2PSK)\n"
892 "- new encr (NONE, WEP, TKIP, CCMP)\n"
897 if (res < 0 || (size_t) res >= sizeof(cmd) - 1) {
898 printf("Too long WPS_REG command.\n");
901 return wpa_ctrl_command(ctrl, cmd);
905 static int wpa_cli_cmd_wps_ap_pin(struct wpa_ctrl *ctrl, int argc,
908 return wpa_cli_cmd(ctrl, "WPS_AP_PIN", 1, argc, argv);
912 static int wpa_cli_cmd_wps_er_start(struct wpa_ctrl *ctrl, int argc,
915 return wpa_cli_cmd(ctrl, "WPS_ER_START", 0, argc, argv);
919 static int wpa_cli_cmd_wps_er_stop(struct wpa_ctrl *ctrl, int argc,
922 return wpa_ctrl_command(ctrl, "WPS_ER_STOP");
927 static int wpa_cli_cmd_wps_er_pin(struct wpa_ctrl *ctrl, int argc,
931 printf("Invalid WPS_ER_PIN command: need at least two "
933 "- UUID: use 'any' to select any\n"
934 "- PIN: Enrollee PIN\n"
935 "optional: - Enrollee MAC address\n");
939 return wpa_cli_cmd(ctrl, "WPS_ER_PIN", 2, argc, argv);
943 static int wpa_cli_cmd_wps_er_pbc(struct wpa_ctrl *ctrl, int argc,
946 return wpa_cli_cmd(ctrl, "WPS_ER_PBC", 1, argc, argv);
950 static int wpa_cli_cmd_wps_er_learn(struct wpa_ctrl *ctrl, int argc,
954 printf("Invalid WPS_ER_LEARN command: need two arguments:\n"
955 "- UUID: specify which AP to use\n"
960 return wpa_cli_cmd(ctrl, "WPS_ER_LEARN", 2, argc, argv);
964 static int wpa_cli_cmd_wps_er_set_config(struct wpa_ctrl *ctrl, int argc,
968 printf("Invalid WPS_ER_SET_CONFIG command: need two "
970 "- UUID: specify which AP to use\n"
971 "- Network configuration id\n");
975 return wpa_cli_cmd(ctrl, "WPS_ER_SET_CONFIG", 2, argc, argv);
979 static int wpa_cli_cmd_wps_er_config(struct wpa_ctrl *ctrl, int argc,
985 if (argc == 5 || argc == 6) {
986 char ssid_hex[2 * 32 + 1];
987 char key_hex[2 * 64 + 1];
991 for (i = 0; i < 32; i++) {
992 if (argv[2][i] == '\0')
994 os_snprintf(&ssid_hex[i * 2], 3, "%02x", argv[2][i]);
999 for (i = 0; i < 64; i++) {
1000 if (argv[5][i] == '\0')
1002 os_snprintf(&key_hex[i * 2], 3, "%02x",
1007 res = os_snprintf(cmd, sizeof(cmd),
1008 "WPS_ER_CONFIG %s %s %s %s %s %s",
1009 argv[0], argv[1], ssid_hex, argv[3], argv[4],
1012 printf("Invalid WPS_ER_CONFIG command: need six arguments:\n"
1016 "- new auth (OPEN, WPAPSK, WPA2PSK)\n"
1017 "- new encr (NONE, WEP, TKIP, CCMP)\n"
1022 if (res < 0 || (size_t) res >= sizeof(cmd) - 1) {
1023 printf("Too long WPS_ER_CONFIG command.\n");
1026 return wpa_ctrl_command(ctrl, cmd);
1030 #ifdef CONFIG_WPS_NFC
1031 static int wpa_cli_cmd_wps_er_nfc_config_token(struct wpa_ctrl *ctrl, int argc,
1035 printf("Invalid WPS_ER_NFC_CONFIG_TOKEN command: need two "
1037 "- WPS/NDEF: token format\n"
1038 "- UUID: specify which AP to use\n");
1042 return wpa_cli_cmd(ctrl, "WPS_ER_NFC_CONFIG_TOKEN", 2, argc, argv);
1044 #endif /* CONFIG_WPS_NFC */
1047 static int wpa_cli_cmd_ibss_rsn(struct wpa_ctrl *ctrl, int argc, char *argv[])
1049 return wpa_cli_cmd(ctrl, "IBSS_RSN", 1, argc, argv);
1053 static int wpa_cli_cmd_level(struct wpa_ctrl *ctrl, int argc, char *argv[])
1055 return wpa_cli_cmd(ctrl, "LEVEL", 1, argc, argv);
1059 static int wpa_cli_cmd_identity(struct wpa_ctrl *ctrl, int argc, char *argv[])
1061 char cmd[256], *pos, *end;
1065 printf("Invalid IDENTITY command: needs two arguments "
1066 "(network id and identity)\n");
1070 end = cmd + sizeof(cmd);
1072 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "IDENTITY-%s:%s",
1074 if (ret < 0 || ret >= end - pos) {
1075 printf("Too long IDENTITY command.\n");
1079 for (i = 2; i < argc; i++) {
1080 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
1081 if (ret < 0 || ret >= end - pos) {
1082 printf("Too long IDENTITY command.\n");
1088 return wpa_ctrl_command(ctrl, cmd);
1092 static int wpa_cli_cmd_password(struct wpa_ctrl *ctrl, int argc, char *argv[])
1094 char cmd[256], *pos, *end;
1098 printf("Invalid PASSWORD command: needs two arguments "
1099 "(network id and password)\n");
1103 end = cmd + sizeof(cmd);
1105 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "PASSWORD-%s:%s",
1107 if (ret < 0 || ret >= end - pos) {
1108 printf("Too long PASSWORD command.\n");
1112 for (i = 2; i < argc; i++) {
1113 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
1114 if (ret < 0 || ret >= end - pos) {
1115 printf("Too long PASSWORD command.\n");
1121 return wpa_ctrl_command(ctrl, cmd);
1125 static int wpa_cli_cmd_new_password(struct wpa_ctrl *ctrl, int argc,
1128 char cmd[256], *pos, *end;
1132 printf("Invalid NEW_PASSWORD command: needs two arguments "
1133 "(network id and password)\n");
1137 end = cmd + sizeof(cmd);
1139 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "NEW_PASSWORD-%s:%s",
1141 if (ret < 0 || ret >= end - pos) {
1142 printf("Too long NEW_PASSWORD command.\n");
1146 for (i = 2; i < argc; i++) {
1147 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
1148 if (ret < 0 || ret >= end - pos) {
1149 printf("Too long NEW_PASSWORD command.\n");
1155 return wpa_ctrl_command(ctrl, cmd);
1159 static int wpa_cli_cmd_pin(struct wpa_ctrl *ctrl, int argc, char *argv[])
1161 char cmd[256], *pos, *end;
1165 printf("Invalid PIN command: needs two arguments "
1166 "(network id and pin)\n");
1170 end = cmd + sizeof(cmd);
1172 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "PIN-%s:%s",
1174 if (ret < 0 || ret >= end - pos) {
1175 printf("Too long PIN command.\n");
1179 for (i = 2; i < argc; i++) {
1180 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
1181 if (ret < 0 || ret >= end - pos) {
1182 printf("Too long PIN command.\n");
1187 return wpa_ctrl_command(ctrl, cmd);
1191 static int wpa_cli_cmd_otp(struct wpa_ctrl *ctrl, int argc, char *argv[])
1193 char cmd[256], *pos, *end;
1197 printf("Invalid OTP command: needs two arguments (network "
1198 "id and password)\n");
1202 end = cmd + sizeof(cmd);
1204 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "OTP-%s:%s",
1206 if (ret < 0 || ret >= end - pos) {
1207 printf("Too long OTP command.\n");
1211 for (i = 2; i < argc; i++) {
1212 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
1213 if (ret < 0 || ret >= end - pos) {
1214 printf("Too long OTP command.\n");
1220 return wpa_ctrl_command(ctrl, cmd);
1224 static int wpa_cli_cmd_passphrase(struct wpa_ctrl *ctrl, int argc,
1227 char cmd[256], *pos, *end;
1231 printf("Invalid PASSPHRASE command: needs two arguments "
1232 "(network id and passphrase)\n");
1236 end = cmd + sizeof(cmd);
1238 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "PASSPHRASE-%s:%s",
1240 if (ret < 0 || ret >= end - pos) {
1241 printf("Too long PASSPHRASE command.\n");
1245 for (i = 2; i < argc; i++) {
1246 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
1247 if (ret < 0 || ret >= end - pos) {
1248 printf("Too long PASSPHRASE command.\n");
1254 return wpa_ctrl_command(ctrl, cmd);
1258 static int wpa_cli_cmd_bssid(struct wpa_ctrl *ctrl, int argc, char *argv[])
1261 printf("Invalid BSSID command: needs two arguments (network "
1266 return wpa_cli_cmd(ctrl, "BSSID", 2, argc, argv);
1270 static int wpa_cli_cmd_blacklist(struct wpa_ctrl *ctrl, int argc, char *argv[])
1272 return wpa_cli_cmd(ctrl, "BLACKLIST", 0, argc, argv);
1276 static int wpa_cli_cmd_log_level(struct wpa_ctrl *ctrl, int argc, char *argv[])
1278 return wpa_cli_cmd(ctrl, "LOG_LEVEL", 0, argc, argv);
1282 static int wpa_cli_cmd_list_networks(struct wpa_ctrl *ctrl, int argc,
1285 return wpa_ctrl_command(ctrl, "LIST_NETWORKS");
1289 static int wpa_cli_cmd_select_network(struct wpa_ctrl *ctrl, int argc,
1292 return wpa_cli_cmd(ctrl, "SELECT_NETWORK", 1, argc, argv);
1296 static int wpa_cli_cmd_enable_network(struct wpa_ctrl *ctrl, int argc,
1299 return wpa_cli_cmd(ctrl, "ENABLE_NETWORK", 1, argc, argv);
1303 static int wpa_cli_cmd_disable_network(struct wpa_ctrl *ctrl, int argc,
1306 return wpa_cli_cmd(ctrl, "DISABLE_NETWORK", 1, argc, argv);
1310 static int wpa_cli_cmd_add_network(struct wpa_ctrl *ctrl, int argc,
1313 return wpa_ctrl_command(ctrl, "ADD_NETWORK");
1317 static int wpa_cli_cmd_remove_network(struct wpa_ctrl *ctrl, int argc,
1320 return wpa_cli_cmd(ctrl, "REMOVE_NETWORK", 1, argc, argv);
1324 static void wpa_cli_show_network_variables(void)
1326 printf("set_network variables:\n"
1327 " ssid (network name, SSID)\n"
1328 " psk (WPA passphrase or pre-shared key)\n"
1329 " key_mgmt (key management protocol)\n"
1330 " identity (EAP identity)\n"
1331 " password (EAP password)\n"
1334 "Note: Values are entered in the same format as the "
1335 "configuration file is using,\n"
1336 "i.e., strings values need to be inside double quotation "
1338 "For example: set_network 1 ssid \"network name\"\n"
1340 "Please see wpa_supplicant.conf documentation for full list "
1341 "of\navailable variables.\n");
1345 static int wpa_cli_cmd_set_network(struct wpa_ctrl *ctrl, int argc,
1349 wpa_cli_show_network_variables();
1354 printf("Invalid SET_NETWORK command: needs three arguments\n"
1355 "(network id, variable name, and value)\n");
1359 return wpa_cli_cmd(ctrl, "SET_NETWORK", 3, argc, argv);
1363 static int wpa_cli_cmd_get_network(struct wpa_ctrl *ctrl, int argc,
1367 wpa_cli_show_network_variables();
1372 printf("Invalid GET_NETWORK command: needs two arguments\n"
1373 "(network id and variable name)\n");
1377 return wpa_cli_cmd(ctrl, "GET_NETWORK", 2, argc, argv);
1381 static int wpa_cli_cmd_list_creds(struct wpa_ctrl *ctrl, int argc,
1384 return wpa_ctrl_command(ctrl, "LIST_CREDS");
1388 static int wpa_cli_cmd_add_cred(struct wpa_ctrl *ctrl, int argc, char *argv[])
1390 return wpa_ctrl_command(ctrl, "ADD_CRED");
1394 static int wpa_cli_cmd_remove_cred(struct wpa_ctrl *ctrl, int argc,
1397 return wpa_cli_cmd(ctrl, "REMOVE_CRED", 1, argc, argv);
1401 static int wpa_cli_cmd_set_cred(struct wpa_ctrl *ctrl, int argc, char *argv[])
1404 printf("Invalid SET_CRED command: needs three arguments\n"
1405 "(cred id, variable name, and value)\n");
1409 return wpa_cli_cmd(ctrl, "SET_CRED", 3, argc, argv);
1413 static int wpa_cli_cmd_disconnect(struct wpa_ctrl *ctrl, int argc,
1416 return wpa_ctrl_command(ctrl, "DISCONNECT");
1420 static int wpa_cli_cmd_reconnect(struct wpa_ctrl *ctrl, int argc,
1423 return wpa_ctrl_command(ctrl, "RECONNECT");
1427 static int wpa_cli_cmd_save_config(struct wpa_ctrl *ctrl, int argc,
1430 return wpa_ctrl_command(ctrl, "SAVE_CONFIG");
1434 static int wpa_cli_cmd_scan(struct wpa_ctrl *ctrl, int argc, char *argv[])
1436 return wpa_ctrl_command(ctrl, "SCAN");
1440 static int wpa_cli_cmd_scan_results(struct wpa_ctrl *ctrl, int argc,
1443 return wpa_ctrl_command(ctrl, "SCAN_RESULTS");
1447 static int wpa_cli_cmd_bss(struct wpa_ctrl *ctrl, int argc, char *argv[])
1449 return wpa_cli_cmd(ctrl, "BSS", 1, argc, argv);
1453 static char ** wpa_cli_complete_bss(const char *str, int pos)
1455 int arg = get_cmd_arg_num(str, pos);
1460 res = cli_txt_list_array(&bsses);
1468 static int wpa_cli_cmd_get_capability(struct wpa_ctrl *ctrl, int argc,
1471 if (argc < 1 || argc > 2) {
1472 printf("Invalid GET_CAPABILITY command: need either one or "
1477 if ((argc == 2) && os_strcmp(argv[1], "strict") != 0) {
1478 printf("Invalid GET_CAPABILITY command: second argument, "
1479 "if any, must be 'strict'\n");
1483 return wpa_cli_cmd(ctrl, "GET_CAPABILITY", 1, argc, argv);
1487 static int wpa_cli_list_interfaces(struct wpa_ctrl *ctrl)
1489 printf("Available interfaces:\n");
1490 return wpa_ctrl_command(ctrl, "INTERFACES");
1494 static int wpa_cli_cmd_interface(struct wpa_ctrl *ctrl, int argc, char *argv[])
1497 wpa_cli_list_interfaces(ctrl);
1501 wpa_cli_close_connection();
1502 os_free(ctrl_ifname);
1503 ctrl_ifname = os_strdup(argv[0]);
1505 if (wpa_cli_open_connection(ctrl_ifname, 1)) {
1506 printf("Connected to interface '%s.\n", ctrl_ifname);
1508 printf("Could not connect to interface '%s' - re-trying\n",
1515 static int wpa_cli_cmd_reconfigure(struct wpa_ctrl *ctrl, int argc,
1518 return wpa_ctrl_command(ctrl, "RECONFIGURE");
1522 static int wpa_cli_cmd_terminate(struct wpa_ctrl *ctrl, int argc,
1525 return wpa_ctrl_command(ctrl, "TERMINATE");
1529 static int wpa_cli_cmd_interface_add(struct wpa_ctrl *ctrl, int argc,
1536 printf("Invalid INTERFACE_ADD command: needs at least one "
1537 "argument (interface name)\n"
1538 "All arguments: ifname confname driver ctrl_interface "
1539 "driver_param bridge_name\n");
1544 * INTERFACE_ADD <ifname>TAB<confname>TAB<driver>TAB<ctrl_interface>TAB
1545 * <driver_param>TAB<bridge_name>
1547 res = os_snprintf(cmd, sizeof(cmd),
1548 "INTERFACE_ADD %s\t%s\t%s\t%s\t%s\t%s",
1550 argc > 1 ? argv[1] : "", argc > 2 ? argv[2] : "",
1551 argc > 3 ? argv[3] : "", argc > 4 ? argv[4] : "",
1552 argc > 5 ? argv[5] : "");
1553 if (res < 0 || (size_t) res >= sizeof(cmd))
1555 cmd[sizeof(cmd) - 1] = '\0';
1556 return wpa_ctrl_command(ctrl, cmd);
1560 static int wpa_cli_cmd_interface_remove(struct wpa_ctrl *ctrl, int argc,
1563 return wpa_cli_cmd(ctrl, "INTERFACE_REMOVE", 1, argc, argv);
1567 static int wpa_cli_cmd_interface_list(struct wpa_ctrl *ctrl, int argc,
1570 return wpa_ctrl_command(ctrl, "INTERFACE_LIST");
1575 static int wpa_cli_cmd_sta(struct wpa_ctrl *ctrl, int argc, char *argv[])
1577 return wpa_cli_cmd(ctrl, "STA", 1, argc, argv);
1581 static int wpa_ctrl_command_sta(struct wpa_ctrl *ctrl, char *cmd,
1582 char *addr, size_t addr_len)
1584 char buf[4096], *pos;
1588 if (ctrl_conn == NULL) {
1589 printf("Not connected to hostapd - command dropped.\n");
1592 len = sizeof(buf) - 1;
1593 ret = wpa_ctrl_request(ctrl, cmd, os_strlen(cmd), buf, &len,
1596 printf("'%s' command timed out.\n", cmd);
1598 } else if (ret < 0) {
1599 printf("'%s' command failed.\n", cmd);
1604 if (os_memcmp(buf, "FAIL", 4) == 0)
1609 while (*pos != '\0' && *pos != '\n')
1612 os_strlcpy(addr, buf, addr_len);
1617 static int wpa_cli_cmd_all_sta(struct wpa_ctrl *ctrl, int argc, char *argv[])
1619 char addr[32], cmd[64];
1621 if (wpa_ctrl_command_sta(ctrl, "STA-FIRST", addr, sizeof(addr)))
1624 os_snprintf(cmd, sizeof(cmd), "STA-NEXT %s", addr);
1625 } while (wpa_ctrl_command_sta(ctrl, cmd, addr, sizeof(addr)) == 0);
1631 static int wpa_cli_cmd_deauthenticate(struct wpa_ctrl *ctrl, int argc,
1634 return wpa_cli_cmd(ctrl, "DEAUTHENTICATE", 1, argc, argv);
1638 static int wpa_cli_cmd_disassociate(struct wpa_ctrl *ctrl, int argc,
1641 return wpa_cli_cmd(ctrl, "DISASSOCIATE", 1, argc, argv);
1643 #endif /* CONFIG_AP */
1646 static int wpa_cli_cmd_suspend(struct wpa_ctrl *ctrl, int argc, char *argv[])
1648 return wpa_ctrl_command(ctrl, "SUSPEND");
1652 static int wpa_cli_cmd_resume(struct wpa_ctrl *ctrl, int argc, char *argv[])
1654 return wpa_ctrl_command(ctrl, "RESUME");
1658 static int wpa_cli_cmd_drop_sa(struct wpa_ctrl *ctrl, int argc, char *argv[])
1660 return wpa_ctrl_command(ctrl, "DROP_SA");
1664 static int wpa_cli_cmd_roam(struct wpa_ctrl *ctrl, int argc, char *argv[])
1666 return wpa_cli_cmd(ctrl, "ROAM", 1, argc, argv);
1672 static int wpa_cli_cmd_p2p_find(struct wpa_ctrl *ctrl, int argc, char *argv[])
1674 return wpa_cli_cmd(ctrl, "P2P_FIND", 0, argc, argv);
1678 static char ** wpa_cli_complete_p2p_find(const char *str, int pos)
1681 int arg = get_cmd_arg_num(str, pos);
1683 res = os_calloc(6, sizeof(char *));
1686 res[0] = os_strdup("type=social");
1687 if (res[0] == NULL) {
1691 res[1] = os_strdup("type=progressive");
1694 res[2] = os_strdup("delay=");
1697 res[3] = os_strdup("dev_id=");
1701 res[4] = os_strdup("[timeout]");
1707 static int wpa_cli_cmd_p2p_stop_find(struct wpa_ctrl *ctrl, int argc,
1710 return wpa_ctrl_command(ctrl, "P2P_STOP_FIND");
1714 static int wpa_cli_cmd_p2p_connect(struct wpa_ctrl *ctrl, int argc,
1717 return wpa_cli_cmd(ctrl, "P2P_CONNECT", 2, argc, argv);
1721 static char ** wpa_cli_complete_p2p_connect(const char *str, int pos)
1723 int arg = get_cmd_arg_num(str, pos);
1728 res = cli_txt_list_array(&p2p_peers);
1736 static int wpa_cli_cmd_p2p_listen(struct wpa_ctrl *ctrl, int argc,
1739 return wpa_cli_cmd(ctrl, "P2P_LISTEN", 0, argc, argv);
1743 static int wpa_cli_cmd_p2p_group_remove(struct wpa_ctrl *ctrl, int argc,
1746 return wpa_cli_cmd(ctrl, "P2P_GROUP_REMOVE", 1, argc, argv);
1750 static char ** wpa_cli_complete_p2p_group_remove(const char *str, int pos)
1752 int arg = get_cmd_arg_num(str, pos);
1757 res = cli_txt_list_array(&p2p_groups);
1765 static int wpa_cli_cmd_p2p_group_add(struct wpa_ctrl *ctrl, int argc,
1768 return wpa_cli_cmd(ctrl, "P2P_GROUP_ADD", 0, argc, argv);
1772 static int wpa_cli_cmd_p2p_prov_disc(struct wpa_ctrl *ctrl, int argc,
1775 if (argc != 2 && argc != 3) {
1776 printf("Invalid P2P_PROV_DISC command: needs at least "
1777 "two arguments, address and config method\n"
1778 "(display, keypad, or pbc) and an optional join\n");
1782 return wpa_cli_cmd(ctrl, "P2P_PROV_DISC", 2, argc, argv);
1786 static int wpa_cli_cmd_p2p_get_passphrase(struct wpa_ctrl *ctrl, int argc,
1789 return wpa_ctrl_command(ctrl, "P2P_GET_PASSPHRASE");
1793 static int wpa_cli_cmd_p2p_serv_disc_req(struct wpa_ctrl *ctrl, int argc,
1798 if (argc != 2 && argc != 4) {
1799 printf("Invalid P2P_SERV_DISC_REQ command: needs two "
1800 "arguments (address and TLVs) or four arguments "
1801 "(address, \"upnp\", version, search target "
1806 if (write_cmd(cmd, sizeof(cmd), "P2P_SERV_DISC_REQ", argc, argv) < 0)
1808 return wpa_ctrl_command(ctrl, cmd);
1812 static int wpa_cli_cmd_p2p_serv_disc_cancel_req(struct wpa_ctrl *ctrl,
1813 int argc, char *argv[])
1815 return wpa_cli_cmd(ctrl, "P2P_SERV_DISC_CANCEL_REQ", 1, argc, argv);
1819 static int wpa_cli_cmd_p2p_serv_disc_resp(struct wpa_ctrl *ctrl, int argc,
1826 printf("Invalid P2P_SERV_DISC_RESP command: needs four "
1827 "arguments (freq, address, dialog token, and TLVs)\n");
1831 res = os_snprintf(cmd, sizeof(cmd), "P2P_SERV_DISC_RESP %s %s %s %s",
1832 argv[0], argv[1], argv[2], argv[3]);
1833 if (res < 0 || (size_t) res >= sizeof(cmd))
1835 cmd[sizeof(cmd) - 1] = '\0';
1836 return wpa_ctrl_command(ctrl, cmd);
1840 static int wpa_cli_cmd_p2p_service_update(struct wpa_ctrl *ctrl, int argc,
1843 return wpa_ctrl_command(ctrl, "P2P_SERVICE_UPDATE");
1847 static int wpa_cli_cmd_p2p_serv_disc_external(struct wpa_ctrl *ctrl,
1848 int argc, char *argv[])
1850 return wpa_cli_cmd(ctrl, "P2P_SERV_DISC_EXTERNAL", 1, argc, argv);
1854 static int wpa_cli_cmd_p2p_service_flush(struct wpa_ctrl *ctrl, int argc,
1857 return wpa_ctrl_command(ctrl, "P2P_SERVICE_FLUSH");
1861 static int wpa_cli_cmd_p2p_service_add(struct wpa_ctrl *ctrl, int argc,
1867 if (argc != 3 && argc != 4) {
1868 printf("Invalid P2P_SERVICE_ADD command: needs three or four "
1874 res = os_snprintf(cmd, sizeof(cmd),
1875 "P2P_SERVICE_ADD %s %s %s %s",
1876 argv[0], argv[1], argv[2], argv[3]);
1878 res = os_snprintf(cmd, sizeof(cmd),
1879 "P2P_SERVICE_ADD %s %s %s",
1880 argv[0], argv[1], argv[2]);
1881 if (res < 0 || (size_t) res >= sizeof(cmd))
1883 cmd[sizeof(cmd) - 1] = '\0';
1884 return wpa_ctrl_command(ctrl, cmd);
1888 static int wpa_cli_cmd_p2p_service_del(struct wpa_ctrl *ctrl, int argc,
1894 if (argc != 2 && argc != 3) {
1895 printf("Invalid P2P_SERVICE_DEL command: needs two or three "
1901 res = os_snprintf(cmd, sizeof(cmd),
1902 "P2P_SERVICE_DEL %s %s %s",
1903 argv[0], argv[1], argv[2]);
1905 res = os_snprintf(cmd, sizeof(cmd),
1906 "P2P_SERVICE_DEL %s %s",
1908 if (res < 0 || (size_t) res >= sizeof(cmd))
1910 cmd[sizeof(cmd) - 1] = '\0';
1911 return wpa_ctrl_command(ctrl, cmd);
1915 static int wpa_cli_cmd_p2p_reject(struct wpa_ctrl *ctrl,
1916 int argc, char *argv[])
1918 return wpa_cli_cmd(ctrl, "P2P_REJECT", 1, argc, argv);
1922 static int wpa_cli_cmd_p2p_invite(struct wpa_ctrl *ctrl,
1923 int argc, char *argv[])
1925 return wpa_cli_cmd(ctrl, "P2P_INVITE", 1, argc, argv);
1929 static int wpa_cli_cmd_p2p_peer(struct wpa_ctrl *ctrl, int argc, char *argv[])
1931 return wpa_cli_cmd(ctrl, "P2P_PEER", 1, argc, argv);
1935 static char ** wpa_cli_complete_p2p_peer(const char *str, int pos)
1937 int arg = get_cmd_arg_num(str, pos);
1942 res = cli_txt_list_array(&p2p_peers);
1950 static int wpa_ctrl_command_p2p_peer(struct wpa_ctrl *ctrl, char *cmd,
1951 char *addr, size_t addr_len,
1954 char buf[4096], *pos;
1958 if (ctrl_conn == NULL)
1960 len = sizeof(buf) - 1;
1961 ret = wpa_ctrl_request(ctrl, cmd, os_strlen(cmd), buf, &len,
1964 printf("'%s' command timed out.\n", cmd);
1966 } else if (ret < 0) {
1967 printf("'%s' command failed.\n", cmd);
1972 if (os_memcmp(buf, "FAIL", 4) == 0)
1976 while (*pos != '\0' && *pos != '\n')
1979 os_strlcpy(addr, buf, addr_len);
1980 if (!discovered || os_strstr(pos, "[PROBE_REQ_ONLY]") == NULL)
1981 printf("%s\n", addr);
1986 static int wpa_cli_cmd_p2p_peers(struct wpa_ctrl *ctrl, int argc, char *argv[])
1988 char addr[32], cmd[64];
1991 discovered = argc > 0 && os_strcmp(argv[0], "discovered") == 0;
1993 if (wpa_ctrl_command_p2p_peer(ctrl, "P2P_PEER FIRST",
1994 addr, sizeof(addr), discovered))
1997 os_snprintf(cmd, sizeof(cmd), "P2P_PEER NEXT-%s", addr);
1998 } while (wpa_ctrl_command_p2p_peer(ctrl, cmd, addr, sizeof(addr),
2005 static int wpa_cli_cmd_p2p_set(struct wpa_ctrl *ctrl, int argc, char *argv[])
2007 return wpa_cli_cmd(ctrl, "P2P_SET", 2, argc, argv);
2011 static int wpa_cli_cmd_p2p_flush(struct wpa_ctrl *ctrl, int argc, char *argv[])
2013 return wpa_ctrl_command(ctrl, "P2P_FLUSH");
2017 static int wpa_cli_cmd_p2p_cancel(struct wpa_ctrl *ctrl, int argc,
2020 return wpa_ctrl_command(ctrl, "P2P_CANCEL");
2024 static int wpa_cli_cmd_p2p_unauthorize(struct wpa_ctrl *ctrl, int argc,
2027 return wpa_cli_cmd(ctrl, "P2P_UNAUTHORIZE", 1, argc, argv);
2031 static int wpa_cli_cmd_p2p_presence_req(struct wpa_ctrl *ctrl, int argc,
2034 if (argc != 0 && argc != 2 && argc != 4) {
2035 printf("Invalid P2P_PRESENCE_REQ command: needs two arguments "
2036 "(preferred duration, interval; in microsecods).\n"
2037 "Optional second pair can be used to provide "
2038 "acceptable values.\n");
2042 return wpa_cli_cmd(ctrl, "P2P_PRESENCE_REQ", 0, argc, argv);
2046 static int wpa_cli_cmd_p2p_ext_listen(struct wpa_ctrl *ctrl, int argc,
2049 if (argc != 0 && argc != 2) {
2050 printf("Invalid P2P_EXT_LISTEN command: needs two arguments "
2051 "(availability period, availability interval; in "
2053 "Extended Listen Timing can be cancelled with this "
2054 "command when used without parameters.\n");
2058 return wpa_cli_cmd(ctrl, "P2P_EXT_LISTEN", 0, argc, argv);
2061 #endif /* CONFIG_P2P */
2063 #ifdef CONFIG_WIFI_DISPLAY
2065 static int wpa_cli_cmd_wfd_subelem_set(struct wpa_ctrl *ctrl, int argc,
2071 if (argc != 1 && argc != 2) {
2072 printf("Invalid WFD_SUBELEM_SET command: needs one or two "
2073 "arguments (subelem, hexdump)\n");
2077 res = os_snprintf(cmd, sizeof(cmd), "WFD_SUBELEM_SET %s %s",
2078 argv[0], argc > 1 ? argv[1] : "");
2079 if (res < 0 || (size_t) res >= sizeof(cmd))
2081 cmd[sizeof(cmd) - 1] = '\0';
2082 return wpa_ctrl_command(ctrl, cmd);
2086 static int wpa_cli_cmd_wfd_subelem_get(struct wpa_ctrl *ctrl, int argc,
2093 printf("Invalid WFD_SUBELEM_GET command: needs one "
2094 "argument (subelem)\n");
2098 res = os_snprintf(cmd, sizeof(cmd), "WFD_SUBELEM_GET %s",
2100 if (res < 0 || (size_t) res >= sizeof(cmd))
2102 cmd[sizeof(cmd) - 1] = '\0';
2103 return wpa_ctrl_command(ctrl, cmd);
2105 #endif /* CONFIG_WIFI_DISPLAY */
2108 #ifdef CONFIG_INTERWORKING
2109 static int wpa_cli_cmd_fetch_anqp(struct wpa_ctrl *ctrl, int argc,
2112 return wpa_ctrl_command(ctrl, "FETCH_ANQP");
2116 static int wpa_cli_cmd_stop_fetch_anqp(struct wpa_ctrl *ctrl, int argc,
2119 return wpa_ctrl_command(ctrl, "STOP_FETCH_ANQP");
2123 static int wpa_cli_cmd_interworking_select(struct wpa_ctrl *ctrl, int argc,
2126 return wpa_cli_cmd(ctrl, "INTERWORKING_SELECT", 0, argc, argv);
2130 static int wpa_cli_cmd_interworking_connect(struct wpa_ctrl *ctrl, int argc,
2133 return wpa_cli_cmd(ctrl, "INTERWORKING_CONNECT", 1, argc, argv);
2137 static int wpa_cli_cmd_anqp_get(struct wpa_ctrl *ctrl, int argc, char *argv[])
2139 return wpa_cli_cmd(ctrl, "ANQP_GET", 2, argc, argv);
2143 static int wpa_cli_cmd_gas_request(struct wpa_ctrl *ctrl, int argc,
2146 return wpa_cli_cmd(ctrl, "GAS_REQUEST", 2, argc, argv);
2150 static int wpa_cli_cmd_gas_response_get(struct wpa_ctrl *ctrl, int argc,
2153 return wpa_cli_cmd(ctrl, "GAS_RESPONSE_GET", 2, argc, argv);
2155 #endif /* CONFIG_INTERWORKING */
2160 static int wpa_cli_cmd_hs20_anqp_get(struct wpa_ctrl *ctrl, int argc,
2163 return wpa_cli_cmd(ctrl, "HS20_ANQP_GET", 2, argc, argv);
2167 static int wpa_cli_cmd_get_nai_home_realm_list(struct wpa_ctrl *ctrl, int argc,
2173 printf("Command needs one or two arguments (dst mac addr and "
2174 "optional home realm)\n");
2178 if (write_cmd(cmd, sizeof(cmd), "HS20_GET_NAI_HOME_REALM_LIST",
2182 return wpa_ctrl_command(ctrl, cmd);
2185 #endif /* CONFIG_HS20 */
2188 static int wpa_cli_cmd_sta_autoconnect(struct wpa_ctrl *ctrl, int argc,
2191 return wpa_cli_cmd(ctrl, "STA_AUTOCONNECT", 1, argc, argv);
2195 static int wpa_cli_cmd_tdls_discover(struct wpa_ctrl *ctrl, int argc,
2198 return wpa_cli_cmd(ctrl, "TDLS_DISCOVER", 1, argc, argv);
2202 static int wpa_cli_cmd_tdls_setup(struct wpa_ctrl *ctrl, int argc,
2205 return wpa_cli_cmd(ctrl, "TDLS_SETUP", 1, argc, argv);
2209 static int wpa_cli_cmd_tdls_teardown(struct wpa_ctrl *ctrl, int argc,
2212 return wpa_cli_cmd(ctrl, "TDLS_TEARDOWN", 1, argc, argv);
2216 static int wpa_cli_cmd_signal_poll(struct wpa_ctrl *ctrl, int argc,
2219 return wpa_ctrl_command(ctrl, "SIGNAL_POLL");
2223 static int wpa_cli_cmd_pktcnt_poll(struct wpa_ctrl *ctrl, int argc,
2226 return wpa_ctrl_command(ctrl, "PKTCNT_POLL");
2230 static int wpa_cli_cmd_reauthenticate(struct wpa_ctrl *ctrl, int argc,
2233 return wpa_ctrl_command(ctrl, "REAUTHENTICATE");
2237 #ifdef CONFIG_AUTOSCAN
2239 static int wpa_cli_cmd_autoscan(struct wpa_ctrl *ctrl, int argc, char *argv[])
2242 return wpa_ctrl_command(ctrl, "AUTOSCAN ");
2244 return wpa_cli_cmd(ctrl, "AUTOSCAN", 0, argc, argv);
2247 #endif /* CONFIG_AUTOSCAN */
2252 static int wpa_cli_cmd_wnm_sleep(struct wpa_ctrl *ctrl, int argc, char *argv[])
2254 return wpa_cli_cmd(ctrl, "WNM_SLEEP", 0, argc, argv);
2257 #endif /* CONFIG_WNM */
2260 static int wpa_cli_cmd_raw(struct wpa_ctrl *ctrl, int argc, char *argv[])
2264 return wpa_cli_cmd(ctrl, argv[0], 0, argc - 1, &argv[1]);
2268 enum wpa_cli_cmd_flags {
2269 cli_cmd_flag_none = 0x00,
2270 cli_cmd_flag_sensitive = 0x01
2273 struct wpa_cli_cmd {
2275 int (*handler)(struct wpa_ctrl *ctrl, int argc, char *argv[]);
2276 char ** (*completion)(const char *str, int pos);
2277 enum wpa_cli_cmd_flags flags;
2281 static struct wpa_cli_cmd wpa_cli_commands[] = {
2282 { "status", wpa_cli_cmd_status, NULL,
2284 "[verbose] = get current WPA/EAPOL/EAP status" },
2285 { "ifname", wpa_cli_cmd_ifname, NULL,
2287 "= get current interface name" },
2288 { "ping", wpa_cli_cmd_ping, NULL,
2290 "= pings wpa_supplicant" },
2291 { "relog", wpa_cli_cmd_relog, NULL,
2293 "= re-open log-file (allow rolling logs)" },
2294 { "note", wpa_cli_cmd_note, NULL,
2296 "<text> = add a note to wpa_supplicant debug log" },
2297 { "mib", wpa_cli_cmd_mib, NULL,
2299 "= get MIB variables (dot1x, dot11)" },
2300 { "help", wpa_cli_cmd_help, wpa_cli_complete_help,
2302 "[command] = show usage help" },
2303 { "interface", wpa_cli_cmd_interface, NULL,
2305 "[ifname] = show interfaces/select interface" },
2306 { "level", wpa_cli_cmd_level, NULL,
2308 "<debug level> = change debug level" },
2309 { "license", wpa_cli_cmd_license, NULL,
2311 "= show full wpa_cli license" },
2312 { "quit", wpa_cli_cmd_quit, NULL,
2315 { "set", wpa_cli_cmd_set, NULL,
2317 "= set variables (shows list of variables when run without "
2319 { "get", wpa_cli_cmd_get, NULL,
2321 "<name> = get information" },
2322 { "logon", wpa_cli_cmd_logon, NULL,
2324 "= IEEE 802.1X EAPOL state machine logon" },
2325 { "logoff", wpa_cli_cmd_logoff, NULL,
2327 "= IEEE 802.1X EAPOL state machine logoff" },
2328 { "pmksa", wpa_cli_cmd_pmksa, NULL,
2330 "= show PMKSA cache" },
2331 { "reassociate", wpa_cli_cmd_reassociate, NULL,
2333 "= force reassociation" },
2334 { "preauthenticate", wpa_cli_cmd_preauthenticate, wpa_cli_complete_bss,
2336 "<BSSID> = force preauthentication" },
2337 { "identity", wpa_cli_cmd_identity, NULL,
2339 "<network id> <identity> = configure identity for an SSID" },
2340 { "password", wpa_cli_cmd_password, NULL,
2341 cli_cmd_flag_sensitive,
2342 "<network id> <password> = configure password for an SSID" },
2343 { "new_password", wpa_cli_cmd_new_password, NULL,
2344 cli_cmd_flag_sensitive,
2345 "<network id> <password> = change password for an SSID" },
2346 { "pin", wpa_cli_cmd_pin, NULL,
2347 cli_cmd_flag_sensitive,
2348 "<network id> <pin> = configure pin for an SSID" },
2349 { "otp", wpa_cli_cmd_otp, NULL,
2350 cli_cmd_flag_sensitive,
2351 "<network id> <password> = configure one-time-password for an SSID"
2353 { "passphrase", wpa_cli_cmd_passphrase, NULL,
2354 cli_cmd_flag_sensitive,
2355 "<network id> <passphrase> = configure private key passphrase\n"
2357 { "bssid", wpa_cli_cmd_bssid, NULL,
2359 "<network id> <BSSID> = set preferred BSSID for an SSID" },
2360 { "blacklist", wpa_cli_cmd_blacklist, wpa_cli_complete_bss,
2362 "<BSSID> = add a BSSID to the blacklist\n"
2363 "blacklist clear = clear the blacklist\n"
2364 "blacklist = display the blacklist" },
2365 { "log_level", wpa_cli_cmd_log_level, NULL,
2367 "<level> [<timestamp>] = update the log level/timestamp\n"
2368 "log_level = display the current log level and log options" },
2369 { "list_networks", wpa_cli_cmd_list_networks, NULL,
2371 "= list configured networks" },
2372 { "select_network", wpa_cli_cmd_select_network, NULL,
2374 "<network id> = select a network (disable others)" },
2375 { "enable_network", wpa_cli_cmd_enable_network, NULL,
2377 "<network id> = enable a network" },
2378 { "disable_network", wpa_cli_cmd_disable_network, NULL,
2380 "<network id> = disable a network" },
2381 { "add_network", wpa_cli_cmd_add_network, NULL,
2383 "= add a network" },
2384 { "remove_network", wpa_cli_cmd_remove_network, NULL,
2386 "<network id> = remove a network" },
2387 { "set_network", wpa_cli_cmd_set_network, NULL,
2388 cli_cmd_flag_sensitive,
2389 "<network id> <variable> <value> = set network variables (shows\n"
2390 " list of variables when run without arguments)" },
2391 { "get_network", wpa_cli_cmd_get_network, NULL,
2393 "<network id> <variable> = get network variables" },
2394 { "list_creds", wpa_cli_cmd_list_creds, NULL,
2396 "= list configured credentials" },
2397 { "add_cred", wpa_cli_cmd_add_cred, NULL,
2399 "= add a credential" },
2400 { "remove_cred", wpa_cli_cmd_remove_cred, NULL,
2402 "<cred id> = remove a credential" },
2403 { "set_cred", wpa_cli_cmd_set_cred, NULL,
2404 cli_cmd_flag_sensitive,
2405 "<cred id> <variable> <value> = set credential variables" },
2406 { "save_config", wpa_cli_cmd_save_config, NULL,
2408 "= save the current configuration" },
2409 { "disconnect", wpa_cli_cmd_disconnect, NULL,
2411 "= disconnect and wait for reassociate/reconnect command before\n"
2413 { "reconnect", wpa_cli_cmd_reconnect, NULL,
2415 "= like reassociate, but only takes effect if already disconnected"
2417 { "scan", wpa_cli_cmd_scan, NULL,
2419 "= request new BSS scan" },
2420 { "scan_results", wpa_cli_cmd_scan_results, NULL,
2422 "= get latest scan results" },
2423 { "bss", wpa_cli_cmd_bss, wpa_cli_complete_bss,
2425 "<<idx> | <bssid>> = get detailed scan result info" },
2426 { "get_capability", wpa_cli_cmd_get_capability, NULL,
2428 "<eap/pairwise/group/key_mgmt/proto/auth_alg/channels> "
2429 "= get capabilies" },
2430 { "reconfigure", wpa_cli_cmd_reconfigure, NULL,
2432 "= force wpa_supplicant to re-read its configuration file" },
2433 { "terminate", wpa_cli_cmd_terminate, NULL,
2435 "= terminate wpa_supplicant" },
2436 { "interface_add", wpa_cli_cmd_interface_add, NULL,
2438 "<ifname> <confname> <driver> <ctrl_interface> <driver_param>\n"
2439 " <bridge_name> = adds new interface, all parameters but <ifname>\n"
2441 { "interface_remove", wpa_cli_cmd_interface_remove, NULL,
2443 "<ifname> = removes the interface" },
2444 { "interface_list", wpa_cli_cmd_interface_list, NULL,
2446 "= list available interfaces" },
2447 { "ap_scan", wpa_cli_cmd_ap_scan, NULL,
2449 "<value> = set ap_scan parameter" },
2450 { "scan_interval", wpa_cli_cmd_scan_interval, NULL,
2452 "<value> = set scan_interval parameter (in seconds)" },
2453 { "bss_expire_age", wpa_cli_cmd_bss_expire_age, NULL,
2455 "<value> = set BSS expiration age parameter" },
2456 { "bss_expire_count", wpa_cli_cmd_bss_expire_count, NULL,
2458 "<value> = set BSS expiration scan count parameter" },
2459 { "bss_flush", wpa_cli_cmd_bss_flush, NULL,
2461 "<value> = set BSS flush age (0 by default)" },
2462 { "stkstart", wpa_cli_cmd_stkstart, NULL,
2464 "<addr> = request STK negotiation with <addr>" },
2465 { "ft_ds", wpa_cli_cmd_ft_ds, wpa_cli_complete_bss,
2467 "<addr> = request over-the-DS FT with <addr>" },
2468 { "wps_pbc", wpa_cli_cmd_wps_pbc, wpa_cli_complete_bss,
2470 "[BSSID] = start Wi-Fi Protected Setup: Push Button Configuration" },
2471 { "wps_pin", wpa_cli_cmd_wps_pin, wpa_cli_complete_bss,
2472 cli_cmd_flag_sensitive,
2473 "<BSSID> [PIN] = start WPS PIN method (returns PIN, if not "
2475 { "wps_check_pin", wpa_cli_cmd_wps_check_pin, NULL,
2476 cli_cmd_flag_sensitive,
2477 "<PIN> = verify PIN checksum" },
2478 { "wps_cancel", wpa_cli_cmd_wps_cancel, NULL, cli_cmd_flag_none,
2479 "Cancels the pending WPS operation" },
2480 #ifdef CONFIG_WPS_NFC
2481 { "wps_nfc", wpa_cli_cmd_wps_nfc, wpa_cli_complete_bss,
2483 "[BSSID] = start Wi-Fi Protected Setup: NFC" },
2484 { "wps_nfc_token", wpa_cli_cmd_wps_nfc_token, NULL,
2486 "<WPS|NDEF> = create password token" },
2487 { "wps_nfc_tag_read", wpa_cli_cmd_wps_nfc_tag_read, NULL,
2488 cli_cmd_flag_sensitive,
2489 "<hexdump of payload> = report read NFC tag with WPS data" },
2490 { "nfc_get_handover_req", wpa_cli_cmd_nfc_get_handover_req, NULL,
2492 "<NDEF> <WPS> = create NFC handover request" },
2493 { "nfc_get_handover_sel", wpa_cli_cmd_nfc_get_handover_sel, NULL,
2495 "<NDEF> <WPS> = create NFC handover select" },
2496 { "nfc_rx_handover_req", wpa_cli_cmd_nfc_rx_handover_req, NULL,
2498 "<hexdump of payload> = report received NFC handover request" },
2499 { "nfc_rx_handover_sel", wpa_cli_cmd_nfc_rx_handover_sel, NULL,
2501 "<hexdump of payload> = report received NFC handover select" },
2502 #endif /* CONFIG_WPS_NFC */
2503 { "wps_reg", wpa_cli_cmd_wps_reg, wpa_cli_complete_bss,
2504 cli_cmd_flag_sensitive,
2505 "<BSSID> <AP PIN> = start WPS Registrar to configure an AP" },
2506 { "wps_ap_pin", wpa_cli_cmd_wps_ap_pin, NULL,
2507 cli_cmd_flag_sensitive,
2508 "[params..] = enable/disable AP PIN" },
2509 { "wps_er_start", wpa_cli_cmd_wps_er_start, NULL,
2511 "[IP address] = start Wi-Fi Protected Setup External Registrar" },
2512 { "wps_er_stop", wpa_cli_cmd_wps_er_stop, NULL,
2514 "= stop Wi-Fi Protected Setup External Registrar" },
2515 { "wps_er_pin", wpa_cli_cmd_wps_er_pin, NULL,
2516 cli_cmd_flag_sensitive,
2517 "<UUID> <PIN> = add an Enrollee PIN to External Registrar" },
2518 { "wps_er_pbc", wpa_cli_cmd_wps_er_pbc, NULL,
2520 "<UUID> = accept an Enrollee PBC using External Registrar" },
2521 { "wps_er_learn", wpa_cli_cmd_wps_er_learn, NULL,
2522 cli_cmd_flag_sensitive,
2523 "<UUID> <PIN> = learn AP configuration" },
2524 { "wps_er_set_config", wpa_cli_cmd_wps_er_set_config, NULL,
2526 "<UUID> <network id> = set AP configuration for enrolling" },
2527 { "wps_er_config", wpa_cli_cmd_wps_er_config, NULL,
2528 cli_cmd_flag_sensitive,
2529 "<UUID> <PIN> <SSID> <auth> <encr> <key> = configure AP" },
2530 #ifdef CONFIG_WPS_NFC
2531 { "wps_er_nfc_config_token", wpa_cli_cmd_wps_er_nfc_config_token, NULL,
2533 "<WPS/NDEF> <UUID> = build NFC configuration token" },
2534 #endif /* CONFIG_WPS_NFC */
2535 { "ibss_rsn", wpa_cli_cmd_ibss_rsn, NULL,
2537 "<addr> = request RSN authentication with <addr> in IBSS" },
2539 { "sta", wpa_cli_cmd_sta, NULL,
2541 "<addr> = get information about an associated station (AP)" },
2542 { "all_sta", wpa_cli_cmd_all_sta, NULL,
2544 "= get information about all associated stations (AP)" },
2545 { "deauthenticate", wpa_cli_cmd_deauthenticate, NULL,
2547 "<addr> = deauthenticate a station" },
2548 { "disassociate", wpa_cli_cmd_disassociate, NULL,
2550 "<addr> = disassociate a station" },
2551 #endif /* CONFIG_AP */
2552 { "suspend", wpa_cli_cmd_suspend, NULL, cli_cmd_flag_none,
2553 "= notification of suspend/hibernate" },
2554 { "resume", wpa_cli_cmd_resume, NULL, cli_cmd_flag_none,
2555 "= notification of resume/thaw" },
2556 { "drop_sa", wpa_cli_cmd_drop_sa, NULL, cli_cmd_flag_none,
2557 "= drop SA without deauth/disassoc (test command)" },
2558 { "roam", wpa_cli_cmd_roam, wpa_cli_complete_bss,
2560 "<addr> = roam to the specified BSS" },
2562 { "p2p_find", wpa_cli_cmd_p2p_find, wpa_cli_complete_p2p_find,
2564 "[timeout] [type=*] = find P2P Devices for up-to timeout seconds" },
2565 { "p2p_stop_find", wpa_cli_cmd_p2p_stop_find, NULL, cli_cmd_flag_none,
2566 "= stop P2P Devices search" },
2567 { "p2p_connect", wpa_cli_cmd_p2p_connect, wpa_cli_complete_p2p_connect,
2569 "<addr> <\"pbc\"|PIN> [ht40] = connect to a P2P Device" },
2570 { "p2p_listen", wpa_cli_cmd_p2p_listen, NULL, cli_cmd_flag_none,
2571 "[timeout] = listen for P2P Devices for up-to timeout seconds" },
2572 { "p2p_group_remove", wpa_cli_cmd_p2p_group_remove,
2573 wpa_cli_complete_p2p_group_remove, cli_cmd_flag_none,
2574 "<ifname> = remove P2P group interface (terminate group if GO)" },
2575 { "p2p_group_add", wpa_cli_cmd_p2p_group_add, NULL, cli_cmd_flag_none,
2576 "[ht40] = add a new P2P group (local end as GO)" },
2577 { "p2p_prov_disc", wpa_cli_cmd_p2p_prov_disc,
2578 wpa_cli_complete_p2p_peer, cli_cmd_flag_none,
2579 "<addr> <method> = request provisioning discovery" },
2580 { "p2p_get_passphrase", wpa_cli_cmd_p2p_get_passphrase, NULL,
2582 "= get the passphrase for a group (GO only)" },
2583 { "p2p_serv_disc_req", wpa_cli_cmd_p2p_serv_disc_req,
2584 wpa_cli_complete_p2p_peer, cli_cmd_flag_none,
2585 "<addr> <TLVs> = schedule service discovery request" },
2586 { "p2p_serv_disc_cancel_req", wpa_cli_cmd_p2p_serv_disc_cancel_req,
2587 NULL, cli_cmd_flag_none,
2588 "<id> = cancel pending service discovery request" },
2589 { "p2p_serv_disc_resp", wpa_cli_cmd_p2p_serv_disc_resp, NULL,
2591 "<freq> <addr> <dialog token> <TLVs> = service discovery response" },
2592 { "p2p_service_update", wpa_cli_cmd_p2p_service_update, NULL,
2594 "= indicate change in local services" },
2595 { "p2p_serv_disc_external", wpa_cli_cmd_p2p_serv_disc_external, NULL,
2597 "<external> = set external processing of service discovery" },
2598 { "p2p_service_flush", wpa_cli_cmd_p2p_service_flush, NULL,
2600 "= remove all stored service entries" },
2601 { "p2p_service_add", wpa_cli_cmd_p2p_service_add, NULL,
2603 "<bonjour|upnp> <query|version> <response|service> = add a local "
2605 { "p2p_service_del", wpa_cli_cmd_p2p_service_del, NULL,
2607 "<bonjour|upnp> <query|version> [|service] = remove a local "
2609 { "p2p_reject", wpa_cli_cmd_p2p_reject, wpa_cli_complete_p2p_peer,
2611 "<addr> = reject connection attempts from a specific peer" },
2612 { "p2p_invite", wpa_cli_cmd_p2p_invite, NULL,
2614 "<cmd> [peer=addr] = invite peer" },
2615 { "p2p_peers", wpa_cli_cmd_p2p_peers, NULL, cli_cmd_flag_none,
2616 "[discovered] = list known (optionally, only fully discovered) P2P "
2618 { "p2p_peer", wpa_cli_cmd_p2p_peer, wpa_cli_complete_p2p_peer,
2620 "<address> = show information about known P2P peer" },
2621 { "p2p_set", wpa_cli_cmd_p2p_set, NULL, cli_cmd_flag_none,
2622 "<field> <value> = set a P2P parameter" },
2623 { "p2p_flush", wpa_cli_cmd_p2p_flush, NULL, cli_cmd_flag_none,
2624 "= flush P2P state" },
2625 { "p2p_cancel", wpa_cli_cmd_p2p_cancel, NULL, cli_cmd_flag_none,
2626 "= cancel P2P group formation" },
2627 { "p2p_unauthorize", wpa_cli_cmd_p2p_unauthorize,
2628 wpa_cli_complete_p2p_peer, cli_cmd_flag_none,
2629 "<address> = unauthorize a peer" },
2630 { "p2p_presence_req", wpa_cli_cmd_p2p_presence_req, NULL,
2632 "[<duration> <interval>] [<duration> <interval>] = request GO "
2634 { "p2p_ext_listen", wpa_cli_cmd_p2p_ext_listen, NULL,
2636 "[<period> <interval>] = set extended listen timing" },
2637 #endif /* CONFIG_P2P */
2638 #ifdef CONFIG_WIFI_DISPLAY
2639 { "wfd_subelem_set", wpa_cli_cmd_wfd_subelem_set, NULL,
2641 "<subelem> [contents] = set Wi-Fi Display subelement" },
2642 { "wfd_subelem_get", wpa_cli_cmd_wfd_subelem_get, NULL,
2644 "<subelem> = get Wi-Fi Display subelement" },
2645 #endif /* CONFIG_WIFI_DISPLAY */
2646 #ifdef CONFIG_INTERWORKING
2647 { "fetch_anqp", wpa_cli_cmd_fetch_anqp, NULL, cli_cmd_flag_none,
2648 "= fetch ANQP information for all APs" },
2649 { "stop_fetch_anqp", wpa_cli_cmd_stop_fetch_anqp, NULL,
2651 "= stop fetch_anqp operation" },
2652 { "interworking_select", wpa_cli_cmd_interworking_select, NULL,
2654 "[auto] = perform Interworking network selection" },
2655 { "interworking_connect", wpa_cli_cmd_interworking_connect,
2656 wpa_cli_complete_bss, cli_cmd_flag_none,
2657 "<BSSID> = connect using Interworking credentials" },
2658 { "anqp_get", wpa_cli_cmd_anqp_get, wpa_cli_complete_bss,
2660 "<addr> <info id>[,<info id>]... = request ANQP information" },
2661 { "gas_request", wpa_cli_cmd_gas_request, wpa_cli_complete_bss,
2663 "<addr> <AdvProtoID> [QueryReq] = GAS request" },
2664 { "gas_response_get", wpa_cli_cmd_gas_response_get,
2665 wpa_cli_complete_bss, cli_cmd_flag_none,
2666 "<addr> <dialog token> [start,len] = Fetch last GAS response" },
2667 #endif /* CONFIG_INTERWORKING */
2669 { "hs20_anqp_get", wpa_cli_cmd_hs20_anqp_get, wpa_cli_complete_bss,
2671 "<addr> <subtype>[,<subtype>]... = request HS 2.0 ANQP information"
2673 { "nai_home_realm_list", wpa_cli_cmd_get_nai_home_realm_list,
2674 wpa_cli_complete_bss, cli_cmd_flag_none,
2675 "<addr> <home realm> = get HS20 nai home realm list" },
2676 #endif /* CONFIG_HS20 */
2677 { "sta_autoconnect", wpa_cli_cmd_sta_autoconnect, NULL,
2679 "<0/1> = disable/enable automatic reconnection" },
2680 { "tdls_discover", wpa_cli_cmd_tdls_discover, NULL,
2682 "<addr> = request TDLS discovery with <addr>" },
2683 { "tdls_setup", wpa_cli_cmd_tdls_setup, NULL,
2685 "<addr> = request TDLS setup with <addr>" },
2686 { "tdls_teardown", wpa_cli_cmd_tdls_teardown, NULL,
2688 "<addr> = tear down TDLS with <addr>" },
2689 { "signal_poll", wpa_cli_cmd_signal_poll, NULL,
2691 "= get signal parameters" },
2692 { "pktcnt_poll", wpa_cli_cmd_pktcnt_poll, NULL,
2694 "= get TX/RX packet counters" },
2695 { "reauthenticate", wpa_cli_cmd_reauthenticate, NULL,
2697 "= trigger IEEE 802.1X/EAPOL reauthentication" },
2698 #ifdef CONFIG_AUTOSCAN
2699 { "autoscan", wpa_cli_cmd_autoscan, NULL, cli_cmd_flag_none,
2700 "[params] = Set or unset (if none) autoscan parameters" },
2701 #endif /* CONFIG_AUTOSCAN */
2703 { "wnm_sleep", wpa_cli_cmd_wnm_sleep, NULL, cli_cmd_flag_none,
2704 "<enter/exit> [interval=#] = enter/exit WNM-Sleep mode" },
2705 #endif /* CONFIG_WNM */
2706 { "raw", wpa_cli_cmd_raw, NULL, cli_cmd_flag_sensitive,
2707 "<params..> = Sent unprocessed command" },
2708 { NULL, NULL, NULL, cli_cmd_flag_none, NULL }
2713 * Prints command usage, lines are padded with the specified string.
2715 static void print_cmd_help(struct wpa_cli_cmd *cmd, const char *pad)
2720 printf("%s%s ", pad, cmd->cmd);
2721 for (n = 0; (c = cmd->usage[n]); n++) {
2730 static void print_help(const char *cmd)
2733 printf("commands:\n");
2734 for (n = 0; wpa_cli_commands[n].cmd; n++) {
2735 if (cmd == NULL || str_starts(wpa_cli_commands[n].cmd, cmd))
2736 print_cmd_help(&wpa_cli_commands[n], " ");
2741 static int wpa_cli_edit_filter_history_cb(void *ctx, const char *cmd)
2743 const char *c, *delim;
2747 delim = os_strchr(cmd, ' ');
2751 len = os_strlen(cmd);
2753 for (n = 0; (c = wpa_cli_commands[n].cmd); n++) {
2754 if (os_strncasecmp(cmd, c, len) == 0 && len == os_strlen(c))
2755 return (wpa_cli_commands[n].flags &
2756 cli_cmd_flag_sensitive);
2762 static char ** wpa_list_cmd_list(void)
2767 count = sizeof(wpa_cli_commands) / sizeof(wpa_cli_commands[0]);
2768 res = os_calloc(count, sizeof(char *));
2772 for (i = 0; wpa_cli_commands[i].cmd; i++) {
2773 res[i] = os_strdup(wpa_cli_commands[i].cmd);
2782 static char ** wpa_cli_cmd_completion(const char *cmd, const char *str,
2787 for (i = 0; wpa_cli_commands[i].cmd; i++) {
2788 if (os_strcasecmp(wpa_cli_commands[i].cmd, cmd) == 0) {
2789 if (wpa_cli_commands[i].completion)
2790 return wpa_cli_commands[i].completion(str,
2793 printf("\r%s\n", wpa_cli_commands[i].usage);
2803 static char ** wpa_cli_edit_completion_cb(void *ctx, const char *str, int pos)
2809 end = os_strchr(str, ' ');
2810 if (end == NULL || str + pos < end)
2811 return wpa_list_cmd_list();
2813 cmd = os_malloc(pos + 1);
2816 os_memcpy(cmd, str, pos);
2817 cmd[end - str] = '\0';
2818 res = wpa_cli_cmd_completion(cmd, str, pos);
2824 static int wpa_request(struct wpa_ctrl *ctrl, int argc, char *argv[])
2826 struct wpa_cli_cmd *cmd, *match = NULL;
2831 cmd = wpa_cli_commands;
2833 if (os_strncasecmp(cmd->cmd, argv[0], os_strlen(argv[0])) == 0)
2836 if (os_strcasecmp(cmd->cmd, argv[0]) == 0) {
2837 /* we have an exact match */
2847 printf("Ambiguous command '%s'; possible commands:", argv[0]);
2848 cmd = wpa_cli_commands;
2850 if (os_strncasecmp(cmd->cmd, argv[0],
2851 os_strlen(argv[0])) == 0) {
2852 printf(" %s", cmd->cmd);
2858 } else if (count == 0) {
2859 printf("Unknown command '%s'\n", argv[0]);
2862 ret = match->handler(ctrl, argc - 1, &argv[1]);
2869 static int str_match(const char *a, const char *b)
2871 return os_strncmp(a, b, os_strlen(b)) == 0;
2875 static int wpa_cli_exec(const char *program, const char *arg1,
2883 len = os_strlen(program) + os_strlen(arg1) + os_strlen(arg2) + 3;
2884 cmd = os_malloc(len);
2887 res = os_snprintf(cmd, len, "%s %s %s", program, arg1, arg2);
2888 if (res < 0 || (size_t) res >= len) {
2892 cmd[len - 1] = '\0';
2894 if (system(cmd) < 0)
2896 #endif /* _WIN32_WCE */
2903 static void wpa_cli_action_process(const char *msg)
2906 char *copy = NULL, *id, *pos2;
2911 pos = os_strchr(pos, '>');
2918 if (str_match(pos, WPA_EVENT_CONNECTED)) {
2920 os_unsetenv("WPA_ID");
2921 os_unsetenv("WPA_ID_STR");
2922 os_unsetenv("WPA_CTRL_DIR");
2924 pos = os_strstr(pos, "[id=");
2926 copy = os_strdup(pos + 4);
2930 while (*pos2 && *pos2 != ' ')
2934 os_setenv("WPA_ID", id, 1);
2935 while (*pos2 && *pos2 != '=')
2940 while (*pos2 && *pos2 != ']')
2943 os_setenv("WPA_ID_STR", id, 1);
2947 os_setenv("WPA_CTRL_DIR", ctrl_iface_dir, 1);
2949 if (!wpa_cli_connected || new_id != wpa_cli_last_id) {
2950 wpa_cli_connected = 1;
2951 wpa_cli_last_id = new_id;
2952 wpa_cli_exec(action_file, ctrl_ifname, "CONNECTED");
2954 } else if (str_match(pos, WPA_EVENT_DISCONNECTED)) {
2955 if (wpa_cli_connected) {
2956 wpa_cli_connected = 0;
2957 wpa_cli_exec(action_file, ctrl_ifname, "DISCONNECTED");
2959 } else if (str_match(pos, P2P_EVENT_GROUP_STARTED)) {
2960 wpa_cli_exec(action_file, ctrl_ifname, pos);
2961 } else if (str_match(pos, P2P_EVENT_GROUP_REMOVED)) {
2962 wpa_cli_exec(action_file, ctrl_ifname, pos);
2963 } else if (str_match(pos, P2P_EVENT_CROSS_CONNECT_ENABLE)) {
2964 wpa_cli_exec(action_file, ctrl_ifname, pos);
2965 } else if (str_match(pos, P2P_EVENT_CROSS_CONNECT_DISABLE)) {
2966 wpa_cli_exec(action_file, ctrl_ifname, pos);
2967 } else if (str_match(pos, P2P_EVENT_GO_NEG_FAILURE)) {
2968 wpa_cli_exec(action_file, ctrl_ifname, pos);
2969 } else if (str_match(pos, WPS_EVENT_SUCCESS)) {
2970 wpa_cli_exec(action_file, ctrl_ifname, pos);
2971 } else if (str_match(pos, WPS_EVENT_FAIL)) {
2972 wpa_cli_exec(action_file, ctrl_ifname, pos);
2973 } else if (str_match(pos, AP_STA_CONNECTED)) {
2974 wpa_cli_exec(action_file, ctrl_ifname, pos);
2975 } else if (str_match(pos, AP_STA_DISCONNECTED)) {
2976 wpa_cli_exec(action_file, ctrl_ifname, pos);
2977 } else if (str_match(pos, WPA_EVENT_TERMINATING)) {
2978 printf("wpa_supplicant is terminating - stop monitoring\n");
2984 #ifndef CONFIG_ANSI_C_EXTRA
2985 static void wpa_cli_action_cb(char *msg, size_t len)
2987 wpa_cli_action_process(msg);
2989 #endif /* CONFIG_ANSI_C_EXTRA */
2992 static void wpa_cli_reconnect(void)
2994 wpa_cli_close_connection();
2995 if (wpa_cli_open_connection(ctrl_ifname, 1) < 0)
3000 printf("\rConnection to wpa_supplicant re-established\n");
3006 static void cli_event(const char *str)
3008 const char *start, *s;
3010 start = os_strchr(str, '>');
3016 if (str_starts(start, WPA_EVENT_BSS_ADDED)) {
3017 s = os_strchr(start, ' ');
3020 s = os_strchr(s + 1, ' ');
3023 cli_txt_list_add(&bsses, s + 1);
3027 if (str_starts(start, WPA_EVENT_BSS_REMOVED)) {
3028 s = os_strchr(start, ' ');
3031 s = os_strchr(s + 1, ' ');
3034 cli_txt_list_del_addr(&bsses, s + 1);
3039 if (str_starts(start, P2P_EVENT_DEVICE_FOUND)) {
3040 s = os_strstr(start, " p2p_dev_addr=");
3043 cli_txt_list_add_addr(&p2p_peers, s + 14);
3047 if (str_starts(start, P2P_EVENT_DEVICE_LOST)) {
3048 s = os_strstr(start, " p2p_dev_addr=");
3051 cli_txt_list_del_addr(&p2p_peers, s + 14);
3055 if (str_starts(start, P2P_EVENT_GROUP_STARTED)) {
3056 s = os_strchr(start, ' ');
3059 cli_txt_list_add_word(&p2p_groups, s + 1);
3063 if (str_starts(start, P2P_EVENT_GROUP_REMOVED)) {
3064 s = os_strchr(start, ' ');
3067 cli_txt_list_del_word(&p2p_groups, s + 1);
3070 #endif /* CONFIG_P2P */
3074 static int check_terminating(const char *msg)
3076 const char *pos = msg;
3080 pos = os_strchr(pos, '>');
3087 if (str_match(pos, WPA_EVENT_TERMINATING) && ctrl_conn) {
3089 printf("\rConnection to wpa_supplicant lost - trying to "
3092 wpa_cli_attached = 0;
3093 wpa_cli_close_connection();
3101 static void wpa_cli_recv_pending(struct wpa_ctrl *ctrl, int action_monitor)
3103 if (ctrl_conn == NULL) {
3104 wpa_cli_reconnect();
3107 while (wpa_ctrl_pending(ctrl) > 0) {
3109 size_t len = sizeof(buf) - 1;
3110 if (wpa_ctrl_recv(ctrl, buf, &len) == 0) {
3113 wpa_cli_action_process(buf);
3116 if (wpa_cli_show_event(buf)) {
3118 printf("\r%s\n", buf);
3122 if (interactive && check_terminating(buf) > 0)
3126 printf("Could not read pending message.\n");
3131 if (wpa_ctrl_pending(ctrl) < 0) {
3132 printf("Connection to wpa_supplicant lost - trying to "
3134 wpa_cli_reconnect();
3140 static int tokenize_cmd(char *cmd, char *argv[])
3153 if (argc == max_args)
3156 char *pos2 = os_strrchr(pos, '"');
3160 while (*pos != '\0' && *pos != ' ')
3170 static void wpa_cli_ping(void *eloop_ctx, void *timeout_ctx)
3172 if (ctrl_conn && _wpa_ctrl_command(ctrl_conn, "PING", 0)) {
3173 printf("Connection to wpa_supplicant lost - trying to "
3175 wpa_cli_close_connection();
3178 wpa_cli_reconnect();
3179 eloop_register_timeout(ping_interval, 0, wpa_cli_ping, NULL, NULL);
3183 static void wpa_cli_mon_receive(int sock, void *eloop_ctx, void *sock_ctx)
3185 wpa_cli_recv_pending(mon_conn, 0);
3189 static void wpa_cli_edit_cmd_cb(void *ctx, char *cmd)
3191 char *argv[max_args];
3193 argc = tokenize_cmd(cmd, argv);
3195 wpa_request(ctrl_conn, argc, argv);
3199 static void wpa_cli_edit_eof_cb(void *ctx)
3205 static int warning_displayed = 0;
3206 static char *hfile = NULL;
3207 static int edit_started = 0;
3209 static void start_edit(void)
3214 #ifdef CONFIG_CTRL_IFACE_UDP_REMOTE
3215 ps = wpa_ctrl_get_remote_ifname(ctrl_conn);
3216 #endif /* CONFIG_CTRL_IFACE_UDP_REMOTE */
3218 home = getenv("HOME");
3220 const char *fname = ".wpa_cli_history";
3221 int hfile_len = os_strlen(home) + 1 + os_strlen(fname) + 1;
3222 hfile = os_malloc(hfile_len);
3224 os_snprintf(hfile, hfile_len, "%s/%s", home, fname);
3227 if (edit_init(wpa_cli_edit_cmd_cb, wpa_cli_edit_eof_cb,
3228 wpa_cli_edit_completion_cb, NULL, hfile, ps) < 0) {
3234 eloop_register_timeout(ping_interval, 0, wpa_cli_ping, NULL, NULL);
3238 static void try_connection(void *eloop_ctx, void *timeout_ctx)
3240 if (ctrl_ifname == NULL)
3241 ctrl_ifname = wpa_cli_get_default_ifname();
3243 if (!wpa_cli_open_connection(ctrl_ifname, 1) == 0) {
3244 if (!warning_displayed) {
3245 printf("Could not connect to wpa_supplicant: "
3246 "%s - re-trying\n", ctrl_ifname);
3247 warning_displayed = 1;
3249 eloop_register_timeout(1, 0, try_connection, NULL, NULL);
3253 if (warning_displayed)
3254 printf("Connection established.\n");
3260 static void wpa_cli_interactive(void)
3262 printf("\nInteractive mode\n\n");
3264 eloop_register_timeout(0, 0, try_connection, NULL, NULL);
3266 eloop_cancel_timeout(try_connection, NULL, NULL);
3268 cli_txt_list_flush(&p2p_peers);
3269 cli_txt_list_flush(&p2p_groups);
3270 cli_txt_list_flush(&bsses);
3272 edit_deinit(hfile, wpa_cli_edit_filter_history_cb);
3274 eloop_cancel_timeout(wpa_cli_ping, NULL, NULL);
3275 wpa_cli_close_connection();
3279 static void wpa_cli_action(struct wpa_ctrl *ctrl)
3281 #ifdef CONFIG_ANSI_C_EXTRA
3282 /* TODO: ANSI C version(?) */
3283 printf("Action processing not supported in ANSI C build.\n");
3284 #else /* CONFIG_ANSI_C_EXTRA */
3288 char buf[256]; /* note: large enough to fit in unsolicited messages */
3291 fd = wpa_ctrl_get_fd(ctrl);
3293 while (!wpa_cli_quit) {
3296 tv.tv_sec = ping_interval;
3298 res = select(fd + 1, &rfds, NULL, NULL, &tv);
3299 if (res < 0 && errno != EINTR) {
3304 if (FD_ISSET(fd, &rfds))
3305 wpa_cli_recv_pending(ctrl, 1);
3307 /* verify that connection is still working */
3308 len = sizeof(buf) - 1;
3309 if (wpa_ctrl_request(ctrl, "PING", 4, buf, &len,
3310 wpa_cli_action_cb) < 0 ||
3311 len < 4 || os_memcmp(buf, "PONG", 4) != 0) {
3312 printf("wpa_supplicant did not reply to PING "
3313 "command - exiting\n");
3318 #endif /* CONFIG_ANSI_C_EXTRA */
3322 static void wpa_cli_cleanup(void)
3324 wpa_cli_close_connection();
3326 os_daemonize_terminate(pid_file);
3328 os_program_deinit();
3332 static void wpa_cli_terminate(int sig, void *ctx)
3338 static char * wpa_cli_get_default_ifname(void)
3340 char *ifname = NULL;
3342 #ifdef CONFIG_CTRL_IFACE_UNIX
3343 struct dirent *dent;
3344 DIR *dir = opendir(ctrl_iface_dir);
3347 char ifprop[PROPERTY_VALUE_MAX];
3348 if (property_get("wifi.interface", ifprop, NULL) != 0) {
3349 ifname = os_strdup(ifprop);
3350 printf("Using interface '%s'\n", ifname);
3353 #endif /* ANDROID */
3356 while ((dent = readdir(dir))) {
3357 #ifdef _DIRENT_HAVE_D_TYPE
3359 * Skip the file if it is not a socket. Also accept
3360 * DT_UNKNOWN (0) in case the C library or underlying
3361 * file system does not support d_type.
3363 if (dent->d_type != DT_SOCK && dent->d_type != DT_UNKNOWN)
3365 #endif /* _DIRENT_HAVE_D_TYPE */
3366 if (os_strcmp(dent->d_name, ".") == 0 ||
3367 os_strcmp(dent->d_name, "..") == 0)
3369 printf("Selected interface '%s'\n", dent->d_name);
3370 ifname = os_strdup(dent->d_name);
3374 #endif /* CONFIG_CTRL_IFACE_UNIX */
3376 #ifdef CONFIG_CTRL_IFACE_NAMED_PIPE
3377 char buf[2048], *pos;
3379 struct wpa_ctrl *ctrl;
3382 ctrl = wpa_ctrl_open(NULL);
3386 len = sizeof(buf) - 1;
3387 ret = wpa_ctrl_request(ctrl, "INTERFACES", 10, buf, &len, NULL);
3390 pos = os_strchr(buf, '\n');
3393 ifname = os_strdup(buf);
3395 wpa_ctrl_close(ctrl);
3396 #endif /* CONFIG_CTRL_IFACE_NAMED_PIPE */
3402 int main(int argc, char *argv[])
3407 const char *global = NULL;
3409 if (os_program_init())
3413 c = getopt(argc, argv, "a:Bg:G:hi:p:P:v");
3418 action_file = optarg;
3427 ping_interval = atoi(optarg);
3433 printf("%s\n", wpa_cli_version);
3436 os_free(ctrl_ifname);
3437 ctrl_ifname = os_strdup(optarg);
3440 ctrl_iface_dir = optarg;
3451 interactive = (argc == optind) && (action_file == NULL);
3454 printf("%s\n\n%s\n\n", wpa_cli_version, wpa_cli_license);
3460 #ifdef CONFIG_CTRL_IFACE_NAMED_PIPE
3461 ctrl_conn = wpa_ctrl_open(NULL);
3462 #else /* CONFIG_CTRL_IFACE_NAMED_PIPE */
3463 ctrl_conn = wpa_ctrl_open(global);
3464 #endif /* CONFIG_CTRL_IFACE_NAMED_PIPE */
3465 if (ctrl_conn == NULL) {
3466 fprintf(stderr, "Failed to connect to wpa_supplicant "
3467 "global interface: %s error: %s\n",
3468 global, strerror(errno));
3473 eloop_register_signal_terminate(wpa_cli_terminate, NULL);
3475 if (ctrl_ifname == NULL)
3476 ctrl_ifname = wpa_cli_get_default_ifname();
3479 wpa_cli_interactive();
3482 wpa_cli_open_connection(ctrl_ifname, 0) < 0) {
3483 fprintf(stderr, "Failed to connect to non-global "
3484 "ctrl_ifname: %s error: %s\n",
3485 ctrl_ifname, strerror(errno));
3490 if (wpa_ctrl_attach(ctrl_conn) == 0) {
3491 wpa_cli_attached = 1;
3493 printf("Warning: Failed to attach to "
3494 "wpa_supplicant.\n");
3499 if (daemonize && os_daemonize(pid_file))
3503 wpa_cli_action(ctrl_conn);
3505 ret = wpa_request(ctrl_conn, argc - optind,
3509 os_free(ctrl_ifname);
3516 #else /* CONFIG_CTRL_IFACE */
3517 int main(int argc, char *argv[])
3519 printf("CONFIG_CTRL_IFACE not defined - wpa_cli disabled\n");
3522 #endif /* CONFIG_CTRL_IFACE */