2 * WPA Supplicant - command line interface for wpa_supplicant daemon
3 * Copyright (c) 2004-2016, 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 *const wpa_cli_version =
30 "wpa_cli v" VERSION_STR "\n"
31 "Copyright (c) 2004-2016, Jouni Malinen <j@w1.fi> and contributors";
34 static const char *const 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 *const 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 #define VENDOR_ELEM_FRAME_ID \
70 " 0: Probe Req (P2P), 1: Probe Resp (P2P) , 2: Probe Resp (GO), " \
71 "3: Beacon (GO), 4: PD Req, 5: PD Resp, 6: GO Neg Req, " \
72 "7: GO Neg Resp, 8: GO Neg Conf, 9: Inv Req, 10: Inv Resp, " \
73 "11: Assoc Req (P2P), 12: Assoc Resp (P2P)"
75 static struct wpa_ctrl *ctrl_conn;
76 static struct wpa_ctrl *mon_conn;
77 static int wpa_cli_quit = 0;
78 static int wpa_cli_attached = 0;
79 static int wpa_cli_connected = -1;
80 static int wpa_cli_last_id = 0;
81 #ifndef CONFIG_CTRL_IFACE_DIR
82 #define CONFIG_CTRL_IFACE_DIR "/var/run/wpa_supplicant"
83 #endif /* CONFIG_CTRL_IFACE_DIR */
84 static const char *ctrl_iface_dir = CONFIG_CTRL_IFACE_DIR;
85 static const char *client_socket_dir = NULL;
86 static char *ctrl_ifname = NULL;
87 static const char *pid_file = NULL;
88 static const char *action_file = NULL;
89 static int ping_interval = 5;
90 static int interactive = 0;
91 static char *ifname_prefix = NULL;
93 struct cli_txt_entry {
98 static DEFINE_DL_LIST(bsses); /* struct cli_txt_entry */
99 static DEFINE_DL_LIST(p2p_peers); /* struct cli_txt_entry */
100 static DEFINE_DL_LIST(p2p_groups); /* struct cli_txt_entry */
101 static DEFINE_DL_LIST(ifnames); /* struct cli_txt_entry */
102 static DEFINE_DL_LIST(networks); /* struct cli_txt_entry */
105 static void print_help(const char *cmd);
106 static void wpa_cli_mon_receive(int sock, void *eloop_ctx, void *sock_ctx);
107 static void wpa_cli_close_connection(void);
108 static char * wpa_cli_get_default_ifname(void);
109 static char ** wpa_list_cmd_list(void);
110 static void update_networks(struct wpa_ctrl *ctrl);
113 static void usage(void)
115 printf("wpa_cli [-p<path to ctrl sockets>] [-i<ifname>] [-hvB] "
116 "[-a<action file>] \\\n"
117 " [-P<pid file>] [-g<global ctrl>] [-G<ping interval>] "
119 " [-s<wpa_client_socket_file_path>] "
121 " -h = help (show this usage text)\n"
122 " -v = shown version information\n"
123 " -a = run in daemon mode executing the action file based on "
126 " -B = run a daemon in the background\n"
127 " default path: " CONFIG_CTRL_IFACE_DIR "\n"
128 " default interface: first interface found in socket path\n");
133 static void cli_txt_list_free(struct cli_txt_entry *e)
135 dl_list_del(&e->list);
141 static void cli_txt_list_flush(struct dl_list *list)
143 struct cli_txt_entry *e;
144 while ((e = dl_list_first(list, struct cli_txt_entry, list)))
145 cli_txt_list_free(e);
149 static struct cli_txt_entry * cli_txt_list_get(struct dl_list *txt_list,
152 struct cli_txt_entry *e;
153 dl_list_for_each(e, txt_list, struct cli_txt_entry, list) {
154 if (os_strcmp(e->txt, txt) == 0)
161 static void cli_txt_list_del(struct dl_list *txt_list, const char *txt)
163 struct cli_txt_entry *e;
164 e = cli_txt_list_get(txt_list, txt);
166 cli_txt_list_free(e);
170 static void cli_txt_list_del_addr(struct dl_list *txt_list, const char *txt)
174 if (hwaddr_aton(txt, addr) < 0)
176 os_snprintf(buf, sizeof(buf), MACSTR, MAC2STR(addr));
177 cli_txt_list_del(txt_list, buf);
182 static void cli_txt_list_del_word(struct dl_list *txt_list, const char *txt,
187 end = os_strchr(txt, separator);
189 end = txt + os_strlen(txt);
190 buf = dup_binstr(txt, end - txt);
193 cli_txt_list_del(txt_list, buf);
196 #endif /* CONFIG_P2P */
199 static int cli_txt_list_add(struct dl_list *txt_list, const char *txt)
201 struct cli_txt_entry *e;
202 e = cli_txt_list_get(txt_list, txt);
205 e = os_zalloc(sizeof(*e));
208 e->txt = os_strdup(txt);
209 if (e->txt == NULL) {
213 dl_list_add(txt_list, &e->list);
219 static int cli_txt_list_add_addr(struct dl_list *txt_list, const char *txt)
223 if (hwaddr_aton(txt, addr) < 0)
225 os_snprintf(buf, sizeof(buf), MACSTR, MAC2STR(addr));
226 return cli_txt_list_add(txt_list, buf);
228 #endif /* CONFIG_P2P */
231 static int cli_txt_list_add_word(struct dl_list *txt_list, const char *txt,
237 end = os_strchr(txt, separator);
239 end = txt + os_strlen(txt);
240 buf = dup_binstr(txt, end - txt);
243 ret = cli_txt_list_add(txt_list, buf);
249 static char ** cli_txt_list_array(struct dl_list *txt_list)
251 unsigned int i, count = dl_list_len(txt_list);
253 struct cli_txt_entry *e;
255 res = os_calloc(count + 1, sizeof(char *));
260 dl_list_for_each(e, txt_list, struct cli_txt_entry, list) {
261 res[i] = os_strdup(e->txt);
271 static int get_cmd_arg_num(const char *str, int pos)
275 for (i = 0; i <= pos; i++) {
278 while (i <= pos && str[i] != ' ')
289 static int str_starts(const char *src, const char *match)
291 return os_strncmp(src, match, os_strlen(match)) == 0;
295 static int wpa_cli_show_event(const char *event)
299 start = os_strchr(event, '>');
305 * Skip BSS added/removed events since they can be relatively frequent
306 * and are likely of not much use for an interactive user.
308 if (str_starts(start, WPA_EVENT_BSS_ADDED) ||
309 str_starts(start, WPA_EVENT_BSS_REMOVED))
316 static int wpa_cli_open_connection(const char *ifname, int attach)
318 #if defined(CONFIG_CTRL_IFACE_UDP) || defined(CONFIG_CTRL_IFACE_NAMED_PIPE)
319 ctrl_conn = wpa_ctrl_open(ifname);
320 if (ctrl_conn == NULL)
323 if (attach && interactive)
324 mon_conn = wpa_ctrl_open(ifname);
327 #else /* CONFIG_CTRL_IFACE_UDP || CONFIG_CTRL_IFACE_NAMED_PIPE */
335 if (access(ctrl_iface_dir, F_OK) < 0) {
336 cfile = os_strdup(ifname);
342 if (client_socket_dir && client_socket_dir[0] &&
343 access(client_socket_dir, F_OK) < 0) {
344 perror(client_socket_dir);
350 flen = os_strlen(ctrl_iface_dir) + os_strlen(ifname) + 2;
351 cfile = os_malloc(flen);
354 res = os_snprintf(cfile, flen, "%s/%s", ctrl_iface_dir,
356 if (os_snprintf_error(flen, res)) {
362 ctrl_conn = wpa_ctrl_open2(cfile, client_socket_dir);
363 if (ctrl_conn == NULL) {
368 if (attach && interactive)
369 mon_conn = wpa_ctrl_open2(cfile, client_socket_dir);
373 #endif /* CONFIG_CTRL_IFACE_UDP || CONFIG_CTRL_IFACE_NAMED_PIPE */
376 if (wpa_ctrl_attach(mon_conn) == 0) {
377 wpa_cli_attached = 1;
379 eloop_register_read_sock(
380 wpa_ctrl_get_fd(mon_conn),
381 wpa_cli_mon_receive, NULL, NULL);
383 printf("Warning: Failed to attach to "
384 "wpa_supplicant.\n");
385 wpa_cli_close_connection();
394 static void wpa_cli_close_connection(void)
396 if (ctrl_conn == NULL)
399 if (wpa_cli_attached) {
400 wpa_ctrl_detach(interactive ? mon_conn : ctrl_conn);
401 wpa_cli_attached = 0;
403 wpa_ctrl_close(ctrl_conn);
406 eloop_unregister_read_sock(wpa_ctrl_get_fd(mon_conn));
407 wpa_ctrl_close(mon_conn);
413 static void wpa_cli_msg_cb(char *msg, size_t len)
419 static int _wpa_ctrl_command(struct wpa_ctrl *ctrl, char *cmd, int print)
425 if (ctrl_conn == NULL) {
426 printf("Not connected to wpa_supplicant - command dropped.\n");
430 os_snprintf(buf, sizeof(buf), "IFNAME=%s %s",
432 buf[sizeof(buf) - 1] = '\0';
435 len = sizeof(buf) - 1;
436 ret = wpa_ctrl_request(ctrl, cmd, os_strlen(cmd), buf, &len,
439 printf("'%s' command timed out.\n", cmd);
441 } else if (ret < 0) {
442 printf("'%s' command failed.\n", cmd);
448 if (interactive && len > 0 && buf[len - 1] != '\n')
455 static int wpa_ctrl_command(struct wpa_ctrl *ctrl, char *cmd)
457 return _wpa_ctrl_command(ctrl, cmd, 1);
461 static int write_cmd(char *buf, size_t buflen, const char *cmd, int argc,
470 res = os_snprintf(pos, end - pos, "%s", cmd);
471 if (os_snprintf_error(end - pos, res))
475 for (i = 0; i < argc; i++) {
476 res = os_snprintf(pos, end - pos, " %s", argv[i]);
477 if (os_snprintf_error(end - pos, res))
482 buf[buflen - 1] = '\0';
486 printf("Too long command\n");
491 static int wpa_cli_cmd(struct wpa_ctrl *ctrl, const char *cmd, int min_args,
492 int argc, char *argv[])
495 if (argc < min_args) {
496 printf("Invalid %s command - at least %d argument%s "
497 "required.\n", cmd, min_args,
498 min_args > 1 ? "s are" : " is");
501 if (write_cmd(buf, sizeof(buf), cmd, argc, argv) < 0)
503 return wpa_ctrl_command(ctrl, buf);
507 static int wpa_cli_cmd_ifname(struct wpa_ctrl *ctrl, int argc, char *argv[])
509 return wpa_ctrl_command(ctrl, "IFNAME");
513 static int wpa_cli_cmd_status(struct wpa_ctrl *ctrl, int argc, char *argv[])
515 if (argc > 0 && os_strcmp(argv[0], "verbose") == 0)
516 return wpa_ctrl_command(ctrl, "STATUS-VERBOSE");
517 if (argc > 0 && os_strcmp(argv[0], "wps") == 0)
518 return wpa_ctrl_command(ctrl, "STATUS-WPS");
519 if (argc > 0 && os_strcmp(argv[0], "driver") == 0)
520 return wpa_ctrl_command(ctrl, "STATUS-DRIVER");
522 if (argc > 0 && os_strcmp(argv[0], "no_events") == 0)
523 return wpa_ctrl_command(ctrl, "STATUS-NO_EVENTS");
525 return wpa_ctrl_command(ctrl, "STATUS");
529 static int wpa_cli_cmd_ping(struct wpa_ctrl *ctrl, int argc, char *argv[])
531 return wpa_ctrl_command(ctrl, "PING");
535 static int wpa_cli_cmd_relog(struct wpa_ctrl *ctrl, int argc, char *argv[])
537 return wpa_ctrl_command(ctrl, "RELOG");
541 static int wpa_cli_cmd_note(struct wpa_ctrl *ctrl, int argc, char *argv[])
543 return wpa_cli_cmd(ctrl, "NOTE", 1, argc, argv);
547 static int wpa_cli_cmd_mib(struct wpa_ctrl *ctrl, int argc, char *argv[])
549 return wpa_ctrl_command(ctrl, "MIB");
553 static int wpa_cli_cmd_pmksa(struct wpa_ctrl *ctrl, int argc, char *argv[])
555 return wpa_ctrl_command(ctrl, "PMKSA");
559 static int wpa_cli_cmd_pmksa_flush(struct wpa_ctrl *ctrl, int argc,
562 return wpa_ctrl_command(ctrl, "PMKSA_FLUSH");
566 static int wpa_cli_cmd_help(struct wpa_ctrl *ctrl, int argc, char *argv[])
568 print_help(argc > 0 ? argv[0] : NULL);
573 static char ** wpa_cli_complete_help(const char *str, int pos)
575 int arg = get_cmd_arg_num(str, pos);
580 res = wpa_list_cmd_list();
588 static int wpa_cli_cmd_license(struct wpa_ctrl *ctrl, int argc, char *argv[])
590 printf("%s\n\n%s\n", wpa_cli_version, wpa_cli_full_license);
595 static int wpa_cli_cmd_quit(struct wpa_ctrl *ctrl, int argc, char *argv[])
604 static int wpa_cli_cmd_set(struct wpa_ctrl *ctrl, int argc, char *argv[])
610 res = os_snprintf(cmd, sizeof(cmd), "SET %s ", argv[0]);
611 if (os_snprintf_error(sizeof(cmd), res)) {
612 printf("Too long SET command.\n");
615 return wpa_ctrl_command(ctrl, cmd);
618 return wpa_cli_cmd(ctrl, "SET", 2, argc, argv);
622 static char ** wpa_cli_complete_set(const char *str, int pos)
624 int arg = get_cmd_arg_num(str, pos);
625 const char *fields[] = {
627 "EAPOL::heldPeriod", "EAPOL::authPeriod", "EAPOL::startPeriod",
628 "EAPOL::maxStart", "dot11RSNAConfigPMKLifetime",
629 "dot11RSNAConfigPMKReauthThreshold", "dot11RSNAConfigSATimeout",
630 "wps_fragment_size", "wps_version_number", "ampdu",
631 "tdls_testing", "tdls_disabled", "pno", "radio_disabled",
632 "uapsd", "ps", "wifi_display", "bssid_filter", "disallow_aps",
634 /* global configuration parameters */
635 #ifdef CONFIG_CTRL_IFACE
636 "ctrl_interface", "no_ctrl_interface", "ctrl_interface_group",
637 #endif /* CONFIG_CTRL_IFACE */
638 "eapol_version", "ap_scan", "bgscan",
640 "user_mpm", "max_peer_links", "mesh_max_inactivity",
641 "dot11RSNASAERetransPeriod",
642 #endif /* CONFIG_MESH */
643 "disable_scan_offload", "fast_reauth", "opensc_engine_path",
644 "pkcs11_engine_path", "pkcs11_module_path", "openssl_ciphers",
645 "pcsc_reader", "pcsc_pin", "external_sim", "driver_param",
646 "dot11RSNAConfigPMKLifetime",
647 "dot11RSNAConfigPMKReauthThreshold",
648 "dot11RSNAConfigSATimeout",
649 #ifndef CONFIG_NO_CONFIG_WRITE
651 #endif /* CONFIG_NO_CONFIG_WRITE */
654 "uuid", "device_name", "manufacturer", "model_name",
655 "model_number", "serial_number", "device_type", "os_version",
656 "config_methods", "wps_cred_processing", "wps_vendor_ext_m1",
657 #endif /* CONFIG_WPS */
660 "p2p_listen_reg_class", "p2p_listen_channel",
661 "p2p_oper_reg_class", "p2p_oper_channel", "p2p_go_intent",
662 "p2p_ssid_postfix", "persistent_reconnect", "p2p_intra_bss",
663 "p2p_group_idle", "p2p_passphrase_len", "p2p_pref_chan",
664 "p2p_no_go_freq", "p2p_add_cli_chan",
665 "p2p_optimize_listen_chan", "p2p_go_ht40", "p2p_go_vht",
666 "p2p_disabled", "p2p_go_ctwindow", "p2p_no_group_iface",
667 "p2p_ignore_shared_freq", "ip_addr_go", "ip_addr_mask",
668 "ip_addr_start", "ip_addr_end",
669 #endif /* CONFIG_P2P */
670 "country", "bss_max_count", "bss_expiration_age",
671 "bss_expiration_scan_count", "filter_ssids", "filter_rssi",
672 "max_num_sta", "disassoc_low_ack",
675 #endif /* CONFIG_HS20 */
676 "interworking", "hessid", "access_network_type", "pbc_in_m1",
677 "autoscan", "wps_nfc_dev_pw_id", "wps_nfc_dh_pubkey",
678 "wps_nfc_dh_privkey", "wps_nfc_dev_pw", "ext_password_backend",
679 "p2p_go_max_inactivity", "auto_interworking", "okc", "pmf",
680 "sae_groups", "dtim_period", "beacon_int",
681 "ap_vendor_elements", "ignore_old_scan_res", "freq_list",
682 "scan_cur_freq", "sched_scan_interval",
683 "tdls_external_control", "osu_dir", "wowlan_triggers",
684 "p2p_search_delay", "mac_addr", "rand_addr_lifetime",
685 "preassoc_mac_addr", "key_mgmt_offload", "passive_scan",
686 "reassoc_same_bss_optim", "wps_priority"
688 int i, num_fields = ARRAY_SIZE(fields);
691 char **res = os_calloc(num_fields + 1, sizeof(char *));
694 for (i = 0; i < num_fields; i++) {
695 res[i] = os_strdup(fields[i]);
702 if (arg > 1 && os_strncasecmp(str, "set bssid_filter ", 17) == 0)
703 return cli_txt_list_array(&bsses);
708 static int wpa_cli_cmd_dump(struct wpa_ctrl *ctrl, int argc, char *argv[])
710 return wpa_ctrl_command(ctrl, "DUMP");
714 static int wpa_cli_cmd_get(struct wpa_ctrl *ctrl, int argc, char *argv[])
716 return wpa_cli_cmd(ctrl, "GET", 1, argc, argv);
720 static char ** wpa_cli_complete_get(const char *str, int pos)
722 int arg = get_cmd_arg_num(str, pos);
723 const char *fields[] = {
724 #ifdef CONFIG_CTRL_IFACE
725 "ctrl_interface", "ctrl_interface_group",
726 #endif /* CONFIG_CTRL_IFACE */
727 "eapol_version", "ap_scan",
729 "user_mpm", "max_peer_links", "mesh_max_inactivity",
730 #endif /* CONFIG_MESH */
731 "disable_scan_offload", "fast_reauth", "opensc_engine_path",
732 "pkcs11_engine_path", "pkcs11_module_path", "openssl_ciphers",
733 "pcsc_reader", "pcsc_pin", "external_sim", "driver_param",
734 "dot11RSNAConfigPMKLifetime",
735 "dot11RSNAConfigPMKReauthThreshold",
736 "dot11RSNAConfigSATimeout",
737 #ifndef CONFIG_NO_CONFIG_WRITE
739 #endif /* CONFIG_NO_CONFIG_WRITE */
741 "device_name", "manufacturer", "model_name", "model_number",
742 "serial_number", "config_methods", "wps_cred_processing",
743 #endif /* CONFIG_WPS */
745 "p2p_listen_reg_class", "p2p_listen_channel",
746 "p2p_oper_reg_class", "p2p_oper_channel", "p2p_go_intent",
747 "p2p_ssid_postfix", "persistent_reconnect", "p2p_intra_bss",
748 "p2p_group_idle", "p2p_passphrase_len", "p2p_add_cli_chan",
749 "p2p_optimize_listen_chan", "p2p_go_ht40", "p2p_go_vht",
750 "p2p_disabled", "p2p_go_ctwindow", "p2p_no_group_iface",
751 "p2p_ignore_shared_freq", "ip_addr_go", "ip_addr_mask",
752 "ip_addr_start", "ip_addr_end",
753 #endif /* CONFIG_P2P */
754 "bss_max_count", "bss_expiration_age",
755 "bss_expiration_scan_count", "filter_ssids", "filter_rssi",
756 "max_num_sta", "disassoc_low_ack",
759 #endif /* CONFIG_HS20 */
760 "interworking", "access_network_type", "pbc_in_m1", "autoscan",
761 "wps_nfc_dev_pw_id", "ext_password_backend",
762 "p2p_go_max_inactivity", "auto_interworking", "okc", "pmf",
763 "dtim_period", "beacon_int", "ignore_old_scan_res",
764 "scan_cur_freq", "sched_scan_interval",
765 "tdls_external_control", "osu_dir", "wowlan_triggers",
766 "p2p_search_delay", "mac_addr", "rand_addr_lifetime",
767 "preassoc_mac_addr", "key_mgmt_offload", "passive_scan",
768 "reassoc_same_bss_optim"
770 int i, num_fields = ARRAY_SIZE(fields);
773 char **res = os_calloc(num_fields + 1, sizeof(char *));
776 for (i = 0; i < num_fields; i++) {
777 res[i] = os_strdup(fields[i]);
788 static int wpa_cli_cmd_logoff(struct wpa_ctrl *ctrl, int argc, char *argv[])
790 return wpa_ctrl_command(ctrl, "LOGOFF");
794 static int wpa_cli_cmd_logon(struct wpa_ctrl *ctrl, int argc, char *argv[])
796 return wpa_ctrl_command(ctrl, "LOGON");
800 static int wpa_cli_cmd_reassociate(struct wpa_ctrl *ctrl, int argc,
803 return wpa_ctrl_command(ctrl, "REASSOCIATE");
807 static int wpa_cli_cmd_reattach(struct wpa_ctrl *ctrl, int argc, char *argv[])
809 return wpa_ctrl_command(ctrl, "REATTACH");
813 static int wpa_cli_cmd_preauthenticate(struct wpa_ctrl *ctrl, int argc,
816 return wpa_cli_cmd(ctrl, "PREAUTH", 1, argc, argv);
820 static int wpa_cli_cmd_ap_scan(struct wpa_ctrl *ctrl, int argc, char *argv[])
822 return wpa_cli_cmd(ctrl, "AP_SCAN", 1, argc, argv);
826 static int wpa_cli_cmd_scan_interval(struct wpa_ctrl *ctrl, int argc,
829 return wpa_cli_cmd(ctrl, "SCAN_INTERVAL", 1, argc, argv);
833 static int wpa_cli_cmd_bss_expire_age(struct wpa_ctrl *ctrl, int argc,
836 return wpa_cli_cmd(ctrl, "BSS_EXPIRE_AGE", 1, argc, argv);
840 static int wpa_cli_cmd_bss_expire_count(struct wpa_ctrl *ctrl, int argc,
843 return wpa_cli_cmd(ctrl, "BSS_EXPIRE_COUNT", 1, argc, argv);
847 static int wpa_cli_cmd_bss_flush(struct wpa_ctrl *ctrl, int argc, char *argv[])
853 res = os_snprintf(cmd, sizeof(cmd), "BSS_FLUSH 0");
855 res = os_snprintf(cmd, sizeof(cmd), "BSS_FLUSH %s", argv[0]);
856 if (os_snprintf_error(sizeof(cmd), res)) {
857 printf("Too long BSS_FLUSH command.\n");
860 return wpa_ctrl_command(ctrl, cmd);
864 static int wpa_cli_cmd_stkstart(struct wpa_ctrl *ctrl, int argc,
867 return wpa_cli_cmd(ctrl, "STKSTART", 1, argc, argv);
871 static int wpa_cli_cmd_ft_ds(struct wpa_ctrl *ctrl, int argc, char *argv[])
873 return wpa_cli_cmd(ctrl, "FT_DS", 1, argc, argv);
877 static int wpa_cli_cmd_wps_pbc(struct wpa_ctrl *ctrl, int argc, char *argv[])
879 return wpa_cli_cmd(ctrl, "WPS_PBC", 0, argc, argv);
883 static int wpa_cli_cmd_wps_pin(struct wpa_ctrl *ctrl, int argc, char *argv[])
886 printf("Invalid WPS_PIN command: need one or two arguments:\n"
887 "- BSSID: use 'any' to select any\n"
888 "- PIN: optional, used only with devices that have no "
893 return wpa_cli_cmd(ctrl, "WPS_PIN", 1, argc, argv);
897 static int wpa_cli_cmd_wps_check_pin(struct wpa_ctrl *ctrl, int argc,
900 return wpa_cli_cmd(ctrl, "WPS_CHECK_PIN", 1, argc, argv);
904 static int wpa_cli_cmd_wps_cancel(struct wpa_ctrl *ctrl, int argc,
907 return wpa_ctrl_command(ctrl, "WPS_CANCEL");
911 #ifdef CONFIG_WPS_NFC
913 static int wpa_cli_cmd_wps_nfc(struct wpa_ctrl *ctrl, int argc, char *argv[])
915 return wpa_cli_cmd(ctrl, "WPS_NFC", 0, argc, argv);
919 static int wpa_cli_cmd_wps_nfc_config_token(struct wpa_ctrl *ctrl, int argc,
922 return wpa_cli_cmd(ctrl, "WPS_NFC_CONFIG_TOKEN", 1, argc, argv);
926 static int wpa_cli_cmd_wps_nfc_token(struct wpa_ctrl *ctrl, int argc,
929 return wpa_cli_cmd(ctrl, "WPS_NFC_TOKEN", 1, argc, argv);
933 static int wpa_cli_cmd_wps_nfc_tag_read(struct wpa_ctrl *ctrl, int argc,
941 printf("Invalid 'wps_nfc_tag_read' command - one argument "
946 buflen = 18 + os_strlen(argv[0]);
947 buf = os_malloc(buflen);
950 os_snprintf(buf, buflen, "WPS_NFC_TAG_READ %s", argv[0]);
952 ret = wpa_ctrl_command(ctrl, buf);
959 static int wpa_cli_cmd_nfc_get_handover_req(struct wpa_ctrl *ctrl, int argc,
962 return wpa_cli_cmd(ctrl, "NFC_GET_HANDOVER_REQ", 2, argc, argv);
966 static int wpa_cli_cmd_nfc_get_handover_sel(struct wpa_ctrl *ctrl, int argc,
969 return wpa_cli_cmd(ctrl, "NFC_GET_HANDOVER_SEL", 2, argc, argv);
973 static int wpa_cli_cmd_nfc_report_handover(struct wpa_ctrl *ctrl, int argc,
976 return wpa_cli_cmd(ctrl, "NFC_REPORT_HANDOVER", 4, argc, argv);
979 #endif /* CONFIG_WPS_NFC */
982 static int wpa_cli_cmd_wps_reg(struct wpa_ctrl *ctrl, int argc, char *argv[])
988 res = os_snprintf(cmd, sizeof(cmd), "WPS_REG %s %s",
990 else if (argc == 5 || argc == 6) {
991 char ssid_hex[2 * SSID_MAX_LEN + 1];
992 char key_hex[2 * 64 + 1];
996 for (i = 0; i < SSID_MAX_LEN; i++) {
997 if (argv[2][i] == '\0')
999 os_snprintf(&ssid_hex[i * 2], 3, "%02x", argv[2][i]);
1004 for (i = 0; i < 64; i++) {
1005 if (argv[5][i] == '\0')
1007 os_snprintf(&key_hex[i * 2], 3, "%02x",
1012 res = os_snprintf(cmd, sizeof(cmd),
1013 "WPS_REG %s %s %s %s %s %s",
1014 argv[0], argv[1], ssid_hex, argv[3], argv[4],
1017 printf("Invalid WPS_REG command: need two arguments:\n"
1018 "- BSSID of the target AP\n"
1020 printf("Alternatively, six arguments can be used to "
1021 "reconfigure the AP:\n"
1022 "- BSSID of the target AP\n"
1025 "- new auth (OPEN, WPAPSK, WPA2PSK)\n"
1026 "- new encr (NONE, WEP, TKIP, CCMP)\n"
1031 if (os_snprintf_error(sizeof(cmd), res)) {
1032 printf("Too long WPS_REG command.\n");
1035 return wpa_ctrl_command(ctrl, cmd);
1039 static int wpa_cli_cmd_wps_ap_pin(struct wpa_ctrl *ctrl, int argc,
1042 return wpa_cli_cmd(ctrl, "WPS_AP_PIN", 1, argc, argv);
1046 static int wpa_cli_cmd_wps_er_start(struct wpa_ctrl *ctrl, int argc,
1049 return wpa_cli_cmd(ctrl, "WPS_ER_START", 0, argc, argv);
1053 static int wpa_cli_cmd_wps_er_stop(struct wpa_ctrl *ctrl, int argc,
1056 return wpa_ctrl_command(ctrl, "WPS_ER_STOP");
1061 static int wpa_cli_cmd_wps_er_pin(struct wpa_ctrl *ctrl, int argc,
1065 printf("Invalid WPS_ER_PIN command: need at least two "
1067 "- UUID: use 'any' to select any\n"
1068 "- PIN: Enrollee PIN\n"
1069 "optional: - Enrollee MAC address\n");
1073 return wpa_cli_cmd(ctrl, "WPS_ER_PIN", 2, argc, argv);
1077 static int wpa_cli_cmd_wps_er_pbc(struct wpa_ctrl *ctrl, int argc,
1080 return wpa_cli_cmd(ctrl, "WPS_ER_PBC", 1, argc, argv);
1084 static int wpa_cli_cmd_wps_er_learn(struct wpa_ctrl *ctrl, int argc,
1088 printf("Invalid WPS_ER_LEARN command: need two arguments:\n"
1089 "- UUID: specify which AP to use\n"
1094 return wpa_cli_cmd(ctrl, "WPS_ER_LEARN", 2, argc, argv);
1098 static int wpa_cli_cmd_wps_er_set_config(struct wpa_ctrl *ctrl, int argc,
1102 printf("Invalid WPS_ER_SET_CONFIG command: need two "
1104 "- UUID: specify which AP to use\n"
1105 "- Network configuration id\n");
1109 return wpa_cli_cmd(ctrl, "WPS_ER_SET_CONFIG", 2, argc, argv);
1113 static int wpa_cli_cmd_wps_er_config(struct wpa_ctrl *ctrl, int argc,
1119 if (argc == 5 || argc == 6) {
1120 char ssid_hex[2 * SSID_MAX_LEN + 1];
1121 char key_hex[2 * 64 + 1];
1125 for (i = 0; i < SSID_MAX_LEN; i++) {
1126 if (argv[2][i] == '\0')
1128 os_snprintf(&ssid_hex[i * 2], 3, "%02x", argv[2][i]);
1133 for (i = 0; i < 64; i++) {
1134 if (argv[5][i] == '\0')
1136 os_snprintf(&key_hex[i * 2], 3, "%02x",
1141 res = os_snprintf(cmd, sizeof(cmd),
1142 "WPS_ER_CONFIG %s %s %s %s %s %s",
1143 argv[0], argv[1], ssid_hex, argv[3], argv[4],
1146 printf("Invalid WPS_ER_CONFIG command: need six arguments:\n"
1150 "- new auth (OPEN, WPAPSK, WPA2PSK)\n"
1151 "- new encr (NONE, WEP, TKIP, CCMP)\n"
1156 if (os_snprintf_error(sizeof(cmd), res)) {
1157 printf("Too long WPS_ER_CONFIG command.\n");
1160 return wpa_ctrl_command(ctrl, cmd);
1164 #ifdef CONFIG_WPS_NFC
1165 static int wpa_cli_cmd_wps_er_nfc_config_token(struct wpa_ctrl *ctrl, int argc,
1169 printf("Invalid WPS_ER_NFC_CONFIG_TOKEN command: need two "
1171 "- WPS/NDEF: token format\n"
1172 "- UUID: specify which AP to use\n");
1176 return wpa_cli_cmd(ctrl, "WPS_ER_NFC_CONFIG_TOKEN", 2, argc, argv);
1178 #endif /* CONFIG_WPS_NFC */
1181 static int wpa_cli_cmd_ibss_rsn(struct wpa_ctrl *ctrl, int argc, char *argv[])
1183 return wpa_cli_cmd(ctrl, "IBSS_RSN", 1, argc, argv);
1187 static int wpa_cli_cmd_level(struct wpa_ctrl *ctrl, int argc, char *argv[])
1189 return wpa_cli_cmd(ctrl, "LEVEL", 1, argc, argv);
1193 static int wpa_cli_cmd_identity(struct wpa_ctrl *ctrl, int argc, char *argv[])
1195 char cmd[256], *pos, *end;
1199 printf("Invalid IDENTITY command: needs two arguments "
1200 "(network id and identity)\n");
1204 end = cmd + sizeof(cmd);
1206 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "IDENTITY-%s:%s",
1208 if (os_snprintf_error(end - pos, ret)) {
1209 printf("Too long IDENTITY command.\n");
1213 for (i = 2; i < argc; i++) {
1214 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
1215 if (os_snprintf_error(end - pos, ret)) {
1216 printf("Too long IDENTITY command.\n");
1222 return wpa_ctrl_command(ctrl, cmd);
1226 static int wpa_cli_cmd_password(struct wpa_ctrl *ctrl, int argc, char *argv[])
1228 char cmd[256], *pos, *end;
1232 printf("Invalid PASSWORD command: needs two arguments "
1233 "(network id and password)\n");
1237 end = cmd + sizeof(cmd);
1239 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "PASSWORD-%s:%s",
1241 if (os_snprintf_error(end - pos, ret)) {
1242 printf("Too long PASSWORD command.\n");
1246 for (i = 2; i < argc; i++) {
1247 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
1248 if (os_snprintf_error(end - pos, ret)) {
1249 printf("Too long PASSWORD command.\n");
1255 return wpa_ctrl_command(ctrl, cmd);
1259 static int wpa_cli_cmd_new_password(struct wpa_ctrl *ctrl, int argc,
1262 char cmd[256], *pos, *end;
1266 printf("Invalid NEW_PASSWORD command: needs two arguments "
1267 "(network id and password)\n");
1271 end = cmd + sizeof(cmd);
1273 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "NEW_PASSWORD-%s:%s",
1275 if (os_snprintf_error(end - pos, ret)) {
1276 printf("Too long NEW_PASSWORD command.\n");
1280 for (i = 2; i < argc; i++) {
1281 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
1282 if (os_snprintf_error(end - pos, ret)) {
1283 printf("Too long NEW_PASSWORD command.\n");
1289 return wpa_ctrl_command(ctrl, cmd);
1293 static int wpa_cli_cmd_pin(struct wpa_ctrl *ctrl, int argc, char *argv[])
1295 char cmd[256], *pos, *end;
1299 printf("Invalid PIN command: needs two arguments "
1300 "(network id and pin)\n");
1304 end = cmd + sizeof(cmd);
1306 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "PIN-%s:%s",
1308 if (os_snprintf_error(end - pos, ret)) {
1309 printf("Too long PIN command.\n");
1313 for (i = 2; i < argc; i++) {
1314 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
1315 if (os_snprintf_error(end - pos, ret)) {
1316 printf("Too long PIN command.\n");
1321 return wpa_ctrl_command(ctrl, cmd);
1325 static int wpa_cli_cmd_otp(struct wpa_ctrl *ctrl, int argc, char *argv[])
1327 char cmd[256], *pos, *end;
1331 printf("Invalid OTP command: needs two arguments (network "
1332 "id and password)\n");
1336 end = cmd + sizeof(cmd);
1338 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "OTP-%s:%s",
1340 if (os_snprintf_error(end - pos, ret)) {
1341 printf("Too long OTP command.\n");
1345 for (i = 2; i < argc; i++) {
1346 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
1347 if (os_snprintf_error(end - pos, ret)) {
1348 printf("Too long OTP command.\n");
1354 return wpa_ctrl_command(ctrl, cmd);
1358 static int wpa_cli_cmd_sim(struct wpa_ctrl *ctrl, int argc, char *argv[])
1360 char cmd[256], *pos, *end;
1364 printf("Invalid SIM command: needs two arguments "
1365 "(network id and SIM operation response)\n");
1369 end = cmd + sizeof(cmd);
1371 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "SIM-%s:%s",
1373 if (os_snprintf_error(end - pos, ret)) {
1374 printf("Too long SIM command.\n");
1378 for (i = 2; i < argc; i++) {
1379 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
1380 if (os_snprintf_error(end - pos, ret)) {
1381 printf("Too long SIM command.\n");
1386 return wpa_ctrl_command(ctrl, cmd);
1390 static int wpa_cli_cmd_passphrase(struct wpa_ctrl *ctrl, int argc,
1393 char cmd[256], *pos, *end;
1397 printf("Invalid PASSPHRASE command: needs two arguments "
1398 "(network id and passphrase)\n");
1402 end = cmd + sizeof(cmd);
1404 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "PASSPHRASE-%s:%s",
1406 if (os_snprintf_error(end - pos, ret)) {
1407 printf("Too long PASSPHRASE command.\n");
1411 for (i = 2; i < argc; i++) {
1412 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
1413 if (os_snprintf_error(end - pos, ret)) {
1414 printf("Too long PASSPHRASE command.\n");
1420 return wpa_ctrl_command(ctrl, cmd);
1424 static int wpa_cli_cmd_bssid(struct wpa_ctrl *ctrl, int argc, char *argv[])
1427 printf("Invalid BSSID command: needs two arguments (network "
1432 return wpa_cli_cmd(ctrl, "BSSID", 2, argc, argv);
1436 static int wpa_cli_cmd_blacklist(struct wpa_ctrl *ctrl, int argc, char *argv[])
1438 return wpa_cli_cmd(ctrl, "BLACKLIST", 0, argc, argv);
1442 static int wpa_cli_cmd_log_level(struct wpa_ctrl *ctrl, int argc, char *argv[])
1444 return wpa_cli_cmd(ctrl, "LOG_LEVEL", 0, argc, argv);
1448 static int wpa_cli_cmd_list_networks(struct wpa_ctrl *ctrl, int argc,
1451 return wpa_ctrl_command(ctrl, "LIST_NETWORKS");
1455 static int wpa_cli_cmd_select_network(struct wpa_ctrl *ctrl, int argc,
1458 return wpa_cli_cmd(ctrl, "SELECT_NETWORK", 1, argc, argv);
1462 static int wpa_cli_cmd_enable_network(struct wpa_ctrl *ctrl, int argc,
1465 return wpa_cli_cmd(ctrl, "ENABLE_NETWORK", 1, argc, argv);
1469 static int wpa_cli_cmd_disable_network(struct wpa_ctrl *ctrl, int argc,
1472 return wpa_cli_cmd(ctrl, "DISABLE_NETWORK", 1, argc, argv);
1476 static int wpa_cli_cmd_add_network(struct wpa_ctrl *ctrl, int argc,
1479 int res = wpa_ctrl_command(ctrl, "ADD_NETWORK");
1481 update_networks(ctrl);
1486 static int wpa_cli_cmd_remove_network(struct wpa_ctrl *ctrl, int argc,
1489 int res = wpa_cli_cmd(ctrl, "REMOVE_NETWORK", 1, argc, argv);
1491 update_networks(ctrl);
1496 static void wpa_cli_show_network_variables(void)
1498 printf("set_network variables:\n"
1499 " ssid (network name, SSID)\n"
1500 " psk (WPA passphrase or pre-shared key)\n"
1501 " key_mgmt (key management protocol)\n"
1502 " identity (EAP identity)\n"
1503 " password (EAP password)\n"
1506 "Note: Values are entered in the same format as the "
1507 "configuration file is using,\n"
1508 "i.e., strings values need to be inside double quotation "
1510 "For example: set_network 1 ssid \"network name\"\n"
1512 "Please see wpa_supplicant.conf documentation for full list "
1513 "of\navailable variables.\n");
1517 static int wpa_cli_cmd_set_network(struct wpa_ctrl *ctrl, int argc,
1521 wpa_cli_show_network_variables();
1526 printf("Invalid SET_NETWORK command: needs three arguments\n"
1527 "(network id, variable name, and value)\n");
1531 return wpa_cli_cmd(ctrl, "SET_NETWORK", 3, argc, argv);
1535 static int wpa_cli_cmd_get_network(struct wpa_ctrl *ctrl, int argc,
1539 wpa_cli_show_network_variables();
1544 printf("Invalid GET_NETWORK command: needs two arguments\n"
1545 "(network id and variable name)\n");
1549 return wpa_cli_cmd(ctrl, "GET_NETWORK", 2, argc, argv);
1553 static const char *network_fields[] = {
1554 "ssid", "scan_ssid", "bssid", "bssid_blacklist",
1555 "bssid_whitelist", "psk", "proto", "key_mgmt",
1556 "bg_scan_period", "pairwise", "group", "auth_alg", "scan_freq",
1557 "freq_list", "max_oper_chwidth",
1558 #ifdef IEEE8021X_EAPOL
1559 "eap", "identity", "anonymous_identity", "password", "ca_cert",
1560 "ca_path", "client_cert", "private_key", "private_key_passwd",
1561 "dh_file", "subject_match", "altsubject_match",
1562 "domain_suffix_match", "domain_match", "ca_cert2", "ca_path2",
1563 "client_cert2", "private_key2", "private_key2_passwd",
1564 "dh_file2", "subject_match2", "altsubject_match2",
1565 "domain_suffix_match2", "domain_match2", "phase1", "phase2",
1566 "pcsc", "pin", "engine_id", "key_id", "cert_id", "ca_cert_id",
1567 "pin2", "engine2_id", "key2_id", "cert2_id", "ca_cert2_id",
1568 "engine", "engine2", "eapol_flags", "sim_num",
1569 "openssl_ciphers", "erp",
1570 #endif /* IEEE8021X_EAPOL */
1571 "wep_key0", "wep_key1", "wep_key2", "wep_key3",
1572 "wep_tx_keyidx", "priority",
1573 #ifdef IEEE8021X_EAPOL
1574 "eap_workaround", "pac_file", "fragment_size", "ocsp",
1575 #endif /* IEEE8021X_EAPOL */
1577 "mode", "no_auto_peer",
1578 #else /* CONFIG_MESH */
1580 #endif /* CONFIG_MESH */
1581 "proactive_key_caching", "disabled", "id_str",
1582 #ifdef CONFIG_IEEE80211W
1584 #endif /* CONFIG_IEEE80211W */
1585 "peerkey", "mixed_cell", "frequency", "fixed_freq",
1587 "mesh_basic_rates", "dot11MeshMaxRetries",
1588 "dot11MeshRetryTimeout", "dot11MeshConfirmTimeout",
1589 "dot11MeshHoldingTimeout",
1590 #endif /* CONFIG_MESH */
1591 "wpa_ptk_rekey", "bgscan", "ignore_broadcast_ssid",
1593 "go_p2p_dev_addr", "p2p_client_list", "psk_list",
1594 #endif /* CONFIG_P2P */
1595 #ifdef CONFIG_HT_OVERRIDES
1596 "disable_ht", "disable_ht40", "disable_sgi", "disable_ldpc",
1597 "ht40_intolerant", "disable_max_amsdu", "ampdu_factor",
1598 "ampdu_density", "ht_mcs",
1599 #endif /* CONFIG_HT_OVERRIDES */
1600 #ifdef CONFIG_VHT_OVERRIDES
1601 "disable_vht", "vht_capa", "vht_capa_mask", "vht_rx_mcs_nss_1",
1602 "vht_rx_mcs_nss_2", "vht_rx_mcs_nss_3", "vht_rx_mcs_nss_4",
1603 "vht_rx_mcs_nss_5", "vht_rx_mcs_nss_6", "vht_rx_mcs_nss_7",
1604 "vht_rx_mcs_nss_8", "vht_tx_mcs_nss_1", "vht_tx_mcs_nss_2",
1605 "vht_tx_mcs_nss_3", "vht_tx_mcs_nss_4", "vht_tx_mcs_nss_5",
1606 "vht_tx_mcs_nss_6", "vht_tx_mcs_nss_7", "vht_tx_mcs_nss_8",
1607 #endif /* CONFIG_VHT_OVERRIDES */
1608 "ap_max_inactivity", "dtim_period", "beacon_int",
1609 #ifdef CONFIG_MACSEC
1611 #endif /* CONFIG_MACSEC */
1613 "update_identifier",
1614 #endif /* CONFIG_HS20 */
1615 "mac_addr", "pbss", "wps_disabled"
1619 static char ** wpa_cli_complete_network(const char *str, int pos)
1621 int arg = get_cmd_arg_num(str, pos);
1622 int i, num_fields = ARRAY_SIZE(network_fields);
1627 res = cli_txt_list_array(&networks);
1630 res = os_calloc(num_fields + 1, sizeof(char *));
1633 for (i = 0; i < num_fields; i++) {
1634 res[i] = os_strdup(network_fields[i]);
1643 static char ** wpa_cli_complete_network_id(const char *str, int pos)
1645 int arg = get_cmd_arg_num(str, pos);
1647 return cli_txt_list_array(&networks);
1652 static int wpa_cli_cmd_dup_network(struct wpa_ctrl *ctrl, int argc,
1656 wpa_cli_show_network_variables();
1661 printf("Invalid DUP_NETWORK command: needs three arguments\n"
1662 "(src netid, dest netid, and variable name)\n");
1666 return wpa_cli_cmd(ctrl, "DUP_NETWORK", 3, argc, argv);
1670 static char ** wpa_cli_complete_dup_network(const char *str, int pos)
1672 int arg = get_cmd_arg_num(str, pos);
1673 int i, num_fields = ARRAY_SIZE(network_fields);
1679 res = cli_txt_list_array(&networks);
1682 res = os_calloc(num_fields + 1, sizeof(char *));
1685 for (i = 0; i < num_fields; i++) {
1686 res[i] = os_strdup(network_fields[i]);
1695 static int wpa_cli_cmd_list_creds(struct wpa_ctrl *ctrl, int argc,
1698 return wpa_ctrl_command(ctrl, "LIST_CREDS");
1702 static int wpa_cli_cmd_add_cred(struct wpa_ctrl *ctrl, int argc, char *argv[])
1704 return wpa_ctrl_command(ctrl, "ADD_CRED");
1708 static int wpa_cli_cmd_remove_cred(struct wpa_ctrl *ctrl, int argc,
1711 return wpa_cli_cmd(ctrl, "REMOVE_CRED", 1, argc, argv);
1715 static int wpa_cli_cmd_set_cred(struct wpa_ctrl *ctrl, int argc, char *argv[])
1718 printf("Invalid SET_CRED command: needs three arguments\n"
1719 "(cred id, variable name, and value)\n");
1723 return wpa_cli_cmd(ctrl, "SET_CRED", 3, argc, argv);
1727 static int wpa_cli_cmd_get_cred(struct wpa_ctrl *ctrl, int argc, char *argv[])
1730 printf("Invalid GET_CRED command: needs two arguments\n"
1731 "(cred id, variable name)\n");
1735 return wpa_cli_cmd(ctrl, "GET_CRED", 2, argc, argv);
1739 static int wpa_cli_cmd_disconnect(struct wpa_ctrl *ctrl, int argc,
1742 return wpa_ctrl_command(ctrl, "DISCONNECT");
1746 static int wpa_cli_cmd_reconnect(struct wpa_ctrl *ctrl, int argc,
1749 return wpa_ctrl_command(ctrl, "RECONNECT");
1753 static int wpa_cli_cmd_save_config(struct wpa_ctrl *ctrl, int argc,
1756 return wpa_ctrl_command(ctrl, "SAVE_CONFIG");
1760 static int wpa_cli_cmd_scan(struct wpa_ctrl *ctrl, int argc, char *argv[])
1762 return wpa_cli_cmd(ctrl, "SCAN", 0, argc, argv);
1766 static int wpa_cli_cmd_scan_results(struct wpa_ctrl *ctrl, int argc,
1769 return wpa_ctrl_command(ctrl, "SCAN_RESULTS");
1773 static int wpa_cli_cmd_abort_scan(struct wpa_ctrl *ctrl, int argc,
1776 return wpa_ctrl_command(ctrl, "ABORT_SCAN");
1780 static int wpa_cli_cmd_bss(struct wpa_ctrl *ctrl, int argc, char *argv[])
1782 return wpa_cli_cmd(ctrl, "BSS", 1, argc, argv);
1786 static char ** wpa_cli_complete_bss(const char *str, int pos)
1788 int arg = get_cmd_arg_num(str, pos);
1793 res = cli_txt_list_array(&bsses);
1801 static int wpa_cli_cmd_get_capability(struct wpa_ctrl *ctrl, int argc,
1804 if (argc < 1 || argc > 2) {
1805 printf("Invalid GET_CAPABILITY command: need either one or "
1810 if ((argc == 2) && os_strcmp(argv[1], "strict") != 0) {
1811 printf("Invalid GET_CAPABILITY command: second argument, "
1812 "if any, must be 'strict'\n");
1816 return wpa_cli_cmd(ctrl, "GET_CAPABILITY", 1, argc, argv);
1820 static int wpa_cli_list_interfaces(struct wpa_ctrl *ctrl)
1822 printf("Available interfaces:\n");
1823 return wpa_ctrl_command(ctrl, "INTERFACES");
1827 static int wpa_cli_cmd_interface(struct wpa_ctrl *ctrl, int argc, char *argv[])
1830 wpa_cli_list_interfaces(ctrl);
1834 wpa_cli_close_connection();
1835 os_free(ctrl_ifname);
1836 ctrl_ifname = os_strdup(argv[0]);
1838 printf("Failed to allocate memory\n");
1842 if (wpa_cli_open_connection(ctrl_ifname, 1) == 0) {
1843 printf("Connected to interface '%s.\n", ctrl_ifname);
1845 printf("Could not connect to interface '%s' - re-trying\n",
1852 static int wpa_cli_cmd_reconfigure(struct wpa_ctrl *ctrl, int argc,
1855 return wpa_ctrl_command(ctrl, "RECONFIGURE");
1859 static int wpa_cli_cmd_terminate(struct wpa_ctrl *ctrl, int argc,
1862 return wpa_ctrl_command(ctrl, "TERMINATE");
1866 static int wpa_cli_cmd_interface_add(struct wpa_ctrl *ctrl, int argc,
1873 printf("Invalid INTERFACE_ADD command: needs at least one "
1874 "argument (interface name)\n"
1875 "All arguments: ifname confname driver ctrl_interface "
1876 "driver_param bridge_name [create]\n");
1881 * INTERFACE_ADD <ifname>TAB<confname>TAB<driver>TAB<ctrl_interface>TAB
1882 * <driver_param>TAB<bridge_name>[TAB<create>[TAB<type>]]
1884 res = os_snprintf(cmd, sizeof(cmd),
1885 "INTERFACE_ADD %s\t%s\t%s\t%s\t%s\t%s\t%s\t%s",
1887 argc > 1 ? argv[1] : "", argc > 2 ? argv[2] : "",
1888 argc > 3 ? argv[3] : "", argc > 4 ? argv[4] : "",
1889 argc > 5 ? argv[5] : "", argc > 6 ? argv[6] : "",
1890 argc > 7 ? argv[7] : "");
1891 if (os_snprintf_error(sizeof(cmd), res))
1893 cmd[sizeof(cmd) - 1] = '\0';
1894 return wpa_ctrl_command(ctrl, cmd);
1898 static int wpa_cli_cmd_interface_remove(struct wpa_ctrl *ctrl, int argc,
1901 return wpa_cli_cmd(ctrl, "INTERFACE_REMOVE", 1, argc, argv);
1905 static int wpa_cli_cmd_interface_list(struct wpa_ctrl *ctrl, int argc,
1908 return wpa_ctrl_command(ctrl, "INTERFACE_LIST");
1913 static int wpa_cli_cmd_sta(struct wpa_ctrl *ctrl, int argc, char *argv[])
1915 return wpa_cli_cmd(ctrl, "STA", 1, argc, argv);
1919 static int wpa_ctrl_command_sta(struct wpa_ctrl *ctrl, char *cmd,
1920 char *addr, size_t addr_len)
1922 char buf[4096], *pos;
1926 if (ctrl_conn == NULL) {
1927 printf("Not connected to hostapd - command dropped.\n");
1930 if (ifname_prefix) {
1931 os_snprintf(buf, sizeof(buf), "IFNAME=%s %s",
1932 ifname_prefix, cmd);
1933 buf[sizeof(buf) - 1] = '\0';
1936 len = sizeof(buf) - 1;
1937 ret = wpa_ctrl_request(ctrl, cmd, os_strlen(cmd), buf, &len,
1940 printf("'%s' command timed out.\n", cmd);
1942 } else if (ret < 0) {
1943 printf("'%s' command failed.\n", cmd);
1948 if (os_memcmp(buf, "FAIL", 4) == 0)
1953 while (*pos != '\0' && *pos != '\n')
1956 os_strlcpy(addr, buf, addr_len);
1961 static int wpa_cli_cmd_all_sta(struct wpa_ctrl *ctrl, int argc, char *argv[])
1963 char addr[32], cmd[64];
1965 if (wpa_ctrl_command_sta(ctrl, "STA-FIRST", addr, sizeof(addr)))
1968 os_snprintf(cmd, sizeof(cmd), "STA-NEXT %s", addr);
1969 } while (wpa_ctrl_command_sta(ctrl, cmd, addr, sizeof(addr)) == 0);
1975 static int wpa_cli_cmd_deauthenticate(struct wpa_ctrl *ctrl, int argc,
1978 return wpa_cli_cmd(ctrl, "DEAUTHENTICATE", 1, argc, argv);
1982 static int wpa_cli_cmd_disassociate(struct wpa_ctrl *ctrl, int argc,
1985 return wpa_cli_cmd(ctrl, "DISASSOCIATE", 1, argc, argv);
1988 static int wpa_cli_cmd_chanswitch(struct wpa_ctrl *ctrl, int argc,
1991 return wpa_cli_cmd(ctrl, "CHAN_SWITCH", 2, argc, argv);
1994 #endif /* CONFIG_AP */
1997 static int wpa_cli_cmd_suspend(struct wpa_ctrl *ctrl, int argc, char *argv[])
1999 return wpa_ctrl_command(ctrl, "SUSPEND");
2003 static int wpa_cli_cmd_resume(struct wpa_ctrl *ctrl, int argc, char *argv[])
2005 return wpa_ctrl_command(ctrl, "RESUME");
2009 #ifdef CONFIG_TESTING_OPTIONS
2010 static int wpa_cli_cmd_drop_sa(struct wpa_ctrl *ctrl, int argc, char *argv[])
2012 return wpa_ctrl_command(ctrl, "DROP_SA");
2014 #endif /* CONFIG_TESTING_OPTIONS */
2017 static int wpa_cli_cmd_roam(struct wpa_ctrl *ctrl, int argc, char *argv[])
2019 return wpa_cli_cmd(ctrl, "ROAM", 1, argc, argv);
2025 static int wpa_cli_cmd_mesh_interface_add(struct wpa_ctrl *ctrl, int argc,
2028 return wpa_cli_cmd(ctrl, "MESH_INTERFACE_ADD", 0, argc, argv);
2032 static int wpa_cli_cmd_mesh_group_add(struct wpa_ctrl *ctrl, int argc,
2035 return wpa_cli_cmd(ctrl, "MESH_GROUP_ADD", 1, argc, argv);
2039 static int wpa_cli_cmd_mesh_group_remove(struct wpa_ctrl *ctrl, int argc,
2042 return wpa_cli_cmd(ctrl, "MESH_GROUP_REMOVE", 1, argc, argv);
2046 static int wpa_cli_cmd_mesh_peer_remove(struct wpa_ctrl *ctrl, int argc,
2049 return wpa_cli_cmd(ctrl, "MESH_PEER_REMOVE", 1, argc, argv);
2053 static int wpa_cli_cmd_mesh_peer_add(struct wpa_ctrl *ctrl, int argc,
2056 return wpa_cli_cmd(ctrl, "MESH_PEER_ADD", 1, argc, argv);
2059 #endif /* CONFIG_MESH */
2064 static int wpa_cli_cmd_p2p_find(struct wpa_ctrl *ctrl, int argc, char *argv[])
2066 return wpa_cli_cmd(ctrl, "P2P_FIND", 0, argc, argv);
2070 static char ** wpa_cli_complete_p2p_find(const char *str, int pos)
2073 int arg = get_cmd_arg_num(str, pos);
2075 res = os_calloc(6, sizeof(char *));
2078 res[0] = os_strdup("type=social");
2079 if (res[0] == NULL) {
2083 res[1] = os_strdup("type=progressive");
2086 res[2] = os_strdup("delay=");
2089 res[3] = os_strdup("dev_id=");
2093 res[4] = os_strdup("[timeout]");
2099 static int wpa_cli_cmd_p2p_stop_find(struct wpa_ctrl *ctrl, int argc,
2102 return wpa_ctrl_command(ctrl, "P2P_STOP_FIND");
2106 static int wpa_cli_cmd_p2p_asp_provision(struct wpa_ctrl *ctrl, int argc,
2109 return wpa_cli_cmd(ctrl, "P2P_ASP_PROVISION", 3, argc, argv);
2113 static int wpa_cli_cmd_p2p_asp_provision_resp(struct wpa_ctrl *ctrl, int argc,
2116 return wpa_cli_cmd(ctrl, "P2P_ASP_PROVISION_RESP", 2, argc, argv);
2120 static int wpa_cli_cmd_p2p_connect(struct wpa_ctrl *ctrl, int argc,
2123 return wpa_cli_cmd(ctrl, "P2P_CONNECT", 2, argc, argv);
2127 static char ** wpa_cli_complete_p2p_connect(const char *str, int pos)
2129 int arg = get_cmd_arg_num(str, pos);
2134 res = cli_txt_list_array(&p2p_peers);
2142 static int wpa_cli_cmd_p2p_listen(struct wpa_ctrl *ctrl, int argc,
2145 return wpa_cli_cmd(ctrl, "P2P_LISTEN", 0, argc, argv);
2149 static int wpa_cli_cmd_p2p_group_remove(struct wpa_ctrl *ctrl, int argc,
2152 return wpa_cli_cmd(ctrl, "P2P_GROUP_REMOVE", 1, argc, argv);
2156 static char ** wpa_cli_complete_p2p_group_remove(const char *str, int pos)
2158 int arg = get_cmd_arg_num(str, pos);
2163 res = cli_txt_list_array(&p2p_groups);
2171 static int wpa_cli_cmd_p2p_group_add(struct wpa_ctrl *ctrl, int argc,
2174 return wpa_cli_cmd(ctrl, "P2P_GROUP_ADD", 0, argc, argv);
2178 static int wpa_cli_cmd_p2p_group_member(struct wpa_ctrl *ctrl, int argc,
2181 return wpa_cli_cmd(ctrl, "P2P_GROUP_MEMBER", 1, argc, argv);
2185 static int wpa_cli_cmd_p2p_prov_disc(struct wpa_ctrl *ctrl, int argc,
2188 if (argc != 2 && argc != 3) {
2189 printf("Invalid P2P_PROV_DISC command: needs at least "
2190 "two arguments, address and config method\n"
2191 "(display, keypad, or pbc) and an optional join\n");
2195 return wpa_cli_cmd(ctrl, "P2P_PROV_DISC", 2, argc, argv);
2199 static int wpa_cli_cmd_p2p_get_passphrase(struct wpa_ctrl *ctrl, int argc,
2202 return wpa_ctrl_command(ctrl, "P2P_GET_PASSPHRASE");
2206 static int wpa_cli_cmd_p2p_serv_disc_req(struct wpa_ctrl *ctrl, int argc,
2212 printf("Invalid P2P_SERV_DISC_REQ command: needs two "
2213 "or more arguments (address and TLVs)\n");
2217 if (write_cmd(cmd, sizeof(cmd), "P2P_SERV_DISC_REQ", argc, argv) < 0)
2219 return wpa_ctrl_command(ctrl, cmd);
2223 static int wpa_cli_cmd_p2p_serv_disc_cancel_req(struct wpa_ctrl *ctrl,
2224 int argc, char *argv[])
2226 return wpa_cli_cmd(ctrl, "P2P_SERV_DISC_CANCEL_REQ", 1, argc, argv);
2230 static int wpa_cli_cmd_p2p_serv_disc_resp(struct wpa_ctrl *ctrl, int argc,
2237 printf("Invalid P2P_SERV_DISC_RESP command: needs four "
2238 "arguments (freq, address, dialog token, and TLVs)\n");
2242 res = os_snprintf(cmd, sizeof(cmd), "P2P_SERV_DISC_RESP %s %s %s %s",
2243 argv[0], argv[1], argv[2], argv[3]);
2244 if (os_snprintf_error(sizeof(cmd), res))
2246 cmd[sizeof(cmd) - 1] = '\0';
2247 return wpa_ctrl_command(ctrl, cmd);
2251 static int wpa_cli_cmd_p2p_service_update(struct wpa_ctrl *ctrl, int argc,
2254 return wpa_ctrl_command(ctrl, "P2P_SERVICE_UPDATE");
2258 static int wpa_cli_cmd_p2p_serv_disc_external(struct wpa_ctrl *ctrl,
2259 int argc, char *argv[])
2261 return wpa_cli_cmd(ctrl, "P2P_SERV_DISC_EXTERNAL", 1, argc, argv);
2265 static int wpa_cli_cmd_p2p_service_flush(struct wpa_ctrl *ctrl, int argc,
2268 return wpa_ctrl_command(ctrl, "P2P_SERVICE_FLUSH");
2272 static int wpa_cli_cmd_p2p_service_add(struct wpa_ctrl *ctrl, int argc,
2276 printf("Invalid P2P_SERVICE_ADD command: needs 3-6 arguments\n");
2280 return wpa_cli_cmd(ctrl, "P2P_SERVICE_ADD", 3, argc, argv);
2284 static int wpa_cli_cmd_p2p_service_rep(struct wpa_ctrl *ctrl, int argc,
2287 if (argc < 5 || argc > 6) {
2288 printf("Invalid P2P_SERVICE_REP command: needs 5-6 "
2293 return wpa_cli_cmd(ctrl, "P2P_SERVICE_REP", 5, argc, argv);
2297 static int wpa_cli_cmd_p2p_service_del(struct wpa_ctrl *ctrl, int argc,
2303 if (argc != 2 && argc != 3) {
2304 printf("Invalid P2P_SERVICE_DEL command: needs two or three "
2310 res = os_snprintf(cmd, sizeof(cmd),
2311 "P2P_SERVICE_DEL %s %s %s",
2312 argv[0], argv[1], argv[2]);
2314 res = os_snprintf(cmd, sizeof(cmd),
2315 "P2P_SERVICE_DEL %s %s",
2317 if (os_snprintf_error(sizeof(cmd), res))
2319 cmd[sizeof(cmd) - 1] = '\0';
2320 return wpa_ctrl_command(ctrl, cmd);
2324 static int wpa_cli_cmd_p2p_reject(struct wpa_ctrl *ctrl,
2325 int argc, char *argv[])
2327 return wpa_cli_cmd(ctrl, "P2P_REJECT", 1, argc, argv);
2331 static int wpa_cli_cmd_p2p_invite(struct wpa_ctrl *ctrl,
2332 int argc, char *argv[])
2334 return wpa_cli_cmd(ctrl, "P2P_INVITE", 1, argc, argv);
2338 static int wpa_cli_cmd_p2p_peer(struct wpa_ctrl *ctrl, int argc, char *argv[])
2340 return wpa_cli_cmd(ctrl, "P2P_PEER", 1, argc, argv);
2344 static char ** wpa_cli_complete_p2p_peer(const char *str, int pos)
2346 int arg = get_cmd_arg_num(str, pos);
2351 res = cli_txt_list_array(&p2p_peers);
2359 static int wpa_ctrl_command_p2p_peer(struct wpa_ctrl *ctrl, char *cmd,
2360 char *addr, size_t addr_len,
2363 char buf[4096], *pos;
2367 if (ctrl_conn == NULL)
2369 len = sizeof(buf) - 1;
2370 ret = wpa_ctrl_request(ctrl, cmd, os_strlen(cmd), buf, &len,
2373 printf("'%s' command timed out.\n", cmd);
2375 } else if (ret < 0) {
2376 printf("'%s' command failed.\n", cmd);
2381 if (os_memcmp(buf, "FAIL", 4) == 0)
2385 while (*pos != '\0' && *pos != '\n')
2388 os_strlcpy(addr, buf, addr_len);
2389 if (!discovered || os_strstr(pos, "[PROBE_REQ_ONLY]") == NULL)
2390 printf("%s\n", addr);
2395 static int wpa_cli_cmd_p2p_peers(struct wpa_ctrl *ctrl, int argc, char *argv[])
2397 char addr[32], cmd[64];
2400 discovered = argc > 0 && os_strcmp(argv[0], "discovered") == 0;
2402 if (wpa_ctrl_command_p2p_peer(ctrl, "P2P_PEER FIRST",
2403 addr, sizeof(addr), discovered))
2406 os_snprintf(cmd, sizeof(cmd), "P2P_PEER NEXT-%s", addr);
2407 } while (wpa_ctrl_command_p2p_peer(ctrl, cmd, addr, sizeof(addr),
2414 static int wpa_cli_cmd_p2p_set(struct wpa_ctrl *ctrl, int argc, char *argv[])
2416 return wpa_cli_cmd(ctrl, "P2P_SET", 2, argc, argv);
2420 static char ** wpa_cli_complete_p2p_set(const char *str, int pos)
2422 int arg = get_cmd_arg_num(str, pos);
2423 const char *fields[] = {
2443 int i, num_fields = ARRAY_SIZE(fields);
2446 char **res = os_calloc(num_fields + 1, sizeof(char *));
2449 for (i = 0; i < num_fields; i++) {
2450 res[i] = os_strdup(fields[i]);
2457 if (arg == 2 && os_strncasecmp(str, "p2p_set peer_filter ", 20) == 0)
2458 return cli_txt_list_array(&p2p_peers);
2464 static int wpa_cli_cmd_p2p_flush(struct wpa_ctrl *ctrl, int argc, char *argv[])
2466 return wpa_ctrl_command(ctrl, "P2P_FLUSH");
2470 static int wpa_cli_cmd_p2p_cancel(struct wpa_ctrl *ctrl, int argc,
2473 return wpa_ctrl_command(ctrl, "P2P_CANCEL");
2477 static int wpa_cli_cmd_p2p_unauthorize(struct wpa_ctrl *ctrl, int argc,
2480 return wpa_cli_cmd(ctrl, "P2P_UNAUTHORIZE", 1, argc, argv);
2484 static int wpa_cli_cmd_p2p_presence_req(struct wpa_ctrl *ctrl, int argc,
2487 if (argc != 0 && argc != 2 && argc != 4) {
2488 printf("Invalid P2P_PRESENCE_REQ command: needs two arguments "
2489 "(preferred duration, interval; in microsecods).\n"
2490 "Optional second pair can be used to provide "
2491 "acceptable values.\n");
2495 return wpa_cli_cmd(ctrl, "P2P_PRESENCE_REQ", 0, argc, argv);
2499 static int wpa_cli_cmd_p2p_ext_listen(struct wpa_ctrl *ctrl, int argc,
2502 if (argc != 0 && argc != 2) {
2503 printf("Invalid P2P_EXT_LISTEN command: needs two arguments "
2504 "(availability period, availability interval; in "
2506 "Extended Listen Timing can be cancelled with this "
2507 "command when used without parameters.\n");
2511 return wpa_cli_cmd(ctrl, "P2P_EXT_LISTEN", 0, argc, argv);
2515 static int wpa_cli_cmd_p2p_remove_client(struct wpa_ctrl *ctrl, int argc,
2518 return wpa_cli_cmd(ctrl, "P2P_REMOVE_CLIENT", 1, argc, argv);
2522 static int wpa_cli_cmd_vendor_elem_add(struct wpa_ctrl *ctrl, int argc,
2525 return wpa_cli_cmd(ctrl, "VENDOR_ELEM_ADD", 2, argc, argv);
2529 static int wpa_cli_cmd_vendor_elem_get(struct wpa_ctrl *ctrl, int argc,
2532 return wpa_cli_cmd(ctrl, "VENDOR_ELEM_GET", 1, argc, argv);
2536 static int wpa_cli_cmd_vendor_elem_remove(struct wpa_ctrl *ctrl, int argc,
2539 return wpa_cli_cmd(ctrl, "VENDOR_ELEM_REMOVE", 2, argc, argv);
2542 #endif /* CONFIG_P2P */
2544 #ifdef CONFIG_WIFI_DISPLAY
2546 static int wpa_cli_cmd_wfd_subelem_set(struct wpa_ctrl *ctrl, int argc,
2552 if (argc != 1 && argc != 2) {
2553 printf("Invalid WFD_SUBELEM_SET command: needs one or two "
2554 "arguments (subelem, hexdump)\n");
2558 res = os_snprintf(cmd, sizeof(cmd), "WFD_SUBELEM_SET %s %s",
2559 argv[0], argc > 1 ? argv[1] : "");
2560 if (os_snprintf_error(sizeof(cmd), res))
2562 cmd[sizeof(cmd) - 1] = '\0';
2563 return wpa_ctrl_command(ctrl, cmd);
2567 static int wpa_cli_cmd_wfd_subelem_get(struct wpa_ctrl *ctrl, int argc,
2574 printf("Invalid WFD_SUBELEM_GET command: needs one "
2575 "argument (subelem)\n");
2579 res = os_snprintf(cmd, sizeof(cmd), "WFD_SUBELEM_GET %s",
2581 if (os_snprintf_error(sizeof(cmd), res))
2583 cmd[sizeof(cmd) - 1] = '\0';
2584 return wpa_ctrl_command(ctrl, cmd);
2586 #endif /* CONFIG_WIFI_DISPLAY */
2589 #ifdef CONFIG_INTERWORKING
2590 static int wpa_cli_cmd_fetch_anqp(struct wpa_ctrl *ctrl, int argc,
2593 return wpa_ctrl_command(ctrl, "FETCH_ANQP");
2597 static int wpa_cli_cmd_stop_fetch_anqp(struct wpa_ctrl *ctrl, int argc,
2600 return wpa_ctrl_command(ctrl, "STOP_FETCH_ANQP");
2604 static int wpa_cli_cmd_interworking_select(struct wpa_ctrl *ctrl, int argc,
2607 return wpa_cli_cmd(ctrl, "INTERWORKING_SELECT", 0, argc, argv);
2611 static int wpa_cli_cmd_interworking_connect(struct wpa_ctrl *ctrl, int argc,
2614 return wpa_cli_cmd(ctrl, "INTERWORKING_CONNECT", 1, argc, argv);
2618 static int wpa_cli_cmd_interworking_add_network(struct wpa_ctrl *ctrl, int argc,
2621 return wpa_cli_cmd(ctrl, "INTERWORKING_ADD_NETWORK", 1, argc, argv);
2625 static int wpa_cli_cmd_anqp_get(struct wpa_ctrl *ctrl, int argc, char *argv[])
2627 return wpa_cli_cmd(ctrl, "ANQP_GET", 2, argc, argv);
2631 static int wpa_cli_cmd_gas_request(struct wpa_ctrl *ctrl, int argc,
2634 return wpa_cli_cmd(ctrl, "GAS_REQUEST", 2, argc, argv);
2638 static int wpa_cli_cmd_gas_response_get(struct wpa_ctrl *ctrl, int argc,
2641 return wpa_cli_cmd(ctrl, "GAS_RESPONSE_GET", 2, argc, argv);
2643 #endif /* CONFIG_INTERWORKING */
2648 static int wpa_cli_cmd_hs20_anqp_get(struct wpa_ctrl *ctrl, int argc,
2651 return wpa_cli_cmd(ctrl, "HS20_ANQP_GET", 2, argc, argv);
2655 static int wpa_cli_cmd_get_nai_home_realm_list(struct wpa_ctrl *ctrl, int argc,
2661 printf("Command needs one or two arguments (dst mac addr and "
2662 "optional home realm)\n");
2666 if (write_cmd(cmd, sizeof(cmd), "HS20_GET_NAI_HOME_REALM_LIST",
2670 return wpa_ctrl_command(ctrl, cmd);
2674 static int wpa_cli_cmd_hs20_icon_request(struct wpa_ctrl *ctrl, int argc,
2680 printf("Command needs two arguments (dst mac addr and "
2685 if (write_cmd(cmd, sizeof(cmd), "HS20_ICON_REQUEST", argc, argv) < 0)
2688 return wpa_ctrl_command(ctrl, cmd);
2692 static int wpa_cli_cmd_fetch_osu(struct wpa_ctrl *ctrl, int argc, char *argv[])
2694 return wpa_ctrl_command(ctrl, "FETCH_OSU");
2698 static int wpa_cli_cmd_cancel_fetch_osu(struct wpa_ctrl *ctrl, int argc,
2701 return wpa_ctrl_command(ctrl, "CANCEL_FETCH_OSU");
2704 #endif /* CONFIG_HS20 */
2707 static int wpa_cli_cmd_sta_autoconnect(struct wpa_ctrl *ctrl, int argc,
2710 return wpa_cli_cmd(ctrl, "STA_AUTOCONNECT", 1, argc, argv);
2714 static int wpa_cli_cmd_tdls_discover(struct wpa_ctrl *ctrl, int argc,
2717 return wpa_cli_cmd(ctrl, "TDLS_DISCOVER", 1, argc, argv);
2721 static int wpa_cli_cmd_tdls_setup(struct wpa_ctrl *ctrl, int argc,
2724 return wpa_cli_cmd(ctrl, "TDLS_SETUP", 1, argc, argv);
2728 static int wpa_cli_cmd_tdls_teardown(struct wpa_ctrl *ctrl, int argc,
2731 return wpa_cli_cmd(ctrl, "TDLS_TEARDOWN", 1, argc, argv);
2735 static int wpa_cli_cmd_tdls_link_status(struct wpa_ctrl *ctrl, int argc,
2738 return wpa_cli_cmd(ctrl, "TDLS_LINK_STATUS", 1, argc, argv);
2742 static int wpa_cli_cmd_wmm_ac_addts(struct wpa_ctrl *ctrl, int argc,
2745 return wpa_cli_cmd(ctrl, "WMM_AC_ADDTS", 3, argc, argv);
2749 static int wpa_cli_cmd_wmm_ac_delts(struct wpa_ctrl *ctrl, int argc,
2752 return wpa_cli_cmd(ctrl, "WMM_AC_DELTS", 1, argc, argv);
2756 static int wpa_cli_cmd_wmm_ac_status(struct wpa_ctrl *ctrl, int argc,
2759 return wpa_ctrl_command(ctrl, "WMM_AC_STATUS");
2763 static int wpa_cli_cmd_tdls_chan_switch(struct wpa_ctrl *ctrl, int argc,
2766 return wpa_cli_cmd(ctrl, "TDLS_CHAN_SWITCH", 2, argc, argv);
2770 static int wpa_cli_cmd_tdls_cancel_chan_switch(struct wpa_ctrl *ctrl, int argc,
2773 return wpa_cli_cmd(ctrl, "TDLS_CANCEL_CHAN_SWITCH", 1, argc, argv);
2777 static int wpa_cli_cmd_signal_poll(struct wpa_ctrl *ctrl, int argc,
2780 return wpa_ctrl_command(ctrl, "SIGNAL_POLL");
2784 static int wpa_cli_cmd_signal_monitor(struct wpa_ctrl *ctrl, int argc,
2787 return wpa_cli_cmd(ctrl, "SIGNAL_MONITOR", 0, argc, argv);
2791 static int wpa_cli_cmd_pktcnt_poll(struct wpa_ctrl *ctrl, int argc,
2794 return wpa_ctrl_command(ctrl, "PKTCNT_POLL");
2798 static int wpa_cli_cmd_reauthenticate(struct wpa_ctrl *ctrl, int argc,
2801 return wpa_ctrl_command(ctrl, "REAUTHENTICATE");
2805 #ifdef CONFIG_AUTOSCAN
2807 static int wpa_cli_cmd_autoscan(struct wpa_ctrl *ctrl, int argc, char *argv[])
2810 return wpa_ctrl_command(ctrl, "AUTOSCAN ");
2812 return wpa_cli_cmd(ctrl, "AUTOSCAN", 0, argc, argv);
2815 #endif /* CONFIG_AUTOSCAN */
2820 static int wpa_cli_cmd_wnm_sleep(struct wpa_ctrl *ctrl, int argc, char *argv[])
2822 return wpa_cli_cmd(ctrl, "WNM_SLEEP", 0, argc, argv);
2826 static int wpa_cli_cmd_wnm_bss_query(struct wpa_ctrl *ctrl, int argc, char *argv[])
2828 return wpa_cli_cmd(ctrl, "WNM_BSS_QUERY", 1, argc, argv);
2831 #endif /* CONFIG_WNM */
2834 static int wpa_cli_cmd_raw(struct wpa_ctrl *ctrl, int argc, char *argv[])
2838 return wpa_cli_cmd(ctrl, argv[0], 0, argc - 1, &argv[1]);
2843 static int wpa_cli_cmd_driver(struct wpa_ctrl *ctrl, int argc, char *argv[])
2845 return wpa_cli_cmd(ctrl, "DRIVER", 1, argc, argv);
2847 #endif /* ANDROID */
2850 static int wpa_cli_cmd_vendor(struct wpa_ctrl *ctrl, int argc, char *argv[])
2852 return wpa_cli_cmd(ctrl, "VENDOR", 1, argc, argv);
2856 static int wpa_cli_cmd_flush(struct wpa_ctrl *ctrl, int argc, char *argv[])
2858 return wpa_ctrl_command(ctrl, "FLUSH");
2862 static int wpa_cli_cmd_radio_work(struct wpa_ctrl *ctrl, int argc, char *argv[])
2864 return wpa_cli_cmd(ctrl, "RADIO_WORK", 1, argc, argv);
2868 static int wpa_cli_cmd_neighbor_rep_request(struct wpa_ctrl *ctrl, int argc,
2871 return wpa_cli_cmd(ctrl, "NEIGHBOR_REP_REQUEST", 0, argc, argv);
2875 static int wpa_cli_cmd_erp_flush(struct wpa_ctrl *ctrl, int argc, char *argv[])
2877 return wpa_ctrl_command(ctrl, "ERP_FLUSH");
2881 static int wpa_cli_cmd_mac_rand_scan(struct wpa_ctrl *ctrl, int argc,
2884 return wpa_cli_cmd(ctrl, "MAC_RAND_SCAN", 1, argc, argv);
2888 static int wpa_cli_cmd_get_pref_freq_list(struct wpa_ctrl *ctrl, int argc,
2891 return wpa_cli_cmd(ctrl, "GET_PREF_FREQ_LIST", 1, argc, argv);
2895 enum wpa_cli_cmd_flags {
2896 cli_cmd_flag_none = 0x00,
2897 cli_cmd_flag_sensitive = 0x01
2900 struct wpa_cli_cmd {
2902 int (*handler)(struct wpa_ctrl *ctrl, int argc, char *argv[]);
2903 char ** (*completion)(const char *str, int pos);
2904 enum wpa_cli_cmd_flags flags;
2908 static const struct wpa_cli_cmd wpa_cli_commands[] = {
2909 { "status", wpa_cli_cmd_status, NULL,
2911 "[verbose] = get current WPA/EAPOL/EAP status" },
2912 { "ifname", wpa_cli_cmd_ifname, NULL,
2914 "= get current interface name" },
2915 { "ping", wpa_cli_cmd_ping, NULL,
2917 "= pings wpa_supplicant" },
2918 { "relog", wpa_cli_cmd_relog, NULL,
2920 "= re-open log-file (allow rolling logs)" },
2921 { "note", wpa_cli_cmd_note, NULL,
2923 "<text> = add a note to wpa_supplicant debug log" },
2924 { "mib", wpa_cli_cmd_mib, NULL,
2926 "= get MIB variables (dot1x, dot11)" },
2927 { "help", wpa_cli_cmd_help, wpa_cli_complete_help,
2929 "[command] = show usage help" },
2930 { "interface", wpa_cli_cmd_interface, NULL,
2932 "[ifname] = show interfaces/select interface" },
2933 { "level", wpa_cli_cmd_level, NULL,
2935 "<debug level> = change debug level" },
2936 { "license", wpa_cli_cmd_license, NULL,
2938 "= show full wpa_cli license" },
2939 { "quit", wpa_cli_cmd_quit, NULL,
2942 { "set", wpa_cli_cmd_set, wpa_cli_complete_set,
2944 "= set variables (shows list of variables when run without "
2946 { "dump", wpa_cli_cmd_dump, NULL,
2948 "= dump config variables" },
2949 { "get", wpa_cli_cmd_get, wpa_cli_complete_get,
2951 "<name> = get information" },
2952 { "logon", wpa_cli_cmd_logon, NULL,
2954 "= IEEE 802.1X EAPOL state machine logon" },
2955 { "logoff", wpa_cli_cmd_logoff, NULL,
2957 "= IEEE 802.1X EAPOL state machine logoff" },
2958 { "pmksa", wpa_cli_cmd_pmksa, NULL,
2960 "= show PMKSA cache" },
2961 { "pmksa_flush", wpa_cli_cmd_pmksa_flush, NULL,
2963 "= flush PMKSA cache entries" },
2964 { "reassociate", wpa_cli_cmd_reassociate, NULL,
2966 "= force reassociation" },
2967 { "reattach", wpa_cli_cmd_reattach, NULL,
2969 "= force reassociation back to the same BSS" },
2970 { "preauthenticate", wpa_cli_cmd_preauthenticate, wpa_cli_complete_bss,
2972 "<BSSID> = force preauthentication" },
2973 { "identity", wpa_cli_cmd_identity, NULL,
2975 "<network id> <identity> = configure identity for an SSID" },
2976 { "password", wpa_cli_cmd_password, NULL,
2977 cli_cmd_flag_sensitive,
2978 "<network id> <password> = configure password for an SSID" },
2979 { "new_password", wpa_cli_cmd_new_password, NULL,
2980 cli_cmd_flag_sensitive,
2981 "<network id> <password> = change password for an SSID" },
2982 { "pin", wpa_cli_cmd_pin, NULL,
2983 cli_cmd_flag_sensitive,
2984 "<network id> <pin> = configure pin for an SSID" },
2985 { "otp", wpa_cli_cmd_otp, NULL,
2986 cli_cmd_flag_sensitive,
2987 "<network id> <password> = configure one-time-password for an SSID"
2989 { "passphrase", wpa_cli_cmd_passphrase, NULL,
2990 cli_cmd_flag_sensitive,
2991 "<network id> <passphrase> = configure private key passphrase\n"
2993 { "sim", wpa_cli_cmd_sim, NULL,
2994 cli_cmd_flag_sensitive,
2995 "<network id> <pin> = report SIM operation result" },
2996 { "bssid", wpa_cli_cmd_bssid, NULL,
2998 "<network id> <BSSID> = set preferred BSSID for an SSID" },
2999 { "blacklist", wpa_cli_cmd_blacklist, wpa_cli_complete_bss,
3001 "<BSSID> = add a BSSID to the blacklist\n"
3002 "blacklist clear = clear the blacklist\n"
3003 "blacklist = display the blacklist" },
3004 { "log_level", wpa_cli_cmd_log_level, NULL,
3006 "<level> [<timestamp>] = update the log level/timestamp\n"
3007 "log_level = display the current log level and log options" },
3008 { "list_networks", wpa_cli_cmd_list_networks, NULL,
3010 "= list configured networks" },
3011 { "select_network", wpa_cli_cmd_select_network,
3012 wpa_cli_complete_network_id,
3014 "<network id> = select a network (disable others)" },
3015 { "enable_network", wpa_cli_cmd_enable_network,
3016 wpa_cli_complete_network_id,
3018 "<network id> = enable a network" },
3019 { "disable_network", wpa_cli_cmd_disable_network,
3020 wpa_cli_complete_network_id,
3022 "<network id> = disable a network" },
3023 { "add_network", wpa_cli_cmd_add_network, NULL,
3025 "= add a network" },
3026 { "remove_network", wpa_cli_cmd_remove_network,
3027 wpa_cli_complete_network_id,
3029 "<network id> = remove a network" },
3030 { "set_network", wpa_cli_cmd_set_network, wpa_cli_complete_network,
3031 cli_cmd_flag_sensitive,
3032 "<network id> <variable> <value> = set network variables (shows\n"
3033 " list of variables when run without arguments)" },
3034 { "get_network", wpa_cli_cmd_get_network, wpa_cli_complete_network,
3036 "<network id> <variable> = get network variables" },
3037 { "dup_network", wpa_cli_cmd_dup_network, wpa_cli_complete_dup_network,
3039 "<src network id> <dst network id> <variable> = duplicate network variables"
3041 { "list_creds", wpa_cli_cmd_list_creds, NULL,
3043 "= list configured credentials" },
3044 { "add_cred", wpa_cli_cmd_add_cred, NULL,
3046 "= add a credential" },
3047 { "remove_cred", wpa_cli_cmd_remove_cred, NULL,
3049 "<cred id> = remove a credential" },
3050 { "set_cred", wpa_cli_cmd_set_cred, NULL,
3051 cli_cmd_flag_sensitive,
3052 "<cred id> <variable> <value> = set credential variables" },
3053 { "get_cred", wpa_cli_cmd_get_cred, NULL,
3055 "<cred id> <variable> = get credential variables" },
3056 { "save_config", wpa_cli_cmd_save_config, NULL,
3058 "= save the current configuration" },
3059 { "disconnect", wpa_cli_cmd_disconnect, NULL,
3061 "= disconnect and wait for reassociate/reconnect command before\n"
3063 { "reconnect", wpa_cli_cmd_reconnect, NULL,
3065 "= like reassociate, but only takes effect if already disconnected"
3067 { "scan", wpa_cli_cmd_scan, NULL,
3069 "= request new BSS scan" },
3070 { "scan_results", wpa_cli_cmd_scan_results, NULL,
3072 "= get latest scan results" },
3073 { "abort_scan", wpa_cli_cmd_abort_scan, NULL,
3075 "= request ongoing scan to be aborted" },
3076 { "bss", wpa_cli_cmd_bss, wpa_cli_complete_bss,
3078 "<<idx> | <bssid>> = get detailed scan result info" },
3079 { "get_capability", wpa_cli_cmd_get_capability, NULL,
3081 "<eap/pairwise/group/key_mgmt/proto/auth_alg/channels/freq/modes> "
3082 "= get capabilities" },
3083 { "reconfigure", wpa_cli_cmd_reconfigure, NULL,
3085 "= force wpa_supplicant to re-read its configuration file" },
3086 { "terminate", wpa_cli_cmd_terminate, NULL,
3088 "= terminate wpa_supplicant" },
3089 { "interface_add", wpa_cli_cmd_interface_add, NULL,
3091 "<ifname> <confname> <driver> <ctrl_interface> <driver_param>\n"
3092 " <bridge_name> <create> <type> = adds new interface, all "
3094 " <ifname> are optional. Supported types are station ('sta') and "
3096 { "interface_remove", wpa_cli_cmd_interface_remove, NULL,
3098 "<ifname> = removes the interface" },
3099 { "interface_list", wpa_cli_cmd_interface_list, NULL,
3101 "= list available interfaces" },
3102 { "ap_scan", wpa_cli_cmd_ap_scan, NULL,
3104 "<value> = set ap_scan parameter" },
3105 { "scan_interval", wpa_cli_cmd_scan_interval, NULL,
3107 "<value> = set scan_interval parameter (in seconds)" },
3108 { "bss_expire_age", wpa_cli_cmd_bss_expire_age, NULL,
3110 "<value> = set BSS expiration age parameter" },
3111 { "bss_expire_count", wpa_cli_cmd_bss_expire_count, NULL,
3113 "<value> = set BSS expiration scan count parameter" },
3114 { "bss_flush", wpa_cli_cmd_bss_flush, NULL,
3116 "<value> = set BSS flush age (0 by default)" },
3117 { "stkstart", wpa_cli_cmd_stkstart, NULL,
3119 "<addr> = request STK negotiation with <addr>" },
3120 { "ft_ds", wpa_cli_cmd_ft_ds, wpa_cli_complete_bss,
3122 "<addr> = request over-the-DS FT with <addr>" },
3123 { "wps_pbc", wpa_cli_cmd_wps_pbc, wpa_cli_complete_bss,
3125 "[BSSID] = start Wi-Fi Protected Setup: Push Button Configuration" },
3126 { "wps_pin", wpa_cli_cmd_wps_pin, wpa_cli_complete_bss,
3127 cli_cmd_flag_sensitive,
3128 "<BSSID> [PIN] = start WPS PIN method (returns PIN, if not "
3130 { "wps_check_pin", wpa_cli_cmd_wps_check_pin, NULL,
3131 cli_cmd_flag_sensitive,
3132 "<PIN> = verify PIN checksum" },
3133 { "wps_cancel", wpa_cli_cmd_wps_cancel, NULL, cli_cmd_flag_none,
3134 "Cancels the pending WPS operation" },
3135 #ifdef CONFIG_WPS_NFC
3136 { "wps_nfc", wpa_cli_cmd_wps_nfc, wpa_cli_complete_bss,
3138 "[BSSID] = start Wi-Fi Protected Setup: NFC" },
3139 { "wps_nfc_config_token", wpa_cli_cmd_wps_nfc_config_token, NULL,
3141 "<WPS|NDEF> = build configuration token" },
3142 { "wps_nfc_token", wpa_cli_cmd_wps_nfc_token, NULL,
3144 "<WPS|NDEF> = create password token" },
3145 { "wps_nfc_tag_read", wpa_cli_cmd_wps_nfc_tag_read, NULL,
3146 cli_cmd_flag_sensitive,
3147 "<hexdump of payload> = report read NFC tag with WPS data" },
3148 { "nfc_get_handover_req", wpa_cli_cmd_nfc_get_handover_req, NULL,
3150 "<NDEF> <WPS> = create NFC handover request" },
3151 { "nfc_get_handover_sel", wpa_cli_cmd_nfc_get_handover_sel, NULL,
3153 "<NDEF> <WPS> = create NFC handover select" },
3154 { "nfc_report_handover", wpa_cli_cmd_nfc_report_handover, NULL,
3156 "<role> <type> <hexdump of req> <hexdump of sel> = report completed "
3158 #endif /* CONFIG_WPS_NFC */
3159 { "wps_reg", wpa_cli_cmd_wps_reg, wpa_cli_complete_bss,
3160 cli_cmd_flag_sensitive,
3161 "<BSSID> <AP PIN> = start WPS Registrar to configure an AP" },
3162 { "wps_ap_pin", wpa_cli_cmd_wps_ap_pin, NULL,
3163 cli_cmd_flag_sensitive,
3164 "[params..] = enable/disable AP PIN" },
3165 { "wps_er_start", wpa_cli_cmd_wps_er_start, NULL,
3167 "[IP address] = start Wi-Fi Protected Setup External Registrar" },
3168 { "wps_er_stop", wpa_cli_cmd_wps_er_stop, NULL,
3170 "= stop Wi-Fi Protected Setup External Registrar" },
3171 { "wps_er_pin", wpa_cli_cmd_wps_er_pin, NULL,
3172 cli_cmd_flag_sensitive,
3173 "<UUID> <PIN> = add an Enrollee PIN to External Registrar" },
3174 { "wps_er_pbc", wpa_cli_cmd_wps_er_pbc, NULL,
3176 "<UUID> = accept an Enrollee PBC using External Registrar" },
3177 { "wps_er_learn", wpa_cli_cmd_wps_er_learn, NULL,
3178 cli_cmd_flag_sensitive,
3179 "<UUID> <PIN> = learn AP configuration" },
3180 { "wps_er_set_config", wpa_cli_cmd_wps_er_set_config, NULL,
3182 "<UUID> <network id> = set AP configuration for enrolling" },
3183 { "wps_er_config", wpa_cli_cmd_wps_er_config, NULL,
3184 cli_cmd_flag_sensitive,
3185 "<UUID> <PIN> <SSID> <auth> <encr> <key> = configure AP" },
3186 #ifdef CONFIG_WPS_NFC
3187 { "wps_er_nfc_config_token", wpa_cli_cmd_wps_er_nfc_config_token, NULL,
3189 "<WPS/NDEF> <UUID> = build NFC configuration token" },
3190 #endif /* CONFIG_WPS_NFC */
3191 { "ibss_rsn", wpa_cli_cmd_ibss_rsn, NULL,
3193 "<addr> = request RSN authentication with <addr> in IBSS" },
3195 { "sta", wpa_cli_cmd_sta, NULL,
3197 "<addr> = get information about an associated station (AP)" },
3198 { "all_sta", wpa_cli_cmd_all_sta, NULL,
3200 "= get information about all associated stations (AP)" },
3201 { "deauthenticate", wpa_cli_cmd_deauthenticate, NULL,
3203 "<addr> = deauthenticate a station" },
3204 { "disassociate", wpa_cli_cmd_disassociate, NULL,
3206 "<addr> = disassociate a station" },
3207 { "chan_switch", wpa_cli_cmd_chanswitch, NULL,
3209 "<cs_count> <freq> [sec_channel_offset=] [center_freq1=]"
3210 " [center_freq2=] [bandwidth=] [blocktx] [ht|vht]"
3211 " = CSA parameters" },
3212 #endif /* CONFIG_AP */
3213 { "suspend", wpa_cli_cmd_suspend, NULL, cli_cmd_flag_none,
3214 "= notification of suspend/hibernate" },
3215 { "resume", wpa_cli_cmd_resume, NULL, cli_cmd_flag_none,
3216 "= notification of resume/thaw" },
3217 #ifdef CONFIG_TESTING_OPTIONS
3218 { "drop_sa", wpa_cli_cmd_drop_sa, NULL, cli_cmd_flag_none,
3219 "= drop SA without deauth/disassoc (test command)" },
3220 #endif /* CONFIG_TESTING_OPTIONS */
3221 { "roam", wpa_cli_cmd_roam, wpa_cli_complete_bss,
3223 "<addr> = roam to the specified BSS" },
3225 { "mesh_interface_add", wpa_cli_cmd_mesh_interface_add, NULL,
3227 "[ifname] = Create a new mesh interface" },
3228 { "mesh_group_add", wpa_cli_cmd_mesh_group_add, NULL,
3230 "<network id> = join a mesh network (disable others)" },
3231 { "mesh_group_remove", wpa_cli_cmd_mesh_group_remove, NULL,
3233 "<ifname> = Remove mesh group interface" },
3234 { "mesh_peer_remove", wpa_cli_cmd_mesh_peer_remove, NULL,
3236 "<addr> = Remove a mesh peer" },
3237 { "mesh_peer_add", wpa_cli_cmd_mesh_peer_add, NULL,
3239 "<addr> [duration=<seconds>] = Add a mesh peer" },
3240 #endif /* CONFIG_MESH */
3242 { "p2p_find", wpa_cli_cmd_p2p_find, wpa_cli_complete_p2p_find,
3244 "[timeout] [type=*] = find P2P Devices for up-to timeout seconds" },
3245 { "p2p_stop_find", wpa_cli_cmd_p2p_stop_find, NULL, cli_cmd_flag_none,
3246 "= stop P2P Devices search" },
3247 { "p2p_asp_provision", wpa_cli_cmd_p2p_asp_provision, NULL,
3249 "<addr> adv_id=<adv_id> conncap=<conncap> [info=<infodata>] = provision with a P2P ASP Device" },
3250 { "p2p_asp_provision_resp", wpa_cli_cmd_p2p_asp_provision_resp, NULL,
3252 "<addr> adv_id=<adv_id> [role<conncap>] [info=<infodata>] = provision with a P2P ASP Device" },
3253 { "p2p_connect", wpa_cli_cmd_p2p_connect, wpa_cli_complete_p2p_connect,
3255 "<addr> <\"pbc\"|PIN> [ht40] = connect to a P2P Device" },
3256 { "p2p_listen", wpa_cli_cmd_p2p_listen, NULL, cli_cmd_flag_none,
3257 "[timeout] = listen for P2P Devices for up-to timeout seconds" },
3258 { "p2p_group_remove", wpa_cli_cmd_p2p_group_remove,
3259 wpa_cli_complete_p2p_group_remove, cli_cmd_flag_none,
3260 "<ifname> = remove P2P group interface (terminate group if GO)" },
3261 { "p2p_group_add", wpa_cli_cmd_p2p_group_add, NULL, cli_cmd_flag_none,
3262 "[ht40] = add a new P2P group (local end as GO)" },
3263 { "p2p_group_member", wpa_cli_cmd_p2p_group_member, NULL,
3265 "<dev_addr> = Get peer interface address on local GO using peer Device Address" },
3266 { "p2p_prov_disc", wpa_cli_cmd_p2p_prov_disc,
3267 wpa_cli_complete_p2p_peer, cli_cmd_flag_none,
3268 "<addr> <method> = request provisioning discovery" },
3269 { "p2p_get_passphrase", wpa_cli_cmd_p2p_get_passphrase, NULL,
3271 "= get the passphrase for a group (GO only)" },
3272 { "p2p_serv_disc_req", wpa_cli_cmd_p2p_serv_disc_req,
3273 wpa_cli_complete_p2p_peer, cli_cmd_flag_none,
3274 "<addr> <TLVs> = schedule service discovery request" },
3275 { "p2p_serv_disc_cancel_req", wpa_cli_cmd_p2p_serv_disc_cancel_req,
3276 NULL, cli_cmd_flag_none,
3277 "<id> = cancel pending service discovery request" },
3278 { "p2p_serv_disc_resp", wpa_cli_cmd_p2p_serv_disc_resp, NULL,
3280 "<freq> <addr> <dialog token> <TLVs> = service discovery response" },
3281 { "p2p_service_update", wpa_cli_cmd_p2p_service_update, NULL,
3283 "= indicate change in local services" },
3284 { "p2p_serv_disc_external", wpa_cli_cmd_p2p_serv_disc_external, NULL,
3286 "<external> = set external processing of service discovery" },
3287 { "p2p_service_flush", wpa_cli_cmd_p2p_service_flush, NULL,
3289 "= remove all stored service entries" },
3290 { "p2p_service_add", wpa_cli_cmd_p2p_service_add, NULL,
3292 "<bonjour|upnp|asp> <query|version> <response|service> = add a local "
3294 { "p2p_service_rep", wpa_cli_cmd_p2p_service_rep, NULL,
3296 "asp <auto> <adv_id> <svc_state> <svc_string> [<svc_info>] = replace "
3297 "local ASP service" },
3298 { "p2p_service_del", wpa_cli_cmd_p2p_service_del, NULL,
3300 "<bonjour|upnp> <query|version> [|service] = remove a local "
3302 { "p2p_reject", wpa_cli_cmd_p2p_reject, wpa_cli_complete_p2p_peer,
3304 "<addr> = reject connection attempts from a specific peer" },
3305 { "p2p_invite", wpa_cli_cmd_p2p_invite, NULL,
3307 "<cmd> [peer=addr] = invite peer" },
3308 { "p2p_peers", wpa_cli_cmd_p2p_peers, NULL, cli_cmd_flag_none,
3309 "[discovered] = list known (optionally, only fully discovered) P2P "
3311 { "p2p_peer", wpa_cli_cmd_p2p_peer, wpa_cli_complete_p2p_peer,
3313 "<address> = show information about known P2P peer" },
3314 { "p2p_set", wpa_cli_cmd_p2p_set, wpa_cli_complete_p2p_set,
3316 "<field> <value> = set a P2P parameter" },
3317 { "p2p_flush", wpa_cli_cmd_p2p_flush, NULL, cli_cmd_flag_none,
3318 "= flush P2P state" },
3319 { "p2p_cancel", wpa_cli_cmd_p2p_cancel, NULL, cli_cmd_flag_none,
3320 "= cancel P2P group formation" },
3321 { "p2p_unauthorize", wpa_cli_cmd_p2p_unauthorize,
3322 wpa_cli_complete_p2p_peer, cli_cmd_flag_none,
3323 "<address> = unauthorize a peer" },
3324 { "p2p_presence_req", wpa_cli_cmd_p2p_presence_req, NULL,
3326 "[<duration> <interval>] [<duration> <interval>] = request GO "
3328 { "p2p_ext_listen", wpa_cli_cmd_p2p_ext_listen, NULL,
3330 "[<period> <interval>] = set extended listen timing" },
3331 { "p2p_remove_client", wpa_cli_cmd_p2p_remove_client,
3332 wpa_cli_complete_p2p_peer, cli_cmd_flag_none,
3333 "<address|iface=address> = remove a peer from all groups" },
3334 { "vendor_elem_add", wpa_cli_cmd_vendor_elem_add, NULL,
3336 "<frame id> <hexdump of elem(s)> = add vendor specific IEs to frame(s)\n"
3337 VENDOR_ELEM_FRAME_ID },
3338 { "vendor_elem_get", wpa_cli_cmd_vendor_elem_get, NULL,
3340 "<frame id> = get vendor specific IE(s) to frame(s)\n"
3341 VENDOR_ELEM_FRAME_ID },
3342 { "vendor_elem_remove", wpa_cli_cmd_vendor_elem_remove, NULL,
3344 "<frame id> <hexdump of elem(s)> = remove vendor specific IE(s) in frame(s)\n"
3345 VENDOR_ELEM_FRAME_ID },
3346 #endif /* CONFIG_P2P */
3347 #ifdef CONFIG_WIFI_DISPLAY
3348 { "wfd_subelem_set", wpa_cli_cmd_wfd_subelem_set, NULL,
3350 "<subelem> [contents] = set Wi-Fi Display subelement" },
3351 { "wfd_subelem_get", wpa_cli_cmd_wfd_subelem_get, NULL,
3353 "<subelem> = get Wi-Fi Display subelement" },
3354 #endif /* CONFIG_WIFI_DISPLAY */
3355 #ifdef CONFIG_INTERWORKING
3356 { "fetch_anqp", wpa_cli_cmd_fetch_anqp, NULL, cli_cmd_flag_none,
3357 "= fetch ANQP information for all APs" },
3358 { "stop_fetch_anqp", wpa_cli_cmd_stop_fetch_anqp, NULL,
3360 "= stop fetch_anqp operation" },
3361 { "interworking_select", wpa_cli_cmd_interworking_select, NULL,
3363 "[auto] = perform Interworking network selection" },
3364 { "interworking_connect", wpa_cli_cmd_interworking_connect,
3365 wpa_cli_complete_bss, cli_cmd_flag_none,
3366 "<BSSID> = connect using Interworking credentials" },
3367 { "interworking_add_network", wpa_cli_cmd_interworking_add_network,
3368 wpa_cli_complete_bss, cli_cmd_flag_none,
3369 "<BSSID> = connect using Interworking credentials" },
3370 { "anqp_get", wpa_cli_cmd_anqp_get, wpa_cli_complete_bss,
3372 "<addr> <info id>[,<info id>]... = request ANQP information" },
3373 { "gas_request", wpa_cli_cmd_gas_request, wpa_cli_complete_bss,
3375 "<addr> <AdvProtoID> [QueryReq] = GAS request" },
3376 { "gas_response_get", wpa_cli_cmd_gas_response_get,
3377 wpa_cli_complete_bss, cli_cmd_flag_none,
3378 "<addr> <dialog token> [start,len] = Fetch last GAS response" },
3379 #endif /* CONFIG_INTERWORKING */
3381 { "hs20_anqp_get", wpa_cli_cmd_hs20_anqp_get, wpa_cli_complete_bss,
3383 "<addr> <subtype>[,<subtype>]... = request HS 2.0 ANQP information"
3385 { "nai_home_realm_list", wpa_cli_cmd_get_nai_home_realm_list,
3386 wpa_cli_complete_bss, cli_cmd_flag_none,
3387 "<addr> <home realm> = get HS20 nai home realm list" },
3388 { "hs20_icon_request", wpa_cli_cmd_hs20_icon_request,
3389 wpa_cli_complete_bss, cli_cmd_flag_none,
3390 "<addr> <icon name> = get Hotspot 2.0 OSU icon" },
3391 { "fetch_osu", wpa_cli_cmd_fetch_osu, NULL, cli_cmd_flag_none,
3392 "= fetch OSU provider information from all APs" },
3393 { "cancel_fetch_osu", wpa_cli_cmd_cancel_fetch_osu, NULL,
3395 "= cancel fetch_osu command" },
3396 #endif /* CONFIG_HS20 */
3397 { "sta_autoconnect", wpa_cli_cmd_sta_autoconnect, NULL,
3399 "<0/1> = disable/enable automatic reconnection" },
3400 { "tdls_discover", wpa_cli_cmd_tdls_discover, NULL,
3402 "<addr> = request TDLS discovery with <addr>" },
3403 { "tdls_setup", wpa_cli_cmd_tdls_setup, NULL,
3405 "<addr> = request TDLS setup with <addr>" },
3406 { "tdls_teardown", wpa_cli_cmd_tdls_teardown, NULL,
3408 "<addr> = tear down TDLS with <addr>" },
3409 { "tdls_link_status", wpa_cli_cmd_tdls_link_status, NULL,
3411 "<addr> = TDLS link status with <addr>" },
3412 { "wmm_ac_addts", wpa_cli_cmd_wmm_ac_addts, NULL,
3414 "<uplink/downlink/bidi> <tsid=0..7> <up=0..7> [nominal_msdu_size=#] "
3415 "[mean_data_rate=#] [min_phy_rate=#] [sba=#] [fixed_nominal_msdu] "
3416 "= add WMM-AC traffic stream" },
3417 { "wmm_ac_delts", wpa_cli_cmd_wmm_ac_delts, NULL,
3419 "<tsid> = delete WMM-AC traffic stream" },
3420 { "wmm_ac_status", wpa_cli_cmd_wmm_ac_status, NULL,
3422 "= show status for Wireless Multi-Media Admission-Control" },
3423 { "tdls_chan_switch", wpa_cli_cmd_tdls_chan_switch, NULL,
3425 "<addr> <oper class> <freq> [sec_channel_offset=] [center_freq1=] "
3426 "[center_freq2=] [bandwidth=] [ht|vht] = enable channel switching "
3428 { "tdls_cancel_chan_switch", wpa_cli_cmd_tdls_cancel_chan_switch, NULL,
3430 "<addr> = disable channel switching with TDLS peer <addr>" },
3431 { "signal_poll", wpa_cli_cmd_signal_poll, NULL,
3433 "= get signal parameters" },
3434 { "signal_monitor", wpa_cli_cmd_signal_monitor, NULL,
3436 "= set signal monitor parameters" },
3437 { "pktcnt_poll", wpa_cli_cmd_pktcnt_poll, NULL,
3439 "= get TX/RX packet counters" },
3440 { "reauthenticate", wpa_cli_cmd_reauthenticate, NULL,
3442 "= trigger IEEE 802.1X/EAPOL reauthentication" },
3443 #ifdef CONFIG_AUTOSCAN
3444 { "autoscan", wpa_cli_cmd_autoscan, NULL, cli_cmd_flag_none,
3445 "[params] = Set or unset (if none) autoscan parameters" },
3446 #endif /* CONFIG_AUTOSCAN */
3448 { "wnm_sleep", wpa_cli_cmd_wnm_sleep, NULL, cli_cmd_flag_none,
3449 "<enter/exit> [interval=#] = enter/exit WNM-Sleep mode" },
3450 { "wnm_bss_query", wpa_cli_cmd_wnm_bss_query, NULL, cli_cmd_flag_none,
3451 "<query reason> [list] = Send BSS Transition Management Query" },
3452 #endif /* CONFIG_WNM */
3453 { "raw", wpa_cli_cmd_raw, NULL, cli_cmd_flag_sensitive,
3454 "<params..> = Sent unprocessed command" },
3455 { "flush", wpa_cli_cmd_flush, NULL, cli_cmd_flag_none,
3456 "= flush wpa_supplicant state" },
3458 { "driver", wpa_cli_cmd_driver, NULL, cli_cmd_flag_none,
3459 "<command> = driver private commands" },
3460 #endif /* ANDROID */
3461 { "radio_work", wpa_cli_cmd_radio_work, NULL, cli_cmd_flag_none,
3462 "= radio_work <show/add/done>" },
3463 { "vendor", wpa_cli_cmd_vendor, NULL, cli_cmd_flag_none,
3464 "<vendor id> <command id> [<hex formatted command argument>] = Send vendor command"
3466 { "neighbor_rep_request",
3467 wpa_cli_cmd_neighbor_rep_request, NULL, cli_cmd_flag_none,
3468 "[ssid=<SSID>] [lci] [civic] = Trigger request to AP for neighboring AP report (with optional given SSID in hex or enclosed in double quotes, default: current SSID; with optional LCI and location civic request)"
3470 { "erp_flush", wpa_cli_cmd_erp_flush, NULL, cli_cmd_flag_none,
3471 "= flush ERP keys" },
3473 wpa_cli_cmd_mac_rand_scan, NULL, cli_cmd_flag_none,
3474 "<scan|sched|pno|all> enable=<0/1> [addr=mac-address "
3475 "mask=mac-address-mask] = scan MAC randomization"
3477 { "get_pref_freq_list", wpa_cli_cmd_get_pref_freq_list, NULL,
3479 "<interface type> = retrieve preferred freq list for the specified interface type" },
3480 { NULL, NULL, NULL, cli_cmd_flag_none, NULL }
3485 * Prints command usage, lines are padded with the specified string.
3487 static void print_cmd_help(const struct wpa_cli_cmd *cmd, const char *pad)
3492 printf("%s%s ", pad, cmd->cmd);
3493 for (n = 0; (c = cmd->usage[n]); n++) {
3502 static void print_help(const char *cmd)
3505 printf("commands:\n");
3506 for (n = 0; wpa_cli_commands[n].cmd; n++) {
3507 if (cmd == NULL || str_starts(wpa_cli_commands[n].cmd, cmd))
3508 print_cmd_help(&wpa_cli_commands[n], " ");
3513 static int wpa_cli_edit_filter_history_cb(void *ctx, const char *cmd)
3515 const char *c, *delim;
3519 delim = os_strchr(cmd, ' ');
3523 len = os_strlen(cmd);
3525 for (n = 0; (c = wpa_cli_commands[n].cmd); n++) {
3526 if (os_strncasecmp(cmd, c, len) == 0 && len == os_strlen(c))
3527 return (wpa_cli_commands[n].flags &
3528 cli_cmd_flag_sensitive);
3534 static char ** wpa_list_cmd_list(void)
3538 struct cli_txt_entry *e;
3540 count = ARRAY_SIZE(wpa_cli_commands);
3541 count += dl_list_len(&p2p_groups);
3542 count += dl_list_len(&ifnames);
3543 res = os_calloc(count + 1, sizeof(char *));
3547 for (i = 0; wpa_cli_commands[i].cmd; i++) {
3548 res[i] = os_strdup(wpa_cli_commands[i].cmd);
3553 dl_list_for_each(e, &p2p_groups, struct cli_txt_entry, list) {
3554 size_t len = 8 + os_strlen(e->txt);
3555 res[i] = os_malloc(len);
3558 os_snprintf(res[i], len, "ifname=%s", e->txt);
3562 dl_list_for_each(e, &ifnames, struct cli_txt_entry, list) {
3563 res[i] = os_strdup(e->txt);
3573 static char ** wpa_cli_cmd_completion(const char *cmd, const char *str,
3578 for (i = 0; wpa_cli_commands[i].cmd; i++) {
3579 if (os_strcasecmp(wpa_cli_commands[i].cmd, cmd) == 0) {
3580 if (wpa_cli_commands[i].completion)
3581 return wpa_cli_commands[i].completion(str,
3584 printf("\r%s\n", wpa_cli_commands[i].usage);
3594 static char ** wpa_cli_edit_completion_cb(void *ctx, const char *str, int pos)
3600 if (pos > 7 && os_strncasecmp(str, "IFNAME=", 7) == 0) {
3601 end = os_strchr(str, ' ');
3602 if (end && pos > end - str) {
3603 pos -= end - str + 1;
3608 end = os_strchr(str, ' ');
3609 if (end == NULL || str + pos < end)
3610 return wpa_list_cmd_list();
3612 cmd = os_malloc(pos + 1);
3615 os_memcpy(cmd, str, pos);
3616 cmd[end - str] = '\0';
3617 res = wpa_cli_cmd_completion(cmd, str, pos);
3623 static int wpa_request(struct wpa_ctrl *ctrl, int argc, char *argv[])
3625 const struct wpa_cli_cmd *cmd, *match = NULL;
3629 if (argc > 1 && os_strncasecmp(argv[0], "IFNAME=", 7) == 0) {
3630 ifname_prefix = argv[0] + 7;
3634 ifname_prefix = NULL;
3640 cmd = wpa_cli_commands;
3642 if (os_strncasecmp(cmd->cmd, argv[0], os_strlen(argv[0])) == 0)
3645 if (os_strcasecmp(cmd->cmd, argv[0]) == 0) {
3646 /* we have an exact match */
3656 printf("Ambiguous command '%s'; possible commands:", argv[0]);
3657 cmd = wpa_cli_commands;
3659 if (os_strncasecmp(cmd->cmd, argv[0],
3660 os_strlen(argv[0])) == 0) {
3661 printf(" %s", cmd->cmd);
3667 } else if (count == 0) {
3668 printf("Unknown command '%s'\n", argv[0]);
3671 ret = match->handler(ctrl, argc - 1, &argv[1]);
3678 static int str_match(const char *a, const char *b)
3680 return os_strncmp(a, b, os_strlen(b)) == 0;
3684 static int wpa_cli_exec(const char *program, const char *arg1,
3691 /* If no interface is specified, set the global */
3695 len = os_strlen(arg1) + os_strlen(arg2) + 2;
3696 arg = os_malloc(len);
3699 os_snprintf(arg, len, "%s %s", arg1, arg2);
3700 res = os_exec(program, arg, 1);
3707 static void wpa_cli_action_process(const char *msg)
3710 char *copy = NULL, *id, *pos2;
3711 const char *ifname = ctrl_ifname;
3712 char ifname_buf[100];
3714 if (eloop_terminated())
3718 if (os_strncmp(pos, "IFNAME=", 7) == 0) {
3720 end = os_strchr(pos + 7, ' ');
3721 if (end && (unsigned int) (end - pos) < sizeof(ifname_buf)) {
3723 os_memcpy(ifname_buf, pos, end - pos);
3724 ifname_buf[end - pos] = '\0';
3725 ifname = ifname_buf;
3730 const char *prev = pos;
3732 pos = os_strchr(pos, '>');
3739 if (str_match(pos, WPA_EVENT_CONNECTED)) {
3741 os_unsetenv("WPA_ID");
3742 os_unsetenv("WPA_ID_STR");
3743 os_unsetenv("WPA_CTRL_DIR");
3745 pos = os_strstr(pos, "[id=");
3747 copy = os_strdup(pos + 4);
3751 while (*pos2 && *pos2 != ' ')
3755 os_setenv("WPA_ID", id, 1);
3756 while (*pos2 && *pos2 != '=')
3761 while (*pos2 && *pos2 != ']')
3764 os_setenv("WPA_ID_STR", id, 1);
3768 os_setenv("WPA_CTRL_DIR", ctrl_iface_dir, 1);
3770 if (wpa_cli_connected <= 0 || new_id != wpa_cli_last_id) {
3771 wpa_cli_connected = 1;
3772 wpa_cli_last_id = new_id;
3773 wpa_cli_exec(action_file, ifname, "CONNECTED");
3775 } else if (str_match(pos, WPA_EVENT_DISCONNECTED)) {
3776 if (wpa_cli_connected) {
3777 wpa_cli_connected = 0;
3778 wpa_cli_exec(action_file, ifname, "DISCONNECTED");
3780 } else if (str_match(pos, AP_EVENT_ENABLED)) {
3781 wpa_cli_exec(action_file, ctrl_ifname, pos);
3782 } else if (str_match(pos, AP_EVENT_DISABLED)) {
3783 wpa_cli_exec(action_file, ctrl_ifname, pos);
3784 } else if (str_match(pos, MESH_GROUP_STARTED)) {
3785 wpa_cli_exec(action_file, ctrl_ifname, pos);
3786 } else if (str_match(pos, MESH_GROUP_REMOVED)) {
3787 wpa_cli_exec(action_file, ctrl_ifname, pos);
3788 } else if (str_match(pos, MESH_PEER_CONNECTED)) {
3789 wpa_cli_exec(action_file, ctrl_ifname, pos);
3790 } else if (str_match(pos, MESH_PEER_DISCONNECTED)) {
3791 wpa_cli_exec(action_file, ctrl_ifname, pos);
3792 } else if (str_match(pos, P2P_EVENT_GROUP_STARTED)) {
3793 wpa_cli_exec(action_file, ifname, pos);
3794 } else if (str_match(pos, P2P_EVENT_GROUP_REMOVED)) {
3795 wpa_cli_exec(action_file, ifname, pos);
3796 } else if (str_match(pos, P2P_EVENT_CROSS_CONNECT_ENABLE)) {
3797 wpa_cli_exec(action_file, ifname, pos);
3798 } else if (str_match(pos, P2P_EVENT_CROSS_CONNECT_DISABLE)) {
3799 wpa_cli_exec(action_file, ifname, pos);
3800 } else if (str_match(pos, P2P_EVENT_GO_NEG_FAILURE)) {
3801 wpa_cli_exec(action_file, ifname, pos);
3802 } else if (str_match(pos, WPS_EVENT_SUCCESS)) {
3803 wpa_cli_exec(action_file, ifname, pos);
3804 } else if (str_match(pos, WPS_EVENT_FAIL)) {
3805 wpa_cli_exec(action_file, ifname, pos);
3806 } else if (str_match(pos, AP_STA_CONNECTED)) {
3807 wpa_cli_exec(action_file, ifname, pos);
3808 } else if (str_match(pos, AP_STA_DISCONNECTED)) {
3809 wpa_cli_exec(action_file, ifname, pos);
3810 } else if (str_match(pos, ESS_DISASSOC_IMMINENT)) {
3811 wpa_cli_exec(action_file, ifname, pos);
3812 } else if (str_match(pos, HS20_SUBSCRIPTION_REMEDIATION)) {
3813 wpa_cli_exec(action_file, ifname, pos);
3814 } else if (str_match(pos, HS20_DEAUTH_IMMINENT_NOTICE)) {
3815 wpa_cli_exec(action_file, ifname, pos);
3816 } else if (str_match(pos, WPA_EVENT_TERMINATING)) {
3817 printf("wpa_supplicant is terminating - stop monitoring\n");
3823 #ifndef CONFIG_ANSI_C_EXTRA
3824 static void wpa_cli_action_cb(char *msg, size_t len)
3826 wpa_cli_action_process(msg);
3828 #endif /* CONFIG_ANSI_C_EXTRA */
3831 static void wpa_cli_reconnect(void)
3833 wpa_cli_close_connection();
3834 if (wpa_cli_open_connection(ctrl_ifname, 1) < 0)
3839 printf("\rConnection to wpa_supplicant re-established\n");
3845 static void cli_event(const char *str)
3847 const char *start, *s;
3849 start = os_strchr(str, '>');
3855 if (str_starts(start, WPA_EVENT_BSS_ADDED)) {
3856 s = os_strchr(start, ' ');
3859 s = os_strchr(s + 1, ' ');
3862 cli_txt_list_add(&bsses, s + 1);
3866 if (str_starts(start, WPA_EVENT_BSS_REMOVED)) {
3867 s = os_strchr(start, ' ');
3870 s = os_strchr(s + 1, ' ');
3873 cli_txt_list_del_addr(&bsses, s + 1);
3878 if (str_starts(start, P2P_EVENT_DEVICE_FOUND)) {
3879 s = os_strstr(start, " p2p_dev_addr=");
3882 cli_txt_list_add_addr(&p2p_peers, s + 14);
3886 if (str_starts(start, P2P_EVENT_DEVICE_LOST)) {
3887 s = os_strstr(start, " p2p_dev_addr=");
3890 cli_txt_list_del_addr(&p2p_peers, s + 14);
3894 if (str_starts(start, P2P_EVENT_GROUP_STARTED)) {
3895 s = os_strchr(start, ' ');
3898 cli_txt_list_add_word(&p2p_groups, s + 1, ' ');
3902 if (str_starts(start, P2P_EVENT_GROUP_REMOVED)) {
3903 s = os_strchr(start, ' ');
3906 cli_txt_list_del_word(&p2p_groups, s + 1, ' ');
3909 #endif /* CONFIG_P2P */
3913 static int check_terminating(const char *msg)
3915 const char *pos = msg;
3919 pos = os_strchr(pos, '>');
3926 if (str_match(pos, WPA_EVENT_TERMINATING) && ctrl_conn) {
3928 printf("\rConnection to wpa_supplicant lost - trying to "
3931 wpa_cli_attached = 0;
3932 wpa_cli_close_connection();
3940 static void wpa_cli_recv_pending(struct wpa_ctrl *ctrl, int action_monitor)
3942 if (ctrl_conn == NULL) {
3943 wpa_cli_reconnect();
3946 while (wpa_ctrl_pending(ctrl) > 0) {
3948 size_t len = sizeof(buf) - 1;
3949 if (wpa_ctrl_recv(ctrl, buf, &len) == 0) {
3952 wpa_cli_action_process(buf);
3955 if (wpa_cli_show_event(buf)) {
3957 printf("\r%s\n", buf);
3961 if (interactive && check_terminating(buf) > 0)
3965 printf("Could not read pending message.\n");
3970 if (wpa_ctrl_pending(ctrl) < 0) {
3971 printf("Connection to wpa_supplicant lost - trying to "
3973 wpa_cli_reconnect();
3979 static int tokenize_cmd(char *cmd, char *argv[])
3992 if (argc == max_args)
3995 char *pos2 = os_strrchr(pos, '"');
3999 while (*pos != '\0' && *pos != ' ')
4009 static void wpa_cli_ping(void *eloop_ctx, void *timeout_ctx)
4013 char *prefix = ifname_prefix;
4015 ifname_prefix = NULL;
4016 res = _wpa_ctrl_command(ctrl_conn, "PING", 0);
4017 ifname_prefix = prefix;
4019 printf("Connection to wpa_supplicant lost - trying to "
4021 wpa_cli_close_connection();
4025 wpa_cli_reconnect();
4026 eloop_register_timeout(ping_interval, 0, wpa_cli_ping, NULL, NULL);
4030 static void wpa_cli_mon_receive(int sock, void *eloop_ctx, void *sock_ctx)
4032 wpa_cli_recv_pending(mon_conn, 0);
4036 static void wpa_cli_edit_cmd_cb(void *ctx, char *cmd)
4038 char *argv[max_args];
4040 argc = tokenize_cmd(cmd, argv);
4042 wpa_request(ctrl_conn, argc, argv);
4046 static void wpa_cli_edit_eof_cb(void *ctx)
4052 static int warning_displayed = 0;
4053 static char *hfile = NULL;
4054 static int edit_started = 0;
4056 static void start_edit(void)
4061 #ifdef CONFIG_CTRL_IFACE_UDP_REMOTE
4062 ps = wpa_ctrl_get_remote_ifname(ctrl_conn);
4063 #endif /* CONFIG_CTRL_IFACE_UDP_REMOTE */
4065 #ifdef CONFIG_WPA_CLI_HISTORY_DIR
4066 home = CONFIG_WPA_CLI_HISTORY_DIR;
4067 #else /* CONFIG_WPA_CLI_HISTORY_DIR */
4068 home = getenv("HOME");
4069 #endif /* CONFIG_WPA_CLI_HISTORY_DIR */
4071 const char *fname = ".wpa_cli_history";
4072 int hfile_len = os_strlen(home) + 1 + os_strlen(fname) + 1;
4073 hfile = os_malloc(hfile_len);
4075 os_snprintf(hfile, hfile_len, "%s/%s", home, fname);
4078 if (edit_init(wpa_cli_edit_cmd_cb, wpa_cli_edit_eof_cb,
4079 wpa_cli_edit_completion_cb, NULL, hfile, ps) < 0) {
4085 eloop_register_timeout(ping_interval, 0, wpa_cli_ping, NULL, NULL);
4089 static void update_bssid_list(struct wpa_ctrl *ctrl)
4092 size_t len = sizeof(buf);
4094 char *cmd = "BSS RANGE=ALL MASK=0x2";
4099 ret = wpa_ctrl_request(ctrl, cmd, os_strlen(cmd), buf, &len, NULL);
4106 pos = os_strstr(pos, "bssid=");
4110 end = os_strchr(pos, '\n');
4114 cli_txt_list_add(&bsses, pos);
4120 static void update_ifnames(struct wpa_ctrl *ctrl)
4123 size_t len = sizeof(buf);
4125 char *cmd = "INTERFACES";
4129 cli_txt_list_flush(&ifnames);
4133 ret = wpa_ctrl_request(ctrl, cmd, os_strlen(cmd), buf, &len, NULL);
4140 end = os_strchr(pos, '\n');
4144 ret = os_snprintf(txt, sizeof(txt), "ifname=%s", pos);
4145 if (!os_snprintf_error(sizeof(txt), ret))
4146 cli_txt_list_add(&ifnames, txt);
4152 static void update_networks(struct wpa_ctrl *ctrl)
4155 size_t len = sizeof(buf);
4157 char *cmd = "LIST_NETWORKS";
4161 cli_txt_list_flush(&networks);
4165 ret = wpa_ctrl_request(ctrl, cmd, os_strlen(cmd), buf, &len, NULL);
4172 end = os_strchr(pos, '\n');
4177 cli_txt_list_add_word(&networks, pos, '\t');
4184 static void try_connection(void *eloop_ctx, void *timeout_ctx)
4189 if (ctrl_ifname == NULL)
4190 ctrl_ifname = wpa_cli_get_default_ifname();
4192 if (wpa_cli_open_connection(ctrl_ifname, 1)) {
4193 if (!warning_displayed) {
4194 printf("Could not connect to wpa_supplicant: "
4196 ctrl_ifname ? ctrl_ifname : "(nil)");
4197 warning_displayed = 1;
4199 eloop_register_timeout(1, 0, try_connection, NULL, NULL);
4203 update_bssid_list(ctrl_conn);
4204 update_networks(ctrl_conn);
4206 if (warning_displayed)
4207 printf("Connection established.\n");
4214 static void wpa_cli_interactive(void)
4216 printf("\nInteractive mode\n\n");
4218 eloop_register_timeout(0, 0, try_connection, NULL, NULL);
4220 eloop_cancel_timeout(try_connection, NULL, NULL);
4222 cli_txt_list_flush(&p2p_peers);
4223 cli_txt_list_flush(&p2p_groups);
4224 cli_txt_list_flush(&bsses);
4225 cli_txt_list_flush(&ifnames);
4226 cli_txt_list_flush(&networks);
4228 edit_deinit(hfile, wpa_cli_edit_filter_history_cb);
4230 eloop_cancel_timeout(wpa_cli_ping, NULL, NULL);
4231 wpa_cli_close_connection();
4235 static void wpa_cli_action_ping(void *eloop_ctx, void *timeout_ctx)
4237 struct wpa_ctrl *ctrl = eloop_ctx;
4241 /* verify that connection is still working */
4242 len = sizeof(buf) - 1;
4243 if (wpa_ctrl_request(ctrl, "PING", 4, buf, &len,
4244 wpa_cli_action_cb) < 0 ||
4245 len < 4 || os_memcmp(buf, "PONG", 4) != 0) {
4246 printf("wpa_supplicant did not reply to PING command - exiting\n");
4250 eloop_register_timeout(ping_interval, 0, wpa_cli_action_ping,
4255 static void wpa_cli_action_receive(int sock, void *eloop_ctx, void *sock_ctx)
4257 struct wpa_ctrl *ctrl = eloop_ctx;
4259 wpa_cli_recv_pending(ctrl, 1);
4263 static void wpa_cli_action(struct wpa_ctrl *ctrl)
4265 #ifdef CONFIG_ANSI_C_EXTRA
4266 /* TODO: ANSI C version(?) */
4267 printf("Action processing not supported in ANSI C build.\n");
4268 #else /* CONFIG_ANSI_C_EXTRA */
4271 fd = wpa_ctrl_get_fd(ctrl);
4272 eloop_register_timeout(ping_interval, 0, wpa_cli_action_ping,
4274 eloop_register_read_sock(fd, wpa_cli_action_receive, ctrl, NULL);
4276 eloop_cancel_timeout(wpa_cli_action_ping, ctrl, NULL);
4277 eloop_unregister_read_sock(fd);
4278 #endif /* CONFIG_ANSI_C_EXTRA */
4282 static void wpa_cli_cleanup(void)
4284 wpa_cli_close_connection();
4286 os_daemonize_terminate(pid_file);
4288 os_program_deinit();
4292 static void wpa_cli_terminate(int sig, void *ctx)
4298 static char * wpa_cli_get_default_ifname(void)
4300 char *ifname = NULL;
4303 char ifprop[PROPERTY_VALUE_MAX];
4304 if (property_get("wifi.interface", ifprop, NULL) != 0) {
4305 ifname = os_strdup(ifprop);
4306 printf("Using interface '%s'\n", ifname ? ifname : "N/A");
4309 #ifdef CONFIG_CTRL_IFACE_UNIX
4310 struct dirent *dent;
4311 DIR *dir = opendir(ctrl_iface_dir);
4315 while ((dent = readdir(dir))) {
4316 #ifdef _DIRENT_HAVE_D_TYPE
4318 * Skip the file if it is not a socket. Also accept
4319 * DT_UNKNOWN (0) in case the C library or underlying
4320 * file system does not support d_type.
4322 if (dent->d_type != DT_SOCK && dent->d_type != DT_UNKNOWN)
4324 #endif /* _DIRENT_HAVE_D_TYPE */
4325 if (os_strcmp(dent->d_name, ".") == 0 ||
4326 os_strcmp(dent->d_name, "..") == 0)
4328 printf("Selected interface '%s'\n", dent->d_name);
4329 ifname = os_strdup(dent->d_name);
4333 #endif /* CONFIG_CTRL_IFACE_UNIX */
4335 #ifdef CONFIG_CTRL_IFACE_NAMED_PIPE
4336 char buf[4096], *pos;
4338 struct wpa_ctrl *ctrl;
4341 ctrl = wpa_ctrl_open(NULL);
4345 len = sizeof(buf) - 1;
4346 ret = wpa_ctrl_request(ctrl, "INTERFACES", 10, buf, &len, NULL);
4349 pos = os_strchr(buf, '\n');
4352 ifname = os_strdup(buf);
4354 wpa_ctrl_close(ctrl);
4355 #endif /* CONFIG_CTRL_IFACE_NAMED_PIPE */
4356 #endif /* ANDROID */
4362 int main(int argc, char *argv[])
4367 const char *global = NULL;
4369 if (os_program_init())
4373 c = getopt(argc, argv, "a:Bg:G:hi:p:P:s:v");
4378 action_file = optarg;
4387 ping_interval = atoi(optarg);
4393 printf("%s\n", wpa_cli_version);
4396 os_free(ctrl_ifname);
4397 ctrl_ifname = os_strdup(optarg);
4400 ctrl_iface_dir = optarg;
4406 client_socket_dir = optarg;
4414 interactive = (argc == optind) && (action_file == NULL);
4417 printf("%s\n\n%s\n\n", wpa_cli_version, wpa_cli_license);
4423 #ifdef CONFIG_CTRL_IFACE_NAMED_PIPE
4424 ctrl_conn = wpa_ctrl_open(NULL);
4425 #else /* CONFIG_CTRL_IFACE_NAMED_PIPE */
4426 ctrl_conn = wpa_ctrl_open(global);
4427 #endif /* CONFIG_CTRL_IFACE_NAMED_PIPE */
4428 if (ctrl_conn == NULL) {
4429 fprintf(stderr, "Failed to connect to wpa_supplicant "
4430 "global interface: %s error: %s\n",
4431 global, strerror(errno));
4436 update_ifnames(ctrl_conn);
4437 mon_conn = wpa_ctrl_open(global);
4439 if (wpa_ctrl_attach(mon_conn) == 0) {
4440 wpa_cli_attached = 1;
4441 eloop_register_read_sock(
4442 wpa_ctrl_get_fd(mon_conn),
4443 wpa_cli_mon_receive,
4446 printf("Failed to open monitor "
4447 "connection through global "
4448 "control interface\n");
4454 eloop_register_signal_terminate(wpa_cli_terminate, NULL);
4456 if (ctrl_ifname == NULL)
4457 ctrl_ifname = wpa_cli_get_default_ifname();
4460 wpa_cli_interactive();
4463 wpa_cli_open_connection(ctrl_ifname, 0) < 0) {
4464 fprintf(stderr, "Failed to connect to non-global "
4465 "ctrl_ifname: %s error: %s\n",
4466 ctrl_ifname ? ctrl_ifname : "(nil)",
4472 if (wpa_ctrl_attach(ctrl_conn) == 0) {
4473 wpa_cli_attached = 1;
4475 printf("Warning: Failed to attach to "
4476 "wpa_supplicant.\n");
4481 if (daemonize && os_daemonize(pid_file) && eloop_sock_requeue())
4485 wpa_cli_action(ctrl_conn);
4487 ret = wpa_request(ctrl_conn, argc - optind,
4491 os_free(ctrl_ifname);
4498 #else /* CONFIG_CTRL_IFACE */
4499 int main(int argc, char *argv[])
4501 printf("CONFIG_CTRL_IFACE not defined - wpa_cli disabled\n");
4504 #endif /* CONFIG_CTRL_IFACE */