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
= dup_binstr(txt
, end
- txt
);
179 cli_txt_list_del(txt_list
, buf
);
182 #endif /* CONFIG_P2P */
185 static int cli_txt_list_add(struct dl_list
*txt_list
, const char *txt
)
187 struct cli_txt_entry
*e
;
188 e
= cli_txt_list_get(txt_list
, txt
);
191 e
= os_zalloc(sizeof(*e
));
194 e
->txt
= os_strdup(txt
);
195 if (e
->txt
== NULL
) {
199 dl_list_add(txt_list
, &e
->list
);
205 static int cli_txt_list_add_addr(struct dl_list
*txt_list
, const char *txt
)
209 if (hwaddr_aton(txt
, addr
) < 0)
211 os_snprintf(buf
, sizeof(buf
), MACSTR
, MAC2STR(addr
));
212 return cli_txt_list_add(txt_list
, buf
);
216 static int cli_txt_list_add_word(struct dl_list
*txt_list
, const char *txt
)
221 end
= os_strchr(txt
, ' ');
223 end
= txt
+ os_strlen(txt
);
224 buf
= dup_binstr(txt
, end
- txt
);
227 ret
= cli_txt_list_add(txt_list
, buf
);
231 #endif /* CONFIG_P2P */
234 static char ** cli_txt_list_array(struct dl_list
*txt_list
)
236 unsigned int i
, count
= dl_list_len(txt_list
);
238 struct cli_txt_entry
*e
;
240 res
= os_calloc(count
+ 1, sizeof(char *));
245 dl_list_for_each(e
, txt_list
, struct cli_txt_entry
, list
) {
246 res
[i
] = os_strdup(e
->txt
);
256 static int get_cmd_arg_num(const char *str
, int pos
)
260 for (i
= 0; i
<= pos
; i
++) {
263 while (i
<= pos
&& str
[i
] != ' ')
274 static int str_starts(const char *src
, const char *match
)
276 return os_strncmp(src
, match
, os_strlen(match
)) == 0;
280 static int wpa_cli_show_event(const char *event
)
284 start
= os_strchr(event
, '>');
290 * Skip BSS added/removed events since they can be relatively frequent
291 * and are likely of not much use for an interactive user.
293 if (str_starts(start
, WPA_EVENT_BSS_ADDED
) ||
294 str_starts(start
, WPA_EVENT_BSS_REMOVED
))
301 static int wpa_cli_open_connection(const char *ifname
, int attach
)
303 #if defined(CONFIG_CTRL_IFACE_UDP) || defined(CONFIG_CTRL_IFACE_NAMED_PIPE)
304 ctrl_conn
= wpa_ctrl_open(ifname
);
305 if (ctrl_conn
== NULL
)
308 if (attach
&& interactive
)
309 mon_conn
= wpa_ctrl_open(ifname
);
312 #else /* CONFIG_CTRL_IFACE_UDP || CONFIG_CTRL_IFACE_NAMED_PIPE */
320 if (access(ctrl_iface_dir
, F_OK
) < 0) {
321 cfile
= os_strdup(ifname
);
328 flen
= os_strlen(ctrl_iface_dir
) + os_strlen(ifname
) + 2;
329 cfile
= os_malloc(flen
);
332 res
= os_snprintf(cfile
, flen
, "%s/%s", ctrl_iface_dir
,
334 if (res
< 0 || res
>= flen
) {
340 ctrl_conn
= wpa_ctrl_open(cfile
);
341 if (ctrl_conn
== NULL
) {
346 if (attach
&& interactive
)
347 mon_conn
= wpa_ctrl_open(cfile
);
351 #endif /* CONFIG_CTRL_IFACE_UDP || CONFIG_CTRL_IFACE_NAMED_PIPE */
354 if (wpa_ctrl_attach(mon_conn
) == 0) {
355 wpa_cli_attached
= 1;
357 eloop_register_read_sock(
358 wpa_ctrl_get_fd(mon_conn
),
359 wpa_cli_mon_receive
, NULL
, NULL
);
361 printf("Warning: Failed to attach to "
362 "wpa_supplicant.\n");
363 wpa_cli_close_connection();
372 static void wpa_cli_close_connection(void)
374 if (ctrl_conn
== NULL
)
377 if (wpa_cli_attached
) {
378 wpa_ctrl_detach(interactive
? mon_conn
: ctrl_conn
);
379 wpa_cli_attached
= 0;
381 wpa_ctrl_close(ctrl_conn
);
384 eloop_unregister_read_sock(wpa_ctrl_get_fd(mon_conn
));
385 wpa_ctrl_close(mon_conn
);
391 static void wpa_cli_msg_cb(char *msg
, size_t len
)
397 static int _wpa_ctrl_command(struct wpa_ctrl
*ctrl
, char *cmd
, int print
)
403 if (ctrl_conn
== NULL
) {
404 printf("Not connected to wpa_supplicant - command dropped.\n");
407 len
= sizeof(buf
) - 1;
408 ret
= wpa_ctrl_request(ctrl
, cmd
, os_strlen(cmd
), buf
, &len
,
411 printf("'%s' command timed out.\n", cmd
);
413 } else if (ret
< 0) {
414 printf("'%s' command failed.\n", cmd
);
420 if (interactive
&& len
> 0 && buf
[len
- 1] != '\n')
427 static int wpa_ctrl_command(struct wpa_ctrl
*ctrl
, char *cmd
)
429 return _wpa_ctrl_command(ctrl
, cmd
, 1);
433 static int write_cmd(char *buf
, size_t buflen
, const char *cmd
, int argc
,
442 res
= os_snprintf(pos
, end
- pos
, "%s", cmd
);
443 if (res
< 0 || res
>= end
- pos
)
447 for (i
= 0; i
< argc
; i
++) {
448 res
= os_snprintf(pos
, end
- pos
, " %s", argv
[i
]);
449 if (res
< 0 || res
>= end
- pos
)
454 buf
[buflen
- 1] = '\0';
458 printf("Too long command\n");
463 static int wpa_cli_cmd(struct wpa_ctrl
*ctrl
, const char *cmd
, int min_args
,
464 int argc
, char *argv
[])
467 if (argc
< min_args
) {
468 printf("Invalid %s command - at least %d argument%s "
469 "required.\n", cmd
, min_args
,
470 min_args
> 1 ? "s are" : " is");
473 if (write_cmd(buf
, sizeof(buf
), cmd
, argc
, argv
) < 0)
475 return wpa_ctrl_command(ctrl
, buf
);
479 static int wpa_cli_cmd_ifname(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
481 return wpa_ctrl_command(ctrl
, "IFNAME");
485 static int wpa_cli_cmd_status(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
487 if (argc
> 0 && os_strcmp(argv
[0], "verbose") == 0)
488 return wpa_ctrl_command(ctrl
, "STATUS-VERBOSE");
489 if (argc
> 0 && os_strcmp(argv
[0], "wps") == 0)
490 return wpa_ctrl_command(ctrl
, "STATUS-WPS");
491 return wpa_ctrl_command(ctrl
, "STATUS");
495 static int wpa_cli_cmd_ping(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
497 return wpa_ctrl_command(ctrl
, "PING");
501 static int wpa_cli_cmd_relog(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
503 return wpa_ctrl_command(ctrl
, "RELOG");
507 static int wpa_cli_cmd_note(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
509 return wpa_cli_cmd(ctrl
, "NOTE", 1, argc
, argv
);
513 static int wpa_cli_cmd_mib(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
515 return wpa_ctrl_command(ctrl
, "MIB");
519 static int wpa_cli_cmd_pmksa(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
521 return wpa_ctrl_command(ctrl
, "PMKSA");
525 static int wpa_cli_cmd_help(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
527 print_help(argc
> 0 ? argv
[0] : NULL
);
532 static char ** wpa_cli_complete_help(const char *str
, int pos
)
534 int arg
= get_cmd_arg_num(str
, pos
);
539 res
= wpa_list_cmd_list();
547 static int wpa_cli_cmd_license(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
549 printf("%s\n\n%s\n", wpa_cli_version
, wpa_cli_full_license
);
554 static int wpa_cli_cmd_quit(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
563 static void wpa_cli_show_variables(void)
565 printf("set variables:\n"
566 " EAPOL::heldPeriod (EAPOL state machine held period, "
568 " EAPOL::authPeriod (EAPOL state machine authentication "
569 "period, in seconds)\n"
570 " EAPOL::startPeriod (EAPOL state machine start period, in "
572 " EAPOL::maxStart (EAPOL state machine maximum start "
574 printf(" dot11RSNAConfigPMKLifetime (WPA/WPA2 PMK lifetime in "
576 " dot11RSNAConfigPMKReauthThreshold (WPA/WPA2 reauthentication"
577 " threshold\n\tpercentage)\n"
578 " dot11RSNAConfigSATimeout (WPA/WPA2 timeout for completing "
579 "security\n\tassociation in seconds)\n");
583 static int wpa_cli_cmd_set(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
589 wpa_cli_show_variables();
593 if (argc
!= 1 && argc
!= 2) {
594 printf("Invalid SET command: needs two arguments (variable "
595 "name and value)\n");
600 res
= os_snprintf(cmd
, sizeof(cmd
), "SET %s ", argv
[0]);
602 res
= os_snprintf(cmd
, sizeof(cmd
), "SET %s %s",
604 if (res
< 0 || (size_t) res
>= sizeof(cmd
) - 1) {
605 printf("Too long SET command.\n");
608 return wpa_ctrl_command(ctrl
, cmd
);
612 static int wpa_cli_cmd_get(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
614 return wpa_cli_cmd(ctrl
, "GET", 1, argc
, argv
);
618 static int wpa_cli_cmd_logoff(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
620 return wpa_ctrl_command(ctrl
, "LOGOFF");
624 static int wpa_cli_cmd_logon(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
626 return wpa_ctrl_command(ctrl
, "LOGON");
630 static int wpa_cli_cmd_reassociate(struct wpa_ctrl
*ctrl
, int argc
,
633 return wpa_ctrl_command(ctrl
, "REASSOCIATE");
637 static int wpa_cli_cmd_preauthenticate(struct wpa_ctrl
*ctrl
, int argc
,
640 return wpa_cli_cmd(ctrl
, "PREAUTH", 1, argc
, argv
);
644 static int wpa_cli_cmd_ap_scan(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
646 return wpa_cli_cmd(ctrl
, "AP_SCAN", 1, argc
, argv
);
650 static int wpa_cli_cmd_scan_interval(struct wpa_ctrl
*ctrl
, int argc
,
653 return wpa_cli_cmd(ctrl
, "SCAN_INTERVAL", 1, argc
, argv
);
657 static int wpa_cli_cmd_bss_expire_age(struct wpa_ctrl
*ctrl
, int argc
,
660 return wpa_cli_cmd(ctrl
, "BSS_EXPIRE_AGE", 1, argc
, argv
);
664 static int wpa_cli_cmd_bss_expire_count(struct wpa_ctrl
*ctrl
, int argc
,
667 return wpa_cli_cmd(ctrl
, "BSS_EXPIRE_COUNT", 1, argc
, argv
);
671 static int wpa_cli_cmd_bss_flush(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
677 res
= os_snprintf(cmd
, sizeof(cmd
), "BSS_FLUSH 0");
679 res
= os_snprintf(cmd
, sizeof(cmd
), "BSS_FLUSH %s", argv
[0]);
680 if (res
< 0 || (size_t) res
>= sizeof(cmd
) - 1) {
681 printf("Too long BSS_FLUSH command.\n");
684 return wpa_ctrl_command(ctrl
, cmd
);
688 static int wpa_cli_cmd_stkstart(struct wpa_ctrl
*ctrl
, int argc
,
691 return wpa_cli_cmd(ctrl
, "STKSTART", 1, argc
, argv
);
695 static int wpa_cli_cmd_ft_ds(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
697 return wpa_cli_cmd(ctrl
, "FT_DS", 1, argc
, argv
);
701 static int wpa_cli_cmd_wps_pbc(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
703 return wpa_cli_cmd(ctrl
, "WPS_PBC", 0, argc
, argv
);
707 static int wpa_cli_cmd_wps_pin(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
710 printf("Invalid WPS_PIN command: need one or two arguments:\n"
711 "- BSSID: use 'any' to select any\n"
712 "- PIN: optional, used only with devices that have no "
717 return wpa_cli_cmd(ctrl
, "WPS_PIN", 1, argc
, argv
);
721 static int wpa_cli_cmd_wps_check_pin(struct wpa_ctrl
*ctrl
, int argc
,
724 return wpa_cli_cmd(ctrl
, "WPS_CHECK_PIN", 1, argc
, argv
);
728 static int wpa_cli_cmd_wps_cancel(struct wpa_ctrl
*ctrl
, int argc
,
731 return wpa_ctrl_command(ctrl
, "WPS_CANCEL");
735 #ifdef CONFIG_WPS_NFC
737 static int wpa_cli_cmd_wps_nfc(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
739 return wpa_cli_cmd(ctrl
, "WPS_NFC", 0, argc
, argv
);
743 static int wpa_cli_cmd_wps_nfc_config_token(struct wpa_ctrl
*ctrl
, int argc
,
746 return wpa_cli_cmd(ctrl
, "WPS_NFC_CONFIG_TOKEN", 1, argc
, argv
);
750 static int wpa_cli_cmd_wps_nfc_token(struct wpa_ctrl
*ctrl
, int argc
,
753 return wpa_cli_cmd(ctrl
, "WPS_NFC_TOKEN", 1, argc
, argv
);
757 static int wpa_cli_cmd_wps_nfc_tag_read(struct wpa_ctrl
*ctrl
, int argc
,
765 printf("Invalid 'wps_nfc_tag_read' command - one argument "
770 buflen
= 18 + os_strlen(argv
[0]);
771 buf
= os_malloc(buflen
);
774 os_snprintf(buf
, buflen
, "WPS_NFC_TAG_READ %s", argv
[0]);
776 ret
= wpa_ctrl_command(ctrl
, buf
);
783 static int wpa_cli_cmd_nfc_get_handover_req(struct wpa_ctrl
*ctrl
, int argc
,
786 return wpa_cli_cmd(ctrl
, "NFC_GET_HANDOVER_REQ", 2, argc
, argv
);
790 static int wpa_cli_cmd_nfc_get_handover_sel(struct wpa_ctrl
*ctrl
, int argc
,
793 return wpa_cli_cmd(ctrl
, "NFC_GET_HANDOVER_SEL", 2, argc
, argv
);
797 static int wpa_cli_cmd_nfc_rx_handover_req(struct wpa_ctrl
*ctrl
, int argc
,
805 printf("Invalid 'nfc_rx_handover_req' command - one argument "
810 buflen
= 21 + os_strlen(argv
[0]);
811 buf
= os_malloc(buflen
);
814 os_snprintf(buf
, buflen
, "NFC_RX_HANDOVER_REQ %s", argv
[0]);
816 ret
= wpa_ctrl_command(ctrl
, buf
);
823 static int wpa_cli_cmd_nfc_rx_handover_sel(struct wpa_ctrl
*ctrl
, int argc
,
831 printf("Invalid 'nfc_rx_handover_sel' command - one argument "
836 buflen
= 21 + os_strlen(argv
[0]);
837 buf
= os_malloc(buflen
);
840 os_snprintf(buf
, buflen
, "NFC_RX_HANDOVER_SEL %s", argv
[0]);
842 ret
= wpa_ctrl_command(ctrl
, buf
);
849 static int wpa_cli_cmd_nfc_report_handover(struct wpa_ctrl
*ctrl
, int argc
,
852 return wpa_cli_cmd(ctrl
, "NFC_REPORT_HANDOVER", 4, argc
, argv
);
855 #endif /* CONFIG_WPS_NFC */
858 static int wpa_cli_cmd_wps_reg(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
864 res
= os_snprintf(cmd
, sizeof(cmd
), "WPS_REG %s %s",
866 else if (argc
== 5 || argc
== 6) {
867 char ssid_hex
[2 * 32 + 1];
868 char key_hex
[2 * 64 + 1];
872 for (i
= 0; i
< 32; i
++) {
873 if (argv
[2][i
] == '\0')
875 os_snprintf(&ssid_hex
[i
* 2], 3, "%02x", argv
[2][i
]);
880 for (i
= 0; i
< 64; i
++) {
881 if (argv
[5][i
] == '\0')
883 os_snprintf(&key_hex
[i
* 2], 3, "%02x",
888 res
= os_snprintf(cmd
, sizeof(cmd
),
889 "WPS_REG %s %s %s %s %s %s",
890 argv
[0], argv
[1], ssid_hex
, argv
[3], argv
[4],
893 printf("Invalid WPS_REG command: need two arguments:\n"
894 "- BSSID of the target AP\n"
896 printf("Alternatively, six arguments can be used to "
897 "reconfigure the AP:\n"
898 "- BSSID of the target AP\n"
901 "- new auth (OPEN, WPAPSK, WPA2PSK)\n"
902 "- new encr (NONE, WEP, TKIP, CCMP)\n"
907 if (res
< 0 || (size_t) res
>= sizeof(cmd
) - 1) {
908 printf("Too long WPS_REG command.\n");
911 return wpa_ctrl_command(ctrl
, cmd
);
915 static int wpa_cli_cmd_wps_ap_pin(struct wpa_ctrl
*ctrl
, int argc
,
918 return wpa_cli_cmd(ctrl
, "WPS_AP_PIN", 1, argc
, argv
);
922 static int wpa_cli_cmd_wps_er_start(struct wpa_ctrl
*ctrl
, int argc
,
925 return wpa_cli_cmd(ctrl
, "WPS_ER_START", 0, argc
, argv
);
929 static int wpa_cli_cmd_wps_er_stop(struct wpa_ctrl
*ctrl
, int argc
,
932 return wpa_ctrl_command(ctrl
, "WPS_ER_STOP");
937 static int wpa_cli_cmd_wps_er_pin(struct wpa_ctrl
*ctrl
, int argc
,
941 printf("Invalid WPS_ER_PIN command: need at least two "
943 "- UUID: use 'any' to select any\n"
944 "- PIN: Enrollee PIN\n"
945 "optional: - Enrollee MAC address\n");
949 return wpa_cli_cmd(ctrl
, "WPS_ER_PIN", 2, argc
, argv
);
953 static int wpa_cli_cmd_wps_er_pbc(struct wpa_ctrl
*ctrl
, int argc
,
956 return wpa_cli_cmd(ctrl
, "WPS_ER_PBC", 1, argc
, argv
);
960 static int wpa_cli_cmd_wps_er_learn(struct wpa_ctrl
*ctrl
, int argc
,
964 printf("Invalid WPS_ER_LEARN command: need two arguments:\n"
965 "- UUID: specify which AP to use\n"
970 return wpa_cli_cmd(ctrl
, "WPS_ER_LEARN", 2, argc
, argv
);
974 static int wpa_cli_cmd_wps_er_set_config(struct wpa_ctrl
*ctrl
, int argc
,
978 printf("Invalid WPS_ER_SET_CONFIG command: need two "
980 "- UUID: specify which AP to use\n"
981 "- Network configuration id\n");
985 return wpa_cli_cmd(ctrl
, "WPS_ER_SET_CONFIG", 2, argc
, argv
);
989 static int wpa_cli_cmd_wps_er_config(struct wpa_ctrl
*ctrl
, int argc
,
995 if (argc
== 5 || argc
== 6) {
996 char ssid_hex
[2 * 32 + 1];
997 char key_hex
[2 * 64 + 1];
1001 for (i
= 0; i
< 32; i
++) {
1002 if (argv
[2][i
] == '\0')
1004 os_snprintf(&ssid_hex
[i
* 2], 3, "%02x", argv
[2][i
]);
1009 for (i
= 0; i
< 64; i
++) {
1010 if (argv
[5][i
] == '\0')
1012 os_snprintf(&key_hex
[i
* 2], 3, "%02x",
1017 res
= os_snprintf(cmd
, sizeof(cmd
),
1018 "WPS_ER_CONFIG %s %s %s %s %s %s",
1019 argv
[0], argv
[1], ssid_hex
, argv
[3], argv
[4],
1022 printf("Invalid WPS_ER_CONFIG command: need six arguments:\n"
1026 "- new auth (OPEN, WPAPSK, WPA2PSK)\n"
1027 "- new encr (NONE, WEP, TKIP, CCMP)\n"
1032 if (res
< 0 || (size_t) res
>= sizeof(cmd
) - 1) {
1033 printf("Too long WPS_ER_CONFIG command.\n");
1036 return wpa_ctrl_command(ctrl
, cmd
);
1040 #ifdef CONFIG_WPS_NFC
1041 static int wpa_cli_cmd_wps_er_nfc_config_token(struct wpa_ctrl
*ctrl
, int argc
,
1045 printf("Invalid WPS_ER_NFC_CONFIG_TOKEN command: need two "
1047 "- WPS/NDEF: token format\n"
1048 "- UUID: specify which AP to use\n");
1052 return wpa_cli_cmd(ctrl
, "WPS_ER_NFC_CONFIG_TOKEN", 2, argc
, argv
);
1054 #endif /* CONFIG_WPS_NFC */
1057 static int wpa_cli_cmd_ibss_rsn(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1059 return wpa_cli_cmd(ctrl
, "IBSS_RSN", 1, argc
, argv
);
1063 static int wpa_cli_cmd_level(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1065 return wpa_cli_cmd(ctrl
, "LEVEL", 1, argc
, argv
);
1069 static int wpa_cli_cmd_identity(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1071 char cmd
[256], *pos
, *end
;
1075 printf("Invalid IDENTITY command: needs two arguments "
1076 "(network id and identity)\n");
1080 end
= cmd
+ sizeof(cmd
);
1082 ret
= os_snprintf(pos
, end
- pos
, WPA_CTRL_RSP
"IDENTITY-%s:%s",
1084 if (ret
< 0 || ret
>= end
- pos
) {
1085 printf("Too long IDENTITY command.\n");
1089 for (i
= 2; i
< argc
; i
++) {
1090 ret
= os_snprintf(pos
, end
- pos
, " %s", argv
[i
]);
1091 if (ret
< 0 || ret
>= end
- pos
) {
1092 printf("Too long IDENTITY command.\n");
1098 return wpa_ctrl_command(ctrl
, cmd
);
1102 static int wpa_cli_cmd_password(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1104 char cmd
[256], *pos
, *end
;
1108 printf("Invalid PASSWORD command: needs two arguments "
1109 "(network id and password)\n");
1113 end
= cmd
+ sizeof(cmd
);
1115 ret
= os_snprintf(pos
, end
- pos
, WPA_CTRL_RSP
"PASSWORD-%s:%s",
1117 if (ret
< 0 || ret
>= end
- pos
) {
1118 printf("Too long PASSWORD command.\n");
1122 for (i
= 2; i
< argc
; i
++) {
1123 ret
= os_snprintf(pos
, end
- pos
, " %s", argv
[i
]);
1124 if (ret
< 0 || ret
>= end
- pos
) {
1125 printf("Too long PASSWORD command.\n");
1131 return wpa_ctrl_command(ctrl
, cmd
);
1135 static int wpa_cli_cmd_new_password(struct wpa_ctrl
*ctrl
, int argc
,
1138 char cmd
[256], *pos
, *end
;
1142 printf("Invalid NEW_PASSWORD command: needs two arguments "
1143 "(network id and password)\n");
1147 end
= cmd
+ sizeof(cmd
);
1149 ret
= os_snprintf(pos
, end
- pos
, WPA_CTRL_RSP
"NEW_PASSWORD-%s:%s",
1151 if (ret
< 0 || ret
>= end
- pos
) {
1152 printf("Too long NEW_PASSWORD command.\n");
1156 for (i
= 2; i
< argc
; i
++) {
1157 ret
= os_snprintf(pos
, end
- pos
, " %s", argv
[i
]);
1158 if (ret
< 0 || ret
>= end
- pos
) {
1159 printf("Too long NEW_PASSWORD command.\n");
1165 return wpa_ctrl_command(ctrl
, cmd
);
1169 static int wpa_cli_cmd_pin(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1171 char cmd
[256], *pos
, *end
;
1175 printf("Invalid PIN command: needs two arguments "
1176 "(network id and pin)\n");
1180 end
= cmd
+ sizeof(cmd
);
1182 ret
= os_snprintf(pos
, end
- pos
, WPA_CTRL_RSP
"PIN-%s:%s",
1184 if (ret
< 0 || ret
>= end
- pos
) {
1185 printf("Too long PIN command.\n");
1189 for (i
= 2; i
< argc
; i
++) {
1190 ret
= os_snprintf(pos
, end
- pos
, " %s", argv
[i
]);
1191 if (ret
< 0 || ret
>= end
- pos
) {
1192 printf("Too long PIN command.\n");
1197 return wpa_ctrl_command(ctrl
, cmd
);
1201 static int wpa_cli_cmd_otp(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1203 char cmd
[256], *pos
, *end
;
1207 printf("Invalid OTP command: needs two arguments (network "
1208 "id and password)\n");
1212 end
= cmd
+ sizeof(cmd
);
1214 ret
= os_snprintf(pos
, end
- pos
, WPA_CTRL_RSP
"OTP-%s:%s",
1216 if (ret
< 0 || ret
>= end
- pos
) {
1217 printf("Too long OTP command.\n");
1221 for (i
= 2; i
< argc
; i
++) {
1222 ret
= os_snprintf(pos
, end
- pos
, " %s", argv
[i
]);
1223 if (ret
< 0 || ret
>= end
- pos
) {
1224 printf("Too long OTP command.\n");
1230 return wpa_ctrl_command(ctrl
, cmd
);
1234 static int wpa_cli_cmd_passphrase(struct wpa_ctrl
*ctrl
, int argc
,
1237 char cmd
[256], *pos
, *end
;
1241 printf("Invalid PASSPHRASE command: needs two arguments "
1242 "(network id and passphrase)\n");
1246 end
= cmd
+ sizeof(cmd
);
1248 ret
= os_snprintf(pos
, end
- pos
, WPA_CTRL_RSP
"PASSPHRASE-%s:%s",
1250 if (ret
< 0 || ret
>= end
- pos
) {
1251 printf("Too long PASSPHRASE command.\n");
1255 for (i
= 2; i
< argc
; i
++) {
1256 ret
= os_snprintf(pos
, end
- pos
, " %s", argv
[i
]);
1257 if (ret
< 0 || ret
>= end
- pos
) {
1258 printf("Too long PASSPHRASE command.\n");
1264 return wpa_ctrl_command(ctrl
, cmd
);
1268 static int wpa_cli_cmd_bssid(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1271 printf("Invalid BSSID command: needs two arguments (network "
1276 return wpa_cli_cmd(ctrl
, "BSSID", 2, argc
, argv
);
1280 static int wpa_cli_cmd_blacklist(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1282 return wpa_cli_cmd(ctrl
, "BLACKLIST", 0, argc
, argv
);
1286 static int wpa_cli_cmd_log_level(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1288 return wpa_cli_cmd(ctrl
, "LOG_LEVEL", 0, argc
, argv
);
1292 static int wpa_cli_cmd_list_networks(struct wpa_ctrl
*ctrl
, int argc
,
1295 return wpa_ctrl_command(ctrl
, "LIST_NETWORKS");
1299 static int wpa_cli_cmd_select_network(struct wpa_ctrl
*ctrl
, int argc
,
1302 return wpa_cli_cmd(ctrl
, "SELECT_NETWORK", 1, argc
, argv
);
1306 static int wpa_cli_cmd_enable_network(struct wpa_ctrl
*ctrl
, int argc
,
1309 return wpa_cli_cmd(ctrl
, "ENABLE_NETWORK", 1, argc
, argv
);
1313 static int wpa_cli_cmd_disable_network(struct wpa_ctrl
*ctrl
, int argc
,
1316 return wpa_cli_cmd(ctrl
, "DISABLE_NETWORK", 1, argc
, argv
);
1320 static int wpa_cli_cmd_add_network(struct wpa_ctrl
*ctrl
, int argc
,
1323 return wpa_ctrl_command(ctrl
, "ADD_NETWORK");
1327 static int wpa_cli_cmd_remove_network(struct wpa_ctrl
*ctrl
, int argc
,
1330 return wpa_cli_cmd(ctrl
, "REMOVE_NETWORK", 1, argc
, argv
);
1334 static void wpa_cli_show_network_variables(void)
1336 printf("set_network variables:\n"
1337 " ssid (network name, SSID)\n"
1338 " psk (WPA passphrase or pre-shared key)\n"
1339 " key_mgmt (key management protocol)\n"
1340 " identity (EAP identity)\n"
1341 " password (EAP password)\n"
1344 "Note: Values are entered in the same format as the "
1345 "configuration file is using,\n"
1346 "i.e., strings values need to be inside double quotation "
1348 "For example: set_network 1 ssid \"network name\"\n"
1350 "Please see wpa_supplicant.conf documentation for full list "
1351 "of\navailable variables.\n");
1355 static int wpa_cli_cmd_set_network(struct wpa_ctrl
*ctrl
, int argc
,
1359 wpa_cli_show_network_variables();
1364 printf("Invalid SET_NETWORK command: needs three arguments\n"
1365 "(network id, variable name, and value)\n");
1369 return wpa_cli_cmd(ctrl
, "SET_NETWORK", 3, argc
, argv
);
1373 static int wpa_cli_cmd_get_network(struct wpa_ctrl
*ctrl
, int argc
,
1377 wpa_cli_show_network_variables();
1382 printf("Invalid GET_NETWORK command: needs two arguments\n"
1383 "(network id and variable name)\n");
1387 return wpa_cli_cmd(ctrl
, "GET_NETWORK", 2, argc
, argv
);
1391 static int wpa_cli_cmd_list_creds(struct wpa_ctrl
*ctrl
, int argc
,
1394 return wpa_ctrl_command(ctrl
, "LIST_CREDS");
1398 static int wpa_cli_cmd_add_cred(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1400 return wpa_ctrl_command(ctrl
, "ADD_CRED");
1404 static int wpa_cli_cmd_remove_cred(struct wpa_ctrl
*ctrl
, int argc
,
1407 return wpa_cli_cmd(ctrl
, "REMOVE_CRED", 1, argc
, argv
);
1411 static int wpa_cli_cmd_set_cred(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1414 printf("Invalid SET_CRED command: needs three arguments\n"
1415 "(cred id, variable name, and value)\n");
1419 return wpa_cli_cmd(ctrl
, "SET_CRED", 3, argc
, argv
);
1423 static int wpa_cli_cmd_disconnect(struct wpa_ctrl
*ctrl
, int argc
,
1426 return wpa_ctrl_command(ctrl
, "DISCONNECT");
1430 static int wpa_cli_cmd_reconnect(struct wpa_ctrl
*ctrl
, int argc
,
1433 return wpa_ctrl_command(ctrl
, "RECONNECT");
1437 static int wpa_cli_cmd_save_config(struct wpa_ctrl
*ctrl
, int argc
,
1440 return wpa_ctrl_command(ctrl
, "SAVE_CONFIG");
1444 static int wpa_cli_cmd_scan(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1446 return wpa_cli_cmd(ctrl
, "SCAN", 0, argc
, argv
);
1450 static int wpa_cli_cmd_scan_results(struct wpa_ctrl
*ctrl
, int argc
,
1453 return wpa_ctrl_command(ctrl
, "SCAN_RESULTS");
1457 static int wpa_cli_cmd_bss(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1459 return wpa_cli_cmd(ctrl
, "BSS", 1, argc
, argv
);
1463 static char ** wpa_cli_complete_bss(const char *str
, int pos
)
1465 int arg
= get_cmd_arg_num(str
, pos
);
1470 res
= cli_txt_list_array(&bsses
);
1478 static int wpa_cli_cmd_get_capability(struct wpa_ctrl
*ctrl
, int argc
,
1481 if (argc
< 1 || argc
> 2) {
1482 printf("Invalid GET_CAPABILITY command: need either one or "
1487 if ((argc
== 2) && os_strcmp(argv
[1], "strict") != 0) {
1488 printf("Invalid GET_CAPABILITY command: second argument, "
1489 "if any, must be 'strict'\n");
1493 return wpa_cli_cmd(ctrl
, "GET_CAPABILITY", 1, argc
, argv
);
1497 static int wpa_cli_list_interfaces(struct wpa_ctrl
*ctrl
)
1499 printf("Available interfaces:\n");
1500 return wpa_ctrl_command(ctrl
, "INTERFACES");
1504 static int wpa_cli_cmd_interface(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1507 wpa_cli_list_interfaces(ctrl
);
1511 wpa_cli_close_connection();
1512 os_free(ctrl_ifname
);
1513 ctrl_ifname
= os_strdup(argv
[0]);
1515 if (wpa_cli_open_connection(ctrl_ifname
, 1)) {
1516 printf("Connected to interface '%s.\n", ctrl_ifname
);
1518 printf("Could not connect to interface '%s' - re-trying\n",
1525 static int wpa_cli_cmd_reconfigure(struct wpa_ctrl
*ctrl
, int argc
,
1528 return wpa_ctrl_command(ctrl
, "RECONFIGURE");
1532 static int wpa_cli_cmd_terminate(struct wpa_ctrl
*ctrl
, int argc
,
1535 return wpa_ctrl_command(ctrl
, "TERMINATE");
1539 static int wpa_cli_cmd_interface_add(struct wpa_ctrl
*ctrl
, int argc
,
1546 printf("Invalid INTERFACE_ADD command: needs at least one "
1547 "argument (interface name)\n"
1548 "All arguments: ifname confname driver ctrl_interface "
1549 "driver_param bridge_name\n");
1554 * INTERFACE_ADD <ifname>TAB<confname>TAB<driver>TAB<ctrl_interface>TAB
1555 * <driver_param>TAB<bridge_name>
1557 res
= os_snprintf(cmd
, sizeof(cmd
),
1558 "INTERFACE_ADD %s\t%s\t%s\t%s\t%s\t%s",
1560 argc
> 1 ? argv
[1] : "", argc
> 2 ? argv
[2] : "",
1561 argc
> 3 ? argv
[3] : "", argc
> 4 ? argv
[4] : "",
1562 argc
> 5 ? argv
[5] : "");
1563 if (res
< 0 || (size_t) res
>= sizeof(cmd
))
1565 cmd
[sizeof(cmd
) - 1] = '\0';
1566 return wpa_ctrl_command(ctrl
, cmd
);
1570 static int wpa_cli_cmd_interface_remove(struct wpa_ctrl
*ctrl
, int argc
,
1573 return wpa_cli_cmd(ctrl
, "INTERFACE_REMOVE", 1, argc
, argv
);
1577 static int wpa_cli_cmd_interface_list(struct wpa_ctrl
*ctrl
, int argc
,
1580 return wpa_ctrl_command(ctrl
, "INTERFACE_LIST");
1585 static int wpa_cli_cmd_sta(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1587 return wpa_cli_cmd(ctrl
, "STA", 1, argc
, argv
);
1591 static int wpa_ctrl_command_sta(struct wpa_ctrl
*ctrl
, char *cmd
,
1592 char *addr
, size_t addr_len
)
1594 char buf
[4096], *pos
;
1598 if (ctrl_conn
== NULL
) {
1599 printf("Not connected to hostapd - command dropped.\n");
1602 len
= sizeof(buf
) - 1;
1603 ret
= wpa_ctrl_request(ctrl
, cmd
, os_strlen(cmd
), buf
, &len
,
1606 printf("'%s' command timed out.\n", cmd
);
1608 } else if (ret
< 0) {
1609 printf("'%s' command failed.\n", cmd
);
1614 if (os_memcmp(buf
, "FAIL", 4) == 0)
1619 while (*pos
!= '\0' && *pos
!= '\n')
1622 os_strlcpy(addr
, buf
, addr_len
);
1627 static int wpa_cli_cmd_all_sta(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1629 char addr
[32], cmd
[64];
1631 if (wpa_ctrl_command_sta(ctrl
, "STA-FIRST", addr
, sizeof(addr
)))
1634 os_snprintf(cmd
, sizeof(cmd
), "STA-NEXT %s", addr
);
1635 } while (wpa_ctrl_command_sta(ctrl
, cmd
, addr
, sizeof(addr
)) == 0);
1641 static int wpa_cli_cmd_deauthenticate(struct wpa_ctrl
*ctrl
, int argc
,
1644 return wpa_cli_cmd(ctrl
, "DEAUTHENTICATE", 1, argc
, argv
);
1648 static int wpa_cli_cmd_disassociate(struct wpa_ctrl
*ctrl
, int argc
,
1651 return wpa_cli_cmd(ctrl
, "DISASSOCIATE", 1, argc
, argv
);
1653 #endif /* CONFIG_AP */
1656 static int wpa_cli_cmd_suspend(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1658 return wpa_ctrl_command(ctrl
, "SUSPEND");
1662 static int wpa_cli_cmd_resume(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1664 return wpa_ctrl_command(ctrl
, "RESUME");
1668 static int wpa_cli_cmd_drop_sa(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1670 return wpa_ctrl_command(ctrl
, "DROP_SA");
1674 static int wpa_cli_cmd_roam(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1676 return wpa_cli_cmd(ctrl
, "ROAM", 1, argc
, argv
);
1682 static int wpa_cli_cmd_p2p_find(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1684 return wpa_cli_cmd(ctrl
, "P2P_FIND", 0, argc
, argv
);
1688 static char ** wpa_cli_complete_p2p_find(const char *str
, int pos
)
1691 int arg
= get_cmd_arg_num(str
, pos
);
1693 res
= os_calloc(6, sizeof(char *));
1696 res
[0] = os_strdup("type=social");
1697 if (res
[0] == NULL
) {
1701 res
[1] = os_strdup("type=progressive");
1704 res
[2] = os_strdup("delay=");
1707 res
[3] = os_strdup("dev_id=");
1711 res
[4] = os_strdup("[timeout]");
1717 static int wpa_cli_cmd_p2p_stop_find(struct wpa_ctrl
*ctrl
, int argc
,
1720 return wpa_ctrl_command(ctrl
, "P2P_STOP_FIND");
1724 static int wpa_cli_cmd_p2p_connect(struct wpa_ctrl
*ctrl
, int argc
,
1727 return wpa_cli_cmd(ctrl
, "P2P_CONNECT", 2, argc
, argv
);
1731 static char ** wpa_cli_complete_p2p_connect(const char *str
, int pos
)
1733 int arg
= get_cmd_arg_num(str
, pos
);
1738 res
= cli_txt_list_array(&p2p_peers
);
1746 static int wpa_cli_cmd_p2p_listen(struct wpa_ctrl
*ctrl
, int argc
,
1749 return wpa_cli_cmd(ctrl
, "P2P_LISTEN", 0, argc
, argv
);
1753 static int wpa_cli_cmd_p2p_group_remove(struct wpa_ctrl
*ctrl
, int argc
,
1756 return wpa_cli_cmd(ctrl
, "P2P_GROUP_REMOVE", 1, argc
, argv
);
1760 static char ** wpa_cli_complete_p2p_group_remove(const char *str
, int pos
)
1762 int arg
= get_cmd_arg_num(str
, pos
);
1767 res
= cli_txt_list_array(&p2p_groups
);
1775 static int wpa_cli_cmd_p2p_group_add(struct wpa_ctrl
*ctrl
, int argc
,
1778 return wpa_cli_cmd(ctrl
, "P2P_GROUP_ADD", 0, argc
, argv
);
1782 static int wpa_cli_cmd_p2p_prov_disc(struct wpa_ctrl
*ctrl
, int argc
,
1785 if (argc
!= 2 && argc
!= 3) {
1786 printf("Invalid P2P_PROV_DISC command: needs at least "
1787 "two arguments, address and config method\n"
1788 "(display, keypad, or pbc) and an optional join\n");
1792 return wpa_cli_cmd(ctrl
, "P2P_PROV_DISC", 2, argc
, argv
);
1796 static int wpa_cli_cmd_p2p_get_passphrase(struct wpa_ctrl
*ctrl
, int argc
,
1799 return wpa_ctrl_command(ctrl
, "P2P_GET_PASSPHRASE");
1803 static int wpa_cli_cmd_p2p_serv_disc_req(struct wpa_ctrl
*ctrl
, int argc
,
1808 if (argc
!= 2 && argc
!= 4) {
1809 printf("Invalid P2P_SERV_DISC_REQ command: needs two "
1810 "arguments (address and TLVs) or four arguments "
1811 "(address, \"upnp\", version, search target "
1816 if (write_cmd(cmd
, sizeof(cmd
), "P2P_SERV_DISC_REQ", argc
, argv
) < 0)
1818 return wpa_ctrl_command(ctrl
, cmd
);
1822 static int wpa_cli_cmd_p2p_serv_disc_cancel_req(struct wpa_ctrl
*ctrl
,
1823 int argc
, char *argv
[])
1825 return wpa_cli_cmd(ctrl
, "P2P_SERV_DISC_CANCEL_REQ", 1, argc
, argv
);
1829 static int wpa_cli_cmd_p2p_serv_disc_resp(struct wpa_ctrl
*ctrl
, int argc
,
1836 printf("Invalid P2P_SERV_DISC_RESP command: needs four "
1837 "arguments (freq, address, dialog token, and TLVs)\n");
1841 res
= os_snprintf(cmd
, sizeof(cmd
), "P2P_SERV_DISC_RESP %s %s %s %s",
1842 argv
[0], argv
[1], argv
[2], argv
[3]);
1843 if (res
< 0 || (size_t) res
>= sizeof(cmd
))
1845 cmd
[sizeof(cmd
) - 1] = '\0';
1846 return wpa_ctrl_command(ctrl
, cmd
);
1850 static int wpa_cli_cmd_p2p_service_update(struct wpa_ctrl
*ctrl
, int argc
,
1853 return wpa_ctrl_command(ctrl
, "P2P_SERVICE_UPDATE");
1857 static int wpa_cli_cmd_p2p_serv_disc_external(struct wpa_ctrl
*ctrl
,
1858 int argc
, char *argv
[])
1860 return wpa_cli_cmd(ctrl
, "P2P_SERV_DISC_EXTERNAL", 1, argc
, argv
);
1864 static int wpa_cli_cmd_p2p_service_flush(struct wpa_ctrl
*ctrl
, int argc
,
1867 return wpa_ctrl_command(ctrl
, "P2P_SERVICE_FLUSH");
1871 static int wpa_cli_cmd_p2p_service_add(struct wpa_ctrl
*ctrl
, int argc
,
1877 if (argc
!= 3 && argc
!= 4) {
1878 printf("Invalid P2P_SERVICE_ADD command: needs three or four "
1884 res
= os_snprintf(cmd
, sizeof(cmd
),
1885 "P2P_SERVICE_ADD %s %s %s %s",
1886 argv
[0], argv
[1], argv
[2], argv
[3]);
1888 res
= os_snprintf(cmd
, sizeof(cmd
),
1889 "P2P_SERVICE_ADD %s %s %s",
1890 argv
[0], argv
[1], argv
[2]);
1891 if (res
< 0 || (size_t) res
>= sizeof(cmd
))
1893 cmd
[sizeof(cmd
) - 1] = '\0';
1894 return wpa_ctrl_command(ctrl
, cmd
);
1898 static int wpa_cli_cmd_p2p_service_del(struct wpa_ctrl
*ctrl
, int argc
,
1904 if (argc
!= 2 && argc
!= 3) {
1905 printf("Invalid P2P_SERVICE_DEL command: needs two or three "
1911 res
= os_snprintf(cmd
, sizeof(cmd
),
1912 "P2P_SERVICE_DEL %s %s %s",
1913 argv
[0], argv
[1], argv
[2]);
1915 res
= os_snprintf(cmd
, sizeof(cmd
),
1916 "P2P_SERVICE_DEL %s %s",
1918 if (res
< 0 || (size_t) res
>= sizeof(cmd
))
1920 cmd
[sizeof(cmd
) - 1] = '\0';
1921 return wpa_ctrl_command(ctrl
, cmd
);
1925 static int wpa_cli_cmd_p2p_reject(struct wpa_ctrl
*ctrl
,
1926 int argc
, char *argv
[])
1928 return wpa_cli_cmd(ctrl
, "P2P_REJECT", 1, argc
, argv
);
1932 static int wpa_cli_cmd_p2p_invite(struct wpa_ctrl
*ctrl
,
1933 int argc
, char *argv
[])
1935 return wpa_cli_cmd(ctrl
, "P2P_INVITE", 1, argc
, argv
);
1939 static int wpa_cli_cmd_p2p_peer(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1941 return wpa_cli_cmd(ctrl
, "P2P_PEER", 1, argc
, argv
);
1945 static char ** wpa_cli_complete_p2p_peer(const char *str
, int pos
)
1947 int arg
= get_cmd_arg_num(str
, pos
);
1952 res
= cli_txt_list_array(&p2p_peers
);
1960 static int wpa_ctrl_command_p2p_peer(struct wpa_ctrl
*ctrl
, char *cmd
,
1961 char *addr
, size_t addr_len
,
1964 char buf
[4096], *pos
;
1968 if (ctrl_conn
== NULL
)
1970 len
= sizeof(buf
) - 1;
1971 ret
= wpa_ctrl_request(ctrl
, cmd
, os_strlen(cmd
), buf
, &len
,
1974 printf("'%s' command timed out.\n", cmd
);
1976 } else if (ret
< 0) {
1977 printf("'%s' command failed.\n", cmd
);
1982 if (os_memcmp(buf
, "FAIL", 4) == 0)
1986 while (*pos
!= '\0' && *pos
!= '\n')
1989 os_strlcpy(addr
, buf
, addr_len
);
1990 if (!discovered
|| os_strstr(pos
, "[PROBE_REQ_ONLY]") == NULL
)
1991 printf("%s\n", addr
);
1996 static int wpa_cli_cmd_p2p_peers(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1998 char addr
[32], cmd
[64];
2001 discovered
= argc
> 0 && os_strcmp(argv
[0], "discovered") == 0;
2003 if (wpa_ctrl_command_p2p_peer(ctrl
, "P2P_PEER FIRST",
2004 addr
, sizeof(addr
), discovered
))
2007 os_snprintf(cmd
, sizeof(cmd
), "P2P_PEER NEXT-%s", addr
);
2008 } while (wpa_ctrl_command_p2p_peer(ctrl
, cmd
, addr
, sizeof(addr
),
2015 static int wpa_cli_cmd_p2p_set(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2017 return wpa_cli_cmd(ctrl
, "P2P_SET", 2, argc
, argv
);
2021 static int wpa_cli_cmd_p2p_flush(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2023 return wpa_ctrl_command(ctrl
, "P2P_FLUSH");
2027 static int wpa_cli_cmd_p2p_cancel(struct wpa_ctrl
*ctrl
, int argc
,
2030 return wpa_ctrl_command(ctrl
, "P2P_CANCEL");
2034 static int wpa_cli_cmd_p2p_unauthorize(struct wpa_ctrl
*ctrl
, int argc
,
2037 return wpa_cli_cmd(ctrl
, "P2P_UNAUTHORIZE", 1, argc
, argv
);
2041 static int wpa_cli_cmd_p2p_presence_req(struct wpa_ctrl
*ctrl
, int argc
,
2044 if (argc
!= 0 && argc
!= 2 && argc
!= 4) {
2045 printf("Invalid P2P_PRESENCE_REQ command: needs two arguments "
2046 "(preferred duration, interval; in microsecods).\n"
2047 "Optional second pair can be used to provide "
2048 "acceptable values.\n");
2052 return wpa_cli_cmd(ctrl
, "P2P_PRESENCE_REQ", 0, argc
, argv
);
2056 static int wpa_cli_cmd_p2p_ext_listen(struct wpa_ctrl
*ctrl
, int argc
,
2059 if (argc
!= 0 && argc
!= 2) {
2060 printf("Invalid P2P_EXT_LISTEN command: needs two arguments "
2061 "(availability period, availability interval; in "
2063 "Extended Listen Timing can be cancelled with this "
2064 "command when used without parameters.\n");
2068 return wpa_cli_cmd(ctrl
, "P2P_EXT_LISTEN", 0, argc
, argv
);
2071 #endif /* CONFIG_P2P */
2073 #ifdef CONFIG_WIFI_DISPLAY
2075 static int wpa_cli_cmd_wfd_subelem_set(struct wpa_ctrl
*ctrl
, int argc
,
2081 if (argc
!= 1 && argc
!= 2) {
2082 printf("Invalid WFD_SUBELEM_SET command: needs one or two "
2083 "arguments (subelem, hexdump)\n");
2087 res
= os_snprintf(cmd
, sizeof(cmd
), "WFD_SUBELEM_SET %s %s",
2088 argv
[0], argc
> 1 ? argv
[1] : "");
2089 if (res
< 0 || (size_t) res
>= sizeof(cmd
))
2091 cmd
[sizeof(cmd
) - 1] = '\0';
2092 return wpa_ctrl_command(ctrl
, cmd
);
2096 static int wpa_cli_cmd_wfd_subelem_get(struct wpa_ctrl
*ctrl
, int argc
,
2103 printf("Invalid WFD_SUBELEM_GET command: needs one "
2104 "argument (subelem)\n");
2108 res
= os_snprintf(cmd
, sizeof(cmd
), "WFD_SUBELEM_GET %s",
2110 if (res
< 0 || (size_t) res
>= sizeof(cmd
))
2112 cmd
[sizeof(cmd
) - 1] = '\0';
2113 return wpa_ctrl_command(ctrl
, cmd
);
2115 #endif /* CONFIG_WIFI_DISPLAY */
2118 #ifdef CONFIG_INTERWORKING
2119 static int wpa_cli_cmd_fetch_anqp(struct wpa_ctrl
*ctrl
, int argc
,
2122 return wpa_ctrl_command(ctrl
, "FETCH_ANQP");
2126 static int wpa_cli_cmd_stop_fetch_anqp(struct wpa_ctrl
*ctrl
, int argc
,
2129 return wpa_ctrl_command(ctrl
, "STOP_FETCH_ANQP");
2133 static int wpa_cli_cmd_interworking_select(struct wpa_ctrl
*ctrl
, int argc
,
2136 return wpa_cli_cmd(ctrl
, "INTERWORKING_SELECT", 0, argc
, argv
);
2140 static int wpa_cli_cmd_interworking_connect(struct wpa_ctrl
*ctrl
, int argc
,
2143 return wpa_cli_cmd(ctrl
, "INTERWORKING_CONNECT", 1, argc
, argv
);
2147 static int wpa_cli_cmd_anqp_get(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2149 return wpa_cli_cmd(ctrl
, "ANQP_GET", 2, argc
, argv
);
2153 static int wpa_cli_cmd_gas_request(struct wpa_ctrl
*ctrl
, int argc
,
2156 return wpa_cli_cmd(ctrl
, "GAS_REQUEST", 2, argc
, argv
);
2160 static int wpa_cli_cmd_gas_response_get(struct wpa_ctrl
*ctrl
, int argc
,
2163 return wpa_cli_cmd(ctrl
, "GAS_RESPONSE_GET", 2, argc
, argv
);
2165 #endif /* CONFIG_INTERWORKING */
2170 static int wpa_cli_cmd_hs20_anqp_get(struct wpa_ctrl
*ctrl
, int argc
,
2173 return wpa_cli_cmd(ctrl
, "HS20_ANQP_GET", 2, argc
, argv
);
2177 static int wpa_cli_cmd_get_nai_home_realm_list(struct wpa_ctrl
*ctrl
, int argc
,
2183 printf("Command needs one or two arguments (dst mac addr and "
2184 "optional home realm)\n");
2188 if (write_cmd(cmd
, sizeof(cmd
), "HS20_GET_NAI_HOME_REALM_LIST",
2192 return wpa_ctrl_command(ctrl
, cmd
);
2195 #endif /* CONFIG_HS20 */
2198 static int wpa_cli_cmd_sta_autoconnect(struct wpa_ctrl
*ctrl
, int argc
,
2201 return wpa_cli_cmd(ctrl
, "STA_AUTOCONNECT", 1, argc
, argv
);
2205 static int wpa_cli_cmd_tdls_discover(struct wpa_ctrl
*ctrl
, int argc
,
2208 return wpa_cli_cmd(ctrl
, "TDLS_DISCOVER", 1, argc
, argv
);
2212 static int wpa_cli_cmd_tdls_setup(struct wpa_ctrl
*ctrl
, int argc
,
2215 return wpa_cli_cmd(ctrl
, "TDLS_SETUP", 1, argc
, argv
);
2219 static int wpa_cli_cmd_tdls_teardown(struct wpa_ctrl
*ctrl
, int argc
,
2222 return wpa_cli_cmd(ctrl
, "TDLS_TEARDOWN", 1, argc
, argv
);
2226 static int wpa_cli_cmd_signal_poll(struct wpa_ctrl
*ctrl
, int argc
,
2229 return wpa_ctrl_command(ctrl
, "SIGNAL_POLL");
2233 static int wpa_cli_cmd_pktcnt_poll(struct wpa_ctrl
*ctrl
, int argc
,
2236 return wpa_ctrl_command(ctrl
, "PKTCNT_POLL");
2240 static int wpa_cli_cmd_reauthenticate(struct wpa_ctrl
*ctrl
, int argc
,
2243 return wpa_ctrl_command(ctrl
, "REAUTHENTICATE");
2247 #ifdef CONFIG_AUTOSCAN
2249 static int wpa_cli_cmd_autoscan(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2252 return wpa_ctrl_command(ctrl
, "AUTOSCAN ");
2254 return wpa_cli_cmd(ctrl
, "AUTOSCAN", 0, argc
, argv
);
2257 #endif /* CONFIG_AUTOSCAN */
2262 static int wpa_cli_cmd_wnm_sleep(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2264 return wpa_cli_cmd(ctrl
, "WNM_SLEEP", 0, argc
, argv
);
2267 #endif /* CONFIG_WNM */
2270 static int wpa_cli_cmd_raw(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2274 return wpa_cli_cmd(ctrl
, argv
[0], 0, argc
- 1, &argv
[1]);
2278 static int wpa_cli_cmd_flush(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2280 return wpa_ctrl_command(ctrl
, "FLUSH");
2284 enum wpa_cli_cmd_flags
{
2285 cli_cmd_flag_none
= 0x00,
2286 cli_cmd_flag_sensitive
= 0x01
2289 struct wpa_cli_cmd
{
2291 int (*handler
)(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[]);
2292 char ** (*completion
)(const char *str
, int pos
);
2293 enum wpa_cli_cmd_flags flags
;
2297 static struct wpa_cli_cmd wpa_cli_commands
[] = {
2298 { "status", wpa_cli_cmd_status
, NULL
,
2300 "[verbose] = get current WPA/EAPOL/EAP status" },
2301 { "ifname", wpa_cli_cmd_ifname
, NULL
,
2303 "= get current interface name" },
2304 { "ping", wpa_cli_cmd_ping
, NULL
,
2306 "= pings wpa_supplicant" },
2307 { "relog", wpa_cli_cmd_relog
, NULL
,
2309 "= re-open log-file (allow rolling logs)" },
2310 { "note", wpa_cli_cmd_note
, NULL
,
2312 "<text> = add a note to wpa_supplicant debug log" },
2313 { "mib", wpa_cli_cmd_mib
, NULL
,
2315 "= get MIB variables (dot1x, dot11)" },
2316 { "help", wpa_cli_cmd_help
, wpa_cli_complete_help
,
2318 "[command] = show usage help" },
2319 { "interface", wpa_cli_cmd_interface
, NULL
,
2321 "[ifname] = show interfaces/select interface" },
2322 { "level", wpa_cli_cmd_level
, NULL
,
2324 "<debug level> = change debug level" },
2325 { "license", wpa_cli_cmd_license
, NULL
,
2327 "= show full wpa_cli license" },
2328 { "quit", wpa_cli_cmd_quit
, NULL
,
2331 { "set", wpa_cli_cmd_set
, NULL
,
2333 "= set variables (shows list of variables when run without "
2335 { "get", wpa_cli_cmd_get
, NULL
,
2337 "<name> = get information" },
2338 { "logon", wpa_cli_cmd_logon
, NULL
,
2340 "= IEEE 802.1X EAPOL state machine logon" },
2341 { "logoff", wpa_cli_cmd_logoff
, NULL
,
2343 "= IEEE 802.1X EAPOL state machine logoff" },
2344 { "pmksa", wpa_cli_cmd_pmksa
, NULL
,
2346 "= show PMKSA cache" },
2347 { "reassociate", wpa_cli_cmd_reassociate
, NULL
,
2349 "= force reassociation" },
2350 { "preauthenticate", wpa_cli_cmd_preauthenticate
, wpa_cli_complete_bss
,
2352 "<BSSID> = force preauthentication" },
2353 { "identity", wpa_cli_cmd_identity
, NULL
,
2355 "<network id> <identity> = configure identity for an SSID" },
2356 { "password", wpa_cli_cmd_password
, NULL
,
2357 cli_cmd_flag_sensitive
,
2358 "<network id> <password> = configure password for an SSID" },
2359 { "new_password", wpa_cli_cmd_new_password
, NULL
,
2360 cli_cmd_flag_sensitive
,
2361 "<network id> <password> = change password for an SSID" },
2362 { "pin", wpa_cli_cmd_pin
, NULL
,
2363 cli_cmd_flag_sensitive
,
2364 "<network id> <pin> = configure pin for an SSID" },
2365 { "otp", wpa_cli_cmd_otp
, NULL
,
2366 cli_cmd_flag_sensitive
,
2367 "<network id> <password> = configure one-time-password for an SSID"
2369 { "passphrase", wpa_cli_cmd_passphrase
, NULL
,
2370 cli_cmd_flag_sensitive
,
2371 "<network id> <passphrase> = configure private key passphrase\n"
2373 { "bssid", wpa_cli_cmd_bssid
, NULL
,
2375 "<network id> <BSSID> = set preferred BSSID for an SSID" },
2376 { "blacklist", wpa_cli_cmd_blacklist
, wpa_cli_complete_bss
,
2378 "<BSSID> = add a BSSID to the blacklist\n"
2379 "blacklist clear = clear the blacklist\n"
2380 "blacklist = display the blacklist" },
2381 { "log_level", wpa_cli_cmd_log_level
, NULL
,
2383 "<level> [<timestamp>] = update the log level/timestamp\n"
2384 "log_level = display the current log level and log options" },
2385 { "list_networks", wpa_cli_cmd_list_networks
, NULL
,
2387 "= list configured networks" },
2388 { "select_network", wpa_cli_cmd_select_network
, NULL
,
2390 "<network id> = select a network (disable others)" },
2391 { "enable_network", wpa_cli_cmd_enable_network
, NULL
,
2393 "<network id> = enable a network" },
2394 { "disable_network", wpa_cli_cmd_disable_network
, NULL
,
2396 "<network id> = disable a network" },
2397 { "add_network", wpa_cli_cmd_add_network
, NULL
,
2399 "= add a network" },
2400 { "remove_network", wpa_cli_cmd_remove_network
, NULL
,
2402 "<network id> = remove a network" },
2403 { "set_network", wpa_cli_cmd_set_network
, NULL
,
2404 cli_cmd_flag_sensitive
,
2405 "<network id> <variable> <value> = set network variables (shows\n"
2406 " list of variables when run without arguments)" },
2407 { "get_network", wpa_cli_cmd_get_network
, NULL
,
2409 "<network id> <variable> = get network variables" },
2410 { "list_creds", wpa_cli_cmd_list_creds
, NULL
,
2412 "= list configured credentials" },
2413 { "add_cred", wpa_cli_cmd_add_cred
, NULL
,
2415 "= add a credential" },
2416 { "remove_cred", wpa_cli_cmd_remove_cred
, NULL
,
2418 "<cred id> = remove a credential" },
2419 { "set_cred", wpa_cli_cmd_set_cred
, NULL
,
2420 cli_cmd_flag_sensitive
,
2421 "<cred id> <variable> <value> = set credential variables" },
2422 { "save_config", wpa_cli_cmd_save_config
, NULL
,
2424 "= save the current configuration" },
2425 { "disconnect", wpa_cli_cmd_disconnect
, NULL
,
2427 "= disconnect and wait for reassociate/reconnect command before\n"
2429 { "reconnect", wpa_cli_cmd_reconnect
, NULL
,
2431 "= like reassociate, but only takes effect if already disconnected"
2433 { "scan", wpa_cli_cmd_scan
, NULL
,
2435 "= request new BSS scan" },
2436 { "scan_results", wpa_cli_cmd_scan_results
, NULL
,
2438 "= get latest scan results" },
2439 { "bss", wpa_cli_cmd_bss
, wpa_cli_complete_bss
,
2441 "<<idx> | <bssid>> = get detailed scan result info" },
2442 { "get_capability", wpa_cli_cmd_get_capability
, NULL
,
2444 "<eap/pairwise/group/key_mgmt/proto/auth_alg/channels/freq/modes> "
2445 "= get capabilies" },
2446 { "reconfigure", wpa_cli_cmd_reconfigure
, NULL
,
2448 "= force wpa_supplicant to re-read its configuration file" },
2449 { "terminate", wpa_cli_cmd_terminate
, NULL
,
2451 "= terminate wpa_supplicant" },
2452 { "interface_add", wpa_cli_cmd_interface_add
, NULL
,
2454 "<ifname> <confname> <driver> <ctrl_interface> <driver_param>\n"
2455 " <bridge_name> = adds new interface, all parameters but <ifname>\n"
2457 { "interface_remove", wpa_cli_cmd_interface_remove
, NULL
,
2459 "<ifname> = removes the interface" },
2460 { "interface_list", wpa_cli_cmd_interface_list
, NULL
,
2462 "= list available interfaces" },
2463 { "ap_scan", wpa_cli_cmd_ap_scan
, NULL
,
2465 "<value> = set ap_scan parameter" },
2466 { "scan_interval", wpa_cli_cmd_scan_interval
, NULL
,
2468 "<value> = set scan_interval parameter (in seconds)" },
2469 { "bss_expire_age", wpa_cli_cmd_bss_expire_age
, NULL
,
2471 "<value> = set BSS expiration age parameter" },
2472 { "bss_expire_count", wpa_cli_cmd_bss_expire_count
, NULL
,
2474 "<value> = set BSS expiration scan count parameter" },
2475 { "bss_flush", wpa_cli_cmd_bss_flush
, NULL
,
2477 "<value> = set BSS flush age (0 by default)" },
2478 { "stkstart", wpa_cli_cmd_stkstart
, NULL
,
2480 "<addr> = request STK negotiation with <addr>" },
2481 { "ft_ds", wpa_cli_cmd_ft_ds
, wpa_cli_complete_bss
,
2483 "<addr> = request over-the-DS FT with <addr>" },
2484 { "wps_pbc", wpa_cli_cmd_wps_pbc
, wpa_cli_complete_bss
,
2486 "[BSSID] = start Wi-Fi Protected Setup: Push Button Configuration" },
2487 { "wps_pin", wpa_cli_cmd_wps_pin
, wpa_cli_complete_bss
,
2488 cli_cmd_flag_sensitive
,
2489 "<BSSID> [PIN] = start WPS PIN method (returns PIN, if not "
2491 { "wps_check_pin", wpa_cli_cmd_wps_check_pin
, NULL
,
2492 cli_cmd_flag_sensitive
,
2493 "<PIN> = verify PIN checksum" },
2494 { "wps_cancel", wpa_cli_cmd_wps_cancel
, NULL
, cli_cmd_flag_none
,
2495 "Cancels the pending WPS operation" },
2496 #ifdef CONFIG_WPS_NFC
2497 { "wps_nfc", wpa_cli_cmd_wps_nfc
, wpa_cli_complete_bss
,
2499 "[BSSID] = start Wi-Fi Protected Setup: NFC" },
2500 { "wps_nfc_config_token", wpa_cli_cmd_wps_nfc_config_token
, NULL
,
2502 "<WPS|NDEF> = build configuration token" },
2503 { "wps_nfc_token", wpa_cli_cmd_wps_nfc_token
, NULL
,
2505 "<WPS|NDEF> = create password token" },
2506 { "wps_nfc_tag_read", wpa_cli_cmd_wps_nfc_tag_read
, NULL
,
2507 cli_cmd_flag_sensitive
,
2508 "<hexdump of payload> = report read NFC tag with WPS data" },
2509 { "nfc_get_handover_req", wpa_cli_cmd_nfc_get_handover_req
, NULL
,
2511 "<NDEF> <WPS> = create NFC handover request" },
2512 { "nfc_get_handover_sel", wpa_cli_cmd_nfc_get_handover_sel
, NULL
,
2514 "<NDEF> <WPS> = create NFC handover select" },
2515 { "nfc_rx_handover_req", wpa_cli_cmd_nfc_rx_handover_req
, NULL
,
2517 "<hexdump of payload> = report received NFC handover request" },
2518 { "nfc_rx_handover_sel", wpa_cli_cmd_nfc_rx_handover_sel
, NULL
,
2520 "<hexdump of payload> = report received NFC handover select" },
2521 { "nfc_report_handover", wpa_cli_cmd_nfc_report_handover
, NULL
,
2523 "<role> <type> <hexdump of req> <hexdump of sel> = report completed "
2525 #endif /* CONFIG_WPS_NFC */
2526 { "wps_reg", wpa_cli_cmd_wps_reg
, wpa_cli_complete_bss
,
2527 cli_cmd_flag_sensitive
,
2528 "<BSSID> <AP PIN> = start WPS Registrar to configure an AP" },
2529 { "wps_ap_pin", wpa_cli_cmd_wps_ap_pin
, NULL
,
2530 cli_cmd_flag_sensitive
,
2531 "[params..] = enable/disable AP PIN" },
2532 { "wps_er_start", wpa_cli_cmd_wps_er_start
, NULL
,
2534 "[IP address] = start Wi-Fi Protected Setup External Registrar" },
2535 { "wps_er_stop", wpa_cli_cmd_wps_er_stop
, NULL
,
2537 "= stop Wi-Fi Protected Setup External Registrar" },
2538 { "wps_er_pin", wpa_cli_cmd_wps_er_pin
, NULL
,
2539 cli_cmd_flag_sensitive
,
2540 "<UUID> <PIN> = add an Enrollee PIN to External Registrar" },
2541 { "wps_er_pbc", wpa_cli_cmd_wps_er_pbc
, NULL
,
2543 "<UUID> = accept an Enrollee PBC using External Registrar" },
2544 { "wps_er_learn", wpa_cli_cmd_wps_er_learn
, NULL
,
2545 cli_cmd_flag_sensitive
,
2546 "<UUID> <PIN> = learn AP configuration" },
2547 { "wps_er_set_config", wpa_cli_cmd_wps_er_set_config
, NULL
,
2549 "<UUID> <network id> = set AP configuration for enrolling" },
2550 { "wps_er_config", wpa_cli_cmd_wps_er_config
, NULL
,
2551 cli_cmd_flag_sensitive
,
2552 "<UUID> <PIN> <SSID> <auth> <encr> <key> = configure AP" },
2553 #ifdef CONFIG_WPS_NFC
2554 { "wps_er_nfc_config_token", wpa_cli_cmd_wps_er_nfc_config_token
, NULL
,
2556 "<WPS/NDEF> <UUID> = build NFC configuration token" },
2557 #endif /* CONFIG_WPS_NFC */
2558 { "ibss_rsn", wpa_cli_cmd_ibss_rsn
, NULL
,
2560 "<addr> = request RSN authentication with <addr> in IBSS" },
2562 { "sta", wpa_cli_cmd_sta
, NULL
,
2564 "<addr> = get information about an associated station (AP)" },
2565 { "all_sta", wpa_cli_cmd_all_sta
, NULL
,
2567 "= get information about all associated stations (AP)" },
2568 { "deauthenticate", wpa_cli_cmd_deauthenticate
, NULL
,
2570 "<addr> = deauthenticate a station" },
2571 { "disassociate", wpa_cli_cmd_disassociate
, NULL
,
2573 "<addr> = disassociate a station" },
2574 #endif /* CONFIG_AP */
2575 { "suspend", wpa_cli_cmd_suspend
, NULL
, cli_cmd_flag_none
,
2576 "= notification of suspend/hibernate" },
2577 { "resume", wpa_cli_cmd_resume
, NULL
, cli_cmd_flag_none
,
2578 "= notification of resume/thaw" },
2579 { "drop_sa", wpa_cli_cmd_drop_sa
, NULL
, cli_cmd_flag_none
,
2580 "= drop SA without deauth/disassoc (test command)" },
2581 { "roam", wpa_cli_cmd_roam
, wpa_cli_complete_bss
,
2583 "<addr> = roam to the specified BSS" },
2585 { "p2p_find", wpa_cli_cmd_p2p_find
, wpa_cli_complete_p2p_find
,
2587 "[timeout] [type=*] = find P2P Devices for up-to timeout seconds" },
2588 { "p2p_stop_find", wpa_cli_cmd_p2p_stop_find
, NULL
, cli_cmd_flag_none
,
2589 "= stop P2P Devices search" },
2590 { "p2p_connect", wpa_cli_cmd_p2p_connect
, wpa_cli_complete_p2p_connect
,
2592 "<addr> <\"pbc\"|PIN> [ht40] = connect to a P2P Device" },
2593 { "p2p_listen", wpa_cli_cmd_p2p_listen
, NULL
, cli_cmd_flag_none
,
2594 "[timeout] = listen for P2P Devices for up-to timeout seconds" },
2595 { "p2p_group_remove", wpa_cli_cmd_p2p_group_remove
,
2596 wpa_cli_complete_p2p_group_remove
, cli_cmd_flag_none
,
2597 "<ifname> = remove P2P group interface (terminate group if GO)" },
2598 { "p2p_group_add", wpa_cli_cmd_p2p_group_add
, NULL
, cli_cmd_flag_none
,
2599 "[ht40] = add a new P2P group (local end as GO)" },
2600 { "p2p_prov_disc", wpa_cli_cmd_p2p_prov_disc
,
2601 wpa_cli_complete_p2p_peer
, cli_cmd_flag_none
,
2602 "<addr> <method> = request provisioning discovery" },
2603 { "p2p_get_passphrase", wpa_cli_cmd_p2p_get_passphrase
, NULL
,
2605 "= get the passphrase for a group (GO only)" },
2606 { "p2p_serv_disc_req", wpa_cli_cmd_p2p_serv_disc_req
,
2607 wpa_cli_complete_p2p_peer
, cli_cmd_flag_none
,
2608 "<addr> <TLVs> = schedule service discovery request" },
2609 { "p2p_serv_disc_cancel_req", wpa_cli_cmd_p2p_serv_disc_cancel_req
,
2610 NULL
, cli_cmd_flag_none
,
2611 "<id> = cancel pending service discovery request" },
2612 { "p2p_serv_disc_resp", wpa_cli_cmd_p2p_serv_disc_resp
, NULL
,
2614 "<freq> <addr> <dialog token> <TLVs> = service discovery response" },
2615 { "p2p_service_update", wpa_cli_cmd_p2p_service_update
, NULL
,
2617 "= indicate change in local services" },
2618 { "p2p_serv_disc_external", wpa_cli_cmd_p2p_serv_disc_external
, NULL
,
2620 "<external> = set external processing of service discovery" },
2621 { "p2p_service_flush", wpa_cli_cmd_p2p_service_flush
, NULL
,
2623 "= remove all stored service entries" },
2624 { "p2p_service_add", wpa_cli_cmd_p2p_service_add
, NULL
,
2626 "<bonjour|upnp> <query|version> <response|service> = add a local "
2628 { "p2p_service_del", wpa_cli_cmd_p2p_service_del
, NULL
,
2630 "<bonjour|upnp> <query|version> [|service] = remove a local "
2632 { "p2p_reject", wpa_cli_cmd_p2p_reject
, wpa_cli_complete_p2p_peer
,
2634 "<addr> = reject connection attempts from a specific peer" },
2635 { "p2p_invite", wpa_cli_cmd_p2p_invite
, NULL
,
2637 "<cmd> [peer=addr] = invite peer" },
2638 { "p2p_peers", wpa_cli_cmd_p2p_peers
, NULL
, cli_cmd_flag_none
,
2639 "[discovered] = list known (optionally, only fully discovered) P2P "
2641 { "p2p_peer", wpa_cli_cmd_p2p_peer
, wpa_cli_complete_p2p_peer
,
2643 "<address> = show information about known P2P peer" },
2644 { "p2p_set", wpa_cli_cmd_p2p_set
, NULL
, cli_cmd_flag_none
,
2645 "<field> <value> = set a P2P parameter" },
2646 { "p2p_flush", wpa_cli_cmd_p2p_flush
, NULL
, cli_cmd_flag_none
,
2647 "= flush P2P state" },
2648 { "p2p_cancel", wpa_cli_cmd_p2p_cancel
, NULL
, cli_cmd_flag_none
,
2649 "= cancel P2P group formation" },
2650 { "p2p_unauthorize", wpa_cli_cmd_p2p_unauthorize
,
2651 wpa_cli_complete_p2p_peer
, cli_cmd_flag_none
,
2652 "<address> = unauthorize a peer" },
2653 { "p2p_presence_req", wpa_cli_cmd_p2p_presence_req
, NULL
,
2655 "[<duration> <interval>] [<duration> <interval>] = request GO "
2657 { "p2p_ext_listen", wpa_cli_cmd_p2p_ext_listen
, NULL
,
2659 "[<period> <interval>] = set extended listen timing" },
2660 #endif /* CONFIG_P2P */
2661 #ifdef CONFIG_WIFI_DISPLAY
2662 { "wfd_subelem_set", wpa_cli_cmd_wfd_subelem_set
, NULL
,
2664 "<subelem> [contents] = set Wi-Fi Display subelement" },
2665 { "wfd_subelem_get", wpa_cli_cmd_wfd_subelem_get
, NULL
,
2667 "<subelem> = get Wi-Fi Display subelement" },
2668 #endif /* CONFIG_WIFI_DISPLAY */
2669 #ifdef CONFIG_INTERWORKING
2670 { "fetch_anqp", wpa_cli_cmd_fetch_anqp
, NULL
, cli_cmd_flag_none
,
2671 "= fetch ANQP information for all APs" },
2672 { "stop_fetch_anqp", wpa_cli_cmd_stop_fetch_anqp
, NULL
,
2674 "= stop fetch_anqp operation" },
2675 { "interworking_select", wpa_cli_cmd_interworking_select
, NULL
,
2677 "[auto] = perform Interworking network selection" },
2678 { "interworking_connect", wpa_cli_cmd_interworking_connect
,
2679 wpa_cli_complete_bss
, cli_cmd_flag_none
,
2680 "<BSSID> = connect using Interworking credentials" },
2681 { "anqp_get", wpa_cli_cmd_anqp_get
, wpa_cli_complete_bss
,
2683 "<addr> <info id>[,<info id>]... = request ANQP information" },
2684 { "gas_request", wpa_cli_cmd_gas_request
, wpa_cli_complete_bss
,
2686 "<addr> <AdvProtoID> [QueryReq] = GAS request" },
2687 { "gas_response_get", wpa_cli_cmd_gas_response_get
,
2688 wpa_cli_complete_bss
, cli_cmd_flag_none
,
2689 "<addr> <dialog token> [start,len] = Fetch last GAS response" },
2690 #endif /* CONFIG_INTERWORKING */
2692 { "hs20_anqp_get", wpa_cli_cmd_hs20_anqp_get
, wpa_cli_complete_bss
,
2694 "<addr> <subtype>[,<subtype>]... = request HS 2.0 ANQP information"
2696 { "nai_home_realm_list", wpa_cli_cmd_get_nai_home_realm_list
,
2697 wpa_cli_complete_bss
, cli_cmd_flag_none
,
2698 "<addr> <home realm> = get HS20 nai home realm list" },
2699 #endif /* CONFIG_HS20 */
2700 { "sta_autoconnect", wpa_cli_cmd_sta_autoconnect
, NULL
,
2702 "<0/1> = disable/enable automatic reconnection" },
2703 { "tdls_discover", wpa_cli_cmd_tdls_discover
, NULL
,
2705 "<addr> = request TDLS discovery with <addr>" },
2706 { "tdls_setup", wpa_cli_cmd_tdls_setup
, NULL
,
2708 "<addr> = request TDLS setup with <addr>" },
2709 { "tdls_teardown", wpa_cli_cmd_tdls_teardown
, NULL
,
2711 "<addr> = tear down TDLS with <addr>" },
2712 { "signal_poll", wpa_cli_cmd_signal_poll
, NULL
,
2714 "= get signal parameters" },
2715 { "pktcnt_poll", wpa_cli_cmd_pktcnt_poll
, NULL
,
2717 "= get TX/RX packet counters" },
2718 { "reauthenticate", wpa_cli_cmd_reauthenticate
, NULL
,
2720 "= trigger IEEE 802.1X/EAPOL reauthentication" },
2721 #ifdef CONFIG_AUTOSCAN
2722 { "autoscan", wpa_cli_cmd_autoscan
, NULL
, cli_cmd_flag_none
,
2723 "[params] = Set or unset (if none) autoscan parameters" },
2724 #endif /* CONFIG_AUTOSCAN */
2726 { "wnm_sleep", wpa_cli_cmd_wnm_sleep
, NULL
, cli_cmd_flag_none
,
2727 "<enter/exit> [interval=#] = enter/exit WNM-Sleep mode" },
2728 #endif /* CONFIG_WNM */
2729 { "raw", wpa_cli_cmd_raw
, NULL
, cli_cmd_flag_sensitive
,
2730 "<params..> = Sent unprocessed command" },
2731 { "flush", wpa_cli_cmd_flush
, NULL
, cli_cmd_flag_none
,
2732 "= flush wpa_supplicant state" },
2733 { NULL
, NULL
, NULL
, cli_cmd_flag_none
, NULL
}
2738 * Prints command usage, lines are padded with the specified string.
2740 static void print_cmd_help(struct wpa_cli_cmd
*cmd
, const char *pad
)
2745 printf("%s%s ", pad
, cmd
->cmd
);
2746 for (n
= 0; (c
= cmd
->usage
[n
]); n
++) {
2755 static void print_help(const char *cmd
)
2758 printf("commands:\n");
2759 for (n
= 0; wpa_cli_commands
[n
].cmd
; n
++) {
2760 if (cmd
== NULL
|| str_starts(wpa_cli_commands
[n
].cmd
, cmd
))
2761 print_cmd_help(&wpa_cli_commands
[n
], " ");
2766 static int wpa_cli_edit_filter_history_cb(void *ctx
, const char *cmd
)
2768 const char *c
, *delim
;
2772 delim
= os_strchr(cmd
, ' ');
2776 len
= os_strlen(cmd
);
2778 for (n
= 0; (c
= wpa_cli_commands
[n
].cmd
); n
++) {
2779 if (os_strncasecmp(cmd
, c
, len
) == 0 && len
== os_strlen(c
))
2780 return (wpa_cli_commands
[n
].flags
&
2781 cli_cmd_flag_sensitive
);
2787 static char ** wpa_list_cmd_list(void)
2792 count
= sizeof(wpa_cli_commands
) / sizeof(wpa_cli_commands
[0]);
2793 res
= os_calloc(count
, sizeof(char *));
2797 for (i
= 0; wpa_cli_commands
[i
].cmd
; i
++) {
2798 res
[i
] = os_strdup(wpa_cli_commands
[i
].cmd
);
2807 static char ** wpa_cli_cmd_completion(const char *cmd
, const char *str
,
2812 for (i
= 0; wpa_cli_commands
[i
].cmd
; i
++) {
2813 if (os_strcasecmp(wpa_cli_commands
[i
].cmd
, cmd
) == 0) {
2814 if (wpa_cli_commands
[i
].completion
)
2815 return wpa_cli_commands
[i
].completion(str
,
2818 printf("\r%s\n", wpa_cli_commands
[i
].usage
);
2828 static char ** wpa_cli_edit_completion_cb(void *ctx
, const char *str
, int pos
)
2834 end
= os_strchr(str
, ' ');
2835 if (end
== NULL
|| str
+ pos
< end
)
2836 return wpa_list_cmd_list();
2838 cmd
= os_malloc(pos
+ 1);
2841 os_memcpy(cmd
, str
, pos
);
2842 cmd
[end
- str
] = '\0';
2843 res
= wpa_cli_cmd_completion(cmd
, str
, pos
);
2849 static int wpa_request(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2851 struct wpa_cli_cmd
*cmd
, *match
= NULL
;
2856 cmd
= wpa_cli_commands
;
2858 if (os_strncasecmp(cmd
->cmd
, argv
[0], os_strlen(argv
[0])) == 0)
2861 if (os_strcasecmp(cmd
->cmd
, argv
[0]) == 0) {
2862 /* we have an exact match */
2872 printf("Ambiguous command '%s'; possible commands:", argv
[0]);
2873 cmd
= wpa_cli_commands
;
2875 if (os_strncasecmp(cmd
->cmd
, argv
[0],
2876 os_strlen(argv
[0])) == 0) {
2877 printf(" %s", cmd
->cmd
);
2883 } else if (count
== 0) {
2884 printf("Unknown command '%s'\n", argv
[0]);
2887 ret
= match
->handler(ctrl
, argc
- 1, &argv
[1]);
2894 static int str_match(const char *a
, const char *b
)
2896 return os_strncmp(a
, b
, os_strlen(b
)) == 0;
2900 static int wpa_cli_exec(const char *program
, const char *arg1
,
2908 len
= os_strlen(program
) + os_strlen(arg1
) + os_strlen(arg2
) + 3;
2909 cmd
= os_malloc(len
);
2912 res
= os_snprintf(cmd
, len
, "%s %s %s", program
, arg1
, arg2
);
2913 if (res
< 0 || (size_t) res
>= len
) {
2917 cmd
[len
- 1] = '\0';
2919 if (system(cmd
) < 0)
2921 #endif /* _WIN32_WCE */
2928 static void wpa_cli_action_process(const char *msg
)
2931 char *copy
= NULL
, *id
, *pos2
;
2936 pos
= os_strchr(pos
, '>');
2943 if (str_match(pos
, WPA_EVENT_CONNECTED
)) {
2945 os_unsetenv("WPA_ID");
2946 os_unsetenv("WPA_ID_STR");
2947 os_unsetenv("WPA_CTRL_DIR");
2949 pos
= os_strstr(pos
, "[id=");
2951 copy
= os_strdup(pos
+ 4);
2955 while (*pos2
&& *pos2
!= ' ')
2959 os_setenv("WPA_ID", id
, 1);
2960 while (*pos2
&& *pos2
!= '=')
2965 while (*pos2
&& *pos2
!= ']')
2968 os_setenv("WPA_ID_STR", id
, 1);
2972 os_setenv("WPA_CTRL_DIR", ctrl_iface_dir
, 1);
2974 if (!wpa_cli_connected
|| new_id
!= wpa_cli_last_id
) {
2975 wpa_cli_connected
= 1;
2976 wpa_cli_last_id
= new_id
;
2977 wpa_cli_exec(action_file
, ctrl_ifname
, "CONNECTED");
2979 } else if (str_match(pos
, WPA_EVENT_DISCONNECTED
)) {
2980 if (wpa_cli_connected
) {
2981 wpa_cli_connected
= 0;
2982 wpa_cli_exec(action_file
, ctrl_ifname
, "DISCONNECTED");
2984 } else if (str_match(pos
, P2P_EVENT_GROUP_STARTED
)) {
2985 wpa_cli_exec(action_file
, ctrl_ifname
, pos
);
2986 } else if (str_match(pos
, P2P_EVENT_GROUP_REMOVED
)) {
2987 wpa_cli_exec(action_file
, ctrl_ifname
, pos
);
2988 } else if (str_match(pos
, P2P_EVENT_CROSS_CONNECT_ENABLE
)) {
2989 wpa_cli_exec(action_file
, ctrl_ifname
, pos
);
2990 } else if (str_match(pos
, P2P_EVENT_CROSS_CONNECT_DISABLE
)) {
2991 wpa_cli_exec(action_file
, ctrl_ifname
, pos
);
2992 } else if (str_match(pos
, P2P_EVENT_GO_NEG_FAILURE
)) {
2993 wpa_cli_exec(action_file
, ctrl_ifname
, pos
);
2994 } else if (str_match(pos
, WPS_EVENT_SUCCESS
)) {
2995 wpa_cli_exec(action_file
, ctrl_ifname
, pos
);
2996 } else if (str_match(pos
, WPS_EVENT_FAIL
)) {
2997 wpa_cli_exec(action_file
, ctrl_ifname
, pos
);
2998 } else if (str_match(pos
, AP_STA_CONNECTED
)) {
2999 wpa_cli_exec(action_file
, ctrl_ifname
, pos
);
3000 } else if (str_match(pos
, AP_STA_DISCONNECTED
)) {
3001 wpa_cli_exec(action_file
, ctrl_ifname
, pos
);
3002 } else if (str_match(pos
, WPA_EVENT_TERMINATING
)) {
3003 printf("wpa_supplicant is terminating - stop monitoring\n");
3009 #ifndef CONFIG_ANSI_C_EXTRA
3010 static void wpa_cli_action_cb(char *msg
, size_t len
)
3012 wpa_cli_action_process(msg
);
3014 #endif /* CONFIG_ANSI_C_EXTRA */
3017 static void wpa_cli_reconnect(void)
3019 wpa_cli_close_connection();
3020 if (wpa_cli_open_connection(ctrl_ifname
, 1) < 0)
3025 printf("\rConnection to wpa_supplicant re-established\n");
3031 static void cli_event(const char *str
)
3033 const char *start
, *s
;
3035 start
= os_strchr(str
, '>');
3041 if (str_starts(start
, WPA_EVENT_BSS_ADDED
)) {
3042 s
= os_strchr(start
, ' ');
3045 s
= os_strchr(s
+ 1, ' ');
3048 cli_txt_list_add(&bsses
, s
+ 1);
3052 if (str_starts(start
, WPA_EVENT_BSS_REMOVED
)) {
3053 s
= os_strchr(start
, ' ');
3056 s
= os_strchr(s
+ 1, ' ');
3059 cli_txt_list_del_addr(&bsses
, s
+ 1);
3064 if (str_starts(start
, P2P_EVENT_DEVICE_FOUND
)) {
3065 s
= os_strstr(start
, " p2p_dev_addr=");
3068 cli_txt_list_add_addr(&p2p_peers
, s
+ 14);
3072 if (str_starts(start
, P2P_EVENT_DEVICE_LOST
)) {
3073 s
= os_strstr(start
, " p2p_dev_addr=");
3076 cli_txt_list_del_addr(&p2p_peers
, s
+ 14);
3080 if (str_starts(start
, P2P_EVENT_GROUP_STARTED
)) {
3081 s
= os_strchr(start
, ' ');
3084 cli_txt_list_add_word(&p2p_groups
, s
+ 1);
3088 if (str_starts(start
, P2P_EVENT_GROUP_REMOVED
)) {
3089 s
= os_strchr(start
, ' ');
3092 cli_txt_list_del_word(&p2p_groups
, s
+ 1);
3095 #endif /* CONFIG_P2P */
3099 static int check_terminating(const char *msg
)
3101 const char *pos
= msg
;
3105 pos
= os_strchr(pos
, '>');
3112 if (str_match(pos
, WPA_EVENT_TERMINATING
) && ctrl_conn
) {
3114 printf("\rConnection to wpa_supplicant lost - trying to "
3117 wpa_cli_attached
= 0;
3118 wpa_cli_close_connection();
3126 static void wpa_cli_recv_pending(struct wpa_ctrl
*ctrl
, int action_monitor
)
3128 if (ctrl_conn
== NULL
) {
3129 wpa_cli_reconnect();
3132 while (wpa_ctrl_pending(ctrl
) > 0) {
3134 size_t len
= sizeof(buf
) - 1;
3135 if (wpa_ctrl_recv(ctrl
, buf
, &len
) == 0) {
3138 wpa_cli_action_process(buf
);
3141 if (wpa_cli_show_event(buf
)) {
3143 printf("\r%s\n", buf
);
3147 if (interactive
&& check_terminating(buf
) > 0)
3151 printf("Could not read pending message.\n");
3156 if (wpa_ctrl_pending(ctrl
) < 0) {
3157 printf("Connection to wpa_supplicant lost - trying to "
3159 wpa_cli_reconnect();
3165 static int tokenize_cmd(char *cmd
, char *argv
[])
3178 if (argc
== max_args
)
3181 char *pos2
= os_strrchr(pos
, '"');
3185 while (*pos
!= '\0' && *pos
!= ' ')
3195 static void wpa_cli_ping(void *eloop_ctx
, void *timeout_ctx
)
3197 if (ctrl_conn
&& _wpa_ctrl_command(ctrl_conn
, "PING", 0)) {
3198 printf("Connection to wpa_supplicant lost - trying to "
3200 wpa_cli_close_connection();
3203 wpa_cli_reconnect();
3204 eloop_register_timeout(ping_interval
, 0, wpa_cli_ping
, NULL
, NULL
);
3208 static void wpa_cli_mon_receive(int sock
, void *eloop_ctx
, void *sock_ctx
)
3210 wpa_cli_recv_pending(mon_conn
, 0);
3214 static void wpa_cli_edit_cmd_cb(void *ctx
, char *cmd
)
3216 char *argv
[max_args
];
3218 argc
= tokenize_cmd(cmd
, argv
);
3220 wpa_request(ctrl_conn
, argc
, argv
);
3224 static void wpa_cli_edit_eof_cb(void *ctx
)
3230 static int warning_displayed
= 0;
3231 static char *hfile
= NULL
;
3232 static int edit_started
= 0;
3234 static void start_edit(void)
3239 #ifdef CONFIG_CTRL_IFACE_UDP_REMOTE
3240 ps
= wpa_ctrl_get_remote_ifname(ctrl_conn
);
3241 #endif /* CONFIG_CTRL_IFACE_UDP_REMOTE */
3243 home
= getenv("HOME");
3245 const char *fname
= ".wpa_cli_history";
3246 int hfile_len
= os_strlen(home
) + 1 + os_strlen(fname
) + 1;
3247 hfile
= os_malloc(hfile_len
);
3249 os_snprintf(hfile
, hfile_len
, "%s/%s", home
, fname
);
3252 if (edit_init(wpa_cli_edit_cmd_cb
, wpa_cli_edit_eof_cb
,
3253 wpa_cli_edit_completion_cb
, NULL
, hfile
, ps
) < 0) {
3259 eloop_register_timeout(ping_interval
, 0, wpa_cli_ping
, NULL
, NULL
);
3263 static void try_connection(void *eloop_ctx
, void *timeout_ctx
)
3265 if (ctrl_ifname
== NULL
)
3266 ctrl_ifname
= wpa_cli_get_default_ifname();
3268 if (!wpa_cli_open_connection(ctrl_ifname
, 1) == 0) {
3269 if (!warning_displayed
) {
3270 printf("Could not connect to wpa_supplicant: "
3271 "%s - re-trying\n", ctrl_ifname
);
3272 warning_displayed
= 1;
3274 eloop_register_timeout(1, 0, try_connection
, NULL
, NULL
);
3278 if (warning_displayed
)
3279 printf("Connection established.\n");
3285 static void wpa_cli_interactive(void)
3287 printf("\nInteractive mode\n\n");
3289 eloop_register_timeout(0, 0, try_connection
, NULL
, NULL
);
3291 eloop_cancel_timeout(try_connection
, NULL
, NULL
);
3293 cli_txt_list_flush(&p2p_peers
);
3294 cli_txt_list_flush(&p2p_groups
);
3295 cli_txt_list_flush(&bsses
);
3297 edit_deinit(hfile
, wpa_cli_edit_filter_history_cb
);
3299 eloop_cancel_timeout(wpa_cli_ping
, NULL
, NULL
);
3300 wpa_cli_close_connection();
3304 static void wpa_cli_action(struct wpa_ctrl
*ctrl
)
3306 #ifdef CONFIG_ANSI_C_EXTRA
3307 /* TODO: ANSI C version(?) */
3308 printf("Action processing not supported in ANSI C build.\n");
3309 #else /* CONFIG_ANSI_C_EXTRA */
3313 char buf
[256]; /* note: large enough to fit in unsolicited messages */
3316 fd
= wpa_ctrl_get_fd(ctrl
);
3318 while (!wpa_cli_quit
) {
3321 tv
.tv_sec
= ping_interval
;
3323 res
= select(fd
+ 1, &rfds
, NULL
, NULL
, &tv
);
3324 if (res
< 0 && errno
!= EINTR
) {
3329 if (FD_ISSET(fd
, &rfds
))
3330 wpa_cli_recv_pending(ctrl
, 1);
3332 /* verify that connection is still working */
3333 len
= sizeof(buf
) - 1;
3334 if (wpa_ctrl_request(ctrl
, "PING", 4, buf
, &len
,
3335 wpa_cli_action_cb
) < 0 ||
3336 len
< 4 || os_memcmp(buf
, "PONG", 4) != 0) {
3337 printf("wpa_supplicant did not reply to PING "
3338 "command - exiting\n");
3343 #endif /* CONFIG_ANSI_C_EXTRA */
3347 static void wpa_cli_cleanup(void)
3349 wpa_cli_close_connection();
3351 os_daemonize_terminate(pid_file
);
3353 os_program_deinit();
3357 static void wpa_cli_terminate(int sig
, void *ctx
)
3363 static char * wpa_cli_get_default_ifname(void)
3365 char *ifname
= NULL
;
3367 #ifdef CONFIG_CTRL_IFACE_UNIX
3368 struct dirent
*dent
;
3369 DIR *dir
= opendir(ctrl_iface_dir
);
3372 char ifprop
[PROPERTY_VALUE_MAX
];
3373 if (property_get("wifi.interface", ifprop
, NULL
) != 0) {
3374 ifname
= os_strdup(ifprop
);
3375 printf("Using interface '%s'\n", ifname
);
3378 #endif /* ANDROID */
3381 while ((dent
= readdir(dir
))) {
3382 #ifdef _DIRENT_HAVE_D_TYPE
3384 * Skip the file if it is not a socket. Also accept
3385 * DT_UNKNOWN (0) in case the C library or underlying
3386 * file system does not support d_type.
3388 if (dent
->d_type
!= DT_SOCK
&& dent
->d_type
!= DT_UNKNOWN
)
3390 #endif /* _DIRENT_HAVE_D_TYPE */
3391 if (os_strcmp(dent
->d_name
, ".") == 0 ||
3392 os_strcmp(dent
->d_name
, "..") == 0)
3394 printf("Selected interface '%s'\n", dent
->d_name
);
3395 ifname
= os_strdup(dent
->d_name
);
3399 #endif /* CONFIG_CTRL_IFACE_UNIX */
3401 #ifdef CONFIG_CTRL_IFACE_NAMED_PIPE
3402 char buf
[2048], *pos
;
3404 struct wpa_ctrl
*ctrl
;
3407 ctrl
= wpa_ctrl_open(NULL
);
3411 len
= sizeof(buf
) - 1;
3412 ret
= wpa_ctrl_request(ctrl
, "INTERFACES", 10, buf
, &len
, NULL
);
3415 pos
= os_strchr(buf
, '\n');
3418 ifname
= os_strdup(buf
);
3420 wpa_ctrl_close(ctrl
);
3421 #endif /* CONFIG_CTRL_IFACE_NAMED_PIPE */
3427 int main(int argc
, char *argv
[])
3432 const char *global
= NULL
;
3434 if (os_program_init())
3438 c
= getopt(argc
, argv
, "a:Bg:G:hi:p:P:v");
3443 action_file
= optarg
;
3452 ping_interval
= atoi(optarg
);
3458 printf("%s\n", wpa_cli_version
);
3461 os_free(ctrl_ifname
);
3462 ctrl_ifname
= os_strdup(optarg
);
3465 ctrl_iface_dir
= optarg
;
3476 interactive
= (argc
== optind
) && (action_file
== NULL
);
3479 printf("%s\n\n%s\n\n", wpa_cli_version
, wpa_cli_license
);
3485 #ifdef CONFIG_CTRL_IFACE_NAMED_PIPE
3486 ctrl_conn
= wpa_ctrl_open(NULL
);
3487 #else /* CONFIG_CTRL_IFACE_NAMED_PIPE */
3488 ctrl_conn
= wpa_ctrl_open(global
);
3489 #endif /* CONFIG_CTRL_IFACE_NAMED_PIPE */
3490 if (ctrl_conn
== NULL
) {
3491 fprintf(stderr
, "Failed to connect to wpa_supplicant "
3492 "global interface: %s error: %s\n",
3493 global
, strerror(errno
));
3498 eloop_register_signal_terminate(wpa_cli_terminate
, NULL
);
3500 if (ctrl_ifname
== NULL
)
3501 ctrl_ifname
= wpa_cli_get_default_ifname();
3504 wpa_cli_interactive();
3507 wpa_cli_open_connection(ctrl_ifname
, 0) < 0) {
3508 fprintf(stderr
, "Failed to connect to non-global "
3509 "ctrl_ifname: %s error: %s\n",
3510 ctrl_ifname
, strerror(errno
));
3515 if (wpa_ctrl_attach(ctrl_conn
) == 0) {
3516 wpa_cli_attached
= 1;
3518 printf("Warning: Failed to attach to "
3519 "wpa_supplicant.\n");
3524 if (daemonize
&& os_daemonize(pid_file
))
3528 wpa_cli_action(ctrl_conn
);
3530 ret
= wpa_request(ctrl_conn
, argc
- optind
,
3534 os_free(ctrl_ifname
);
3541 #else /* CONFIG_CTRL_IFACE */
3542 int main(int argc
, char *argv
[])
3544 printf("CONFIG_CTRL_IFACE not defined - wpa_cli disabled\n");
3547 #endif /* CONFIG_CTRL_IFACE */