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 (os_snprintf_error(flen
, res
)) {
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 (os_snprintf_error(end
- pos
, res
))
455 for (i
= 0; i
< argc
; i
++) {
456 res
= os_snprintf(pos
, end
- pos
, " %s", argv
[i
]);
457 if (os_snprintf_error(end
- pos
, res
))
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_pmksa_flush(struct wpa_ctrl
*ctrl
, int argc
,
538 return wpa_ctrl_command(ctrl
, "PMKSA_FLUSH");
542 static int wpa_cli_cmd_help(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
544 print_help(argc
> 0 ? argv
[0] : NULL
);
549 static char ** wpa_cli_complete_help(const char *str
, int pos
)
551 int arg
= get_cmd_arg_num(str
, pos
);
556 res
= wpa_list_cmd_list();
564 static int wpa_cli_cmd_license(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
566 printf("%s\n\n%s\n", wpa_cli_version
, wpa_cli_full_license
);
571 static int wpa_cli_cmd_quit(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
580 static int wpa_cli_cmd_set(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
586 res
= os_snprintf(cmd
, sizeof(cmd
), "SET %s ", argv
[0]);
587 if (os_snprintf_error(sizeof(cmd
), res
)) {
588 printf("Too long SET command.\n");
591 return wpa_ctrl_command(ctrl
, cmd
);
594 return wpa_cli_cmd(ctrl
, "SET", 2, argc
, argv
);
598 static char ** wpa_cli_complete_set(const char *str
, int pos
)
600 int arg
= get_cmd_arg_num(str
, pos
);
601 const char *fields
[] = {
603 "EAPOL::heldPeriod", "EAPOL::authPeriod", "EAPOL::startPeriod",
604 "EAPOL::maxStart", "dot11RSNAConfigPMKLifetime",
605 "dot11RSNAConfigPMKReauthThreshold", "dot11RSNAConfigSATimeout",
606 "wps_fragment_size", "wps_version_number", "ampdu",
607 "tdls_testing", "tdls_disabled", "pno", "radio_disabled",
608 "uapsd", "ps", "wifi_display", "bssid_filter", "disallow_aps",
610 /* global configuration parameters */
611 "eapol_version", "ap_scan", "disable_scan_offload",
612 "fast_reauth", "opensc_engine_path", "pkcs11_engine_path",
613 "pkcs11_module_path", "openssl_ciphers",
614 "pcsc_reader", "pcsc_pin",
615 "driver_param", "dot11RSNAConfigPMKLifetime",
616 "dot11RSNAConfigPMKReauthThreshold",
617 "dot11RSNAConfigSATimeout",
618 "update_config", "load_dynamic_eap", "uuid", "device_name",
619 "manufacturer", "model_name", "model_number", "serial_number",
620 "device_type", "os_version", "config_methods",
621 "wps_cred_processing", "wps_vendor_ext_m1", "sec_device_type",
622 "p2p_listen_reg_class", "p2p_listen_channel",
623 "p2p_oper_reg_class", "p2p_oper_channel",
624 "p2p_go_intent", "p2p_ssid_postfix", "persistent_reconnect",
625 "p2p_intra_bss", "p2p_group_idle", "p2p_pref_chan",
627 "p2p_go_ht40", "p2p_disabled", "p2p_no_group_iface",
629 "p2p_ignore_shared_freq", "country", "bss_max_count",
630 "bss_expiration_age", "bss_expiration_scan_count",
631 "filter_ssids", "filter_rssi", "max_num_sta",
632 "disassoc_low_ack", "hs20", "interworking", "hessid",
633 "access_network_type", "pbc_in_m1", "autoscan",
634 "wps_nfc_dev_pw_id", "wps_nfc_dh_pubkey", "wps_nfc_dh_privkey",
635 "wps_nfc_dev_pw", "ext_password_backend",
636 "p2p_go_max_inactivity", "auto_interworking", "okc", "pmf",
637 "sae_groups", "dtim_period", "beacon_int", "ap_vendor_elements",
638 "ignore_old_scan_res", "freq_list", "external_sim",
639 "tdls_external_control", "p2p_search_delay"
641 int i
, num_fields
= ARRAY_SIZE(fields
);
644 char **res
= os_calloc(num_fields
+ 1, sizeof(char *));
647 for (i
= 0; i
< num_fields
; i
++) {
648 res
[i
] = os_strdup(fields
[i
]);
655 if (arg
> 1 && os_strncasecmp(str
, "set bssid_filter ", 17) == 0)
656 return cli_txt_list_array(&bsses
);
662 static int wpa_cli_cmd_get(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
664 return wpa_cli_cmd(ctrl
, "GET", 1, argc
, argv
);
668 static int wpa_cli_cmd_logoff(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
670 return wpa_ctrl_command(ctrl
, "LOGOFF");
674 static int wpa_cli_cmd_logon(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
676 return wpa_ctrl_command(ctrl
, "LOGON");
680 static int wpa_cli_cmd_reassociate(struct wpa_ctrl
*ctrl
, int argc
,
683 return wpa_ctrl_command(ctrl
, "REASSOCIATE");
687 static int wpa_cli_cmd_reattach(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
689 return wpa_ctrl_command(ctrl
, "REATTACH");
693 static int wpa_cli_cmd_preauthenticate(struct wpa_ctrl
*ctrl
, int argc
,
696 return wpa_cli_cmd(ctrl
, "PREAUTH", 1, argc
, argv
);
700 static int wpa_cli_cmd_ap_scan(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
702 return wpa_cli_cmd(ctrl
, "AP_SCAN", 1, argc
, argv
);
706 static int wpa_cli_cmd_scan_interval(struct wpa_ctrl
*ctrl
, int argc
,
709 return wpa_cli_cmd(ctrl
, "SCAN_INTERVAL", 1, argc
, argv
);
713 static int wpa_cli_cmd_bss_expire_age(struct wpa_ctrl
*ctrl
, int argc
,
716 return wpa_cli_cmd(ctrl
, "BSS_EXPIRE_AGE", 1, argc
, argv
);
720 static int wpa_cli_cmd_bss_expire_count(struct wpa_ctrl
*ctrl
, int argc
,
723 return wpa_cli_cmd(ctrl
, "BSS_EXPIRE_COUNT", 1, argc
, argv
);
727 static int wpa_cli_cmd_bss_flush(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
733 res
= os_snprintf(cmd
, sizeof(cmd
), "BSS_FLUSH 0");
735 res
= os_snprintf(cmd
, sizeof(cmd
), "BSS_FLUSH %s", argv
[0]);
736 if (os_snprintf_error(sizeof(cmd
), res
)) {
737 printf("Too long BSS_FLUSH command.\n");
740 return wpa_ctrl_command(ctrl
, cmd
);
744 static int wpa_cli_cmd_stkstart(struct wpa_ctrl
*ctrl
, int argc
,
747 return wpa_cli_cmd(ctrl
, "STKSTART", 1, argc
, argv
);
751 static int wpa_cli_cmd_ft_ds(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
753 return wpa_cli_cmd(ctrl
, "FT_DS", 1, argc
, argv
);
757 static int wpa_cli_cmd_wps_pbc(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
759 return wpa_cli_cmd(ctrl
, "WPS_PBC", 0, argc
, argv
);
763 static int wpa_cli_cmd_wps_pin(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
766 printf("Invalid WPS_PIN command: need one or two arguments:\n"
767 "- BSSID: use 'any' to select any\n"
768 "- PIN: optional, used only with devices that have no "
773 return wpa_cli_cmd(ctrl
, "WPS_PIN", 1, argc
, argv
);
777 static int wpa_cli_cmd_wps_check_pin(struct wpa_ctrl
*ctrl
, int argc
,
780 return wpa_cli_cmd(ctrl
, "WPS_CHECK_PIN", 1, argc
, argv
);
784 static int wpa_cli_cmd_wps_cancel(struct wpa_ctrl
*ctrl
, int argc
,
787 return wpa_ctrl_command(ctrl
, "WPS_CANCEL");
791 #ifdef CONFIG_WPS_NFC
793 static int wpa_cli_cmd_wps_nfc(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
795 return wpa_cli_cmd(ctrl
, "WPS_NFC", 0, argc
, argv
);
799 static int wpa_cli_cmd_wps_nfc_config_token(struct wpa_ctrl
*ctrl
, int argc
,
802 return wpa_cli_cmd(ctrl
, "WPS_NFC_CONFIG_TOKEN", 1, argc
, argv
);
806 static int wpa_cli_cmd_wps_nfc_token(struct wpa_ctrl
*ctrl
, int argc
,
809 return wpa_cli_cmd(ctrl
, "WPS_NFC_TOKEN", 1, argc
, argv
);
813 static int wpa_cli_cmd_wps_nfc_tag_read(struct wpa_ctrl
*ctrl
, int argc
,
821 printf("Invalid 'wps_nfc_tag_read' command - one argument "
826 buflen
= 18 + os_strlen(argv
[0]);
827 buf
= os_malloc(buflen
);
830 os_snprintf(buf
, buflen
, "WPS_NFC_TAG_READ %s", argv
[0]);
832 ret
= wpa_ctrl_command(ctrl
, buf
);
839 static int wpa_cli_cmd_nfc_get_handover_req(struct wpa_ctrl
*ctrl
, int argc
,
842 return wpa_cli_cmd(ctrl
, "NFC_GET_HANDOVER_REQ", 2, argc
, argv
);
846 static int wpa_cli_cmd_nfc_get_handover_sel(struct wpa_ctrl
*ctrl
, int argc
,
849 return wpa_cli_cmd(ctrl
, "NFC_GET_HANDOVER_SEL", 2, argc
, argv
);
853 static int wpa_cli_cmd_nfc_report_handover(struct wpa_ctrl
*ctrl
, int argc
,
856 return wpa_cli_cmd(ctrl
, "NFC_REPORT_HANDOVER", 4, argc
, argv
);
859 #endif /* CONFIG_WPS_NFC */
862 static int wpa_cli_cmd_wps_reg(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
868 res
= os_snprintf(cmd
, sizeof(cmd
), "WPS_REG %s %s",
870 else if (argc
== 5 || argc
== 6) {
871 char ssid_hex
[2 * 32 + 1];
872 char key_hex
[2 * 64 + 1];
876 for (i
= 0; i
< 32; i
++) {
877 if (argv
[2][i
] == '\0')
879 os_snprintf(&ssid_hex
[i
* 2], 3, "%02x", argv
[2][i
]);
884 for (i
= 0; i
< 64; i
++) {
885 if (argv
[5][i
] == '\0')
887 os_snprintf(&key_hex
[i
* 2], 3, "%02x",
892 res
= os_snprintf(cmd
, sizeof(cmd
),
893 "WPS_REG %s %s %s %s %s %s",
894 argv
[0], argv
[1], ssid_hex
, argv
[3], argv
[4],
897 printf("Invalid WPS_REG command: need two arguments:\n"
898 "- BSSID of the target AP\n"
900 printf("Alternatively, six arguments can be used to "
901 "reconfigure the AP:\n"
902 "- BSSID of the target AP\n"
905 "- new auth (OPEN, WPAPSK, WPA2PSK)\n"
906 "- new encr (NONE, WEP, TKIP, CCMP)\n"
911 if (os_snprintf_error(sizeof(cmd
), res
)) {
912 printf("Too long WPS_REG command.\n");
915 return wpa_ctrl_command(ctrl
, cmd
);
919 static int wpa_cli_cmd_wps_ap_pin(struct wpa_ctrl
*ctrl
, int argc
,
922 return wpa_cli_cmd(ctrl
, "WPS_AP_PIN", 1, argc
, argv
);
926 static int wpa_cli_cmd_wps_er_start(struct wpa_ctrl
*ctrl
, int argc
,
929 return wpa_cli_cmd(ctrl
, "WPS_ER_START", 0, argc
, argv
);
933 static int wpa_cli_cmd_wps_er_stop(struct wpa_ctrl
*ctrl
, int argc
,
936 return wpa_ctrl_command(ctrl
, "WPS_ER_STOP");
941 static int wpa_cli_cmd_wps_er_pin(struct wpa_ctrl
*ctrl
, int argc
,
945 printf("Invalid WPS_ER_PIN command: need at least two "
947 "- UUID: use 'any' to select any\n"
948 "- PIN: Enrollee PIN\n"
949 "optional: - Enrollee MAC address\n");
953 return wpa_cli_cmd(ctrl
, "WPS_ER_PIN", 2, argc
, argv
);
957 static int wpa_cli_cmd_wps_er_pbc(struct wpa_ctrl
*ctrl
, int argc
,
960 return wpa_cli_cmd(ctrl
, "WPS_ER_PBC", 1, argc
, argv
);
964 static int wpa_cli_cmd_wps_er_learn(struct wpa_ctrl
*ctrl
, int argc
,
968 printf("Invalid WPS_ER_LEARN command: need two arguments:\n"
969 "- UUID: specify which AP to use\n"
974 return wpa_cli_cmd(ctrl
, "WPS_ER_LEARN", 2, argc
, argv
);
978 static int wpa_cli_cmd_wps_er_set_config(struct wpa_ctrl
*ctrl
, int argc
,
982 printf("Invalid WPS_ER_SET_CONFIG command: need two "
984 "- UUID: specify which AP to use\n"
985 "- Network configuration id\n");
989 return wpa_cli_cmd(ctrl
, "WPS_ER_SET_CONFIG", 2, argc
, argv
);
993 static int wpa_cli_cmd_wps_er_config(struct wpa_ctrl
*ctrl
, int argc
,
999 if (argc
== 5 || argc
== 6) {
1000 char ssid_hex
[2 * 32 + 1];
1001 char key_hex
[2 * 64 + 1];
1005 for (i
= 0; i
< 32; i
++) {
1006 if (argv
[2][i
] == '\0')
1008 os_snprintf(&ssid_hex
[i
* 2], 3, "%02x", argv
[2][i
]);
1013 for (i
= 0; i
< 64; i
++) {
1014 if (argv
[5][i
] == '\0')
1016 os_snprintf(&key_hex
[i
* 2], 3, "%02x",
1021 res
= os_snprintf(cmd
, sizeof(cmd
),
1022 "WPS_ER_CONFIG %s %s %s %s %s %s",
1023 argv
[0], argv
[1], ssid_hex
, argv
[3], argv
[4],
1026 printf("Invalid WPS_ER_CONFIG command: need six arguments:\n"
1030 "- new auth (OPEN, WPAPSK, WPA2PSK)\n"
1031 "- new encr (NONE, WEP, TKIP, CCMP)\n"
1036 if (os_snprintf_error(sizeof(cmd
), res
)) {
1037 printf("Too long WPS_ER_CONFIG command.\n");
1040 return wpa_ctrl_command(ctrl
, cmd
);
1044 #ifdef CONFIG_WPS_NFC
1045 static int wpa_cli_cmd_wps_er_nfc_config_token(struct wpa_ctrl
*ctrl
, int argc
,
1049 printf("Invalid WPS_ER_NFC_CONFIG_TOKEN command: need two "
1051 "- WPS/NDEF: token format\n"
1052 "- UUID: specify which AP to use\n");
1056 return wpa_cli_cmd(ctrl
, "WPS_ER_NFC_CONFIG_TOKEN", 2, argc
, argv
);
1058 #endif /* CONFIG_WPS_NFC */
1061 static int wpa_cli_cmd_ibss_rsn(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1063 return wpa_cli_cmd(ctrl
, "IBSS_RSN", 1, argc
, argv
);
1067 static int wpa_cli_cmd_level(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1069 return wpa_cli_cmd(ctrl
, "LEVEL", 1, argc
, argv
);
1073 static int wpa_cli_cmd_identity(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1075 char cmd
[256], *pos
, *end
;
1079 printf("Invalid IDENTITY command: needs two arguments "
1080 "(network id and identity)\n");
1084 end
= cmd
+ sizeof(cmd
);
1086 ret
= os_snprintf(pos
, end
- pos
, WPA_CTRL_RSP
"IDENTITY-%s:%s",
1088 if (os_snprintf_error(end
- pos
, ret
)) {
1089 printf("Too long IDENTITY command.\n");
1093 for (i
= 2; i
< argc
; i
++) {
1094 ret
= os_snprintf(pos
, end
- pos
, " %s", argv
[i
]);
1095 if (os_snprintf_error(end
- pos
, ret
)) {
1096 printf("Too long IDENTITY command.\n");
1102 return wpa_ctrl_command(ctrl
, cmd
);
1106 static int wpa_cli_cmd_password(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1108 char cmd
[256], *pos
, *end
;
1112 printf("Invalid PASSWORD command: needs two arguments "
1113 "(network id and password)\n");
1117 end
= cmd
+ sizeof(cmd
);
1119 ret
= os_snprintf(pos
, end
- pos
, WPA_CTRL_RSP
"PASSWORD-%s:%s",
1121 if (os_snprintf_error(end
- pos
, ret
)) {
1122 printf("Too long PASSWORD command.\n");
1126 for (i
= 2; i
< argc
; i
++) {
1127 ret
= os_snprintf(pos
, end
- pos
, " %s", argv
[i
]);
1128 if (os_snprintf_error(end
- pos
, ret
)) {
1129 printf("Too long PASSWORD command.\n");
1135 return wpa_ctrl_command(ctrl
, cmd
);
1139 static int wpa_cli_cmd_new_password(struct wpa_ctrl
*ctrl
, int argc
,
1142 char cmd
[256], *pos
, *end
;
1146 printf("Invalid NEW_PASSWORD command: needs two arguments "
1147 "(network id and password)\n");
1151 end
= cmd
+ sizeof(cmd
);
1153 ret
= os_snprintf(pos
, end
- pos
, WPA_CTRL_RSP
"NEW_PASSWORD-%s:%s",
1155 if (os_snprintf_error(end
- pos
, ret
)) {
1156 printf("Too long NEW_PASSWORD command.\n");
1160 for (i
= 2; i
< argc
; i
++) {
1161 ret
= os_snprintf(pos
, end
- pos
, " %s", argv
[i
]);
1162 if (os_snprintf_error(end
- pos
, ret
)) {
1163 printf("Too long NEW_PASSWORD command.\n");
1169 return wpa_ctrl_command(ctrl
, cmd
);
1173 static int wpa_cli_cmd_pin(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1175 char cmd
[256], *pos
, *end
;
1179 printf("Invalid PIN command: needs two arguments "
1180 "(network id and pin)\n");
1184 end
= cmd
+ sizeof(cmd
);
1186 ret
= os_snprintf(pos
, end
- pos
, WPA_CTRL_RSP
"PIN-%s:%s",
1188 if (os_snprintf_error(end
- pos
, ret
)) {
1189 printf("Too long PIN command.\n");
1193 for (i
= 2; i
< argc
; i
++) {
1194 ret
= os_snprintf(pos
, end
- pos
, " %s", argv
[i
]);
1195 if (os_snprintf_error(end
- pos
, ret
)) {
1196 printf("Too long PIN command.\n");
1201 return wpa_ctrl_command(ctrl
, cmd
);
1205 static int wpa_cli_cmd_otp(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1207 char cmd
[256], *pos
, *end
;
1211 printf("Invalid OTP command: needs two arguments (network "
1212 "id and password)\n");
1216 end
= cmd
+ sizeof(cmd
);
1218 ret
= os_snprintf(pos
, end
- pos
, WPA_CTRL_RSP
"OTP-%s:%s",
1220 if (os_snprintf_error(end
- pos
, ret
)) {
1221 printf("Too long OTP command.\n");
1225 for (i
= 2; i
< argc
; i
++) {
1226 ret
= os_snprintf(pos
, end
- pos
, " %s", argv
[i
]);
1227 if (os_snprintf_error(end
- pos
, ret
)) {
1228 printf("Too long OTP command.\n");
1234 return wpa_ctrl_command(ctrl
, cmd
);
1238 static int wpa_cli_cmd_sim(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1240 char cmd
[256], *pos
, *end
;
1244 printf("Invalid SIM command: needs two arguments "
1245 "(network id and SIM operation response)\n");
1249 end
= cmd
+ sizeof(cmd
);
1251 ret
= os_snprintf(pos
, end
- pos
, WPA_CTRL_RSP
"SIM-%s:%s",
1253 if (os_snprintf_error(end
- pos
, ret
)) {
1254 printf("Too long SIM command.\n");
1258 for (i
= 2; i
< argc
; i
++) {
1259 ret
= os_snprintf(pos
, end
- pos
, " %s", argv
[i
]);
1260 if (os_snprintf_error(end
- pos
, ret
)) {
1261 printf("Too long SIM command.\n");
1266 return wpa_ctrl_command(ctrl
, cmd
);
1270 static int wpa_cli_cmd_passphrase(struct wpa_ctrl
*ctrl
, int argc
,
1273 char cmd
[256], *pos
, *end
;
1277 printf("Invalid PASSPHRASE command: needs two arguments "
1278 "(network id and passphrase)\n");
1282 end
= cmd
+ sizeof(cmd
);
1284 ret
= os_snprintf(pos
, end
- pos
, WPA_CTRL_RSP
"PASSPHRASE-%s:%s",
1286 if (os_snprintf_error(end
- pos
, ret
)) {
1287 printf("Too long PASSPHRASE command.\n");
1291 for (i
= 2; i
< argc
; i
++) {
1292 ret
= os_snprintf(pos
, end
- pos
, " %s", argv
[i
]);
1293 if (os_snprintf_error(end
- pos
, ret
)) {
1294 printf("Too long PASSPHRASE command.\n");
1300 return wpa_ctrl_command(ctrl
, cmd
);
1304 static int wpa_cli_cmd_bssid(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1307 printf("Invalid BSSID command: needs two arguments (network "
1312 return wpa_cli_cmd(ctrl
, "BSSID", 2, argc
, argv
);
1316 static int wpa_cli_cmd_blacklist(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1318 return wpa_cli_cmd(ctrl
, "BLACKLIST", 0, argc
, argv
);
1322 static int wpa_cli_cmd_log_level(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1324 return wpa_cli_cmd(ctrl
, "LOG_LEVEL", 0, argc
, argv
);
1328 static int wpa_cli_cmd_list_networks(struct wpa_ctrl
*ctrl
, int argc
,
1331 return wpa_ctrl_command(ctrl
, "LIST_NETWORKS");
1335 static int wpa_cli_cmd_select_network(struct wpa_ctrl
*ctrl
, int argc
,
1338 return wpa_cli_cmd(ctrl
, "SELECT_NETWORK", 1, argc
, argv
);
1342 static int wpa_cli_cmd_enable_network(struct wpa_ctrl
*ctrl
, int argc
,
1345 return wpa_cli_cmd(ctrl
, "ENABLE_NETWORK", 1, argc
, argv
);
1349 static int wpa_cli_cmd_disable_network(struct wpa_ctrl
*ctrl
, int argc
,
1352 return wpa_cli_cmd(ctrl
, "DISABLE_NETWORK", 1, argc
, argv
);
1356 static int wpa_cli_cmd_add_network(struct wpa_ctrl
*ctrl
, int argc
,
1359 return wpa_ctrl_command(ctrl
, "ADD_NETWORK");
1363 static int wpa_cli_cmd_remove_network(struct wpa_ctrl
*ctrl
, int argc
,
1366 return wpa_cli_cmd(ctrl
, "REMOVE_NETWORK", 1, argc
, argv
);
1370 static void wpa_cli_show_network_variables(void)
1372 printf("set_network variables:\n"
1373 " ssid (network name, SSID)\n"
1374 " psk (WPA passphrase or pre-shared key)\n"
1375 " key_mgmt (key management protocol)\n"
1376 " identity (EAP identity)\n"
1377 " password (EAP password)\n"
1380 "Note: Values are entered in the same format as the "
1381 "configuration file is using,\n"
1382 "i.e., strings values need to be inside double quotation "
1384 "For example: set_network 1 ssid \"network name\"\n"
1386 "Please see wpa_supplicant.conf documentation for full list "
1387 "of\navailable variables.\n");
1391 static int wpa_cli_cmd_set_network(struct wpa_ctrl
*ctrl
, int argc
,
1395 wpa_cli_show_network_variables();
1400 printf("Invalid SET_NETWORK command: needs three arguments\n"
1401 "(network id, variable name, and value)\n");
1405 return wpa_cli_cmd(ctrl
, "SET_NETWORK", 3, argc
, argv
);
1409 static int wpa_cli_cmd_get_network(struct wpa_ctrl
*ctrl
, int argc
,
1413 wpa_cli_show_network_variables();
1418 printf("Invalid GET_NETWORK command: needs two arguments\n"
1419 "(network id and variable name)\n");
1423 return wpa_cli_cmd(ctrl
, "GET_NETWORK", 2, argc
, argv
);
1427 static int wpa_cli_cmd_dup_network(struct wpa_ctrl
*ctrl
, int argc
,
1431 wpa_cli_show_network_variables();
1436 printf("Invalid DUP_NETWORK command: needs three arguments\n"
1437 "(src netid, dest netid, and variable name)\n");
1441 return wpa_cli_cmd(ctrl
, "DUP_NETWORK", 3, argc
, argv
);
1445 static int wpa_cli_cmd_list_creds(struct wpa_ctrl
*ctrl
, int argc
,
1448 return wpa_ctrl_command(ctrl
, "LIST_CREDS");
1452 static int wpa_cli_cmd_add_cred(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1454 return wpa_ctrl_command(ctrl
, "ADD_CRED");
1458 static int wpa_cli_cmd_remove_cred(struct wpa_ctrl
*ctrl
, int argc
,
1461 return wpa_cli_cmd(ctrl
, "REMOVE_CRED", 1, argc
, argv
);
1465 static int wpa_cli_cmd_set_cred(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1468 printf("Invalid SET_CRED command: needs three arguments\n"
1469 "(cred id, variable name, and value)\n");
1473 return wpa_cli_cmd(ctrl
, "SET_CRED", 3, argc
, argv
);
1477 static int wpa_cli_cmd_get_cred(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1480 printf("Invalid GET_CRED command: needs two arguments\n"
1481 "(cred id, variable name)\n");
1485 return wpa_cli_cmd(ctrl
, "GET_CRED", 2, argc
, argv
);
1489 static int wpa_cli_cmd_disconnect(struct wpa_ctrl
*ctrl
, int argc
,
1492 return wpa_ctrl_command(ctrl
, "DISCONNECT");
1496 static int wpa_cli_cmd_reconnect(struct wpa_ctrl
*ctrl
, int argc
,
1499 return wpa_ctrl_command(ctrl
, "RECONNECT");
1503 static int wpa_cli_cmd_save_config(struct wpa_ctrl
*ctrl
, int argc
,
1506 return wpa_ctrl_command(ctrl
, "SAVE_CONFIG");
1510 static int wpa_cli_cmd_scan(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1512 return wpa_cli_cmd(ctrl
, "SCAN", 0, argc
, argv
);
1516 static int wpa_cli_cmd_scan_results(struct wpa_ctrl
*ctrl
, int argc
,
1519 return wpa_ctrl_command(ctrl
, "SCAN_RESULTS");
1523 static int wpa_cli_cmd_bss(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1525 return wpa_cli_cmd(ctrl
, "BSS", 1, argc
, argv
);
1529 static char ** wpa_cli_complete_bss(const char *str
, int pos
)
1531 int arg
= get_cmd_arg_num(str
, pos
);
1536 res
= cli_txt_list_array(&bsses
);
1544 static int wpa_cli_cmd_get_capability(struct wpa_ctrl
*ctrl
, int argc
,
1547 if (argc
< 1 || argc
> 2) {
1548 printf("Invalid GET_CAPABILITY command: need either one or "
1553 if ((argc
== 2) && os_strcmp(argv
[1], "strict") != 0) {
1554 printf("Invalid GET_CAPABILITY command: second argument, "
1555 "if any, must be 'strict'\n");
1559 return wpa_cli_cmd(ctrl
, "GET_CAPABILITY", 1, argc
, argv
);
1563 static int wpa_cli_list_interfaces(struct wpa_ctrl
*ctrl
)
1565 printf("Available interfaces:\n");
1566 return wpa_ctrl_command(ctrl
, "INTERFACES");
1570 static int wpa_cli_cmd_interface(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1573 wpa_cli_list_interfaces(ctrl
);
1577 wpa_cli_close_connection();
1578 os_free(ctrl_ifname
);
1579 ctrl_ifname
= os_strdup(argv
[0]);
1581 printf("Failed to allocate memory\n");
1585 if (wpa_cli_open_connection(ctrl_ifname
, 1) == 0) {
1586 printf("Connected to interface '%s.\n", ctrl_ifname
);
1588 printf("Could not connect to interface '%s' - re-trying\n",
1595 static int wpa_cli_cmd_reconfigure(struct wpa_ctrl
*ctrl
, int argc
,
1598 return wpa_ctrl_command(ctrl
, "RECONFIGURE");
1602 static int wpa_cli_cmd_terminate(struct wpa_ctrl
*ctrl
, int argc
,
1605 return wpa_ctrl_command(ctrl
, "TERMINATE");
1609 static int wpa_cli_cmd_interface_add(struct wpa_ctrl
*ctrl
, int argc
,
1616 printf("Invalid INTERFACE_ADD command: needs at least one "
1617 "argument (interface name)\n"
1618 "All arguments: ifname confname driver ctrl_interface "
1619 "driver_param bridge_name\n");
1624 * INTERFACE_ADD <ifname>TAB<confname>TAB<driver>TAB<ctrl_interface>TAB
1625 * <driver_param>TAB<bridge_name>
1627 res
= os_snprintf(cmd
, sizeof(cmd
),
1628 "INTERFACE_ADD %s\t%s\t%s\t%s\t%s\t%s",
1630 argc
> 1 ? argv
[1] : "", argc
> 2 ? argv
[2] : "",
1631 argc
> 3 ? argv
[3] : "", argc
> 4 ? argv
[4] : "",
1632 argc
> 5 ? argv
[5] : "");
1633 if (os_snprintf_error(sizeof(cmd
), res
))
1635 cmd
[sizeof(cmd
) - 1] = '\0';
1636 return wpa_ctrl_command(ctrl
, cmd
);
1640 static int wpa_cli_cmd_interface_remove(struct wpa_ctrl
*ctrl
, int argc
,
1643 return wpa_cli_cmd(ctrl
, "INTERFACE_REMOVE", 1, argc
, argv
);
1647 static int wpa_cli_cmd_interface_list(struct wpa_ctrl
*ctrl
, int argc
,
1650 return wpa_ctrl_command(ctrl
, "INTERFACE_LIST");
1655 static int wpa_cli_cmd_sta(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1657 return wpa_cli_cmd(ctrl
, "STA", 1, argc
, argv
);
1661 static int wpa_ctrl_command_sta(struct wpa_ctrl
*ctrl
, char *cmd
,
1662 char *addr
, size_t addr_len
)
1664 char buf
[4096], *pos
;
1668 if (ctrl_conn
== NULL
) {
1669 printf("Not connected to hostapd - command dropped.\n");
1672 len
= sizeof(buf
) - 1;
1673 ret
= wpa_ctrl_request(ctrl
, cmd
, os_strlen(cmd
), buf
, &len
,
1676 printf("'%s' command timed out.\n", cmd
);
1678 } else if (ret
< 0) {
1679 printf("'%s' command failed.\n", cmd
);
1684 if (os_memcmp(buf
, "FAIL", 4) == 0)
1689 while (*pos
!= '\0' && *pos
!= '\n')
1692 os_strlcpy(addr
, buf
, addr_len
);
1697 static int wpa_cli_cmd_all_sta(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1699 char addr
[32], cmd
[64];
1701 if (wpa_ctrl_command_sta(ctrl
, "STA-FIRST", addr
, sizeof(addr
)))
1704 os_snprintf(cmd
, sizeof(cmd
), "STA-NEXT %s", addr
);
1705 } while (wpa_ctrl_command_sta(ctrl
, cmd
, addr
, sizeof(addr
)) == 0);
1711 static int wpa_cli_cmd_deauthenticate(struct wpa_ctrl
*ctrl
, int argc
,
1714 return wpa_cli_cmd(ctrl
, "DEAUTHENTICATE", 1, argc
, argv
);
1718 static int wpa_cli_cmd_disassociate(struct wpa_ctrl
*ctrl
, int argc
,
1721 return wpa_cli_cmd(ctrl
, "DISASSOCIATE", 1, argc
, argv
);
1724 static int wpa_cli_cmd_chanswitch(struct wpa_ctrl
*ctrl
, int argc
,
1727 return wpa_cli_cmd(ctrl
, "CHAN_SWITCH", 2, argc
, argv
);
1730 #endif /* CONFIG_AP */
1733 static int wpa_cli_cmd_suspend(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1735 return wpa_ctrl_command(ctrl
, "SUSPEND");
1739 static int wpa_cli_cmd_resume(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1741 return wpa_ctrl_command(ctrl
, "RESUME");
1745 #ifdef CONFIG_TESTING_OPTIONS
1746 static int wpa_cli_cmd_drop_sa(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1748 return wpa_ctrl_command(ctrl
, "DROP_SA");
1750 #endif /* CONFIG_TESTING_OPTIONS */
1753 static int wpa_cli_cmd_roam(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1755 return wpa_cli_cmd(ctrl
, "ROAM", 1, argc
, argv
);
1761 static int wpa_cli_cmd_mesh_interface_add(struct wpa_ctrl
*ctrl
, int argc
,
1764 return wpa_cli_cmd(ctrl
, "MESH_INTERFACE_ADD", 0, argc
, argv
);
1768 static int wpa_cli_cmd_mesh_group_add(struct wpa_ctrl
*ctrl
, int argc
,
1771 return wpa_cli_cmd(ctrl
, "MESH_GROUP_ADD", 1, argc
, argv
);
1775 static int wpa_cli_cmd_mesh_group_remove(struct wpa_ctrl
*ctrl
, int argc
,
1778 return wpa_cli_cmd(ctrl
, "MESH_GROUP_REMOVE", 1, argc
, argv
);
1781 #endif /* CONFIG_MESH */
1786 static int wpa_cli_cmd_p2p_find(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1788 return wpa_cli_cmd(ctrl
, "P2P_FIND", 0, argc
, argv
);
1792 static char ** wpa_cli_complete_p2p_find(const char *str
, int pos
)
1795 int arg
= get_cmd_arg_num(str
, pos
);
1797 res
= os_calloc(6, sizeof(char *));
1800 res
[0] = os_strdup("type=social");
1801 if (res
[0] == NULL
) {
1805 res
[1] = os_strdup("type=progressive");
1808 res
[2] = os_strdup("delay=");
1811 res
[3] = os_strdup("dev_id=");
1815 res
[4] = os_strdup("[timeout]");
1821 static int wpa_cli_cmd_p2p_stop_find(struct wpa_ctrl
*ctrl
, int argc
,
1824 return wpa_ctrl_command(ctrl
, "P2P_STOP_FIND");
1828 static int wpa_cli_cmd_p2p_connect(struct wpa_ctrl
*ctrl
, int argc
,
1831 return wpa_cli_cmd(ctrl
, "P2P_CONNECT", 2, argc
, argv
);
1835 static char ** wpa_cli_complete_p2p_connect(const char *str
, int pos
)
1837 int arg
= get_cmd_arg_num(str
, pos
);
1842 res
= cli_txt_list_array(&p2p_peers
);
1850 static int wpa_cli_cmd_p2p_listen(struct wpa_ctrl
*ctrl
, int argc
,
1853 return wpa_cli_cmd(ctrl
, "P2P_LISTEN", 0, argc
, argv
);
1857 static int wpa_cli_cmd_p2p_group_remove(struct wpa_ctrl
*ctrl
, int argc
,
1860 return wpa_cli_cmd(ctrl
, "P2P_GROUP_REMOVE", 1, argc
, argv
);
1864 static char ** wpa_cli_complete_p2p_group_remove(const char *str
, int pos
)
1866 int arg
= get_cmd_arg_num(str
, pos
);
1871 res
= cli_txt_list_array(&p2p_groups
);
1879 static int wpa_cli_cmd_p2p_group_add(struct wpa_ctrl
*ctrl
, int argc
,
1882 return wpa_cli_cmd(ctrl
, "P2P_GROUP_ADD", 0, argc
, argv
);
1886 static int wpa_cli_cmd_p2p_prov_disc(struct wpa_ctrl
*ctrl
, int argc
,
1889 if (argc
!= 2 && argc
!= 3) {
1890 printf("Invalid P2P_PROV_DISC command: needs at least "
1891 "two arguments, address and config method\n"
1892 "(display, keypad, or pbc) and an optional join\n");
1896 return wpa_cli_cmd(ctrl
, "P2P_PROV_DISC", 2, argc
, argv
);
1900 static int wpa_cli_cmd_p2p_get_passphrase(struct wpa_ctrl
*ctrl
, int argc
,
1903 return wpa_ctrl_command(ctrl
, "P2P_GET_PASSPHRASE");
1907 static int wpa_cli_cmd_p2p_serv_disc_req(struct wpa_ctrl
*ctrl
, int argc
,
1912 if (argc
!= 2 && argc
!= 4) {
1913 printf("Invalid P2P_SERV_DISC_REQ command: needs two "
1914 "arguments (address and TLVs) or four arguments "
1915 "(address, \"upnp\", version, search target "
1920 if (write_cmd(cmd
, sizeof(cmd
), "P2P_SERV_DISC_REQ", argc
, argv
) < 0)
1922 return wpa_ctrl_command(ctrl
, cmd
);
1926 static int wpa_cli_cmd_p2p_serv_disc_cancel_req(struct wpa_ctrl
*ctrl
,
1927 int argc
, char *argv
[])
1929 return wpa_cli_cmd(ctrl
, "P2P_SERV_DISC_CANCEL_REQ", 1, argc
, argv
);
1933 static int wpa_cli_cmd_p2p_serv_disc_resp(struct wpa_ctrl
*ctrl
, int argc
,
1940 printf("Invalid P2P_SERV_DISC_RESP command: needs four "
1941 "arguments (freq, address, dialog token, and TLVs)\n");
1945 res
= os_snprintf(cmd
, sizeof(cmd
), "P2P_SERV_DISC_RESP %s %s %s %s",
1946 argv
[0], argv
[1], argv
[2], argv
[3]);
1947 if (os_snprintf_error(sizeof(cmd
), res
))
1949 cmd
[sizeof(cmd
) - 1] = '\0';
1950 return wpa_ctrl_command(ctrl
, cmd
);
1954 static int wpa_cli_cmd_p2p_service_update(struct wpa_ctrl
*ctrl
, int argc
,
1957 return wpa_ctrl_command(ctrl
, "P2P_SERVICE_UPDATE");
1961 static int wpa_cli_cmd_p2p_serv_disc_external(struct wpa_ctrl
*ctrl
,
1962 int argc
, char *argv
[])
1964 return wpa_cli_cmd(ctrl
, "P2P_SERV_DISC_EXTERNAL", 1, argc
, argv
);
1968 static int wpa_cli_cmd_p2p_service_flush(struct wpa_ctrl
*ctrl
, int argc
,
1971 return wpa_ctrl_command(ctrl
, "P2P_SERVICE_FLUSH");
1975 static int wpa_cli_cmd_p2p_service_add(struct wpa_ctrl
*ctrl
, int argc
,
1981 if (argc
!= 3 && argc
!= 4) {
1982 printf("Invalid P2P_SERVICE_ADD command: needs three or four "
1988 res
= os_snprintf(cmd
, sizeof(cmd
),
1989 "P2P_SERVICE_ADD %s %s %s %s",
1990 argv
[0], argv
[1], argv
[2], argv
[3]);
1992 res
= os_snprintf(cmd
, sizeof(cmd
),
1993 "P2P_SERVICE_ADD %s %s %s",
1994 argv
[0], argv
[1], argv
[2]);
1995 if (os_snprintf_error(sizeof(cmd
), res
))
1997 cmd
[sizeof(cmd
) - 1] = '\0';
1998 return wpa_ctrl_command(ctrl
, cmd
);
2002 static int wpa_cli_cmd_p2p_service_del(struct wpa_ctrl
*ctrl
, int argc
,
2008 if (argc
!= 2 && argc
!= 3) {
2009 printf("Invalid P2P_SERVICE_DEL command: needs two or three "
2015 res
= os_snprintf(cmd
, sizeof(cmd
),
2016 "P2P_SERVICE_DEL %s %s %s",
2017 argv
[0], argv
[1], argv
[2]);
2019 res
= os_snprintf(cmd
, sizeof(cmd
),
2020 "P2P_SERVICE_DEL %s %s",
2022 if (os_snprintf_error(sizeof(cmd
), res
))
2024 cmd
[sizeof(cmd
) - 1] = '\0';
2025 return wpa_ctrl_command(ctrl
, cmd
);
2029 static int wpa_cli_cmd_p2p_reject(struct wpa_ctrl
*ctrl
,
2030 int argc
, char *argv
[])
2032 return wpa_cli_cmd(ctrl
, "P2P_REJECT", 1, argc
, argv
);
2036 static int wpa_cli_cmd_p2p_invite(struct wpa_ctrl
*ctrl
,
2037 int argc
, char *argv
[])
2039 return wpa_cli_cmd(ctrl
, "P2P_INVITE", 1, argc
, argv
);
2043 static int wpa_cli_cmd_p2p_peer(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2045 return wpa_cli_cmd(ctrl
, "P2P_PEER", 1, argc
, argv
);
2049 static char ** wpa_cli_complete_p2p_peer(const char *str
, int pos
)
2051 int arg
= get_cmd_arg_num(str
, pos
);
2056 res
= cli_txt_list_array(&p2p_peers
);
2064 static int wpa_ctrl_command_p2p_peer(struct wpa_ctrl
*ctrl
, char *cmd
,
2065 char *addr
, size_t addr_len
,
2068 char buf
[4096], *pos
;
2072 if (ctrl_conn
== NULL
)
2074 len
= sizeof(buf
) - 1;
2075 ret
= wpa_ctrl_request(ctrl
, cmd
, os_strlen(cmd
), buf
, &len
,
2078 printf("'%s' command timed out.\n", cmd
);
2080 } else if (ret
< 0) {
2081 printf("'%s' command failed.\n", cmd
);
2086 if (os_memcmp(buf
, "FAIL", 4) == 0)
2090 while (*pos
!= '\0' && *pos
!= '\n')
2093 os_strlcpy(addr
, buf
, addr_len
);
2094 if (!discovered
|| os_strstr(pos
, "[PROBE_REQ_ONLY]") == NULL
)
2095 printf("%s\n", addr
);
2100 static int wpa_cli_cmd_p2p_peers(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2102 char addr
[32], cmd
[64];
2105 discovered
= argc
> 0 && os_strcmp(argv
[0], "discovered") == 0;
2107 if (wpa_ctrl_command_p2p_peer(ctrl
, "P2P_PEER FIRST",
2108 addr
, sizeof(addr
), discovered
))
2111 os_snprintf(cmd
, sizeof(cmd
), "P2P_PEER NEXT-%s", addr
);
2112 } while (wpa_ctrl_command_p2p_peer(ctrl
, cmd
, addr
, sizeof(addr
),
2119 static int wpa_cli_cmd_p2p_set(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2121 return wpa_cli_cmd(ctrl
, "P2P_SET", 2, argc
, argv
);
2125 static char ** wpa_cli_complete_p2p_set(const char *str
, int pos
)
2127 int arg
= get_cmd_arg_num(str
, pos
);
2128 const char *fields
[] = {
2148 int i
, num_fields
= ARRAY_SIZE(fields
);
2151 char **res
= os_calloc(num_fields
+ 1, sizeof(char *));
2154 for (i
= 0; i
< num_fields
; i
++) {
2155 res
[i
] = os_strdup(fields
[i
]);
2162 if (arg
== 2 && os_strncasecmp(str
, "p2p_set peer_filter ", 20) == 0)
2163 return cli_txt_list_array(&p2p_peers
);
2169 static int wpa_cli_cmd_p2p_flush(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2171 return wpa_ctrl_command(ctrl
, "P2P_FLUSH");
2175 static int wpa_cli_cmd_p2p_cancel(struct wpa_ctrl
*ctrl
, int argc
,
2178 return wpa_ctrl_command(ctrl
, "P2P_CANCEL");
2182 static int wpa_cli_cmd_p2p_unauthorize(struct wpa_ctrl
*ctrl
, int argc
,
2185 return wpa_cli_cmd(ctrl
, "P2P_UNAUTHORIZE", 1, argc
, argv
);
2189 static int wpa_cli_cmd_p2p_presence_req(struct wpa_ctrl
*ctrl
, int argc
,
2192 if (argc
!= 0 && argc
!= 2 && argc
!= 4) {
2193 printf("Invalid P2P_PRESENCE_REQ command: needs two arguments "
2194 "(preferred duration, interval; in microsecods).\n"
2195 "Optional second pair can be used to provide "
2196 "acceptable values.\n");
2200 return wpa_cli_cmd(ctrl
, "P2P_PRESENCE_REQ", 0, argc
, argv
);
2204 static int wpa_cli_cmd_p2p_ext_listen(struct wpa_ctrl
*ctrl
, int argc
,
2207 if (argc
!= 0 && argc
!= 2) {
2208 printf("Invalid P2P_EXT_LISTEN command: needs two arguments "
2209 "(availability period, availability interval; in "
2211 "Extended Listen Timing can be cancelled with this "
2212 "command when used without parameters.\n");
2216 return wpa_cli_cmd(ctrl
, "P2P_EXT_LISTEN", 0, argc
, argv
);
2220 static int wpa_cli_cmd_p2p_remove_client(struct wpa_ctrl
*ctrl
, int argc
,
2223 return wpa_cli_cmd(ctrl
, "P2P_REMOVE_CLIENT", 1, argc
, argv
);
2226 #endif /* CONFIG_P2P */
2228 #ifdef CONFIG_WIFI_DISPLAY
2230 static int wpa_cli_cmd_wfd_subelem_set(struct wpa_ctrl
*ctrl
, int argc
,
2236 if (argc
!= 1 && argc
!= 2) {
2237 printf("Invalid WFD_SUBELEM_SET command: needs one or two "
2238 "arguments (subelem, hexdump)\n");
2242 res
= os_snprintf(cmd
, sizeof(cmd
), "WFD_SUBELEM_SET %s %s",
2243 argv
[0], argc
> 1 ? argv
[1] : "");
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_wfd_subelem_get(struct wpa_ctrl
*ctrl
, int argc
,
2258 printf("Invalid WFD_SUBELEM_GET command: needs one "
2259 "argument (subelem)\n");
2263 res
= os_snprintf(cmd
, sizeof(cmd
), "WFD_SUBELEM_GET %s",
2265 if (os_snprintf_error(sizeof(cmd
), res
))
2267 cmd
[sizeof(cmd
) - 1] = '\0';
2268 return wpa_ctrl_command(ctrl
, cmd
);
2270 #endif /* CONFIG_WIFI_DISPLAY */
2273 #ifdef CONFIG_INTERWORKING
2274 static int wpa_cli_cmd_fetch_anqp(struct wpa_ctrl
*ctrl
, int argc
,
2277 return wpa_ctrl_command(ctrl
, "FETCH_ANQP");
2281 static int wpa_cli_cmd_stop_fetch_anqp(struct wpa_ctrl
*ctrl
, int argc
,
2284 return wpa_ctrl_command(ctrl
, "STOP_FETCH_ANQP");
2288 static int wpa_cli_cmd_interworking_select(struct wpa_ctrl
*ctrl
, int argc
,
2291 return wpa_cli_cmd(ctrl
, "INTERWORKING_SELECT", 0, argc
, argv
);
2295 static int wpa_cli_cmd_interworking_connect(struct wpa_ctrl
*ctrl
, int argc
,
2298 return wpa_cli_cmd(ctrl
, "INTERWORKING_CONNECT", 1, argc
, argv
);
2302 static int wpa_cli_cmd_anqp_get(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2304 return wpa_cli_cmd(ctrl
, "ANQP_GET", 2, argc
, argv
);
2308 static int wpa_cli_cmd_gas_request(struct wpa_ctrl
*ctrl
, int argc
,
2311 return wpa_cli_cmd(ctrl
, "GAS_REQUEST", 2, argc
, argv
);
2315 static int wpa_cli_cmd_gas_response_get(struct wpa_ctrl
*ctrl
, int argc
,
2318 return wpa_cli_cmd(ctrl
, "GAS_RESPONSE_GET", 2, argc
, argv
);
2320 #endif /* CONFIG_INTERWORKING */
2325 static int wpa_cli_cmd_hs20_anqp_get(struct wpa_ctrl
*ctrl
, int argc
,
2328 return wpa_cli_cmd(ctrl
, "HS20_ANQP_GET", 2, argc
, argv
);
2332 static int wpa_cli_cmd_get_nai_home_realm_list(struct wpa_ctrl
*ctrl
, int argc
,
2338 printf("Command needs one or two arguments (dst mac addr and "
2339 "optional home realm)\n");
2343 if (write_cmd(cmd
, sizeof(cmd
), "HS20_GET_NAI_HOME_REALM_LIST",
2347 return wpa_ctrl_command(ctrl
, cmd
);
2351 static int wpa_cli_cmd_hs20_icon_request(struct wpa_ctrl
*ctrl
, int argc
,
2357 printf("Command needs two arguments (dst mac addr and "
2362 if (write_cmd(cmd
, sizeof(cmd
), "HS20_ICON_REQUEST", argc
, argv
) < 0)
2365 return wpa_ctrl_command(ctrl
, cmd
);
2369 static int wpa_cli_cmd_fetch_osu(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2371 return wpa_ctrl_command(ctrl
, "FETCH_OSU");
2375 static int wpa_cli_cmd_cancel_fetch_osu(struct wpa_ctrl
*ctrl
, int argc
,
2378 return wpa_ctrl_command(ctrl
, "CANCEL_FETCH_OSU");
2381 #endif /* CONFIG_HS20 */
2384 static int wpa_cli_cmd_sta_autoconnect(struct wpa_ctrl
*ctrl
, int argc
,
2387 return wpa_cli_cmd(ctrl
, "STA_AUTOCONNECT", 1, argc
, argv
);
2391 static int wpa_cli_cmd_tdls_discover(struct wpa_ctrl
*ctrl
, int argc
,
2394 return wpa_cli_cmd(ctrl
, "TDLS_DISCOVER", 1, argc
, argv
);
2398 static int wpa_cli_cmd_tdls_setup(struct wpa_ctrl
*ctrl
, int argc
,
2401 return wpa_cli_cmd(ctrl
, "TDLS_SETUP", 1, argc
, argv
);
2405 static int wpa_cli_cmd_tdls_teardown(struct wpa_ctrl
*ctrl
, int argc
,
2408 return wpa_cli_cmd(ctrl
, "TDLS_TEARDOWN", 1, argc
, argv
);
2412 static int wpa_cli_cmd_wmm_ac_addts(struct wpa_ctrl
*ctrl
, int argc
,
2415 return wpa_cli_cmd(ctrl
, "WMM_AC_ADDTS", 3, argc
, argv
);
2419 static int wpa_cli_cmd_wmm_ac_delts(struct wpa_ctrl
*ctrl
, int argc
,
2422 return wpa_cli_cmd(ctrl
, "WMM_AC_DELTS", 1, argc
, argv
);
2426 static int wpa_cli_cmd_wmm_ac_status(struct wpa_ctrl
*ctrl
, int argc
,
2429 return wpa_ctrl_command(ctrl
, "WMM_AC_STATUS");
2433 static int wpa_cli_cmd_tdls_chan_switch(struct wpa_ctrl
*ctrl
, int argc
,
2436 return wpa_cli_cmd(ctrl
, "TDLS_CHAN_SWITCH", 2, argc
, argv
);
2440 static int wpa_cli_cmd_tdls_cancel_chan_switch(struct wpa_ctrl
*ctrl
, int argc
,
2443 return wpa_cli_cmd(ctrl
, "TDLS_CANCEL_CHAN_SWITCH", 1, argc
, argv
);
2447 static int wpa_cli_cmd_signal_poll(struct wpa_ctrl
*ctrl
, int argc
,
2450 return wpa_ctrl_command(ctrl
, "SIGNAL_POLL");
2454 static int wpa_cli_cmd_pktcnt_poll(struct wpa_ctrl
*ctrl
, int argc
,
2457 return wpa_ctrl_command(ctrl
, "PKTCNT_POLL");
2461 static int wpa_cli_cmd_reauthenticate(struct wpa_ctrl
*ctrl
, int argc
,
2464 return wpa_ctrl_command(ctrl
, "REAUTHENTICATE");
2468 #ifdef CONFIG_AUTOSCAN
2470 static int wpa_cli_cmd_autoscan(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2473 return wpa_ctrl_command(ctrl
, "AUTOSCAN ");
2475 return wpa_cli_cmd(ctrl
, "AUTOSCAN", 0, argc
, argv
);
2478 #endif /* CONFIG_AUTOSCAN */
2483 static int wpa_cli_cmd_wnm_sleep(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2485 return wpa_cli_cmd(ctrl
, "WNM_SLEEP", 0, argc
, argv
);
2489 static int wpa_cli_cmd_wnm_bss_query(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2491 return wpa_cli_cmd(ctrl
, "WNM_BSS_QUERY", 1, argc
, argv
);
2494 #endif /* CONFIG_WNM */
2497 static int wpa_cli_cmd_raw(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2501 return wpa_cli_cmd(ctrl
, argv
[0], 0, argc
- 1, &argv
[1]);
2506 static int wpa_cli_cmd_driver(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2508 return wpa_cli_cmd(ctrl
, "DRIVER", 1, argc
, argv
);
2510 #endif /* ANDROID */
2513 static int wpa_cli_cmd_vendor(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2515 return wpa_cli_cmd(ctrl
, "VENDOR", 1, argc
, argv
);
2519 static int wpa_cli_cmd_flush(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2521 return wpa_ctrl_command(ctrl
, "FLUSH");
2525 static int wpa_cli_cmd_radio_work(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2527 return wpa_cli_cmd(ctrl
, "RADIO_WORK", 1, argc
, argv
);
2531 static int wpa_cli_cmd_neighbor_rep_request(struct wpa_ctrl
*ctrl
, int argc
,
2534 return wpa_cli_cmd(ctrl
, "NEIGHBOR_REP_REQUEST", 0, argc
, argv
);
2538 static int wpa_cli_cmd_erp_flush(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2540 return wpa_ctrl_command(ctrl
, "ERP_FLUSH");
2544 static int wpa_cli_cmd_mac_rand_scan(struct wpa_ctrl
*ctrl
, int argc
,
2547 return wpa_cli_cmd(ctrl
, "MAC_RAND_SCAN", 1, argc
, argv
);
2551 enum wpa_cli_cmd_flags
{
2552 cli_cmd_flag_none
= 0x00,
2553 cli_cmd_flag_sensitive
= 0x01
2556 struct wpa_cli_cmd
{
2558 int (*handler
)(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[]);
2559 char ** (*completion
)(const char *str
, int pos
);
2560 enum wpa_cli_cmd_flags flags
;
2564 static struct wpa_cli_cmd wpa_cli_commands
[] = {
2565 { "status", wpa_cli_cmd_status
, NULL
,
2567 "[verbose] = get current WPA/EAPOL/EAP status" },
2568 { "ifname", wpa_cli_cmd_ifname
, NULL
,
2570 "= get current interface name" },
2571 { "ping", wpa_cli_cmd_ping
, NULL
,
2573 "= pings wpa_supplicant" },
2574 { "relog", wpa_cli_cmd_relog
, NULL
,
2576 "= re-open log-file (allow rolling logs)" },
2577 { "note", wpa_cli_cmd_note
, NULL
,
2579 "<text> = add a note to wpa_supplicant debug log" },
2580 { "mib", wpa_cli_cmd_mib
, NULL
,
2582 "= get MIB variables (dot1x, dot11)" },
2583 { "help", wpa_cli_cmd_help
, wpa_cli_complete_help
,
2585 "[command] = show usage help" },
2586 { "interface", wpa_cli_cmd_interface
, NULL
,
2588 "[ifname] = show interfaces/select interface" },
2589 { "level", wpa_cli_cmd_level
, NULL
,
2591 "<debug level> = change debug level" },
2592 { "license", wpa_cli_cmd_license
, NULL
,
2594 "= show full wpa_cli license" },
2595 { "quit", wpa_cli_cmd_quit
, NULL
,
2598 { "set", wpa_cli_cmd_set
, wpa_cli_complete_set
,
2600 "= set variables (shows list of variables when run without "
2602 { "get", wpa_cli_cmd_get
, NULL
,
2604 "<name> = get information" },
2605 { "logon", wpa_cli_cmd_logon
, NULL
,
2607 "= IEEE 802.1X EAPOL state machine logon" },
2608 { "logoff", wpa_cli_cmd_logoff
, NULL
,
2610 "= IEEE 802.1X EAPOL state machine logoff" },
2611 { "pmksa", wpa_cli_cmd_pmksa
, NULL
,
2613 "= show PMKSA cache" },
2614 { "pmksa_flush", wpa_cli_cmd_pmksa_flush
, NULL
,
2616 "= flush PMKSA cache entries" },
2617 { "reassociate", wpa_cli_cmd_reassociate
, NULL
,
2619 "= force reassociation" },
2620 { "reattach", wpa_cli_cmd_reattach
, NULL
,
2622 "= force reassociation back to the same BSS" },
2623 { "preauthenticate", wpa_cli_cmd_preauthenticate
, wpa_cli_complete_bss
,
2625 "<BSSID> = force preauthentication" },
2626 { "identity", wpa_cli_cmd_identity
, NULL
,
2628 "<network id> <identity> = configure identity for an SSID" },
2629 { "password", wpa_cli_cmd_password
, NULL
,
2630 cli_cmd_flag_sensitive
,
2631 "<network id> <password> = configure password for an SSID" },
2632 { "new_password", wpa_cli_cmd_new_password
, NULL
,
2633 cli_cmd_flag_sensitive
,
2634 "<network id> <password> = change password for an SSID" },
2635 { "pin", wpa_cli_cmd_pin
, NULL
,
2636 cli_cmd_flag_sensitive
,
2637 "<network id> <pin> = configure pin for an SSID" },
2638 { "otp", wpa_cli_cmd_otp
, NULL
,
2639 cli_cmd_flag_sensitive
,
2640 "<network id> <password> = configure one-time-password for an SSID"
2642 { "passphrase", wpa_cli_cmd_passphrase
, NULL
,
2643 cli_cmd_flag_sensitive
,
2644 "<network id> <passphrase> = configure private key passphrase\n"
2646 { "sim", wpa_cli_cmd_sim
, NULL
,
2647 cli_cmd_flag_sensitive
,
2648 "<network id> <pin> = report SIM operation result" },
2649 { "bssid", wpa_cli_cmd_bssid
, NULL
,
2651 "<network id> <BSSID> = set preferred BSSID for an SSID" },
2652 { "blacklist", wpa_cli_cmd_blacklist
, wpa_cli_complete_bss
,
2654 "<BSSID> = add a BSSID to the blacklist\n"
2655 "blacklist clear = clear the blacklist\n"
2656 "blacklist = display the blacklist" },
2657 { "log_level", wpa_cli_cmd_log_level
, NULL
,
2659 "<level> [<timestamp>] = update the log level/timestamp\n"
2660 "log_level = display the current log level and log options" },
2661 { "list_networks", wpa_cli_cmd_list_networks
, NULL
,
2663 "= list configured networks" },
2664 { "select_network", wpa_cli_cmd_select_network
, NULL
,
2666 "<network id> = select a network (disable others)" },
2667 { "enable_network", wpa_cli_cmd_enable_network
, NULL
,
2669 "<network id> = enable a network" },
2670 { "disable_network", wpa_cli_cmd_disable_network
, NULL
,
2672 "<network id> = disable a network" },
2673 { "add_network", wpa_cli_cmd_add_network
, NULL
,
2675 "= add a network" },
2676 { "remove_network", wpa_cli_cmd_remove_network
, NULL
,
2678 "<network id> = remove a network" },
2679 { "set_network", wpa_cli_cmd_set_network
, NULL
,
2680 cli_cmd_flag_sensitive
,
2681 "<network id> <variable> <value> = set network variables (shows\n"
2682 " list of variables when run without arguments)" },
2683 { "get_network", wpa_cli_cmd_get_network
, NULL
,
2685 "<network id> <variable> = get network variables" },
2686 { "dup_network", wpa_cli_cmd_dup_network
, NULL
,
2688 "<src network id> <dst network id> <variable> = duplicate network variables"
2690 { "list_creds", wpa_cli_cmd_list_creds
, NULL
,
2692 "= list configured credentials" },
2693 { "add_cred", wpa_cli_cmd_add_cred
, NULL
,
2695 "= add a credential" },
2696 { "remove_cred", wpa_cli_cmd_remove_cred
, NULL
,
2698 "<cred id> = remove a credential" },
2699 { "set_cred", wpa_cli_cmd_set_cred
, NULL
,
2700 cli_cmd_flag_sensitive
,
2701 "<cred id> <variable> <value> = set credential variables" },
2702 { "get_cred", wpa_cli_cmd_get_cred
, NULL
,
2704 "<cred id> <variable> = get credential variables" },
2705 { "save_config", wpa_cli_cmd_save_config
, NULL
,
2707 "= save the current configuration" },
2708 { "disconnect", wpa_cli_cmd_disconnect
, NULL
,
2710 "= disconnect and wait for reassociate/reconnect command before\n"
2712 { "reconnect", wpa_cli_cmd_reconnect
, NULL
,
2714 "= like reassociate, but only takes effect if already disconnected"
2716 { "scan", wpa_cli_cmd_scan
, NULL
,
2718 "= request new BSS scan" },
2719 { "scan_results", wpa_cli_cmd_scan_results
, NULL
,
2721 "= get latest scan results" },
2722 { "bss", wpa_cli_cmd_bss
, wpa_cli_complete_bss
,
2724 "<<idx> | <bssid>> = get detailed scan result info" },
2725 { "get_capability", wpa_cli_cmd_get_capability
, NULL
,
2727 "<eap/pairwise/group/key_mgmt/proto/auth_alg/channels/freq/modes> "
2728 "= get capabilies" },
2729 { "reconfigure", wpa_cli_cmd_reconfigure
, NULL
,
2731 "= force wpa_supplicant to re-read its configuration file" },
2732 { "terminate", wpa_cli_cmd_terminate
, NULL
,
2734 "= terminate wpa_supplicant" },
2735 { "interface_add", wpa_cli_cmd_interface_add
, NULL
,
2737 "<ifname> <confname> <driver> <ctrl_interface> <driver_param>\n"
2738 " <bridge_name> = adds new interface, all parameters but <ifname>\n"
2740 { "interface_remove", wpa_cli_cmd_interface_remove
, NULL
,
2742 "<ifname> = removes the interface" },
2743 { "interface_list", wpa_cli_cmd_interface_list
, NULL
,
2745 "= list available interfaces" },
2746 { "ap_scan", wpa_cli_cmd_ap_scan
, NULL
,
2748 "<value> = set ap_scan parameter" },
2749 { "scan_interval", wpa_cli_cmd_scan_interval
, NULL
,
2751 "<value> = set scan_interval parameter (in seconds)" },
2752 { "bss_expire_age", wpa_cli_cmd_bss_expire_age
, NULL
,
2754 "<value> = set BSS expiration age parameter" },
2755 { "bss_expire_count", wpa_cli_cmd_bss_expire_count
, NULL
,
2757 "<value> = set BSS expiration scan count parameter" },
2758 { "bss_flush", wpa_cli_cmd_bss_flush
, NULL
,
2760 "<value> = set BSS flush age (0 by default)" },
2761 { "stkstart", wpa_cli_cmd_stkstart
, NULL
,
2763 "<addr> = request STK negotiation with <addr>" },
2764 { "ft_ds", wpa_cli_cmd_ft_ds
, wpa_cli_complete_bss
,
2766 "<addr> = request over-the-DS FT with <addr>" },
2767 { "wps_pbc", wpa_cli_cmd_wps_pbc
, wpa_cli_complete_bss
,
2769 "[BSSID] = start Wi-Fi Protected Setup: Push Button Configuration" },
2770 { "wps_pin", wpa_cli_cmd_wps_pin
, wpa_cli_complete_bss
,
2771 cli_cmd_flag_sensitive
,
2772 "<BSSID> [PIN] = start WPS PIN method (returns PIN, if not "
2774 { "wps_check_pin", wpa_cli_cmd_wps_check_pin
, NULL
,
2775 cli_cmd_flag_sensitive
,
2776 "<PIN> = verify PIN checksum" },
2777 { "wps_cancel", wpa_cli_cmd_wps_cancel
, NULL
, cli_cmd_flag_none
,
2778 "Cancels the pending WPS operation" },
2779 #ifdef CONFIG_WPS_NFC
2780 { "wps_nfc", wpa_cli_cmd_wps_nfc
, wpa_cli_complete_bss
,
2782 "[BSSID] = start Wi-Fi Protected Setup: NFC" },
2783 { "wps_nfc_config_token", wpa_cli_cmd_wps_nfc_config_token
, NULL
,
2785 "<WPS|NDEF> = build configuration token" },
2786 { "wps_nfc_token", wpa_cli_cmd_wps_nfc_token
, NULL
,
2788 "<WPS|NDEF> = create password token" },
2789 { "wps_nfc_tag_read", wpa_cli_cmd_wps_nfc_tag_read
, NULL
,
2790 cli_cmd_flag_sensitive
,
2791 "<hexdump of payload> = report read NFC tag with WPS data" },
2792 { "nfc_get_handover_req", wpa_cli_cmd_nfc_get_handover_req
, NULL
,
2794 "<NDEF> <WPS> = create NFC handover request" },
2795 { "nfc_get_handover_sel", wpa_cli_cmd_nfc_get_handover_sel
, NULL
,
2797 "<NDEF> <WPS> = create NFC handover select" },
2798 { "nfc_report_handover", wpa_cli_cmd_nfc_report_handover
, NULL
,
2800 "<role> <type> <hexdump of req> <hexdump of sel> = report completed "
2802 #endif /* CONFIG_WPS_NFC */
2803 { "wps_reg", wpa_cli_cmd_wps_reg
, wpa_cli_complete_bss
,
2804 cli_cmd_flag_sensitive
,
2805 "<BSSID> <AP PIN> = start WPS Registrar to configure an AP" },
2806 { "wps_ap_pin", wpa_cli_cmd_wps_ap_pin
, NULL
,
2807 cli_cmd_flag_sensitive
,
2808 "[params..] = enable/disable AP PIN" },
2809 { "wps_er_start", wpa_cli_cmd_wps_er_start
, NULL
,
2811 "[IP address] = start Wi-Fi Protected Setup External Registrar" },
2812 { "wps_er_stop", wpa_cli_cmd_wps_er_stop
, NULL
,
2814 "= stop Wi-Fi Protected Setup External Registrar" },
2815 { "wps_er_pin", wpa_cli_cmd_wps_er_pin
, NULL
,
2816 cli_cmd_flag_sensitive
,
2817 "<UUID> <PIN> = add an Enrollee PIN to External Registrar" },
2818 { "wps_er_pbc", wpa_cli_cmd_wps_er_pbc
, NULL
,
2820 "<UUID> = accept an Enrollee PBC using External Registrar" },
2821 { "wps_er_learn", wpa_cli_cmd_wps_er_learn
, NULL
,
2822 cli_cmd_flag_sensitive
,
2823 "<UUID> <PIN> = learn AP configuration" },
2824 { "wps_er_set_config", wpa_cli_cmd_wps_er_set_config
, NULL
,
2826 "<UUID> <network id> = set AP configuration for enrolling" },
2827 { "wps_er_config", wpa_cli_cmd_wps_er_config
, NULL
,
2828 cli_cmd_flag_sensitive
,
2829 "<UUID> <PIN> <SSID> <auth> <encr> <key> = configure AP" },
2830 #ifdef CONFIG_WPS_NFC
2831 { "wps_er_nfc_config_token", wpa_cli_cmd_wps_er_nfc_config_token
, NULL
,
2833 "<WPS/NDEF> <UUID> = build NFC configuration token" },
2834 #endif /* CONFIG_WPS_NFC */
2835 { "ibss_rsn", wpa_cli_cmd_ibss_rsn
, NULL
,
2837 "<addr> = request RSN authentication with <addr> in IBSS" },
2839 { "sta", wpa_cli_cmd_sta
, NULL
,
2841 "<addr> = get information about an associated station (AP)" },
2842 { "all_sta", wpa_cli_cmd_all_sta
, NULL
,
2844 "= get information about all associated stations (AP)" },
2845 { "deauthenticate", wpa_cli_cmd_deauthenticate
, NULL
,
2847 "<addr> = deauthenticate a station" },
2848 { "disassociate", wpa_cli_cmd_disassociate
, NULL
,
2850 "<addr> = disassociate a station" },
2851 { "chan_switch", wpa_cli_cmd_chanswitch
, NULL
,
2853 "<cs_count> <freq> [sec_channel_offset=] [center_freq1=]"
2854 " [center_freq2=] [bandwidth=] [blocktx] [ht|vht]"
2855 " = CSA parameters" },
2856 #endif /* CONFIG_AP */
2857 { "suspend", wpa_cli_cmd_suspend
, NULL
, cli_cmd_flag_none
,
2858 "= notification of suspend/hibernate" },
2859 { "resume", wpa_cli_cmd_resume
, NULL
, cli_cmd_flag_none
,
2860 "= notification of resume/thaw" },
2861 #ifdef CONFIG_TESTING_OPTIONS
2862 { "drop_sa", wpa_cli_cmd_drop_sa
, NULL
, cli_cmd_flag_none
,
2863 "= drop SA without deauth/disassoc (test command)" },
2864 #endif /* CONFIG_TESTING_OPTIONS */
2865 { "roam", wpa_cli_cmd_roam
, wpa_cli_complete_bss
,
2867 "<addr> = roam to the specified BSS" },
2869 { "mesh_interface_add", wpa_cli_cmd_mesh_interface_add
, NULL
,
2871 "[ifname] = Create a new mesh interface" },
2872 { "mesh_group_add", wpa_cli_cmd_mesh_group_add
, NULL
,
2874 "<network id> = join a mesh network (disable others)" },
2875 { "mesh_group_remove", wpa_cli_cmd_mesh_group_remove
, NULL
,
2877 "<ifname> = Remove mesh group interface" },
2878 #endif /* CONFIG_MESH */
2880 { "p2p_find", wpa_cli_cmd_p2p_find
, wpa_cli_complete_p2p_find
,
2882 "[timeout] [type=*] = find P2P Devices for up-to timeout seconds" },
2883 { "p2p_stop_find", wpa_cli_cmd_p2p_stop_find
, NULL
, cli_cmd_flag_none
,
2884 "= stop P2P Devices search" },
2885 { "p2p_connect", wpa_cli_cmd_p2p_connect
, wpa_cli_complete_p2p_connect
,
2887 "<addr> <\"pbc\"|PIN> [ht40] = connect to a P2P Device" },
2888 { "p2p_listen", wpa_cli_cmd_p2p_listen
, NULL
, cli_cmd_flag_none
,
2889 "[timeout] = listen for P2P Devices for up-to timeout seconds" },
2890 { "p2p_group_remove", wpa_cli_cmd_p2p_group_remove
,
2891 wpa_cli_complete_p2p_group_remove
, cli_cmd_flag_none
,
2892 "<ifname> = remove P2P group interface (terminate group if GO)" },
2893 { "p2p_group_add", wpa_cli_cmd_p2p_group_add
, NULL
, cli_cmd_flag_none
,
2894 "[ht40] = add a new P2P group (local end as GO)" },
2895 { "p2p_prov_disc", wpa_cli_cmd_p2p_prov_disc
,
2896 wpa_cli_complete_p2p_peer
, cli_cmd_flag_none
,
2897 "<addr> <method> = request provisioning discovery" },
2898 { "p2p_get_passphrase", wpa_cli_cmd_p2p_get_passphrase
, NULL
,
2900 "= get the passphrase for a group (GO only)" },
2901 { "p2p_serv_disc_req", wpa_cli_cmd_p2p_serv_disc_req
,
2902 wpa_cli_complete_p2p_peer
, cli_cmd_flag_none
,
2903 "<addr> <TLVs> = schedule service discovery request" },
2904 { "p2p_serv_disc_cancel_req", wpa_cli_cmd_p2p_serv_disc_cancel_req
,
2905 NULL
, cli_cmd_flag_none
,
2906 "<id> = cancel pending service discovery request" },
2907 { "p2p_serv_disc_resp", wpa_cli_cmd_p2p_serv_disc_resp
, NULL
,
2909 "<freq> <addr> <dialog token> <TLVs> = service discovery response" },
2910 { "p2p_service_update", wpa_cli_cmd_p2p_service_update
, NULL
,
2912 "= indicate change in local services" },
2913 { "p2p_serv_disc_external", wpa_cli_cmd_p2p_serv_disc_external
, NULL
,
2915 "<external> = set external processing of service discovery" },
2916 { "p2p_service_flush", wpa_cli_cmd_p2p_service_flush
, NULL
,
2918 "= remove all stored service entries" },
2919 { "p2p_service_add", wpa_cli_cmd_p2p_service_add
, NULL
,
2921 "<bonjour|upnp> <query|version> <response|service> = add a local "
2923 { "p2p_service_del", wpa_cli_cmd_p2p_service_del
, NULL
,
2925 "<bonjour|upnp> <query|version> [|service] = remove a local "
2927 { "p2p_reject", wpa_cli_cmd_p2p_reject
, wpa_cli_complete_p2p_peer
,
2929 "<addr> = reject connection attempts from a specific peer" },
2930 { "p2p_invite", wpa_cli_cmd_p2p_invite
, NULL
,
2932 "<cmd> [peer=addr] = invite peer" },
2933 { "p2p_peers", wpa_cli_cmd_p2p_peers
, NULL
, cli_cmd_flag_none
,
2934 "[discovered] = list known (optionally, only fully discovered) P2P "
2936 { "p2p_peer", wpa_cli_cmd_p2p_peer
, wpa_cli_complete_p2p_peer
,
2938 "<address> = show information about known P2P peer" },
2939 { "p2p_set", wpa_cli_cmd_p2p_set
, wpa_cli_complete_p2p_set
,
2941 "<field> <value> = set a P2P parameter" },
2942 { "p2p_flush", wpa_cli_cmd_p2p_flush
, NULL
, cli_cmd_flag_none
,
2943 "= flush P2P state" },
2944 { "p2p_cancel", wpa_cli_cmd_p2p_cancel
, NULL
, cli_cmd_flag_none
,
2945 "= cancel P2P group formation" },
2946 { "p2p_unauthorize", wpa_cli_cmd_p2p_unauthorize
,
2947 wpa_cli_complete_p2p_peer
, cli_cmd_flag_none
,
2948 "<address> = unauthorize a peer" },
2949 { "p2p_presence_req", wpa_cli_cmd_p2p_presence_req
, NULL
,
2951 "[<duration> <interval>] [<duration> <interval>] = request GO "
2953 { "p2p_ext_listen", wpa_cli_cmd_p2p_ext_listen
, NULL
,
2955 "[<period> <interval>] = set extended listen timing" },
2956 { "p2p_remove_client", wpa_cli_cmd_p2p_remove_client
,
2957 wpa_cli_complete_p2p_peer
, cli_cmd_flag_none
,
2958 "<address|iface=address> = remove a peer from all groups" },
2959 #endif /* CONFIG_P2P */
2960 #ifdef CONFIG_WIFI_DISPLAY
2961 { "wfd_subelem_set", wpa_cli_cmd_wfd_subelem_set
, NULL
,
2963 "<subelem> [contents] = set Wi-Fi Display subelement" },
2964 { "wfd_subelem_get", wpa_cli_cmd_wfd_subelem_get
, NULL
,
2966 "<subelem> = get Wi-Fi Display subelement" },
2967 #endif /* CONFIG_WIFI_DISPLAY */
2968 #ifdef CONFIG_INTERWORKING
2969 { "fetch_anqp", wpa_cli_cmd_fetch_anqp
, NULL
, cli_cmd_flag_none
,
2970 "= fetch ANQP information for all APs" },
2971 { "stop_fetch_anqp", wpa_cli_cmd_stop_fetch_anqp
, NULL
,
2973 "= stop fetch_anqp operation" },
2974 { "interworking_select", wpa_cli_cmd_interworking_select
, NULL
,
2976 "[auto] = perform Interworking network selection" },
2977 { "interworking_connect", wpa_cli_cmd_interworking_connect
,
2978 wpa_cli_complete_bss
, cli_cmd_flag_none
,
2979 "<BSSID> = connect using Interworking credentials" },
2980 { "anqp_get", wpa_cli_cmd_anqp_get
, wpa_cli_complete_bss
,
2982 "<addr> <info id>[,<info id>]... = request ANQP information" },
2983 { "gas_request", wpa_cli_cmd_gas_request
, wpa_cli_complete_bss
,
2985 "<addr> <AdvProtoID> [QueryReq] = GAS request" },
2986 { "gas_response_get", wpa_cli_cmd_gas_response_get
,
2987 wpa_cli_complete_bss
, cli_cmd_flag_none
,
2988 "<addr> <dialog token> [start,len] = Fetch last GAS response" },
2989 #endif /* CONFIG_INTERWORKING */
2991 { "hs20_anqp_get", wpa_cli_cmd_hs20_anqp_get
, wpa_cli_complete_bss
,
2993 "<addr> <subtype>[,<subtype>]... = request HS 2.0 ANQP information"
2995 { "nai_home_realm_list", wpa_cli_cmd_get_nai_home_realm_list
,
2996 wpa_cli_complete_bss
, cli_cmd_flag_none
,
2997 "<addr> <home realm> = get HS20 nai home realm list" },
2998 { "hs20_icon_request", wpa_cli_cmd_hs20_icon_request
,
2999 wpa_cli_complete_bss
, cli_cmd_flag_none
,
3000 "<addr> <icon name> = get Hotspot 2.0 OSU icon" },
3001 { "fetch_osu", wpa_cli_cmd_fetch_osu
, NULL
, cli_cmd_flag_none
,
3002 "= fetch OSU provider information from all APs" },
3003 { "cancel_fetch_osu", wpa_cli_cmd_cancel_fetch_osu
, NULL
,
3005 "= cancel fetch_osu command" },
3006 #endif /* CONFIG_HS20 */
3007 { "sta_autoconnect", wpa_cli_cmd_sta_autoconnect
, NULL
,
3009 "<0/1> = disable/enable automatic reconnection" },
3010 { "tdls_discover", wpa_cli_cmd_tdls_discover
, NULL
,
3012 "<addr> = request TDLS discovery with <addr>" },
3013 { "tdls_setup", wpa_cli_cmd_tdls_setup
, NULL
,
3015 "<addr> = request TDLS setup with <addr>" },
3016 { "tdls_teardown", wpa_cli_cmd_tdls_teardown
, NULL
,
3018 "<addr> = tear down TDLS with <addr>" },
3019 { "wmm_ac_addts", wpa_cli_cmd_wmm_ac_addts
, NULL
,
3021 "<uplink/downlink/bidi> <tsid=0..7> <up=0..7> [nominal_msdu_size=#] "
3022 "[mean_data_rate=#] [min_phy_rate=#] [sba=#] [fixed_nominal_msdu] "
3023 "= add WMM-AC traffic stream" },
3024 { "wmm_ac_delts", wpa_cli_cmd_wmm_ac_delts
, NULL
,
3026 "<tsid> = delete WMM-AC traffic stream" },
3027 { "wmm_ac_status", wpa_cli_cmd_wmm_ac_status
, NULL
,
3029 "= show status for Wireless Multi-Media Admission-Control" },
3030 { "tdls_chan_switch", wpa_cli_cmd_tdls_chan_switch
, NULL
,
3032 "<addr> <oper class> <freq> [sec_channel_offset=] [center_freq1=] "
3033 "[center_freq2=] [bandwidth=] [ht|vht] = enable channel switching "
3035 { "tdls_cancel_chan_switch", wpa_cli_cmd_tdls_cancel_chan_switch
, NULL
,
3037 "<addr> = disable channel switching with TDLS peer <addr>" },
3038 { "signal_poll", wpa_cli_cmd_signal_poll
, NULL
,
3040 "= get signal parameters" },
3041 { "pktcnt_poll", wpa_cli_cmd_pktcnt_poll
, NULL
,
3043 "= get TX/RX packet counters" },
3044 { "reauthenticate", wpa_cli_cmd_reauthenticate
, NULL
,
3046 "= trigger IEEE 802.1X/EAPOL reauthentication" },
3047 #ifdef CONFIG_AUTOSCAN
3048 { "autoscan", wpa_cli_cmd_autoscan
, NULL
, cli_cmd_flag_none
,
3049 "[params] = Set or unset (if none) autoscan parameters" },
3050 #endif /* CONFIG_AUTOSCAN */
3052 { "wnm_sleep", wpa_cli_cmd_wnm_sleep
, NULL
, cli_cmd_flag_none
,
3053 "<enter/exit> [interval=#] = enter/exit WNM-Sleep mode" },
3054 { "wnm_bss_query", wpa_cli_cmd_wnm_bss_query
, NULL
, cli_cmd_flag_none
,
3055 "<query reason> = Send BSS Transition Management Query" },
3056 #endif /* CONFIG_WNM */
3057 { "raw", wpa_cli_cmd_raw
, NULL
, cli_cmd_flag_sensitive
,
3058 "<params..> = Sent unprocessed command" },
3059 { "flush", wpa_cli_cmd_flush
, NULL
, cli_cmd_flag_none
,
3060 "= flush wpa_supplicant state" },
3062 { "driver", wpa_cli_cmd_driver
, NULL
, cli_cmd_flag_none
,
3063 "<command> = driver private commands" },
3064 #endif /* ANDROID */
3065 { "radio_work", wpa_cli_cmd_radio_work
, NULL
, cli_cmd_flag_none
,
3066 "= radio_work <show/add/done>" },
3067 { "vendor", wpa_cli_cmd_vendor
, NULL
, cli_cmd_flag_none
,
3068 "<vendor id> <command id> [<hex formatted command argument>] = Send vendor command"
3070 { "neighbor_rep_request",
3071 wpa_cli_cmd_neighbor_rep_request
, NULL
, cli_cmd_flag_none
,
3072 "[ssid=<SSID>] = Trigger request to AP for neighboring AP report "
3073 "(with optional given SSID, default: current SSID)"
3075 { "erp_flush", wpa_cli_cmd_erp_flush
, NULL
, cli_cmd_flag_none
,
3076 "= flush ERP keys" },
3078 wpa_cli_cmd_mac_rand_scan
, NULL
, cli_cmd_flag_none
,
3079 "<scan|sched|pno|all> enable=<0/1> [addr=mac-address "
3080 "mask=mac-address-mask] = scan MAC randomization"
3082 { NULL
, NULL
, NULL
, cli_cmd_flag_none
, NULL
}
3087 * Prints command usage, lines are padded with the specified string.
3089 static void print_cmd_help(struct wpa_cli_cmd
*cmd
, const char *pad
)
3094 printf("%s%s ", pad
, cmd
->cmd
);
3095 for (n
= 0; (c
= cmd
->usage
[n
]); n
++) {
3104 static void print_help(const char *cmd
)
3107 printf("commands:\n");
3108 for (n
= 0; wpa_cli_commands
[n
].cmd
; n
++) {
3109 if (cmd
== NULL
|| str_starts(wpa_cli_commands
[n
].cmd
, cmd
))
3110 print_cmd_help(&wpa_cli_commands
[n
], " ");
3115 static int wpa_cli_edit_filter_history_cb(void *ctx
, const char *cmd
)
3117 const char *c
, *delim
;
3121 delim
= os_strchr(cmd
, ' ');
3125 len
= os_strlen(cmd
);
3127 for (n
= 0; (c
= wpa_cli_commands
[n
].cmd
); n
++) {
3128 if (os_strncasecmp(cmd
, c
, len
) == 0 && len
== os_strlen(c
))
3129 return (wpa_cli_commands
[n
].flags
&
3130 cli_cmd_flag_sensitive
);
3136 static char ** wpa_list_cmd_list(void)
3140 struct cli_txt_entry
*e
;
3142 count
= ARRAY_SIZE(wpa_cli_commands
);
3143 count
+= dl_list_len(&p2p_groups
);
3144 count
+= dl_list_len(&ifnames
);
3145 res
= os_calloc(count
+ 1, sizeof(char *));
3149 for (i
= 0; wpa_cli_commands
[i
].cmd
; i
++) {
3150 res
[i
] = os_strdup(wpa_cli_commands
[i
].cmd
);
3155 dl_list_for_each(e
, &p2p_groups
, struct cli_txt_entry
, list
) {
3156 size_t len
= 8 + os_strlen(e
->txt
);
3157 res
[i
] = os_malloc(len
);
3160 os_snprintf(res
[i
], len
, "ifname=%s", e
->txt
);
3164 dl_list_for_each(e
, &ifnames
, struct cli_txt_entry
, list
) {
3165 res
[i
] = os_strdup(e
->txt
);
3175 static char ** wpa_cli_cmd_completion(const char *cmd
, const char *str
,
3180 for (i
= 0; wpa_cli_commands
[i
].cmd
; i
++) {
3181 if (os_strcasecmp(wpa_cli_commands
[i
].cmd
, cmd
) == 0) {
3182 if (wpa_cli_commands
[i
].completion
)
3183 return wpa_cli_commands
[i
].completion(str
,
3186 printf("\r%s\n", wpa_cli_commands
[i
].usage
);
3196 static char ** wpa_cli_edit_completion_cb(void *ctx
, const char *str
, int pos
)
3202 if (pos
> 7 && os_strncasecmp(str
, "IFNAME=", 7) == 0) {
3203 end
= os_strchr(str
, ' ');
3204 if (end
&& pos
> end
- str
) {
3205 pos
-= end
- str
+ 1;
3210 end
= os_strchr(str
, ' ');
3211 if (end
== NULL
|| str
+ pos
< end
)
3212 return wpa_list_cmd_list();
3214 cmd
= os_malloc(pos
+ 1);
3217 os_memcpy(cmd
, str
, pos
);
3218 cmd
[end
- str
] = '\0';
3219 res
= wpa_cli_cmd_completion(cmd
, str
, pos
);
3225 static int wpa_request(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
3227 struct wpa_cli_cmd
*cmd
, *match
= NULL
;
3231 if (argc
> 1 && os_strncasecmp(argv
[0], "IFNAME=", 7) == 0) {
3232 ifname_prefix
= argv
[0] + 7;
3236 ifname_prefix
= NULL
;
3242 cmd
= wpa_cli_commands
;
3244 if (os_strncasecmp(cmd
->cmd
, argv
[0], os_strlen(argv
[0])) == 0)
3247 if (os_strcasecmp(cmd
->cmd
, argv
[0]) == 0) {
3248 /* we have an exact match */
3258 printf("Ambiguous command '%s'; possible commands:", argv
[0]);
3259 cmd
= wpa_cli_commands
;
3261 if (os_strncasecmp(cmd
->cmd
, argv
[0],
3262 os_strlen(argv
[0])) == 0) {
3263 printf(" %s", cmd
->cmd
);
3269 } else if (count
== 0) {
3270 printf("Unknown command '%s'\n", argv
[0]);
3273 ret
= match
->handler(ctrl
, argc
- 1, &argv
[1]);
3280 static int str_match(const char *a
, const char *b
)
3282 return os_strncmp(a
, b
, os_strlen(b
)) == 0;
3286 static int wpa_cli_exec(const char *program
, const char *arg1
,
3293 len
= os_strlen(arg1
) + os_strlen(arg2
) + 2;
3294 arg
= os_malloc(len
);
3297 os_snprintf(arg
, len
, "%s %s", arg1
, arg2
);
3298 res
= os_exec(program
, arg
, 1);
3305 static void wpa_cli_action_process(const char *msg
)
3308 char *copy
= NULL
, *id
, *pos2
;
3309 const char *ifname
= ctrl_ifname
;
3310 char ifname_buf
[100];
3313 if (os_strncmp(pos
, "IFNAME=", 7) == 0) {
3315 end
= os_strchr(pos
+ 7, ' ');
3316 if (end
&& (unsigned int) (end
- pos
) < sizeof(ifname_buf
)) {
3318 os_memcpy(ifname_buf
, pos
, end
- pos
);
3319 ifname_buf
[end
- pos
] = '\0';
3320 ifname
= ifname_buf
;
3325 const char *prev
= pos
;
3327 pos
= os_strchr(pos
, '>');
3334 if (str_match(pos
, WPA_EVENT_CONNECTED
)) {
3336 os_unsetenv("WPA_ID");
3337 os_unsetenv("WPA_ID_STR");
3338 os_unsetenv("WPA_CTRL_DIR");
3340 pos
= os_strstr(pos
, "[id=");
3342 copy
= os_strdup(pos
+ 4);
3346 while (*pos2
&& *pos2
!= ' ')
3350 os_setenv("WPA_ID", id
, 1);
3351 while (*pos2
&& *pos2
!= '=')
3356 while (*pos2
&& *pos2
!= ']')
3359 os_setenv("WPA_ID_STR", id
, 1);
3363 os_setenv("WPA_CTRL_DIR", ctrl_iface_dir
, 1);
3365 if (wpa_cli_connected
<= 0 || new_id
!= wpa_cli_last_id
) {
3366 wpa_cli_connected
= 1;
3367 wpa_cli_last_id
= new_id
;
3368 wpa_cli_exec(action_file
, ifname
, "CONNECTED");
3370 } else if (str_match(pos
, WPA_EVENT_DISCONNECTED
)) {
3371 if (wpa_cli_connected
) {
3372 wpa_cli_connected
= 0;
3373 wpa_cli_exec(action_file
, ifname
, "DISCONNECTED");
3375 } else if (str_match(pos
, MESH_GROUP_STARTED
)) {
3376 wpa_cli_exec(action_file
, ctrl_ifname
, pos
);
3377 } else if (str_match(pos
, MESH_GROUP_REMOVED
)) {
3378 wpa_cli_exec(action_file
, ctrl_ifname
, pos
);
3379 } else if (str_match(pos
, MESH_PEER_CONNECTED
)) {
3380 wpa_cli_exec(action_file
, ctrl_ifname
, pos
);
3381 } else if (str_match(pos
, MESH_PEER_DISCONNECTED
)) {
3382 wpa_cli_exec(action_file
, ctrl_ifname
, pos
);
3383 } else if (str_match(pos
, P2P_EVENT_GROUP_STARTED
)) {
3384 wpa_cli_exec(action_file
, ifname
, pos
);
3385 } else if (str_match(pos
, P2P_EVENT_GROUP_REMOVED
)) {
3386 wpa_cli_exec(action_file
, ifname
, pos
);
3387 } else if (str_match(pos
, P2P_EVENT_CROSS_CONNECT_ENABLE
)) {
3388 wpa_cli_exec(action_file
, ifname
, pos
);
3389 } else if (str_match(pos
, P2P_EVENT_CROSS_CONNECT_DISABLE
)) {
3390 wpa_cli_exec(action_file
, ifname
, pos
);
3391 } else if (str_match(pos
, P2P_EVENT_GO_NEG_FAILURE
)) {
3392 wpa_cli_exec(action_file
, ifname
, pos
);
3393 } else if (str_match(pos
, WPS_EVENT_SUCCESS
)) {
3394 wpa_cli_exec(action_file
, ifname
, pos
);
3395 } else if (str_match(pos
, WPS_EVENT_FAIL
)) {
3396 wpa_cli_exec(action_file
, ifname
, pos
);
3397 } else if (str_match(pos
, AP_STA_CONNECTED
)) {
3398 wpa_cli_exec(action_file
, ifname
, pos
);
3399 } else if (str_match(pos
, AP_STA_DISCONNECTED
)) {
3400 wpa_cli_exec(action_file
, ifname
, pos
);
3401 } else if (str_match(pos
, ESS_DISASSOC_IMMINENT
)) {
3402 wpa_cli_exec(action_file
, ifname
, pos
);
3403 } else if (str_match(pos
, HS20_SUBSCRIPTION_REMEDIATION
)) {
3404 wpa_cli_exec(action_file
, ifname
, pos
);
3405 } else if (str_match(pos
, HS20_DEAUTH_IMMINENT_NOTICE
)) {
3406 wpa_cli_exec(action_file
, ifname
, pos
);
3407 } else if (str_match(pos
, WPA_EVENT_TERMINATING
)) {
3408 printf("wpa_supplicant is terminating - stop monitoring\n");
3414 #ifndef CONFIG_ANSI_C_EXTRA
3415 static void wpa_cli_action_cb(char *msg
, size_t len
)
3417 wpa_cli_action_process(msg
);
3419 #endif /* CONFIG_ANSI_C_EXTRA */
3422 static void wpa_cli_reconnect(void)
3424 wpa_cli_close_connection();
3425 if (wpa_cli_open_connection(ctrl_ifname
, 1) < 0)
3430 printf("\rConnection to wpa_supplicant re-established\n");
3436 static void cli_event(const char *str
)
3438 const char *start
, *s
;
3440 start
= os_strchr(str
, '>');
3446 if (str_starts(start
, WPA_EVENT_BSS_ADDED
)) {
3447 s
= os_strchr(start
, ' ');
3450 s
= os_strchr(s
+ 1, ' ');
3453 cli_txt_list_add(&bsses
, s
+ 1);
3457 if (str_starts(start
, WPA_EVENT_BSS_REMOVED
)) {
3458 s
= os_strchr(start
, ' ');
3461 s
= os_strchr(s
+ 1, ' ');
3464 cli_txt_list_del_addr(&bsses
, s
+ 1);
3469 if (str_starts(start
, P2P_EVENT_DEVICE_FOUND
)) {
3470 s
= os_strstr(start
, " p2p_dev_addr=");
3473 cli_txt_list_add_addr(&p2p_peers
, s
+ 14);
3477 if (str_starts(start
, P2P_EVENT_DEVICE_LOST
)) {
3478 s
= os_strstr(start
, " p2p_dev_addr=");
3481 cli_txt_list_del_addr(&p2p_peers
, s
+ 14);
3485 if (str_starts(start
, P2P_EVENT_GROUP_STARTED
)) {
3486 s
= os_strchr(start
, ' ');
3489 cli_txt_list_add_word(&p2p_groups
, s
+ 1);
3493 if (str_starts(start
, P2P_EVENT_GROUP_REMOVED
)) {
3494 s
= os_strchr(start
, ' ');
3497 cli_txt_list_del_word(&p2p_groups
, s
+ 1);
3500 #endif /* CONFIG_P2P */
3504 static int check_terminating(const char *msg
)
3506 const char *pos
= msg
;
3510 pos
= os_strchr(pos
, '>');
3517 if (str_match(pos
, WPA_EVENT_TERMINATING
) && ctrl_conn
) {
3519 printf("\rConnection to wpa_supplicant lost - trying to "
3522 wpa_cli_attached
= 0;
3523 wpa_cli_close_connection();
3531 static void wpa_cli_recv_pending(struct wpa_ctrl
*ctrl
, int action_monitor
)
3533 if (ctrl_conn
== NULL
) {
3534 wpa_cli_reconnect();
3537 while (wpa_ctrl_pending(ctrl
) > 0) {
3539 size_t len
= sizeof(buf
) - 1;
3540 if (wpa_ctrl_recv(ctrl
, buf
, &len
) == 0) {
3543 wpa_cli_action_process(buf
);
3546 if (wpa_cli_show_event(buf
)) {
3548 printf("\r%s\n", buf
);
3552 if (interactive
&& check_terminating(buf
) > 0)
3556 printf("Could not read pending message.\n");
3561 if (wpa_ctrl_pending(ctrl
) < 0) {
3562 printf("Connection to wpa_supplicant lost - trying to "
3564 wpa_cli_reconnect();
3570 static int tokenize_cmd(char *cmd
, char *argv
[])
3583 if (argc
== max_args
)
3586 char *pos2
= os_strrchr(pos
, '"');
3590 while (*pos
!= '\0' && *pos
!= ' ')
3600 static void wpa_cli_ping(void *eloop_ctx
, void *timeout_ctx
)
3604 char *prefix
= ifname_prefix
;
3606 ifname_prefix
= NULL
;
3607 res
= _wpa_ctrl_command(ctrl_conn
, "PING", 0);
3608 ifname_prefix
= prefix
;
3610 printf("Connection to wpa_supplicant lost - trying to "
3612 wpa_cli_close_connection();
3616 wpa_cli_reconnect();
3617 eloop_register_timeout(ping_interval
, 0, wpa_cli_ping
, NULL
, NULL
);
3621 static void wpa_cli_mon_receive(int sock
, void *eloop_ctx
, void *sock_ctx
)
3623 wpa_cli_recv_pending(mon_conn
, 0);
3627 static void wpa_cli_edit_cmd_cb(void *ctx
, char *cmd
)
3629 char *argv
[max_args
];
3631 argc
= tokenize_cmd(cmd
, argv
);
3633 wpa_request(ctrl_conn
, argc
, argv
);
3637 static void wpa_cli_edit_eof_cb(void *ctx
)
3643 static int warning_displayed
= 0;
3644 static char *hfile
= NULL
;
3645 static int edit_started
= 0;
3647 static void start_edit(void)
3652 #ifdef CONFIG_CTRL_IFACE_UDP_REMOTE
3653 ps
= wpa_ctrl_get_remote_ifname(ctrl_conn
);
3654 #endif /* CONFIG_CTRL_IFACE_UDP_REMOTE */
3656 home
= getenv("HOME");
3658 const char *fname
= ".wpa_cli_history";
3659 int hfile_len
= os_strlen(home
) + 1 + os_strlen(fname
) + 1;
3660 hfile
= os_malloc(hfile_len
);
3662 os_snprintf(hfile
, hfile_len
, "%s/%s", home
, fname
);
3665 if (edit_init(wpa_cli_edit_cmd_cb
, wpa_cli_edit_eof_cb
,
3666 wpa_cli_edit_completion_cb
, NULL
, hfile
, ps
) < 0) {
3672 eloop_register_timeout(ping_interval
, 0, wpa_cli_ping
, NULL
, NULL
);
3676 static void update_bssid_list(struct wpa_ctrl
*ctrl
)
3679 size_t len
= sizeof(buf
);
3681 char *cmd
= "BSS RANGE=ALL MASK=0x2";
3686 ret
= wpa_ctrl_request(ctrl
, cmd
, os_strlen(cmd
), buf
, &len
, NULL
);
3693 pos
= os_strstr(pos
, "bssid=");
3697 end
= os_strchr(pos
, '\n');
3701 cli_txt_list_add(&bsses
, pos
);
3707 static void update_ifnames(struct wpa_ctrl
*ctrl
)
3710 size_t len
= sizeof(buf
);
3712 char *cmd
= "INTERFACES";
3716 cli_txt_list_flush(&ifnames
);
3720 ret
= wpa_ctrl_request(ctrl
, cmd
, os_strlen(cmd
), buf
, &len
, NULL
);
3727 end
= os_strchr(pos
, '\n');
3731 ret
= os_snprintf(txt
, sizeof(txt
), "ifname=%s", pos
);
3732 if (!os_snprintf_error(sizeof(txt
), ret
))
3733 cli_txt_list_add(&ifnames
, txt
);
3739 static void try_connection(void *eloop_ctx
, void *timeout_ctx
)
3744 if (ctrl_ifname
== NULL
)
3745 ctrl_ifname
= wpa_cli_get_default_ifname();
3747 if (!wpa_cli_open_connection(ctrl_ifname
, 1) == 0) {
3748 if (!warning_displayed
) {
3749 printf("Could not connect to wpa_supplicant: "
3751 ctrl_ifname
? ctrl_ifname
: "(nil)");
3752 warning_displayed
= 1;
3754 eloop_register_timeout(1, 0, try_connection
, NULL
, NULL
);
3758 update_bssid_list(ctrl_conn
);
3760 if (warning_displayed
)
3761 printf("Connection established.\n");
3768 static void wpa_cli_interactive(void)
3770 printf("\nInteractive mode\n\n");
3772 eloop_register_timeout(0, 0, try_connection
, NULL
, NULL
);
3774 eloop_cancel_timeout(try_connection
, NULL
, NULL
);
3776 cli_txt_list_flush(&p2p_peers
);
3777 cli_txt_list_flush(&p2p_groups
);
3778 cli_txt_list_flush(&bsses
);
3779 cli_txt_list_flush(&ifnames
);
3781 edit_deinit(hfile
, wpa_cli_edit_filter_history_cb
);
3783 eloop_cancel_timeout(wpa_cli_ping
, NULL
, NULL
);
3784 wpa_cli_close_connection();
3788 static void wpa_cli_action(struct wpa_ctrl
*ctrl
)
3790 #ifdef CONFIG_ANSI_C_EXTRA
3791 /* TODO: ANSI C version(?) */
3792 printf("Action processing not supported in ANSI C build.\n");
3793 #else /* CONFIG_ANSI_C_EXTRA */
3797 char buf
[256]; /* note: large enough to fit in unsolicited messages */
3800 fd
= wpa_ctrl_get_fd(ctrl
);
3802 while (!wpa_cli_quit
) {
3805 tv
.tv_sec
= ping_interval
;
3807 res
= select(fd
+ 1, &rfds
, NULL
, NULL
, &tv
);
3808 if (res
< 0 && errno
!= EINTR
) {
3813 if (FD_ISSET(fd
, &rfds
))
3814 wpa_cli_recv_pending(ctrl
, 1);
3816 /* verify that connection is still working */
3817 len
= sizeof(buf
) - 1;
3818 if (wpa_ctrl_request(ctrl
, "PING", 4, buf
, &len
,
3819 wpa_cli_action_cb
) < 0 ||
3820 len
< 4 || os_memcmp(buf
, "PONG", 4) != 0) {
3821 printf("wpa_supplicant did not reply to PING "
3822 "command - exiting\n");
3827 #endif /* CONFIG_ANSI_C_EXTRA */
3831 static void wpa_cli_cleanup(void)
3833 wpa_cli_close_connection();
3835 os_daemonize_terminate(pid_file
);
3837 os_program_deinit();
3841 static void wpa_cli_terminate(int sig
, void *ctx
)
3847 static char * wpa_cli_get_default_ifname(void)
3849 char *ifname
= NULL
;
3851 #ifdef CONFIG_CTRL_IFACE_UNIX
3852 struct dirent
*dent
;
3853 DIR *dir
= opendir(ctrl_iface_dir
);
3856 char ifprop
[PROPERTY_VALUE_MAX
];
3857 if (property_get("wifi.interface", ifprop
, NULL
) != 0) {
3858 ifname
= os_strdup(ifprop
);
3859 printf("Using interface '%s'\n", ifname
);
3862 #endif /* ANDROID */
3865 while ((dent
= readdir(dir
))) {
3866 #ifdef _DIRENT_HAVE_D_TYPE
3868 * Skip the file if it is not a socket. Also accept
3869 * DT_UNKNOWN (0) in case the C library or underlying
3870 * file system does not support d_type.
3872 if (dent
->d_type
!= DT_SOCK
&& dent
->d_type
!= DT_UNKNOWN
)
3874 #endif /* _DIRENT_HAVE_D_TYPE */
3875 if (os_strcmp(dent
->d_name
, ".") == 0 ||
3876 os_strcmp(dent
->d_name
, "..") == 0)
3878 printf("Selected interface '%s'\n", dent
->d_name
);
3879 ifname
= os_strdup(dent
->d_name
);
3883 #endif /* CONFIG_CTRL_IFACE_UNIX */
3885 #ifdef CONFIG_CTRL_IFACE_NAMED_PIPE
3886 char buf
[4096], *pos
;
3888 struct wpa_ctrl
*ctrl
;
3891 ctrl
= wpa_ctrl_open(NULL
);
3895 len
= sizeof(buf
) - 1;
3896 ret
= wpa_ctrl_request(ctrl
, "INTERFACES", 10, buf
, &len
, NULL
);
3899 pos
= os_strchr(buf
, '\n');
3902 ifname
= os_strdup(buf
);
3904 wpa_ctrl_close(ctrl
);
3905 #endif /* CONFIG_CTRL_IFACE_NAMED_PIPE */
3911 int main(int argc
, char *argv
[])
3916 const char *global
= NULL
;
3918 if (os_program_init())
3922 c
= getopt(argc
, argv
, "a:Bg:G:hi:p:P:v");
3927 action_file
= optarg
;
3936 ping_interval
= atoi(optarg
);
3942 printf("%s\n", wpa_cli_version
);
3945 os_free(ctrl_ifname
);
3946 ctrl_ifname
= os_strdup(optarg
);
3949 ctrl_iface_dir
= optarg
;
3960 interactive
= (argc
== optind
) && (action_file
== NULL
);
3963 printf("%s\n\n%s\n\n", wpa_cli_version
, wpa_cli_license
);
3969 #ifdef CONFIG_CTRL_IFACE_NAMED_PIPE
3970 ctrl_conn
= wpa_ctrl_open(NULL
);
3971 #else /* CONFIG_CTRL_IFACE_NAMED_PIPE */
3972 ctrl_conn
= wpa_ctrl_open(global
);
3973 #endif /* CONFIG_CTRL_IFACE_NAMED_PIPE */
3974 if (ctrl_conn
== NULL
) {
3975 fprintf(stderr
, "Failed to connect to wpa_supplicant "
3976 "global interface: %s error: %s\n",
3977 global
, strerror(errno
));
3982 update_ifnames(ctrl_conn
);
3983 mon_conn
= wpa_ctrl_open(global
);
3985 if (wpa_ctrl_attach(mon_conn
) == 0) {
3986 wpa_cli_attached
= 1;
3987 eloop_register_read_sock(
3988 wpa_ctrl_get_fd(mon_conn
),
3989 wpa_cli_mon_receive
,
3992 printf("Failed to open monitor "
3993 "connection through global "
3994 "control interface\n");
4000 eloop_register_signal_terminate(wpa_cli_terminate
, NULL
);
4002 if (ctrl_ifname
== NULL
)
4003 ctrl_ifname
= wpa_cli_get_default_ifname();
4006 wpa_cli_interactive();
4009 wpa_cli_open_connection(ctrl_ifname
, 0) < 0) {
4010 fprintf(stderr
, "Failed to connect to non-global "
4011 "ctrl_ifname: %s error: %s\n",
4012 ctrl_ifname
? ctrl_ifname
: "(nil)",
4018 if (wpa_ctrl_attach(ctrl_conn
) == 0) {
4019 wpa_cli_attached
= 1;
4021 printf("Warning: Failed to attach to "
4022 "wpa_supplicant.\n");
4027 if (daemonize
&& os_daemonize(pid_file
))
4031 wpa_cli_action(ctrl_conn
);
4033 ret
= wpa_request(ctrl_conn
, argc
- optind
,
4037 os_free(ctrl_ifname
);
4044 #else /* CONFIG_CTRL_IFACE */
4045 int main(int argc
, char *argv
[])
4047 printf("CONFIG_CTRL_IFACE not defined - wpa_cli disabled\n");
4050 #endif /* CONFIG_CTRL_IFACE */