2 * WPA Supplicant - command line interface for wpa_supplicant daemon
3 * Copyright (c) 2004-2019, 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/cli.h"
18 #include "common/wpa_ctrl.h"
19 #include "utils/common.h"
20 #include "utils/eloop.h"
21 #include "utils/edit.h"
22 #include "utils/list.h"
23 #include "common/version.h"
24 #include "common/ieee802_11_defs.h"
26 #include <cutils/properties.h>
30 static const char *const wpa_cli_version
=
31 "wpa_cli v" VERSION_STR
"\n"
32 "Copyright (c) 2004-2019, Jouni Malinen <j@w1.fi> and contributors";
34 #define VENDOR_ELEM_FRAME_ID \
35 " 0: Probe Req (P2P), 1: Probe Resp (P2P) , 2: Probe Resp (GO), " \
36 "3: Beacon (GO), 4: PD Req, 5: PD Resp, 6: GO Neg Req, " \
37 "7: GO Neg Resp, 8: GO Neg Conf, 9: Inv Req, 10: Inv Resp, " \
38 "11: Assoc Req (P2P), 12: Assoc Resp (P2P)"
40 static struct wpa_ctrl
*ctrl_conn
;
41 static struct wpa_ctrl
*mon_conn
;
42 static int wpa_cli_quit
= 0;
43 static int wpa_cli_attached
= 0;
44 static int wpa_cli_connected
= -1;
45 static int wpa_cli_last_id
= 0;
46 #ifndef CONFIG_CTRL_IFACE_DIR
47 #define CONFIG_CTRL_IFACE_DIR "/var/run/wpa_supplicant"
48 #endif /* CONFIG_CTRL_IFACE_DIR */
49 static const char *ctrl_iface_dir
= CONFIG_CTRL_IFACE_DIR
;
50 static const char *client_socket_dir
= NULL
;
51 static char *ctrl_ifname
= NULL
;
52 static const char *global
= NULL
;
53 static const char *pid_file
= NULL
;
54 static const char *action_file
= NULL
;
55 static int ping_interval
= 5;
56 static int interactive
= 0;
57 static char *ifname_prefix
= NULL
;
59 static DEFINE_DL_LIST(bsses
); /* struct cli_txt_entry */
60 static DEFINE_DL_LIST(p2p_peers
); /* struct cli_txt_entry */
61 static DEFINE_DL_LIST(p2p_groups
); /* struct cli_txt_entry */
62 static DEFINE_DL_LIST(ifnames
); /* struct cli_txt_entry */
63 static DEFINE_DL_LIST(networks
); /* struct cli_txt_entry */
64 static DEFINE_DL_LIST(creds
); /* struct cli_txt_entry */
66 static DEFINE_DL_LIST(stations
); /* struct cli_txt_entry */
67 #endif /* CONFIG_AP */
70 static void print_help(const char *cmd
);
71 static void wpa_cli_mon_receive(int sock
, void *eloop_ctx
, void *sock_ctx
);
72 static void wpa_cli_close_connection(void);
73 static char * wpa_cli_get_default_ifname(void);
74 static char ** wpa_list_cmd_list(void);
75 static void update_creds(struct wpa_ctrl
*ctrl
);
76 static void update_networks(struct wpa_ctrl
*ctrl
);
77 static void update_stations(struct wpa_ctrl
*ctrl
);
78 static void update_ifnames(struct wpa_ctrl
*ctrl
);
81 static void usage(void)
83 printf("wpa_cli [-p<path to ctrl sockets>] [-i<ifname>] [-hvB] "
84 "[-a<action file>] \\\n"
85 " [-P<pid file>] [-g<global ctrl>] [-G<ping interval>] "
87 " [-s<wpa_client_socket_file_path>] "
89 " -h = help (show this usage text)\n"
90 " -v = shown version information\n"
91 " -a = run in daemon mode executing the action file based on "
94 " -B = run a daemon in the background\n"
95 " default path: " CONFIG_CTRL_IFACE_DIR
"\n"
96 " default interface: first interface found in socket path\n");
101 static int wpa_cli_show_event(const char *event
)
105 start
= os_strchr(event
, '>');
111 * Skip BSS added/removed events since they can be relatively frequent
112 * and are likely of not much use for an interactive user.
114 if (str_starts(start
, WPA_EVENT_BSS_ADDED
) ||
115 str_starts(start
, WPA_EVENT_BSS_REMOVED
))
122 static int wpa_cli_open_connection(const char *ifname
, int attach
)
124 #if defined(CONFIG_CTRL_IFACE_UDP) || defined(CONFIG_CTRL_IFACE_NAMED_PIPE)
125 ctrl_conn
= wpa_ctrl_open(ifname
);
126 if (ctrl_conn
== NULL
)
129 if (attach
&& interactive
)
130 mon_conn
= wpa_ctrl_open(ifname
);
133 #else /* CONFIG_CTRL_IFACE_UDP || CONFIG_CTRL_IFACE_NAMED_PIPE */
141 if (access(ctrl_iface_dir
, F_OK
) < 0) {
142 cfile
= os_strdup(ifname
);
148 if (client_socket_dir
&& client_socket_dir
[0] &&
149 access(client_socket_dir
, F_OK
) < 0) {
150 perror(client_socket_dir
);
156 flen
= os_strlen(ctrl_iface_dir
) + os_strlen(ifname
) + 2;
157 cfile
= os_malloc(flen
);
160 res
= os_snprintf(cfile
, flen
, "%s/%s", ctrl_iface_dir
,
162 if (os_snprintf_error(flen
, res
)) {
168 ctrl_conn
= wpa_ctrl_open2(cfile
, client_socket_dir
);
169 if (ctrl_conn
== NULL
) {
174 if (attach
&& interactive
)
175 mon_conn
= wpa_ctrl_open2(cfile
, client_socket_dir
);
179 #endif /* CONFIG_CTRL_IFACE_UDP || CONFIG_CTRL_IFACE_NAMED_PIPE */
182 if (wpa_ctrl_attach(mon_conn
) == 0) {
183 wpa_cli_attached
= 1;
185 eloop_register_read_sock(
186 wpa_ctrl_get_fd(mon_conn
),
187 wpa_cli_mon_receive
, NULL
, NULL
);
189 printf("Warning: Failed to attach to "
190 "wpa_supplicant.\n");
191 wpa_cli_close_connection();
200 static void wpa_cli_close_connection(void)
202 if (ctrl_conn
== NULL
)
205 if (wpa_cli_attached
) {
206 wpa_ctrl_detach(interactive
? mon_conn
: ctrl_conn
);
207 wpa_cli_attached
= 0;
209 wpa_ctrl_close(ctrl_conn
);
212 eloop_unregister_read_sock(wpa_ctrl_get_fd(mon_conn
));
213 wpa_ctrl_close(mon_conn
);
219 static void wpa_cli_msg_cb(char *msg
, size_t len
)
225 static int _wpa_ctrl_command(struct wpa_ctrl
*ctrl
, const char *cmd
, int print
)
231 if (ctrl_conn
== NULL
) {
232 printf("Not connected to wpa_supplicant - command dropped.\n");
236 os_snprintf(buf
, sizeof(buf
), "IFNAME=%s %s",
238 buf
[sizeof(buf
) - 1] = '\0';
241 len
= sizeof(buf
) - 1;
242 ret
= wpa_ctrl_request(ctrl
, cmd
, os_strlen(cmd
), buf
, &len
,
245 printf("'%s' command timed out.\n", cmd
);
247 } else if (ret
< 0) {
248 printf("'%s' command failed.\n", cmd
);
254 if (interactive
&& len
> 0 && buf
[len
- 1] != '\n')
261 static int wpa_ctrl_command(struct wpa_ctrl
*ctrl
, const char *cmd
)
263 return _wpa_ctrl_command(ctrl
, cmd
, 1);
267 static int wpa_cli_cmd(struct wpa_ctrl
*ctrl
, const char *cmd
, int min_args
,
268 int argc
, char *argv
[])
271 if (argc
< min_args
) {
272 printf("Invalid %s command - at least %d argument%s "
273 "required.\n", cmd
, min_args
,
274 min_args
> 1 ? "s are" : " is");
277 if (write_cmd(buf
, sizeof(buf
), cmd
, argc
, argv
) < 0)
279 return wpa_ctrl_command(ctrl
, buf
);
283 static int wpa_cli_cmd_ifname(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
285 return wpa_ctrl_command(ctrl
, "IFNAME");
289 static int wpa_cli_cmd_status(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
291 if (argc
> 0 && os_strcmp(argv
[0], "verbose") == 0)
292 return wpa_ctrl_command(ctrl
, "STATUS-VERBOSE");
293 if (argc
> 0 && os_strcmp(argv
[0], "wps") == 0)
294 return wpa_ctrl_command(ctrl
, "STATUS-WPS");
295 if (argc
> 0 && os_strcmp(argv
[0], "driver") == 0)
296 return wpa_ctrl_command(ctrl
, "STATUS-DRIVER");
298 if (argc
> 0 && os_strcmp(argv
[0], "no_events") == 0)
299 return wpa_ctrl_command(ctrl
, "STATUS-NO_EVENTS");
301 return wpa_ctrl_command(ctrl
, "STATUS");
305 static int wpa_cli_cmd_ping(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
307 return wpa_ctrl_command(ctrl
, "PING");
311 static int wpa_cli_cmd_relog(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
313 return wpa_ctrl_command(ctrl
, "RELOG");
317 static int wpa_cli_cmd_note(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
319 return wpa_cli_cmd(ctrl
, "NOTE", 1, argc
, argv
);
323 static int wpa_cli_cmd_mib(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
325 return wpa_ctrl_command(ctrl
, "MIB");
329 static int wpa_cli_cmd_pmksa(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
331 return wpa_ctrl_command(ctrl
, "PMKSA");
335 static int wpa_cli_cmd_pmksa_flush(struct wpa_ctrl
*ctrl
, int argc
,
338 return wpa_ctrl_command(ctrl
, "PMKSA_FLUSH");
342 #ifdef CONFIG_PMKSA_CACHE_EXTERNAL
344 static int wpa_cli_cmd_pmksa_get(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
346 return wpa_cli_cmd(ctrl
, "PMKSA_GET", 1, argc
, argv
);
350 static int wpa_cli_cmd_pmksa_add(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
352 return wpa_cli_cmd(ctrl
, "PMKSA_ADD", 8, argc
, argv
);
358 static int wpa_cli_mesh_cmd_pmksa_get(struct wpa_ctrl
*ctrl
, int argc
,
361 return wpa_cli_cmd(ctrl
, "MESH_PMKSA_GET", 1, argc
, argv
);
365 static int wpa_cli_mesh_cmd_pmksa_add(struct wpa_ctrl
*ctrl
, int argc
,
368 return wpa_cli_cmd(ctrl
, "MESH_PMKSA_ADD", 4, argc
, argv
);
371 #endif /* CONFIG_MESH */
372 #endif /* CONFIG_PMKSA_CACHE_EXTERNAL */
375 static int wpa_cli_cmd_help(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
377 print_help(argc
> 0 ? argv
[0] : NULL
);
382 static char ** wpa_cli_complete_help(const char *str
, int pos
)
384 int arg
= get_cmd_arg_num(str
, pos
);
389 res
= wpa_list_cmd_list();
397 static int wpa_cli_cmd_license(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
399 printf("%s\n\n%s\n", wpa_cli_version
, cli_full_license
);
404 static int wpa_cli_cmd_quit(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
413 static int wpa_cli_cmd_set(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
419 res
= os_snprintf(cmd
, sizeof(cmd
), "SET %s ", argv
[0]);
420 if (os_snprintf_error(sizeof(cmd
), res
)) {
421 printf("Too long SET command.\n");
424 return wpa_ctrl_command(ctrl
, cmd
);
427 return wpa_cli_cmd(ctrl
, "SET", 2, argc
, argv
);
431 static char ** wpa_cli_complete_set(const char *str
, int pos
)
433 int arg
= get_cmd_arg_num(str
, pos
);
434 const char *fields
[] = {
436 "EAPOL::heldPeriod", "EAPOL::authPeriod", "EAPOL::startPeriod",
437 "EAPOL::maxStart", "dot11RSNAConfigPMKLifetime",
438 "dot11RSNAConfigPMKReauthThreshold", "dot11RSNAConfigSATimeout",
439 "wps_fragment_size", "wps_version_number", "ampdu",
440 "tdls_testing", "tdls_disabled", "pno", "radio_disabled",
441 "uapsd", "ps", "wifi_display", "bssid_filter", "disallow_aps",
443 /* global configuration parameters */
444 #ifdef CONFIG_CTRL_IFACE
445 "ctrl_interface", "no_ctrl_interface", "ctrl_interface_group",
446 #endif /* CONFIG_CTRL_IFACE */
447 "eapol_version", "ap_scan", "bgscan",
449 "user_mpm", "max_peer_links", "mesh_max_inactivity",
450 "dot11RSNASAERetransPeriod",
451 #endif /* CONFIG_MESH */
452 "disable_scan_offload", "fast_reauth", "opensc_engine_path",
453 "pkcs11_engine_path", "pkcs11_module_path", "openssl_ciphers",
454 "pcsc_reader", "pcsc_pin", "external_sim", "driver_param",
455 "dot11RSNAConfigPMKLifetime",
456 "dot11RSNAConfigPMKReauthThreshold",
457 "dot11RSNAConfigSATimeout",
458 #ifndef CONFIG_NO_CONFIG_WRITE
460 #endif /* CONFIG_NO_CONFIG_WRITE */
463 "uuid", "device_name", "manufacturer", "model_name",
464 "model_number", "serial_number", "device_type", "os_version",
465 "config_methods", "wps_cred_processing", "wps_vendor_ext_m1",
466 #endif /* CONFIG_WPS */
469 "p2p_listen_reg_class", "p2p_listen_channel",
470 "p2p_oper_reg_class", "p2p_oper_channel", "p2p_go_intent",
471 "p2p_ssid_postfix", "persistent_reconnect", "p2p_intra_bss",
472 "p2p_group_idle", "p2p_passphrase_len", "p2p_pref_chan",
473 "p2p_no_go_freq", "p2p_add_cli_chan",
474 "p2p_optimize_listen_chan", "p2p_go_ht40", "p2p_go_vht",
475 "p2p_disabled", "p2p_go_ctwindow", "p2p_no_group_iface",
476 "p2p_ignore_shared_freq", "ip_addr_go", "ip_addr_mask",
477 "ip_addr_start", "ip_addr_end",
478 #endif /* CONFIG_P2P */
479 "country", "bss_max_count", "bss_expiration_age",
480 "bss_expiration_scan_count", "filter_ssids", "filter_rssi",
481 "max_num_sta", "disassoc_low_ack", "ap_isolate",
484 #endif /* CONFIG_HS20 */
485 "interworking", "hessid", "access_network_type", "pbc_in_m1",
486 "go_interworking", "go_access_network_type", "go_internet",
487 "go_venue_group", "go_venue_type",
488 "autoscan", "wps_nfc_dev_pw_id", "wps_nfc_dh_pubkey",
489 "wps_nfc_dh_privkey", "wps_nfc_dev_pw", "ext_password_backend",
490 "p2p_go_max_inactivity", "auto_interworking", "okc", "pmf",
491 "sae_groups", "dtim_period", "beacon_int",
492 "ap_vendor_elements", "ignore_old_scan_res", "freq_list",
493 "scan_cur_freq", "sched_scan_interval",
494 "tdls_external_control", "osu_dir", "wowlan_triggers",
495 "p2p_search_delay", "mac_addr", "rand_addr_lifetime",
496 "preassoc_mac_addr", "key_mgmt_offload", "passive_scan",
497 "reassoc_same_bss_optim", "wps_priority",
498 #ifdef CONFIG_TESTING_OPTIONS
500 #endif /* CONFIG_TESTING_OPTIONS */
501 "relative_rssi", "relative_band_adjust",
503 int i
, num_fields
= ARRAY_SIZE(fields
);
506 char **res
= os_calloc(num_fields
+ 1, sizeof(char *));
509 for (i
= 0; i
< num_fields
; i
++) {
510 res
[i
] = os_strdup(fields
[i
]);
517 if (arg
> 1 && os_strncasecmp(str
, "set bssid_filter ", 17) == 0)
518 return cli_txt_list_array(&bsses
);
523 static int wpa_cli_cmd_dump(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
525 return wpa_ctrl_command(ctrl
, "DUMP");
529 static int wpa_cli_cmd_driver_flags(struct wpa_ctrl
*ctrl
, int argc
,
532 return wpa_ctrl_command(ctrl
, "DRIVER_FLAGS");
536 static int wpa_cli_cmd_get(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
538 return wpa_cli_cmd(ctrl
, "GET", 1, argc
, argv
);
542 static char ** wpa_cli_complete_get(const char *str
, int pos
)
544 int arg
= get_cmd_arg_num(str
, pos
);
545 const char *fields
[] = {
546 #ifdef CONFIG_CTRL_IFACE
547 "ctrl_interface", "ctrl_interface_group",
548 #endif /* CONFIG_CTRL_IFACE */
549 "eapol_version", "ap_scan",
551 "user_mpm", "max_peer_links", "mesh_max_inactivity",
552 #endif /* CONFIG_MESH */
553 "disable_scan_offload", "fast_reauth", "opensc_engine_path",
554 "pkcs11_engine_path", "pkcs11_module_path", "openssl_ciphers",
555 "pcsc_reader", "pcsc_pin", "external_sim", "driver_param",
556 "dot11RSNAConfigPMKLifetime",
557 "dot11RSNAConfigPMKReauthThreshold",
558 "dot11RSNAConfigSATimeout",
559 #ifndef CONFIG_NO_CONFIG_WRITE
561 #endif /* CONFIG_NO_CONFIG_WRITE */
563 "device_name", "manufacturer", "model_name", "model_number",
564 "serial_number", "config_methods", "wps_cred_processing",
565 #endif /* CONFIG_WPS */
567 "p2p_listen_reg_class", "p2p_listen_channel",
568 "p2p_oper_reg_class", "p2p_oper_channel", "p2p_go_intent",
569 "p2p_ssid_postfix", "persistent_reconnect", "p2p_intra_bss",
570 "p2p_group_idle", "p2p_passphrase_len", "p2p_add_cli_chan",
571 "p2p_optimize_listen_chan", "p2p_go_ht40", "p2p_go_vht",
572 "p2p_disabled", "p2p_go_ctwindow", "p2p_no_group_iface",
573 "p2p_ignore_shared_freq", "ip_addr_go", "ip_addr_mask",
574 "ip_addr_start", "ip_addr_end",
575 #endif /* CONFIG_P2P */
576 "bss_max_count", "bss_expiration_age",
577 "bss_expiration_scan_count", "filter_ssids", "filter_rssi",
578 "max_num_sta", "disassoc_low_ack", "ap_isolate",
581 #endif /* CONFIG_HS20 */
582 "interworking", "access_network_type", "pbc_in_m1", "autoscan",
583 "go_interworking", "go_access_network_type", "go_internet",
584 "go_venue_group", "go_venue_type",
585 "wps_nfc_dev_pw_id", "ext_password_backend",
586 "p2p_go_max_inactivity", "auto_interworking", "okc", "pmf",
587 "dtim_period", "beacon_int", "ignore_old_scan_res",
588 "scan_cur_freq", "sched_scan_interval",
589 "sched_scan_start_delay",
590 "tdls_external_control", "osu_dir", "wowlan_triggers",
591 "p2p_search_delay", "mac_addr", "rand_addr_lifetime",
592 "preassoc_mac_addr", "key_mgmt_offload", "passive_scan",
593 "reassoc_same_bss_optim"
595 int i
, num_fields
= ARRAY_SIZE(fields
);
598 char **res
= os_calloc(num_fields
+ 1, sizeof(char *));
601 for (i
= 0; i
< num_fields
; i
++) {
602 res
[i
] = os_strdup(fields
[i
]);
613 static int wpa_cli_cmd_logoff(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
615 return wpa_ctrl_command(ctrl
, "LOGOFF");
619 static int wpa_cli_cmd_logon(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
621 return wpa_ctrl_command(ctrl
, "LOGON");
625 static int wpa_cli_cmd_reassociate(struct wpa_ctrl
*ctrl
, int argc
,
628 return wpa_ctrl_command(ctrl
, "REASSOCIATE");
632 static int wpa_cli_cmd_reattach(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
634 return wpa_ctrl_command(ctrl
, "REATTACH");
638 static int wpa_cli_cmd_preauthenticate(struct wpa_ctrl
*ctrl
, int argc
,
641 return wpa_cli_cmd(ctrl
, "PREAUTH", 1, argc
, argv
);
645 static int wpa_cli_cmd_ap_scan(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
647 return wpa_cli_cmd(ctrl
, "AP_SCAN", 1, argc
, argv
);
651 static int wpa_cli_cmd_scan_interval(struct wpa_ctrl
*ctrl
, int argc
,
654 return wpa_cli_cmd(ctrl
, "SCAN_INTERVAL", 1, argc
, argv
);
658 static int wpa_cli_cmd_bss_expire_age(struct wpa_ctrl
*ctrl
, int argc
,
661 return wpa_cli_cmd(ctrl
, "BSS_EXPIRE_AGE", 1, argc
, argv
);
665 static int wpa_cli_cmd_bss_expire_count(struct wpa_ctrl
*ctrl
, int argc
,
668 return wpa_cli_cmd(ctrl
, "BSS_EXPIRE_COUNT", 1, argc
, argv
);
672 static int wpa_cli_cmd_bss_flush(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
678 res
= os_snprintf(cmd
, sizeof(cmd
), "BSS_FLUSH 0");
680 res
= os_snprintf(cmd
, sizeof(cmd
), "BSS_FLUSH %s", argv
[0]);
681 if (os_snprintf_error(sizeof(cmd
), res
)) {
682 printf("Too long BSS_FLUSH command.\n");
685 return wpa_ctrl_command(ctrl
, cmd
);
689 static int wpa_cli_cmd_ft_ds(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
691 return wpa_cli_cmd(ctrl
, "FT_DS", 1, argc
, argv
);
695 static int wpa_cli_cmd_wps_pbc(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
697 return wpa_cli_cmd(ctrl
, "WPS_PBC", 0, argc
, argv
);
701 static int wpa_cli_cmd_wps_pin(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
704 printf("Invalid WPS_PIN command: need one or two arguments:\n"
705 "- BSSID: use 'any' to select any\n"
706 "- PIN: optional, used only with devices that have no "
711 return wpa_cli_cmd(ctrl
, "WPS_PIN", 1, argc
, argv
);
715 static int wpa_cli_cmd_wps_check_pin(struct wpa_ctrl
*ctrl
, int argc
,
718 return wpa_cli_cmd(ctrl
, "WPS_CHECK_PIN", 1, argc
, argv
);
722 static int wpa_cli_cmd_wps_cancel(struct wpa_ctrl
*ctrl
, int argc
,
725 return wpa_ctrl_command(ctrl
, "WPS_CANCEL");
729 #ifdef CONFIG_WPS_NFC
731 static int wpa_cli_cmd_wps_nfc(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
733 return wpa_cli_cmd(ctrl
, "WPS_NFC", 0, argc
, argv
);
737 static int wpa_cli_cmd_wps_nfc_config_token(struct wpa_ctrl
*ctrl
, int argc
,
740 return wpa_cli_cmd(ctrl
, "WPS_NFC_CONFIG_TOKEN", 1, argc
, argv
);
744 static int wpa_cli_cmd_wps_nfc_token(struct wpa_ctrl
*ctrl
, int argc
,
747 return wpa_cli_cmd(ctrl
, "WPS_NFC_TOKEN", 1, argc
, argv
);
751 static int wpa_cli_cmd_wps_nfc_tag_read(struct wpa_ctrl
*ctrl
, int argc
,
759 printf("Invalid 'wps_nfc_tag_read' command - one argument "
764 buflen
= 18 + os_strlen(argv
[0]);
765 buf
= os_malloc(buflen
);
768 os_snprintf(buf
, buflen
, "WPS_NFC_TAG_READ %s", argv
[0]);
770 ret
= wpa_ctrl_command(ctrl
, buf
);
777 static int wpa_cli_cmd_nfc_get_handover_req(struct wpa_ctrl
*ctrl
, int argc
,
780 return wpa_cli_cmd(ctrl
, "NFC_GET_HANDOVER_REQ", 2, argc
, argv
);
784 static int wpa_cli_cmd_nfc_get_handover_sel(struct wpa_ctrl
*ctrl
, int argc
,
787 return wpa_cli_cmd(ctrl
, "NFC_GET_HANDOVER_SEL", 2, argc
, argv
);
791 static int wpa_cli_cmd_nfc_report_handover(struct wpa_ctrl
*ctrl
, int argc
,
794 return wpa_cli_cmd(ctrl
, "NFC_REPORT_HANDOVER", 4, argc
, argv
);
797 #endif /* CONFIG_WPS_NFC */
800 static int wpa_cli_cmd_wps_reg(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
806 res
= os_snprintf(cmd
, sizeof(cmd
), "WPS_REG %s %s",
808 else if (argc
== 5 || argc
== 6) {
809 char ssid_hex
[2 * SSID_MAX_LEN
+ 1];
810 char key_hex
[2 * 64 + 1];
814 for (i
= 0; i
< SSID_MAX_LEN
; i
++) {
815 if (argv
[2][i
] == '\0')
817 os_snprintf(&ssid_hex
[i
* 2], 3, "%02x", argv
[2][i
]);
822 for (i
= 0; i
< 64; i
++) {
823 if (argv
[5][i
] == '\0')
825 os_snprintf(&key_hex
[i
* 2], 3, "%02x",
830 res
= os_snprintf(cmd
, sizeof(cmd
),
831 "WPS_REG %s %s %s %s %s %s",
832 argv
[0], argv
[1], ssid_hex
, argv
[3], argv
[4],
835 printf("Invalid WPS_REG command: need two arguments:\n"
836 "- BSSID of the target AP\n"
838 printf("Alternatively, six arguments can be used to "
839 "reconfigure the AP:\n"
840 "- BSSID of the target AP\n"
843 "- new auth (OPEN, WPAPSK, WPA2PSK)\n"
844 "- new encr (NONE, WEP, TKIP, CCMP)\n"
849 if (os_snprintf_error(sizeof(cmd
), res
)) {
850 printf("Too long WPS_REG command.\n");
853 return wpa_ctrl_command(ctrl
, cmd
);
857 static int wpa_cli_cmd_wps_ap_pin(struct wpa_ctrl
*ctrl
, int argc
,
860 return wpa_cli_cmd(ctrl
, "WPS_AP_PIN", 1, argc
, argv
);
864 static int wpa_cli_cmd_wps_er_start(struct wpa_ctrl
*ctrl
, int argc
,
867 return wpa_cli_cmd(ctrl
, "WPS_ER_START", 0, argc
, argv
);
871 static int wpa_cli_cmd_wps_er_stop(struct wpa_ctrl
*ctrl
, int argc
,
874 return wpa_ctrl_command(ctrl
, "WPS_ER_STOP");
879 static int wpa_cli_cmd_wps_er_pin(struct wpa_ctrl
*ctrl
, int argc
,
883 printf("Invalid WPS_ER_PIN command: need at least two "
885 "- UUID: use 'any' to select any\n"
886 "- PIN: Enrollee PIN\n"
887 "optional: - Enrollee MAC address\n");
891 return wpa_cli_cmd(ctrl
, "WPS_ER_PIN", 2, argc
, argv
);
895 static int wpa_cli_cmd_wps_er_pbc(struct wpa_ctrl
*ctrl
, int argc
,
898 return wpa_cli_cmd(ctrl
, "WPS_ER_PBC", 1, argc
, argv
);
902 static int wpa_cli_cmd_wps_er_learn(struct wpa_ctrl
*ctrl
, int argc
,
906 printf("Invalid WPS_ER_LEARN command: need two arguments:\n"
907 "- UUID: specify which AP to use\n"
912 return wpa_cli_cmd(ctrl
, "WPS_ER_LEARN", 2, argc
, argv
);
916 static int wpa_cli_cmd_wps_er_set_config(struct wpa_ctrl
*ctrl
, int argc
,
920 printf("Invalid WPS_ER_SET_CONFIG command: need two "
922 "- UUID: specify which AP to use\n"
923 "- Network configuration id\n");
927 return wpa_cli_cmd(ctrl
, "WPS_ER_SET_CONFIG", 2, argc
, argv
);
931 static int wpa_cli_cmd_wps_er_config(struct wpa_ctrl
*ctrl
, int argc
,
937 if (argc
== 5 || argc
== 6) {
938 char ssid_hex
[2 * SSID_MAX_LEN
+ 1];
939 char key_hex
[2 * 64 + 1];
943 for (i
= 0; i
< SSID_MAX_LEN
; i
++) {
944 if (argv
[2][i
] == '\0')
946 os_snprintf(&ssid_hex
[i
* 2], 3, "%02x", argv
[2][i
]);
951 for (i
= 0; i
< 64; i
++) {
952 if (argv
[5][i
] == '\0')
954 os_snprintf(&key_hex
[i
* 2], 3, "%02x",
959 res
= os_snprintf(cmd
, sizeof(cmd
),
960 "WPS_ER_CONFIG %s %s %s %s %s %s",
961 argv
[0], argv
[1], ssid_hex
, argv
[3], argv
[4],
964 printf("Invalid WPS_ER_CONFIG command: need six arguments:\n"
968 "- new auth (OPEN, WPAPSK, WPA2PSK)\n"
969 "- new encr (NONE, WEP, TKIP, CCMP)\n"
974 if (os_snprintf_error(sizeof(cmd
), res
)) {
975 printf("Too long WPS_ER_CONFIG command.\n");
978 return wpa_ctrl_command(ctrl
, cmd
);
982 #ifdef CONFIG_WPS_NFC
983 static int wpa_cli_cmd_wps_er_nfc_config_token(struct wpa_ctrl
*ctrl
, int argc
,
987 printf("Invalid WPS_ER_NFC_CONFIG_TOKEN command: need two "
989 "- WPS/NDEF: token format\n"
990 "- UUID: specify which AP to use\n");
994 return wpa_cli_cmd(ctrl
, "WPS_ER_NFC_CONFIG_TOKEN", 2, argc
, argv
);
996 #endif /* CONFIG_WPS_NFC */
999 static int wpa_cli_cmd_ibss_rsn(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1001 return wpa_cli_cmd(ctrl
, "IBSS_RSN", 1, argc
, argv
);
1005 static int wpa_cli_cmd_level(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1007 return wpa_cli_cmd(ctrl
, "LEVEL", 1, argc
, argv
);
1011 static int wpa_cli_cmd_identity(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1013 char cmd
[256], *pos
, *end
;
1017 printf("Invalid IDENTITY command: needs two arguments "
1018 "(network id and identity)\n");
1022 end
= cmd
+ sizeof(cmd
);
1024 ret
= os_snprintf(pos
, end
- pos
, WPA_CTRL_RSP
"IDENTITY-%s:%s",
1026 if (os_snprintf_error(end
- pos
, ret
)) {
1027 printf("Too long IDENTITY command.\n");
1031 for (i
= 2; i
< argc
; i
++) {
1032 ret
= os_snprintf(pos
, end
- pos
, " %s", argv
[i
]);
1033 if (os_snprintf_error(end
- pos
, ret
)) {
1034 printf("Too long IDENTITY command.\n");
1040 return wpa_ctrl_command(ctrl
, cmd
);
1044 static int wpa_cli_cmd_password(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1046 char cmd
[256], *pos
, *end
;
1050 printf("Invalid PASSWORD command: needs two arguments "
1051 "(network id and password)\n");
1055 end
= cmd
+ sizeof(cmd
);
1057 ret
= os_snprintf(pos
, end
- pos
, WPA_CTRL_RSP
"PASSWORD-%s:%s",
1059 if (os_snprintf_error(end
- pos
, ret
)) {
1060 printf("Too long PASSWORD command.\n");
1064 for (i
= 2; i
< argc
; i
++) {
1065 ret
= os_snprintf(pos
, end
- pos
, " %s", argv
[i
]);
1066 if (os_snprintf_error(end
- pos
, ret
)) {
1067 printf("Too long PASSWORD command.\n");
1073 return wpa_ctrl_command(ctrl
, cmd
);
1077 static int wpa_cli_cmd_new_password(struct wpa_ctrl
*ctrl
, int argc
,
1080 char cmd
[256], *pos
, *end
;
1084 printf("Invalid NEW_PASSWORD command: needs two arguments "
1085 "(network id and password)\n");
1089 end
= cmd
+ sizeof(cmd
);
1091 ret
= os_snprintf(pos
, end
- pos
, WPA_CTRL_RSP
"NEW_PASSWORD-%s:%s",
1093 if (os_snprintf_error(end
- pos
, ret
)) {
1094 printf("Too long NEW_PASSWORD command.\n");
1098 for (i
= 2; i
< argc
; i
++) {
1099 ret
= os_snprintf(pos
, end
- pos
, " %s", argv
[i
]);
1100 if (os_snprintf_error(end
- pos
, ret
)) {
1101 printf("Too long NEW_PASSWORD command.\n");
1107 return wpa_ctrl_command(ctrl
, cmd
);
1111 static int wpa_cli_cmd_pin(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1113 char cmd
[256], *pos
, *end
;
1117 printf("Invalid PIN command: needs two arguments "
1118 "(network id and pin)\n");
1122 end
= cmd
+ sizeof(cmd
);
1124 ret
= os_snprintf(pos
, end
- pos
, WPA_CTRL_RSP
"PIN-%s:%s",
1126 if (os_snprintf_error(end
- pos
, ret
)) {
1127 printf("Too long PIN command.\n");
1131 for (i
= 2; i
< argc
; i
++) {
1132 ret
= os_snprintf(pos
, end
- pos
, " %s", argv
[i
]);
1133 if (os_snprintf_error(end
- pos
, ret
)) {
1134 printf("Too long PIN command.\n");
1139 return wpa_ctrl_command(ctrl
, cmd
);
1143 static int wpa_cli_cmd_otp(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1145 char cmd
[256], *pos
, *end
;
1149 printf("Invalid OTP command: needs two arguments (network "
1150 "id and password)\n");
1154 end
= cmd
+ sizeof(cmd
);
1156 ret
= os_snprintf(pos
, end
- pos
, WPA_CTRL_RSP
"OTP-%s:%s",
1158 if (os_snprintf_error(end
- pos
, ret
)) {
1159 printf("Too long OTP command.\n");
1163 for (i
= 2; i
< argc
; i
++) {
1164 ret
= os_snprintf(pos
, end
- pos
, " %s", argv
[i
]);
1165 if (os_snprintf_error(end
- pos
, ret
)) {
1166 printf("Too long OTP command.\n");
1172 return wpa_ctrl_command(ctrl
, cmd
);
1176 static int wpa_cli_cmd_sim(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1178 char cmd
[256], *pos
, *end
;
1182 printf("Invalid SIM command: needs two arguments "
1183 "(network id and SIM operation response)\n");
1187 end
= cmd
+ sizeof(cmd
);
1189 ret
= os_snprintf(pos
, end
- pos
, WPA_CTRL_RSP
"SIM-%s:%s",
1191 if (os_snprintf_error(end
- pos
, ret
)) {
1192 printf("Too long SIM command.\n");
1196 for (i
= 2; i
< argc
; i
++) {
1197 ret
= os_snprintf(pos
, end
- pos
, " %s", argv
[i
]);
1198 if (os_snprintf_error(end
- pos
, ret
)) {
1199 printf("Too long SIM command.\n");
1204 return wpa_ctrl_command(ctrl
, cmd
);
1208 static int wpa_cli_cmd_psk_passphrase(struct wpa_ctrl
*ctrl
, int argc
,
1211 char cmd
[256], *pos
, *end
;
1215 printf("Invalid PSK_PASSPHRASE command: needs two arguments (network id and PSK/passphrase)\n");
1219 end
= cmd
+ sizeof(cmd
);
1221 ret
= os_snprintf(pos
, end
- pos
, WPA_CTRL_RSP
"PSK_PASSPHRASE-%s:%s",
1223 if (os_snprintf_error(end
- pos
, ret
)) {
1224 printf("Too long PSK_PASSPHRASE command.\n");
1228 for (i
= 2; i
< argc
; i
++) {
1229 ret
= os_snprintf(pos
, end
- pos
, " %s", argv
[i
]);
1230 if (os_snprintf_error(end
- pos
, ret
)) {
1231 printf("Too long PSK_PASSPHRASE command.\n");
1237 return wpa_ctrl_command(ctrl
, cmd
);
1241 static int wpa_cli_cmd_passphrase(struct wpa_ctrl
*ctrl
, int argc
,
1244 char cmd
[256], *pos
, *end
;
1248 printf("Invalid PASSPHRASE command: needs two arguments "
1249 "(network id and passphrase)\n");
1253 end
= cmd
+ sizeof(cmd
);
1255 ret
= os_snprintf(pos
, end
- pos
, WPA_CTRL_RSP
"PASSPHRASE-%s:%s",
1257 if (os_snprintf_error(end
- pos
, ret
)) {
1258 printf("Too long PASSPHRASE command.\n");
1262 for (i
= 2; i
< argc
; i
++) {
1263 ret
= os_snprintf(pos
, end
- pos
, " %s", argv
[i
]);
1264 if (os_snprintf_error(end
- pos
, ret
)) {
1265 printf("Too long PASSPHRASE command.\n");
1271 return wpa_ctrl_command(ctrl
, cmd
);
1275 static int wpa_cli_cmd_bssid(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1278 printf("Invalid BSSID command: needs two arguments (network "
1283 return wpa_cli_cmd(ctrl
, "BSSID", 2, argc
, argv
);
1287 static int wpa_cli_cmd_blacklist(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1289 return wpa_cli_cmd(ctrl
, "BLACKLIST", 0, argc
, argv
);
1293 static int wpa_cli_cmd_log_level(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1295 return wpa_cli_cmd(ctrl
, "LOG_LEVEL", 0, argc
, argv
);
1299 static int wpa_cli_cmd_list_networks(struct wpa_ctrl
*ctrl
, int argc
,
1302 return wpa_ctrl_command(ctrl
, "LIST_NETWORKS");
1306 static int wpa_cli_cmd_select_network(struct wpa_ctrl
*ctrl
, int argc
,
1309 return wpa_cli_cmd(ctrl
, "SELECT_NETWORK", 1, argc
, argv
);
1313 static int wpa_cli_cmd_enable_network(struct wpa_ctrl
*ctrl
, int argc
,
1316 return wpa_cli_cmd(ctrl
, "ENABLE_NETWORK", 1, argc
, argv
);
1320 static int wpa_cli_cmd_disable_network(struct wpa_ctrl
*ctrl
, int argc
,
1323 return wpa_cli_cmd(ctrl
, "DISABLE_NETWORK", 1, argc
, argv
);
1327 static int wpa_cli_cmd_add_network(struct wpa_ctrl
*ctrl
, int argc
,
1330 int res
= wpa_ctrl_command(ctrl
, "ADD_NETWORK");
1332 update_networks(ctrl
);
1337 static int wpa_cli_cmd_remove_network(struct wpa_ctrl
*ctrl
, int argc
,
1340 int res
= wpa_cli_cmd(ctrl
, "REMOVE_NETWORK", 1, argc
, argv
);
1342 update_networks(ctrl
);
1347 static void wpa_cli_show_network_variables(void)
1349 printf("set_network variables:\n"
1350 " ssid (network name, SSID)\n"
1351 " psk (WPA passphrase or pre-shared key)\n"
1352 " key_mgmt (key management protocol)\n"
1353 " identity (EAP identity)\n"
1354 " password (EAP password)\n"
1357 "Note: Values are entered in the same format as the "
1358 "configuration file is using,\n"
1359 "i.e., strings values need to be inside double quotation "
1361 "For example: set_network 1 ssid \"network name\"\n"
1363 "Please see wpa_supplicant.conf documentation for full list "
1364 "of\navailable variables.\n");
1368 static int wpa_cli_cmd_set_network(struct wpa_ctrl
*ctrl
, int argc
,
1372 wpa_cli_show_network_variables();
1377 printf("Invalid SET_NETWORK command: needs three arguments\n"
1378 "(network id, variable name, and value)\n");
1382 return wpa_cli_cmd(ctrl
, "SET_NETWORK", 3, argc
, argv
);
1386 static int wpa_cli_cmd_get_network(struct wpa_ctrl
*ctrl
, int argc
,
1390 wpa_cli_show_network_variables();
1395 printf("Invalid GET_NETWORK command: needs two arguments\n"
1396 "(network id and variable name)\n");
1400 return wpa_cli_cmd(ctrl
, "GET_NETWORK", 2, argc
, argv
);
1404 static const char *network_fields
[] = {
1405 "ssid", "scan_ssid", "bssid", "bssid_blacklist",
1406 "bssid_whitelist", "psk", "proto", "key_mgmt",
1407 "bg_scan_period", "pairwise", "group", "auth_alg", "scan_freq",
1408 "freq_list", "max_oper_chwidth", "ht40", "vht", "vht_center_freq1",
1409 "vht_center_freq2", "ht",
1410 #ifdef IEEE8021X_EAPOL
1411 "eap", "identity", "anonymous_identity", "password", "ca_cert",
1412 "ca_path", "client_cert", "private_key", "private_key_passwd",
1413 "dh_file", "subject_match", "altsubject_match",
1414 "check_cert_subject",
1415 "domain_suffix_match", "domain_match", "ca_cert2", "ca_path2",
1416 "client_cert2", "private_key2", "private_key2_passwd",
1417 "dh_file2", "subject_match2", "altsubject_match2",
1418 "check_cert_subject2",
1419 "domain_suffix_match2", "domain_match2", "phase1", "phase2",
1420 "pcsc", "pin", "engine_id", "key_id", "cert_id", "ca_cert_id",
1421 "pin2", "engine2_id", "key2_id", "cert2_id", "ca_cert2_id",
1422 "engine", "engine2", "eapol_flags", "sim_num",
1423 "openssl_ciphers", "erp",
1424 #endif /* IEEE8021X_EAPOL */
1425 "wep_key0", "wep_key1", "wep_key2", "wep_key3",
1426 "wep_tx_keyidx", "priority",
1427 #ifdef IEEE8021X_EAPOL
1428 "eap_workaround", "pac_file", "fragment_size", "ocsp",
1429 #endif /* IEEE8021X_EAPOL */
1431 "mode", "no_auto_peer", "mesh_rssi_threshold",
1432 #else /* CONFIG_MESH */
1434 #endif /* CONFIG_MESH */
1435 "proactive_key_caching", "disabled", "id_str",
1437 "mixed_cell", "frequency", "fixed_freq",
1439 "mesh_basic_rates", "dot11MeshMaxRetries",
1440 "dot11MeshRetryTimeout", "dot11MeshConfirmTimeout",
1441 "dot11MeshHoldingTimeout",
1442 #endif /* CONFIG_MESH */
1443 "wpa_ptk_rekey", "bgscan", "ignore_broadcast_ssid",
1445 "go_p2p_dev_addr", "p2p_client_list", "psk_list",
1446 #endif /* CONFIG_P2P */
1447 #ifdef CONFIG_HT_OVERRIDES
1448 "disable_ht", "disable_ht40", "disable_sgi", "disable_ldpc",
1449 "ht40_intolerant", "disable_max_amsdu", "ampdu_factor",
1450 "ampdu_density", "ht_mcs", "rx_stbc", "tx_stbc",
1451 #endif /* CONFIG_HT_OVERRIDES */
1452 #ifdef CONFIG_VHT_OVERRIDES
1453 "disable_vht", "vht_capa", "vht_capa_mask", "vht_rx_mcs_nss_1",
1454 "vht_rx_mcs_nss_2", "vht_rx_mcs_nss_3", "vht_rx_mcs_nss_4",
1455 "vht_rx_mcs_nss_5", "vht_rx_mcs_nss_6", "vht_rx_mcs_nss_7",
1456 "vht_rx_mcs_nss_8", "vht_tx_mcs_nss_1", "vht_tx_mcs_nss_2",
1457 "vht_tx_mcs_nss_3", "vht_tx_mcs_nss_4", "vht_tx_mcs_nss_5",
1458 "vht_tx_mcs_nss_6", "vht_tx_mcs_nss_7", "vht_tx_mcs_nss_8",
1459 #endif /* CONFIG_VHT_OVERRIDES */
1460 "ap_max_inactivity", "dtim_period", "beacon_int",
1461 #ifdef CONFIG_MACSEC
1463 "macsec_integ_only",
1464 "macsec_replay_protect",
1465 "macsec_replay_window",
1468 #endif /* CONFIG_MACSEC */
1470 "update_identifier",
1471 #endif /* CONFIG_HS20 */
1472 "mac_addr", "pbss", "wps_disabled"
1476 static char ** wpa_cli_complete_network(const char *str
, int pos
)
1478 int arg
= get_cmd_arg_num(str
, pos
);
1479 int i
, num_fields
= ARRAY_SIZE(network_fields
);
1484 res
= cli_txt_list_array(&networks
);
1487 res
= os_calloc(num_fields
+ 1, sizeof(char *));
1490 for (i
= 0; i
< num_fields
; i
++) {
1491 res
[i
] = os_strdup(network_fields
[i
]);
1500 static char ** wpa_cli_complete_network_id(const char *str
, int pos
)
1502 int arg
= get_cmd_arg_num(str
, pos
);
1504 return cli_txt_list_array(&networks
);
1509 static int wpa_cli_cmd_dup_network(struct wpa_ctrl
*ctrl
, int argc
,
1513 wpa_cli_show_network_variables();
1518 printf("Invalid DUP_NETWORK command: needs three arguments\n"
1519 "(src netid, dest netid, and variable name)\n");
1523 return wpa_cli_cmd(ctrl
, "DUP_NETWORK", 3, argc
, argv
);
1527 static char ** wpa_cli_complete_dup_network(const char *str
, int pos
)
1529 int arg
= get_cmd_arg_num(str
, pos
);
1530 int i
, num_fields
= ARRAY_SIZE(network_fields
);
1536 res
= cli_txt_list_array(&networks
);
1539 res
= os_calloc(num_fields
+ 1, sizeof(char *));
1542 for (i
= 0; i
< num_fields
; i
++) {
1543 res
[i
] = os_strdup(network_fields
[i
]);
1552 static int wpa_cli_cmd_list_creds(struct wpa_ctrl
*ctrl
, int argc
,
1555 return wpa_ctrl_command(ctrl
, "LIST_CREDS");
1559 static int wpa_cli_cmd_add_cred(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1561 int res
= wpa_ctrl_command(ctrl
, "ADD_CRED");
1568 static int wpa_cli_cmd_remove_cred(struct wpa_ctrl
*ctrl
, int argc
,
1571 int res
= wpa_cli_cmd(ctrl
, "REMOVE_CRED", 1, argc
, argv
);
1578 static const char * const cred_fields
[] = {
1579 "temporary", "priority", "sp_priority", "pcsc", "eap",
1580 "update_identifier", "min_dl_bandwidth_home", "min_ul_bandwidth_home",
1581 "min_dl_bandwidth_roaming", "min_ul_bandwidth_roaming", "max_bss_load",
1582 "req_conn_capab", "ocsp", "sim_num", "realm", "username", "password",
1583 "ca_cert", "client_cert", "private_key", "private_key_passwd", "imsi",
1584 "milenage", "domain_suffix_match", "domain", "phase1", "phase2",
1585 "roaming_consortium", "required_roaming_consortium", "excluded_ssid",
1586 "roaming_partner", "provisioning_sp"
1590 static char ** wpa_cli_complete_cred(const char *str
, int pos
)
1592 int arg
= get_cmd_arg_num(str
, pos
);
1593 int i
, num_fields
= ARRAY_SIZE(cred_fields
);
1598 res
= cli_txt_list_array(&creds
);
1601 res
= os_calloc(num_fields
+ 1, sizeof(char *));
1604 for (i
= 0; i
< num_fields
; i
++) {
1605 res
[i
] = os_strdup(cred_fields
[i
]);
1614 static int wpa_cli_cmd_set_cred(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1617 printf("Invalid SET_CRED command: needs three arguments\n"
1618 "(cred id, variable name, and value)\n");
1622 return wpa_cli_cmd(ctrl
, "SET_CRED", 3, argc
, argv
);
1626 static int wpa_cli_cmd_get_cred(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1629 printf("Invalid GET_CRED command: needs two arguments\n"
1630 "(cred id, variable name)\n");
1634 return wpa_cli_cmd(ctrl
, "GET_CRED", 2, argc
, argv
);
1638 static int wpa_cli_cmd_disconnect(struct wpa_ctrl
*ctrl
, int argc
,
1641 return wpa_ctrl_command(ctrl
, "DISCONNECT");
1645 static int wpa_cli_cmd_reconnect(struct wpa_ctrl
*ctrl
, int argc
,
1648 return wpa_ctrl_command(ctrl
, "RECONNECT");
1652 static int wpa_cli_cmd_save_config(struct wpa_ctrl
*ctrl
, int argc
,
1655 return wpa_ctrl_command(ctrl
, "SAVE_CONFIG");
1659 static int wpa_cli_cmd_scan(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1661 return wpa_cli_cmd(ctrl
, "SCAN", 0, argc
, argv
);
1665 static int wpa_cli_cmd_scan_results(struct wpa_ctrl
*ctrl
, int argc
,
1668 return wpa_ctrl_command(ctrl
, "SCAN_RESULTS");
1672 static int wpa_cli_cmd_abort_scan(struct wpa_ctrl
*ctrl
, int argc
,
1675 return wpa_ctrl_command(ctrl
, "ABORT_SCAN");
1679 static int wpa_cli_cmd_bss(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1681 return wpa_cli_cmd(ctrl
, "BSS", 1, argc
, argv
);
1685 static char ** wpa_cli_complete_bss(const char *str
, int pos
)
1687 int arg
= get_cmd_arg_num(str
, pos
);
1692 res
= cli_txt_list_array(&bsses
);
1700 static int wpa_cli_cmd_get_capability(struct wpa_ctrl
*ctrl
, int argc
,
1703 if (argc
< 1 || argc
> 2) {
1704 printf("Invalid GET_CAPABILITY command: need either one or "
1709 if ((argc
== 2) && os_strcmp(argv
[1], "strict") != 0) {
1710 printf("Invalid GET_CAPABILITY command: second argument, "
1711 "if any, must be 'strict'\n");
1715 return wpa_cli_cmd(ctrl
, "GET_CAPABILITY", 1, argc
, argv
);
1719 static char ** wpa_cli_complete_get_capability(const char *str
, int pos
)
1721 int arg
= get_cmd_arg_num(str
, pos
);
1722 const char *fields
[] = {
1723 "eap", "pairwise", "group", "group_mgmt", "key_mgmt",
1724 "proto", "auth_alg", "modes", "channels", "freq",
1727 #endif /* CONFIG_TDLS */
1730 #endif /* CONFIG_ERP */
1733 #endif /* CONFIG_FIPS */
1736 #endif /* CONFIG_ACS */
1738 int i
, num_fields
= ARRAY_SIZE(fields
);
1742 res
= os_calloc(num_fields
+ 1, sizeof(char *));
1745 for (i
= 0; i
< num_fields
; i
++) {
1746 res
[i
] = os_strdup(fields
[i
]);
1752 res
= os_calloc(1 + 1, sizeof(char *));
1755 res
[0] = os_strdup("strict");
1761 static int wpa_cli_list_interfaces(struct wpa_ctrl
*ctrl
)
1763 printf("Available interfaces:\n");
1764 return wpa_ctrl_command(ctrl
, "INTERFACES");
1768 static int wpa_cli_cmd_interface(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1771 wpa_cli_list_interfaces(ctrl
);
1775 wpa_cli_close_connection();
1776 os_free(ctrl_ifname
);
1777 ctrl_ifname
= os_strdup(argv
[0]);
1779 printf("Failed to allocate memory\n");
1783 if (wpa_cli_open_connection(ctrl_ifname
, 1) == 0) {
1784 printf("Connected to interface '%s.\n", ctrl_ifname
);
1786 printf("Could not connect to interface '%s' - re-trying\n",
1793 static int wpa_cli_cmd_reconfigure(struct wpa_ctrl
*ctrl
, int argc
,
1796 return wpa_ctrl_command(ctrl
, "RECONFIGURE");
1800 static int wpa_cli_cmd_terminate(struct wpa_ctrl
*ctrl
, int argc
,
1803 return wpa_ctrl_command(ctrl
, "TERMINATE");
1807 static int wpa_cli_cmd_interface_add(struct wpa_ctrl
*ctrl
, int argc
,
1814 printf("Invalid INTERFACE_ADD command: needs at least one "
1815 "argument (interface name)\n"
1816 "All arguments: ifname confname driver ctrl_interface "
1817 "driver_param bridge_name [create]\n");
1822 * INTERFACE_ADD <ifname>TAB<confname>TAB<driver>TAB<ctrl_interface>TAB
1823 * <driver_param>TAB<bridge_name>[TAB<create>[TAB<type>]]
1825 res
= os_snprintf(cmd
, sizeof(cmd
),
1826 "INTERFACE_ADD %s\t%s\t%s\t%s\t%s\t%s\t%s\t%s",
1828 argc
> 1 ? argv
[1] : "", argc
> 2 ? argv
[2] : "",
1829 argc
> 3 ? argv
[3] : "", argc
> 4 ? argv
[4] : "",
1830 argc
> 5 ? argv
[5] : "", argc
> 6 ? argv
[6] : "",
1831 argc
> 7 ? argv
[7] : "");
1832 if (os_snprintf_error(sizeof(cmd
), res
))
1834 cmd
[sizeof(cmd
) - 1] = '\0';
1835 return wpa_ctrl_command(ctrl
, cmd
);
1839 static int wpa_cli_cmd_interface_remove(struct wpa_ctrl
*ctrl
, int argc
,
1842 return wpa_cli_cmd(ctrl
, "INTERFACE_REMOVE", 1, argc
, argv
);
1846 static int wpa_cli_cmd_interface_list(struct wpa_ctrl
*ctrl
, int argc
,
1849 return wpa_ctrl_command(ctrl
, "INTERFACE_LIST");
1854 static int wpa_cli_cmd_sta(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1856 return wpa_cli_cmd(ctrl
, "STA", 1, argc
, argv
);
1860 static char ** wpa_cli_complete_sta(const char *str
, int pos
)
1862 int arg
= get_cmd_arg_num(str
, pos
);
1867 res
= cli_txt_list_array(&stations
);
1875 static int wpa_ctrl_command_sta(struct wpa_ctrl
*ctrl
, const char *cmd
,
1876 char *addr
, size_t addr_len
, int print
)
1878 char buf
[4096], *pos
;
1882 if (ctrl_conn
== NULL
) {
1883 printf("Not connected to hostapd - command dropped.\n");
1886 if (ifname_prefix
) {
1887 os_snprintf(buf
, sizeof(buf
), "IFNAME=%s %s",
1888 ifname_prefix
, cmd
);
1889 buf
[sizeof(buf
) - 1] = '\0';
1892 len
= sizeof(buf
) - 1;
1893 ret
= wpa_ctrl_request(ctrl
, cmd
, os_strlen(cmd
), buf
, &len
,
1896 printf("'%s' command timed out.\n", cmd
);
1898 } else if (ret
< 0) {
1899 printf("'%s' command failed.\n", cmd
);
1904 if (os_memcmp(buf
, "FAIL", 4) == 0 ||
1905 os_memcmp(buf
, "UNKNOWN COMMAND", 15) == 0)
1911 while (*pos
!= '\0' && *pos
!= '\n')
1914 os_strlcpy(addr
, buf
, addr_len
);
1919 static int wpa_cli_cmd_all_sta(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1921 char addr
[32], cmd
[64];
1923 if (wpa_ctrl_command_sta(ctrl
, "STA-FIRST", addr
, sizeof(addr
), 1))
1926 os_snprintf(cmd
, sizeof(cmd
), "STA-NEXT %s", addr
);
1927 } while (wpa_ctrl_command_sta(ctrl
, cmd
, addr
, sizeof(addr
), 1) == 0);
1933 static int wpa_cli_cmd_list_sta(struct wpa_ctrl
*ctrl
, int argc
,
1936 char addr
[32], cmd
[64];
1938 if (wpa_ctrl_command_sta(ctrl
, "STA-FIRST", addr
, sizeof(addr
), 0))
1941 if (os_strcmp(addr
, "") != 0)
1942 printf("%s\n", addr
);
1943 os_snprintf(cmd
, sizeof(cmd
), "STA-NEXT %s", addr
);
1944 } while (wpa_ctrl_command_sta(ctrl
, cmd
, addr
, sizeof(addr
), 0) == 0);
1950 static int wpa_cli_cmd_deauthenticate(struct wpa_ctrl
*ctrl
, int argc
,
1953 return wpa_cli_cmd(ctrl
, "DEAUTHENTICATE", 1, argc
, argv
);
1957 static char ** wpa_cli_complete_deauthenticate(const char *str
, int pos
)
1959 int arg
= get_cmd_arg_num(str
, pos
);
1964 res
= cli_txt_list_array(&stations
);
1972 static int wpa_cli_cmd_disassociate(struct wpa_ctrl
*ctrl
, int argc
,
1975 return wpa_cli_cmd(ctrl
, "DISASSOCIATE", 1, argc
, argv
);
1979 static char ** wpa_cli_complete_disassociate(const char *str
, int pos
)
1981 int arg
= get_cmd_arg_num(str
, pos
);
1986 res
= cli_txt_list_array(&stations
);
1994 static int wpa_cli_cmd_chanswitch(struct wpa_ctrl
*ctrl
, int argc
,
1997 return wpa_cli_cmd(ctrl
, "CHAN_SWITCH", 2, argc
, argv
);
2000 #endif /* CONFIG_AP */
2003 static int wpa_cli_cmd_suspend(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2005 return wpa_ctrl_command(ctrl
, "SUSPEND");
2009 static int wpa_cli_cmd_resume(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2011 return wpa_ctrl_command(ctrl
, "RESUME");
2015 #ifdef CONFIG_TESTING_OPTIONS
2016 static int wpa_cli_cmd_drop_sa(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2018 return wpa_ctrl_command(ctrl
, "DROP_SA");
2020 #endif /* CONFIG_TESTING_OPTIONS */
2023 static int wpa_cli_cmd_roam(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2025 return wpa_cli_cmd(ctrl
, "ROAM", 1, argc
, argv
);
2031 static int wpa_cli_cmd_mesh_interface_add(struct wpa_ctrl
*ctrl
, int argc
,
2034 return wpa_cli_cmd(ctrl
, "MESH_INTERFACE_ADD", 0, argc
, argv
);
2038 static int wpa_cli_cmd_mesh_group_add(struct wpa_ctrl
*ctrl
, int argc
,
2041 return wpa_cli_cmd(ctrl
, "MESH_GROUP_ADD", 1, argc
, argv
);
2045 static int wpa_cli_cmd_mesh_group_remove(struct wpa_ctrl
*ctrl
, int argc
,
2048 return wpa_cli_cmd(ctrl
, "MESH_GROUP_REMOVE", 1, argc
, argv
);
2052 static int wpa_cli_cmd_mesh_peer_remove(struct wpa_ctrl
*ctrl
, int argc
,
2055 return wpa_cli_cmd(ctrl
, "MESH_PEER_REMOVE", 1, argc
, argv
);
2059 static int wpa_cli_cmd_mesh_peer_add(struct wpa_ctrl
*ctrl
, int argc
,
2062 return wpa_cli_cmd(ctrl
, "MESH_PEER_ADD", 1, argc
, argv
);
2066 static int wpa_cli_cmd_mesh_link_probe(struct wpa_ctrl
*ctrl
, int argc
,
2069 return wpa_cli_cmd(ctrl
, "MESH_LINK_PROBE", 1, argc
, argv
);
2072 #endif /* CONFIG_MESH */
2077 static int wpa_cli_cmd_p2p_find(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2079 return wpa_cli_cmd(ctrl
, "P2P_FIND", 0, argc
, argv
);
2083 static char ** wpa_cli_complete_p2p_find(const char *str
, int pos
)
2086 int arg
= get_cmd_arg_num(str
, pos
);
2088 res
= os_calloc(6, sizeof(char *));
2091 res
[0] = os_strdup("type=social");
2092 if (res
[0] == NULL
) {
2096 res
[1] = os_strdup("type=progressive");
2099 res
[2] = os_strdup("delay=");
2102 res
[3] = os_strdup("dev_id=");
2106 res
[4] = os_strdup("[timeout]");
2112 static int wpa_cli_cmd_p2p_stop_find(struct wpa_ctrl
*ctrl
, int argc
,
2115 return wpa_ctrl_command(ctrl
, "P2P_STOP_FIND");
2119 static int wpa_cli_cmd_p2p_asp_provision(struct wpa_ctrl
*ctrl
, int argc
,
2122 return wpa_cli_cmd(ctrl
, "P2P_ASP_PROVISION", 3, argc
, argv
);
2126 static int wpa_cli_cmd_p2p_asp_provision_resp(struct wpa_ctrl
*ctrl
, int argc
,
2129 return wpa_cli_cmd(ctrl
, "P2P_ASP_PROVISION_RESP", 2, argc
, argv
);
2133 static int wpa_cli_cmd_p2p_connect(struct wpa_ctrl
*ctrl
, int argc
,
2136 return wpa_cli_cmd(ctrl
, "P2P_CONNECT", 2, argc
, argv
);
2140 static char ** wpa_cli_complete_p2p_connect(const char *str
, int pos
)
2142 int arg
= get_cmd_arg_num(str
, pos
);
2147 res
= cli_txt_list_array(&p2p_peers
);
2155 static int wpa_cli_cmd_p2p_listen(struct wpa_ctrl
*ctrl
, int argc
,
2158 return wpa_cli_cmd(ctrl
, "P2P_LISTEN", 0, argc
, argv
);
2162 static int wpa_cli_cmd_p2p_group_remove(struct wpa_ctrl
*ctrl
, int argc
,
2165 return wpa_cli_cmd(ctrl
, "P2P_GROUP_REMOVE", 1, argc
, argv
);
2169 static char ** wpa_cli_complete_p2p_group_remove(const char *str
, int pos
)
2171 int arg
= get_cmd_arg_num(str
, pos
);
2176 res
= cli_txt_list_array(&p2p_groups
);
2184 static int wpa_cli_cmd_p2p_group_add(struct wpa_ctrl
*ctrl
, int argc
,
2187 return wpa_cli_cmd(ctrl
, "P2P_GROUP_ADD", 0, argc
, argv
);
2191 static int wpa_cli_cmd_p2p_group_member(struct wpa_ctrl
*ctrl
, int argc
,
2194 return wpa_cli_cmd(ctrl
, "P2P_GROUP_MEMBER", 1, argc
, argv
);
2198 static int wpa_cli_cmd_p2p_prov_disc(struct wpa_ctrl
*ctrl
, int argc
,
2201 if (argc
!= 2 && argc
!= 3) {
2202 printf("Invalid P2P_PROV_DISC command: needs at least "
2203 "two arguments, address and config method\n"
2204 "(display, keypad, or pbc) and an optional join\n");
2208 return wpa_cli_cmd(ctrl
, "P2P_PROV_DISC", 2, argc
, argv
);
2212 static int wpa_cli_cmd_p2p_get_passphrase(struct wpa_ctrl
*ctrl
, int argc
,
2215 return wpa_ctrl_command(ctrl
, "P2P_GET_PASSPHRASE");
2219 static int wpa_cli_cmd_p2p_serv_disc_req(struct wpa_ctrl
*ctrl
, int argc
,
2225 printf("Invalid P2P_SERV_DISC_REQ command: needs two "
2226 "or more arguments (address and TLVs)\n");
2230 if (write_cmd(cmd
, sizeof(cmd
), "P2P_SERV_DISC_REQ", argc
, argv
) < 0)
2232 return wpa_ctrl_command(ctrl
, cmd
);
2236 static int wpa_cli_cmd_p2p_serv_disc_cancel_req(struct wpa_ctrl
*ctrl
,
2237 int argc
, char *argv
[])
2239 return wpa_cli_cmd(ctrl
, "P2P_SERV_DISC_CANCEL_REQ", 1, argc
, argv
);
2243 static int wpa_cli_cmd_p2p_serv_disc_resp(struct wpa_ctrl
*ctrl
, int argc
,
2250 printf("Invalid P2P_SERV_DISC_RESP command: needs four "
2251 "arguments (freq, address, dialog token, and TLVs)\n");
2255 res
= os_snprintf(cmd
, sizeof(cmd
), "P2P_SERV_DISC_RESP %s %s %s %s",
2256 argv
[0], argv
[1], argv
[2], argv
[3]);
2257 if (os_snprintf_error(sizeof(cmd
), res
))
2259 cmd
[sizeof(cmd
) - 1] = '\0';
2260 return wpa_ctrl_command(ctrl
, cmd
);
2264 static int wpa_cli_cmd_p2p_service_update(struct wpa_ctrl
*ctrl
, int argc
,
2267 return wpa_ctrl_command(ctrl
, "P2P_SERVICE_UPDATE");
2271 static int wpa_cli_cmd_p2p_serv_disc_external(struct wpa_ctrl
*ctrl
,
2272 int argc
, char *argv
[])
2274 return wpa_cli_cmd(ctrl
, "P2P_SERV_DISC_EXTERNAL", 1, argc
, argv
);
2278 static int wpa_cli_cmd_p2p_service_flush(struct wpa_ctrl
*ctrl
, int argc
,
2281 return wpa_ctrl_command(ctrl
, "P2P_SERVICE_FLUSH");
2285 static int wpa_cli_cmd_p2p_service_add(struct wpa_ctrl
*ctrl
, int argc
,
2289 printf("Invalid P2P_SERVICE_ADD command: needs 3-6 arguments\n");
2293 return wpa_cli_cmd(ctrl
, "P2P_SERVICE_ADD", 3, argc
, argv
);
2297 static int wpa_cli_cmd_p2p_service_rep(struct wpa_ctrl
*ctrl
, int argc
,
2300 if (argc
< 5 || argc
> 6) {
2301 printf("Invalid P2P_SERVICE_REP command: needs 5-6 "
2306 return wpa_cli_cmd(ctrl
, "P2P_SERVICE_REP", 5, argc
, argv
);
2310 static int wpa_cli_cmd_p2p_service_del(struct wpa_ctrl
*ctrl
, int argc
,
2316 if (argc
!= 2 && argc
!= 3) {
2317 printf("Invalid P2P_SERVICE_DEL command: needs two or three "
2323 res
= os_snprintf(cmd
, sizeof(cmd
),
2324 "P2P_SERVICE_DEL %s %s %s",
2325 argv
[0], argv
[1], argv
[2]);
2327 res
= os_snprintf(cmd
, sizeof(cmd
),
2328 "P2P_SERVICE_DEL %s %s",
2330 if (os_snprintf_error(sizeof(cmd
), res
))
2332 cmd
[sizeof(cmd
) - 1] = '\0';
2333 return wpa_ctrl_command(ctrl
, cmd
);
2337 static int wpa_cli_cmd_p2p_reject(struct wpa_ctrl
*ctrl
,
2338 int argc
, char *argv
[])
2340 return wpa_cli_cmd(ctrl
, "P2P_REJECT", 1, argc
, argv
);
2344 static int wpa_cli_cmd_p2p_invite(struct wpa_ctrl
*ctrl
,
2345 int argc
, char *argv
[])
2347 return wpa_cli_cmd(ctrl
, "P2P_INVITE", 1, argc
, argv
);
2351 static int wpa_cli_cmd_p2p_peer(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2353 return wpa_cli_cmd(ctrl
, "P2P_PEER", 1, argc
, argv
);
2357 static char ** wpa_cli_complete_p2p_peer(const char *str
, int pos
)
2359 int arg
= get_cmd_arg_num(str
, pos
);
2364 res
= cli_txt_list_array(&p2p_peers
);
2372 static int wpa_ctrl_command_p2p_peer(struct wpa_ctrl
*ctrl
, const char *cmd
,
2373 char *addr
, size_t addr_len
,
2376 char buf
[4096], *pos
;
2380 if (ctrl_conn
== NULL
)
2382 len
= sizeof(buf
) - 1;
2383 ret
= wpa_ctrl_request(ctrl
, cmd
, os_strlen(cmd
), buf
, &len
,
2386 printf("'%s' command timed out.\n", cmd
);
2388 } else if (ret
< 0) {
2389 printf("'%s' command failed.\n", cmd
);
2394 if (os_memcmp(buf
, "FAIL", 4) == 0)
2398 while (*pos
!= '\0' && *pos
!= '\n')
2401 os_strlcpy(addr
, buf
, addr_len
);
2402 if (!discovered
|| os_strstr(pos
, "[PROBE_REQ_ONLY]") == NULL
)
2403 printf("%s\n", addr
);
2408 static int wpa_cli_cmd_p2p_peers(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2410 char addr
[32], cmd
[64];
2413 discovered
= argc
> 0 && os_strcmp(argv
[0], "discovered") == 0;
2415 if (wpa_ctrl_command_p2p_peer(ctrl
, "P2P_PEER FIRST",
2416 addr
, sizeof(addr
), discovered
))
2419 os_snprintf(cmd
, sizeof(cmd
), "P2P_PEER NEXT-%s", addr
);
2420 } while (wpa_ctrl_command_p2p_peer(ctrl
, cmd
, addr
, sizeof(addr
),
2427 static int wpa_cli_cmd_p2p_set(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2429 return wpa_cli_cmd(ctrl
, "P2P_SET", 2, argc
, argv
);
2433 static char ** wpa_cli_complete_p2p_set(const char *str
, int pos
)
2435 int arg
= get_cmd_arg_num(str
, pos
);
2436 const char *fields
[] = {
2456 int i
, num_fields
= ARRAY_SIZE(fields
);
2459 char **res
= os_calloc(num_fields
+ 1, sizeof(char *));
2462 for (i
= 0; i
< num_fields
; i
++) {
2463 res
[i
] = os_strdup(fields
[i
]);
2470 if (arg
== 2 && os_strncasecmp(str
, "p2p_set peer_filter ", 20) == 0)
2471 return cli_txt_list_array(&p2p_peers
);
2477 static int wpa_cli_cmd_p2p_flush(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2479 return wpa_ctrl_command(ctrl
, "P2P_FLUSH");
2483 static int wpa_cli_cmd_p2p_cancel(struct wpa_ctrl
*ctrl
, int argc
,
2486 return wpa_ctrl_command(ctrl
, "P2P_CANCEL");
2490 static int wpa_cli_cmd_p2p_unauthorize(struct wpa_ctrl
*ctrl
, int argc
,
2493 return wpa_cli_cmd(ctrl
, "P2P_UNAUTHORIZE", 1, argc
, argv
);
2497 static int wpa_cli_cmd_p2p_presence_req(struct wpa_ctrl
*ctrl
, int argc
,
2500 if (argc
!= 0 && argc
!= 2 && argc
!= 4) {
2501 printf("Invalid P2P_PRESENCE_REQ command: needs two arguments "
2502 "(preferred duration, interval; in microsecods).\n"
2503 "Optional second pair can be used to provide "
2504 "acceptable values.\n");
2508 return wpa_cli_cmd(ctrl
, "P2P_PRESENCE_REQ", 0, argc
, argv
);
2512 static int wpa_cli_cmd_p2p_ext_listen(struct wpa_ctrl
*ctrl
, int argc
,
2515 if (argc
!= 0 && argc
!= 2) {
2516 printf("Invalid P2P_EXT_LISTEN command: needs two arguments "
2517 "(availability period, availability interval; in "
2519 "Extended Listen Timing can be cancelled with this "
2520 "command when used without parameters.\n");
2524 return wpa_cli_cmd(ctrl
, "P2P_EXT_LISTEN", 0, argc
, argv
);
2528 static int wpa_cli_cmd_p2p_remove_client(struct wpa_ctrl
*ctrl
, int argc
,
2531 return wpa_cli_cmd(ctrl
, "P2P_REMOVE_CLIENT", 1, argc
, argv
);
2534 #endif /* CONFIG_P2P */
2537 static int wpa_cli_cmd_vendor_elem_add(struct wpa_ctrl
*ctrl
, int argc
,
2540 return wpa_cli_cmd(ctrl
, "VENDOR_ELEM_ADD", 2, argc
, argv
);
2544 static int wpa_cli_cmd_vendor_elem_get(struct wpa_ctrl
*ctrl
, int argc
,
2547 return wpa_cli_cmd(ctrl
, "VENDOR_ELEM_GET", 1, argc
, argv
);
2551 static int wpa_cli_cmd_vendor_elem_remove(struct wpa_ctrl
*ctrl
, int argc
,
2554 return wpa_cli_cmd(ctrl
, "VENDOR_ELEM_REMOVE", 2, argc
, argv
);
2558 #ifdef CONFIG_WIFI_DISPLAY
2560 static int wpa_cli_cmd_wfd_subelem_set(struct wpa_ctrl
*ctrl
, int argc
,
2566 if (argc
!= 1 && argc
!= 2) {
2567 printf("Invalid WFD_SUBELEM_SET command: needs one or two "
2568 "arguments (subelem, hexdump)\n");
2572 res
= os_snprintf(cmd
, sizeof(cmd
), "WFD_SUBELEM_SET %s %s",
2573 argv
[0], argc
> 1 ? argv
[1] : "");
2574 if (os_snprintf_error(sizeof(cmd
), res
))
2576 cmd
[sizeof(cmd
) - 1] = '\0';
2577 return wpa_ctrl_command(ctrl
, cmd
);
2581 static int wpa_cli_cmd_wfd_subelem_get(struct wpa_ctrl
*ctrl
, int argc
,
2588 printf("Invalid WFD_SUBELEM_GET command: needs one "
2589 "argument (subelem)\n");
2593 res
= os_snprintf(cmd
, sizeof(cmd
), "WFD_SUBELEM_GET %s",
2595 if (os_snprintf_error(sizeof(cmd
), res
))
2597 cmd
[sizeof(cmd
) - 1] = '\0';
2598 return wpa_ctrl_command(ctrl
, cmd
);
2600 #endif /* CONFIG_WIFI_DISPLAY */
2603 #ifdef CONFIG_INTERWORKING
2604 static int wpa_cli_cmd_fetch_anqp(struct wpa_ctrl
*ctrl
, int argc
,
2607 return wpa_ctrl_command(ctrl
, "FETCH_ANQP");
2611 static int wpa_cli_cmd_stop_fetch_anqp(struct wpa_ctrl
*ctrl
, int argc
,
2614 return wpa_ctrl_command(ctrl
, "STOP_FETCH_ANQP");
2618 static int wpa_cli_cmd_interworking_select(struct wpa_ctrl
*ctrl
, int argc
,
2621 return wpa_cli_cmd(ctrl
, "INTERWORKING_SELECT", 0, argc
, argv
);
2625 static int wpa_cli_cmd_interworking_connect(struct wpa_ctrl
*ctrl
, int argc
,
2628 return wpa_cli_cmd(ctrl
, "INTERWORKING_CONNECT", 1, argc
, argv
);
2632 static int wpa_cli_cmd_interworking_add_network(struct wpa_ctrl
*ctrl
, int argc
,
2635 return wpa_cli_cmd(ctrl
, "INTERWORKING_ADD_NETWORK", 1, argc
, argv
);
2639 static int wpa_cli_cmd_anqp_get(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2641 return wpa_cli_cmd(ctrl
, "ANQP_GET", 2, argc
, argv
);
2645 static int wpa_cli_cmd_gas_request(struct wpa_ctrl
*ctrl
, int argc
,
2648 return wpa_cli_cmd(ctrl
, "GAS_REQUEST", 2, argc
, argv
);
2652 static int wpa_cli_cmd_gas_response_get(struct wpa_ctrl
*ctrl
, int argc
,
2655 return wpa_cli_cmd(ctrl
, "GAS_RESPONSE_GET", 2, argc
, argv
);
2657 #endif /* CONFIG_INTERWORKING */
2662 static int wpa_cli_cmd_hs20_anqp_get(struct wpa_ctrl
*ctrl
, int argc
,
2665 return wpa_cli_cmd(ctrl
, "HS20_ANQP_GET", 2, argc
, argv
);
2669 static int wpa_cli_cmd_get_nai_home_realm_list(struct wpa_ctrl
*ctrl
, int argc
,
2675 printf("Command needs one or two arguments (dst mac addr and "
2676 "optional home realm)\n");
2680 if (write_cmd(cmd
, sizeof(cmd
), "HS20_GET_NAI_HOME_REALM_LIST",
2684 return wpa_ctrl_command(ctrl
, cmd
);
2688 static int wpa_cli_cmd_hs20_icon_request(struct wpa_ctrl
*ctrl
, int argc
,
2694 printf("Command needs two arguments (dst mac addr and "
2699 if (write_cmd(cmd
, sizeof(cmd
), "HS20_ICON_REQUEST", argc
, argv
) < 0)
2702 return wpa_ctrl_command(ctrl
, cmd
);
2706 static int wpa_cli_cmd_fetch_osu(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2708 return wpa_ctrl_command(ctrl
, "FETCH_OSU");
2712 static int wpa_cli_cmd_cancel_fetch_osu(struct wpa_ctrl
*ctrl
, int argc
,
2715 return wpa_ctrl_command(ctrl
, "CANCEL_FETCH_OSU");
2718 #endif /* CONFIG_HS20 */
2721 static int wpa_cli_cmd_sta_autoconnect(struct wpa_ctrl
*ctrl
, int argc
,
2724 return wpa_cli_cmd(ctrl
, "STA_AUTOCONNECT", 1, argc
, argv
);
2728 static int wpa_cli_cmd_tdls_discover(struct wpa_ctrl
*ctrl
, int argc
,
2731 return wpa_cli_cmd(ctrl
, "TDLS_DISCOVER", 1, argc
, argv
);
2735 static int wpa_cli_cmd_tdls_setup(struct wpa_ctrl
*ctrl
, int argc
,
2738 return wpa_cli_cmd(ctrl
, "TDLS_SETUP", 1, argc
, argv
);
2742 static int wpa_cli_cmd_tdls_teardown(struct wpa_ctrl
*ctrl
, int argc
,
2745 return wpa_cli_cmd(ctrl
, "TDLS_TEARDOWN", 1, argc
, argv
);
2749 static int wpa_cli_cmd_tdls_link_status(struct wpa_ctrl
*ctrl
, int argc
,
2752 return wpa_cli_cmd(ctrl
, "TDLS_LINK_STATUS", 1, argc
, argv
);
2756 static int wpa_cli_cmd_wmm_ac_addts(struct wpa_ctrl
*ctrl
, int argc
,
2759 return wpa_cli_cmd(ctrl
, "WMM_AC_ADDTS", 3, argc
, argv
);
2763 static int wpa_cli_cmd_wmm_ac_delts(struct wpa_ctrl
*ctrl
, int argc
,
2766 return wpa_cli_cmd(ctrl
, "WMM_AC_DELTS", 1, argc
, argv
);
2770 static int wpa_cli_cmd_wmm_ac_status(struct wpa_ctrl
*ctrl
, int argc
,
2773 return wpa_ctrl_command(ctrl
, "WMM_AC_STATUS");
2777 static int wpa_cli_cmd_tdls_chan_switch(struct wpa_ctrl
*ctrl
, int argc
,
2780 return wpa_cli_cmd(ctrl
, "TDLS_CHAN_SWITCH", 2, argc
, argv
);
2784 static int wpa_cli_cmd_tdls_cancel_chan_switch(struct wpa_ctrl
*ctrl
, int argc
,
2787 return wpa_cli_cmd(ctrl
, "TDLS_CANCEL_CHAN_SWITCH", 1, argc
, argv
);
2791 static int wpa_cli_cmd_signal_poll(struct wpa_ctrl
*ctrl
, int argc
,
2794 return wpa_ctrl_command(ctrl
, "SIGNAL_POLL");
2798 static int wpa_cli_cmd_signal_monitor(struct wpa_ctrl
*ctrl
, int argc
,
2801 return wpa_cli_cmd(ctrl
, "SIGNAL_MONITOR", 0, argc
, argv
);
2805 static int wpa_cli_cmd_pktcnt_poll(struct wpa_ctrl
*ctrl
, int argc
,
2808 return wpa_ctrl_command(ctrl
, "PKTCNT_POLL");
2812 static int wpa_cli_cmd_reauthenticate(struct wpa_ctrl
*ctrl
, int argc
,
2815 return wpa_ctrl_command(ctrl
, "REAUTHENTICATE");
2819 #ifdef CONFIG_AUTOSCAN
2821 static int wpa_cli_cmd_autoscan(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2824 return wpa_ctrl_command(ctrl
, "AUTOSCAN ");
2826 return wpa_cli_cmd(ctrl
, "AUTOSCAN", 0, argc
, argv
);
2829 #endif /* CONFIG_AUTOSCAN */
2834 static int wpa_cli_cmd_wnm_sleep(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2836 return wpa_cli_cmd(ctrl
, "WNM_SLEEP", 0, argc
, argv
);
2840 static int wpa_cli_cmd_wnm_bss_query(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2842 return wpa_cli_cmd(ctrl
, "WNM_BSS_QUERY", 1, argc
, argv
);
2845 #endif /* CONFIG_WNM */
2848 static int wpa_cli_cmd_raw(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2852 return wpa_cli_cmd(ctrl
, argv
[0], 0, argc
- 1, &argv
[1]);
2857 static int wpa_cli_cmd_driver(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2859 return wpa_cli_cmd(ctrl
, "DRIVER", 1, argc
, argv
);
2861 #endif /* ANDROID */
2864 static int wpa_cli_cmd_vendor(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2866 return wpa_cli_cmd(ctrl
, "VENDOR", 1, argc
, argv
);
2870 static int wpa_cli_cmd_flush(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2872 return wpa_ctrl_command(ctrl
, "FLUSH");
2876 static int wpa_cli_cmd_radio_work(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2878 return wpa_cli_cmd(ctrl
, "RADIO_WORK", 1, argc
, argv
);
2882 static int wpa_cli_cmd_neighbor_rep_request(struct wpa_ctrl
*ctrl
, int argc
,
2885 return wpa_cli_cmd(ctrl
, "NEIGHBOR_REP_REQUEST", 0, argc
, argv
);
2889 static int wpa_cli_cmd_erp_flush(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2891 return wpa_ctrl_command(ctrl
, "ERP_FLUSH");
2895 static int wpa_cli_cmd_mac_rand_scan(struct wpa_ctrl
*ctrl
, int argc
,
2898 return wpa_cli_cmd(ctrl
, "MAC_RAND_SCAN", 1, argc
, argv
);
2902 static int wpa_cli_cmd_get_pref_freq_list(struct wpa_ctrl
*ctrl
, int argc
,
2905 return wpa_cli_cmd(ctrl
, "GET_PREF_FREQ_LIST", 1, argc
, argv
);
2909 static int wpa_cli_cmd_p2p_lo_start(struct wpa_ctrl
*ctrl
, int argc
,
2912 return wpa_cli_cmd(ctrl
, "P2P_LO_START", 4, argc
, argv
);
2916 static int wpa_cli_cmd_p2p_lo_stop(struct wpa_ctrl
*ctrl
, int argc
,
2919 return wpa_cli_cmd(ctrl
, "P2P_LO_STOP", 0, argc
, argv
);
2925 static int wpa_cli_cmd_dpp_qr_code(struct wpa_ctrl
*ctrl
, int argc
,
2928 return wpa_cli_cmd(ctrl
, "DPP_QR_CODE", 1, argc
, argv
);
2932 static int wpa_cli_cmd_dpp_bootstrap_gen(struct wpa_ctrl
*ctrl
, int argc
,
2935 return wpa_cli_cmd(ctrl
, "DPP_BOOTSTRAP_GEN", 1, argc
, argv
);
2939 static int wpa_cli_cmd_dpp_bootstrap_remove(struct wpa_ctrl
*ctrl
, int argc
,
2942 return wpa_cli_cmd(ctrl
, "DPP_BOOTSTRAP_REMOVE", 1, argc
, argv
);
2946 static int wpa_cli_cmd_dpp_bootstrap_get_uri(struct wpa_ctrl
*ctrl
, int argc
,
2949 return wpa_cli_cmd(ctrl
, "DPP_BOOTSTRAP_GET_URI", 1, argc
, argv
);
2953 static int wpa_cli_cmd_dpp_bootstrap_info(struct wpa_ctrl
*ctrl
, int argc
,
2956 return wpa_cli_cmd(ctrl
, "DPP_BOOTSTRAP_INFO", 1, argc
, argv
);
2960 static int wpa_cli_cmd_dpp_auth_init(struct wpa_ctrl
*ctrl
, int argc
,
2963 return wpa_cli_cmd(ctrl
, "DPP_AUTH_INIT", 1, argc
, argv
);
2967 static int wpa_cli_cmd_dpp_listen(struct wpa_ctrl
*ctrl
, int argc
,
2970 return wpa_cli_cmd(ctrl
, "DPP_LISTEN", 1, argc
, argv
);
2974 static int wpa_cli_cmd_dpp_stop_listen(struct wpa_ctrl
*ctrl
, int argc
,
2977 return wpa_ctrl_command(ctrl
, "DPP_STOP_LISTEN");
2981 static int wpa_cli_cmd_dpp_configurator_add(struct wpa_ctrl
*ctrl
, int argc
,
2984 return wpa_cli_cmd(ctrl
, "DPP_CONFIGURATOR_ADD", 0, argc
, argv
);
2988 static int wpa_cli_cmd_dpp_configurator_remove(struct wpa_ctrl
*ctrl
, int argc
,
2991 return wpa_cli_cmd(ctrl
, "DPP_CONFIGURATOR_REMOVE", 1, argc
, argv
);
2995 static int wpa_cli_cmd_dpp_configurator_get_key(struct wpa_ctrl
*ctrl
, int argc
,
2998 return wpa_cli_cmd(ctrl
, "DPP_CONFIGURATOR_GET_KEY", 1, argc
, argv
);
3002 static int wpa_cli_cmd_dpp_configurator_sign(struct wpa_ctrl
*ctrl
, int argc
,
3005 return wpa_cli_cmd(ctrl
, "DPP_CONFIGURATOR_SIGN", 1, argc
, argv
);
3009 static int wpa_cli_cmd_dpp_pkex_add(struct wpa_ctrl
*ctrl
, int argc
,
3012 return wpa_cli_cmd(ctrl
, "DPP_PKEX_ADD", 1, argc
, argv
);
3016 static int wpa_cli_cmd_dpp_pkex_remove(struct wpa_ctrl
*ctrl
, int argc
,
3019 return wpa_cli_cmd(ctrl
, "DPP_PKEX_REMOVE", 1, argc
, argv
);
3022 #endif /* CONFIG_DPP */
3025 enum wpa_cli_cmd_flags
{
3026 cli_cmd_flag_none
= 0x00,
3027 cli_cmd_flag_sensitive
= 0x01
3030 struct wpa_cli_cmd
{
3032 int (*handler
)(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[]);
3033 char ** (*completion
)(const char *str
, int pos
);
3034 enum wpa_cli_cmd_flags flags
;
3038 static const struct wpa_cli_cmd wpa_cli_commands
[] = {
3039 { "status", wpa_cli_cmd_status
, NULL
,
3041 "[verbose] = get current WPA/EAPOL/EAP status" },
3042 { "ifname", wpa_cli_cmd_ifname
, NULL
,
3044 "= get current interface name" },
3045 { "ping", wpa_cli_cmd_ping
, NULL
,
3047 "= pings wpa_supplicant" },
3048 { "relog", wpa_cli_cmd_relog
, NULL
,
3050 "= re-open log-file (allow rolling logs)" },
3051 { "note", wpa_cli_cmd_note
, NULL
,
3053 "<text> = add a note to wpa_supplicant debug log" },
3054 { "mib", wpa_cli_cmd_mib
, NULL
,
3056 "= get MIB variables (dot1x, dot11)" },
3057 { "help", wpa_cli_cmd_help
, wpa_cli_complete_help
,
3059 "[command] = show usage help" },
3060 { "interface", wpa_cli_cmd_interface
, NULL
,
3062 "[ifname] = show interfaces/select interface" },
3063 { "level", wpa_cli_cmd_level
, NULL
,
3065 "<debug level> = change debug level" },
3066 { "license", wpa_cli_cmd_license
, NULL
,
3068 "= show full wpa_cli license" },
3069 { "quit", wpa_cli_cmd_quit
, NULL
,
3072 { "set", wpa_cli_cmd_set
, wpa_cli_complete_set
,
3074 "= set variables (shows list of variables when run without "
3076 { "dump", wpa_cli_cmd_dump
, NULL
,
3078 "= dump config variables" },
3079 { "get", wpa_cli_cmd_get
, wpa_cli_complete_get
,
3081 "<name> = get information" },
3082 { "driver_flags", wpa_cli_cmd_driver_flags
, NULL
,
3084 "= list driver flags" },
3085 { "logon", wpa_cli_cmd_logon
, NULL
,
3087 "= IEEE 802.1X EAPOL state machine logon" },
3088 { "logoff", wpa_cli_cmd_logoff
, NULL
,
3090 "= IEEE 802.1X EAPOL state machine logoff" },
3091 { "pmksa", wpa_cli_cmd_pmksa
, NULL
,
3093 "= show PMKSA cache" },
3094 { "pmksa_flush", wpa_cli_cmd_pmksa_flush
, NULL
,
3096 "= flush PMKSA cache entries" },
3097 #ifdef CONFIG_PMKSA_CACHE_EXTERNAL
3098 { "pmksa_get", wpa_cli_cmd_pmksa_get
, NULL
,
3100 "<network_id> = fetch all stored PMKSA cache entries" },
3101 { "pmksa_add", wpa_cli_cmd_pmksa_add
, NULL
,
3102 cli_cmd_flag_sensitive
,
3103 "<network_id> <BSSID> <PMKID> <PMK> <reauth_time in seconds> <expiration in seconds> <akmp> <opportunistic> = store PMKSA cache entry from external storage" },
3105 { "mesh_pmksa_get", wpa_cli_mesh_cmd_pmksa_get
, NULL
,
3107 "<peer MAC address | any> = fetch all stored mesh PMKSA cache entries" },
3108 { "mesh_pmksa_add", wpa_cli_mesh_cmd_pmksa_add
, NULL
,
3109 cli_cmd_flag_sensitive
,
3110 "<BSSID> <PMKID> <PMK> <expiration in seconds> = store mesh PMKSA cache entry from external storage" },
3111 #endif /* CONFIG_MESH */
3112 #endif /* CONFIG_PMKSA_CACHE_EXTERNAL */
3113 { "reassociate", wpa_cli_cmd_reassociate
, NULL
,
3115 "= force reassociation" },
3116 { "reattach", wpa_cli_cmd_reattach
, NULL
,
3118 "= force reassociation back to the same BSS" },
3119 { "preauthenticate", wpa_cli_cmd_preauthenticate
, wpa_cli_complete_bss
,
3121 "<BSSID> = force preauthentication" },
3122 { "identity", wpa_cli_cmd_identity
, wpa_cli_complete_network_id
,
3124 "<network id> <identity> = configure identity for an SSID" },
3125 { "password", wpa_cli_cmd_password
, wpa_cli_complete_network_id
,
3126 cli_cmd_flag_sensitive
,
3127 "<network id> <password> = configure password for an SSID" },
3128 { "new_password", wpa_cli_cmd_new_password
,
3129 wpa_cli_complete_network_id
, cli_cmd_flag_sensitive
,
3130 "<network id> <password> = change password for an SSID" },
3131 { "pin", wpa_cli_cmd_pin
, wpa_cli_complete_network_id
,
3132 cli_cmd_flag_sensitive
,
3133 "<network id> <pin> = configure pin for an SSID" },
3134 { "otp", wpa_cli_cmd_otp
, wpa_cli_complete_network_id
,
3135 cli_cmd_flag_sensitive
,
3136 "<network id> <password> = configure one-time-password for an SSID"
3138 { "psk_passphrase", wpa_cli_cmd_psk_passphrase
,
3139 wpa_cli_complete_network_id
, cli_cmd_flag_sensitive
,
3140 "<network id> <PSK/passphrase> = configure PSK/passphrase for an SSID" },
3141 { "passphrase", wpa_cli_cmd_passphrase
, wpa_cli_complete_network_id
,
3142 cli_cmd_flag_sensitive
,
3143 "<network id> <passphrase> = configure private key passphrase\n"
3145 { "sim", wpa_cli_cmd_sim
, wpa_cli_complete_network_id
,
3146 cli_cmd_flag_sensitive
,
3147 "<network id> <pin> = report SIM operation result" },
3148 { "bssid", wpa_cli_cmd_bssid
, wpa_cli_complete_network_id
,
3150 "<network id> <BSSID> = set preferred BSSID for an SSID" },
3151 { "blacklist", wpa_cli_cmd_blacklist
, wpa_cli_complete_bss
,
3153 "<BSSID> = add a BSSID to the blacklist\n"
3154 "blacklist clear = clear the blacklist\n"
3155 "blacklist = display the blacklist" },
3156 { "log_level", wpa_cli_cmd_log_level
, NULL
,
3158 "<level> [<timestamp>] = update the log level/timestamp\n"
3159 "log_level = display the current log level and log options" },
3160 { "list_networks", wpa_cli_cmd_list_networks
, NULL
,
3162 "= list configured networks" },
3163 { "select_network", wpa_cli_cmd_select_network
,
3164 wpa_cli_complete_network_id
,
3166 "<network id> = select a network (disable others)" },
3167 { "enable_network", wpa_cli_cmd_enable_network
,
3168 wpa_cli_complete_network_id
,
3170 "<network id> = enable a network" },
3171 { "disable_network", wpa_cli_cmd_disable_network
,
3172 wpa_cli_complete_network_id
,
3174 "<network id> = disable a network" },
3175 { "add_network", wpa_cli_cmd_add_network
, NULL
,
3177 "= add a network" },
3178 { "remove_network", wpa_cli_cmd_remove_network
,
3179 wpa_cli_complete_network_id
,
3181 "<network id> = remove a network" },
3182 { "set_network", wpa_cli_cmd_set_network
, wpa_cli_complete_network
,
3183 cli_cmd_flag_sensitive
,
3184 "<network id> <variable> <value> = set network variables (shows\n"
3185 " list of variables when run without arguments)" },
3186 { "get_network", wpa_cli_cmd_get_network
, wpa_cli_complete_network
,
3188 "<network id> <variable> = get network variables" },
3189 { "dup_network", wpa_cli_cmd_dup_network
, wpa_cli_complete_dup_network
,
3191 "<src network id> <dst network id> <variable> = duplicate network variables"
3193 { "list_creds", wpa_cli_cmd_list_creds
, NULL
,
3195 "= list configured credentials" },
3196 { "add_cred", wpa_cli_cmd_add_cred
, NULL
,
3198 "= add a credential" },
3199 { "remove_cred", wpa_cli_cmd_remove_cred
, NULL
,
3201 "<cred id> = remove a credential" },
3202 { "set_cred", wpa_cli_cmd_set_cred
, wpa_cli_complete_cred
,
3203 cli_cmd_flag_sensitive
,
3204 "<cred id> <variable> <value> = set credential variables" },
3205 { "get_cred", wpa_cli_cmd_get_cred
, wpa_cli_complete_cred
,
3207 "<cred id> <variable> = get credential variables" },
3208 { "save_config", wpa_cli_cmd_save_config
, NULL
,
3210 "= save the current configuration" },
3211 { "disconnect", wpa_cli_cmd_disconnect
, NULL
,
3213 "= disconnect and wait for reassociate/reconnect command before\n"
3215 { "reconnect", wpa_cli_cmd_reconnect
, NULL
,
3217 "= like reassociate, but only takes effect if already disconnected"
3219 { "scan", wpa_cli_cmd_scan
, NULL
,
3221 "= request new BSS scan" },
3222 { "scan_results", wpa_cli_cmd_scan_results
, NULL
,
3224 "= get latest scan results" },
3225 { "abort_scan", wpa_cli_cmd_abort_scan
, NULL
,
3227 "= request ongoing scan to be aborted" },
3228 { "bss", wpa_cli_cmd_bss
, wpa_cli_complete_bss
,
3230 "<<idx> | <bssid>> = get detailed scan result info" },
3231 { "get_capability", wpa_cli_cmd_get_capability
,
3232 wpa_cli_complete_get_capability
, cli_cmd_flag_none
,
3233 "<eap/pairwise/group/key_mgmt/proto/auth_alg/channels/freq/modes> "
3234 "= get capabilities" },
3235 { "reconfigure", wpa_cli_cmd_reconfigure
, NULL
,
3237 "= force wpa_supplicant to re-read its configuration file" },
3238 { "terminate", wpa_cli_cmd_terminate
, NULL
,
3240 "= terminate wpa_supplicant" },
3241 { "interface_add", wpa_cli_cmd_interface_add
, NULL
,
3243 "<ifname> <confname> <driver> <ctrl_interface> <driver_param>\n"
3244 " <bridge_name> <create> <type> = adds new interface, all "
3246 " <ifname> are optional. Supported types are station ('sta') and "
3248 { "interface_remove", wpa_cli_cmd_interface_remove
, NULL
,
3250 "<ifname> = removes the interface" },
3251 { "interface_list", wpa_cli_cmd_interface_list
, NULL
,
3253 "= list available interfaces" },
3254 { "ap_scan", wpa_cli_cmd_ap_scan
, NULL
,
3256 "<value> = set ap_scan parameter" },
3257 { "scan_interval", wpa_cli_cmd_scan_interval
, NULL
,
3259 "<value> = set scan_interval parameter (in seconds)" },
3260 { "bss_expire_age", wpa_cli_cmd_bss_expire_age
, NULL
,
3262 "<value> = set BSS expiration age parameter" },
3263 { "bss_expire_count", wpa_cli_cmd_bss_expire_count
, NULL
,
3265 "<value> = set BSS expiration scan count parameter" },
3266 { "bss_flush", wpa_cli_cmd_bss_flush
, NULL
,
3268 "<value> = set BSS flush age (0 by default)" },
3269 { "ft_ds", wpa_cli_cmd_ft_ds
, wpa_cli_complete_bss
,
3271 "<addr> = request over-the-DS FT with <addr>" },
3272 { "wps_pbc", wpa_cli_cmd_wps_pbc
, wpa_cli_complete_bss
,
3274 "[BSSID] = start Wi-Fi Protected Setup: Push Button Configuration" },
3275 { "wps_pin", wpa_cli_cmd_wps_pin
, wpa_cli_complete_bss
,
3276 cli_cmd_flag_sensitive
,
3277 "<BSSID> [PIN] = start WPS PIN method (returns PIN, if not "
3279 { "wps_check_pin", wpa_cli_cmd_wps_check_pin
, NULL
,
3280 cli_cmd_flag_sensitive
,
3281 "<PIN> = verify PIN checksum" },
3282 { "wps_cancel", wpa_cli_cmd_wps_cancel
, NULL
, cli_cmd_flag_none
,
3283 "Cancels the pending WPS operation" },
3284 #ifdef CONFIG_WPS_NFC
3285 { "wps_nfc", wpa_cli_cmd_wps_nfc
, wpa_cli_complete_bss
,
3287 "[BSSID] = start Wi-Fi Protected Setup: NFC" },
3288 { "wps_nfc_config_token", wpa_cli_cmd_wps_nfc_config_token
, NULL
,
3290 "<WPS|NDEF> = build configuration token" },
3291 { "wps_nfc_token", wpa_cli_cmd_wps_nfc_token
, NULL
,
3293 "<WPS|NDEF> = create password token" },
3294 { "wps_nfc_tag_read", wpa_cli_cmd_wps_nfc_tag_read
, NULL
,
3295 cli_cmd_flag_sensitive
,
3296 "<hexdump of payload> = report read NFC tag with WPS data" },
3297 { "nfc_get_handover_req", wpa_cli_cmd_nfc_get_handover_req
, NULL
,
3299 "<NDEF> <WPS> = create NFC handover request" },
3300 { "nfc_get_handover_sel", wpa_cli_cmd_nfc_get_handover_sel
, NULL
,
3302 "<NDEF> <WPS> = create NFC handover select" },
3303 { "nfc_report_handover", wpa_cli_cmd_nfc_report_handover
, NULL
,
3305 "<role> <type> <hexdump of req> <hexdump of sel> = report completed "
3307 #endif /* CONFIG_WPS_NFC */
3308 { "wps_reg", wpa_cli_cmd_wps_reg
, wpa_cli_complete_bss
,
3309 cli_cmd_flag_sensitive
,
3310 "<BSSID> <AP PIN> = start WPS Registrar to configure an AP" },
3311 { "wps_ap_pin", wpa_cli_cmd_wps_ap_pin
, NULL
,
3312 cli_cmd_flag_sensitive
,
3313 "[params..] = enable/disable AP PIN" },
3314 { "wps_er_start", wpa_cli_cmd_wps_er_start
, NULL
,
3316 "[IP address] = start Wi-Fi Protected Setup External Registrar" },
3317 { "wps_er_stop", wpa_cli_cmd_wps_er_stop
, NULL
,
3319 "= stop Wi-Fi Protected Setup External Registrar" },
3320 { "wps_er_pin", wpa_cli_cmd_wps_er_pin
, NULL
,
3321 cli_cmd_flag_sensitive
,
3322 "<UUID> <PIN> = add an Enrollee PIN to External Registrar" },
3323 { "wps_er_pbc", wpa_cli_cmd_wps_er_pbc
, NULL
,
3325 "<UUID> = accept an Enrollee PBC using External Registrar" },
3326 { "wps_er_learn", wpa_cli_cmd_wps_er_learn
, NULL
,
3327 cli_cmd_flag_sensitive
,
3328 "<UUID> <PIN> = learn AP configuration" },
3329 { "wps_er_set_config", wpa_cli_cmd_wps_er_set_config
, NULL
,
3331 "<UUID> <network id> = set AP configuration for enrolling" },
3332 { "wps_er_config", wpa_cli_cmd_wps_er_config
, NULL
,
3333 cli_cmd_flag_sensitive
,
3334 "<UUID> <PIN> <SSID> <auth> <encr> <key> = configure AP" },
3335 #ifdef CONFIG_WPS_NFC
3336 { "wps_er_nfc_config_token", wpa_cli_cmd_wps_er_nfc_config_token
, NULL
,
3338 "<WPS/NDEF> <UUID> = build NFC configuration token" },
3339 #endif /* CONFIG_WPS_NFC */
3340 { "ibss_rsn", wpa_cli_cmd_ibss_rsn
, NULL
,
3342 "<addr> = request RSN authentication with <addr> in IBSS" },
3344 { "sta", wpa_cli_cmd_sta
, wpa_cli_complete_sta
,
3346 "<addr> = get information about an associated station (AP)" },
3347 { "all_sta", wpa_cli_cmd_all_sta
, NULL
,
3349 "= get information about all associated stations (AP)" },
3350 { "list_sta", wpa_cli_cmd_list_sta
, NULL
,
3352 "= list all stations (AP)" },
3353 { "deauthenticate", wpa_cli_cmd_deauthenticate
,
3354 wpa_cli_complete_deauthenticate
, cli_cmd_flag_none
,
3355 "<addr> = deauthenticate a station" },
3356 { "disassociate", wpa_cli_cmd_disassociate
,
3357 wpa_cli_complete_disassociate
, cli_cmd_flag_none
,
3358 "<addr> = disassociate a station" },
3359 { "chan_switch", wpa_cli_cmd_chanswitch
, NULL
,
3361 "<cs_count> <freq> [sec_channel_offset=] [center_freq1=]"
3362 " [center_freq2=] [bandwidth=] [blocktx] [ht|vht]"
3363 " = CSA parameters" },
3364 #endif /* CONFIG_AP */
3365 { "suspend", wpa_cli_cmd_suspend
, NULL
, cli_cmd_flag_none
,
3366 "= notification of suspend/hibernate" },
3367 { "resume", wpa_cli_cmd_resume
, NULL
, cli_cmd_flag_none
,
3368 "= notification of resume/thaw" },
3369 #ifdef CONFIG_TESTING_OPTIONS
3370 { "drop_sa", wpa_cli_cmd_drop_sa
, NULL
, cli_cmd_flag_none
,
3371 "= drop SA without deauth/disassoc (test command)" },
3372 #endif /* CONFIG_TESTING_OPTIONS */
3373 { "roam", wpa_cli_cmd_roam
, wpa_cli_complete_bss
,
3375 "<addr> = roam to the specified BSS" },
3377 { "mesh_interface_add", wpa_cli_cmd_mesh_interface_add
, NULL
,
3379 "[ifname] = Create a new mesh interface" },
3380 { "mesh_group_add", wpa_cli_cmd_mesh_group_add
, NULL
,
3382 "<network id> = join a mesh network (disable others)" },
3383 { "mesh_group_remove", wpa_cli_cmd_mesh_group_remove
, NULL
,
3385 "<ifname> = Remove mesh group interface" },
3386 { "mesh_peer_remove", wpa_cli_cmd_mesh_peer_remove
, NULL
,
3388 "<addr> = Remove a mesh peer" },
3389 { "mesh_peer_add", wpa_cli_cmd_mesh_peer_add
, NULL
,
3391 "<addr> [duration=<seconds>] = Add a mesh peer" },
3392 { "mesh_link_probe", wpa_cli_cmd_mesh_link_probe
, NULL
,
3394 "<addr> [payload=<hex dump of payload>] = Probe a mesh link for a given peer by injecting a frame." },
3395 #endif /* CONFIG_MESH */
3397 { "p2p_find", wpa_cli_cmd_p2p_find
, wpa_cli_complete_p2p_find
,
3399 "[timeout] [type=*] = find P2P Devices for up-to timeout seconds" },
3400 { "p2p_stop_find", wpa_cli_cmd_p2p_stop_find
, NULL
, cli_cmd_flag_none
,
3401 "= stop P2P Devices search" },
3402 { "p2p_asp_provision", wpa_cli_cmd_p2p_asp_provision
, NULL
,
3404 "<addr> adv_id=<adv_id> conncap=<conncap> [info=<infodata>] = provision with a P2P ASP Device" },
3405 { "p2p_asp_provision_resp", wpa_cli_cmd_p2p_asp_provision_resp
, NULL
,
3407 "<addr> adv_id=<adv_id> [role<conncap>] [info=<infodata>] = provision with a P2P ASP Device" },
3408 { "p2p_connect", wpa_cli_cmd_p2p_connect
, wpa_cli_complete_p2p_connect
,
3410 "<addr> <\"pbc\"|PIN> [ht40] = connect to a P2P Device" },
3411 { "p2p_listen", wpa_cli_cmd_p2p_listen
, NULL
, cli_cmd_flag_none
,
3412 "[timeout] = listen for P2P Devices for up-to timeout seconds" },
3413 { "p2p_group_remove", wpa_cli_cmd_p2p_group_remove
,
3414 wpa_cli_complete_p2p_group_remove
, cli_cmd_flag_none
,
3415 "<ifname> = remove P2P group interface (terminate group if GO)" },
3416 { "p2p_group_add", wpa_cli_cmd_p2p_group_add
, NULL
, cli_cmd_flag_none
,
3417 "[ht40] = add a new P2P group (local end as GO)" },
3418 { "p2p_group_member", wpa_cli_cmd_p2p_group_member
, NULL
,
3420 "<dev_addr> = Get peer interface address on local GO using peer Device Address" },
3421 { "p2p_prov_disc", wpa_cli_cmd_p2p_prov_disc
,
3422 wpa_cli_complete_p2p_peer
, cli_cmd_flag_none
,
3423 "<addr> <method> = request provisioning discovery" },
3424 { "p2p_get_passphrase", wpa_cli_cmd_p2p_get_passphrase
, NULL
,
3426 "= get the passphrase for a group (GO only)" },
3427 { "p2p_serv_disc_req", wpa_cli_cmd_p2p_serv_disc_req
,
3428 wpa_cli_complete_p2p_peer
, cli_cmd_flag_none
,
3429 "<addr> <TLVs> = schedule service discovery request" },
3430 { "p2p_serv_disc_cancel_req", wpa_cli_cmd_p2p_serv_disc_cancel_req
,
3431 NULL
, cli_cmd_flag_none
,
3432 "<id> = cancel pending service discovery request" },
3433 { "p2p_serv_disc_resp", wpa_cli_cmd_p2p_serv_disc_resp
, NULL
,
3435 "<freq> <addr> <dialog token> <TLVs> = service discovery response" },
3436 { "p2p_service_update", wpa_cli_cmd_p2p_service_update
, NULL
,
3438 "= indicate change in local services" },
3439 { "p2p_serv_disc_external", wpa_cli_cmd_p2p_serv_disc_external
, NULL
,
3441 "<external> = set external processing of service discovery" },
3442 { "p2p_service_flush", wpa_cli_cmd_p2p_service_flush
, NULL
,
3444 "= remove all stored service entries" },
3445 { "p2p_service_add", wpa_cli_cmd_p2p_service_add
, NULL
,
3447 "<bonjour|upnp|asp> <query|version> <response|service> = add a local "
3449 { "p2p_service_rep", wpa_cli_cmd_p2p_service_rep
, NULL
,
3451 "asp <auto> <adv_id> <svc_state> <svc_string> [<svc_info>] = replace "
3452 "local ASP service" },
3453 { "p2p_service_del", wpa_cli_cmd_p2p_service_del
, NULL
,
3455 "<bonjour|upnp> <query|version> [|service] = remove a local "
3457 { "p2p_reject", wpa_cli_cmd_p2p_reject
, wpa_cli_complete_p2p_peer
,
3459 "<addr> = reject connection attempts from a specific peer" },
3460 { "p2p_invite", wpa_cli_cmd_p2p_invite
, NULL
,
3462 "<cmd> [peer=addr] = invite peer" },
3463 { "p2p_peers", wpa_cli_cmd_p2p_peers
, NULL
, cli_cmd_flag_none
,
3464 "[discovered] = list known (optionally, only fully discovered) P2P "
3466 { "p2p_peer", wpa_cli_cmd_p2p_peer
, wpa_cli_complete_p2p_peer
,
3468 "<address> = show information about known P2P peer" },
3469 { "p2p_set", wpa_cli_cmd_p2p_set
, wpa_cli_complete_p2p_set
,
3471 "<field> <value> = set a P2P parameter" },
3472 { "p2p_flush", wpa_cli_cmd_p2p_flush
, NULL
, cli_cmd_flag_none
,
3473 "= flush P2P state" },
3474 { "p2p_cancel", wpa_cli_cmd_p2p_cancel
, NULL
, cli_cmd_flag_none
,
3475 "= cancel P2P group formation" },
3476 { "p2p_unauthorize", wpa_cli_cmd_p2p_unauthorize
,
3477 wpa_cli_complete_p2p_peer
, cli_cmd_flag_none
,
3478 "<address> = unauthorize a peer" },
3479 { "p2p_presence_req", wpa_cli_cmd_p2p_presence_req
, NULL
,
3481 "[<duration> <interval>] [<duration> <interval>] = request GO "
3483 { "p2p_ext_listen", wpa_cli_cmd_p2p_ext_listen
, NULL
,
3485 "[<period> <interval>] = set extended listen timing" },
3486 { "p2p_remove_client", wpa_cli_cmd_p2p_remove_client
,
3487 wpa_cli_complete_p2p_peer
, cli_cmd_flag_none
,
3488 "<address|iface=address> = remove a peer from all groups" },
3489 #endif /* CONFIG_P2P */
3490 { "vendor_elem_add", wpa_cli_cmd_vendor_elem_add
, NULL
,
3492 "<frame id> <hexdump of elem(s)> = add vendor specific IEs to frame(s)\n"
3493 VENDOR_ELEM_FRAME_ID
},
3494 { "vendor_elem_get", wpa_cli_cmd_vendor_elem_get
, NULL
,
3496 "<frame id> = get vendor specific IE(s) to frame(s)\n"
3497 VENDOR_ELEM_FRAME_ID
},
3498 { "vendor_elem_remove", wpa_cli_cmd_vendor_elem_remove
, NULL
,
3500 "<frame id> <hexdump of elem(s)> = remove vendor specific IE(s) in frame(s)\n"
3501 VENDOR_ELEM_FRAME_ID
},
3502 #ifdef CONFIG_WIFI_DISPLAY
3503 { "wfd_subelem_set", wpa_cli_cmd_wfd_subelem_set
, NULL
,
3505 "<subelem> [contents] = set Wi-Fi Display subelement" },
3506 { "wfd_subelem_get", wpa_cli_cmd_wfd_subelem_get
, NULL
,
3508 "<subelem> = get Wi-Fi Display subelement" },
3509 #endif /* CONFIG_WIFI_DISPLAY */
3510 #ifdef CONFIG_INTERWORKING
3511 { "fetch_anqp", wpa_cli_cmd_fetch_anqp
, NULL
, cli_cmd_flag_none
,
3512 "= fetch ANQP information for all APs" },
3513 { "stop_fetch_anqp", wpa_cli_cmd_stop_fetch_anqp
, NULL
,
3515 "= stop fetch_anqp operation" },
3516 { "interworking_select", wpa_cli_cmd_interworking_select
, NULL
,
3518 "[auto] = perform Interworking network selection" },
3519 { "interworking_connect", wpa_cli_cmd_interworking_connect
,
3520 wpa_cli_complete_bss
, cli_cmd_flag_none
,
3521 "<BSSID> = connect using Interworking credentials" },
3522 { "interworking_add_network", wpa_cli_cmd_interworking_add_network
,
3523 wpa_cli_complete_bss
, cli_cmd_flag_none
,
3524 "<BSSID> = connect using Interworking credentials" },
3525 { "anqp_get", wpa_cli_cmd_anqp_get
, wpa_cli_complete_bss
,
3527 "<addr> <info id>[,<info id>]... = request ANQP information" },
3528 { "gas_request", wpa_cli_cmd_gas_request
, wpa_cli_complete_bss
,
3530 "<addr> <AdvProtoID> [QueryReq] = GAS request" },
3531 { "gas_response_get", wpa_cli_cmd_gas_response_get
,
3532 wpa_cli_complete_bss
, cli_cmd_flag_none
,
3533 "<addr> <dialog token> [start,len] = Fetch last GAS response" },
3534 #endif /* CONFIG_INTERWORKING */
3536 { "hs20_anqp_get", wpa_cli_cmd_hs20_anqp_get
, wpa_cli_complete_bss
,
3538 "<addr> <subtype>[,<subtype>]... = request HS 2.0 ANQP information"
3540 { "nai_home_realm_list", wpa_cli_cmd_get_nai_home_realm_list
,
3541 wpa_cli_complete_bss
, cli_cmd_flag_none
,
3542 "<addr> <home realm> = get HS20 nai home realm list" },
3543 { "hs20_icon_request", wpa_cli_cmd_hs20_icon_request
,
3544 wpa_cli_complete_bss
, cli_cmd_flag_none
,
3545 "<addr> <icon name> = get Hotspot 2.0 OSU icon" },
3546 { "fetch_osu", wpa_cli_cmd_fetch_osu
, NULL
, cli_cmd_flag_none
,
3547 "= fetch OSU provider information from all APs" },
3548 { "cancel_fetch_osu", wpa_cli_cmd_cancel_fetch_osu
, NULL
,
3550 "= cancel fetch_osu command" },
3551 #endif /* CONFIG_HS20 */
3552 { "sta_autoconnect", wpa_cli_cmd_sta_autoconnect
, NULL
,
3554 "<0/1> = disable/enable automatic reconnection" },
3555 { "tdls_discover", wpa_cli_cmd_tdls_discover
, NULL
,
3557 "<addr> = request TDLS discovery with <addr>" },
3558 { "tdls_setup", wpa_cli_cmd_tdls_setup
, NULL
,
3560 "<addr> = request TDLS setup with <addr>" },
3561 { "tdls_teardown", wpa_cli_cmd_tdls_teardown
, NULL
,
3563 "<addr> = tear down TDLS with <addr>" },
3564 { "tdls_link_status", wpa_cli_cmd_tdls_link_status
, NULL
,
3566 "<addr> = TDLS link status with <addr>" },
3567 { "wmm_ac_addts", wpa_cli_cmd_wmm_ac_addts
, NULL
,
3569 "<uplink/downlink/bidi> <tsid=0..7> <up=0..7> [nominal_msdu_size=#] "
3570 "[mean_data_rate=#] [min_phy_rate=#] [sba=#] [fixed_nominal_msdu] "
3571 "= add WMM-AC traffic stream" },
3572 { "wmm_ac_delts", wpa_cli_cmd_wmm_ac_delts
, NULL
,
3574 "<tsid> = delete WMM-AC traffic stream" },
3575 { "wmm_ac_status", wpa_cli_cmd_wmm_ac_status
, NULL
,
3577 "= show status for Wireless Multi-Media Admission-Control" },
3578 { "tdls_chan_switch", wpa_cli_cmd_tdls_chan_switch
, NULL
,
3580 "<addr> <oper class> <freq> [sec_channel_offset=] [center_freq1=] "
3581 "[center_freq2=] [bandwidth=] [ht|vht] = enable channel switching "
3583 { "tdls_cancel_chan_switch", wpa_cli_cmd_tdls_cancel_chan_switch
, NULL
,
3585 "<addr> = disable channel switching with TDLS peer <addr>" },
3586 { "signal_poll", wpa_cli_cmd_signal_poll
, NULL
,
3588 "= get signal parameters" },
3589 { "signal_monitor", wpa_cli_cmd_signal_monitor
, NULL
,
3591 "= set signal monitor parameters" },
3592 { "pktcnt_poll", wpa_cli_cmd_pktcnt_poll
, NULL
,
3594 "= get TX/RX packet counters" },
3595 { "reauthenticate", wpa_cli_cmd_reauthenticate
, NULL
,
3597 "= trigger IEEE 802.1X/EAPOL reauthentication" },
3598 #ifdef CONFIG_AUTOSCAN
3599 { "autoscan", wpa_cli_cmd_autoscan
, NULL
, cli_cmd_flag_none
,
3600 "[params] = Set or unset (if none) autoscan parameters" },
3601 #endif /* CONFIG_AUTOSCAN */
3603 { "wnm_sleep", wpa_cli_cmd_wnm_sleep
, NULL
, cli_cmd_flag_none
,
3604 "<enter/exit> [interval=#] = enter/exit WNM-Sleep mode" },
3605 { "wnm_bss_query", wpa_cli_cmd_wnm_bss_query
, NULL
, cli_cmd_flag_none
,
3606 "<query reason> [list]"
3607 " [neighbor=<BSSID>,<BSSID information>,<operating class>,<channel number>,<PHY type>[,<hexdump of optional subelements>]"
3608 " = Send BSS Transition Management Query" },
3609 #endif /* CONFIG_WNM */
3610 { "raw", wpa_cli_cmd_raw
, NULL
, cli_cmd_flag_sensitive
,
3611 "<params..> = Sent unprocessed command" },
3612 { "flush", wpa_cli_cmd_flush
, NULL
, cli_cmd_flag_none
,
3613 "= flush wpa_supplicant state" },
3615 { "driver", wpa_cli_cmd_driver
, NULL
, cli_cmd_flag_none
,
3616 "<command> = driver private commands" },
3617 #endif /* ANDROID */
3618 { "radio_work", wpa_cli_cmd_radio_work
, NULL
, cli_cmd_flag_none
,
3619 "= radio_work <show/add/done>" },
3620 { "vendor", wpa_cli_cmd_vendor
, NULL
, cli_cmd_flag_none
,
3621 "<vendor id> <command id> [<hex formatted command argument>] = Send vendor command"
3623 { "neighbor_rep_request",
3624 wpa_cli_cmd_neighbor_rep_request
, NULL
, cli_cmd_flag_none
,
3625 "[ssid=<SSID>] [lci] [civic] = Trigger request to AP for neighboring AP report (with optional given SSID in hex or enclosed in double quotes, default: current SSID; with optional LCI and location civic request)"
3627 { "erp_flush", wpa_cli_cmd_erp_flush
, NULL
, cli_cmd_flag_none
,
3628 "= flush ERP keys" },
3630 wpa_cli_cmd_mac_rand_scan
, NULL
, cli_cmd_flag_none
,
3631 "<scan|sched|pno|all> enable=<0/1> [addr=mac-address "
3632 "mask=mac-address-mask] = scan MAC randomization"
3634 { "get_pref_freq_list", wpa_cli_cmd_get_pref_freq_list
, NULL
,
3636 "<interface type> = retrieve preferred freq list for the specified interface type" },
3637 { "p2p_lo_start", wpa_cli_cmd_p2p_lo_start
, NULL
,
3639 "<freq> <period> <interval> <count> = start P2P listen offload" },
3640 { "p2p_lo_stop", wpa_cli_cmd_p2p_lo_stop
, NULL
,
3642 "= stop P2P listen offload" },
3644 { "dpp_qr_code", wpa_cli_cmd_dpp_qr_code
, NULL
, cli_cmd_flag_none
,
3645 "report a scanned DPP URI from a QR Code" },
3646 { "dpp_bootstrap_gen", wpa_cli_cmd_dpp_bootstrap_gen
, NULL
,
3647 cli_cmd_flag_sensitive
,
3648 "type=<qrcode> [chan=..] [mac=..] [info=..] [curve=..] [key=..] = generate DPP bootstrap information" },
3649 { "dpp_bootstrap_remove", wpa_cli_cmd_dpp_bootstrap_remove
, NULL
,
3651 "*|<id> = remove DPP bootstrap information" },
3652 { "dpp_bootstrap_get_uri", wpa_cli_cmd_dpp_bootstrap_get_uri
, NULL
,
3654 "<id> = get DPP bootstrap URI" },
3655 { "dpp_bootstrap_info", wpa_cli_cmd_dpp_bootstrap_info
, NULL
,
3657 "<id> = show DPP bootstrap information" },
3658 { "dpp_auth_init", wpa_cli_cmd_dpp_auth_init
, NULL
, cli_cmd_flag_none
,
3659 "peer=<id> [own=<id>] = initiate DPP bootstrapping" },
3660 { "dpp_listen", wpa_cli_cmd_dpp_listen
, NULL
, cli_cmd_flag_none
,
3661 "<freq in MHz> = start DPP listen" },
3662 { "dpp_stop_listen", wpa_cli_cmd_dpp_stop_listen
, NULL
,
3664 "= stop DPP listen" },
3665 { "dpp_configurator_add", wpa_cli_cmd_dpp_configurator_add
, NULL
,
3666 cli_cmd_flag_sensitive
,
3667 "[curve=..] [key=..] = add DPP configurator" },
3668 { "dpp_configurator_remove", wpa_cli_cmd_dpp_configurator_remove
, NULL
,
3670 "*|<id> = remove DPP configurator" },
3671 { "dpp_configurator_get_key", wpa_cli_cmd_dpp_configurator_get_key
,
3672 NULL
, cli_cmd_flag_none
,
3673 "<id> = Get DPP configurator's private key" },
3674 { "dpp_configurator_sign", wpa_cli_cmd_dpp_configurator_sign
, NULL
,
3676 "conf=<role> configurator=<id> = generate self DPP configuration" },
3677 { "dpp_pkex_add", wpa_cli_cmd_dpp_pkex_add
, NULL
,
3678 cli_cmd_flag_sensitive
,
3680 { "dpp_pkex_remove", wpa_cli_cmd_dpp_pkex_remove
, NULL
,
3682 "*|<id> = remove DPP pkex information" },
3683 #endif /* CONFIG_DPP */
3684 { NULL
, NULL
, NULL
, cli_cmd_flag_none
, NULL
}
3689 * Prints command usage, lines are padded with the specified string.
3691 static void print_cmd_help(const struct wpa_cli_cmd
*cmd
, const char *pad
)
3696 printf("%s%s ", pad
, cmd
->cmd
);
3697 for (n
= 0; (c
= cmd
->usage
[n
]); n
++) {
3706 static void print_help(const char *cmd
)
3709 printf("commands:\n");
3710 for (n
= 0; wpa_cli_commands
[n
].cmd
; n
++) {
3711 if (cmd
== NULL
|| str_starts(wpa_cli_commands
[n
].cmd
, cmd
))
3712 print_cmd_help(&wpa_cli_commands
[n
], " ");
3717 static int wpa_cli_edit_filter_history_cb(void *ctx
, const char *cmd
)
3719 const char *c
, *delim
;
3723 delim
= os_strchr(cmd
, ' ');
3727 len
= os_strlen(cmd
);
3729 for (n
= 0; (c
= wpa_cli_commands
[n
].cmd
); n
++) {
3730 if (os_strncasecmp(cmd
, c
, len
) == 0 && len
== os_strlen(c
))
3731 return (wpa_cli_commands
[n
].flags
&
3732 cli_cmd_flag_sensitive
);
3738 static char ** wpa_list_cmd_list(void)
3742 struct cli_txt_entry
*e
;
3744 count
= ARRAY_SIZE(wpa_cli_commands
);
3745 count
+= dl_list_len(&p2p_groups
);
3746 count
+= dl_list_len(&ifnames
);
3747 res
= os_calloc(count
+ 1, sizeof(char *));
3751 for (i
= 0; wpa_cli_commands
[i
].cmd
; i
++) {
3752 res
[i
] = os_strdup(wpa_cli_commands
[i
].cmd
);
3757 dl_list_for_each(e
, &p2p_groups
, struct cli_txt_entry
, list
) {
3758 size_t len
= 8 + os_strlen(e
->txt
);
3759 res
[i
] = os_malloc(len
);
3762 os_snprintf(res
[i
], len
, "ifname=%s", e
->txt
);
3766 dl_list_for_each(e
, &ifnames
, struct cli_txt_entry
, list
) {
3767 res
[i
] = os_strdup(e
->txt
);
3777 static char ** wpa_cli_cmd_completion(const char *cmd
, const char *str
,
3782 for (i
= 0; wpa_cli_commands
[i
].cmd
; i
++) {
3783 if (os_strcasecmp(wpa_cli_commands
[i
].cmd
, cmd
) == 0) {
3784 if (wpa_cli_commands
[i
].completion
)
3785 return wpa_cli_commands
[i
].completion(str
,
3788 printf("\r%s\n", wpa_cli_commands
[i
].usage
);
3798 static char ** wpa_cli_edit_completion_cb(void *ctx
, const char *str
, int pos
)
3804 if (pos
> 7 && os_strncasecmp(str
, "IFNAME=", 7) == 0) {
3805 end
= os_strchr(str
, ' ');
3806 if (end
&& pos
> end
- str
) {
3807 pos
-= end
- str
+ 1;
3812 end
= os_strchr(str
, ' ');
3813 if (end
== NULL
|| str
+ pos
< end
)
3814 return wpa_list_cmd_list();
3816 cmd
= os_malloc(pos
+ 1);
3819 os_memcpy(cmd
, str
, pos
);
3820 cmd
[end
- str
] = '\0';
3821 res
= wpa_cli_cmd_completion(cmd
, str
, pos
);
3827 static int wpa_request(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
3829 const struct wpa_cli_cmd
*cmd
, *match
= NULL
;
3833 if (argc
> 1 && os_strncasecmp(argv
[0], "IFNAME=", 7) == 0) {
3834 ifname_prefix
= argv
[0] + 7;
3838 ifname_prefix
= NULL
;
3844 cmd
= wpa_cli_commands
;
3846 if (os_strncasecmp(cmd
->cmd
, argv
[0], os_strlen(argv
[0])) == 0)
3849 if (os_strcasecmp(cmd
->cmd
, argv
[0]) == 0) {
3850 /* we have an exact match */
3860 printf("Ambiguous command '%s'; possible commands:", argv
[0]);
3861 cmd
= wpa_cli_commands
;
3863 if (os_strncasecmp(cmd
->cmd
, argv
[0],
3864 os_strlen(argv
[0])) == 0) {
3865 printf(" %s", cmd
->cmd
);
3871 } else if (count
== 0) {
3872 printf("Unknown command '%s'\n", argv
[0]);
3875 ret
= match
->handler(ctrl
, argc
- 1, &argv
[1]);
3882 static int wpa_cli_exec(const char *program
, const char *arg1
,
3889 /* If no interface is specified, set the global */
3893 len
= os_strlen(arg1
) + os_strlen(arg2
) + 2;
3894 arg
= os_malloc(len
);
3897 os_snprintf(arg
, len
, "%s %s", arg1
, arg2
);
3898 res
= os_exec(program
, arg
, 1);
3905 static void wpa_cli_action_process(const char *msg
)
3908 char *copy
= NULL
, *id
, *pos2
;
3909 const char *ifname
= ctrl_ifname
;
3910 char ifname_buf
[100];
3912 if (eloop_terminated())
3916 if (os_strncmp(pos
, "IFNAME=", 7) == 0) {
3918 end
= os_strchr(pos
+ 7, ' ');
3919 if (end
&& (unsigned int) (end
- pos
) < sizeof(ifname_buf
)) {
3921 os_memcpy(ifname_buf
, pos
, end
- pos
);
3922 ifname_buf
[end
- pos
] = '\0';
3923 ifname
= ifname_buf
;
3928 const char *prev
= pos
;
3930 pos
= os_strchr(pos
, '>');
3937 if (str_starts(pos
, WPA_EVENT_CONNECTED
)) {
3939 os_unsetenv("WPA_ID");
3940 os_unsetenv("WPA_ID_STR");
3941 os_unsetenv("WPA_CTRL_DIR");
3943 pos
= os_strstr(pos
, "[id=");
3945 copy
= os_strdup(pos
+ 4);
3949 while (*pos2
&& *pos2
!= ' ')
3953 os_setenv("WPA_ID", id
, 1);
3954 while (*pos2
&& *pos2
!= '=')
3959 while (*pos2
&& *pos2
!= ']')
3962 os_setenv("WPA_ID_STR", id
, 1);
3966 os_setenv("WPA_CTRL_DIR", ctrl_iface_dir
, 1);
3968 if (wpa_cli_connected
<= 0 || new_id
!= wpa_cli_last_id
) {
3969 wpa_cli_connected
= 1;
3970 wpa_cli_last_id
= new_id
;
3971 wpa_cli_exec(action_file
, ifname
, "CONNECTED");
3973 } else if (str_starts(pos
, WPA_EVENT_DISCONNECTED
)) {
3974 if (wpa_cli_connected
) {
3975 wpa_cli_connected
= 0;
3976 wpa_cli_exec(action_file
, ifname
, "DISCONNECTED");
3978 } else if (str_starts(pos
, WPA_EVENT_CHANNEL_SWITCH_STARTED
)) {
3979 wpa_cli_exec(action_file
, ctrl_ifname
, pos
);
3980 } else if (str_starts(pos
, AP_EVENT_ENABLED
)) {
3981 wpa_cli_exec(action_file
, ctrl_ifname
, pos
);
3982 } else if (str_starts(pos
, AP_EVENT_DISABLED
)) {
3983 wpa_cli_exec(action_file
, ctrl_ifname
, pos
);
3984 } else if (str_starts(pos
, MESH_GROUP_STARTED
)) {
3985 wpa_cli_exec(action_file
, ctrl_ifname
, pos
);
3986 } else if (str_starts(pos
, MESH_GROUP_REMOVED
)) {
3987 wpa_cli_exec(action_file
, ctrl_ifname
, pos
);
3988 } else if (str_starts(pos
, MESH_PEER_CONNECTED
)) {
3989 wpa_cli_exec(action_file
, ctrl_ifname
, pos
);
3990 } else if (str_starts(pos
, MESH_PEER_DISCONNECTED
)) {
3991 wpa_cli_exec(action_file
, ctrl_ifname
, pos
);
3992 } else if (str_starts(pos
, P2P_EVENT_GROUP_STARTED
)) {
3993 wpa_cli_exec(action_file
, ifname
, pos
);
3994 } else if (str_starts(pos
, P2P_EVENT_GROUP_REMOVED
)) {
3995 wpa_cli_exec(action_file
, ifname
, pos
);
3996 } else if (str_starts(pos
, P2P_EVENT_CROSS_CONNECT_ENABLE
)) {
3997 wpa_cli_exec(action_file
, ifname
, pos
);
3998 } else if (str_starts(pos
, P2P_EVENT_CROSS_CONNECT_DISABLE
)) {
3999 wpa_cli_exec(action_file
, ifname
, pos
);
4000 } else if (str_starts(pos
, P2P_EVENT_GO_NEG_FAILURE
)) {
4001 wpa_cli_exec(action_file
, ifname
, pos
);
4002 } else if (str_starts(pos
, WPS_EVENT_SUCCESS
)) {
4003 wpa_cli_exec(action_file
, ifname
, pos
);
4004 } else if (str_starts(pos
, WPS_EVENT_ACTIVE
)) {
4005 wpa_cli_exec(action_file
, ifname
, pos
);
4006 } else if (str_starts(pos
, WPS_EVENT_TIMEOUT
)) {
4007 wpa_cli_exec(action_file
, ifname
, pos
);
4008 } else if (str_starts(pos
, WPS_EVENT_FAIL
)) {
4009 wpa_cli_exec(action_file
, ifname
, pos
);
4010 } else if (str_starts(pos
, AP_STA_CONNECTED
)) {
4011 wpa_cli_exec(action_file
, ifname
, pos
);
4012 } else if (str_starts(pos
, AP_STA_DISCONNECTED
)) {
4013 wpa_cli_exec(action_file
, ifname
, pos
);
4014 } else if (str_starts(pos
, ESS_DISASSOC_IMMINENT
)) {
4015 wpa_cli_exec(action_file
, ifname
, pos
);
4016 } else if (str_starts(pos
, HS20_SUBSCRIPTION_REMEDIATION
)) {
4017 wpa_cli_exec(action_file
, ifname
, pos
);
4018 } else if (str_starts(pos
, HS20_DEAUTH_IMMINENT_NOTICE
)) {
4019 wpa_cli_exec(action_file
, ifname
, pos
);
4020 } else if (str_starts(pos
, HS20_T_C_ACCEPTANCE
)) {
4021 wpa_cli_exec(action_file
, ifname
, pos
);
4022 } else if (str_starts(pos
, DPP_EVENT_CONF_RECEIVED
)) {
4023 wpa_cli_exec(action_file
, ifname
, pos
);
4024 } else if (str_starts(pos
, DPP_EVENT_CONFOBJ_AKM
)) {
4025 wpa_cli_exec(action_file
, ifname
, pos
);
4026 } else if (str_starts(pos
, DPP_EVENT_CONFOBJ_SSID
)) {
4027 wpa_cli_exec(action_file
, ifname
, pos
);
4028 } else if (str_starts(pos
, DPP_EVENT_CONNECTOR
)) {
4029 wpa_cli_exec(action_file
, ifname
, pos
);
4030 } else if (str_starts(pos
, DPP_EVENT_CONFOBJ_PASS
)) {
4031 wpa_cli_exec(action_file
, ifname
, pos
);
4032 } else if (str_starts(pos
, DPP_EVENT_CONFOBJ_PSK
)) {
4033 wpa_cli_exec(action_file
, ifname
, pos
);
4034 } else if (str_starts(pos
, DPP_EVENT_C_SIGN_KEY
)) {
4035 wpa_cli_exec(action_file
, ifname
, pos
);
4036 } else if (str_starts(pos
, DPP_EVENT_NET_ACCESS_KEY
)) {
4037 wpa_cli_exec(action_file
, ifname
, pos
);
4038 } else if (str_starts(pos
, WPA_EVENT_TERMINATING
)) {
4039 printf("wpa_supplicant is terminating - stop monitoring\n");
4045 #ifndef CONFIG_ANSI_C_EXTRA
4046 static void wpa_cli_action_cb(char *msg
, size_t len
)
4048 wpa_cli_action_process(msg
);
4050 #endif /* CONFIG_ANSI_C_EXTRA */
4053 static int wpa_cli_open_global_ctrl(void)
4055 #ifdef CONFIG_CTRL_IFACE_NAMED_PIPE
4056 ctrl_conn
= wpa_ctrl_open(NULL
);
4057 #else /* CONFIG_CTRL_IFACE_NAMED_PIPE */
4058 ctrl_conn
= wpa_ctrl_open(global
);
4059 #endif /* CONFIG_CTRL_IFACE_NAMED_PIPE */
4062 "Failed to connect to wpa_supplicant global interface: %s error: %s\n",
4063 global
, strerror(errno
));
4068 update_ifnames(ctrl_conn
);
4069 mon_conn
= wpa_ctrl_open(global
);
4071 if (wpa_ctrl_attach(mon_conn
) == 0) {
4072 wpa_cli_attached
= 1;
4073 eloop_register_read_sock(
4074 wpa_ctrl_get_fd(mon_conn
),
4075 wpa_cli_mon_receive
,
4078 printf("Failed to open monitor connection through global control interface\n");
4081 update_stations(ctrl_conn
);
4088 static void wpa_cli_reconnect(void)
4090 wpa_cli_close_connection();
4091 if ((global
&& wpa_cli_open_global_ctrl() < 0) ||
4092 (!global
&& wpa_cli_open_connection(ctrl_ifname
, 1) < 0))
4097 printf("\rConnection to wpa_supplicant re-established\n");
4099 update_stations(ctrl_conn
);
4104 static void cli_event(const char *str
)
4106 const char *start
, *s
;
4108 start
= os_strchr(str
, '>');
4114 if (str_starts(start
, WPA_EVENT_BSS_ADDED
)) {
4115 s
= os_strchr(start
, ' ');
4118 s
= os_strchr(s
+ 1, ' ');
4121 cli_txt_list_add(&bsses
, s
+ 1);
4125 if (str_starts(start
, WPA_EVENT_BSS_REMOVED
)) {
4126 s
= os_strchr(start
, ' ');
4129 s
= os_strchr(s
+ 1, ' ');
4132 cli_txt_list_del_addr(&bsses
, s
+ 1);
4137 if (str_starts(start
, P2P_EVENT_DEVICE_FOUND
)) {
4138 s
= os_strstr(start
, " p2p_dev_addr=");
4141 cli_txt_list_add_addr(&p2p_peers
, s
+ 14);
4145 if (str_starts(start
, P2P_EVENT_DEVICE_LOST
)) {
4146 s
= os_strstr(start
, " p2p_dev_addr=");
4149 cli_txt_list_del_addr(&p2p_peers
, s
+ 14);
4153 if (str_starts(start
, P2P_EVENT_GROUP_STARTED
)) {
4154 s
= os_strchr(start
, ' ');
4157 cli_txt_list_add_word(&p2p_groups
, s
+ 1, ' ');
4161 if (str_starts(start
, P2P_EVENT_GROUP_REMOVED
)) {
4162 s
= os_strchr(start
, ' ');
4165 cli_txt_list_del_word(&p2p_groups
, s
+ 1, ' ');
4168 #endif /* CONFIG_P2P */
4172 static int check_terminating(const char *msg
)
4174 const char *pos
= msg
;
4178 pos
= os_strchr(pos
, '>');
4185 if (str_starts(pos
, WPA_EVENT_TERMINATING
) && ctrl_conn
) {
4187 printf("\rConnection to wpa_supplicant lost - trying to "
4190 wpa_cli_attached
= 0;
4191 wpa_cli_close_connection();
4199 static void wpa_cli_recv_pending(struct wpa_ctrl
*ctrl
, int action_monitor
)
4201 if (ctrl_conn
== NULL
) {
4202 wpa_cli_reconnect();
4205 while (wpa_ctrl_pending(ctrl
) > 0) {
4207 size_t len
= sizeof(buf
) - 1;
4208 if (wpa_ctrl_recv(ctrl
, buf
, &len
) == 0) {
4211 wpa_cli_action_process(buf
);
4214 if (wpa_cli_show_event(buf
)) {
4216 printf("\r%s\n", buf
);
4220 if (interactive
&& check_terminating(buf
) > 0)
4224 printf("Could not read pending message.\n");
4229 if (wpa_ctrl_pending(ctrl
) < 0) {
4230 printf("Connection to wpa_supplicant lost - trying to "
4232 wpa_cli_reconnect();
4237 static void wpa_cli_ping(void *eloop_ctx
, void *timeout_ctx
)
4241 char *prefix
= ifname_prefix
;
4243 ifname_prefix
= NULL
;
4244 res
= _wpa_ctrl_command(ctrl_conn
, "PING", 0);
4245 ifname_prefix
= prefix
;
4247 printf("Connection to wpa_supplicant lost - trying to "
4249 wpa_cli_close_connection();
4253 wpa_cli_reconnect();
4254 eloop_register_timeout(ping_interval
, 0, wpa_cli_ping
, NULL
, NULL
);
4258 static void wpa_cli_mon_receive(int sock
, void *eloop_ctx
, void *sock_ctx
)
4260 wpa_cli_recv_pending(mon_conn
, 0);
4264 static void wpa_cli_edit_cmd_cb(void *ctx
, char *cmd
)
4266 char *argv
[max_args
];
4268 argc
= tokenize_cmd(cmd
, argv
);
4270 wpa_request(ctrl_conn
, argc
, argv
);
4274 static void wpa_cli_edit_eof_cb(void *ctx
)
4280 static int warning_displayed
= 0;
4281 static char *hfile
= NULL
;
4282 static int edit_started
= 0;
4284 static void start_edit(void)
4289 #ifdef CONFIG_CTRL_IFACE_UDP_REMOTE
4290 ps
= wpa_ctrl_get_remote_ifname(ctrl_conn
);
4291 #endif /* CONFIG_CTRL_IFACE_UDP_REMOTE */
4293 #ifdef CONFIG_WPA_CLI_HISTORY_DIR
4294 home
= CONFIG_WPA_CLI_HISTORY_DIR
;
4295 #else /* CONFIG_WPA_CLI_HISTORY_DIR */
4296 home
= getenv("HOME");
4297 #endif /* CONFIG_WPA_CLI_HISTORY_DIR */
4299 const char *fname
= ".wpa_cli_history";
4300 int hfile_len
= os_strlen(home
) + 1 + os_strlen(fname
) + 1;
4301 hfile
= os_malloc(hfile_len
);
4303 os_snprintf(hfile
, hfile_len
, "%s/%s", home
, fname
);
4306 if (edit_init(wpa_cli_edit_cmd_cb
, wpa_cli_edit_eof_cb
,
4307 wpa_cli_edit_completion_cb
, NULL
, hfile
, ps
) < 0) {
4313 eloop_register_timeout(ping_interval
, 0, wpa_cli_ping
, NULL
, NULL
);
4317 static void update_bssid_list(struct wpa_ctrl
*ctrl
)
4320 size_t len
= sizeof(buf
);
4322 const char *cmd
= "BSS RANGE=ALL MASK=0x2";
4327 ret
= wpa_ctrl_request(ctrl
, cmd
, os_strlen(cmd
), buf
, &len
, NULL
);
4334 pos
= os_strstr(pos
, "bssid=");
4338 end
= os_strchr(pos
, '\n');
4342 cli_txt_list_add(&bsses
, pos
);
4348 static void update_ifnames(struct wpa_ctrl
*ctrl
)
4351 size_t len
= sizeof(buf
);
4353 const char *cmd
= "INTERFACES";
4357 cli_txt_list_flush(&ifnames
);
4361 ret
= wpa_ctrl_request(ctrl
, cmd
, os_strlen(cmd
), buf
, &len
, NULL
);
4368 end
= os_strchr(pos
, '\n');
4372 ret
= os_snprintf(txt
, sizeof(txt
), "ifname=%s", pos
);
4373 if (!os_snprintf_error(sizeof(txt
), ret
))
4374 cli_txt_list_add(&ifnames
, txt
);
4380 static void update_creds(struct wpa_ctrl
*ctrl
)
4383 size_t len
= sizeof(buf
);
4385 const char *cmd
= "LIST_CREDS";
4389 cli_txt_list_flush(&creds
);
4393 ret
= wpa_ctrl_request(ctrl
, cmd
, os_strlen(cmd
), buf
, &len
, NULL
);
4400 end
= os_strchr(pos
, '\n');
4405 cli_txt_list_add_word(&creds
, pos
, '\t');
4412 static void update_networks(struct wpa_ctrl
*ctrl
)
4415 size_t len
= sizeof(buf
);
4417 const char *cmd
= "LIST_NETWORKS";
4421 cli_txt_list_flush(&networks
);
4425 ret
= wpa_ctrl_request(ctrl
, cmd
, os_strlen(cmd
), buf
, &len
, NULL
);
4432 end
= os_strchr(pos
, '\n');
4437 cli_txt_list_add_word(&networks
, pos
, '\t');
4444 static void update_stations(struct wpa_ctrl
*ctrl
)
4447 char addr
[32], cmd
[64];
4449 if (!ctrl
|| !interactive
)
4452 cli_txt_list_flush(&stations
);
4454 if (wpa_ctrl_command_sta(ctrl
, "STA-FIRST", addr
, sizeof(addr
), 0))
4457 if (os_strcmp(addr
, "") != 0)
4458 cli_txt_list_add(&stations
, addr
);
4459 os_snprintf(cmd
, sizeof(cmd
), "STA-NEXT %s", addr
);
4460 } while (wpa_ctrl_command_sta(ctrl
, cmd
, addr
, sizeof(addr
), 0) == 0);
4461 #endif /* CONFIG_AP */
4465 static void try_connection(void *eloop_ctx
, void *timeout_ctx
)
4470 if (ctrl_ifname
== NULL
)
4471 ctrl_ifname
= wpa_cli_get_default_ifname();
4473 if (wpa_cli_open_connection(ctrl_ifname
, 1)) {
4474 if (!warning_displayed
) {
4475 printf("Could not connect to wpa_supplicant: "
4477 ctrl_ifname
? ctrl_ifname
: "(nil)");
4478 warning_displayed
= 1;
4480 eloop_register_timeout(1, 0, try_connection
, NULL
, NULL
);
4484 update_bssid_list(ctrl_conn
);
4485 update_creds(ctrl_conn
);
4486 update_networks(ctrl_conn
);
4487 update_stations(ctrl_conn
);
4489 if (warning_displayed
)
4490 printf("Connection established.\n");
4497 static void wpa_cli_interactive(void)
4499 printf("\nInteractive mode\n\n");
4501 eloop_register_timeout(0, 0, try_connection
, NULL
, NULL
);
4503 eloop_cancel_timeout(try_connection
, NULL
, NULL
);
4505 cli_txt_list_flush(&p2p_peers
);
4506 cli_txt_list_flush(&p2p_groups
);
4507 cli_txt_list_flush(&bsses
);
4508 cli_txt_list_flush(&ifnames
);
4509 cli_txt_list_flush(&creds
);
4510 cli_txt_list_flush(&networks
);
4512 edit_deinit(hfile
, wpa_cli_edit_filter_history_cb
);
4514 eloop_cancel_timeout(wpa_cli_ping
, NULL
, NULL
);
4515 wpa_cli_close_connection();
4519 static void wpa_cli_action_ping(void *eloop_ctx
, void *timeout_ctx
)
4521 struct wpa_ctrl
*ctrl
= eloop_ctx
;
4525 /* verify that connection is still working */
4526 len
= sizeof(buf
) - 1;
4527 if (wpa_ctrl_request(ctrl
, "PING", 4, buf
, &len
,
4528 wpa_cli_action_cb
) < 0 ||
4529 len
< 4 || os_memcmp(buf
, "PONG", 4) != 0) {
4530 printf("wpa_supplicant did not reply to PING command - exiting\n");
4534 eloop_register_timeout(ping_interval
, 0, wpa_cli_action_ping
,
4539 static void wpa_cli_action_receive(int sock
, void *eloop_ctx
, void *sock_ctx
)
4541 struct wpa_ctrl
*ctrl
= eloop_ctx
;
4543 wpa_cli_recv_pending(ctrl
, 1);
4547 static void wpa_cli_action(struct wpa_ctrl
*ctrl
)
4549 #ifdef CONFIG_ANSI_C_EXTRA
4550 /* TODO: ANSI C version(?) */
4551 printf("Action processing not supported in ANSI C build.\n");
4552 #else /* CONFIG_ANSI_C_EXTRA */
4555 fd
= wpa_ctrl_get_fd(ctrl
);
4556 eloop_register_timeout(ping_interval
, 0, wpa_cli_action_ping
,
4558 eloop_register_read_sock(fd
, wpa_cli_action_receive
, ctrl
, NULL
);
4560 eloop_cancel_timeout(wpa_cli_action_ping
, ctrl
, NULL
);
4561 eloop_unregister_read_sock(fd
);
4562 #endif /* CONFIG_ANSI_C_EXTRA */
4566 static void wpa_cli_cleanup(void)
4568 wpa_cli_close_connection();
4570 os_daemonize_terminate(pid_file
);
4572 os_program_deinit();
4576 static void wpa_cli_terminate(int sig
, void *ctx
)
4582 static char * wpa_cli_get_default_ifname(void)
4584 char *ifname
= NULL
;
4587 char ifprop
[PROPERTY_VALUE_MAX
];
4588 if (property_get("wifi.interface", ifprop
, NULL
) != 0) {
4589 ifname
= os_strdup(ifprop
);
4590 printf("Using interface '%s'\n", ifname
? ifname
: "N/A");
4593 #ifdef CONFIG_CTRL_IFACE_UNIX
4594 struct dirent
*dent
;
4595 DIR *dir
= opendir(ctrl_iface_dir
);
4599 while ((dent
= readdir(dir
))) {
4600 #ifdef _DIRENT_HAVE_D_TYPE
4602 * Skip the file if it is not a socket. Also accept
4603 * DT_UNKNOWN (0) in case the C library or underlying
4604 * file system does not support d_type.
4606 if (dent
->d_type
!= DT_SOCK
&& dent
->d_type
!= DT_UNKNOWN
)
4608 #endif /* _DIRENT_HAVE_D_TYPE */
4609 /* Skip current/previous directory and special P2P Device
4611 if (os_strcmp(dent
->d_name
, ".") == 0 ||
4612 os_strcmp(dent
->d_name
, "..") == 0 ||
4613 os_strncmp(dent
->d_name
, "p2p-dev-", 8) == 0)
4615 printf("Selected interface '%s'\n", dent
->d_name
);
4616 ifname
= os_strdup(dent
->d_name
);
4620 #endif /* CONFIG_CTRL_IFACE_UNIX */
4622 #ifdef CONFIG_CTRL_IFACE_NAMED_PIPE
4623 char buf
[4096], *pos
;
4625 struct wpa_ctrl
*ctrl
;
4628 ctrl
= wpa_ctrl_open(NULL
);
4632 len
= sizeof(buf
) - 1;
4633 ret
= wpa_ctrl_request(ctrl
, "INTERFACES", 10, buf
, &len
, NULL
);
4636 pos
= os_strchr(buf
, '\n');
4639 ifname
= os_strdup(buf
);
4641 wpa_ctrl_close(ctrl
);
4642 #endif /* CONFIG_CTRL_IFACE_NAMED_PIPE */
4643 #endif /* ANDROID */
4649 int main(int argc
, char *argv
[])
4655 if (os_program_init())
4659 c
= getopt(argc
, argv
, "a:Bg:G:hi:p:P:s:v");
4664 action_file
= optarg
;
4673 ping_interval
= atoi(optarg
);
4679 printf("%s\n", wpa_cli_version
);
4682 os_free(ctrl_ifname
);
4683 ctrl_ifname
= os_strdup(optarg
);
4686 ctrl_iface_dir
= optarg
;
4692 client_socket_dir
= optarg
;
4700 interactive
= (argc
== optind
) && (action_file
== NULL
);
4703 printf("%s\n\n%s\n\n", wpa_cli_version
, cli_license
);
4708 if (global
&& wpa_cli_open_global_ctrl() < 0)
4711 eloop_register_signal_terminate(wpa_cli_terminate
, NULL
);
4713 if (ctrl_ifname
== NULL
)
4714 ctrl_ifname
= wpa_cli_get_default_ifname();
4717 wpa_cli_interactive();
4720 wpa_cli_open_connection(ctrl_ifname
, 0) < 0) {
4721 fprintf(stderr
, "Failed to connect to non-global "
4722 "ctrl_ifname: %s error: %s\n",
4723 ctrl_ifname
? ctrl_ifname
: "(nil)",
4729 if (wpa_ctrl_attach(ctrl_conn
) == 0) {
4730 wpa_cli_attached
= 1;
4732 printf("Warning: Failed to attach to "
4733 "wpa_supplicant.\n");
4738 if (daemonize
&& os_daemonize(pid_file
) && eloop_sock_requeue())
4742 wpa_cli_action(ctrl_conn
);
4744 ret
= wpa_request(ctrl_conn
, argc
- optind
,
4748 os_free(ctrl_ifname
);
4755 #else /* CONFIG_CTRL_IFACE */
4756 int main(int argc
, char *argv
[])
4758 printf("CONFIG_CTRL_IFACE not defined - wpa_cli disabled\n");
4761 #endif /* CONFIG_CTRL_IFACE */