2 * WPA Supplicant - command line interface for wpa_supplicant daemon
3 * Copyright (c) 2004-2013, Jouni Malinen <j@w1.fi>
5 * This software may be distributed under the terms of the BSD license.
6 * See README for more details.
11 #ifdef CONFIG_CTRL_IFACE
13 #ifdef CONFIG_CTRL_IFACE_UNIX
15 #endif /* CONFIG_CTRL_IFACE_UNIX */
17 #include "common/wpa_ctrl.h"
18 #include "utils/common.h"
19 #include "utils/eloop.h"
20 #include "utils/edit.h"
21 #include "utils/list.h"
22 #include "common/version.h"
23 #include "common/ieee802_11_defs.h"
25 #include <cutils/properties.h>
29 static const char *wpa_cli_version =
30 "wpa_cli v" VERSION_STR "\n"
31 "Copyright (c) 2004-2014, Jouni Malinen <j@w1.fi> and contributors";
34 static const char *wpa_cli_license =
35 "This software may be distributed under the terms of the BSD license.\n"
36 "See README for more details.\n";
38 static const char *wpa_cli_full_license =
39 "This software may be distributed under the terms of the BSD license.\n"
41 "Redistribution and use in source and binary forms, with or without\n"
42 "modification, are permitted provided that the following conditions are\n"
45 "1. Redistributions of source code must retain the above copyright\n"
46 " notice, this list of conditions and the following disclaimer.\n"
48 "2. Redistributions in binary form must reproduce the above copyright\n"
49 " notice, this list of conditions and the following disclaimer in the\n"
50 " documentation and/or other materials provided with the distribution.\n"
52 "3. Neither the name(s) of the above-listed copyright holder(s) nor the\n"
53 " names of its contributors may be used to endorse or promote products\n"
54 " derived from this software without specific prior written permission.\n"
56 "THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n"
57 "\"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n"
58 "LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n"
59 "A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n"
60 "OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n"
61 "SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n"
62 "LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n"
63 "DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n"
64 "THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n"
65 "(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n"
66 "OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n"
69 static struct wpa_ctrl *ctrl_conn;
70 static struct wpa_ctrl *mon_conn;
71 static int wpa_cli_quit = 0;
72 static int wpa_cli_attached = 0;
73 static int wpa_cli_connected = -1;
74 static int wpa_cli_last_id = 0;
75 #ifndef CONFIG_CTRL_IFACE_DIR
76 #define CONFIG_CTRL_IFACE_DIR "/var/run/wpa_supplicant"
77 #endif /* CONFIG_CTRL_IFACE_DIR */
78 static const char *ctrl_iface_dir = CONFIG_CTRL_IFACE_DIR;
79 static char *ctrl_ifname = NULL;
80 static const char *pid_file = NULL;
81 static const char *action_file = NULL;
82 static int ping_interval = 5;
83 static int interactive = 0;
84 static char *ifname_prefix = NULL;
86 struct cli_txt_entry {
91 static DEFINE_DL_LIST(bsses); /* struct cli_txt_entry */
92 static DEFINE_DL_LIST(p2p_peers); /* struct cli_txt_entry */
93 static DEFINE_DL_LIST(p2p_groups); /* struct cli_txt_entry */
94 static DEFINE_DL_LIST(ifnames); /* struct cli_txt_entry */
97 static void print_help(const char *cmd);
98 static void wpa_cli_mon_receive(int sock, void *eloop_ctx, void *sock_ctx);
99 static void wpa_cli_close_connection(void);
100 static char * wpa_cli_get_default_ifname(void);
101 static char ** wpa_list_cmd_list(void);
104 static void usage(void)
106 printf("wpa_cli [-p<path to ctrl sockets>] [-i<ifname>] [-hvB] "
107 "[-a<action file>] \\\n"
108 " [-P<pid file>] [-g<global ctrl>] [-G<ping interval>] "
110 " -h = help (show this usage text)\n"
111 " -v = shown version information\n"
112 " -a = run in daemon mode executing the action file based on "
115 " -B = run a daemon in the background\n"
116 " default path: " CONFIG_CTRL_IFACE_DIR "\n"
117 " default interface: first interface found in socket path\n");
122 static void cli_txt_list_free(struct cli_txt_entry *e)
124 dl_list_del(&e->list);
130 static void cli_txt_list_flush(struct dl_list *list)
132 struct cli_txt_entry *e;
133 while ((e = dl_list_first(list, struct cli_txt_entry, list)))
134 cli_txt_list_free(e);
138 static struct cli_txt_entry * cli_txt_list_get(struct dl_list *txt_list,
141 struct cli_txt_entry *e;
142 dl_list_for_each(e, txt_list, struct cli_txt_entry, list) {
143 if (os_strcmp(e->txt, txt) == 0)
150 static void cli_txt_list_del(struct dl_list *txt_list, const char *txt)
152 struct cli_txt_entry *e;
153 e = cli_txt_list_get(txt_list, txt);
155 cli_txt_list_free(e);
159 static void cli_txt_list_del_addr(struct dl_list *txt_list, const char *txt)
163 if (hwaddr_aton(txt, addr) < 0)
165 os_snprintf(buf, sizeof(buf), MACSTR, MAC2STR(addr));
166 cli_txt_list_del(txt_list, buf);
171 static void cli_txt_list_del_word(struct dl_list *txt_list, const char *txt)
175 end = os_strchr(txt, ' ');
177 end = txt + os_strlen(txt);
178 buf = dup_binstr(txt, end - txt);
181 cli_txt_list_del(txt_list, buf);
184 #endif /* CONFIG_P2P */
187 static int cli_txt_list_add(struct dl_list *txt_list, const char *txt)
189 struct cli_txt_entry *e;
190 e = cli_txt_list_get(txt_list, txt);
193 e = os_zalloc(sizeof(*e));
196 e->txt = os_strdup(txt);
197 if (e->txt == NULL) {
201 dl_list_add(txt_list, &e->list);
207 static int cli_txt_list_add_addr(struct dl_list *txt_list, const char *txt)
211 if (hwaddr_aton(txt, addr) < 0)
213 os_snprintf(buf, sizeof(buf), MACSTR, MAC2STR(addr));
214 return cli_txt_list_add(txt_list, buf);
218 static int cli_txt_list_add_word(struct dl_list *txt_list, const char *txt)
223 end = os_strchr(txt, ' ');
225 end = txt + os_strlen(txt);
226 buf = dup_binstr(txt, end - txt);
229 ret = cli_txt_list_add(txt_list, buf);
233 #endif /* CONFIG_P2P */
236 static char ** cli_txt_list_array(struct dl_list *txt_list)
238 unsigned int i, count = dl_list_len(txt_list);
240 struct cli_txt_entry *e;
242 res = os_calloc(count + 1, sizeof(char *));
247 dl_list_for_each(e, txt_list, struct cli_txt_entry, list) {
248 res[i] = os_strdup(e->txt);
258 static int get_cmd_arg_num(const char *str, int pos)
262 for (i = 0; i <= pos; i++) {
265 while (i <= pos && str[i] != ' ')
276 static int str_starts(const char *src, const char *match)
278 return os_strncmp(src, match, os_strlen(match)) == 0;
282 static int wpa_cli_show_event(const char *event)
286 start = os_strchr(event, '>');
292 * Skip BSS added/removed events since they can be relatively frequent
293 * and are likely of not much use for an interactive user.
295 if (str_starts(start, WPA_EVENT_BSS_ADDED) ||
296 str_starts(start, WPA_EVENT_BSS_REMOVED))
303 static int wpa_cli_open_connection(const char *ifname, int attach)
305 #if defined(CONFIG_CTRL_IFACE_UDP) || defined(CONFIG_CTRL_IFACE_NAMED_PIPE)
306 ctrl_conn = wpa_ctrl_open(ifname);
307 if (ctrl_conn == NULL)
310 if (attach && interactive)
311 mon_conn = wpa_ctrl_open(ifname);
314 #else /* CONFIG_CTRL_IFACE_UDP || CONFIG_CTRL_IFACE_NAMED_PIPE */
322 if (access(ctrl_iface_dir, F_OK) < 0) {
323 cfile = os_strdup(ifname);
330 flen = os_strlen(ctrl_iface_dir) + os_strlen(ifname) + 2;
331 cfile = os_malloc(flen);
334 res = os_snprintf(cfile, flen, "%s/%s", ctrl_iface_dir,
336 if (res < 0 || res >= flen) {
342 ctrl_conn = wpa_ctrl_open(cfile);
343 if (ctrl_conn == NULL) {
348 if (attach && interactive)
349 mon_conn = wpa_ctrl_open(cfile);
353 #endif /* CONFIG_CTRL_IFACE_UDP || CONFIG_CTRL_IFACE_NAMED_PIPE */
356 if (wpa_ctrl_attach(mon_conn) == 0) {
357 wpa_cli_attached = 1;
359 eloop_register_read_sock(
360 wpa_ctrl_get_fd(mon_conn),
361 wpa_cli_mon_receive, NULL, NULL);
363 printf("Warning: Failed to attach to "
364 "wpa_supplicant.\n");
365 wpa_cli_close_connection();
374 static void wpa_cli_close_connection(void)
376 if (ctrl_conn == NULL)
379 if (wpa_cli_attached) {
380 wpa_ctrl_detach(interactive ? mon_conn : ctrl_conn);
381 wpa_cli_attached = 0;
383 wpa_ctrl_close(ctrl_conn);
386 eloop_unregister_read_sock(wpa_ctrl_get_fd(mon_conn));
387 wpa_ctrl_close(mon_conn);
393 static void wpa_cli_msg_cb(char *msg, size_t len)
399 static int _wpa_ctrl_command(struct wpa_ctrl *ctrl, char *cmd, int print)
405 if (ctrl_conn == NULL) {
406 printf("Not connected to wpa_supplicant - command dropped.\n");
410 os_snprintf(buf, sizeof(buf), "IFNAME=%s %s",
412 buf[sizeof(buf) - 1] = '\0';
415 len = sizeof(buf) - 1;
416 ret = wpa_ctrl_request(ctrl, cmd, os_strlen(cmd), buf, &len,
419 printf("'%s' command timed out.\n", cmd);
421 } else if (ret < 0) {
422 printf("'%s' command failed.\n", cmd);
428 if (interactive && len > 0 && buf[len - 1] != '\n')
435 static int wpa_ctrl_command(struct wpa_ctrl *ctrl, char *cmd)
437 return _wpa_ctrl_command(ctrl, cmd, 1);
441 static int write_cmd(char *buf, size_t buflen, const char *cmd, int argc,
450 res = os_snprintf(pos, end - pos, "%s", cmd);
451 if (res < 0 || res >= end - pos)
455 for (i = 0; i < argc; i++) {
456 res = os_snprintf(pos, end - pos, " %s", argv[i]);
457 if (res < 0 || res >= end - pos)
462 buf[buflen - 1] = '\0';
466 printf("Too long command\n");
471 static int wpa_cli_cmd(struct wpa_ctrl *ctrl, const char *cmd, int min_args,
472 int argc, char *argv[])
475 if (argc < min_args) {
476 printf("Invalid %s command - at least %d argument%s "
477 "required.\n", cmd, min_args,
478 min_args > 1 ? "s are" : " is");
481 if (write_cmd(buf, sizeof(buf), cmd, argc, argv) < 0)
483 return wpa_ctrl_command(ctrl, buf);
487 static int wpa_cli_cmd_ifname(struct wpa_ctrl *ctrl, int argc, char *argv[])
489 return wpa_ctrl_command(ctrl, "IFNAME");
493 static int wpa_cli_cmd_status(struct wpa_ctrl *ctrl, int argc, char *argv[])
495 if (argc > 0 && os_strcmp(argv[0], "verbose") == 0)
496 return wpa_ctrl_command(ctrl, "STATUS-VERBOSE");
497 if (argc > 0 && os_strcmp(argv[0], "wps") == 0)
498 return wpa_ctrl_command(ctrl, "STATUS-WPS");
499 if (argc > 0 && os_strcmp(argv[0], "driver") == 0)
500 return wpa_ctrl_command(ctrl, "STATUS-DRIVER");
501 return wpa_ctrl_command(ctrl, "STATUS");
505 static int wpa_cli_cmd_ping(struct wpa_ctrl *ctrl, int argc, char *argv[])
507 return wpa_ctrl_command(ctrl, "PING");
511 static int wpa_cli_cmd_relog(struct wpa_ctrl *ctrl, int argc, char *argv[])
513 return wpa_ctrl_command(ctrl, "RELOG");
517 static int wpa_cli_cmd_note(struct wpa_ctrl *ctrl, int argc, char *argv[])
519 return wpa_cli_cmd(ctrl, "NOTE", 1, argc, argv);
523 static int wpa_cli_cmd_mib(struct wpa_ctrl *ctrl, int argc, char *argv[])
525 return wpa_ctrl_command(ctrl, "MIB");
529 static int wpa_cli_cmd_pmksa(struct wpa_ctrl *ctrl, int argc, char *argv[])
531 return wpa_ctrl_command(ctrl, "PMKSA");
535 static int wpa_cli_cmd_help(struct wpa_ctrl *ctrl, int argc, char *argv[])
537 print_help(argc > 0 ? argv[0] : NULL);
542 static char ** wpa_cli_complete_help(const char *str, int pos)
544 int arg = get_cmd_arg_num(str, pos);
549 res = wpa_list_cmd_list();
557 static int wpa_cli_cmd_license(struct wpa_ctrl *ctrl, int argc, char *argv[])
559 printf("%s\n\n%s\n", wpa_cli_version, wpa_cli_full_license);
564 static int wpa_cli_cmd_quit(struct wpa_ctrl *ctrl, int argc, char *argv[])
573 static int wpa_cli_cmd_set(struct wpa_ctrl *ctrl, int argc, char *argv[])
579 res = os_snprintf(cmd, sizeof(cmd), "SET %s ", argv[0]);
580 if (res < 0 || (size_t) res >= sizeof(cmd) - 1) {
581 printf("Too long SET command.\n");
584 return wpa_ctrl_command(ctrl, cmd);
587 return wpa_cli_cmd(ctrl, "SET", 2, argc, argv);
591 static char ** wpa_cli_complete_set(const char *str, int pos)
593 int arg = get_cmd_arg_num(str, pos);
594 const char *fields[] = {
596 "EAPOL::heldPeriod", "EAPOL::authPeriod", "EAPOL::startPeriod",
597 "EAPOL::maxStart", "dot11RSNAConfigPMKLifetime",
598 "dot11RSNAConfigPMKReauthThreshold", "dot11RSNAConfigSATimeout",
599 "wps_fragment_size", "wps_version_number", "ampdu",
600 "tdls_testing", "tdls_disabled", "pno", "radio_disabled",
601 "uapsd", "ps", "wifi_display", "bssid_filter", "disallow_aps",
603 /* global configuration parameters */
604 "eapol_version", "ap_scan", "disable_scan_offload",
605 "fast_reauth", "opensc_engine_path", "pkcs11_engine_path",
606 "pkcs11_module_path", "pcsc_reader", "pcsc_pin",
607 "driver_param", "dot11RSNAConfigPMKLifetime",
608 "dot11RSNAConfigPMKReauthThreshold",
609 "dot11RSNAConfigSATimeout",
610 "update_config", "load_dynamic_eap", "uuid", "device_name",
611 "manufacturer", "model_name", "model_number", "serial_number",
612 "device_type", "os_version", "config_methods",
613 "wps_cred_processing", "wps_vendor_ext_m1", "sec_device_type",
614 "p2p_listen_reg_class", "p2p_listen_channel",
615 "p2p_oper_reg_class", "p2p_oper_channel",
616 "p2p_go_intent", "p2p_ssid_postfix", "persistent_reconnect",
617 "p2p_intra_bss", "p2p_group_idle", "p2p_pref_chan",
619 "p2p_go_ht40", "p2p_disabled", "p2p_no_group_iface",
621 "p2p_ignore_shared_freq", "country", "bss_max_count",
622 "bss_expiration_age", "bss_expiration_scan_count",
623 "filter_ssids", "filter_rssi", "max_num_sta",
624 "disassoc_low_ack", "hs20", "interworking", "hessid",
625 "access_network_type", "pbc_in_m1", "autoscan",
626 "wps_nfc_dev_pw_id", "wps_nfc_dh_pubkey", "wps_nfc_dh_privkey",
627 "wps_nfc_dev_pw", "ext_password_backend",
628 "p2p_go_max_inactivity", "auto_interworking", "okc", "pmf",
629 "sae_groups", "dtim_period", "beacon_int", "ap_vendor_elements",
630 "ignore_old_scan_res", "freq_list", "external_sim",
631 "tdls_external_control"
633 int i, num_fields = ARRAY_SIZE(fields);
636 char **res = os_calloc(num_fields + 1, sizeof(char *));
639 for (i = 0; i < num_fields; i++) {
640 res[i] = os_strdup(fields[i]);
647 if (arg > 1 && os_strncasecmp(str, "set bssid_filter ", 17) == 0)
648 return cli_txt_list_array(&bsses);
654 static int wpa_cli_cmd_get(struct wpa_ctrl *ctrl, int argc, char *argv[])
656 return wpa_cli_cmd(ctrl, "GET", 1, argc, argv);
660 static int wpa_cli_cmd_logoff(struct wpa_ctrl *ctrl, int argc, char *argv[])
662 return wpa_ctrl_command(ctrl, "LOGOFF");
666 static int wpa_cli_cmd_logon(struct wpa_ctrl *ctrl, int argc, char *argv[])
668 return wpa_ctrl_command(ctrl, "LOGON");
672 static int wpa_cli_cmd_reassociate(struct wpa_ctrl *ctrl, int argc,
675 return wpa_ctrl_command(ctrl, "REASSOCIATE");
679 static int wpa_cli_cmd_preauthenticate(struct wpa_ctrl *ctrl, int argc,
682 return wpa_cli_cmd(ctrl, "PREAUTH", 1, argc, argv);
686 static int wpa_cli_cmd_ap_scan(struct wpa_ctrl *ctrl, int argc, char *argv[])
688 return wpa_cli_cmd(ctrl, "AP_SCAN", 1, argc, argv);
692 static int wpa_cli_cmd_scan_interval(struct wpa_ctrl *ctrl, int argc,
695 return wpa_cli_cmd(ctrl, "SCAN_INTERVAL", 1, argc, argv);
699 static int wpa_cli_cmd_bss_expire_age(struct wpa_ctrl *ctrl, int argc,
702 return wpa_cli_cmd(ctrl, "BSS_EXPIRE_AGE", 1, argc, argv);
706 static int wpa_cli_cmd_bss_expire_count(struct wpa_ctrl *ctrl, int argc,
709 return wpa_cli_cmd(ctrl, "BSS_EXPIRE_COUNT", 1, argc, argv);
713 static int wpa_cli_cmd_bss_flush(struct wpa_ctrl *ctrl, int argc, char *argv[])
719 res = os_snprintf(cmd, sizeof(cmd), "BSS_FLUSH 0");
721 res = os_snprintf(cmd, sizeof(cmd), "BSS_FLUSH %s", argv[0]);
722 if (res < 0 || (size_t) res >= sizeof(cmd) - 1) {
723 printf("Too long BSS_FLUSH command.\n");
726 return wpa_ctrl_command(ctrl, cmd);
730 static int wpa_cli_cmd_stkstart(struct wpa_ctrl *ctrl, int argc,
733 return wpa_cli_cmd(ctrl, "STKSTART", 1, argc, argv);
737 static int wpa_cli_cmd_ft_ds(struct wpa_ctrl *ctrl, int argc, char *argv[])
739 return wpa_cli_cmd(ctrl, "FT_DS", 1, argc, argv);
743 static int wpa_cli_cmd_wps_pbc(struct wpa_ctrl *ctrl, int argc, char *argv[])
745 return wpa_cli_cmd(ctrl, "WPS_PBC", 0, argc, argv);
749 static int wpa_cli_cmd_wps_pin(struct wpa_ctrl *ctrl, int argc, char *argv[])
752 printf("Invalid WPS_PIN command: need one or two arguments:\n"
753 "- BSSID: use 'any' to select any\n"
754 "- PIN: optional, used only with devices that have no "
759 return wpa_cli_cmd(ctrl, "WPS_PIN", 1, argc, argv);
763 static int wpa_cli_cmd_wps_check_pin(struct wpa_ctrl *ctrl, int argc,
766 return wpa_cli_cmd(ctrl, "WPS_CHECK_PIN", 1, argc, argv);
770 static int wpa_cli_cmd_wps_cancel(struct wpa_ctrl *ctrl, int argc,
773 return wpa_ctrl_command(ctrl, "WPS_CANCEL");
777 #ifdef CONFIG_WPS_NFC
779 static int wpa_cli_cmd_wps_nfc(struct wpa_ctrl *ctrl, int argc, char *argv[])
781 return wpa_cli_cmd(ctrl, "WPS_NFC", 0, argc, argv);
785 static int wpa_cli_cmd_wps_nfc_config_token(struct wpa_ctrl *ctrl, int argc,
788 return wpa_cli_cmd(ctrl, "WPS_NFC_CONFIG_TOKEN", 1, argc, argv);
792 static int wpa_cli_cmd_wps_nfc_token(struct wpa_ctrl *ctrl, int argc,
795 return wpa_cli_cmd(ctrl, "WPS_NFC_TOKEN", 1, argc, argv);
799 static int wpa_cli_cmd_wps_nfc_tag_read(struct wpa_ctrl *ctrl, int argc,
807 printf("Invalid 'wps_nfc_tag_read' command - one argument "
812 buflen = 18 + os_strlen(argv[0]);
813 buf = os_malloc(buflen);
816 os_snprintf(buf, buflen, "WPS_NFC_TAG_READ %s", argv[0]);
818 ret = wpa_ctrl_command(ctrl, buf);
825 static int wpa_cli_cmd_nfc_get_handover_req(struct wpa_ctrl *ctrl, int argc,
828 return wpa_cli_cmd(ctrl, "NFC_GET_HANDOVER_REQ", 2, argc, argv);
832 static int wpa_cli_cmd_nfc_get_handover_sel(struct wpa_ctrl *ctrl, int argc,
835 return wpa_cli_cmd(ctrl, "NFC_GET_HANDOVER_SEL", 2, argc, argv);
839 static int wpa_cli_cmd_nfc_rx_handover_req(struct wpa_ctrl *ctrl, int argc,
847 printf("Invalid 'nfc_rx_handover_req' command - one argument "
852 buflen = 21 + os_strlen(argv[0]);
853 buf = os_malloc(buflen);
856 os_snprintf(buf, buflen, "NFC_RX_HANDOVER_REQ %s", argv[0]);
858 ret = wpa_ctrl_command(ctrl, buf);
865 static int wpa_cli_cmd_nfc_rx_handover_sel(struct wpa_ctrl *ctrl, int argc,
873 printf("Invalid 'nfc_rx_handover_sel' command - one argument "
878 buflen = 21 + os_strlen(argv[0]);
879 buf = os_malloc(buflen);
882 os_snprintf(buf, buflen, "NFC_RX_HANDOVER_SEL %s", argv[0]);
884 ret = wpa_ctrl_command(ctrl, buf);
891 static int wpa_cli_cmd_nfc_report_handover(struct wpa_ctrl *ctrl, int argc,
894 return wpa_cli_cmd(ctrl, "NFC_REPORT_HANDOVER", 4, argc, argv);
897 #endif /* CONFIG_WPS_NFC */
900 static int wpa_cli_cmd_wps_reg(struct wpa_ctrl *ctrl, int argc, char *argv[])
906 res = os_snprintf(cmd, sizeof(cmd), "WPS_REG %s %s",
908 else if (argc == 5 || argc == 6) {
909 char ssid_hex[2 * 32 + 1];
910 char key_hex[2 * 64 + 1];
914 for (i = 0; i < 32; i++) {
915 if (argv[2][i] == '\0')
917 os_snprintf(&ssid_hex[i * 2], 3, "%02x", argv[2][i]);
922 for (i = 0; i < 64; i++) {
923 if (argv[5][i] == '\0')
925 os_snprintf(&key_hex[i * 2], 3, "%02x",
930 res = os_snprintf(cmd, sizeof(cmd),
931 "WPS_REG %s %s %s %s %s %s",
932 argv[0], argv[1], ssid_hex, argv[3], argv[4],
935 printf("Invalid WPS_REG command: need two arguments:\n"
936 "- BSSID of the target AP\n"
938 printf("Alternatively, six arguments can be used to "
939 "reconfigure the AP:\n"
940 "- BSSID of the target AP\n"
943 "- new auth (OPEN, WPAPSK, WPA2PSK)\n"
944 "- new encr (NONE, WEP, TKIP, CCMP)\n"
949 if (res < 0 || (size_t) res >= sizeof(cmd) - 1) {
950 printf("Too long WPS_REG command.\n");
953 return wpa_ctrl_command(ctrl, cmd);
957 static int wpa_cli_cmd_wps_ap_pin(struct wpa_ctrl *ctrl, int argc,
960 return wpa_cli_cmd(ctrl, "WPS_AP_PIN", 1, argc, argv);
964 static int wpa_cli_cmd_wps_er_start(struct wpa_ctrl *ctrl, int argc,
967 return wpa_cli_cmd(ctrl, "WPS_ER_START", 0, argc, argv);
971 static int wpa_cli_cmd_wps_er_stop(struct wpa_ctrl *ctrl, int argc,
974 return wpa_ctrl_command(ctrl, "WPS_ER_STOP");
979 static int wpa_cli_cmd_wps_er_pin(struct wpa_ctrl *ctrl, int argc,
983 printf("Invalid WPS_ER_PIN command: need at least two "
985 "- UUID: use 'any' to select any\n"
986 "- PIN: Enrollee PIN\n"
987 "optional: - Enrollee MAC address\n");
991 return wpa_cli_cmd(ctrl, "WPS_ER_PIN", 2, argc, argv);
995 static int wpa_cli_cmd_wps_er_pbc(struct wpa_ctrl *ctrl, int argc,
998 return wpa_cli_cmd(ctrl, "WPS_ER_PBC", 1, argc, argv);
1002 static int wpa_cli_cmd_wps_er_learn(struct wpa_ctrl *ctrl, int argc,
1006 printf("Invalid WPS_ER_LEARN command: need two arguments:\n"
1007 "- UUID: specify which AP to use\n"
1012 return wpa_cli_cmd(ctrl, "WPS_ER_LEARN", 2, argc, argv);
1016 static int wpa_cli_cmd_wps_er_set_config(struct wpa_ctrl *ctrl, int argc,
1020 printf("Invalid WPS_ER_SET_CONFIG command: need two "
1022 "- UUID: specify which AP to use\n"
1023 "- Network configuration id\n");
1027 return wpa_cli_cmd(ctrl, "WPS_ER_SET_CONFIG", 2, argc, argv);
1031 static int wpa_cli_cmd_wps_er_config(struct wpa_ctrl *ctrl, int argc,
1037 if (argc == 5 || argc == 6) {
1038 char ssid_hex[2 * 32 + 1];
1039 char key_hex[2 * 64 + 1];
1043 for (i = 0; i < 32; i++) {
1044 if (argv[2][i] == '\0')
1046 os_snprintf(&ssid_hex[i * 2], 3, "%02x", argv[2][i]);
1051 for (i = 0; i < 64; i++) {
1052 if (argv[5][i] == '\0')
1054 os_snprintf(&key_hex[i * 2], 3, "%02x",
1059 res = os_snprintf(cmd, sizeof(cmd),
1060 "WPS_ER_CONFIG %s %s %s %s %s %s",
1061 argv[0], argv[1], ssid_hex, argv[3], argv[4],
1064 printf("Invalid WPS_ER_CONFIG command: need six arguments:\n"
1068 "- new auth (OPEN, WPAPSK, WPA2PSK)\n"
1069 "- new encr (NONE, WEP, TKIP, CCMP)\n"
1074 if (res < 0 || (size_t) res >= sizeof(cmd) - 1) {
1075 printf("Too long WPS_ER_CONFIG command.\n");
1078 return wpa_ctrl_command(ctrl, cmd);
1082 #ifdef CONFIG_WPS_NFC
1083 static int wpa_cli_cmd_wps_er_nfc_config_token(struct wpa_ctrl *ctrl, int argc,
1087 printf("Invalid WPS_ER_NFC_CONFIG_TOKEN command: need two "
1089 "- WPS/NDEF: token format\n"
1090 "- UUID: specify which AP to use\n");
1094 return wpa_cli_cmd(ctrl, "WPS_ER_NFC_CONFIG_TOKEN", 2, argc, argv);
1096 #endif /* CONFIG_WPS_NFC */
1099 static int wpa_cli_cmd_ibss_rsn(struct wpa_ctrl *ctrl, int argc, char *argv[])
1101 return wpa_cli_cmd(ctrl, "IBSS_RSN", 1, argc, argv);
1105 static int wpa_cli_cmd_level(struct wpa_ctrl *ctrl, int argc, char *argv[])
1107 return wpa_cli_cmd(ctrl, "LEVEL", 1, argc, argv);
1111 static int wpa_cli_cmd_identity(struct wpa_ctrl *ctrl, int argc, char *argv[])
1113 char cmd[256], *pos, *end;
1117 printf("Invalid IDENTITY command: needs two arguments "
1118 "(network id and identity)\n");
1122 end = cmd + sizeof(cmd);
1124 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "IDENTITY-%s:%s",
1126 if (ret < 0 || ret >= end - pos) {
1127 printf("Too long IDENTITY command.\n");
1131 for (i = 2; i < argc; i++) {
1132 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
1133 if (ret < 0 || ret >= end - pos) {
1134 printf("Too long IDENTITY command.\n");
1140 return wpa_ctrl_command(ctrl, cmd);
1144 static int wpa_cli_cmd_password(struct wpa_ctrl *ctrl, int argc, char *argv[])
1146 char cmd[256], *pos, *end;
1150 printf("Invalid PASSWORD command: needs two arguments "
1151 "(network id and password)\n");
1155 end = cmd + sizeof(cmd);
1157 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "PASSWORD-%s:%s",
1159 if (ret < 0 || ret >= end - pos) {
1160 printf("Too long PASSWORD command.\n");
1164 for (i = 2; i < argc; i++) {
1165 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
1166 if (ret < 0 || ret >= end - pos) {
1167 printf("Too long PASSWORD command.\n");
1173 return wpa_ctrl_command(ctrl, cmd);
1177 static int wpa_cli_cmd_new_password(struct wpa_ctrl *ctrl, int argc,
1180 char cmd[256], *pos, *end;
1184 printf("Invalid NEW_PASSWORD command: needs two arguments "
1185 "(network id and password)\n");
1189 end = cmd + sizeof(cmd);
1191 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "NEW_PASSWORD-%s:%s",
1193 if (ret < 0 || ret >= end - pos) {
1194 printf("Too long NEW_PASSWORD command.\n");
1198 for (i = 2; i < argc; i++) {
1199 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
1200 if (ret < 0 || ret >= end - pos) {
1201 printf("Too long NEW_PASSWORD command.\n");
1207 return wpa_ctrl_command(ctrl, cmd);
1211 static int wpa_cli_cmd_pin(struct wpa_ctrl *ctrl, int argc, char *argv[])
1213 char cmd[256], *pos, *end;
1217 printf("Invalid PIN command: needs two arguments "
1218 "(network id and pin)\n");
1222 end = cmd + sizeof(cmd);
1224 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "PIN-%s:%s",
1226 if (ret < 0 || ret >= end - pos) {
1227 printf("Too long PIN command.\n");
1231 for (i = 2; i < argc; i++) {
1232 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
1233 if (ret < 0 || ret >= end - pos) {
1234 printf("Too long PIN command.\n");
1239 return wpa_ctrl_command(ctrl, cmd);
1243 static int wpa_cli_cmd_otp(struct wpa_ctrl *ctrl, int argc, char *argv[])
1245 char cmd[256], *pos, *end;
1249 printf("Invalid OTP command: needs two arguments (network "
1250 "id and password)\n");
1254 end = cmd + sizeof(cmd);
1256 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "OTP-%s:%s",
1258 if (ret < 0 || ret >= end - pos) {
1259 printf("Too long OTP command.\n");
1263 for (i = 2; i < argc; i++) {
1264 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
1265 if (ret < 0 || ret >= end - pos) {
1266 printf("Too long OTP command.\n");
1272 return wpa_ctrl_command(ctrl, cmd);
1276 static int wpa_cli_cmd_sim(struct wpa_ctrl *ctrl, int argc, char *argv[])
1278 char cmd[256], *pos, *end;
1282 printf("Invalid SIM command: needs two arguments "
1283 "(network id and SIM operation response)\n");
1287 end = cmd + sizeof(cmd);
1289 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "SIM-%s:%s",
1291 if (ret < 0 || ret >= end - pos) {
1292 printf("Too long SIM command.\n");
1296 for (i = 2; i < argc; i++) {
1297 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
1298 if (ret < 0 || ret >= end - pos) {
1299 printf("Too long SIM command.\n");
1304 return wpa_ctrl_command(ctrl, cmd);
1308 static int wpa_cli_cmd_passphrase(struct wpa_ctrl *ctrl, int argc,
1311 char cmd[256], *pos, *end;
1315 printf("Invalid PASSPHRASE command: needs two arguments "
1316 "(network id and passphrase)\n");
1320 end = cmd + sizeof(cmd);
1322 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "PASSPHRASE-%s:%s",
1324 if (ret < 0 || ret >= end - pos) {
1325 printf("Too long PASSPHRASE command.\n");
1329 for (i = 2; i < argc; i++) {
1330 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
1331 if (ret < 0 || ret >= end - pos) {
1332 printf("Too long PASSPHRASE command.\n");
1338 return wpa_ctrl_command(ctrl, cmd);
1342 static int wpa_cli_cmd_bssid(struct wpa_ctrl *ctrl, int argc, char *argv[])
1345 printf("Invalid BSSID command: needs two arguments (network "
1350 return wpa_cli_cmd(ctrl, "BSSID", 2, argc, argv);
1354 static int wpa_cli_cmd_blacklist(struct wpa_ctrl *ctrl, int argc, char *argv[])
1356 return wpa_cli_cmd(ctrl, "BLACKLIST", 0, argc, argv);
1360 static int wpa_cli_cmd_log_level(struct wpa_ctrl *ctrl, int argc, char *argv[])
1362 return wpa_cli_cmd(ctrl, "LOG_LEVEL", 0, argc, argv);
1366 static int wpa_cli_cmd_list_networks(struct wpa_ctrl *ctrl, int argc,
1369 return wpa_ctrl_command(ctrl, "LIST_NETWORKS");
1373 static int wpa_cli_cmd_select_network(struct wpa_ctrl *ctrl, int argc,
1376 return wpa_cli_cmd(ctrl, "SELECT_NETWORK", 1, argc, argv);
1380 static int wpa_cli_cmd_enable_network(struct wpa_ctrl *ctrl, int argc,
1383 return wpa_cli_cmd(ctrl, "ENABLE_NETWORK", 1, argc, argv);
1387 static int wpa_cli_cmd_disable_network(struct wpa_ctrl *ctrl, int argc,
1390 return wpa_cli_cmd(ctrl, "DISABLE_NETWORK", 1, argc, argv);
1394 static int wpa_cli_cmd_add_network(struct wpa_ctrl *ctrl, int argc,
1397 return wpa_ctrl_command(ctrl, "ADD_NETWORK");
1401 static int wpa_cli_cmd_remove_network(struct wpa_ctrl *ctrl, int argc,
1404 return wpa_cli_cmd(ctrl, "REMOVE_NETWORK", 1, argc, argv);
1408 static void wpa_cli_show_network_variables(void)
1410 printf("set_network variables:\n"
1411 " ssid (network name, SSID)\n"
1412 " psk (WPA passphrase or pre-shared key)\n"
1413 " key_mgmt (key management protocol)\n"
1414 " identity (EAP identity)\n"
1415 " password (EAP password)\n"
1418 "Note: Values are entered in the same format as the "
1419 "configuration file is using,\n"
1420 "i.e., strings values need to be inside double quotation "
1422 "For example: set_network 1 ssid \"network name\"\n"
1424 "Please see wpa_supplicant.conf documentation for full list "
1425 "of\navailable variables.\n");
1429 static int wpa_cli_cmd_set_network(struct wpa_ctrl *ctrl, int argc,
1433 wpa_cli_show_network_variables();
1438 printf("Invalid SET_NETWORK command: needs three arguments\n"
1439 "(network id, variable name, and value)\n");
1443 return wpa_cli_cmd(ctrl, "SET_NETWORK", 3, argc, argv);
1447 static int wpa_cli_cmd_get_network(struct wpa_ctrl *ctrl, int argc,
1451 wpa_cli_show_network_variables();
1456 printf("Invalid GET_NETWORK command: needs two arguments\n"
1457 "(network id and variable name)\n");
1461 return wpa_cli_cmd(ctrl, "GET_NETWORK", 2, argc, argv);
1465 static int wpa_cli_cmd_list_creds(struct wpa_ctrl *ctrl, int argc,
1468 return wpa_ctrl_command(ctrl, "LIST_CREDS");
1472 static int wpa_cli_cmd_add_cred(struct wpa_ctrl *ctrl, int argc, char *argv[])
1474 return wpa_ctrl_command(ctrl, "ADD_CRED");
1478 static int wpa_cli_cmd_remove_cred(struct wpa_ctrl *ctrl, int argc,
1481 return wpa_cli_cmd(ctrl, "REMOVE_CRED", 1, argc, argv);
1485 static int wpa_cli_cmd_set_cred(struct wpa_ctrl *ctrl, int argc, char *argv[])
1488 printf("Invalid SET_CRED command: needs three arguments\n"
1489 "(cred id, variable name, and value)\n");
1493 return wpa_cli_cmd(ctrl, "SET_CRED", 3, argc, argv);
1497 static int wpa_cli_cmd_disconnect(struct wpa_ctrl *ctrl, int argc,
1500 return wpa_ctrl_command(ctrl, "DISCONNECT");
1504 static int wpa_cli_cmd_reconnect(struct wpa_ctrl *ctrl, int argc,
1507 return wpa_ctrl_command(ctrl, "RECONNECT");
1511 static int wpa_cli_cmd_save_config(struct wpa_ctrl *ctrl, int argc,
1514 return wpa_ctrl_command(ctrl, "SAVE_CONFIG");
1518 static int wpa_cli_cmd_scan(struct wpa_ctrl *ctrl, int argc, char *argv[])
1520 return wpa_cli_cmd(ctrl, "SCAN", 0, argc, argv);
1524 static int wpa_cli_cmd_scan_results(struct wpa_ctrl *ctrl, int argc,
1527 return wpa_ctrl_command(ctrl, "SCAN_RESULTS");
1531 static int wpa_cli_cmd_bss(struct wpa_ctrl *ctrl, int argc, char *argv[])
1533 return wpa_cli_cmd(ctrl, "BSS", 1, argc, argv);
1537 static char ** wpa_cli_complete_bss(const char *str, int pos)
1539 int arg = get_cmd_arg_num(str, pos);
1544 res = cli_txt_list_array(&bsses);
1552 static int wpa_cli_cmd_get_capability(struct wpa_ctrl *ctrl, int argc,
1555 if (argc < 1 || argc > 2) {
1556 printf("Invalid GET_CAPABILITY command: need either one or "
1561 if ((argc == 2) && os_strcmp(argv[1], "strict") != 0) {
1562 printf("Invalid GET_CAPABILITY command: second argument, "
1563 "if any, must be 'strict'\n");
1567 return wpa_cli_cmd(ctrl, "GET_CAPABILITY", 1, argc, argv);
1571 static int wpa_cli_list_interfaces(struct wpa_ctrl *ctrl)
1573 printf("Available interfaces:\n");
1574 return wpa_ctrl_command(ctrl, "INTERFACES");
1578 static int wpa_cli_cmd_interface(struct wpa_ctrl *ctrl, int argc, char *argv[])
1581 wpa_cli_list_interfaces(ctrl);
1585 wpa_cli_close_connection();
1586 os_free(ctrl_ifname);
1587 ctrl_ifname = os_strdup(argv[0]);
1589 if (wpa_cli_open_connection(ctrl_ifname, 1)) {
1590 printf("Connected to interface '%s.\n", ctrl_ifname);
1592 printf("Could not connect to interface '%s' - re-trying\n",
1599 static int wpa_cli_cmd_reconfigure(struct wpa_ctrl *ctrl, int argc,
1602 return wpa_ctrl_command(ctrl, "RECONFIGURE");
1606 static int wpa_cli_cmd_terminate(struct wpa_ctrl *ctrl, int argc,
1609 return wpa_ctrl_command(ctrl, "TERMINATE");
1613 static int wpa_cli_cmd_interface_add(struct wpa_ctrl *ctrl, int argc,
1620 printf("Invalid INTERFACE_ADD command: needs at least one "
1621 "argument (interface name)\n"
1622 "All arguments: ifname confname driver ctrl_interface "
1623 "driver_param bridge_name\n");
1628 * INTERFACE_ADD <ifname>TAB<confname>TAB<driver>TAB<ctrl_interface>TAB
1629 * <driver_param>TAB<bridge_name>
1631 res = os_snprintf(cmd, sizeof(cmd),
1632 "INTERFACE_ADD %s\t%s\t%s\t%s\t%s\t%s",
1634 argc > 1 ? argv[1] : "", argc > 2 ? argv[2] : "",
1635 argc > 3 ? argv[3] : "", argc > 4 ? argv[4] : "",
1636 argc > 5 ? argv[5] : "");
1637 if (res < 0 || (size_t) res >= sizeof(cmd))
1639 cmd[sizeof(cmd) - 1] = '\0';
1640 return wpa_ctrl_command(ctrl, cmd);
1644 static int wpa_cli_cmd_interface_remove(struct wpa_ctrl *ctrl, int argc,
1647 return wpa_cli_cmd(ctrl, "INTERFACE_REMOVE", 1, argc, argv);
1651 static int wpa_cli_cmd_interface_list(struct wpa_ctrl *ctrl, int argc,
1654 return wpa_ctrl_command(ctrl, "INTERFACE_LIST");
1659 static int wpa_cli_cmd_sta(struct wpa_ctrl *ctrl, int argc, char *argv[])
1661 return wpa_cli_cmd(ctrl, "STA", 1, argc, argv);
1665 static int wpa_ctrl_command_sta(struct wpa_ctrl *ctrl, char *cmd,
1666 char *addr, size_t addr_len)
1668 char buf[4096], *pos;
1672 if (ctrl_conn == NULL) {
1673 printf("Not connected to hostapd - command dropped.\n");
1676 len = sizeof(buf) - 1;
1677 ret = wpa_ctrl_request(ctrl, cmd, os_strlen(cmd), buf, &len,
1680 printf("'%s' command timed out.\n", cmd);
1682 } else if (ret < 0) {
1683 printf("'%s' command failed.\n", cmd);
1688 if (os_memcmp(buf, "FAIL", 4) == 0)
1693 while (*pos != '\0' && *pos != '\n')
1696 os_strlcpy(addr, buf, addr_len);
1701 static int wpa_cli_cmd_all_sta(struct wpa_ctrl *ctrl, int argc, char *argv[])
1703 char addr[32], cmd[64];
1705 if (wpa_ctrl_command_sta(ctrl, "STA-FIRST", addr, sizeof(addr)))
1708 os_snprintf(cmd, sizeof(cmd), "STA-NEXT %s", addr);
1709 } while (wpa_ctrl_command_sta(ctrl, cmd, addr, sizeof(addr)) == 0);
1715 static int wpa_cli_cmd_deauthenticate(struct wpa_ctrl *ctrl, int argc,
1718 return wpa_cli_cmd(ctrl, "DEAUTHENTICATE", 1, argc, argv);
1722 static int wpa_cli_cmd_disassociate(struct wpa_ctrl *ctrl, int argc,
1725 return wpa_cli_cmd(ctrl, "DISASSOCIATE", 1, argc, argv);
1728 static int wpa_cli_cmd_chanswitch(struct wpa_ctrl *ctrl, int argc,
1731 return wpa_cli_cmd(ctrl, "CHAN_SWITCH", 2, argc, argv);
1734 #endif /* CONFIG_AP */
1737 static int wpa_cli_cmd_suspend(struct wpa_ctrl *ctrl, int argc, char *argv[])
1739 return wpa_ctrl_command(ctrl, "SUSPEND");
1743 static int wpa_cli_cmd_resume(struct wpa_ctrl *ctrl, int argc, char *argv[])
1745 return wpa_ctrl_command(ctrl, "RESUME");
1749 static int wpa_cli_cmd_drop_sa(struct wpa_ctrl *ctrl, int argc, char *argv[])
1751 return wpa_ctrl_command(ctrl, "DROP_SA");
1755 static int wpa_cli_cmd_roam(struct wpa_ctrl *ctrl, int argc, char *argv[])
1757 return wpa_cli_cmd(ctrl, "ROAM", 1, argc, argv);
1763 static int wpa_cli_cmd_p2p_find(struct wpa_ctrl *ctrl, int argc, char *argv[])
1765 return wpa_cli_cmd(ctrl, "P2P_FIND", 0, argc, argv);
1769 static char ** wpa_cli_complete_p2p_find(const char *str, int pos)
1772 int arg = get_cmd_arg_num(str, pos);
1774 res = os_calloc(6, sizeof(char *));
1777 res[0] = os_strdup("type=social");
1778 if (res[0] == NULL) {
1782 res[1] = os_strdup("type=progressive");
1785 res[2] = os_strdup("delay=");
1788 res[3] = os_strdup("dev_id=");
1792 res[4] = os_strdup("[timeout]");
1798 static int wpa_cli_cmd_p2p_stop_find(struct wpa_ctrl *ctrl, int argc,
1801 return wpa_ctrl_command(ctrl, "P2P_STOP_FIND");
1805 static int wpa_cli_cmd_p2p_connect(struct wpa_ctrl *ctrl, int argc,
1808 return wpa_cli_cmd(ctrl, "P2P_CONNECT", 2, argc, argv);
1812 static char ** wpa_cli_complete_p2p_connect(const char *str, int pos)
1814 int arg = get_cmd_arg_num(str, pos);
1819 res = cli_txt_list_array(&p2p_peers);
1827 static int wpa_cli_cmd_p2p_listen(struct wpa_ctrl *ctrl, int argc,
1830 return wpa_cli_cmd(ctrl, "P2P_LISTEN", 0, argc, argv);
1834 static int wpa_cli_cmd_p2p_group_remove(struct wpa_ctrl *ctrl, int argc,
1837 return wpa_cli_cmd(ctrl, "P2P_GROUP_REMOVE", 1, argc, argv);
1841 static char ** wpa_cli_complete_p2p_group_remove(const char *str, int pos)
1843 int arg = get_cmd_arg_num(str, pos);
1848 res = cli_txt_list_array(&p2p_groups);
1856 static int wpa_cli_cmd_p2p_group_add(struct wpa_ctrl *ctrl, int argc,
1859 return wpa_cli_cmd(ctrl, "P2P_GROUP_ADD", 0, argc, argv);
1863 static int wpa_cli_cmd_p2p_prov_disc(struct wpa_ctrl *ctrl, int argc,
1866 if (argc != 2 && argc != 3) {
1867 printf("Invalid P2P_PROV_DISC command: needs at least "
1868 "two arguments, address and config method\n"
1869 "(display, keypad, or pbc) and an optional join\n");
1873 return wpa_cli_cmd(ctrl, "P2P_PROV_DISC", 2, argc, argv);
1877 static int wpa_cli_cmd_p2p_get_passphrase(struct wpa_ctrl *ctrl, int argc,
1880 return wpa_ctrl_command(ctrl, "P2P_GET_PASSPHRASE");
1884 static int wpa_cli_cmd_p2p_serv_disc_req(struct wpa_ctrl *ctrl, int argc,
1889 if (argc != 2 && argc != 4) {
1890 printf("Invalid P2P_SERV_DISC_REQ command: needs two "
1891 "arguments (address and TLVs) or four arguments "
1892 "(address, \"upnp\", version, search target "
1897 if (write_cmd(cmd, sizeof(cmd), "P2P_SERV_DISC_REQ", argc, argv) < 0)
1899 return wpa_ctrl_command(ctrl, cmd);
1903 static int wpa_cli_cmd_p2p_serv_disc_cancel_req(struct wpa_ctrl *ctrl,
1904 int argc, char *argv[])
1906 return wpa_cli_cmd(ctrl, "P2P_SERV_DISC_CANCEL_REQ", 1, argc, argv);
1910 static int wpa_cli_cmd_p2p_serv_disc_resp(struct wpa_ctrl *ctrl, int argc,
1917 printf("Invalid P2P_SERV_DISC_RESP command: needs four "
1918 "arguments (freq, address, dialog token, and TLVs)\n");
1922 res = os_snprintf(cmd, sizeof(cmd), "P2P_SERV_DISC_RESP %s %s %s %s",
1923 argv[0], argv[1], argv[2], argv[3]);
1924 if (res < 0 || (size_t) res >= sizeof(cmd))
1926 cmd[sizeof(cmd) - 1] = '\0';
1927 return wpa_ctrl_command(ctrl, cmd);
1931 static int wpa_cli_cmd_p2p_service_update(struct wpa_ctrl *ctrl, int argc,
1934 return wpa_ctrl_command(ctrl, "P2P_SERVICE_UPDATE");
1938 static int wpa_cli_cmd_p2p_serv_disc_external(struct wpa_ctrl *ctrl,
1939 int argc, char *argv[])
1941 return wpa_cli_cmd(ctrl, "P2P_SERV_DISC_EXTERNAL", 1, argc, argv);
1945 static int wpa_cli_cmd_p2p_service_flush(struct wpa_ctrl *ctrl, int argc,
1948 return wpa_ctrl_command(ctrl, "P2P_SERVICE_FLUSH");
1952 static int wpa_cli_cmd_p2p_service_add(struct wpa_ctrl *ctrl, int argc,
1958 if (argc != 3 && argc != 4) {
1959 printf("Invalid P2P_SERVICE_ADD command: needs three or four "
1965 res = os_snprintf(cmd, sizeof(cmd),
1966 "P2P_SERVICE_ADD %s %s %s %s",
1967 argv[0], argv[1], argv[2], argv[3]);
1969 res = os_snprintf(cmd, sizeof(cmd),
1970 "P2P_SERVICE_ADD %s %s %s",
1971 argv[0], argv[1], argv[2]);
1972 if (res < 0 || (size_t) res >= sizeof(cmd))
1974 cmd[sizeof(cmd) - 1] = '\0';
1975 return wpa_ctrl_command(ctrl, cmd);
1979 static int wpa_cli_cmd_p2p_service_del(struct wpa_ctrl *ctrl, int argc,
1985 if (argc != 2 && argc != 3) {
1986 printf("Invalid P2P_SERVICE_DEL command: needs two or three "
1992 res = os_snprintf(cmd, sizeof(cmd),
1993 "P2P_SERVICE_DEL %s %s %s",
1994 argv[0], argv[1], argv[2]);
1996 res = os_snprintf(cmd, sizeof(cmd),
1997 "P2P_SERVICE_DEL %s %s",
1999 if (res < 0 || (size_t) res >= sizeof(cmd))
2001 cmd[sizeof(cmd) - 1] = '\0';
2002 return wpa_ctrl_command(ctrl, cmd);
2006 static int wpa_cli_cmd_p2p_reject(struct wpa_ctrl *ctrl,
2007 int argc, char *argv[])
2009 return wpa_cli_cmd(ctrl, "P2P_REJECT", 1, argc, argv);
2013 static int wpa_cli_cmd_p2p_invite(struct wpa_ctrl *ctrl,
2014 int argc, char *argv[])
2016 return wpa_cli_cmd(ctrl, "P2P_INVITE", 1, argc, argv);
2020 static int wpa_cli_cmd_p2p_peer(struct wpa_ctrl *ctrl, int argc, char *argv[])
2022 return wpa_cli_cmd(ctrl, "P2P_PEER", 1, argc, argv);
2026 static char ** wpa_cli_complete_p2p_peer(const char *str, int pos)
2028 int arg = get_cmd_arg_num(str, pos);
2033 res = cli_txt_list_array(&p2p_peers);
2041 static int wpa_ctrl_command_p2p_peer(struct wpa_ctrl *ctrl, char *cmd,
2042 char *addr, size_t addr_len,
2045 char buf[4096], *pos;
2049 if (ctrl_conn == NULL)
2051 len = sizeof(buf) - 1;
2052 ret = wpa_ctrl_request(ctrl, cmd, os_strlen(cmd), buf, &len,
2055 printf("'%s' command timed out.\n", cmd);
2057 } else if (ret < 0) {
2058 printf("'%s' command failed.\n", cmd);
2063 if (os_memcmp(buf, "FAIL", 4) == 0)
2067 while (*pos != '\0' && *pos != '\n')
2070 os_strlcpy(addr, buf, addr_len);
2071 if (!discovered || os_strstr(pos, "[PROBE_REQ_ONLY]") == NULL)
2072 printf("%s\n", addr);
2077 static int wpa_cli_cmd_p2p_peers(struct wpa_ctrl *ctrl, int argc, char *argv[])
2079 char addr[32], cmd[64];
2082 discovered = argc > 0 && os_strcmp(argv[0], "discovered") == 0;
2084 if (wpa_ctrl_command_p2p_peer(ctrl, "P2P_PEER FIRST",
2085 addr, sizeof(addr), discovered))
2088 os_snprintf(cmd, sizeof(cmd), "P2P_PEER NEXT-%s", addr);
2089 } while (wpa_ctrl_command_p2p_peer(ctrl, cmd, addr, sizeof(addr),
2096 static int wpa_cli_cmd_p2p_set(struct wpa_ctrl *ctrl, int argc, char *argv[])
2098 return wpa_cli_cmd(ctrl, "P2P_SET", 2, argc, argv);
2102 static char ** wpa_cli_complete_p2p_set(const char *str, int pos)
2104 int arg = get_cmd_arg_num(str, pos);
2105 const char *fields[] = {
2125 int i, num_fields = ARRAY_SIZE(fields);
2128 char **res = os_calloc(num_fields + 1, sizeof(char *));
2131 for (i = 0; i < num_fields; i++) {
2132 res[i] = os_strdup(fields[i]);
2139 if (arg == 2 && os_strncasecmp(str, "p2p_set peer_filter ", 20) == 0)
2140 return cli_txt_list_array(&p2p_peers);
2146 static int wpa_cli_cmd_p2p_flush(struct wpa_ctrl *ctrl, int argc, char *argv[])
2148 return wpa_ctrl_command(ctrl, "P2P_FLUSH");
2152 static int wpa_cli_cmd_p2p_cancel(struct wpa_ctrl *ctrl, int argc,
2155 return wpa_ctrl_command(ctrl, "P2P_CANCEL");
2159 static int wpa_cli_cmd_p2p_unauthorize(struct wpa_ctrl *ctrl, int argc,
2162 return wpa_cli_cmd(ctrl, "P2P_UNAUTHORIZE", 1, argc, argv);
2166 static int wpa_cli_cmd_p2p_presence_req(struct wpa_ctrl *ctrl, int argc,
2169 if (argc != 0 && argc != 2 && argc != 4) {
2170 printf("Invalid P2P_PRESENCE_REQ command: needs two arguments "
2171 "(preferred duration, interval; in microsecods).\n"
2172 "Optional second pair can be used to provide "
2173 "acceptable values.\n");
2177 return wpa_cli_cmd(ctrl, "P2P_PRESENCE_REQ", 0, argc, argv);
2181 static int wpa_cli_cmd_p2p_ext_listen(struct wpa_ctrl *ctrl, int argc,
2184 if (argc != 0 && argc != 2) {
2185 printf("Invalid P2P_EXT_LISTEN command: needs two arguments "
2186 "(availability period, availability interval; in "
2188 "Extended Listen Timing can be cancelled with this "
2189 "command when used without parameters.\n");
2193 return wpa_cli_cmd(ctrl, "P2P_EXT_LISTEN", 0, argc, argv);
2197 static int wpa_cli_cmd_p2p_remove_client(struct wpa_ctrl *ctrl, int argc,
2200 return wpa_cli_cmd(ctrl, "P2P_REMOVE_CLIENT", 1, argc, argv);
2203 #endif /* CONFIG_P2P */
2205 #ifdef CONFIG_WIFI_DISPLAY
2207 static int wpa_cli_cmd_wfd_subelem_set(struct wpa_ctrl *ctrl, int argc,
2213 if (argc != 1 && argc != 2) {
2214 printf("Invalid WFD_SUBELEM_SET command: needs one or two "
2215 "arguments (subelem, hexdump)\n");
2219 res = os_snprintf(cmd, sizeof(cmd), "WFD_SUBELEM_SET %s %s",
2220 argv[0], argc > 1 ? argv[1] : "");
2221 if (res < 0 || (size_t) res >= sizeof(cmd))
2223 cmd[sizeof(cmd) - 1] = '\0';
2224 return wpa_ctrl_command(ctrl, cmd);
2228 static int wpa_cli_cmd_wfd_subelem_get(struct wpa_ctrl *ctrl, int argc,
2235 printf("Invalid WFD_SUBELEM_GET command: needs one "
2236 "argument (subelem)\n");
2240 res = os_snprintf(cmd, sizeof(cmd), "WFD_SUBELEM_GET %s",
2242 if (res < 0 || (size_t) res >= sizeof(cmd))
2244 cmd[sizeof(cmd) - 1] = '\0';
2245 return wpa_ctrl_command(ctrl, cmd);
2247 #endif /* CONFIG_WIFI_DISPLAY */
2250 #ifdef CONFIG_INTERWORKING
2251 static int wpa_cli_cmd_fetch_anqp(struct wpa_ctrl *ctrl, int argc,
2254 return wpa_ctrl_command(ctrl, "FETCH_ANQP");
2258 static int wpa_cli_cmd_stop_fetch_anqp(struct wpa_ctrl *ctrl, int argc,
2261 return wpa_ctrl_command(ctrl, "STOP_FETCH_ANQP");
2265 static int wpa_cli_cmd_interworking_select(struct wpa_ctrl *ctrl, int argc,
2268 return wpa_cli_cmd(ctrl, "INTERWORKING_SELECT", 0, argc, argv);
2272 static int wpa_cli_cmd_interworking_connect(struct wpa_ctrl *ctrl, int argc,
2275 return wpa_cli_cmd(ctrl, "INTERWORKING_CONNECT", 1, argc, argv);
2279 static int wpa_cli_cmd_anqp_get(struct wpa_ctrl *ctrl, int argc, char *argv[])
2281 return wpa_cli_cmd(ctrl, "ANQP_GET", 2, argc, argv);
2285 static int wpa_cli_cmd_gas_request(struct wpa_ctrl *ctrl, int argc,
2288 return wpa_cli_cmd(ctrl, "GAS_REQUEST", 2, argc, argv);
2292 static int wpa_cli_cmd_gas_response_get(struct wpa_ctrl *ctrl, int argc,
2295 return wpa_cli_cmd(ctrl, "GAS_RESPONSE_GET", 2, argc, argv);
2297 #endif /* CONFIG_INTERWORKING */
2302 static int wpa_cli_cmd_hs20_anqp_get(struct wpa_ctrl *ctrl, int argc,
2305 return wpa_cli_cmd(ctrl, "HS20_ANQP_GET", 2, argc, argv);
2309 static int wpa_cli_cmd_get_nai_home_realm_list(struct wpa_ctrl *ctrl, int argc,
2315 printf("Command needs one or two arguments (dst mac addr and "
2316 "optional home realm)\n");
2320 if (write_cmd(cmd, sizeof(cmd), "HS20_GET_NAI_HOME_REALM_LIST",
2324 return wpa_ctrl_command(ctrl, cmd);
2327 #endif /* CONFIG_HS20 */
2330 static int wpa_cli_cmd_sta_autoconnect(struct wpa_ctrl *ctrl, int argc,
2333 return wpa_cli_cmd(ctrl, "STA_AUTOCONNECT", 1, argc, argv);
2337 static int wpa_cli_cmd_tdls_discover(struct wpa_ctrl *ctrl, int argc,
2340 return wpa_cli_cmd(ctrl, "TDLS_DISCOVER", 1, argc, argv);
2344 static int wpa_cli_cmd_tdls_setup(struct wpa_ctrl *ctrl, int argc,
2347 return wpa_cli_cmd(ctrl, "TDLS_SETUP", 1, argc, argv);
2351 static int wpa_cli_cmd_tdls_teardown(struct wpa_ctrl *ctrl, int argc,
2354 return wpa_cli_cmd(ctrl, "TDLS_TEARDOWN", 1, argc, argv);
2358 static int wpa_cli_cmd_signal_poll(struct wpa_ctrl *ctrl, int argc,
2361 return wpa_ctrl_command(ctrl, "SIGNAL_POLL");
2365 static int wpa_cli_cmd_pktcnt_poll(struct wpa_ctrl *ctrl, int argc,
2368 return wpa_ctrl_command(ctrl, "PKTCNT_POLL");
2372 static int wpa_cli_cmd_reauthenticate(struct wpa_ctrl *ctrl, int argc,
2375 return wpa_ctrl_command(ctrl, "REAUTHENTICATE");
2379 #ifdef CONFIG_AUTOSCAN
2381 static int wpa_cli_cmd_autoscan(struct wpa_ctrl *ctrl, int argc, char *argv[])
2384 return wpa_ctrl_command(ctrl, "AUTOSCAN ");
2386 return wpa_cli_cmd(ctrl, "AUTOSCAN", 0, argc, argv);
2389 #endif /* CONFIG_AUTOSCAN */
2394 static int wpa_cli_cmd_wnm_sleep(struct wpa_ctrl *ctrl, int argc, char *argv[])
2396 return wpa_cli_cmd(ctrl, "WNM_SLEEP", 0, argc, argv);
2400 static int wpa_cli_cmd_wnm_bss_query(struct wpa_ctrl *ctrl, int argc, char *argv[])
2402 return wpa_cli_cmd(ctrl, "WNM_BSS_QUERY", 1, argc, argv);
2405 #endif /* CONFIG_WNM */
2408 static int wpa_cli_cmd_raw(struct wpa_ctrl *ctrl, int argc, char *argv[])
2412 return wpa_cli_cmd(ctrl, argv[0], 0, argc - 1, &argv[1]);
2417 static int wpa_cli_cmd_driver(struct wpa_ctrl *ctrl, int argc, char *argv[])
2419 return wpa_cli_cmd(ctrl, "DRIVER", 1, argc, argv);
2421 #endif /* ANDROID */
2424 static int wpa_cli_cmd_flush(struct wpa_ctrl *ctrl, int argc, char *argv[])
2426 return wpa_ctrl_command(ctrl, "FLUSH");
2430 static int wpa_cli_cmd_radio_work(struct wpa_ctrl *ctrl, int argc, char *argv[])
2432 return wpa_cli_cmd(ctrl, "RADIO_WORK", 1, argc, argv);
2436 enum wpa_cli_cmd_flags {
2437 cli_cmd_flag_none = 0x00,
2438 cli_cmd_flag_sensitive = 0x01
2441 struct wpa_cli_cmd {
2443 int (*handler)(struct wpa_ctrl *ctrl, int argc, char *argv[]);
2444 char ** (*completion)(const char *str, int pos);
2445 enum wpa_cli_cmd_flags flags;
2449 static struct wpa_cli_cmd wpa_cli_commands[] = {
2450 { "status", wpa_cli_cmd_status, NULL,
2452 "[verbose] = get current WPA/EAPOL/EAP status" },
2453 { "ifname", wpa_cli_cmd_ifname, NULL,
2455 "= get current interface name" },
2456 { "ping", wpa_cli_cmd_ping, NULL,
2458 "= pings wpa_supplicant" },
2459 { "relog", wpa_cli_cmd_relog, NULL,
2461 "= re-open log-file (allow rolling logs)" },
2462 { "note", wpa_cli_cmd_note, NULL,
2464 "<text> = add a note to wpa_supplicant debug log" },
2465 { "mib", wpa_cli_cmd_mib, NULL,
2467 "= get MIB variables (dot1x, dot11)" },
2468 { "help", wpa_cli_cmd_help, wpa_cli_complete_help,
2470 "[command] = show usage help" },
2471 { "interface", wpa_cli_cmd_interface, NULL,
2473 "[ifname] = show interfaces/select interface" },
2474 { "level", wpa_cli_cmd_level, NULL,
2476 "<debug level> = change debug level" },
2477 { "license", wpa_cli_cmd_license, NULL,
2479 "= show full wpa_cli license" },
2480 { "quit", wpa_cli_cmd_quit, NULL,
2483 { "set", wpa_cli_cmd_set, wpa_cli_complete_set,
2485 "= set variables (shows list of variables when run without "
2487 { "get", wpa_cli_cmd_get, NULL,
2489 "<name> = get information" },
2490 { "logon", wpa_cli_cmd_logon, NULL,
2492 "= IEEE 802.1X EAPOL state machine logon" },
2493 { "logoff", wpa_cli_cmd_logoff, NULL,
2495 "= IEEE 802.1X EAPOL state machine logoff" },
2496 { "pmksa", wpa_cli_cmd_pmksa, NULL,
2498 "= show PMKSA cache" },
2499 { "reassociate", wpa_cli_cmd_reassociate, NULL,
2501 "= force reassociation" },
2502 { "preauthenticate", wpa_cli_cmd_preauthenticate, wpa_cli_complete_bss,
2504 "<BSSID> = force preauthentication" },
2505 { "identity", wpa_cli_cmd_identity, NULL,
2507 "<network id> <identity> = configure identity for an SSID" },
2508 { "password", wpa_cli_cmd_password, NULL,
2509 cli_cmd_flag_sensitive,
2510 "<network id> <password> = configure password for an SSID" },
2511 { "new_password", wpa_cli_cmd_new_password, NULL,
2512 cli_cmd_flag_sensitive,
2513 "<network id> <password> = change password for an SSID" },
2514 { "pin", wpa_cli_cmd_pin, NULL,
2515 cli_cmd_flag_sensitive,
2516 "<network id> <pin> = configure pin for an SSID" },
2517 { "otp", wpa_cli_cmd_otp, NULL,
2518 cli_cmd_flag_sensitive,
2519 "<network id> <password> = configure one-time-password for an SSID"
2521 { "passphrase", wpa_cli_cmd_passphrase, NULL,
2522 cli_cmd_flag_sensitive,
2523 "<network id> <passphrase> = configure private key passphrase\n"
2525 { "sim", wpa_cli_cmd_sim, NULL,
2526 cli_cmd_flag_sensitive,
2527 "<network id> <pin> = report SIM operation result" },
2528 { "bssid", wpa_cli_cmd_bssid, NULL,
2530 "<network id> <BSSID> = set preferred BSSID for an SSID" },
2531 { "blacklist", wpa_cli_cmd_blacklist, wpa_cli_complete_bss,
2533 "<BSSID> = add a BSSID to the blacklist\n"
2534 "blacklist clear = clear the blacklist\n"
2535 "blacklist = display the blacklist" },
2536 { "log_level", wpa_cli_cmd_log_level, NULL,
2538 "<level> [<timestamp>] = update the log level/timestamp\n"
2539 "log_level = display the current log level and log options" },
2540 { "list_networks", wpa_cli_cmd_list_networks, NULL,
2542 "= list configured networks" },
2543 { "select_network", wpa_cli_cmd_select_network, NULL,
2545 "<network id> = select a network (disable others)" },
2546 { "enable_network", wpa_cli_cmd_enable_network, NULL,
2548 "<network id> = enable a network" },
2549 { "disable_network", wpa_cli_cmd_disable_network, NULL,
2551 "<network id> = disable a network" },
2552 { "add_network", wpa_cli_cmd_add_network, NULL,
2554 "= add a network" },
2555 { "remove_network", wpa_cli_cmd_remove_network, NULL,
2557 "<network id> = remove a network" },
2558 { "set_network", wpa_cli_cmd_set_network, NULL,
2559 cli_cmd_flag_sensitive,
2560 "<network id> <variable> <value> = set network variables (shows\n"
2561 " list of variables when run without arguments)" },
2562 { "get_network", wpa_cli_cmd_get_network, NULL,
2564 "<network id> <variable> = get network variables" },
2565 { "list_creds", wpa_cli_cmd_list_creds, NULL,
2567 "= list configured credentials" },
2568 { "add_cred", wpa_cli_cmd_add_cred, NULL,
2570 "= add a credential" },
2571 { "remove_cred", wpa_cli_cmd_remove_cred, NULL,
2573 "<cred id> = remove a credential" },
2574 { "set_cred", wpa_cli_cmd_set_cred, NULL,
2575 cli_cmd_flag_sensitive,
2576 "<cred id> <variable> <value> = set credential variables" },
2577 { "save_config", wpa_cli_cmd_save_config, NULL,
2579 "= save the current configuration" },
2580 { "disconnect", wpa_cli_cmd_disconnect, NULL,
2582 "= disconnect and wait for reassociate/reconnect command before\n"
2584 { "reconnect", wpa_cli_cmd_reconnect, NULL,
2586 "= like reassociate, but only takes effect if already disconnected"
2588 { "scan", wpa_cli_cmd_scan, NULL,
2590 "= request new BSS scan" },
2591 { "scan_results", wpa_cli_cmd_scan_results, NULL,
2593 "= get latest scan results" },
2594 { "bss", wpa_cli_cmd_bss, wpa_cli_complete_bss,
2596 "<<idx> | <bssid>> = get detailed scan result info" },
2597 { "get_capability", wpa_cli_cmd_get_capability, NULL,
2599 "<eap/pairwise/group/key_mgmt/proto/auth_alg/channels/freq/modes> "
2600 "= get capabilies" },
2601 { "reconfigure", wpa_cli_cmd_reconfigure, NULL,
2603 "= force wpa_supplicant to re-read its configuration file" },
2604 { "terminate", wpa_cli_cmd_terminate, NULL,
2606 "= terminate wpa_supplicant" },
2607 { "interface_add", wpa_cli_cmd_interface_add, NULL,
2609 "<ifname> <confname> <driver> <ctrl_interface> <driver_param>\n"
2610 " <bridge_name> = adds new interface, all parameters but <ifname>\n"
2612 { "interface_remove", wpa_cli_cmd_interface_remove, NULL,
2614 "<ifname> = removes the interface" },
2615 { "interface_list", wpa_cli_cmd_interface_list, NULL,
2617 "= list available interfaces" },
2618 { "ap_scan", wpa_cli_cmd_ap_scan, NULL,
2620 "<value> = set ap_scan parameter" },
2621 { "scan_interval", wpa_cli_cmd_scan_interval, NULL,
2623 "<value> = set scan_interval parameter (in seconds)" },
2624 { "bss_expire_age", wpa_cli_cmd_bss_expire_age, NULL,
2626 "<value> = set BSS expiration age parameter" },
2627 { "bss_expire_count", wpa_cli_cmd_bss_expire_count, NULL,
2629 "<value> = set BSS expiration scan count parameter" },
2630 { "bss_flush", wpa_cli_cmd_bss_flush, NULL,
2632 "<value> = set BSS flush age (0 by default)" },
2633 { "stkstart", wpa_cli_cmd_stkstart, NULL,
2635 "<addr> = request STK negotiation with <addr>" },
2636 { "ft_ds", wpa_cli_cmd_ft_ds, wpa_cli_complete_bss,
2638 "<addr> = request over-the-DS FT with <addr>" },
2639 { "wps_pbc", wpa_cli_cmd_wps_pbc, wpa_cli_complete_bss,
2641 "[BSSID] = start Wi-Fi Protected Setup: Push Button Configuration" },
2642 { "wps_pin", wpa_cli_cmd_wps_pin, wpa_cli_complete_bss,
2643 cli_cmd_flag_sensitive,
2644 "<BSSID> [PIN] = start WPS PIN method (returns PIN, if not "
2646 { "wps_check_pin", wpa_cli_cmd_wps_check_pin, NULL,
2647 cli_cmd_flag_sensitive,
2648 "<PIN> = verify PIN checksum" },
2649 { "wps_cancel", wpa_cli_cmd_wps_cancel, NULL, cli_cmd_flag_none,
2650 "Cancels the pending WPS operation" },
2651 #ifdef CONFIG_WPS_NFC
2652 { "wps_nfc", wpa_cli_cmd_wps_nfc, wpa_cli_complete_bss,
2654 "[BSSID] = start Wi-Fi Protected Setup: NFC" },
2655 { "wps_nfc_config_token", wpa_cli_cmd_wps_nfc_config_token, NULL,
2657 "<WPS|NDEF> = build configuration token" },
2658 { "wps_nfc_token", wpa_cli_cmd_wps_nfc_token, NULL,
2660 "<WPS|NDEF> = create password token" },
2661 { "wps_nfc_tag_read", wpa_cli_cmd_wps_nfc_tag_read, NULL,
2662 cli_cmd_flag_sensitive,
2663 "<hexdump of payload> = report read NFC tag with WPS data" },
2664 { "nfc_get_handover_req", wpa_cli_cmd_nfc_get_handover_req, NULL,
2666 "<NDEF> <WPS> = create NFC handover request" },
2667 { "nfc_get_handover_sel", wpa_cli_cmd_nfc_get_handover_sel, NULL,
2669 "<NDEF> <WPS> = create NFC handover select" },
2670 { "nfc_rx_handover_req", wpa_cli_cmd_nfc_rx_handover_req, NULL,
2672 "<hexdump of payload> = report received NFC handover request" },
2673 { "nfc_rx_handover_sel", wpa_cli_cmd_nfc_rx_handover_sel, NULL,
2675 "<hexdump of payload> = report received NFC handover select" },
2676 { "nfc_report_handover", wpa_cli_cmd_nfc_report_handover, NULL,
2678 "<role> <type> <hexdump of req> <hexdump of sel> = report completed "
2680 #endif /* CONFIG_WPS_NFC */
2681 { "wps_reg", wpa_cli_cmd_wps_reg, wpa_cli_complete_bss,
2682 cli_cmd_flag_sensitive,
2683 "<BSSID> <AP PIN> = start WPS Registrar to configure an AP" },
2684 { "wps_ap_pin", wpa_cli_cmd_wps_ap_pin, NULL,
2685 cli_cmd_flag_sensitive,
2686 "[params..] = enable/disable AP PIN" },
2687 { "wps_er_start", wpa_cli_cmd_wps_er_start, NULL,
2689 "[IP address] = start Wi-Fi Protected Setup External Registrar" },
2690 { "wps_er_stop", wpa_cli_cmd_wps_er_stop, NULL,
2692 "= stop Wi-Fi Protected Setup External Registrar" },
2693 { "wps_er_pin", wpa_cli_cmd_wps_er_pin, NULL,
2694 cli_cmd_flag_sensitive,
2695 "<UUID> <PIN> = add an Enrollee PIN to External Registrar" },
2696 { "wps_er_pbc", wpa_cli_cmd_wps_er_pbc, NULL,
2698 "<UUID> = accept an Enrollee PBC using External Registrar" },
2699 { "wps_er_learn", wpa_cli_cmd_wps_er_learn, NULL,
2700 cli_cmd_flag_sensitive,
2701 "<UUID> <PIN> = learn AP configuration" },
2702 { "wps_er_set_config", wpa_cli_cmd_wps_er_set_config, NULL,
2704 "<UUID> <network id> = set AP configuration for enrolling" },
2705 { "wps_er_config", wpa_cli_cmd_wps_er_config, NULL,
2706 cli_cmd_flag_sensitive,
2707 "<UUID> <PIN> <SSID> <auth> <encr> <key> = configure AP" },
2708 #ifdef CONFIG_WPS_NFC
2709 { "wps_er_nfc_config_token", wpa_cli_cmd_wps_er_nfc_config_token, NULL,
2711 "<WPS/NDEF> <UUID> = build NFC configuration token" },
2712 #endif /* CONFIG_WPS_NFC */
2713 { "ibss_rsn", wpa_cli_cmd_ibss_rsn, NULL,
2715 "<addr> = request RSN authentication with <addr> in IBSS" },
2717 { "sta", wpa_cli_cmd_sta, NULL,
2719 "<addr> = get information about an associated station (AP)" },
2720 { "all_sta", wpa_cli_cmd_all_sta, NULL,
2722 "= get information about all associated stations (AP)" },
2723 { "deauthenticate", wpa_cli_cmd_deauthenticate, NULL,
2725 "<addr> = deauthenticate a station" },
2726 { "disassociate", wpa_cli_cmd_disassociate, NULL,
2728 "<addr> = disassociate a station" },
2729 { "chan_switch", wpa_cli_cmd_chanswitch, NULL,
2731 "<cs_count> <freq> [sec_channel_offset=] [center_freq1=]"
2732 " [center_freq2=] [bandwidth=] [blocktx] [ht|vht]"
2733 " = CSA parameters" },
2734 #endif /* CONFIG_AP */
2735 { "suspend", wpa_cli_cmd_suspend, NULL, cli_cmd_flag_none,
2736 "= notification of suspend/hibernate" },
2737 { "resume", wpa_cli_cmd_resume, NULL, cli_cmd_flag_none,
2738 "= notification of resume/thaw" },
2739 { "drop_sa", wpa_cli_cmd_drop_sa, NULL, cli_cmd_flag_none,
2740 "= drop SA without deauth/disassoc (test command)" },
2741 { "roam", wpa_cli_cmd_roam, wpa_cli_complete_bss,
2743 "<addr> = roam to the specified BSS" },
2745 { "p2p_find", wpa_cli_cmd_p2p_find, wpa_cli_complete_p2p_find,
2747 "[timeout] [type=*] = find P2P Devices for up-to timeout seconds" },
2748 { "p2p_stop_find", wpa_cli_cmd_p2p_stop_find, NULL, cli_cmd_flag_none,
2749 "= stop P2P Devices search" },
2750 { "p2p_connect", wpa_cli_cmd_p2p_connect, wpa_cli_complete_p2p_connect,
2752 "<addr> <\"pbc\"|PIN> [ht40] = connect to a P2P Device" },
2753 { "p2p_listen", wpa_cli_cmd_p2p_listen, NULL, cli_cmd_flag_none,
2754 "[timeout] = listen for P2P Devices for up-to timeout seconds" },
2755 { "p2p_group_remove", wpa_cli_cmd_p2p_group_remove,
2756 wpa_cli_complete_p2p_group_remove, cli_cmd_flag_none,
2757 "<ifname> = remove P2P group interface (terminate group if GO)" },
2758 { "p2p_group_add", wpa_cli_cmd_p2p_group_add, NULL, cli_cmd_flag_none,
2759 "[ht40] = add a new P2P group (local end as GO)" },
2760 { "p2p_prov_disc", wpa_cli_cmd_p2p_prov_disc,
2761 wpa_cli_complete_p2p_peer, cli_cmd_flag_none,
2762 "<addr> <method> = request provisioning discovery" },
2763 { "p2p_get_passphrase", wpa_cli_cmd_p2p_get_passphrase, NULL,
2765 "= get the passphrase for a group (GO only)" },
2766 { "p2p_serv_disc_req", wpa_cli_cmd_p2p_serv_disc_req,
2767 wpa_cli_complete_p2p_peer, cli_cmd_flag_none,
2768 "<addr> <TLVs> = schedule service discovery request" },
2769 { "p2p_serv_disc_cancel_req", wpa_cli_cmd_p2p_serv_disc_cancel_req,
2770 NULL, cli_cmd_flag_none,
2771 "<id> = cancel pending service discovery request" },
2772 { "p2p_serv_disc_resp", wpa_cli_cmd_p2p_serv_disc_resp, NULL,
2774 "<freq> <addr> <dialog token> <TLVs> = service discovery response" },
2775 { "p2p_service_update", wpa_cli_cmd_p2p_service_update, NULL,
2777 "= indicate change in local services" },
2778 { "p2p_serv_disc_external", wpa_cli_cmd_p2p_serv_disc_external, NULL,
2780 "<external> = set external processing of service discovery" },
2781 { "p2p_service_flush", wpa_cli_cmd_p2p_service_flush, NULL,
2783 "= remove all stored service entries" },
2784 { "p2p_service_add", wpa_cli_cmd_p2p_service_add, NULL,
2786 "<bonjour|upnp> <query|version> <response|service> = add a local "
2788 { "p2p_service_del", wpa_cli_cmd_p2p_service_del, NULL,
2790 "<bonjour|upnp> <query|version> [|service] = remove a local "
2792 { "p2p_reject", wpa_cli_cmd_p2p_reject, wpa_cli_complete_p2p_peer,
2794 "<addr> = reject connection attempts from a specific peer" },
2795 { "p2p_invite", wpa_cli_cmd_p2p_invite, NULL,
2797 "<cmd> [peer=addr] = invite peer" },
2798 { "p2p_peers", wpa_cli_cmd_p2p_peers, NULL, cli_cmd_flag_none,
2799 "[discovered] = list known (optionally, only fully discovered) P2P "
2801 { "p2p_peer", wpa_cli_cmd_p2p_peer, wpa_cli_complete_p2p_peer,
2803 "<address> = show information about known P2P peer" },
2804 { "p2p_set", wpa_cli_cmd_p2p_set, wpa_cli_complete_p2p_set,
2806 "<field> <value> = set a P2P parameter" },
2807 { "p2p_flush", wpa_cli_cmd_p2p_flush, NULL, cli_cmd_flag_none,
2808 "= flush P2P state" },
2809 { "p2p_cancel", wpa_cli_cmd_p2p_cancel, NULL, cli_cmd_flag_none,
2810 "= cancel P2P group formation" },
2811 { "p2p_unauthorize", wpa_cli_cmd_p2p_unauthorize,
2812 wpa_cli_complete_p2p_peer, cli_cmd_flag_none,
2813 "<address> = unauthorize a peer" },
2814 { "p2p_presence_req", wpa_cli_cmd_p2p_presence_req, NULL,
2816 "[<duration> <interval>] [<duration> <interval>] = request GO "
2818 { "p2p_ext_listen", wpa_cli_cmd_p2p_ext_listen, NULL,
2820 "[<period> <interval>] = set extended listen timing" },
2821 { "p2p_remove_client", wpa_cli_cmd_p2p_remove_client,
2822 wpa_cli_complete_p2p_peer, cli_cmd_flag_none,
2823 "<address|iface=address> = remove a peer from all groups" },
2824 #endif /* CONFIG_P2P */
2825 #ifdef CONFIG_WIFI_DISPLAY
2826 { "wfd_subelem_set", wpa_cli_cmd_wfd_subelem_set, NULL,
2828 "<subelem> [contents] = set Wi-Fi Display subelement" },
2829 { "wfd_subelem_get", wpa_cli_cmd_wfd_subelem_get, NULL,
2831 "<subelem> = get Wi-Fi Display subelement" },
2832 #endif /* CONFIG_WIFI_DISPLAY */
2833 #ifdef CONFIG_INTERWORKING
2834 { "fetch_anqp", wpa_cli_cmd_fetch_anqp, NULL, cli_cmd_flag_none,
2835 "= fetch ANQP information for all APs" },
2836 { "stop_fetch_anqp", wpa_cli_cmd_stop_fetch_anqp, NULL,
2838 "= stop fetch_anqp operation" },
2839 { "interworking_select", wpa_cli_cmd_interworking_select, NULL,
2841 "[auto] = perform Interworking network selection" },
2842 { "interworking_connect", wpa_cli_cmd_interworking_connect,
2843 wpa_cli_complete_bss, cli_cmd_flag_none,
2844 "<BSSID> = connect using Interworking credentials" },
2845 { "anqp_get", wpa_cli_cmd_anqp_get, wpa_cli_complete_bss,
2847 "<addr> <info id>[,<info id>]... = request ANQP information" },
2848 { "gas_request", wpa_cli_cmd_gas_request, wpa_cli_complete_bss,
2850 "<addr> <AdvProtoID> [QueryReq] = GAS request" },
2851 { "gas_response_get", wpa_cli_cmd_gas_response_get,
2852 wpa_cli_complete_bss, cli_cmd_flag_none,
2853 "<addr> <dialog token> [start,len] = Fetch last GAS response" },
2854 #endif /* CONFIG_INTERWORKING */
2856 { "hs20_anqp_get", wpa_cli_cmd_hs20_anqp_get, wpa_cli_complete_bss,
2858 "<addr> <subtype>[,<subtype>]... = request HS 2.0 ANQP information"
2860 { "nai_home_realm_list", wpa_cli_cmd_get_nai_home_realm_list,
2861 wpa_cli_complete_bss, cli_cmd_flag_none,
2862 "<addr> <home realm> = get HS20 nai home realm list" },
2863 #endif /* CONFIG_HS20 */
2864 { "sta_autoconnect", wpa_cli_cmd_sta_autoconnect, NULL,
2866 "<0/1> = disable/enable automatic reconnection" },
2867 { "tdls_discover", wpa_cli_cmd_tdls_discover, NULL,
2869 "<addr> = request TDLS discovery with <addr>" },
2870 { "tdls_setup", wpa_cli_cmd_tdls_setup, NULL,
2872 "<addr> = request TDLS setup with <addr>" },
2873 { "tdls_teardown", wpa_cli_cmd_tdls_teardown, NULL,
2875 "<addr> = tear down TDLS with <addr>" },
2876 { "signal_poll", wpa_cli_cmd_signal_poll, NULL,
2878 "= get signal parameters" },
2879 { "pktcnt_poll", wpa_cli_cmd_pktcnt_poll, NULL,
2881 "= get TX/RX packet counters" },
2882 { "reauthenticate", wpa_cli_cmd_reauthenticate, NULL,
2884 "= trigger IEEE 802.1X/EAPOL reauthentication" },
2885 #ifdef CONFIG_AUTOSCAN
2886 { "autoscan", wpa_cli_cmd_autoscan, NULL, cli_cmd_flag_none,
2887 "[params] = Set or unset (if none) autoscan parameters" },
2888 #endif /* CONFIG_AUTOSCAN */
2890 { "wnm_sleep", wpa_cli_cmd_wnm_sleep, NULL, cli_cmd_flag_none,
2891 "<enter/exit> [interval=#] = enter/exit WNM-Sleep mode" },
2892 { "wnm_bss_query", wpa_cli_cmd_wnm_bss_query, NULL, cli_cmd_flag_none,
2893 "<query reason> = Send BSS Transition Management Query" },
2894 #endif /* CONFIG_WNM */
2895 { "raw", wpa_cli_cmd_raw, NULL, cli_cmd_flag_sensitive,
2896 "<params..> = Sent unprocessed command" },
2897 { "flush", wpa_cli_cmd_flush, NULL, cli_cmd_flag_none,
2898 "= flush wpa_supplicant state" },
2900 { "driver", wpa_cli_cmd_driver, NULL, cli_cmd_flag_none,
2901 "<command> = driver private commands" },
2902 #endif /* ANDROID */
2903 { "radio_work", wpa_cli_cmd_radio_work, NULL, cli_cmd_flag_none,
2904 "= radio_work <show/add/done>" },
2905 { NULL, NULL, NULL, cli_cmd_flag_none, NULL }
2910 * Prints command usage, lines are padded with the specified string.
2912 static void print_cmd_help(struct wpa_cli_cmd *cmd, const char *pad)
2917 printf("%s%s ", pad, cmd->cmd);
2918 for (n = 0; (c = cmd->usage[n]); n++) {
2927 static void print_help(const char *cmd)
2930 printf("commands:\n");
2931 for (n = 0; wpa_cli_commands[n].cmd; n++) {
2932 if (cmd == NULL || str_starts(wpa_cli_commands[n].cmd, cmd))
2933 print_cmd_help(&wpa_cli_commands[n], " ");
2938 static int wpa_cli_edit_filter_history_cb(void *ctx, const char *cmd)
2940 const char *c, *delim;
2944 delim = os_strchr(cmd, ' ');
2948 len = os_strlen(cmd);
2950 for (n = 0; (c = wpa_cli_commands[n].cmd); n++) {
2951 if (os_strncasecmp(cmd, c, len) == 0 && len == os_strlen(c))
2952 return (wpa_cli_commands[n].flags &
2953 cli_cmd_flag_sensitive);
2959 static char ** wpa_list_cmd_list(void)
2963 struct cli_txt_entry *e;
2965 count = ARRAY_SIZE(wpa_cli_commands);
2966 count += dl_list_len(&p2p_groups);
2967 count += dl_list_len(&ifnames);
2968 res = os_calloc(count + 1, sizeof(char *));
2972 for (i = 0; wpa_cli_commands[i].cmd; i++) {
2973 res[i] = os_strdup(wpa_cli_commands[i].cmd);
2978 dl_list_for_each(e, &p2p_groups, struct cli_txt_entry, list) {
2979 size_t len = 8 + os_strlen(e->txt);
2980 res[i] = os_malloc(len);
2983 os_snprintf(res[i], len, "ifname=%s", e->txt);
2987 dl_list_for_each(e, &ifnames, struct cli_txt_entry, list) {
2988 res[i] = os_strdup(e->txt);
2998 static char ** wpa_cli_cmd_completion(const char *cmd, const char *str,
3003 for (i = 0; wpa_cli_commands[i].cmd; i++) {
3004 if (os_strcasecmp(wpa_cli_commands[i].cmd, cmd) == 0) {
3005 if (wpa_cli_commands[i].completion)
3006 return wpa_cli_commands[i].completion(str,
3009 printf("\r%s\n", wpa_cli_commands[i].usage);
3019 static char ** wpa_cli_edit_completion_cb(void *ctx, const char *str, int pos)
3025 if (pos > 7 && os_strncasecmp(str, "IFNAME=", 7) == 0) {
3026 end = os_strchr(str, ' ');
3027 if (end && pos > end - str) {
3028 pos -= end - str + 1;
3033 end = os_strchr(str, ' ');
3034 if (end == NULL || str + pos < end)
3035 return wpa_list_cmd_list();
3037 cmd = os_malloc(pos + 1);
3040 os_memcpy(cmd, str, pos);
3041 cmd[end - str] = '\0';
3042 res = wpa_cli_cmd_completion(cmd, str, pos);
3048 static int wpa_request(struct wpa_ctrl *ctrl, int argc, char *argv[])
3050 struct wpa_cli_cmd *cmd, *match = NULL;
3054 if (argc > 1 && os_strncasecmp(argv[0], "IFNAME=", 7) == 0) {
3055 ifname_prefix = argv[0] + 7;
3059 ifname_prefix = NULL;
3065 cmd = wpa_cli_commands;
3067 if (os_strncasecmp(cmd->cmd, argv[0], os_strlen(argv[0])) == 0)
3070 if (os_strcasecmp(cmd->cmd, argv[0]) == 0) {
3071 /* we have an exact match */
3081 printf("Ambiguous command '%s'; possible commands:", argv[0]);
3082 cmd = wpa_cli_commands;
3084 if (os_strncasecmp(cmd->cmd, argv[0],
3085 os_strlen(argv[0])) == 0) {
3086 printf(" %s", cmd->cmd);
3092 } else if (count == 0) {
3093 printf("Unknown command '%s'\n", argv[0]);
3096 ret = match->handler(ctrl, argc - 1, &argv[1]);
3103 static int str_match(const char *a, const char *b)
3105 return os_strncmp(a, b, os_strlen(b)) == 0;
3109 static int wpa_cli_exec(const char *program, const char *arg1,
3117 len = os_strlen(program) + os_strlen(arg1) + os_strlen(arg2) + 3;
3118 cmd = os_malloc(len);
3121 res = os_snprintf(cmd, len, "%s %s %s", program, arg1, arg2);
3122 if (res < 0 || (size_t) res >= len) {
3126 cmd[len - 1] = '\0';
3128 if (system(cmd) < 0)
3130 #endif /* _WIN32_WCE */
3137 static void wpa_cli_action_process(const char *msg)
3140 char *copy = NULL, *id, *pos2;
3145 pos = os_strchr(pos, '>');
3152 if (str_match(pos, WPA_EVENT_CONNECTED)) {
3154 os_unsetenv("WPA_ID");
3155 os_unsetenv("WPA_ID_STR");
3156 os_unsetenv("WPA_CTRL_DIR");
3158 pos = os_strstr(pos, "[id=");
3160 copy = os_strdup(pos + 4);
3164 while (*pos2 && *pos2 != ' ')
3168 os_setenv("WPA_ID", id, 1);
3169 while (*pos2 && *pos2 != '=')
3174 while (*pos2 && *pos2 != ']')
3177 os_setenv("WPA_ID_STR", id, 1);
3181 os_setenv("WPA_CTRL_DIR", ctrl_iface_dir, 1);
3183 if (wpa_cli_connected <= 0 || new_id != wpa_cli_last_id) {
3184 wpa_cli_connected = 1;
3185 wpa_cli_last_id = new_id;
3186 wpa_cli_exec(action_file, ctrl_ifname, "CONNECTED");
3188 } else if (str_match(pos, WPA_EVENT_DISCONNECTED)) {
3189 if (wpa_cli_connected) {
3190 wpa_cli_connected = 0;
3191 wpa_cli_exec(action_file, ctrl_ifname, "DISCONNECTED");
3193 } else if (str_match(pos, P2P_EVENT_GROUP_STARTED)) {
3194 wpa_cli_exec(action_file, ctrl_ifname, pos);
3195 } else if (str_match(pos, P2P_EVENT_GROUP_REMOVED)) {
3196 wpa_cli_exec(action_file, ctrl_ifname, pos);
3197 } else if (str_match(pos, P2P_EVENT_CROSS_CONNECT_ENABLE)) {
3198 wpa_cli_exec(action_file, ctrl_ifname, pos);
3199 } else if (str_match(pos, P2P_EVENT_CROSS_CONNECT_DISABLE)) {
3200 wpa_cli_exec(action_file, ctrl_ifname, pos);
3201 } else if (str_match(pos, P2P_EVENT_GO_NEG_FAILURE)) {
3202 wpa_cli_exec(action_file, ctrl_ifname, pos);
3203 } else if (str_match(pos, WPS_EVENT_SUCCESS)) {
3204 wpa_cli_exec(action_file, ctrl_ifname, pos);
3205 } else if (str_match(pos, WPS_EVENT_FAIL)) {
3206 wpa_cli_exec(action_file, ctrl_ifname, pos);
3207 } else if (str_match(pos, AP_STA_CONNECTED)) {
3208 wpa_cli_exec(action_file, ctrl_ifname, pos);
3209 } else if (str_match(pos, AP_STA_DISCONNECTED)) {
3210 wpa_cli_exec(action_file, ctrl_ifname, pos);
3211 } else if (str_match(pos, ESS_DISASSOC_IMMINENT)) {
3212 wpa_cli_exec(action_file, ctrl_ifname, pos);
3213 } else if (str_match(pos, WPA_EVENT_TERMINATING)) {
3214 printf("wpa_supplicant is terminating - stop monitoring\n");
3220 #ifndef CONFIG_ANSI_C_EXTRA
3221 static void wpa_cli_action_cb(char *msg, size_t len)
3223 wpa_cli_action_process(msg);
3225 #endif /* CONFIG_ANSI_C_EXTRA */
3228 static void wpa_cli_reconnect(void)
3230 wpa_cli_close_connection();
3231 if (wpa_cli_open_connection(ctrl_ifname, 1) < 0)
3236 printf("\rConnection to wpa_supplicant re-established\n");
3242 static void cli_event(const char *str)
3244 const char *start, *s;
3246 start = os_strchr(str, '>');
3252 if (str_starts(start, WPA_EVENT_BSS_ADDED)) {
3253 s = os_strchr(start, ' ');
3256 s = os_strchr(s + 1, ' ');
3259 cli_txt_list_add(&bsses, s + 1);
3263 if (str_starts(start, WPA_EVENT_BSS_REMOVED)) {
3264 s = os_strchr(start, ' ');
3267 s = os_strchr(s + 1, ' ');
3270 cli_txt_list_del_addr(&bsses, s + 1);
3275 if (str_starts(start, P2P_EVENT_DEVICE_FOUND)) {
3276 s = os_strstr(start, " p2p_dev_addr=");
3279 cli_txt_list_add_addr(&p2p_peers, s + 14);
3283 if (str_starts(start, P2P_EVENT_DEVICE_LOST)) {
3284 s = os_strstr(start, " p2p_dev_addr=");
3287 cli_txt_list_del_addr(&p2p_peers, s + 14);
3291 if (str_starts(start, P2P_EVENT_GROUP_STARTED)) {
3292 s = os_strchr(start, ' ');
3295 cli_txt_list_add_word(&p2p_groups, s + 1);
3299 if (str_starts(start, P2P_EVENT_GROUP_REMOVED)) {
3300 s = os_strchr(start, ' ');
3303 cli_txt_list_del_word(&p2p_groups, s + 1);
3306 #endif /* CONFIG_P2P */
3310 static int check_terminating(const char *msg)
3312 const char *pos = msg;
3316 pos = os_strchr(pos, '>');
3323 if (str_match(pos, WPA_EVENT_TERMINATING) && ctrl_conn) {
3325 printf("\rConnection to wpa_supplicant lost - trying to "
3328 wpa_cli_attached = 0;
3329 wpa_cli_close_connection();
3337 static void wpa_cli_recv_pending(struct wpa_ctrl *ctrl, int action_monitor)
3339 if (ctrl_conn == NULL) {
3340 wpa_cli_reconnect();
3343 while (wpa_ctrl_pending(ctrl) > 0) {
3345 size_t len = sizeof(buf) - 1;
3346 if (wpa_ctrl_recv(ctrl, buf, &len) == 0) {
3349 wpa_cli_action_process(buf);
3352 if (wpa_cli_show_event(buf)) {
3354 printf("\r%s\n", buf);
3358 if (interactive && check_terminating(buf) > 0)
3362 printf("Could not read pending message.\n");
3367 if (wpa_ctrl_pending(ctrl) < 0) {
3368 printf("Connection to wpa_supplicant lost - trying to "
3370 wpa_cli_reconnect();
3376 static int tokenize_cmd(char *cmd, char *argv[])
3389 if (argc == max_args)
3392 char *pos2 = os_strrchr(pos, '"');
3396 while (*pos != '\0' && *pos != ' ')
3406 static void wpa_cli_ping(void *eloop_ctx, void *timeout_ctx)
3408 if (ctrl_conn && _wpa_ctrl_command(ctrl_conn, "PING", 0)) {
3409 printf("Connection to wpa_supplicant lost - trying to "
3411 wpa_cli_close_connection();
3414 wpa_cli_reconnect();
3415 eloop_register_timeout(ping_interval, 0, wpa_cli_ping, NULL, NULL);
3419 static void wpa_cli_mon_receive(int sock, void *eloop_ctx, void *sock_ctx)
3421 wpa_cli_recv_pending(mon_conn, 0);
3425 static void wpa_cli_edit_cmd_cb(void *ctx, char *cmd)
3427 char *argv[max_args];
3429 argc = tokenize_cmd(cmd, argv);
3431 wpa_request(ctrl_conn, argc, argv);
3435 static void wpa_cli_edit_eof_cb(void *ctx)
3441 static int warning_displayed = 0;
3442 static char *hfile = NULL;
3443 static int edit_started = 0;
3445 static void start_edit(void)
3450 #ifdef CONFIG_CTRL_IFACE_UDP_REMOTE
3451 ps = wpa_ctrl_get_remote_ifname(ctrl_conn);
3452 #endif /* CONFIG_CTRL_IFACE_UDP_REMOTE */
3454 home = getenv("HOME");
3456 const char *fname = ".wpa_cli_history";
3457 int hfile_len = os_strlen(home) + 1 + os_strlen(fname) + 1;
3458 hfile = os_malloc(hfile_len);
3460 os_snprintf(hfile, hfile_len, "%s/%s", home, fname);
3463 if (edit_init(wpa_cli_edit_cmd_cb, wpa_cli_edit_eof_cb,
3464 wpa_cli_edit_completion_cb, NULL, hfile, ps) < 0) {
3470 eloop_register_timeout(ping_interval, 0, wpa_cli_ping, NULL, NULL);
3474 static void update_bssid_list(struct wpa_ctrl *ctrl)
3477 size_t len = sizeof(buf);
3479 char *cmd = "BSS RANGE=ALL MASK=0x2";
3484 ret = wpa_ctrl_request(ctrl, cmd, os_strlen(cmd), buf, &len, NULL);
3491 pos = os_strstr(pos, "bssid=");
3495 end = os_strchr(pos, '\n');
3499 cli_txt_list_add(&bsses, pos);
3505 static void update_ifnames(struct wpa_ctrl *ctrl)
3508 size_t len = sizeof(buf);
3510 char *cmd = "INTERFACES";
3514 cli_txt_list_flush(&ifnames);
3518 ret = wpa_ctrl_request(ctrl, cmd, os_strlen(cmd), buf, &len, NULL);
3525 end = os_strchr(pos, '\n');
3529 ret = os_snprintf(txt, sizeof(txt), "ifname=%s", pos);
3530 if (ret > 0 && ret < (int) sizeof(txt))
3531 cli_txt_list_add(&ifnames, txt);
3537 static void try_connection(void *eloop_ctx, void *timeout_ctx)
3542 if (ctrl_ifname == NULL)
3543 ctrl_ifname = wpa_cli_get_default_ifname();
3545 if (!wpa_cli_open_connection(ctrl_ifname, 1) == 0) {
3546 if (!warning_displayed) {
3547 printf("Could not connect to wpa_supplicant: "
3548 "%s - re-trying\n", ctrl_ifname);
3549 warning_displayed = 1;
3551 eloop_register_timeout(1, 0, try_connection, NULL, NULL);
3555 update_bssid_list(ctrl_conn);
3557 if (warning_displayed)
3558 printf("Connection established.\n");
3565 static void wpa_cli_interactive(void)
3567 printf("\nInteractive mode\n\n");
3569 eloop_register_timeout(0, 0, try_connection, NULL, NULL);
3571 eloop_cancel_timeout(try_connection, NULL, NULL);
3573 cli_txt_list_flush(&p2p_peers);
3574 cli_txt_list_flush(&p2p_groups);
3575 cli_txt_list_flush(&bsses);
3576 cli_txt_list_flush(&ifnames);
3578 edit_deinit(hfile, wpa_cli_edit_filter_history_cb);
3580 eloop_cancel_timeout(wpa_cli_ping, NULL, NULL);
3581 wpa_cli_close_connection();
3585 static void wpa_cli_action(struct wpa_ctrl *ctrl)
3587 #ifdef CONFIG_ANSI_C_EXTRA
3588 /* TODO: ANSI C version(?) */
3589 printf("Action processing not supported in ANSI C build.\n");
3590 #else /* CONFIG_ANSI_C_EXTRA */
3594 char buf[256]; /* note: large enough to fit in unsolicited messages */
3597 fd = wpa_ctrl_get_fd(ctrl);
3599 while (!wpa_cli_quit) {
3602 tv.tv_sec = ping_interval;
3604 res = select(fd + 1, &rfds, NULL, NULL, &tv);
3605 if (res < 0 && errno != EINTR) {
3610 if (FD_ISSET(fd, &rfds))
3611 wpa_cli_recv_pending(ctrl, 1);
3613 /* verify that connection is still working */
3614 len = sizeof(buf) - 1;
3615 if (wpa_ctrl_request(ctrl, "PING", 4, buf, &len,
3616 wpa_cli_action_cb) < 0 ||
3617 len < 4 || os_memcmp(buf, "PONG", 4) != 0) {
3618 printf("wpa_supplicant did not reply to PING "
3619 "command - exiting\n");
3624 #endif /* CONFIG_ANSI_C_EXTRA */
3628 static void wpa_cli_cleanup(void)
3630 wpa_cli_close_connection();
3632 os_daemonize_terminate(pid_file);
3634 os_program_deinit();
3638 static void wpa_cli_terminate(int sig, void *ctx)
3644 static char * wpa_cli_get_default_ifname(void)
3646 char *ifname = NULL;
3648 #ifdef CONFIG_CTRL_IFACE_UNIX
3649 struct dirent *dent;
3650 DIR *dir = opendir(ctrl_iface_dir);
3653 char ifprop[PROPERTY_VALUE_MAX];
3654 if (property_get("wifi.interface", ifprop, NULL) != 0) {
3655 ifname = os_strdup(ifprop);
3656 printf("Using interface '%s'\n", ifname);
3659 #endif /* ANDROID */
3662 while ((dent = readdir(dir))) {
3663 #ifdef _DIRENT_HAVE_D_TYPE
3665 * Skip the file if it is not a socket. Also accept
3666 * DT_UNKNOWN (0) in case the C library or underlying
3667 * file system does not support d_type.
3669 if (dent->d_type != DT_SOCK && dent->d_type != DT_UNKNOWN)
3671 #endif /* _DIRENT_HAVE_D_TYPE */
3672 if (os_strcmp(dent->d_name, ".") == 0 ||
3673 os_strcmp(dent->d_name, "..") == 0)
3675 printf("Selected interface '%s'\n", dent->d_name);
3676 ifname = os_strdup(dent->d_name);
3680 #endif /* CONFIG_CTRL_IFACE_UNIX */
3682 #ifdef CONFIG_CTRL_IFACE_NAMED_PIPE
3683 char buf[4096], *pos;
3685 struct wpa_ctrl *ctrl;
3688 ctrl = wpa_ctrl_open(NULL);
3692 len = sizeof(buf) - 1;
3693 ret = wpa_ctrl_request(ctrl, "INTERFACES", 10, buf, &len, NULL);
3696 pos = os_strchr(buf, '\n');
3699 ifname = os_strdup(buf);
3701 wpa_ctrl_close(ctrl);
3702 #endif /* CONFIG_CTRL_IFACE_NAMED_PIPE */
3708 int main(int argc, char *argv[])
3713 const char *global = NULL;
3715 if (os_program_init())
3719 c = getopt(argc, argv, "a:Bg:G:hi:p:P:v");
3724 action_file = optarg;
3733 ping_interval = atoi(optarg);
3739 printf("%s\n", wpa_cli_version);
3742 os_free(ctrl_ifname);
3743 ctrl_ifname = os_strdup(optarg);
3746 ctrl_iface_dir = optarg;
3757 interactive = (argc == optind) && (action_file == NULL);
3760 printf("%s\n\n%s\n\n", wpa_cli_version, wpa_cli_license);
3766 #ifdef CONFIG_CTRL_IFACE_NAMED_PIPE
3767 ctrl_conn = wpa_ctrl_open(NULL);
3768 #else /* CONFIG_CTRL_IFACE_NAMED_PIPE */
3769 ctrl_conn = wpa_ctrl_open(global);
3770 #endif /* CONFIG_CTRL_IFACE_NAMED_PIPE */
3771 if (ctrl_conn == NULL) {
3772 fprintf(stderr, "Failed to connect to wpa_supplicant "
3773 "global interface: %s error: %s\n",
3774 global, strerror(errno));
3779 update_ifnames(ctrl_conn);
3780 mon_conn = wpa_ctrl_open(global);
3782 if (wpa_ctrl_attach(mon_conn) == 0) {
3783 wpa_cli_attached = 1;
3784 eloop_register_read_sock(
3785 wpa_ctrl_get_fd(mon_conn),
3786 wpa_cli_mon_receive,
3789 printf("Failed to open monitor "
3790 "connection through global "
3791 "control interface\n");
3797 eloop_register_signal_terminate(wpa_cli_terminate, NULL);
3799 if (ctrl_ifname == NULL)
3800 ctrl_ifname = wpa_cli_get_default_ifname();
3803 wpa_cli_interactive();
3806 wpa_cli_open_connection(ctrl_ifname, 0) < 0) {
3807 fprintf(stderr, "Failed to connect to non-global "
3808 "ctrl_ifname: %s error: %s\n",
3809 ctrl_ifname, strerror(errno));
3814 if (wpa_ctrl_attach(ctrl_conn) == 0) {
3815 wpa_cli_attached = 1;
3817 printf("Warning: Failed to attach to "
3818 "wpa_supplicant.\n");
3823 if (daemonize && os_daemonize(pid_file))
3827 wpa_cli_action(ctrl_conn);
3829 ret = wpa_request(ctrl_conn, argc - optind,
3833 os_free(ctrl_ifname);
3840 #else /* CONFIG_CTRL_IFACE */
3841 int main(int argc, char *argv[])
3843 printf("CONFIG_CTRL_IFACE not defined - wpa_cli disabled\n");
3846 #endif /* CONFIG_CTRL_IFACE */