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-2013, 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_config_token(struct wpa_ctrl
*ctrl
, int argc
,
750 return wpa_cli_cmd(ctrl
, "WPS_NFC_CONFIG_TOKEN", 1, argc
, argv
);
754 static int wpa_cli_cmd_wps_nfc_token(struct wpa_ctrl
*ctrl
, int argc
,
757 return wpa_cli_cmd(ctrl
, "WPS_NFC_TOKEN", 1, argc
, argv
);
761 static int wpa_cli_cmd_wps_nfc_tag_read(struct wpa_ctrl
*ctrl
, int argc
,
769 printf("Invalid 'wps_nfc_tag_read' command - one argument "
774 buflen
= 18 + os_strlen(argv
[0]);
775 buf
= os_malloc(buflen
);
778 os_snprintf(buf
, buflen
, "WPS_NFC_TAG_READ %s", argv
[0]);
780 ret
= wpa_ctrl_command(ctrl
, buf
);
787 static int wpa_cli_cmd_nfc_get_handover_req(struct wpa_ctrl
*ctrl
, int argc
,
790 return wpa_cli_cmd(ctrl
, "NFC_GET_HANDOVER_REQ", 2, argc
, argv
);
794 static int wpa_cli_cmd_nfc_get_handover_sel(struct wpa_ctrl
*ctrl
, int argc
,
797 return wpa_cli_cmd(ctrl
, "NFC_GET_HANDOVER_SEL", 2, argc
, argv
);
801 static int wpa_cli_cmd_nfc_rx_handover_req(struct wpa_ctrl
*ctrl
, int argc
,
809 printf("Invalid 'nfc_rx_handover_req' command - one argument "
814 buflen
= 21 + os_strlen(argv
[0]);
815 buf
= os_malloc(buflen
);
818 os_snprintf(buf
, buflen
, "NFC_RX_HANDOVER_REQ %s", argv
[0]);
820 ret
= wpa_ctrl_command(ctrl
, buf
);
827 static int wpa_cli_cmd_nfc_rx_handover_sel(struct wpa_ctrl
*ctrl
, int argc
,
835 printf("Invalid 'nfc_rx_handover_sel' command - one argument "
840 buflen
= 21 + os_strlen(argv
[0]);
841 buf
= os_malloc(buflen
);
844 os_snprintf(buf
, buflen
, "NFC_RX_HANDOVER_SEL %s", argv
[0]);
846 ret
= wpa_ctrl_command(ctrl
, buf
);
853 static int wpa_cli_cmd_nfc_report_handover(struct wpa_ctrl
*ctrl
, int argc
,
856 return wpa_cli_cmd(ctrl
, "NFC_REPORT_HANDOVER", 4, argc
, argv
);
859 #endif /* CONFIG_WPS_NFC */
862 static int wpa_cli_cmd_wps_reg(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
868 res
= os_snprintf(cmd
, sizeof(cmd
), "WPS_REG %s %s",
870 else if (argc
== 5 || argc
== 6) {
871 char ssid_hex
[2 * 32 + 1];
872 char key_hex
[2 * 64 + 1];
876 for (i
= 0; i
< 32; i
++) {
877 if (argv
[2][i
] == '\0')
879 os_snprintf(&ssid_hex
[i
* 2], 3, "%02x", argv
[2][i
]);
884 for (i
= 0; i
< 64; i
++) {
885 if (argv
[5][i
] == '\0')
887 os_snprintf(&key_hex
[i
* 2], 3, "%02x",
892 res
= os_snprintf(cmd
, sizeof(cmd
),
893 "WPS_REG %s %s %s %s %s %s",
894 argv
[0], argv
[1], ssid_hex
, argv
[3], argv
[4],
897 printf("Invalid WPS_REG command: need two arguments:\n"
898 "- BSSID of the target AP\n"
900 printf("Alternatively, six arguments can be used to "
901 "reconfigure the AP:\n"
902 "- BSSID of the target AP\n"
905 "- new auth (OPEN, WPAPSK, WPA2PSK)\n"
906 "- new encr (NONE, WEP, TKIP, CCMP)\n"
911 if (res
< 0 || (size_t) res
>= sizeof(cmd
) - 1) {
912 printf("Too long WPS_REG command.\n");
915 return wpa_ctrl_command(ctrl
, cmd
);
919 static int wpa_cli_cmd_wps_ap_pin(struct wpa_ctrl
*ctrl
, int argc
,
922 return wpa_cli_cmd(ctrl
, "WPS_AP_PIN", 1, argc
, argv
);
926 static int wpa_cli_cmd_wps_er_start(struct wpa_ctrl
*ctrl
, int argc
,
929 return wpa_cli_cmd(ctrl
, "WPS_ER_START", 0, argc
, argv
);
933 static int wpa_cli_cmd_wps_er_stop(struct wpa_ctrl
*ctrl
, int argc
,
936 return wpa_ctrl_command(ctrl
, "WPS_ER_STOP");
941 static int wpa_cli_cmd_wps_er_pin(struct wpa_ctrl
*ctrl
, int argc
,
945 printf("Invalid WPS_ER_PIN command: need at least two "
947 "- UUID: use 'any' to select any\n"
948 "- PIN: Enrollee PIN\n"
949 "optional: - Enrollee MAC address\n");
953 return wpa_cli_cmd(ctrl
, "WPS_ER_PIN", 2, argc
, argv
);
957 static int wpa_cli_cmd_wps_er_pbc(struct wpa_ctrl
*ctrl
, int argc
,
960 return wpa_cli_cmd(ctrl
, "WPS_ER_PBC", 1, argc
, argv
);
964 static int wpa_cli_cmd_wps_er_learn(struct wpa_ctrl
*ctrl
, int argc
,
968 printf("Invalid WPS_ER_LEARN command: need two arguments:\n"
969 "- UUID: specify which AP to use\n"
974 return wpa_cli_cmd(ctrl
, "WPS_ER_LEARN", 2, argc
, argv
);
978 static int wpa_cli_cmd_wps_er_set_config(struct wpa_ctrl
*ctrl
, int argc
,
982 printf("Invalid WPS_ER_SET_CONFIG command: need two "
984 "- UUID: specify which AP to use\n"
985 "- Network configuration id\n");
989 return wpa_cli_cmd(ctrl
, "WPS_ER_SET_CONFIG", 2, argc
, argv
);
993 static int wpa_cli_cmd_wps_er_config(struct wpa_ctrl
*ctrl
, int argc
,
999 if (argc
== 5 || argc
== 6) {
1000 char ssid_hex
[2 * 32 + 1];
1001 char key_hex
[2 * 64 + 1];
1005 for (i
= 0; i
< 32; i
++) {
1006 if (argv
[2][i
] == '\0')
1008 os_snprintf(&ssid_hex
[i
* 2], 3, "%02x", argv
[2][i
]);
1013 for (i
= 0; i
< 64; i
++) {
1014 if (argv
[5][i
] == '\0')
1016 os_snprintf(&key_hex
[i
* 2], 3, "%02x",
1021 res
= os_snprintf(cmd
, sizeof(cmd
),
1022 "WPS_ER_CONFIG %s %s %s %s %s %s",
1023 argv
[0], argv
[1], ssid_hex
, argv
[3], argv
[4],
1026 printf("Invalid WPS_ER_CONFIG command: need six arguments:\n"
1030 "- new auth (OPEN, WPAPSK, WPA2PSK)\n"
1031 "- new encr (NONE, WEP, TKIP, CCMP)\n"
1036 if (res
< 0 || (size_t) res
>= sizeof(cmd
) - 1) {
1037 printf("Too long WPS_ER_CONFIG command.\n");
1040 return wpa_ctrl_command(ctrl
, cmd
);
1044 #ifdef CONFIG_WPS_NFC
1045 static int wpa_cli_cmd_wps_er_nfc_config_token(struct wpa_ctrl
*ctrl
, int argc
,
1049 printf("Invalid WPS_ER_NFC_CONFIG_TOKEN command: need two "
1051 "- WPS/NDEF: token format\n"
1052 "- UUID: specify which AP to use\n");
1056 return wpa_cli_cmd(ctrl
, "WPS_ER_NFC_CONFIG_TOKEN", 2, argc
, argv
);
1058 #endif /* CONFIG_WPS_NFC */
1061 static int wpa_cli_cmd_ibss_rsn(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1063 return wpa_cli_cmd(ctrl
, "IBSS_RSN", 1, argc
, argv
);
1067 static int wpa_cli_cmd_level(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1069 return wpa_cli_cmd(ctrl
, "LEVEL", 1, argc
, argv
);
1073 static int wpa_cli_cmd_identity(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1075 char cmd
[256], *pos
, *end
;
1079 printf("Invalid IDENTITY command: needs two arguments "
1080 "(network id and identity)\n");
1084 end
= cmd
+ sizeof(cmd
);
1086 ret
= os_snprintf(pos
, end
- pos
, WPA_CTRL_RSP
"IDENTITY-%s:%s",
1088 if (ret
< 0 || ret
>= end
- pos
) {
1089 printf("Too long IDENTITY command.\n");
1093 for (i
= 2; i
< argc
; i
++) {
1094 ret
= os_snprintf(pos
, end
- pos
, " %s", argv
[i
]);
1095 if (ret
< 0 || ret
>= end
- pos
) {
1096 printf("Too long IDENTITY command.\n");
1102 return wpa_ctrl_command(ctrl
, cmd
);
1106 static int wpa_cli_cmd_password(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1108 char cmd
[256], *pos
, *end
;
1112 printf("Invalid PASSWORD command: needs two arguments "
1113 "(network id and password)\n");
1117 end
= cmd
+ sizeof(cmd
);
1119 ret
= os_snprintf(pos
, end
- pos
, WPA_CTRL_RSP
"PASSWORD-%s:%s",
1121 if (ret
< 0 || ret
>= end
- pos
) {
1122 printf("Too long PASSWORD command.\n");
1126 for (i
= 2; i
< argc
; i
++) {
1127 ret
= os_snprintf(pos
, end
- pos
, " %s", argv
[i
]);
1128 if (ret
< 0 || ret
>= end
- pos
) {
1129 printf("Too long PASSWORD command.\n");
1135 return wpa_ctrl_command(ctrl
, cmd
);
1139 static int wpa_cli_cmd_new_password(struct wpa_ctrl
*ctrl
, int argc
,
1142 char cmd
[256], *pos
, *end
;
1146 printf("Invalid NEW_PASSWORD command: needs two arguments "
1147 "(network id and password)\n");
1151 end
= cmd
+ sizeof(cmd
);
1153 ret
= os_snprintf(pos
, end
- pos
, WPA_CTRL_RSP
"NEW_PASSWORD-%s:%s",
1155 if (ret
< 0 || ret
>= end
- pos
) {
1156 printf("Too long NEW_PASSWORD command.\n");
1160 for (i
= 2; i
< argc
; i
++) {
1161 ret
= os_snprintf(pos
, end
- pos
, " %s", argv
[i
]);
1162 if (ret
< 0 || ret
>= end
- pos
) {
1163 printf("Too long NEW_PASSWORD command.\n");
1169 return wpa_ctrl_command(ctrl
, cmd
);
1173 static int wpa_cli_cmd_pin(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1175 char cmd
[256], *pos
, *end
;
1179 printf("Invalid PIN command: needs two arguments "
1180 "(network id and pin)\n");
1184 end
= cmd
+ sizeof(cmd
);
1186 ret
= os_snprintf(pos
, end
- pos
, WPA_CTRL_RSP
"PIN-%s:%s",
1188 if (ret
< 0 || ret
>= end
- pos
) {
1189 printf("Too long PIN command.\n");
1193 for (i
= 2; i
< argc
; i
++) {
1194 ret
= os_snprintf(pos
, end
- pos
, " %s", argv
[i
]);
1195 if (ret
< 0 || ret
>= end
- pos
) {
1196 printf("Too long PIN command.\n");
1201 return wpa_ctrl_command(ctrl
, cmd
);
1205 static int wpa_cli_cmd_otp(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1207 char cmd
[256], *pos
, *end
;
1211 printf("Invalid OTP command: needs two arguments (network "
1212 "id and password)\n");
1216 end
= cmd
+ sizeof(cmd
);
1218 ret
= os_snprintf(pos
, end
- pos
, WPA_CTRL_RSP
"OTP-%s:%s",
1220 if (ret
< 0 || ret
>= end
- pos
) {
1221 printf("Too long OTP command.\n");
1225 for (i
= 2; i
< argc
; i
++) {
1226 ret
= os_snprintf(pos
, end
- pos
, " %s", argv
[i
]);
1227 if (ret
< 0 || ret
>= end
- pos
) {
1228 printf("Too long OTP command.\n");
1234 return wpa_ctrl_command(ctrl
, cmd
);
1238 static int wpa_cli_cmd_passphrase(struct wpa_ctrl
*ctrl
, int argc
,
1241 char cmd
[256], *pos
, *end
;
1245 printf("Invalid PASSPHRASE command: needs two arguments "
1246 "(network id and passphrase)\n");
1250 end
= cmd
+ sizeof(cmd
);
1252 ret
= os_snprintf(pos
, end
- pos
, WPA_CTRL_RSP
"PASSPHRASE-%s:%s",
1254 if (ret
< 0 || ret
>= end
- pos
) {
1255 printf("Too long PASSPHRASE command.\n");
1259 for (i
= 2; i
< argc
; i
++) {
1260 ret
= os_snprintf(pos
, end
- pos
, " %s", argv
[i
]);
1261 if (ret
< 0 || ret
>= end
- pos
) {
1262 printf("Too long PASSPHRASE command.\n");
1268 return wpa_ctrl_command(ctrl
, cmd
);
1272 static int wpa_cli_cmd_bssid(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1275 printf("Invalid BSSID command: needs two arguments (network "
1280 return wpa_cli_cmd(ctrl
, "BSSID", 2, argc
, argv
);
1284 static int wpa_cli_cmd_blacklist(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1286 return wpa_cli_cmd(ctrl
, "BLACKLIST", 0, argc
, argv
);
1290 static int wpa_cli_cmd_log_level(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1292 return wpa_cli_cmd(ctrl
, "LOG_LEVEL", 0, argc
, argv
);
1296 static int wpa_cli_cmd_list_networks(struct wpa_ctrl
*ctrl
, int argc
,
1299 return wpa_ctrl_command(ctrl
, "LIST_NETWORKS");
1303 static int wpa_cli_cmd_select_network(struct wpa_ctrl
*ctrl
, int argc
,
1306 return wpa_cli_cmd(ctrl
, "SELECT_NETWORK", 1, argc
, argv
);
1310 static int wpa_cli_cmd_enable_network(struct wpa_ctrl
*ctrl
, int argc
,
1313 return wpa_cli_cmd(ctrl
, "ENABLE_NETWORK", 1, argc
, argv
);
1317 static int wpa_cli_cmd_disable_network(struct wpa_ctrl
*ctrl
, int argc
,
1320 return wpa_cli_cmd(ctrl
, "DISABLE_NETWORK", 1, argc
, argv
);
1324 static int wpa_cli_cmd_add_network(struct wpa_ctrl
*ctrl
, int argc
,
1327 return wpa_ctrl_command(ctrl
, "ADD_NETWORK");
1331 static int wpa_cli_cmd_remove_network(struct wpa_ctrl
*ctrl
, int argc
,
1334 return wpa_cli_cmd(ctrl
, "REMOVE_NETWORK", 1, argc
, argv
);
1338 static void wpa_cli_show_network_variables(void)
1340 printf("set_network variables:\n"
1341 " ssid (network name, SSID)\n"
1342 " psk (WPA passphrase or pre-shared key)\n"
1343 " key_mgmt (key management protocol)\n"
1344 " identity (EAP identity)\n"
1345 " password (EAP password)\n"
1348 "Note: Values are entered in the same format as the "
1349 "configuration file is using,\n"
1350 "i.e., strings values need to be inside double quotation "
1352 "For example: set_network 1 ssid \"network name\"\n"
1354 "Please see wpa_supplicant.conf documentation for full list "
1355 "of\navailable variables.\n");
1359 static int wpa_cli_cmd_set_network(struct wpa_ctrl
*ctrl
, int argc
,
1363 wpa_cli_show_network_variables();
1368 printf("Invalid SET_NETWORK command: needs three arguments\n"
1369 "(network id, variable name, and value)\n");
1373 return wpa_cli_cmd(ctrl
, "SET_NETWORK", 3, argc
, argv
);
1377 static int wpa_cli_cmd_get_network(struct wpa_ctrl
*ctrl
, int argc
,
1381 wpa_cli_show_network_variables();
1386 printf("Invalid GET_NETWORK command: needs two arguments\n"
1387 "(network id and variable name)\n");
1391 return wpa_cli_cmd(ctrl
, "GET_NETWORK", 2, argc
, argv
);
1395 static int wpa_cli_cmd_list_creds(struct wpa_ctrl
*ctrl
, int argc
,
1398 return wpa_ctrl_command(ctrl
, "LIST_CREDS");
1402 static int wpa_cli_cmd_add_cred(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1404 return wpa_ctrl_command(ctrl
, "ADD_CRED");
1408 static int wpa_cli_cmd_remove_cred(struct wpa_ctrl
*ctrl
, int argc
,
1411 return wpa_cli_cmd(ctrl
, "REMOVE_CRED", 1, argc
, argv
);
1415 static int wpa_cli_cmd_set_cred(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1418 printf("Invalid SET_CRED command: needs three arguments\n"
1419 "(cred id, variable name, and value)\n");
1423 return wpa_cli_cmd(ctrl
, "SET_CRED", 3, argc
, argv
);
1427 static int wpa_cli_cmd_disconnect(struct wpa_ctrl
*ctrl
, int argc
,
1430 return wpa_ctrl_command(ctrl
, "DISCONNECT");
1434 static int wpa_cli_cmd_reconnect(struct wpa_ctrl
*ctrl
, int argc
,
1437 return wpa_ctrl_command(ctrl
, "RECONNECT");
1441 static int wpa_cli_cmd_save_config(struct wpa_ctrl
*ctrl
, int argc
,
1444 return wpa_ctrl_command(ctrl
, "SAVE_CONFIG");
1448 static int wpa_cli_cmd_scan(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1450 return wpa_cli_cmd(ctrl
, "SCAN", 0, argc
, argv
);
1454 static int wpa_cli_cmd_scan_results(struct wpa_ctrl
*ctrl
, int argc
,
1457 return wpa_ctrl_command(ctrl
, "SCAN_RESULTS");
1461 static int wpa_cli_cmd_bss(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1463 return wpa_cli_cmd(ctrl
, "BSS", 1, argc
, argv
);
1467 static char ** wpa_cli_complete_bss(const char *str
, int pos
)
1469 int arg
= get_cmd_arg_num(str
, pos
);
1474 res
= cli_txt_list_array(&bsses
);
1482 static int wpa_cli_cmd_get_capability(struct wpa_ctrl
*ctrl
, int argc
,
1485 if (argc
< 1 || argc
> 2) {
1486 printf("Invalid GET_CAPABILITY command: need either one or "
1491 if ((argc
== 2) && os_strcmp(argv
[1], "strict") != 0) {
1492 printf("Invalid GET_CAPABILITY command: second argument, "
1493 "if any, must be 'strict'\n");
1497 return wpa_cli_cmd(ctrl
, "GET_CAPABILITY", 1, argc
, argv
);
1501 static int wpa_cli_list_interfaces(struct wpa_ctrl
*ctrl
)
1503 printf("Available interfaces:\n");
1504 return wpa_ctrl_command(ctrl
, "INTERFACES");
1508 static int wpa_cli_cmd_interface(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1511 wpa_cli_list_interfaces(ctrl
);
1515 wpa_cli_close_connection();
1516 os_free(ctrl_ifname
);
1517 ctrl_ifname
= os_strdup(argv
[0]);
1519 if (wpa_cli_open_connection(ctrl_ifname
, 1)) {
1520 printf("Connected to interface '%s.\n", ctrl_ifname
);
1522 printf("Could not connect to interface '%s' - re-trying\n",
1529 static int wpa_cli_cmd_reconfigure(struct wpa_ctrl
*ctrl
, int argc
,
1532 return wpa_ctrl_command(ctrl
, "RECONFIGURE");
1536 static int wpa_cli_cmd_terminate(struct wpa_ctrl
*ctrl
, int argc
,
1539 return wpa_ctrl_command(ctrl
, "TERMINATE");
1543 static int wpa_cli_cmd_interface_add(struct wpa_ctrl
*ctrl
, int argc
,
1550 printf("Invalid INTERFACE_ADD command: needs at least one "
1551 "argument (interface name)\n"
1552 "All arguments: ifname confname driver ctrl_interface "
1553 "driver_param bridge_name\n");
1558 * INTERFACE_ADD <ifname>TAB<confname>TAB<driver>TAB<ctrl_interface>TAB
1559 * <driver_param>TAB<bridge_name>
1561 res
= os_snprintf(cmd
, sizeof(cmd
),
1562 "INTERFACE_ADD %s\t%s\t%s\t%s\t%s\t%s",
1564 argc
> 1 ? argv
[1] : "", argc
> 2 ? argv
[2] : "",
1565 argc
> 3 ? argv
[3] : "", argc
> 4 ? argv
[4] : "",
1566 argc
> 5 ? argv
[5] : "");
1567 if (res
< 0 || (size_t) res
>= sizeof(cmd
))
1569 cmd
[sizeof(cmd
) - 1] = '\0';
1570 return wpa_ctrl_command(ctrl
, cmd
);
1574 static int wpa_cli_cmd_interface_remove(struct wpa_ctrl
*ctrl
, int argc
,
1577 return wpa_cli_cmd(ctrl
, "INTERFACE_REMOVE", 1, argc
, argv
);
1581 static int wpa_cli_cmd_interface_list(struct wpa_ctrl
*ctrl
, int argc
,
1584 return wpa_ctrl_command(ctrl
, "INTERFACE_LIST");
1589 static int wpa_cli_cmd_sta(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1591 return wpa_cli_cmd(ctrl
, "STA", 1, argc
, argv
);
1595 static int wpa_ctrl_command_sta(struct wpa_ctrl
*ctrl
, char *cmd
,
1596 char *addr
, size_t addr_len
)
1598 char buf
[4096], *pos
;
1602 if (ctrl_conn
== NULL
) {
1603 printf("Not connected to hostapd - command dropped.\n");
1606 len
= sizeof(buf
) - 1;
1607 ret
= wpa_ctrl_request(ctrl
, cmd
, os_strlen(cmd
), buf
, &len
,
1610 printf("'%s' command timed out.\n", cmd
);
1612 } else if (ret
< 0) {
1613 printf("'%s' command failed.\n", cmd
);
1618 if (os_memcmp(buf
, "FAIL", 4) == 0)
1623 while (*pos
!= '\0' && *pos
!= '\n')
1626 os_strlcpy(addr
, buf
, addr_len
);
1631 static int wpa_cli_cmd_all_sta(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1633 char addr
[32], cmd
[64];
1635 if (wpa_ctrl_command_sta(ctrl
, "STA-FIRST", addr
, sizeof(addr
)))
1638 os_snprintf(cmd
, sizeof(cmd
), "STA-NEXT %s", addr
);
1639 } while (wpa_ctrl_command_sta(ctrl
, cmd
, addr
, sizeof(addr
)) == 0);
1645 static int wpa_cli_cmd_deauthenticate(struct wpa_ctrl
*ctrl
, int argc
,
1648 return wpa_cli_cmd(ctrl
, "DEAUTHENTICATE", 1, argc
, argv
);
1652 static int wpa_cli_cmd_disassociate(struct wpa_ctrl
*ctrl
, int argc
,
1655 return wpa_cli_cmd(ctrl
, "DISASSOCIATE", 1, argc
, argv
);
1657 #endif /* CONFIG_AP */
1660 static int wpa_cli_cmd_suspend(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1662 return wpa_ctrl_command(ctrl
, "SUSPEND");
1666 static int wpa_cli_cmd_resume(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1668 return wpa_ctrl_command(ctrl
, "RESUME");
1672 static int wpa_cli_cmd_drop_sa(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1674 return wpa_ctrl_command(ctrl
, "DROP_SA");
1678 static int wpa_cli_cmd_roam(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1680 return wpa_cli_cmd(ctrl
, "ROAM", 1, argc
, argv
);
1686 static int wpa_cli_cmd_p2p_find(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1688 return wpa_cli_cmd(ctrl
, "P2P_FIND", 0, argc
, argv
);
1692 static char ** wpa_cli_complete_p2p_find(const char *str
, int pos
)
1695 int arg
= get_cmd_arg_num(str
, pos
);
1697 res
= os_calloc(6, sizeof(char *));
1700 res
[0] = os_strdup("type=social");
1701 if (res
[0] == NULL
) {
1705 res
[1] = os_strdup("type=progressive");
1708 res
[2] = os_strdup("delay=");
1711 res
[3] = os_strdup("dev_id=");
1715 res
[4] = os_strdup("[timeout]");
1721 static int wpa_cli_cmd_p2p_stop_find(struct wpa_ctrl
*ctrl
, int argc
,
1724 return wpa_ctrl_command(ctrl
, "P2P_STOP_FIND");
1728 static int wpa_cli_cmd_p2p_connect(struct wpa_ctrl
*ctrl
, int argc
,
1731 return wpa_cli_cmd(ctrl
, "P2P_CONNECT", 2, argc
, argv
);
1735 static char ** wpa_cli_complete_p2p_connect(const char *str
, int pos
)
1737 int arg
= get_cmd_arg_num(str
, pos
);
1742 res
= cli_txt_list_array(&p2p_peers
);
1750 static int wpa_cli_cmd_p2p_listen(struct wpa_ctrl
*ctrl
, int argc
,
1753 return wpa_cli_cmd(ctrl
, "P2P_LISTEN", 0, argc
, argv
);
1757 static int wpa_cli_cmd_p2p_group_remove(struct wpa_ctrl
*ctrl
, int argc
,
1760 return wpa_cli_cmd(ctrl
, "P2P_GROUP_REMOVE", 1, argc
, argv
);
1764 static char ** wpa_cli_complete_p2p_group_remove(const char *str
, int pos
)
1766 int arg
= get_cmd_arg_num(str
, pos
);
1771 res
= cli_txt_list_array(&p2p_groups
);
1779 static int wpa_cli_cmd_p2p_group_add(struct wpa_ctrl
*ctrl
, int argc
,
1782 return wpa_cli_cmd(ctrl
, "P2P_GROUP_ADD", 0, argc
, argv
);
1786 static int wpa_cli_cmd_p2p_prov_disc(struct wpa_ctrl
*ctrl
, int argc
,
1789 if (argc
!= 2 && argc
!= 3) {
1790 printf("Invalid P2P_PROV_DISC command: needs at least "
1791 "two arguments, address and config method\n"
1792 "(display, keypad, or pbc) and an optional join\n");
1796 return wpa_cli_cmd(ctrl
, "P2P_PROV_DISC", 2, argc
, argv
);
1800 static int wpa_cli_cmd_p2p_get_passphrase(struct wpa_ctrl
*ctrl
, int argc
,
1803 return wpa_ctrl_command(ctrl
, "P2P_GET_PASSPHRASE");
1807 static int wpa_cli_cmd_p2p_serv_disc_req(struct wpa_ctrl
*ctrl
, int argc
,
1812 if (argc
!= 2 && argc
!= 4) {
1813 printf("Invalid P2P_SERV_DISC_REQ command: needs two "
1814 "arguments (address and TLVs) or four arguments "
1815 "(address, \"upnp\", version, search target "
1820 if (write_cmd(cmd
, sizeof(cmd
), "P2P_SERV_DISC_REQ", argc
, argv
) < 0)
1822 return wpa_ctrl_command(ctrl
, cmd
);
1826 static int wpa_cli_cmd_p2p_serv_disc_cancel_req(struct wpa_ctrl
*ctrl
,
1827 int argc
, char *argv
[])
1829 return wpa_cli_cmd(ctrl
, "P2P_SERV_DISC_CANCEL_REQ", 1, argc
, argv
);
1833 static int wpa_cli_cmd_p2p_serv_disc_resp(struct wpa_ctrl
*ctrl
, int argc
,
1840 printf("Invalid P2P_SERV_DISC_RESP command: needs four "
1841 "arguments (freq, address, dialog token, and TLVs)\n");
1845 res
= os_snprintf(cmd
, sizeof(cmd
), "P2P_SERV_DISC_RESP %s %s %s %s",
1846 argv
[0], argv
[1], argv
[2], argv
[3]);
1847 if (res
< 0 || (size_t) res
>= sizeof(cmd
))
1849 cmd
[sizeof(cmd
) - 1] = '\0';
1850 return wpa_ctrl_command(ctrl
, cmd
);
1854 static int wpa_cli_cmd_p2p_service_update(struct wpa_ctrl
*ctrl
, int argc
,
1857 return wpa_ctrl_command(ctrl
, "P2P_SERVICE_UPDATE");
1861 static int wpa_cli_cmd_p2p_serv_disc_external(struct wpa_ctrl
*ctrl
,
1862 int argc
, char *argv
[])
1864 return wpa_cli_cmd(ctrl
, "P2P_SERV_DISC_EXTERNAL", 1, argc
, argv
);
1868 static int wpa_cli_cmd_p2p_service_flush(struct wpa_ctrl
*ctrl
, int argc
,
1871 return wpa_ctrl_command(ctrl
, "P2P_SERVICE_FLUSH");
1875 static int wpa_cli_cmd_p2p_service_add(struct wpa_ctrl
*ctrl
, int argc
,
1881 if (argc
!= 3 && argc
!= 4) {
1882 printf("Invalid P2P_SERVICE_ADD command: needs three or four "
1888 res
= os_snprintf(cmd
, sizeof(cmd
),
1889 "P2P_SERVICE_ADD %s %s %s %s",
1890 argv
[0], argv
[1], argv
[2], argv
[3]);
1892 res
= os_snprintf(cmd
, sizeof(cmd
),
1893 "P2P_SERVICE_ADD %s %s %s",
1894 argv
[0], argv
[1], argv
[2]);
1895 if (res
< 0 || (size_t) res
>= sizeof(cmd
))
1897 cmd
[sizeof(cmd
) - 1] = '\0';
1898 return wpa_ctrl_command(ctrl
, cmd
);
1902 static int wpa_cli_cmd_p2p_service_del(struct wpa_ctrl
*ctrl
, int argc
,
1908 if (argc
!= 2 && argc
!= 3) {
1909 printf("Invalid P2P_SERVICE_DEL command: needs two or three "
1915 res
= os_snprintf(cmd
, sizeof(cmd
),
1916 "P2P_SERVICE_DEL %s %s %s",
1917 argv
[0], argv
[1], argv
[2]);
1919 res
= os_snprintf(cmd
, sizeof(cmd
),
1920 "P2P_SERVICE_DEL %s %s",
1922 if (res
< 0 || (size_t) res
>= sizeof(cmd
))
1924 cmd
[sizeof(cmd
) - 1] = '\0';
1925 return wpa_ctrl_command(ctrl
, cmd
);
1929 static int wpa_cli_cmd_p2p_reject(struct wpa_ctrl
*ctrl
,
1930 int argc
, char *argv
[])
1932 return wpa_cli_cmd(ctrl
, "P2P_REJECT", 1, argc
, argv
);
1936 static int wpa_cli_cmd_p2p_invite(struct wpa_ctrl
*ctrl
,
1937 int argc
, char *argv
[])
1939 return wpa_cli_cmd(ctrl
, "P2P_INVITE", 1, argc
, argv
);
1943 static int wpa_cli_cmd_p2p_peer(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1945 return wpa_cli_cmd(ctrl
, "P2P_PEER", 1, argc
, argv
);
1949 static char ** wpa_cli_complete_p2p_peer(const char *str
, int pos
)
1951 int arg
= get_cmd_arg_num(str
, pos
);
1956 res
= cli_txt_list_array(&p2p_peers
);
1964 static int wpa_ctrl_command_p2p_peer(struct wpa_ctrl
*ctrl
, char *cmd
,
1965 char *addr
, size_t addr_len
,
1968 char buf
[4096], *pos
;
1972 if (ctrl_conn
== NULL
)
1974 len
= sizeof(buf
) - 1;
1975 ret
= wpa_ctrl_request(ctrl
, cmd
, os_strlen(cmd
), buf
, &len
,
1978 printf("'%s' command timed out.\n", cmd
);
1980 } else if (ret
< 0) {
1981 printf("'%s' command failed.\n", cmd
);
1986 if (os_memcmp(buf
, "FAIL", 4) == 0)
1990 while (*pos
!= '\0' && *pos
!= '\n')
1993 os_strlcpy(addr
, buf
, addr_len
);
1994 if (!discovered
|| os_strstr(pos
, "[PROBE_REQ_ONLY]") == NULL
)
1995 printf("%s\n", addr
);
2000 static int wpa_cli_cmd_p2p_peers(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2002 char addr
[32], cmd
[64];
2005 discovered
= argc
> 0 && os_strcmp(argv
[0], "discovered") == 0;
2007 if (wpa_ctrl_command_p2p_peer(ctrl
, "P2P_PEER FIRST",
2008 addr
, sizeof(addr
), discovered
))
2011 os_snprintf(cmd
, sizeof(cmd
), "P2P_PEER NEXT-%s", addr
);
2012 } while (wpa_ctrl_command_p2p_peer(ctrl
, cmd
, addr
, sizeof(addr
),
2019 static int wpa_cli_cmd_p2p_set(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2021 return wpa_cli_cmd(ctrl
, "P2P_SET", 2, argc
, argv
);
2025 static int wpa_cli_cmd_p2p_flush(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2027 return wpa_ctrl_command(ctrl
, "P2P_FLUSH");
2031 static int wpa_cli_cmd_p2p_cancel(struct wpa_ctrl
*ctrl
, int argc
,
2034 return wpa_ctrl_command(ctrl
, "P2P_CANCEL");
2038 static int wpa_cli_cmd_p2p_unauthorize(struct wpa_ctrl
*ctrl
, int argc
,
2041 return wpa_cli_cmd(ctrl
, "P2P_UNAUTHORIZE", 1, argc
, argv
);
2045 static int wpa_cli_cmd_p2p_presence_req(struct wpa_ctrl
*ctrl
, int argc
,
2048 if (argc
!= 0 && argc
!= 2 && argc
!= 4) {
2049 printf("Invalid P2P_PRESENCE_REQ command: needs two arguments "
2050 "(preferred duration, interval; in microsecods).\n"
2051 "Optional second pair can be used to provide "
2052 "acceptable values.\n");
2056 return wpa_cli_cmd(ctrl
, "P2P_PRESENCE_REQ", 0, argc
, argv
);
2060 static int wpa_cli_cmd_p2p_ext_listen(struct wpa_ctrl
*ctrl
, int argc
,
2063 if (argc
!= 0 && argc
!= 2) {
2064 printf("Invalid P2P_EXT_LISTEN command: needs two arguments "
2065 "(availability period, availability interval; in "
2067 "Extended Listen Timing can be cancelled with this "
2068 "command when used without parameters.\n");
2072 return wpa_cli_cmd(ctrl
, "P2P_EXT_LISTEN", 0, argc
, argv
);
2075 #endif /* CONFIG_P2P */
2077 #ifdef CONFIG_WIFI_DISPLAY
2079 static int wpa_cli_cmd_wfd_subelem_set(struct wpa_ctrl
*ctrl
, int argc
,
2085 if (argc
!= 1 && argc
!= 2) {
2086 printf("Invalid WFD_SUBELEM_SET command: needs one or two "
2087 "arguments (subelem, hexdump)\n");
2091 res
= os_snprintf(cmd
, sizeof(cmd
), "WFD_SUBELEM_SET %s %s",
2092 argv
[0], argc
> 1 ? argv
[1] : "");
2093 if (res
< 0 || (size_t) res
>= sizeof(cmd
))
2095 cmd
[sizeof(cmd
) - 1] = '\0';
2096 return wpa_ctrl_command(ctrl
, cmd
);
2100 static int wpa_cli_cmd_wfd_subelem_get(struct wpa_ctrl
*ctrl
, int argc
,
2107 printf("Invalid WFD_SUBELEM_GET command: needs one "
2108 "argument (subelem)\n");
2112 res
= os_snprintf(cmd
, sizeof(cmd
), "WFD_SUBELEM_GET %s",
2114 if (res
< 0 || (size_t) res
>= sizeof(cmd
))
2116 cmd
[sizeof(cmd
) - 1] = '\0';
2117 return wpa_ctrl_command(ctrl
, cmd
);
2119 #endif /* CONFIG_WIFI_DISPLAY */
2122 #ifdef CONFIG_INTERWORKING
2123 static int wpa_cli_cmd_fetch_anqp(struct wpa_ctrl
*ctrl
, int argc
,
2126 return wpa_ctrl_command(ctrl
, "FETCH_ANQP");
2130 static int wpa_cli_cmd_stop_fetch_anqp(struct wpa_ctrl
*ctrl
, int argc
,
2133 return wpa_ctrl_command(ctrl
, "STOP_FETCH_ANQP");
2137 static int wpa_cli_cmd_interworking_select(struct wpa_ctrl
*ctrl
, int argc
,
2140 return wpa_cli_cmd(ctrl
, "INTERWORKING_SELECT", 0, argc
, argv
);
2144 static int wpa_cli_cmd_interworking_connect(struct wpa_ctrl
*ctrl
, int argc
,
2147 return wpa_cli_cmd(ctrl
, "INTERWORKING_CONNECT", 1, argc
, argv
);
2151 static int wpa_cli_cmd_anqp_get(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2153 return wpa_cli_cmd(ctrl
, "ANQP_GET", 2, argc
, argv
);
2157 static int wpa_cli_cmd_gas_request(struct wpa_ctrl
*ctrl
, int argc
,
2160 return wpa_cli_cmd(ctrl
, "GAS_REQUEST", 2, argc
, argv
);
2164 static int wpa_cli_cmd_gas_response_get(struct wpa_ctrl
*ctrl
, int argc
,
2167 return wpa_cli_cmd(ctrl
, "GAS_RESPONSE_GET", 2, argc
, argv
);
2169 #endif /* CONFIG_INTERWORKING */
2174 static int wpa_cli_cmd_hs20_anqp_get(struct wpa_ctrl
*ctrl
, int argc
,
2177 return wpa_cli_cmd(ctrl
, "HS20_ANQP_GET", 2, argc
, argv
);
2181 static int wpa_cli_cmd_get_nai_home_realm_list(struct wpa_ctrl
*ctrl
, int argc
,
2187 printf("Command needs one or two arguments (dst mac addr and "
2188 "optional home realm)\n");
2192 if (write_cmd(cmd
, sizeof(cmd
), "HS20_GET_NAI_HOME_REALM_LIST",
2196 return wpa_ctrl_command(ctrl
, cmd
);
2199 #endif /* CONFIG_HS20 */
2202 static int wpa_cli_cmd_sta_autoconnect(struct wpa_ctrl
*ctrl
, int argc
,
2205 return wpa_cli_cmd(ctrl
, "STA_AUTOCONNECT", 1, argc
, argv
);
2209 static int wpa_cli_cmd_tdls_discover(struct wpa_ctrl
*ctrl
, int argc
,
2212 return wpa_cli_cmd(ctrl
, "TDLS_DISCOVER", 1, argc
, argv
);
2216 static int wpa_cli_cmd_tdls_setup(struct wpa_ctrl
*ctrl
, int argc
,
2219 return wpa_cli_cmd(ctrl
, "TDLS_SETUP", 1, argc
, argv
);
2223 static int wpa_cli_cmd_tdls_teardown(struct wpa_ctrl
*ctrl
, int argc
,
2226 return wpa_cli_cmd(ctrl
, "TDLS_TEARDOWN", 1, argc
, argv
);
2230 static int wpa_cli_cmd_signal_poll(struct wpa_ctrl
*ctrl
, int argc
,
2233 return wpa_ctrl_command(ctrl
, "SIGNAL_POLL");
2237 static int wpa_cli_cmd_pktcnt_poll(struct wpa_ctrl
*ctrl
, int argc
,
2240 return wpa_ctrl_command(ctrl
, "PKTCNT_POLL");
2244 static int wpa_cli_cmd_reauthenticate(struct wpa_ctrl
*ctrl
, int argc
,
2247 return wpa_ctrl_command(ctrl
, "REAUTHENTICATE");
2251 #ifdef CONFIG_AUTOSCAN
2253 static int wpa_cli_cmd_autoscan(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2256 return wpa_ctrl_command(ctrl
, "AUTOSCAN ");
2258 return wpa_cli_cmd(ctrl
, "AUTOSCAN", 0, argc
, argv
);
2261 #endif /* CONFIG_AUTOSCAN */
2266 static int wpa_cli_cmd_wnm_sleep(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2268 return wpa_cli_cmd(ctrl
, "WNM_SLEEP", 0, argc
, argv
);
2271 #endif /* CONFIG_WNM */
2274 static int wpa_cli_cmd_raw(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2278 return wpa_cli_cmd(ctrl
, argv
[0], 0, argc
- 1, &argv
[1]);
2282 enum wpa_cli_cmd_flags
{
2283 cli_cmd_flag_none
= 0x00,
2284 cli_cmd_flag_sensitive
= 0x01
2287 struct wpa_cli_cmd
{
2289 int (*handler
)(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[]);
2290 char ** (*completion
)(const char *str
, int pos
);
2291 enum wpa_cli_cmd_flags flags
;
2295 static struct wpa_cli_cmd wpa_cli_commands
[] = {
2296 { "status", wpa_cli_cmd_status
, NULL
,
2298 "[verbose] = get current WPA/EAPOL/EAP status" },
2299 { "ifname", wpa_cli_cmd_ifname
, NULL
,
2301 "= get current interface name" },
2302 { "ping", wpa_cli_cmd_ping
, NULL
,
2304 "= pings wpa_supplicant" },
2305 { "relog", wpa_cli_cmd_relog
, NULL
,
2307 "= re-open log-file (allow rolling logs)" },
2308 { "note", wpa_cli_cmd_note
, NULL
,
2310 "<text> = add a note to wpa_supplicant debug log" },
2311 { "mib", wpa_cli_cmd_mib
, NULL
,
2313 "= get MIB variables (dot1x, dot11)" },
2314 { "help", wpa_cli_cmd_help
, wpa_cli_complete_help
,
2316 "[command] = show usage help" },
2317 { "interface", wpa_cli_cmd_interface
, NULL
,
2319 "[ifname] = show interfaces/select interface" },
2320 { "level", wpa_cli_cmd_level
, NULL
,
2322 "<debug level> = change debug level" },
2323 { "license", wpa_cli_cmd_license
, NULL
,
2325 "= show full wpa_cli license" },
2326 { "quit", wpa_cli_cmd_quit
, NULL
,
2329 { "set", wpa_cli_cmd_set
, NULL
,
2331 "= set variables (shows list of variables when run without "
2333 { "get", wpa_cli_cmd_get
, NULL
,
2335 "<name> = get information" },
2336 { "logon", wpa_cli_cmd_logon
, NULL
,
2338 "= IEEE 802.1X EAPOL state machine logon" },
2339 { "logoff", wpa_cli_cmd_logoff
, NULL
,
2341 "= IEEE 802.1X EAPOL state machine logoff" },
2342 { "pmksa", wpa_cli_cmd_pmksa
, NULL
,
2344 "= show PMKSA cache" },
2345 { "reassociate", wpa_cli_cmd_reassociate
, NULL
,
2347 "= force reassociation" },
2348 { "preauthenticate", wpa_cli_cmd_preauthenticate
, wpa_cli_complete_bss
,
2350 "<BSSID> = force preauthentication" },
2351 { "identity", wpa_cli_cmd_identity
, NULL
,
2353 "<network id> <identity> = configure identity for an SSID" },
2354 { "password", wpa_cli_cmd_password
, NULL
,
2355 cli_cmd_flag_sensitive
,
2356 "<network id> <password> = configure password for an SSID" },
2357 { "new_password", wpa_cli_cmd_new_password
, NULL
,
2358 cli_cmd_flag_sensitive
,
2359 "<network id> <password> = change password for an SSID" },
2360 { "pin", wpa_cli_cmd_pin
, NULL
,
2361 cli_cmd_flag_sensitive
,
2362 "<network id> <pin> = configure pin for an SSID" },
2363 { "otp", wpa_cli_cmd_otp
, NULL
,
2364 cli_cmd_flag_sensitive
,
2365 "<network id> <password> = configure one-time-password for an SSID"
2367 { "passphrase", wpa_cli_cmd_passphrase
, NULL
,
2368 cli_cmd_flag_sensitive
,
2369 "<network id> <passphrase> = configure private key passphrase\n"
2371 { "bssid", wpa_cli_cmd_bssid
, NULL
,
2373 "<network id> <BSSID> = set preferred BSSID for an SSID" },
2374 { "blacklist", wpa_cli_cmd_blacklist
, wpa_cli_complete_bss
,
2376 "<BSSID> = add a BSSID to the blacklist\n"
2377 "blacklist clear = clear the blacklist\n"
2378 "blacklist = display the blacklist" },
2379 { "log_level", wpa_cli_cmd_log_level
, NULL
,
2381 "<level> [<timestamp>] = update the log level/timestamp\n"
2382 "log_level = display the current log level and log options" },
2383 { "list_networks", wpa_cli_cmd_list_networks
, NULL
,
2385 "= list configured networks" },
2386 { "select_network", wpa_cli_cmd_select_network
, NULL
,
2388 "<network id> = select a network (disable others)" },
2389 { "enable_network", wpa_cli_cmd_enable_network
, NULL
,
2391 "<network id> = enable a network" },
2392 { "disable_network", wpa_cli_cmd_disable_network
, NULL
,
2394 "<network id> = disable a network" },
2395 { "add_network", wpa_cli_cmd_add_network
, NULL
,
2397 "= add a network" },
2398 { "remove_network", wpa_cli_cmd_remove_network
, NULL
,
2400 "<network id> = remove a network" },
2401 { "set_network", wpa_cli_cmd_set_network
, NULL
,
2402 cli_cmd_flag_sensitive
,
2403 "<network id> <variable> <value> = set network variables (shows\n"
2404 " list of variables when run without arguments)" },
2405 { "get_network", wpa_cli_cmd_get_network
, NULL
,
2407 "<network id> <variable> = get network variables" },
2408 { "list_creds", wpa_cli_cmd_list_creds
, NULL
,
2410 "= list configured credentials" },
2411 { "add_cred", wpa_cli_cmd_add_cred
, NULL
,
2413 "= add a credential" },
2414 { "remove_cred", wpa_cli_cmd_remove_cred
, NULL
,
2416 "<cred id> = remove a credential" },
2417 { "set_cred", wpa_cli_cmd_set_cred
, NULL
,
2418 cli_cmd_flag_sensitive
,
2419 "<cred id> <variable> <value> = set credential variables" },
2420 { "save_config", wpa_cli_cmd_save_config
, NULL
,
2422 "= save the current configuration" },
2423 { "disconnect", wpa_cli_cmd_disconnect
, NULL
,
2425 "= disconnect and wait for reassociate/reconnect command before\n"
2427 { "reconnect", wpa_cli_cmd_reconnect
, NULL
,
2429 "= like reassociate, but only takes effect if already disconnected"
2431 { "scan", wpa_cli_cmd_scan
, NULL
,
2433 "= request new BSS scan" },
2434 { "scan_results", wpa_cli_cmd_scan_results
, NULL
,
2436 "= get latest scan results" },
2437 { "bss", wpa_cli_cmd_bss
, wpa_cli_complete_bss
,
2439 "<<idx> | <bssid>> = get detailed scan result info" },
2440 { "get_capability", wpa_cli_cmd_get_capability
, NULL
,
2442 "<eap/pairwise/group/key_mgmt/proto/auth_alg/channels> "
2443 "= get capabilies" },
2444 { "reconfigure", wpa_cli_cmd_reconfigure
, NULL
,
2446 "= force wpa_supplicant to re-read its configuration file" },
2447 { "terminate", wpa_cli_cmd_terminate
, NULL
,
2449 "= terminate wpa_supplicant" },
2450 { "interface_add", wpa_cli_cmd_interface_add
, NULL
,
2452 "<ifname> <confname> <driver> <ctrl_interface> <driver_param>\n"
2453 " <bridge_name> = adds new interface, all parameters but <ifname>\n"
2455 { "interface_remove", wpa_cli_cmd_interface_remove
, NULL
,
2457 "<ifname> = removes the interface" },
2458 { "interface_list", wpa_cli_cmd_interface_list
, NULL
,
2460 "= list available interfaces" },
2461 { "ap_scan", wpa_cli_cmd_ap_scan
, NULL
,
2463 "<value> = set ap_scan parameter" },
2464 { "scan_interval", wpa_cli_cmd_scan_interval
, NULL
,
2466 "<value> = set scan_interval parameter (in seconds)" },
2467 { "bss_expire_age", wpa_cli_cmd_bss_expire_age
, NULL
,
2469 "<value> = set BSS expiration age parameter" },
2470 { "bss_expire_count", wpa_cli_cmd_bss_expire_count
, NULL
,
2472 "<value> = set BSS expiration scan count parameter" },
2473 { "bss_flush", wpa_cli_cmd_bss_flush
, NULL
,
2475 "<value> = set BSS flush age (0 by default)" },
2476 { "stkstart", wpa_cli_cmd_stkstart
, NULL
,
2478 "<addr> = request STK negotiation with <addr>" },
2479 { "ft_ds", wpa_cli_cmd_ft_ds
, wpa_cli_complete_bss
,
2481 "<addr> = request over-the-DS FT with <addr>" },
2482 { "wps_pbc", wpa_cli_cmd_wps_pbc
, wpa_cli_complete_bss
,
2484 "[BSSID] = start Wi-Fi Protected Setup: Push Button Configuration" },
2485 { "wps_pin", wpa_cli_cmd_wps_pin
, wpa_cli_complete_bss
,
2486 cli_cmd_flag_sensitive
,
2487 "<BSSID> [PIN] = start WPS PIN method (returns PIN, if not "
2489 { "wps_check_pin", wpa_cli_cmd_wps_check_pin
, NULL
,
2490 cli_cmd_flag_sensitive
,
2491 "<PIN> = verify PIN checksum" },
2492 { "wps_cancel", wpa_cli_cmd_wps_cancel
, NULL
, cli_cmd_flag_none
,
2493 "Cancels the pending WPS operation" },
2494 #ifdef CONFIG_WPS_NFC
2495 { "wps_nfc", wpa_cli_cmd_wps_nfc
, wpa_cli_complete_bss
,
2497 "[BSSID] = start Wi-Fi Protected Setup: NFC" },
2498 { "wps_nfc_config_token", wpa_cli_cmd_wps_nfc_config_token
, NULL
,
2500 "<WPS|NDEF> = build configuration token" },
2501 { "wps_nfc_token", wpa_cli_cmd_wps_nfc_token
, NULL
,
2503 "<WPS|NDEF> = create password token" },
2504 { "wps_nfc_tag_read", wpa_cli_cmd_wps_nfc_tag_read
, NULL
,
2505 cli_cmd_flag_sensitive
,
2506 "<hexdump of payload> = report read NFC tag with WPS data" },
2507 { "nfc_get_handover_req", wpa_cli_cmd_nfc_get_handover_req
, NULL
,
2509 "<NDEF> <WPS> = create NFC handover request" },
2510 { "nfc_get_handover_sel", wpa_cli_cmd_nfc_get_handover_sel
, NULL
,
2512 "<NDEF> <WPS> = create NFC handover select" },
2513 { "nfc_rx_handover_req", wpa_cli_cmd_nfc_rx_handover_req
, NULL
,
2515 "<hexdump of payload> = report received NFC handover request" },
2516 { "nfc_rx_handover_sel", wpa_cli_cmd_nfc_rx_handover_sel
, NULL
,
2518 "<hexdump of payload> = report received NFC handover select" },
2519 { "nfc_report_handover", wpa_cli_cmd_nfc_report_handover
, NULL
,
2521 "<role> <type> <hexdump of req> <hexdump of sel> = report completed "
2523 #endif /* CONFIG_WPS_NFC */
2524 { "wps_reg", wpa_cli_cmd_wps_reg
, wpa_cli_complete_bss
,
2525 cli_cmd_flag_sensitive
,
2526 "<BSSID> <AP PIN> = start WPS Registrar to configure an AP" },
2527 { "wps_ap_pin", wpa_cli_cmd_wps_ap_pin
, NULL
,
2528 cli_cmd_flag_sensitive
,
2529 "[params..] = enable/disable AP PIN" },
2530 { "wps_er_start", wpa_cli_cmd_wps_er_start
, NULL
,
2532 "[IP address] = start Wi-Fi Protected Setup External Registrar" },
2533 { "wps_er_stop", wpa_cli_cmd_wps_er_stop
, NULL
,
2535 "= stop Wi-Fi Protected Setup External Registrar" },
2536 { "wps_er_pin", wpa_cli_cmd_wps_er_pin
, NULL
,
2537 cli_cmd_flag_sensitive
,
2538 "<UUID> <PIN> = add an Enrollee PIN to External Registrar" },
2539 { "wps_er_pbc", wpa_cli_cmd_wps_er_pbc
, NULL
,
2541 "<UUID> = accept an Enrollee PBC using External Registrar" },
2542 { "wps_er_learn", wpa_cli_cmd_wps_er_learn
, NULL
,
2543 cli_cmd_flag_sensitive
,
2544 "<UUID> <PIN> = learn AP configuration" },
2545 { "wps_er_set_config", wpa_cli_cmd_wps_er_set_config
, NULL
,
2547 "<UUID> <network id> = set AP configuration for enrolling" },
2548 { "wps_er_config", wpa_cli_cmd_wps_er_config
, NULL
,
2549 cli_cmd_flag_sensitive
,
2550 "<UUID> <PIN> <SSID> <auth> <encr> <key> = configure AP" },
2551 #ifdef CONFIG_WPS_NFC
2552 { "wps_er_nfc_config_token", wpa_cli_cmd_wps_er_nfc_config_token
, NULL
,
2554 "<WPS/NDEF> <UUID> = build NFC configuration token" },
2555 #endif /* CONFIG_WPS_NFC */
2556 { "ibss_rsn", wpa_cli_cmd_ibss_rsn
, NULL
,
2558 "<addr> = request RSN authentication with <addr> in IBSS" },
2560 { "sta", wpa_cli_cmd_sta
, NULL
,
2562 "<addr> = get information about an associated station (AP)" },
2563 { "all_sta", wpa_cli_cmd_all_sta
, NULL
,
2565 "= get information about all associated stations (AP)" },
2566 { "deauthenticate", wpa_cli_cmd_deauthenticate
, NULL
,
2568 "<addr> = deauthenticate a station" },
2569 { "disassociate", wpa_cli_cmd_disassociate
, NULL
,
2571 "<addr> = disassociate a station" },
2572 #endif /* CONFIG_AP */
2573 { "suspend", wpa_cli_cmd_suspend
, NULL
, cli_cmd_flag_none
,
2574 "= notification of suspend/hibernate" },
2575 { "resume", wpa_cli_cmd_resume
, NULL
, cli_cmd_flag_none
,
2576 "= notification of resume/thaw" },
2577 { "drop_sa", wpa_cli_cmd_drop_sa
, NULL
, cli_cmd_flag_none
,
2578 "= drop SA without deauth/disassoc (test command)" },
2579 { "roam", wpa_cli_cmd_roam
, wpa_cli_complete_bss
,
2581 "<addr> = roam to the specified BSS" },
2583 { "p2p_find", wpa_cli_cmd_p2p_find
, wpa_cli_complete_p2p_find
,
2585 "[timeout] [type=*] = find P2P Devices for up-to timeout seconds" },
2586 { "p2p_stop_find", wpa_cli_cmd_p2p_stop_find
, NULL
, cli_cmd_flag_none
,
2587 "= stop P2P Devices search" },
2588 { "p2p_connect", wpa_cli_cmd_p2p_connect
, wpa_cli_complete_p2p_connect
,
2590 "<addr> <\"pbc\"|PIN> [ht40] = connect to a P2P Device" },
2591 { "p2p_listen", wpa_cli_cmd_p2p_listen
, NULL
, cli_cmd_flag_none
,
2592 "[timeout] = listen for P2P Devices for up-to timeout seconds" },
2593 { "p2p_group_remove", wpa_cli_cmd_p2p_group_remove
,
2594 wpa_cli_complete_p2p_group_remove
, cli_cmd_flag_none
,
2595 "<ifname> = remove P2P group interface (terminate group if GO)" },
2596 { "p2p_group_add", wpa_cli_cmd_p2p_group_add
, NULL
, cli_cmd_flag_none
,
2597 "[ht40] = add a new P2P group (local end as GO)" },
2598 { "p2p_prov_disc", wpa_cli_cmd_p2p_prov_disc
,
2599 wpa_cli_complete_p2p_peer
, cli_cmd_flag_none
,
2600 "<addr> <method> = request provisioning discovery" },
2601 { "p2p_get_passphrase", wpa_cli_cmd_p2p_get_passphrase
, NULL
,
2603 "= get the passphrase for a group (GO only)" },
2604 { "p2p_serv_disc_req", wpa_cli_cmd_p2p_serv_disc_req
,
2605 wpa_cli_complete_p2p_peer
, cli_cmd_flag_none
,
2606 "<addr> <TLVs> = schedule service discovery request" },
2607 { "p2p_serv_disc_cancel_req", wpa_cli_cmd_p2p_serv_disc_cancel_req
,
2608 NULL
, cli_cmd_flag_none
,
2609 "<id> = cancel pending service discovery request" },
2610 { "p2p_serv_disc_resp", wpa_cli_cmd_p2p_serv_disc_resp
, NULL
,
2612 "<freq> <addr> <dialog token> <TLVs> = service discovery response" },
2613 { "p2p_service_update", wpa_cli_cmd_p2p_service_update
, NULL
,
2615 "= indicate change in local services" },
2616 { "p2p_serv_disc_external", wpa_cli_cmd_p2p_serv_disc_external
, NULL
,
2618 "<external> = set external processing of service discovery" },
2619 { "p2p_service_flush", wpa_cli_cmd_p2p_service_flush
, NULL
,
2621 "= remove all stored service entries" },
2622 { "p2p_service_add", wpa_cli_cmd_p2p_service_add
, NULL
,
2624 "<bonjour|upnp> <query|version> <response|service> = add a local "
2626 { "p2p_service_del", wpa_cli_cmd_p2p_service_del
, NULL
,
2628 "<bonjour|upnp> <query|version> [|service] = remove a local "
2630 { "p2p_reject", wpa_cli_cmd_p2p_reject
, wpa_cli_complete_p2p_peer
,
2632 "<addr> = reject connection attempts from a specific peer" },
2633 { "p2p_invite", wpa_cli_cmd_p2p_invite
, NULL
,
2635 "<cmd> [peer=addr] = invite peer" },
2636 { "p2p_peers", wpa_cli_cmd_p2p_peers
, NULL
, cli_cmd_flag_none
,
2637 "[discovered] = list known (optionally, only fully discovered) P2P "
2639 { "p2p_peer", wpa_cli_cmd_p2p_peer
, wpa_cli_complete_p2p_peer
,
2641 "<address> = show information about known P2P peer" },
2642 { "p2p_set", wpa_cli_cmd_p2p_set
, NULL
, cli_cmd_flag_none
,
2643 "<field> <value> = set a P2P parameter" },
2644 { "p2p_flush", wpa_cli_cmd_p2p_flush
, NULL
, cli_cmd_flag_none
,
2645 "= flush P2P state" },
2646 { "p2p_cancel", wpa_cli_cmd_p2p_cancel
, NULL
, cli_cmd_flag_none
,
2647 "= cancel P2P group formation" },
2648 { "p2p_unauthorize", wpa_cli_cmd_p2p_unauthorize
,
2649 wpa_cli_complete_p2p_peer
, cli_cmd_flag_none
,
2650 "<address> = unauthorize a peer" },
2651 { "p2p_presence_req", wpa_cli_cmd_p2p_presence_req
, NULL
,
2653 "[<duration> <interval>] [<duration> <interval>] = request GO "
2655 { "p2p_ext_listen", wpa_cli_cmd_p2p_ext_listen
, NULL
,
2657 "[<period> <interval>] = set extended listen timing" },
2658 #endif /* CONFIG_P2P */
2659 #ifdef CONFIG_WIFI_DISPLAY
2660 { "wfd_subelem_set", wpa_cli_cmd_wfd_subelem_set
, NULL
,
2662 "<subelem> [contents] = set Wi-Fi Display subelement" },
2663 { "wfd_subelem_get", wpa_cli_cmd_wfd_subelem_get
, NULL
,
2665 "<subelem> = get Wi-Fi Display subelement" },
2666 #endif /* CONFIG_WIFI_DISPLAY */
2667 #ifdef CONFIG_INTERWORKING
2668 { "fetch_anqp", wpa_cli_cmd_fetch_anqp
, NULL
, cli_cmd_flag_none
,
2669 "= fetch ANQP information for all APs" },
2670 { "stop_fetch_anqp", wpa_cli_cmd_stop_fetch_anqp
, NULL
,
2672 "= stop fetch_anqp operation" },
2673 { "interworking_select", wpa_cli_cmd_interworking_select
, NULL
,
2675 "[auto] = perform Interworking network selection" },
2676 { "interworking_connect", wpa_cli_cmd_interworking_connect
,
2677 wpa_cli_complete_bss
, cli_cmd_flag_none
,
2678 "<BSSID> = connect using Interworking credentials" },
2679 { "anqp_get", wpa_cli_cmd_anqp_get
, wpa_cli_complete_bss
,
2681 "<addr> <info id>[,<info id>]... = request ANQP information" },
2682 { "gas_request", wpa_cli_cmd_gas_request
, wpa_cli_complete_bss
,
2684 "<addr> <AdvProtoID> [QueryReq] = GAS request" },
2685 { "gas_response_get", wpa_cli_cmd_gas_response_get
,
2686 wpa_cli_complete_bss
, cli_cmd_flag_none
,
2687 "<addr> <dialog token> [start,len] = Fetch last GAS response" },
2688 #endif /* CONFIG_INTERWORKING */
2690 { "hs20_anqp_get", wpa_cli_cmd_hs20_anqp_get
, wpa_cli_complete_bss
,
2692 "<addr> <subtype>[,<subtype>]... = request HS 2.0 ANQP information"
2694 { "nai_home_realm_list", wpa_cli_cmd_get_nai_home_realm_list
,
2695 wpa_cli_complete_bss
, cli_cmd_flag_none
,
2696 "<addr> <home realm> = get HS20 nai home realm list" },
2697 #endif /* CONFIG_HS20 */
2698 { "sta_autoconnect", wpa_cli_cmd_sta_autoconnect
, NULL
,
2700 "<0/1> = disable/enable automatic reconnection" },
2701 { "tdls_discover", wpa_cli_cmd_tdls_discover
, NULL
,
2703 "<addr> = request TDLS discovery with <addr>" },
2704 { "tdls_setup", wpa_cli_cmd_tdls_setup
, NULL
,
2706 "<addr> = request TDLS setup with <addr>" },
2707 { "tdls_teardown", wpa_cli_cmd_tdls_teardown
, NULL
,
2709 "<addr> = tear down TDLS with <addr>" },
2710 { "signal_poll", wpa_cli_cmd_signal_poll
, NULL
,
2712 "= get signal parameters" },
2713 { "pktcnt_poll", wpa_cli_cmd_pktcnt_poll
, NULL
,
2715 "= get TX/RX packet counters" },
2716 { "reauthenticate", wpa_cli_cmd_reauthenticate
, NULL
,
2718 "= trigger IEEE 802.1X/EAPOL reauthentication" },
2719 #ifdef CONFIG_AUTOSCAN
2720 { "autoscan", wpa_cli_cmd_autoscan
, NULL
, cli_cmd_flag_none
,
2721 "[params] = Set or unset (if none) autoscan parameters" },
2722 #endif /* CONFIG_AUTOSCAN */
2724 { "wnm_sleep", wpa_cli_cmd_wnm_sleep
, NULL
, cli_cmd_flag_none
,
2725 "<enter/exit> [interval=#] = enter/exit WNM-Sleep mode" },
2726 #endif /* CONFIG_WNM */
2727 { "raw", wpa_cli_cmd_raw
, NULL
, cli_cmd_flag_sensitive
,
2728 "<params..> = Sent unprocessed command" },
2729 { NULL
, NULL
, NULL
, cli_cmd_flag_none
, NULL
}
2734 * Prints command usage, lines are padded with the specified string.
2736 static void print_cmd_help(struct wpa_cli_cmd
*cmd
, const char *pad
)
2741 printf("%s%s ", pad
, cmd
->cmd
);
2742 for (n
= 0; (c
= cmd
->usage
[n
]); n
++) {
2751 static void print_help(const char *cmd
)
2754 printf("commands:\n");
2755 for (n
= 0; wpa_cli_commands
[n
].cmd
; n
++) {
2756 if (cmd
== NULL
|| str_starts(wpa_cli_commands
[n
].cmd
, cmd
))
2757 print_cmd_help(&wpa_cli_commands
[n
], " ");
2762 static int wpa_cli_edit_filter_history_cb(void *ctx
, const char *cmd
)
2764 const char *c
, *delim
;
2768 delim
= os_strchr(cmd
, ' ');
2772 len
= os_strlen(cmd
);
2774 for (n
= 0; (c
= wpa_cli_commands
[n
].cmd
); n
++) {
2775 if (os_strncasecmp(cmd
, c
, len
) == 0 && len
== os_strlen(c
))
2776 return (wpa_cli_commands
[n
].flags
&
2777 cli_cmd_flag_sensitive
);
2783 static char ** wpa_list_cmd_list(void)
2788 count
= sizeof(wpa_cli_commands
) / sizeof(wpa_cli_commands
[0]);
2789 res
= os_calloc(count
, sizeof(char *));
2793 for (i
= 0; wpa_cli_commands
[i
].cmd
; i
++) {
2794 res
[i
] = os_strdup(wpa_cli_commands
[i
].cmd
);
2803 static char ** wpa_cli_cmd_completion(const char *cmd
, const char *str
,
2808 for (i
= 0; wpa_cli_commands
[i
].cmd
; i
++) {
2809 if (os_strcasecmp(wpa_cli_commands
[i
].cmd
, cmd
) == 0) {
2810 if (wpa_cli_commands
[i
].completion
)
2811 return wpa_cli_commands
[i
].completion(str
,
2814 printf("\r%s\n", wpa_cli_commands
[i
].usage
);
2824 static char ** wpa_cli_edit_completion_cb(void *ctx
, const char *str
, int pos
)
2830 end
= os_strchr(str
, ' ');
2831 if (end
== NULL
|| str
+ pos
< end
)
2832 return wpa_list_cmd_list();
2834 cmd
= os_malloc(pos
+ 1);
2837 os_memcpy(cmd
, str
, pos
);
2838 cmd
[end
- str
] = '\0';
2839 res
= wpa_cli_cmd_completion(cmd
, str
, pos
);
2845 static int wpa_request(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2847 struct wpa_cli_cmd
*cmd
, *match
= NULL
;
2852 cmd
= wpa_cli_commands
;
2854 if (os_strncasecmp(cmd
->cmd
, argv
[0], os_strlen(argv
[0])) == 0)
2857 if (os_strcasecmp(cmd
->cmd
, argv
[0]) == 0) {
2858 /* we have an exact match */
2868 printf("Ambiguous command '%s'; possible commands:", argv
[0]);
2869 cmd
= wpa_cli_commands
;
2871 if (os_strncasecmp(cmd
->cmd
, argv
[0],
2872 os_strlen(argv
[0])) == 0) {
2873 printf(" %s", cmd
->cmd
);
2879 } else if (count
== 0) {
2880 printf("Unknown command '%s'\n", argv
[0]);
2883 ret
= match
->handler(ctrl
, argc
- 1, &argv
[1]);
2890 static int str_match(const char *a
, const char *b
)
2892 return os_strncmp(a
, b
, os_strlen(b
)) == 0;
2896 static int wpa_cli_exec(const char *program
, const char *arg1
,
2904 len
= os_strlen(program
) + os_strlen(arg1
) + os_strlen(arg2
) + 3;
2905 cmd
= os_malloc(len
);
2908 res
= os_snprintf(cmd
, len
, "%s %s %s", program
, arg1
, arg2
);
2909 if (res
< 0 || (size_t) res
>= len
) {
2913 cmd
[len
- 1] = '\0';
2915 if (system(cmd
) < 0)
2917 #endif /* _WIN32_WCE */
2924 static void wpa_cli_action_process(const char *msg
)
2927 char *copy
= NULL
, *id
, *pos2
;
2932 pos
= os_strchr(pos
, '>');
2939 if (str_match(pos
, WPA_EVENT_CONNECTED
)) {
2941 os_unsetenv("WPA_ID");
2942 os_unsetenv("WPA_ID_STR");
2943 os_unsetenv("WPA_CTRL_DIR");
2945 pos
= os_strstr(pos
, "[id=");
2947 copy
= os_strdup(pos
+ 4);
2951 while (*pos2
&& *pos2
!= ' ')
2955 os_setenv("WPA_ID", id
, 1);
2956 while (*pos2
&& *pos2
!= '=')
2961 while (*pos2
&& *pos2
!= ']')
2964 os_setenv("WPA_ID_STR", id
, 1);
2968 os_setenv("WPA_CTRL_DIR", ctrl_iface_dir
, 1);
2970 if (!wpa_cli_connected
|| new_id
!= wpa_cli_last_id
) {
2971 wpa_cli_connected
= 1;
2972 wpa_cli_last_id
= new_id
;
2973 wpa_cli_exec(action_file
, ctrl_ifname
, "CONNECTED");
2975 } else if (str_match(pos
, WPA_EVENT_DISCONNECTED
)) {
2976 if (wpa_cli_connected
) {
2977 wpa_cli_connected
= 0;
2978 wpa_cli_exec(action_file
, ctrl_ifname
, "DISCONNECTED");
2980 } else if (str_match(pos
, P2P_EVENT_GROUP_STARTED
)) {
2981 wpa_cli_exec(action_file
, ctrl_ifname
, pos
);
2982 } else if (str_match(pos
, P2P_EVENT_GROUP_REMOVED
)) {
2983 wpa_cli_exec(action_file
, ctrl_ifname
, pos
);
2984 } else if (str_match(pos
, P2P_EVENT_CROSS_CONNECT_ENABLE
)) {
2985 wpa_cli_exec(action_file
, ctrl_ifname
, pos
);
2986 } else if (str_match(pos
, P2P_EVENT_CROSS_CONNECT_DISABLE
)) {
2987 wpa_cli_exec(action_file
, ctrl_ifname
, pos
);
2988 } else if (str_match(pos
, P2P_EVENT_GO_NEG_FAILURE
)) {
2989 wpa_cli_exec(action_file
, ctrl_ifname
, pos
);
2990 } else if (str_match(pos
, WPS_EVENT_SUCCESS
)) {
2991 wpa_cli_exec(action_file
, ctrl_ifname
, pos
);
2992 } else if (str_match(pos
, WPS_EVENT_FAIL
)) {
2993 wpa_cli_exec(action_file
, ctrl_ifname
, pos
);
2994 } else if (str_match(pos
, AP_STA_CONNECTED
)) {
2995 wpa_cli_exec(action_file
, ctrl_ifname
, pos
);
2996 } else if (str_match(pos
, AP_STA_DISCONNECTED
)) {
2997 wpa_cli_exec(action_file
, ctrl_ifname
, pos
);
2998 } else if (str_match(pos
, WPA_EVENT_TERMINATING
)) {
2999 printf("wpa_supplicant is terminating - stop monitoring\n");
3005 #ifndef CONFIG_ANSI_C_EXTRA
3006 static void wpa_cli_action_cb(char *msg
, size_t len
)
3008 wpa_cli_action_process(msg
);
3010 #endif /* CONFIG_ANSI_C_EXTRA */
3013 static void wpa_cli_reconnect(void)
3015 wpa_cli_close_connection();
3016 if (wpa_cli_open_connection(ctrl_ifname
, 1) < 0)
3021 printf("\rConnection to wpa_supplicant re-established\n");
3027 static void cli_event(const char *str
)
3029 const char *start
, *s
;
3031 start
= os_strchr(str
, '>');
3037 if (str_starts(start
, WPA_EVENT_BSS_ADDED
)) {
3038 s
= os_strchr(start
, ' ');
3041 s
= os_strchr(s
+ 1, ' ');
3044 cli_txt_list_add(&bsses
, s
+ 1);
3048 if (str_starts(start
, WPA_EVENT_BSS_REMOVED
)) {
3049 s
= os_strchr(start
, ' ');
3052 s
= os_strchr(s
+ 1, ' ');
3055 cli_txt_list_del_addr(&bsses
, s
+ 1);
3060 if (str_starts(start
, P2P_EVENT_DEVICE_FOUND
)) {
3061 s
= os_strstr(start
, " p2p_dev_addr=");
3064 cli_txt_list_add_addr(&p2p_peers
, s
+ 14);
3068 if (str_starts(start
, P2P_EVENT_DEVICE_LOST
)) {
3069 s
= os_strstr(start
, " p2p_dev_addr=");
3072 cli_txt_list_del_addr(&p2p_peers
, s
+ 14);
3076 if (str_starts(start
, P2P_EVENT_GROUP_STARTED
)) {
3077 s
= os_strchr(start
, ' ');
3080 cli_txt_list_add_word(&p2p_groups
, s
+ 1);
3084 if (str_starts(start
, P2P_EVENT_GROUP_REMOVED
)) {
3085 s
= os_strchr(start
, ' ');
3088 cli_txt_list_del_word(&p2p_groups
, s
+ 1);
3091 #endif /* CONFIG_P2P */
3095 static int check_terminating(const char *msg
)
3097 const char *pos
= msg
;
3101 pos
= os_strchr(pos
, '>');
3108 if (str_match(pos
, WPA_EVENT_TERMINATING
) && ctrl_conn
) {
3110 printf("\rConnection to wpa_supplicant lost - trying to "
3113 wpa_cli_attached
= 0;
3114 wpa_cli_close_connection();
3122 static void wpa_cli_recv_pending(struct wpa_ctrl
*ctrl
, int action_monitor
)
3124 if (ctrl_conn
== NULL
) {
3125 wpa_cli_reconnect();
3128 while (wpa_ctrl_pending(ctrl
) > 0) {
3130 size_t len
= sizeof(buf
) - 1;
3131 if (wpa_ctrl_recv(ctrl
, buf
, &len
) == 0) {
3134 wpa_cli_action_process(buf
);
3137 if (wpa_cli_show_event(buf
)) {
3139 printf("\r%s\n", buf
);
3143 if (interactive
&& check_terminating(buf
) > 0)
3147 printf("Could not read pending message.\n");
3152 if (wpa_ctrl_pending(ctrl
) < 0) {
3153 printf("Connection to wpa_supplicant lost - trying to "
3155 wpa_cli_reconnect();
3161 static int tokenize_cmd(char *cmd
, char *argv
[])
3174 if (argc
== max_args
)
3177 char *pos2
= os_strrchr(pos
, '"');
3181 while (*pos
!= '\0' && *pos
!= ' ')
3191 static void wpa_cli_ping(void *eloop_ctx
, void *timeout_ctx
)
3193 if (ctrl_conn
&& _wpa_ctrl_command(ctrl_conn
, "PING", 0)) {
3194 printf("Connection to wpa_supplicant lost - trying to "
3196 wpa_cli_close_connection();
3199 wpa_cli_reconnect();
3200 eloop_register_timeout(ping_interval
, 0, wpa_cli_ping
, NULL
, NULL
);
3204 static void wpa_cli_mon_receive(int sock
, void *eloop_ctx
, void *sock_ctx
)
3206 wpa_cli_recv_pending(mon_conn
, 0);
3210 static void wpa_cli_edit_cmd_cb(void *ctx
, char *cmd
)
3212 char *argv
[max_args
];
3214 argc
= tokenize_cmd(cmd
, argv
);
3216 wpa_request(ctrl_conn
, argc
, argv
);
3220 static void wpa_cli_edit_eof_cb(void *ctx
)
3226 static int warning_displayed
= 0;
3227 static char *hfile
= NULL
;
3228 static int edit_started
= 0;
3230 static void start_edit(void)
3235 #ifdef CONFIG_CTRL_IFACE_UDP_REMOTE
3236 ps
= wpa_ctrl_get_remote_ifname(ctrl_conn
);
3237 #endif /* CONFIG_CTRL_IFACE_UDP_REMOTE */
3239 home
= getenv("HOME");
3241 const char *fname
= ".wpa_cli_history";
3242 int hfile_len
= os_strlen(home
) + 1 + os_strlen(fname
) + 1;
3243 hfile
= os_malloc(hfile_len
);
3245 os_snprintf(hfile
, hfile_len
, "%s/%s", home
, fname
);
3248 if (edit_init(wpa_cli_edit_cmd_cb
, wpa_cli_edit_eof_cb
,
3249 wpa_cli_edit_completion_cb
, NULL
, hfile
, ps
) < 0) {
3255 eloop_register_timeout(ping_interval
, 0, wpa_cli_ping
, NULL
, NULL
);
3259 static void try_connection(void *eloop_ctx
, void *timeout_ctx
)
3261 if (ctrl_ifname
== NULL
)
3262 ctrl_ifname
= wpa_cli_get_default_ifname();
3264 if (!wpa_cli_open_connection(ctrl_ifname
, 1) == 0) {
3265 if (!warning_displayed
) {
3266 printf("Could not connect to wpa_supplicant: "
3267 "%s - re-trying\n", ctrl_ifname
);
3268 warning_displayed
= 1;
3270 eloop_register_timeout(1, 0, try_connection
, NULL
, NULL
);
3274 if (warning_displayed
)
3275 printf("Connection established.\n");
3281 static void wpa_cli_interactive(void)
3283 printf("\nInteractive mode\n\n");
3285 eloop_register_timeout(0, 0, try_connection
, NULL
, NULL
);
3287 eloop_cancel_timeout(try_connection
, NULL
, NULL
);
3289 cli_txt_list_flush(&p2p_peers
);
3290 cli_txt_list_flush(&p2p_groups
);
3291 cli_txt_list_flush(&bsses
);
3293 edit_deinit(hfile
, wpa_cli_edit_filter_history_cb
);
3295 eloop_cancel_timeout(wpa_cli_ping
, NULL
, NULL
);
3296 wpa_cli_close_connection();
3300 static void wpa_cli_action(struct wpa_ctrl
*ctrl
)
3302 #ifdef CONFIG_ANSI_C_EXTRA
3303 /* TODO: ANSI C version(?) */
3304 printf("Action processing not supported in ANSI C build.\n");
3305 #else /* CONFIG_ANSI_C_EXTRA */
3309 char buf
[256]; /* note: large enough to fit in unsolicited messages */
3312 fd
= wpa_ctrl_get_fd(ctrl
);
3314 while (!wpa_cli_quit
) {
3317 tv
.tv_sec
= ping_interval
;
3319 res
= select(fd
+ 1, &rfds
, NULL
, NULL
, &tv
);
3320 if (res
< 0 && errno
!= EINTR
) {
3325 if (FD_ISSET(fd
, &rfds
))
3326 wpa_cli_recv_pending(ctrl
, 1);
3328 /* verify that connection is still working */
3329 len
= sizeof(buf
) - 1;
3330 if (wpa_ctrl_request(ctrl
, "PING", 4, buf
, &len
,
3331 wpa_cli_action_cb
) < 0 ||
3332 len
< 4 || os_memcmp(buf
, "PONG", 4) != 0) {
3333 printf("wpa_supplicant did not reply to PING "
3334 "command - exiting\n");
3339 #endif /* CONFIG_ANSI_C_EXTRA */
3343 static void wpa_cli_cleanup(void)
3345 wpa_cli_close_connection();
3347 os_daemonize_terminate(pid_file
);
3349 os_program_deinit();
3353 static void wpa_cli_terminate(int sig
, void *ctx
)
3359 static char * wpa_cli_get_default_ifname(void)
3361 char *ifname
= NULL
;
3363 #ifdef CONFIG_CTRL_IFACE_UNIX
3364 struct dirent
*dent
;
3365 DIR *dir
= opendir(ctrl_iface_dir
);
3368 char ifprop
[PROPERTY_VALUE_MAX
];
3369 if (property_get("wifi.interface", ifprop
, NULL
) != 0) {
3370 ifname
= os_strdup(ifprop
);
3371 printf("Using interface '%s'\n", ifname
);
3374 #endif /* ANDROID */
3377 while ((dent
= readdir(dir
))) {
3378 #ifdef _DIRENT_HAVE_D_TYPE
3380 * Skip the file if it is not a socket. Also accept
3381 * DT_UNKNOWN (0) in case the C library or underlying
3382 * file system does not support d_type.
3384 if (dent
->d_type
!= DT_SOCK
&& dent
->d_type
!= DT_UNKNOWN
)
3386 #endif /* _DIRENT_HAVE_D_TYPE */
3387 if (os_strcmp(dent
->d_name
, ".") == 0 ||
3388 os_strcmp(dent
->d_name
, "..") == 0)
3390 printf("Selected interface '%s'\n", dent
->d_name
);
3391 ifname
= os_strdup(dent
->d_name
);
3395 #endif /* CONFIG_CTRL_IFACE_UNIX */
3397 #ifdef CONFIG_CTRL_IFACE_NAMED_PIPE
3398 char buf
[2048], *pos
;
3400 struct wpa_ctrl
*ctrl
;
3403 ctrl
= wpa_ctrl_open(NULL
);
3407 len
= sizeof(buf
) - 1;
3408 ret
= wpa_ctrl_request(ctrl
, "INTERFACES", 10, buf
, &len
, NULL
);
3411 pos
= os_strchr(buf
, '\n');
3414 ifname
= os_strdup(buf
);
3416 wpa_ctrl_close(ctrl
);
3417 #endif /* CONFIG_CTRL_IFACE_NAMED_PIPE */
3423 int main(int argc
, char *argv
[])
3428 const char *global
= NULL
;
3430 if (os_program_init())
3434 c
= getopt(argc
, argv
, "a:Bg:G:hi:p:P:v");
3439 action_file
= optarg
;
3448 ping_interval
= atoi(optarg
);
3454 printf("%s\n", wpa_cli_version
);
3457 os_free(ctrl_ifname
);
3458 ctrl_ifname
= os_strdup(optarg
);
3461 ctrl_iface_dir
= optarg
;
3472 interactive
= (argc
== optind
) && (action_file
== NULL
);
3475 printf("%s\n\n%s\n\n", wpa_cli_version
, wpa_cli_license
);
3481 #ifdef CONFIG_CTRL_IFACE_NAMED_PIPE
3482 ctrl_conn
= wpa_ctrl_open(NULL
);
3483 #else /* CONFIG_CTRL_IFACE_NAMED_PIPE */
3484 ctrl_conn
= wpa_ctrl_open(global
);
3485 #endif /* CONFIG_CTRL_IFACE_NAMED_PIPE */
3486 if (ctrl_conn
== NULL
) {
3487 fprintf(stderr
, "Failed to connect to wpa_supplicant "
3488 "global interface: %s error: %s\n",
3489 global
, strerror(errno
));
3494 eloop_register_signal_terminate(wpa_cli_terminate
, NULL
);
3496 if (ctrl_ifname
== NULL
)
3497 ctrl_ifname
= wpa_cli_get_default_ifname();
3500 wpa_cli_interactive();
3503 wpa_cli_open_connection(ctrl_ifname
, 0) < 0) {
3504 fprintf(stderr
, "Failed to connect to non-global "
3505 "ctrl_ifname: %s error: %s\n",
3506 ctrl_ifname
, strerror(errno
));
3511 if (wpa_ctrl_attach(ctrl_conn
) == 0) {
3512 wpa_cli_attached
= 1;
3514 printf("Warning: Failed to attach to "
3515 "wpa_supplicant.\n");
3520 if (daemonize
&& os_daemonize(pid_file
))
3524 wpa_cli_action(ctrl_conn
);
3526 ret
= wpa_request(ctrl_conn
, argc
- optind
,
3530 os_free(ctrl_ifname
);
3537 #else /* CONFIG_CTRL_IFACE */
3538 int main(int argc
, char *argv
[])
3540 printf("CONFIG_CTRL_IFACE not defined - wpa_cli disabled\n");
3543 #endif /* CONFIG_CTRL_IFACE */