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",
1436 #ifdef CONFIG_IEEE80211W
1438 #endif /* CONFIG_IEEE80211W */
1439 "mixed_cell", "frequency", "fixed_freq",
1441 "mesh_basic_rates", "dot11MeshMaxRetries",
1442 "dot11MeshRetryTimeout", "dot11MeshConfirmTimeout",
1443 "dot11MeshHoldingTimeout",
1444 #endif /* CONFIG_MESH */
1445 "wpa_ptk_rekey", "bgscan", "ignore_broadcast_ssid",
1447 "go_p2p_dev_addr", "p2p_client_list", "psk_list",
1448 #endif /* CONFIG_P2P */
1449 #ifdef CONFIG_HT_OVERRIDES
1450 "disable_ht", "disable_ht40", "disable_sgi", "disable_ldpc",
1451 "ht40_intolerant", "disable_max_amsdu", "ampdu_factor",
1452 "ampdu_density", "ht_mcs", "rx_stbc", "tx_stbc",
1453 #endif /* CONFIG_HT_OVERRIDES */
1454 #ifdef CONFIG_VHT_OVERRIDES
1455 "disable_vht", "vht_capa", "vht_capa_mask", "vht_rx_mcs_nss_1",
1456 "vht_rx_mcs_nss_2", "vht_rx_mcs_nss_3", "vht_rx_mcs_nss_4",
1457 "vht_rx_mcs_nss_5", "vht_rx_mcs_nss_6", "vht_rx_mcs_nss_7",
1458 "vht_rx_mcs_nss_8", "vht_tx_mcs_nss_1", "vht_tx_mcs_nss_2",
1459 "vht_tx_mcs_nss_3", "vht_tx_mcs_nss_4", "vht_tx_mcs_nss_5",
1460 "vht_tx_mcs_nss_6", "vht_tx_mcs_nss_7", "vht_tx_mcs_nss_8",
1461 #endif /* CONFIG_VHT_OVERRIDES */
1462 "ap_max_inactivity", "dtim_period", "beacon_int",
1463 #ifdef CONFIG_MACSEC
1465 "macsec_integ_only",
1466 "macsec_replay_protect",
1467 "macsec_replay_window",
1470 #endif /* CONFIG_MACSEC */
1472 "update_identifier",
1473 #endif /* CONFIG_HS20 */
1474 "mac_addr", "pbss", "wps_disabled"
1478 static char ** wpa_cli_complete_network(const char *str
, int pos
)
1480 int arg
= get_cmd_arg_num(str
, pos
);
1481 int i
, num_fields
= ARRAY_SIZE(network_fields
);
1486 res
= cli_txt_list_array(&networks
);
1489 res
= os_calloc(num_fields
+ 1, sizeof(char *));
1492 for (i
= 0; i
< num_fields
; i
++) {
1493 res
[i
] = os_strdup(network_fields
[i
]);
1502 static char ** wpa_cli_complete_network_id(const char *str
, int pos
)
1504 int arg
= get_cmd_arg_num(str
, pos
);
1506 return cli_txt_list_array(&networks
);
1511 static int wpa_cli_cmd_dup_network(struct wpa_ctrl
*ctrl
, int argc
,
1515 wpa_cli_show_network_variables();
1520 printf("Invalid DUP_NETWORK command: needs three arguments\n"
1521 "(src netid, dest netid, and variable name)\n");
1525 return wpa_cli_cmd(ctrl
, "DUP_NETWORK", 3, argc
, argv
);
1529 static char ** wpa_cli_complete_dup_network(const char *str
, int pos
)
1531 int arg
= get_cmd_arg_num(str
, pos
);
1532 int i
, num_fields
= ARRAY_SIZE(network_fields
);
1538 res
= cli_txt_list_array(&networks
);
1541 res
= os_calloc(num_fields
+ 1, sizeof(char *));
1544 for (i
= 0; i
< num_fields
; i
++) {
1545 res
[i
] = os_strdup(network_fields
[i
]);
1554 static int wpa_cli_cmd_list_creds(struct wpa_ctrl
*ctrl
, int argc
,
1557 return wpa_ctrl_command(ctrl
, "LIST_CREDS");
1561 static int wpa_cli_cmd_add_cred(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1563 int res
= wpa_ctrl_command(ctrl
, "ADD_CRED");
1570 static int wpa_cli_cmd_remove_cred(struct wpa_ctrl
*ctrl
, int argc
,
1573 int res
= wpa_cli_cmd(ctrl
, "REMOVE_CRED", 1, argc
, argv
);
1580 static const char * const cred_fields
[] = {
1581 "temporary", "priority", "sp_priority", "pcsc", "eap",
1582 "update_identifier", "min_dl_bandwidth_home", "min_ul_bandwidth_home",
1583 "min_dl_bandwidth_roaming", "min_ul_bandwidth_roaming", "max_bss_load",
1584 "req_conn_capab", "ocsp", "sim_num", "realm", "username", "password",
1585 "ca_cert", "client_cert", "private_key", "private_key_passwd", "imsi",
1586 "milenage", "domain_suffix_match", "domain", "phase1", "phase2",
1587 "roaming_consortium", "required_roaming_consortium", "excluded_ssid",
1588 "roaming_partner", "provisioning_sp"
1592 static char ** wpa_cli_complete_cred(const char *str
, int pos
)
1594 int arg
= get_cmd_arg_num(str
, pos
);
1595 int i
, num_fields
= ARRAY_SIZE(cred_fields
);
1600 res
= cli_txt_list_array(&creds
);
1603 res
= os_calloc(num_fields
+ 1, sizeof(char *));
1606 for (i
= 0; i
< num_fields
; i
++) {
1607 res
[i
] = os_strdup(cred_fields
[i
]);
1616 static int wpa_cli_cmd_set_cred(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1619 printf("Invalid SET_CRED command: needs three arguments\n"
1620 "(cred id, variable name, and value)\n");
1624 return wpa_cli_cmd(ctrl
, "SET_CRED", 3, argc
, argv
);
1628 static int wpa_cli_cmd_get_cred(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1631 printf("Invalid GET_CRED command: needs two arguments\n"
1632 "(cred id, variable name)\n");
1636 return wpa_cli_cmd(ctrl
, "GET_CRED", 2, argc
, argv
);
1640 static int wpa_cli_cmd_disconnect(struct wpa_ctrl
*ctrl
, int argc
,
1643 return wpa_ctrl_command(ctrl
, "DISCONNECT");
1647 static int wpa_cli_cmd_reconnect(struct wpa_ctrl
*ctrl
, int argc
,
1650 return wpa_ctrl_command(ctrl
, "RECONNECT");
1654 static int wpa_cli_cmd_save_config(struct wpa_ctrl
*ctrl
, int argc
,
1657 return wpa_ctrl_command(ctrl
, "SAVE_CONFIG");
1661 static int wpa_cli_cmd_scan(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1663 return wpa_cli_cmd(ctrl
, "SCAN", 0, argc
, argv
);
1667 static int wpa_cli_cmd_scan_results(struct wpa_ctrl
*ctrl
, int argc
,
1670 return wpa_ctrl_command(ctrl
, "SCAN_RESULTS");
1674 static int wpa_cli_cmd_abort_scan(struct wpa_ctrl
*ctrl
, int argc
,
1677 return wpa_ctrl_command(ctrl
, "ABORT_SCAN");
1681 static int wpa_cli_cmd_bss(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1683 return wpa_cli_cmd(ctrl
, "BSS", 1, argc
, argv
);
1687 static char ** wpa_cli_complete_bss(const char *str
, int pos
)
1689 int arg
= get_cmd_arg_num(str
, pos
);
1694 res
= cli_txt_list_array(&bsses
);
1702 static int wpa_cli_cmd_get_capability(struct wpa_ctrl
*ctrl
, int argc
,
1705 if (argc
< 1 || argc
> 2) {
1706 printf("Invalid GET_CAPABILITY command: need either one or "
1711 if ((argc
== 2) && os_strcmp(argv
[1], "strict") != 0) {
1712 printf("Invalid GET_CAPABILITY command: second argument, "
1713 "if any, must be 'strict'\n");
1717 return wpa_cli_cmd(ctrl
, "GET_CAPABILITY", 1, argc
, argv
);
1721 static char ** wpa_cli_complete_get_capability(const char *str
, int pos
)
1723 int arg
= get_cmd_arg_num(str
, pos
);
1724 const char *fields
[] = {
1725 "eap", "pairwise", "group", "group_mgmt", "key_mgmt",
1726 "proto", "auth_alg", "modes", "channels", "freq",
1729 #endif /* CONFIG_TDLS */
1732 #endif /* CONFIG_ERP */
1735 #endif /* CONFIG_FIPS */
1738 #endif /* CONFIG_ACS */
1740 int i
, num_fields
= ARRAY_SIZE(fields
);
1744 res
= os_calloc(num_fields
+ 1, sizeof(char *));
1747 for (i
= 0; i
< num_fields
; i
++) {
1748 res
[i
] = os_strdup(fields
[i
]);
1754 res
= os_calloc(1 + 1, sizeof(char *));
1757 res
[0] = os_strdup("strict");
1763 static int wpa_cli_list_interfaces(struct wpa_ctrl
*ctrl
)
1765 printf("Available interfaces:\n");
1766 return wpa_ctrl_command(ctrl
, "INTERFACES");
1770 static int wpa_cli_cmd_interface(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1773 wpa_cli_list_interfaces(ctrl
);
1777 wpa_cli_close_connection();
1778 os_free(ctrl_ifname
);
1779 ctrl_ifname
= os_strdup(argv
[0]);
1781 printf("Failed to allocate memory\n");
1785 if (wpa_cli_open_connection(ctrl_ifname
, 1) == 0) {
1786 printf("Connected to interface '%s.\n", ctrl_ifname
);
1788 printf("Could not connect to interface '%s' - re-trying\n",
1795 static int wpa_cli_cmd_reconfigure(struct wpa_ctrl
*ctrl
, int argc
,
1798 return wpa_ctrl_command(ctrl
, "RECONFIGURE");
1802 static int wpa_cli_cmd_terminate(struct wpa_ctrl
*ctrl
, int argc
,
1805 return wpa_ctrl_command(ctrl
, "TERMINATE");
1809 static int wpa_cli_cmd_interface_add(struct wpa_ctrl
*ctrl
, int argc
,
1816 printf("Invalid INTERFACE_ADD command: needs at least one "
1817 "argument (interface name)\n"
1818 "All arguments: ifname confname driver ctrl_interface "
1819 "driver_param bridge_name [create]\n");
1824 * INTERFACE_ADD <ifname>TAB<confname>TAB<driver>TAB<ctrl_interface>TAB
1825 * <driver_param>TAB<bridge_name>[TAB<create>[TAB<type>]]
1827 res
= os_snprintf(cmd
, sizeof(cmd
),
1828 "INTERFACE_ADD %s\t%s\t%s\t%s\t%s\t%s\t%s\t%s",
1830 argc
> 1 ? argv
[1] : "", argc
> 2 ? argv
[2] : "",
1831 argc
> 3 ? argv
[3] : "", argc
> 4 ? argv
[4] : "",
1832 argc
> 5 ? argv
[5] : "", argc
> 6 ? argv
[6] : "",
1833 argc
> 7 ? argv
[7] : "");
1834 if (os_snprintf_error(sizeof(cmd
), res
))
1836 cmd
[sizeof(cmd
) - 1] = '\0';
1837 return wpa_ctrl_command(ctrl
, cmd
);
1841 static int wpa_cli_cmd_interface_remove(struct wpa_ctrl
*ctrl
, int argc
,
1844 return wpa_cli_cmd(ctrl
, "INTERFACE_REMOVE", 1, argc
, argv
);
1848 static int wpa_cli_cmd_interface_list(struct wpa_ctrl
*ctrl
, int argc
,
1851 return wpa_ctrl_command(ctrl
, "INTERFACE_LIST");
1856 static int wpa_cli_cmd_sta(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1858 return wpa_cli_cmd(ctrl
, "STA", 1, argc
, argv
);
1862 static char ** wpa_cli_complete_sta(const char *str
, int pos
)
1864 int arg
= get_cmd_arg_num(str
, pos
);
1869 res
= cli_txt_list_array(&stations
);
1877 static int wpa_ctrl_command_sta(struct wpa_ctrl
*ctrl
, const char *cmd
,
1878 char *addr
, size_t addr_len
, int print
)
1880 char buf
[4096], *pos
;
1884 if (ctrl_conn
== NULL
) {
1885 printf("Not connected to hostapd - command dropped.\n");
1888 if (ifname_prefix
) {
1889 os_snprintf(buf
, sizeof(buf
), "IFNAME=%s %s",
1890 ifname_prefix
, cmd
);
1891 buf
[sizeof(buf
) - 1] = '\0';
1894 len
= sizeof(buf
) - 1;
1895 ret
= wpa_ctrl_request(ctrl
, cmd
, os_strlen(cmd
), buf
, &len
,
1898 printf("'%s' command timed out.\n", cmd
);
1900 } else if (ret
< 0) {
1901 printf("'%s' command failed.\n", cmd
);
1906 if (os_memcmp(buf
, "FAIL", 4) == 0 ||
1907 os_memcmp(buf
, "UNKNOWN COMMAND", 15) == 0)
1913 while (*pos
!= '\0' && *pos
!= '\n')
1916 os_strlcpy(addr
, buf
, addr_len
);
1921 static int wpa_cli_cmd_all_sta(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1923 char addr
[32], cmd
[64];
1925 if (wpa_ctrl_command_sta(ctrl
, "STA-FIRST", addr
, sizeof(addr
), 1))
1928 os_snprintf(cmd
, sizeof(cmd
), "STA-NEXT %s", addr
);
1929 } while (wpa_ctrl_command_sta(ctrl
, cmd
, addr
, sizeof(addr
), 1) == 0);
1935 static int wpa_cli_cmd_list_sta(struct wpa_ctrl
*ctrl
, int argc
,
1938 char addr
[32], cmd
[64];
1940 if (wpa_ctrl_command_sta(ctrl
, "STA-FIRST", addr
, sizeof(addr
), 0))
1943 if (os_strcmp(addr
, "") != 0)
1944 printf("%s\n", addr
);
1945 os_snprintf(cmd
, sizeof(cmd
), "STA-NEXT %s", addr
);
1946 } while (wpa_ctrl_command_sta(ctrl
, cmd
, addr
, sizeof(addr
), 0) == 0);
1952 static int wpa_cli_cmd_deauthenticate(struct wpa_ctrl
*ctrl
, int argc
,
1955 return wpa_cli_cmd(ctrl
, "DEAUTHENTICATE", 1, argc
, argv
);
1959 static char ** wpa_cli_complete_deauthenticate(const char *str
, int pos
)
1961 int arg
= get_cmd_arg_num(str
, pos
);
1966 res
= cli_txt_list_array(&stations
);
1974 static int wpa_cli_cmd_disassociate(struct wpa_ctrl
*ctrl
, int argc
,
1977 return wpa_cli_cmd(ctrl
, "DISASSOCIATE", 1, argc
, argv
);
1981 static char ** wpa_cli_complete_disassociate(const char *str
, int pos
)
1983 int arg
= get_cmd_arg_num(str
, pos
);
1988 res
= cli_txt_list_array(&stations
);
1996 static int wpa_cli_cmd_chanswitch(struct wpa_ctrl
*ctrl
, int argc
,
1999 return wpa_cli_cmd(ctrl
, "CHAN_SWITCH", 2, argc
, argv
);
2002 #endif /* CONFIG_AP */
2005 static int wpa_cli_cmd_suspend(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2007 return wpa_ctrl_command(ctrl
, "SUSPEND");
2011 static int wpa_cli_cmd_resume(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2013 return wpa_ctrl_command(ctrl
, "RESUME");
2017 #ifdef CONFIG_TESTING_OPTIONS
2018 static int wpa_cli_cmd_drop_sa(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2020 return wpa_ctrl_command(ctrl
, "DROP_SA");
2022 #endif /* CONFIG_TESTING_OPTIONS */
2025 static int wpa_cli_cmd_roam(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2027 return wpa_cli_cmd(ctrl
, "ROAM", 1, argc
, argv
);
2033 static int wpa_cli_cmd_mesh_interface_add(struct wpa_ctrl
*ctrl
, int argc
,
2036 return wpa_cli_cmd(ctrl
, "MESH_INTERFACE_ADD", 0, argc
, argv
);
2040 static int wpa_cli_cmd_mesh_group_add(struct wpa_ctrl
*ctrl
, int argc
,
2043 return wpa_cli_cmd(ctrl
, "MESH_GROUP_ADD", 1, argc
, argv
);
2047 static int wpa_cli_cmd_mesh_group_remove(struct wpa_ctrl
*ctrl
, int argc
,
2050 return wpa_cli_cmd(ctrl
, "MESH_GROUP_REMOVE", 1, argc
, argv
);
2054 static int wpa_cli_cmd_mesh_peer_remove(struct wpa_ctrl
*ctrl
, int argc
,
2057 return wpa_cli_cmd(ctrl
, "MESH_PEER_REMOVE", 1, argc
, argv
);
2061 static int wpa_cli_cmd_mesh_peer_add(struct wpa_ctrl
*ctrl
, int argc
,
2064 return wpa_cli_cmd(ctrl
, "MESH_PEER_ADD", 1, argc
, argv
);
2067 #endif /* CONFIG_MESH */
2072 static int wpa_cli_cmd_p2p_find(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2074 return wpa_cli_cmd(ctrl
, "P2P_FIND", 0, argc
, argv
);
2078 static char ** wpa_cli_complete_p2p_find(const char *str
, int pos
)
2081 int arg
= get_cmd_arg_num(str
, pos
);
2083 res
= os_calloc(6, sizeof(char *));
2086 res
[0] = os_strdup("type=social");
2087 if (res
[0] == NULL
) {
2091 res
[1] = os_strdup("type=progressive");
2094 res
[2] = os_strdup("delay=");
2097 res
[3] = os_strdup("dev_id=");
2101 res
[4] = os_strdup("[timeout]");
2107 static int wpa_cli_cmd_p2p_stop_find(struct wpa_ctrl
*ctrl
, int argc
,
2110 return wpa_ctrl_command(ctrl
, "P2P_STOP_FIND");
2114 static int wpa_cli_cmd_p2p_asp_provision(struct wpa_ctrl
*ctrl
, int argc
,
2117 return wpa_cli_cmd(ctrl
, "P2P_ASP_PROVISION", 3, argc
, argv
);
2121 static int wpa_cli_cmd_p2p_asp_provision_resp(struct wpa_ctrl
*ctrl
, int argc
,
2124 return wpa_cli_cmd(ctrl
, "P2P_ASP_PROVISION_RESP", 2, argc
, argv
);
2128 static int wpa_cli_cmd_p2p_connect(struct wpa_ctrl
*ctrl
, int argc
,
2131 return wpa_cli_cmd(ctrl
, "P2P_CONNECT", 2, argc
, argv
);
2135 static char ** wpa_cli_complete_p2p_connect(const char *str
, int pos
)
2137 int arg
= get_cmd_arg_num(str
, pos
);
2142 res
= cli_txt_list_array(&p2p_peers
);
2150 static int wpa_cli_cmd_p2p_listen(struct wpa_ctrl
*ctrl
, int argc
,
2153 return wpa_cli_cmd(ctrl
, "P2P_LISTEN", 0, argc
, argv
);
2157 static int wpa_cli_cmd_p2p_group_remove(struct wpa_ctrl
*ctrl
, int argc
,
2160 return wpa_cli_cmd(ctrl
, "P2P_GROUP_REMOVE", 1, argc
, argv
);
2164 static char ** wpa_cli_complete_p2p_group_remove(const char *str
, int pos
)
2166 int arg
= get_cmd_arg_num(str
, pos
);
2171 res
= cli_txt_list_array(&p2p_groups
);
2179 static int wpa_cli_cmd_p2p_group_add(struct wpa_ctrl
*ctrl
, int argc
,
2182 return wpa_cli_cmd(ctrl
, "P2P_GROUP_ADD", 0, argc
, argv
);
2186 static int wpa_cli_cmd_p2p_group_member(struct wpa_ctrl
*ctrl
, int argc
,
2189 return wpa_cli_cmd(ctrl
, "P2P_GROUP_MEMBER", 1, argc
, argv
);
2193 static int wpa_cli_cmd_p2p_prov_disc(struct wpa_ctrl
*ctrl
, int argc
,
2196 if (argc
!= 2 && argc
!= 3) {
2197 printf("Invalid P2P_PROV_DISC command: needs at least "
2198 "two arguments, address and config method\n"
2199 "(display, keypad, or pbc) and an optional join\n");
2203 return wpa_cli_cmd(ctrl
, "P2P_PROV_DISC", 2, argc
, argv
);
2207 static int wpa_cli_cmd_p2p_get_passphrase(struct wpa_ctrl
*ctrl
, int argc
,
2210 return wpa_ctrl_command(ctrl
, "P2P_GET_PASSPHRASE");
2214 static int wpa_cli_cmd_p2p_serv_disc_req(struct wpa_ctrl
*ctrl
, int argc
,
2220 printf("Invalid P2P_SERV_DISC_REQ command: needs two "
2221 "or more arguments (address and TLVs)\n");
2225 if (write_cmd(cmd
, sizeof(cmd
), "P2P_SERV_DISC_REQ", argc
, argv
) < 0)
2227 return wpa_ctrl_command(ctrl
, cmd
);
2231 static int wpa_cli_cmd_p2p_serv_disc_cancel_req(struct wpa_ctrl
*ctrl
,
2232 int argc
, char *argv
[])
2234 return wpa_cli_cmd(ctrl
, "P2P_SERV_DISC_CANCEL_REQ", 1, argc
, argv
);
2238 static int wpa_cli_cmd_p2p_serv_disc_resp(struct wpa_ctrl
*ctrl
, int argc
,
2245 printf("Invalid P2P_SERV_DISC_RESP command: needs four "
2246 "arguments (freq, address, dialog token, and TLVs)\n");
2250 res
= os_snprintf(cmd
, sizeof(cmd
), "P2P_SERV_DISC_RESP %s %s %s %s",
2251 argv
[0], argv
[1], argv
[2], argv
[3]);
2252 if (os_snprintf_error(sizeof(cmd
), res
))
2254 cmd
[sizeof(cmd
) - 1] = '\0';
2255 return wpa_ctrl_command(ctrl
, cmd
);
2259 static int wpa_cli_cmd_p2p_service_update(struct wpa_ctrl
*ctrl
, int argc
,
2262 return wpa_ctrl_command(ctrl
, "P2P_SERVICE_UPDATE");
2266 static int wpa_cli_cmd_p2p_serv_disc_external(struct wpa_ctrl
*ctrl
,
2267 int argc
, char *argv
[])
2269 return wpa_cli_cmd(ctrl
, "P2P_SERV_DISC_EXTERNAL", 1, argc
, argv
);
2273 static int wpa_cli_cmd_p2p_service_flush(struct wpa_ctrl
*ctrl
, int argc
,
2276 return wpa_ctrl_command(ctrl
, "P2P_SERVICE_FLUSH");
2280 static int wpa_cli_cmd_p2p_service_add(struct wpa_ctrl
*ctrl
, int argc
,
2284 printf("Invalid P2P_SERVICE_ADD command: needs 3-6 arguments\n");
2288 return wpa_cli_cmd(ctrl
, "P2P_SERVICE_ADD", 3, argc
, argv
);
2292 static int wpa_cli_cmd_p2p_service_rep(struct wpa_ctrl
*ctrl
, int argc
,
2295 if (argc
< 5 || argc
> 6) {
2296 printf("Invalid P2P_SERVICE_REP command: needs 5-6 "
2301 return wpa_cli_cmd(ctrl
, "P2P_SERVICE_REP", 5, argc
, argv
);
2305 static int wpa_cli_cmd_p2p_service_del(struct wpa_ctrl
*ctrl
, int argc
,
2311 if (argc
!= 2 && argc
!= 3) {
2312 printf("Invalid P2P_SERVICE_DEL command: needs two or three "
2318 res
= os_snprintf(cmd
, sizeof(cmd
),
2319 "P2P_SERVICE_DEL %s %s %s",
2320 argv
[0], argv
[1], argv
[2]);
2322 res
= os_snprintf(cmd
, sizeof(cmd
),
2323 "P2P_SERVICE_DEL %s %s",
2325 if (os_snprintf_error(sizeof(cmd
), res
))
2327 cmd
[sizeof(cmd
) - 1] = '\0';
2328 return wpa_ctrl_command(ctrl
, cmd
);
2332 static int wpa_cli_cmd_p2p_reject(struct wpa_ctrl
*ctrl
,
2333 int argc
, char *argv
[])
2335 return wpa_cli_cmd(ctrl
, "P2P_REJECT", 1, argc
, argv
);
2339 static int wpa_cli_cmd_p2p_invite(struct wpa_ctrl
*ctrl
,
2340 int argc
, char *argv
[])
2342 return wpa_cli_cmd(ctrl
, "P2P_INVITE", 1, argc
, argv
);
2346 static int wpa_cli_cmd_p2p_peer(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2348 return wpa_cli_cmd(ctrl
, "P2P_PEER", 1, argc
, argv
);
2352 static char ** wpa_cli_complete_p2p_peer(const char *str
, int pos
)
2354 int arg
= get_cmd_arg_num(str
, pos
);
2359 res
= cli_txt_list_array(&p2p_peers
);
2367 static int wpa_ctrl_command_p2p_peer(struct wpa_ctrl
*ctrl
, const char *cmd
,
2368 char *addr
, size_t addr_len
,
2371 char buf
[4096], *pos
;
2375 if (ctrl_conn
== NULL
)
2377 len
= sizeof(buf
) - 1;
2378 ret
= wpa_ctrl_request(ctrl
, cmd
, os_strlen(cmd
), buf
, &len
,
2381 printf("'%s' command timed out.\n", cmd
);
2383 } else if (ret
< 0) {
2384 printf("'%s' command failed.\n", cmd
);
2389 if (os_memcmp(buf
, "FAIL", 4) == 0)
2393 while (*pos
!= '\0' && *pos
!= '\n')
2396 os_strlcpy(addr
, buf
, addr_len
);
2397 if (!discovered
|| os_strstr(pos
, "[PROBE_REQ_ONLY]") == NULL
)
2398 printf("%s\n", addr
);
2403 static int wpa_cli_cmd_p2p_peers(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2405 char addr
[32], cmd
[64];
2408 discovered
= argc
> 0 && os_strcmp(argv
[0], "discovered") == 0;
2410 if (wpa_ctrl_command_p2p_peer(ctrl
, "P2P_PEER FIRST",
2411 addr
, sizeof(addr
), discovered
))
2414 os_snprintf(cmd
, sizeof(cmd
), "P2P_PEER NEXT-%s", addr
);
2415 } while (wpa_ctrl_command_p2p_peer(ctrl
, cmd
, addr
, sizeof(addr
),
2422 static int wpa_cli_cmd_p2p_set(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2424 return wpa_cli_cmd(ctrl
, "P2P_SET", 2, argc
, argv
);
2428 static char ** wpa_cli_complete_p2p_set(const char *str
, int pos
)
2430 int arg
= get_cmd_arg_num(str
, pos
);
2431 const char *fields
[] = {
2451 int i
, num_fields
= ARRAY_SIZE(fields
);
2454 char **res
= os_calloc(num_fields
+ 1, sizeof(char *));
2457 for (i
= 0; i
< num_fields
; i
++) {
2458 res
[i
] = os_strdup(fields
[i
]);
2465 if (arg
== 2 && os_strncasecmp(str
, "p2p_set peer_filter ", 20) == 0)
2466 return cli_txt_list_array(&p2p_peers
);
2472 static int wpa_cli_cmd_p2p_flush(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2474 return wpa_ctrl_command(ctrl
, "P2P_FLUSH");
2478 static int wpa_cli_cmd_p2p_cancel(struct wpa_ctrl
*ctrl
, int argc
,
2481 return wpa_ctrl_command(ctrl
, "P2P_CANCEL");
2485 static int wpa_cli_cmd_p2p_unauthorize(struct wpa_ctrl
*ctrl
, int argc
,
2488 return wpa_cli_cmd(ctrl
, "P2P_UNAUTHORIZE", 1, argc
, argv
);
2492 static int wpa_cli_cmd_p2p_presence_req(struct wpa_ctrl
*ctrl
, int argc
,
2495 if (argc
!= 0 && argc
!= 2 && argc
!= 4) {
2496 printf("Invalid P2P_PRESENCE_REQ command: needs two arguments "
2497 "(preferred duration, interval; in microsecods).\n"
2498 "Optional second pair can be used to provide "
2499 "acceptable values.\n");
2503 return wpa_cli_cmd(ctrl
, "P2P_PRESENCE_REQ", 0, argc
, argv
);
2507 static int wpa_cli_cmd_p2p_ext_listen(struct wpa_ctrl
*ctrl
, int argc
,
2510 if (argc
!= 0 && argc
!= 2) {
2511 printf("Invalid P2P_EXT_LISTEN command: needs two arguments "
2512 "(availability period, availability interval; in "
2514 "Extended Listen Timing can be cancelled with this "
2515 "command when used without parameters.\n");
2519 return wpa_cli_cmd(ctrl
, "P2P_EXT_LISTEN", 0, argc
, argv
);
2523 static int wpa_cli_cmd_p2p_remove_client(struct wpa_ctrl
*ctrl
, int argc
,
2526 return wpa_cli_cmd(ctrl
, "P2P_REMOVE_CLIENT", 1, argc
, argv
);
2529 #endif /* CONFIG_P2P */
2532 static int wpa_cli_cmd_vendor_elem_add(struct wpa_ctrl
*ctrl
, int argc
,
2535 return wpa_cli_cmd(ctrl
, "VENDOR_ELEM_ADD", 2, argc
, argv
);
2539 static int wpa_cli_cmd_vendor_elem_get(struct wpa_ctrl
*ctrl
, int argc
,
2542 return wpa_cli_cmd(ctrl
, "VENDOR_ELEM_GET", 1, argc
, argv
);
2546 static int wpa_cli_cmd_vendor_elem_remove(struct wpa_ctrl
*ctrl
, int argc
,
2549 return wpa_cli_cmd(ctrl
, "VENDOR_ELEM_REMOVE", 2, argc
, argv
);
2553 #ifdef CONFIG_WIFI_DISPLAY
2555 static int wpa_cli_cmd_wfd_subelem_set(struct wpa_ctrl
*ctrl
, int argc
,
2561 if (argc
!= 1 && argc
!= 2) {
2562 printf("Invalid WFD_SUBELEM_SET command: needs one or two "
2563 "arguments (subelem, hexdump)\n");
2567 res
= os_snprintf(cmd
, sizeof(cmd
), "WFD_SUBELEM_SET %s %s",
2568 argv
[0], argc
> 1 ? argv
[1] : "");
2569 if (os_snprintf_error(sizeof(cmd
), res
))
2571 cmd
[sizeof(cmd
) - 1] = '\0';
2572 return wpa_ctrl_command(ctrl
, cmd
);
2576 static int wpa_cli_cmd_wfd_subelem_get(struct wpa_ctrl
*ctrl
, int argc
,
2583 printf("Invalid WFD_SUBELEM_GET command: needs one "
2584 "argument (subelem)\n");
2588 res
= os_snprintf(cmd
, sizeof(cmd
), "WFD_SUBELEM_GET %s",
2590 if (os_snprintf_error(sizeof(cmd
), res
))
2592 cmd
[sizeof(cmd
) - 1] = '\0';
2593 return wpa_ctrl_command(ctrl
, cmd
);
2595 #endif /* CONFIG_WIFI_DISPLAY */
2598 #ifdef CONFIG_INTERWORKING
2599 static int wpa_cli_cmd_fetch_anqp(struct wpa_ctrl
*ctrl
, int argc
,
2602 return wpa_ctrl_command(ctrl
, "FETCH_ANQP");
2606 static int wpa_cli_cmd_stop_fetch_anqp(struct wpa_ctrl
*ctrl
, int argc
,
2609 return wpa_ctrl_command(ctrl
, "STOP_FETCH_ANQP");
2613 static int wpa_cli_cmd_interworking_select(struct wpa_ctrl
*ctrl
, int argc
,
2616 return wpa_cli_cmd(ctrl
, "INTERWORKING_SELECT", 0, argc
, argv
);
2620 static int wpa_cli_cmd_interworking_connect(struct wpa_ctrl
*ctrl
, int argc
,
2623 return wpa_cli_cmd(ctrl
, "INTERWORKING_CONNECT", 1, argc
, argv
);
2627 static int wpa_cli_cmd_interworking_add_network(struct wpa_ctrl
*ctrl
, int argc
,
2630 return wpa_cli_cmd(ctrl
, "INTERWORKING_ADD_NETWORK", 1, argc
, argv
);
2634 static int wpa_cli_cmd_anqp_get(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2636 return wpa_cli_cmd(ctrl
, "ANQP_GET", 2, argc
, argv
);
2640 static int wpa_cli_cmd_gas_request(struct wpa_ctrl
*ctrl
, int argc
,
2643 return wpa_cli_cmd(ctrl
, "GAS_REQUEST", 2, argc
, argv
);
2647 static int wpa_cli_cmd_gas_response_get(struct wpa_ctrl
*ctrl
, int argc
,
2650 return wpa_cli_cmd(ctrl
, "GAS_RESPONSE_GET", 2, argc
, argv
);
2652 #endif /* CONFIG_INTERWORKING */
2657 static int wpa_cli_cmd_hs20_anqp_get(struct wpa_ctrl
*ctrl
, int argc
,
2660 return wpa_cli_cmd(ctrl
, "HS20_ANQP_GET", 2, argc
, argv
);
2664 static int wpa_cli_cmd_get_nai_home_realm_list(struct wpa_ctrl
*ctrl
, int argc
,
2670 printf("Command needs one or two arguments (dst mac addr and "
2671 "optional home realm)\n");
2675 if (write_cmd(cmd
, sizeof(cmd
), "HS20_GET_NAI_HOME_REALM_LIST",
2679 return wpa_ctrl_command(ctrl
, cmd
);
2683 static int wpa_cli_cmd_hs20_icon_request(struct wpa_ctrl
*ctrl
, int argc
,
2689 printf("Command needs two arguments (dst mac addr and "
2694 if (write_cmd(cmd
, sizeof(cmd
), "HS20_ICON_REQUEST", argc
, argv
) < 0)
2697 return wpa_ctrl_command(ctrl
, cmd
);
2701 static int wpa_cli_cmd_fetch_osu(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2703 return wpa_ctrl_command(ctrl
, "FETCH_OSU");
2707 static int wpa_cli_cmd_cancel_fetch_osu(struct wpa_ctrl
*ctrl
, int argc
,
2710 return wpa_ctrl_command(ctrl
, "CANCEL_FETCH_OSU");
2713 #endif /* CONFIG_HS20 */
2716 static int wpa_cli_cmd_sta_autoconnect(struct wpa_ctrl
*ctrl
, int argc
,
2719 return wpa_cli_cmd(ctrl
, "STA_AUTOCONNECT", 1, argc
, argv
);
2723 static int wpa_cli_cmd_tdls_discover(struct wpa_ctrl
*ctrl
, int argc
,
2726 return wpa_cli_cmd(ctrl
, "TDLS_DISCOVER", 1, argc
, argv
);
2730 static int wpa_cli_cmd_tdls_setup(struct wpa_ctrl
*ctrl
, int argc
,
2733 return wpa_cli_cmd(ctrl
, "TDLS_SETUP", 1, argc
, argv
);
2737 static int wpa_cli_cmd_tdls_teardown(struct wpa_ctrl
*ctrl
, int argc
,
2740 return wpa_cli_cmd(ctrl
, "TDLS_TEARDOWN", 1, argc
, argv
);
2744 static int wpa_cli_cmd_tdls_link_status(struct wpa_ctrl
*ctrl
, int argc
,
2747 return wpa_cli_cmd(ctrl
, "TDLS_LINK_STATUS", 1, argc
, argv
);
2751 static int wpa_cli_cmd_wmm_ac_addts(struct wpa_ctrl
*ctrl
, int argc
,
2754 return wpa_cli_cmd(ctrl
, "WMM_AC_ADDTS", 3, argc
, argv
);
2758 static int wpa_cli_cmd_wmm_ac_delts(struct wpa_ctrl
*ctrl
, int argc
,
2761 return wpa_cli_cmd(ctrl
, "WMM_AC_DELTS", 1, argc
, argv
);
2765 static int wpa_cli_cmd_wmm_ac_status(struct wpa_ctrl
*ctrl
, int argc
,
2768 return wpa_ctrl_command(ctrl
, "WMM_AC_STATUS");
2772 static int wpa_cli_cmd_tdls_chan_switch(struct wpa_ctrl
*ctrl
, int argc
,
2775 return wpa_cli_cmd(ctrl
, "TDLS_CHAN_SWITCH", 2, argc
, argv
);
2779 static int wpa_cli_cmd_tdls_cancel_chan_switch(struct wpa_ctrl
*ctrl
, int argc
,
2782 return wpa_cli_cmd(ctrl
, "TDLS_CANCEL_CHAN_SWITCH", 1, argc
, argv
);
2786 static int wpa_cli_cmd_signal_poll(struct wpa_ctrl
*ctrl
, int argc
,
2789 return wpa_ctrl_command(ctrl
, "SIGNAL_POLL");
2793 static int wpa_cli_cmd_signal_monitor(struct wpa_ctrl
*ctrl
, int argc
,
2796 return wpa_cli_cmd(ctrl
, "SIGNAL_MONITOR", 0, argc
, argv
);
2800 static int wpa_cli_cmd_pktcnt_poll(struct wpa_ctrl
*ctrl
, int argc
,
2803 return wpa_ctrl_command(ctrl
, "PKTCNT_POLL");
2807 static int wpa_cli_cmd_reauthenticate(struct wpa_ctrl
*ctrl
, int argc
,
2810 return wpa_ctrl_command(ctrl
, "REAUTHENTICATE");
2814 #ifdef CONFIG_AUTOSCAN
2816 static int wpa_cli_cmd_autoscan(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2819 return wpa_ctrl_command(ctrl
, "AUTOSCAN ");
2821 return wpa_cli_cmd(ctrl
, "AUTOSCAN", 0, argc
, argv
);
2824 #endif /* CONFIG_AUTOSCAN */
2829 static int wpa_cli_cmd_wnm_sleep(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2831 return wpa_cli_cmd(ctrl
, "WNM_SLEEP", 0, argc
, argv
);
2835 static int wpa_cli_cmd_wnm_bss_query(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2837 return wpa_cli_cmd(ctrl
, "WNM_BSS_QUERY", 1, argc
, argv
);
2840 #endif /* CONFIG_WNM */
2843 static int wpa_cli_cmd_raw(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2847 return wpa_cli_cmd(ctrl
, argv
[0], 0, argc
- 1, &argv
[1]);
2852 static int wpa_cli_cmd_driver(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2854 return wpa_cli_cmd(ctrl
, "DRIVER", 1, argc
, argv
);
2856 #endif /* ANDROID */
2859 static int wpa_cli_cmd_vendor(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2861 return wpa_cli_cmd(ctrl
, "VENDOR", 1, argc
, argv
);
2865 static int wpa_cli_cmd_flush(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2867 return wpa_ctrl_command(ctrl
, "FLUSH");
2871 static int wpa_cli_cmd_radio_work(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2873 return wpa_cli_cmd(ctrl
, "RADIO_WORK", 1, argc
, argv
);
2877 static int wpa_cli_cmd_neighbor_rep_request(struct wpa_ctrl
*ctrl
, int argc
,
2880 return wpa_cli_cmd(ctrl
, "NEIGHBOR_REP_REQUEST", 0, argc
, argv
);
2884 static int wpa_cli_cmd_erp_flush(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2886 return wpa_ctrl_command(ctrl
, "ERP_FLUSH");
2890 static int wpa_cli_cmd_mac_rand_scan(struct wpa_ctrl
*ctrl
, int argc
,
2893 return wpa_cli_cmd(ctrl
, "MAC_RAND_SCAN", 1, argc
, argv
);
2897 static int wpa_cli_cmd_get_pref_freq_list(struct wpa_ctrl
*ctrl
, int argc
,
2900 return wpa_cli_cmd(ctrl
, "GET_PREF_FREQ_LIST", 1, argc
, argv
);
2904 static int wpa_cli_cmd_p2p_lo_start(struct wpa_ctrl
*ctrl
, int argc
,
2907 return wpa_cli_cmd(ctrl
, "P2P_LO_START", 4, argc
, argv
);
2911 static int wpa_cli_cmd_p2p_lo_stop(struct wpa_ctrl
*ctrl
, int argc
,
2914 return wpa_cli_cmd(ctrl
, "P2P_LO_STOP", 0, argc
, argv
);
2920 static int wpa_cli_cmd_dpp_qr_code(struct wpa_ctrl
*ctrl
, int argc
,
2923 return wpa_cli_cmd(ctrl
, "DPP_QR_CODE", 1, argc
, argv
);
2927 static int wpa_cli_cmd_dpp_bootstrap_gen(struct wpa_ctrl
*ctrl
, int argc
,
2930 return wpa_cli_cmd(ctrl
, "DPP_BOOTSTRAP_GEN", 1, argc
, argv
);
2934 static int wpa_cli_cmd_dpp_bootstrap_remove(struct wpa_ctrl
*ctrl
, int argc
,
2937 return wpa_cli_cmd(ctrl
, "DPP_BOOTSTRAP_REMOVE", 1, argc
, argv
);
2941 static int wpa_cli_cmd_dpp_bootstrap_get_uri(struct wpa_ctrl
*ctrl
, int argc
,
2944 return wpa_cli_cmd(ctrl
, "DPP_BOOTSTRAP_GET_URI", 1, argc
, argv
);
2948 static int wpa_cli_cmd_dpp_bootstrap_info(struct wpa_ctrl
*ctrl
, int argc
,
2951 return wpa_cli_cmd(ctrl
, "DPP_BOOTSTRAP_INFO", 1, argc
, argv
);
2955 static int wpa_cli_cmd_dpp_auth_init(struct wpa_ctrl
*ctrl
, int argc
,
2958 return wpa_cli_cmd(ctrl
, "DPP_AUTH_INIT", 1, argc
, argv
);
2962 static int wpa_cli_cmd_dpp_listen(struct wpa_ctrl
*ctrl
, int argc
,
2965 return wpa_cli_cmd(ctrl
, "DPP_LISTEN", 1, argc
, argv
);
2969 static int wpa_cli_cmd_dpp_stop_listen(struct wpa_ctrl
*ctrl
, int argc
,
2972 return wpa_ctrl_command(ctrl
, "DPP_STOP_LISTEN");
2976 static int wpa_cli_cmd_dpp_configurator_add(struct wpa_ctrl
*ctrl
, int argc
,
2979 return wpa_cli_cmd(ctrl
, "DPP_CONFIGURATOR_ADD", 0, argc
, argv
);
2983 static int wpa_cli_cmd_dpp_configurator_remove(struct wpa_ctrl
*ctrl
, int argc
,
2986 return wpa_cli_cmd(ctrl
, "DPP_CONFIGURATOR_REMOVE", 1, argc
, argv
);
2990 static int wpa_cli_cmd_dpp_configurator_get_key(struct wpa_ctrl
*ctrl
, int argc
,
2993 return wpa_cli_cmd(ctrl
, "DPP_CONFIGURATOR_GET_KEY", 1, argc
, argv
);
2997 static int wpa_cli_cmd_dpp_configurator_sign(struct wpa_ctrl
*ctrl
, int argc
,
3000 return wpa_cli_cmd(ctrl
, "DPP_CONFIGURATOR_SIGN", 1, argc
, argv
);
3004 static int wpa_cli_cmd_dpp_pkex_add(struct wpa_ctrl
*ctrl
, int argc
,
3007 return wpa_cli_cmd(ctrl
, "DPP_PKEX_ADD", 1, argc
, argv
);
3011 static int wpa_cli_cmd_dpp_pkex_remove(struct wpa_ctrl
*ctrl
, int argc
,
3014 return wpa_cli_cmd(ctrl
, "DPP_PKEX_REMOVE", 1, argc
, argv
);
3017 #endif /* CONFIG_DPP */
3020 enum wpa_cli_cmd_flags
{
3021 cli_cmd_flag_none
= 0x00,
3022 cli_cmd_flag_sensitive
= 0x01
3025 struct wpa_cli_cmd
{
3027 int (*handler
)(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[]);
3028 char ** (*completion
)(const char *str
, int pos
);
3029 enum wpa_cli_cmd_flags flags
;
3033 static const struct wpa_cli_cmd wpa_cli_commands
[] = {
3034 { "status", wpa_cli_cmd_status
, NULL
,
3036 "[verbose] = get current WPA/EAPOL/EAP status" },
3037 { "ifname", wpa_cli_cmd_ifname
, NULL
,
3039 "= get current interface name" },
3040 { "ping", wpa_cli_cmd_ping
, NULL
,
3042 "= pings wpa_supplicant" },
3043 { "relog", wpa_cli_cmd_relog
, NULL
,
3045 "= re-open log-file (allow rolling logs)" },
3046 { "note", wpa_cli_cmd_note
, NULL
,
3048 "<text> = add a note to wpa_supplicant debug log" },
3049 { "mib", wpa_cli_cmd_mib
, NULL
,
3051 "= get MIB variables (dot1x, dot11)" },
3052 { "help", wpa_cli_cmd_help
, wpa_cli_complete_help
,
3054 "[command] = show usage help" },
3055 { "interface", wpa_cli_cmd_interface
, NULL
,
3057 "[ifname] = show interfaces/select interface" },
3058 { "level", wpa_cli_cmd_level
, NULL
,
3060 "<debug level> = change debug level" },
3061 { "license", wpa_cli_cmd_license
, NULL
,
3063 "= show full wpa_cli license" },
3064 { "quit", wpa_cli_cmd_quit
, NULL
,
3067 { "set", wpa_cli_cmd_set
, wpa_cli_complete_set
,
3069 "= set variables (shows list of variables when run without "
3071 { "dump", wpa_cli_cmd_dump
, NULL
,
3073 "= dump config variables" },
3074 { "get", wpa_cli_cmd_get
, wpa_cli_complete_get
,
3076 "<name> = get information" },
3077 { "driver_flags", wpa_cli_cmd_driver_flags
, NULL
,
3079 "= list driver flags" },
3080 { "logon", wpa_cli_cmd_logon
, NULL
,
3082 "= IEEE 802.1X EAPOL state machine logon" },
3083 { "logoff", wpa_cli_cmd_logoff
, NULL
,
3085 "= IEEE 802.1X EAPOL state machine logoff" },
3086 { "pmksa", wpa_cli_cmd_pmksa
, NULL
,
3088 "= show PMKSA cache" },
3089 { "pmksa_flush", wpa_cli_cmd_pmksa_flush
, NULL
,
3091 "= flush PMKSA cache entries" },
3092 #ifdef CONFIG_PMKSA_CACHE_EXTERNAL
3093 { "pmksa_get", wpa_cli_cmd_pmksa_get
, NULL
,
3095 "<network_id> = fetch all stored PMKSA cache entries" },
3096 { "pmksa_add", wpa_cli_cmd_pmksa_add
, NULL
,
3097 cli_cmd_flag_sensitive
,
3098 "<network_id> <BSSID> <PMKID> <PMK> <reauth_time in seconds> <expiration in seconds> <akmp> <opportunistic> = store PMKSA cache entry from external storage" },
3100 { "mesh_pmksa_get", wpa_cli_mesh_cmd_pmksa_get
, NULL
,
3102 "<peer MAC address | any> = fetch all stored mesh PMKSA cache entries" },
3103 { "mesh_pmksa_add", wpa_cli_mesh_cmd_pmksa_add
, NULL
,
3104 cli_cmd_flag_sensitive
,
3105 "<BSSID> <PMKID> <PMK> <expiration in seconds> = store mesh PMKSA cache entry from external storage" },
3106 #endif /* CONFIG_MESH */
3107 #endif /* CONFIG_PMKSA_CACHE_EXTERNAL */
3108 { "reassociate", wpa_cli_cmd_reassociate
, NULL
,
3110 "= force reassociation" },
3111 { "reattach", wpa_cli_cmd_reattach
, NULL
,
3113 "= force reassociation back to the same BSS" },
3114 { "preauthenticate", wpa_cli_cmd_preauthenticate
, wpa_cli_complete_bss
,
3116 "<BSSID> = force preauthentication" },
3117 { "identity", wpa_cli_cmd_identity
, wpa_cli_complete_network_id
,
3119 "<network id> <identity> = configure identity for an SSID" },
3120 { "password", wpa_cli_cmd_password
, wpa_cli_complete_network_id
,
3121 cli_cmd_flag_sensitive
,
3122 "<network id> <password> = configure password for an SSID" },
3123 { "new_password", wpa_cli_cmd_new_password
,
3124 wpa_cli_complete_network_id
, cli_cmd_flag_sensitive
,
3125 "<network id> <password> = change password for an SSID" },
3126 { "pin", wpa_cli_cmd_pin
, wpa_cli_complete_network_id
,
3127 cli_cmd_flag_sensitive
,
3128 "<network id> <pin> = configure pin for an SSID" },
3129 { "otp", wpa_cli_cmd_otp
, wpa_cli_complete_network_id
,
3130 cli_cmd_flag_sensitive
,
3131 "<network id> <password> = configure one-time-password for an SSID"
3133 { "psk_passphrase", wpa_cli_cmd_psk_passphrase
,
3134 wpa_cli_complete_network_id
, cli_cmd_flag_sensitive
,
3135 "<network id> <PSK/passphrase> = configure PSK/passphrase for an SSID" },
3136 { "passphrase", wpa_cli_cmd_passphrase
, wpa_cli_complete_network_id
,
3137 cli_cmd_flag_sensitive
,
3138 "<network id> <passphrase> = configure private key passphrase\n"
3140 { "sim", wpa_cli_cmd_sim
, wpa_cli_complete_network_id
,
3141 cli_cmd_flag_sensitive
,
3142 "<network id> <pin> = report SIM operation result" },
3143 { "bssid", wpa_cli_cmd_bssid
, wpa_cli_complete_network_id
,
3145 "<network id> <BSSID> = set preferred BSSID for an SSID" },
3146 { "blacklist", wpa_cli_cmd_blacklist
, wpa_cli_complete_bss
,
3148 "<BSSID> = add a BSSID to the blacklist\n"
3149 "blacklist clear = clear the blacklist\n"
3150 "blacklist = display the blacklist" },
3151 { "log_level", wpa_cli_cmd_log_level
, NULL
,
3153 "<level> [<timestamp>] = update the log level/timestamp\n"
3154 "log_level = display the current log level and log options" },
3155 { "list_networks", wpa_cli_cmd_list_networks
, NULL
,
3157 "= list configured networks" },
3158 { "select_network", wpa_cli_cmd_select_network
,
3159 wpa_cli_complete_network_id
,
3161 "<network id> = select a network (disable others)" },
3162 { "enable_network", wpa_cli_cmd_enable_network
,
3163 wpa_cli_complete_network_id
,
3165 "<network id> = enable a network" },
3166 { "disable_network", wpa_cli_cmd_disable_network
,
3167 wpa_cli_complete_network_id
,
3169 "<network id> = disable a network" },
3170 { "add_network", wpa_cli_cmd_add_network
, NULL
,
3172 "= add a network" },
3173 { "remove_network", wpa_cli_cmd_remove_network
,
3174 wpa_cli_complete_network_id
,
3176 "<network id> = remove a network" },
3177 { "set_network", wpa_cli_cmd_set_network
, wpa_cli_complete_network
,
3178 cli_cmd_flag_sensitive
,
3179 "<network id> <variable> <value> = set network variables (shows\n"
3180 " list of variables when run without arguments)" },
3181 { "get_network", wpa_cli_cmd_get_network
, wpa_cli_complete_network
,
3183 "<network id> <variable> = get network variables" },
3184 { "dup_network", wpa_cli_cmd_dup_network
, wpa_cli_complete_dup_network
,
3186 "<src network id> <dst network id> <variable> = duplicate network variables"
3188 { "list_creds", wpa_cli_cmd_list_creds
, NULL
,
3190 "= list configured credentials" },
3191 { "add_cred", wpa_cli_cmd_add_cred
, NULL
,
3193 "= add a credential" },
3194 { "remove_cred", wpa_cli_cmd_remove_cred
, NULL
,
3196 "<cred id> = remove a credential" },
3197 { "set_cred", wpa_cli_cmd_set_cred
, wpa_cli_complete_cred
,
3198 cli_cmd_flag_sensitive
,
3199 "<cred id> <variable> <value> = set credential variables" },
3200 { "get_cred", wpa_cli_cmd_get_cred
, wpa_cli_complete_cred
,
3202 "<cred id> <variable> = get credential variables" },
3203 { "save_config", wpa_cli_cmd_save_config
, NULL
,
3205 "= save the current configuration" },
3206 { "disconnect", wpa_cli_cmd_disconnect
, NULL
,
3208 "= disconnect and wait for reassociate/reconnect command before\n"
3210 { "reconnect", wpa_cli_cmd_reconnect
, NULL
,
3212 "= like reassociate, but only takes effect if already disconnected"
3214 { "scan", wpa_cli_cmd_scan
, NULL
,
3216 "= request new BSS scan" },
3217 { "scan_results", wpa_cli_cmd_scan_results
, NULL
,
3219 "= get latest scan results" },
3220 { "abort_scan", wpa_cli_cmd_abort_scan
, NULL
,
3222 "= request ongoing scan to be aborted" },
3223 { "bss", wpa_cli_cmd_bss
, wpa_cli_complete_bss
,
3225 "<<idx> | <bssid>> = get detailed scan result info" },
3226 { "get_capability", wpa_cli_cmd_get_capability
,
3227 wpa_cli_complete_get_capability
, cli_cmd_flag_none
,
3228 "<eap/pairwise/group/key_mgmt/proto/auth_alg/channels/freq/modes> "
3229 "= get capabilities" },
3230 { "reconfigure", wpa_cli_cmd_reconfigure
, NULL
,
3232 "= force wpa_supplicant to re-read its configuration file" },
3233 { "terminate", wpa_cli_cmd_terminate
, NULL
,
3235 "= terminate wpa_supplicant" },
3236 { "interface_add", wpa_cli_cmd_interface_add
, NULL
,
3238 "<ifname> <confname> <driver> <ctrl_interface> <driver_param>\n"
3239 " <bridge_name> <create> <type> = adds new interface, all "
3241 " <ifname> are optional. Supported types are station ('sta') and "
3243 { "interface_remove", wpa_cli_cmd_interface_remove
, NULL
,
3245 "<ifname> = removes the interface" },
3246 { "interface_list", wpa_cli_cmd_interface_list
, NULL
,
3248 "= list available interfaces" },
3249 { "ap_scan", wpa_cli_cmd_ap_scan
, NULL
,
3251 "<value> = set ap_scan parameter" },
3252 { "scan_interval", wpa_cli_cmd_scan_interval
, NULL
,
3254 "<value> = set scan_interval parameter (in seconds)" },
3255 { "bss_expire_age", wpa_cli_cmd_bss_expire_age
, NULL
,
3257 "<value> = set BSS expiration age parameter" },
3258 { "bss_expire_count", wpa_cli_cmd_bss_expire_count
, NULL
,
3260 "<value> = set BSS expiration scan count parameter" },
3261 { "bss_flush", wpa_cli_cmd_bss_flush
, NULL
,
3263 "<value> = set BSS flush age (0 by default)" },
3264 { "ft_ds", wpa_cli_cmd_ft_ds
, wpa_cli_complete_bss
,
3266 "<addr> = request over-the-DS FT with <addr>" },
3267 { "wps_pbc", wpa_cli_cmd_wps_pbc
, wpa_cli_complete_bss
,
3269 "[BSSID] = start Wi-Fi Protected Setup: Push Button Configuration" },
3270 { "wps_pin", wpa_cli_cmd_wps_pin
, wpa_cli_complete_bss
,
3271 cli_cmd_flag_sensitive
,
3272 "<BSSID> [PIN] = start WPS PIN method (returns PIN, if not "
3274 { "wps_check_pin", wpa_cli_cmd_wps_check_pin
, NULL
,
3275 cli_cmd_flag_sensitive
,
3276 "<PIN> = verify PIN checksum" },
3277 { "wps_cancel", wpa_cli_cmd_wps_cancel
, NULL
, cli_cmd_flag_none
,
3278 "Cancels the pending WPS operation" },
3279 #ifdef CONFIG_WPS_NFC
3280 { "wps_nfc", wpa_cli_cmd_wps_nfc
, wpa_cli_complete_bss
,
3282 "[BSSID] = start Wi-Fi Protected Setup: NFC" },
3283 { "wps_nfc_config_token", wpa_cli_cmd_wps_nfc_config_token
, NULL
,
3285 "<WPS|NDEF> = build configuration token" },
3286 { "wps_nfc_token", wpa_cli_cmd_wps_nfc_token
, NULL
,
3288 "<WPS|NDEF> = create password token" },
3289 { "wps_nfc_tag_read", wpa_cli_cmd_wps_nfc_tag_read
, NULL
,
3290 cli_cmd_flag_sensitive
,
3291 "<hexdump of payload> = report read NFC tag with WPS data" },
3292 { "nfc_get_handover_req", wpa_cli_cmd_nfc_get_handover_req
, NULL
,
3294 "<NDEF> <WPS> = create NFC handover request" },
3295 { "nfc_get_handover_sel", wpa_cli_cmd_nfc_get_handover_sel
, NULL
,
3297 "<NDEF> <WPS> = create NFC handover select" },
3298 { "nfc_report_handover", wpa_cli_cmd_nfc_report_handover
, NULL
,
3300 "<role> <type> <hexdump of req> <hexdump of sel> = report completed "
3302 #endif /* CONFIG_WPS_NFC */
3303 { "wps_reg", wpa_cli_cmd_wps_reg
, wpa_cli_complete_bss
,
3304 cli_cmd_flag_sensitive
,
3305 "<BSSID> <AP PIN> = start WPS Registrar to configure an AP" },
3306 { "wps_ap_pin", wpa_cli_cmd_wps_ap_pin
, NULL
,
3307 cli_cmd_flag_sensitive
,
3308 "[params..] = enable/disable AP PIN" },
3309 { "wps_er_start", wpa_cli_cmd_wps_er_start
, NULL
,
3311 "[IP address] = start Wi-Fi Protected Setup External Registrar" },
3312 { "wps_er_stop", wpa_cli_cmd_wps_er_stop
, NULL
,
3314 "= stop Wi-Fi Protected Setup External Registrar" },
3315 { "wps_er_pin", wpa_cli_cmd_wps_er_pin
, NULL
,
3316 cli_cmd_flag_sensitive
,
3317 "<UUID> <PIN> = add an Enrollee PIN to External Registrar" },
3318 { "wps_er_pbc", wpa_cli_cmd_wps_er_pbc
, NULL
,
3320 "<UUID> = accept an Enrollee PBC using External Registrar" },
3321 { "wps_er_learn", wpa_cli_cmd_wps_er_learn
, NULL
,
3322 cli_cmd_flag_sensitive
,
3323 "<UUID> <PIN> = learn AP configuration" },
3324 { "wps_er_set_config", wpa_cli_cmd_wps_er_set_config
, NULL
,
3326 "<UUID> <network id> = set AP configuration for enrolling" },
3327 { "wps_er_config", wpa_cli_cmd_wps_er_config
, NULL
,
3328 cli_cmd_flag_sensitive
,
3329 "<UUID> <PIN> <SSID> <auth> <encr> <key> = configure AP" },
3330 #ifdef CONFIG_WPS_NFC
3331 { "wps_er_nfc_config_token", wpa_cli_cmd_wps_er_nfc_config_token
, NULL
,
3333 "<WPS/NDEF> <UUID> = build NFC configuration token" },
3334 #endif /* CONFIG_WPS_NFC */
3335 { "ibss_rsn", wpa_cli_cmd_ibss_rsn
, NULL
,
3337 "<addr> = request RSN authentication with <addr> in IBSS" },
3339 { "sta", wpa_cli_cmd_sta
, wpa_cli_complete_sta
,
3341 "<addr> = get information about an associated station (AP)" },
3342 { "all_sta", wpa_cli_cmd_all_sta
, NULL
,
3344 "= get information about all associated stations (AP)" },
3345 { "list_sta", wpa_cli_cmd_list_sta
, NULL
,
3347 "= list all stations (AP)" },
3348 { "deauthenticate", wpa_cli_cmd_deauthenticate
,
3349 wpa_cli_complete_deauthenticate
, cli_cmd_flag_none
,
3350 "<addr> = deauthenticate a station" },
3351 { "disassociate", wpa_cli_cmd_disassociate
,
3352 wpa_cli_complete_disassociate
, cli_cmd_flag_none
,
3353 "<addr> = disassociate a station" },
3354 { "chan_switch", wpa_cli_cmd_chanswitch
, NULL
,
3356 "<cs_count> <freq> [sec_channel_offset=] [center_freq1=]"
3357 " [center_freq2=] [bandwidth=] [blocktx] [ht|vht]"
3358 " = CSA parameters" },
3359 #endif /* CONFIG_AP */
3360 { "suspend", wpa_cli_cmd_suspend
, NULL
, cli_cmd_flag_none
,
3361 "= notification of suspend/hibernate" },
3362 { "resume", wpa_cli_cmd_resume
, NULL
, cli_cmd_flag_none
,
3363 "= notification of resume/thaw" },
3364 #ifdef CONFIG_TESTING_OPTIONS
3365 { "drop_sa", wpa_cli_cmd_drop_sa
, NULL
, cli_cmd_flag_none
,
3366 "= drop SA without deauth/disassoc (test command)" },
3367 #endif /* CONFIG_TESTING_OPTIONS */
3368 { "roam", wpa_cli_cmd_roam
, wpa_cli_complete_bss
,
3370 "<addr> = roam to the specified BSS" },
3372 { "mesh_interface_add", wpa_cli_cmd_mesh_interface_add
, NULL
,
3374 "[ifname] = Create a new mesh interface" },
3375 { "mesh_group_add", wpa_cli_cmd_mesh_group_add
, NULL
,
3377 "<network id> = join a mesh network (disable others)" },
3378 { "mesh_group_remove", wpa_cli_cmd_mesh_group_remove
, NULL
,
3380 "<ifname> = Remove mesh group interface" },
3381 { "mesh_peer_remove", wpa_cli_cmd_mesh_peer_remove
, NULL
,
3383 "<addr> = Remove a mesh peer" },
3384 { "mesh_peer_add", wpa_cli_cmd_mesh_peer_add
, NULL
,
3386 "<addr> [duration=<seconds>] = Add a mesh peer" },
3387 #endif /* CONFIG_MESH */
3389 { "p2p_find", wpa_cli_cmd_p2p_find
, wpa_cli_complete_p2p_find
,
3391 "[timeout] [type=*] = find P2P Devices for up-to timeout seconds" },
3392 { "p2p_stop_find", wpa_cli_cmd_p2p_stop_find
, NULL
, cli_cmd_flag_none
,
3393 "= stop P2P Devices search" },
3394 { "p2p_asp_provision", wpa_cli_cmd_p2p_asp_provision
, NULL
,
3396 "<addr> adv_id=<adv_id> conncap=<conncap> [info=<infodata>] = provision with a P2P ASP Device" },
3397 { "p2p_asp_provision_resp", wpa_cli_cmd_p2p_asp_provision_resp
, NULL
,
3399 "<addr> adv_id=<adv_id> [role<conncap>] [info=<infodata>] = provision with a P2P ASP Device" },
3400 { "p2p_connect", wpa_cli_cmd_p2p_connect
, wpa_cli_complete_p2p_connect
,
3402 "<addr> <\"pbc\"|PIN> [ht40] = connect to a P2P Device" },
3403 { "p2p_listen", wpa_cli_cmd_p2p_listen
, NULL
, cli_cmd_flag_none
,
3404 "[timeout] = listen for P2P Devices for up-to timeout seconds" },
3405 { "p2p_group_remove", wpa_cli_cmd_p2p_group_remove
,
3406 wpa_cli_complete_p2p_group_remove
, cli_cmd_flag_none
,
3407 "<ifname> = remove P2P group interface (terminate group if GO)" },
3408 { "p2p_group_add", wpa_cli_cmd_p2p_group_add
, NULL
, cli_cmd_flag_none
,
3409 "[ht40] = add a new P2P group (local end as GO)" },
3410 { "p2p_group_member", wpa_cli_cmd_p2p_group_member
, NULL
,
3412 "<dev_addr> = Get peer interface address on local GO using peer Device Address" },
3413 { "p2p_prov_disc", wpa_cli_cmd_p2p_prov_disc
,
3414 wpa_cli_complete_p2p_peer
, cli_cmd_flag_none
,
3415 "<addr> <method> = request provisioning discovery" },
3416 { "p2p_get_passphrase", wpa_cli_cmd_p2p_get_passphrase
, NULL
,
3418 "= get the passphrase for a group (GO only)" },
3419 { "p2p_serv_disc_req", wpa_cli_cmd_p2p_serv_disc_req
,
3420 wpa_cli_complete_p2p_peer
, cli_cmd_flag_none
,
3421 "<addr> <TLVs> = schedule service discovery request" },
3422 { "p2p_serv_disc_cancel_req", wpa_cli_cmd_p2p_serv_disc_cancel_req
,
3423 NULL
, cli_cmd_flag_none
,
3424 "<id> = cancel pending service discovery request" },
3425 { "p2p_serv_disc_resp", wpa_cli_cmd_p2p_serv_disc_resp
, NULL
,
3427 "<freq> <addr> <dialog token> <TLVs> = service discovery response" },
3428 { "p2p_service_update", wpa_cli_cmd_p2p_service_update
, NULL
,
3430 "= indicate change in local services" },
3431 { "p2p_serv_disc_external", wpa_cli_cmd_p2p_serv_disc_external
, NULL
,
3433 "<external> = set external processing of service discovery" },
3434 { "p2p_service_flush", wpa_cli_cmd_p2p_service_flush
, NULL
,
3436 "= remove all stored service entries" },
3437 { "p2p_service_add", wpa_cli_cmd_p2p_service_add
, NULL
,
3439 "<bonjour|upnp|asp> <query|version> <response|service> = add a local "
3441 { "p2p_service_rep", wpa_cli_cmd_p2p_service_rep
, NULL
,
3443 "asp <auto> <adv_id> <svc_state> <svc_string> [<svc_info>] = replace "
3444 "local ASP service" },
3445 { "p2p_service_del", wpa_cli_cmd_p2p_service_del
, NULL
,
3447 "<bonjour|upnp> <query|version> [|service] = remove a local "
3449 { "p2p_reject", wpa_cli_cmd_p2p_reject
, wpa_cli_complete_p2p_peer
,
3451 "<addr> = reject connection attempts from a specific peer" },
3452 { "p2p_invite", wpa_cli_cmd_p2p_invite
, NULL
,
3454 "<cmd> [peer=addr] = invite peer" },
3455 { "p2p_peers", wpa_cli_cmd_p2p_peers
, NULL
, cli_cmd_flag_none
,
3456 "[discovered] = list known (optionally, only fully discovered) P2P "
3458 { "p2p_peer", wpa_cli_cmd_p2p_peer
, wpa_cli_complete_p2p_peer
,
3460 "<address> = show information about known P2P peer" },
3461 { "p2p_set", wpa_cli_cmd_p2p_set
, wpa_cli_complete_p2p_set
,
3463 "<field> <value> = set a P2P parameter" },
3464 { "p2p_flush", wpa_cli_cmd_p2p_flush
, NULL
, cli_cmd_flag_none
,
3465 "= flush P2P state" },
3466 { "p2p_cancel", wpa_cli_cmd_p2p_cancel
, NULL
, cli_cmd_flag_none
,
3467 "= cancel P2P group formation" },
3468 { "p2p_unauthorize", wpa_cli_cmd_p2p_unauthorize
,
3469 wpa_cli_complete_p2p_peer
, cli_cmd_flag_none
,
3470 "<address> = unauthorize a peer" },
3471 { "p2p_presence_req", wpa_cli_cmd_p2p_presence_req
, NULL
,
3473 "[<duration> <interval>] [<duration> <interval>] = request GO "
3475 { "p2p_ext_listen", wpa_cli_cmd_p2p_ext_listen
, NULL
,
3477 "[<period> <interval>] = set extended listen timing" },
3478 { "p2p_remove_client", wpa_cli_cmd_p2p_remove_client
,
3479 wpa_cli_complete_p2p_peer
, cli_cmd_flag_none
,
3480 "<address|iface=address> = remove a peer from all groups" },
3481 #endif /* CONFIG_P2P */
3482 { "vendor_elem_add", wpa_cli_cmd_vendor_elem_add
, NULL
,
3484 "<frame id> <hexdump of elem(s)> = add vendor specific IEs to frame(s)\n"
3485 VENDOR_ELEM_FRAME_ID
},
3486 { "vendor_elem_get", wpa_cli_cmd_vendor_elem_get
, NULL
,
3488 "<frame id> = get vendor specific IE(s) to frame(s)\n"
3489 VENDOR_ELEM_FRAME_ID
},
3490 { "vendor_elem_remove", wpa_cli_cmd_vendor_elem_remove
, NULL
,
3492 "<frame id> <hexdump of elem(s)> = remove vendor specific IE(s) in frame(s)\n"
3493 VENDOR_ELEM_FRAME_ID
},
3494 #ifdef CONFIG_WIFI_DISPLAY
3495 { "wfd_subelem_set", wpa_cli_cmd_wfd_subelem_set
, NULL
,
3497 "<subelem> [contents] = set Wi-Fi Display subelement" },
3498 { "wfd_subelem_get", wpa_cli_cmd_wfd_subelem_get
, NULL
,
3500 "<subelem> = get Wi-Fi Display subelement" },
3501 #endif /* CONFIG_WIFI_DISPLAY */
3502 #ifdef CONFIG_INTERWORKING
3503 { "fetch_anqp", wpa_cli_cmd_fetch_anqp
, NULL
, cli_cmd_flag_none
,
3504 "= fetch ANQP information for all APs" },
3505 { "stop_fetch_anqp", wpa_cli_cmd_stop_fetch_anqp
, NULL
,
3507 "= stop fetch_anqp operation" },
3508 { "interworking_select", wpa_cli_cmd_interworking_select
, NULL
,
3510 "[auto] = perform Interworking network selection" },
3511 { "interworking_connect", wpa_cli_cmd_interworking_connect
,
3512 wpa_cli_complete_bss
, cli_cmd_flag_none
,
3513 "<BSSID> = connect using Interworking credentials" },
3514 { "interworking_add_network", wpa_cli_cmd_interworking_add_network
,
3515 wpa_cli_complete_bss
, cli_cmd_flag_none
,
3516 "<BSSID> = connect using Interworking credentials" },
3517 { "anqp_get", wpa_cli_cmd_anqp_get
, wpa_cli_complete_bss
,
3519 "<addr> <info id>[,<info id>]... = request ANQP information" },
3520 { "gas_request", wpa_cli_cmd_gas_request
, wpa_cli_complete_bss
,
3522 "<addr> <AdvProtoID> [QueryReq] = GAS request" },
3523 { "gas_response_get", wpa_cli_cmd_gas_response_get
,
3524 wpa_cli_complete_bss
, cli_cmd_flag_none
,
3525 "<addr> <dialog token> [start,len] = Fetch last GAS response" },
3526 #endif /* CONFIG_INTERWORKING */
3528 { "hs20_anqp_get", wpa_cli_cmd_hs20_anqp_get
, wpa_cli_complete_bss
,
3530 "<addr> <subtype>[,<subtype>]... = request HS 2.0 ANQP information"
3532 { "nai_home_realm_list", wpa_cli_cmd_get_nai_home_realm_list
,
3533 wpa_cli_complete_bss
, cli_cmd_flag_none
,
3534 "<addr> <home realm> = get HS20 nai home realm list" },
3535 { "hs20_icon_request", wpa_cli_cmd_hs20_icon_request
,
3536 wpa_cli_complete_bss
, cli_cmd_flag_none
,
3537 "<addr> <icon name> = get Hotspot 2.0 OSU icon" },
3538 { "fetch_osu", wpa_cli_cmd_fetch_osu
, NULL
, cli_cmd_flag_none
,
3539 "= fetch OSU provider information from all APs" },
3540 { "cancel_fetch_osu", wpa_cli_cmd_cancel_fetch_osu
, NULL
,
3542 "= cancel fetch_osu command" },
3543 #endif /* CONFIG_HS20 */
3544 { "sta_autoconnect", wpa_cli_cmd_sta_autoconnect
, NULL
,
3546 "<0/1> = disable/enable automatic reconnection" },
3547 { "tdls_discover", wpa_cli_cmd_tdls_discover
, NULL
,
3549 "<addr> = request TDLS discovery with <addr>" },
3550 { "tdls_setup", wpa_cli_cmd_tdls_setup
, NULL
,
3552 "<addr> = request TDLS setup with <addr>" },
3553 { "tdls_teardown", wpa_cli_cmd_tdls_teardown
, NULL
,
3555 "<addr> = tear down TDLS with <addr>" },
3556 { "tdls_link_status", wpa_cli_cmd_tdls_link_status
, NULL
,
3558 "<addr> = TDLS link status with <addr>" },
3559 { "wmm_ac_addts", wpa_cli_cmd_wmm_ac_addts
, NULL
,
3561 "<uplink/downlink/bidi> <tsid=0..7> <up=0..7> [nominal_msdu_size=#] "
3562 "[mean_data_rate=#] [min_phy_rate=#] [sba=#] [fixed_nominal_msdu] "
3563 "= add WMM-AC traffic stream" },
3564 { "wmm_ac_delts", wpa_cli_cmd_wmm_ac_delts
, NULL
,
3566 "<tsid> = delete WMM-AC traffic stream" },
3567 { "wmm_ac_status", wpa_cli_cmd_wmm_ac_status
, NULL
,
3569 "= show status for Wireless Multi-Media Admission-Control" },
3570 { "tdls_chan_switch", wpa_cli_cmd_tdls_chan_switch
, NULL
,
3572 "<addr> <oper class> <freq> [sec_channel_offset=] [center_freq1=] "
3573 "[center_freq2=] [bandwidth=] [ht|vht] = enable channel switching "
3575 { "tdls_cancel_chan_switch", wpa_cli_cmd_tdls_cancel_chan_switch
, NULL
,
3577 "<addr> = disable channel switching with TDLS peer <addr>" },
3578 { "signal_poll", wpa_cli_cmd_signal_poll
, NULL
,
3580 "= get signal parameters" },
3581 { "signal_monitor", wpa_cli_cmd_signal_monitor
, NULL
,
3583 "= set signal monitor parameters" },
3584 { "pktcnt_poll", wpa_cli_cmd_pktcnt_poll
, NULL
,
3586 "= get TX/RX packet counters" },
3587 { "reauthenticate", wpa_cli_cmd_reauthenticate
, NULL
,
3589 "= trigger IEEE 802.1X/EAPOL reauthentication" },
3590 #ifdef CONFIG_AUTOSCAN
3591 { "autoscan", wpa_cli_cmd_autoscan
, NULL
, cli_cmd_flag_none
,
3592 "[params] = Set or unset (if none) autoscan parameters" },
3593 #endif /* CONFIG_AUTOSCAN */
3595 { "wnm_sleep", wpa_cli_cmd_wnm_sleep
, NULL
, cli_cmd_flag_none
,
3596 "<enter/exit> [interval=#] = enter/exit WNM-Sleep mode" },
3597 { "wnm_bss_query", wpa_cli_cmd_wnm_bss_query
, NULL
, cli_cmd_flag_none
,
3598 "<query reason> [list]"
3599 " [neighbor=<BSSID>,<BSSID information>,<operating class>,<channel number>,<PHY type>[,<hexdump of optional subelements>]"
3600 " = Send BSS Transition Management Query" },
3601 #endif /* CONFIG_WNM */
3602 { "raw", wpa_cli_cmd_raw
, NULL
, cli_cmd_flag_sensitive
,
3603 "<params..> = Sent unprocessed command" },
3604 { "flush", wpa_cli_cmd_flush
, NULL
, cli_cmd_flag_none
,
3605 "= flush wpa_supplicant state" },
3607 { "driver", wpa_cli_cmd_driver
, NULL
, cli_cmd_flag_none
,
3608 "<command> = driver private commands" },
3609 #endif /* ANDROID */
3610 { "radio_work", wpa_cli_cmd_radio_work
, NULL
, cli_cmd_flag_none
,
3611 "= radio_work <show/add/done>" },
3612 { "vendor", wpa_cli_cmd_vendor
, NULL
, cli_cmd_flag_none
,
3613 "<vendor id> <command id> [<hex formatted command argument>] = Send vendor command"
3615 { "neighbor_rep_request",
3616 wpa_cli_cmd_neighbor_rep_request
, NULL
, cli_cmd_flag_none
,
3617 "[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)"
3619 { "erp_flush", wpa_cli_cmd_erp_flush
, NULL
, cli_cmd_flag_none
,
3620 "= flush ERP keys" },
3622 wpa_cli_cmd_mac_rand_scan
, NULL
, cli_cmd_flag_none
,
3623 "<scan|sched|pno|all> enable=<0/1> [addr=mac-address "
3624 "mask=mac-address-mask] = scan MAC randomization"
3626 { "get_pref_freq_list", wpa_cli_cmd_get_pref_freq_list
, NULL
,
3628 "<interface type> = retrieve preferred freq list for the specified interface type" },
3629 { "p2p_lo_start", wpa_cli_cmd_p2p_lo_start
, NULL
,
3631 "<freq> <period> <interval> <count> = start P2P listen offload" },
3632 { "p2p_lo_stop", wpa_cli_cmd_p2p_lo_stop
, NULL
,
3634 "= stop P2P listen offload" },
3636 { "dpp_qr_code", wpa_cli_cmd_dpp_qr_code
, NULL
, cli_cmd_flag_none
,
3637 "report a scanned DPP URI from a QR Code" },
3638 { "dpp_bootstrap_gen", wpa_cli_cmd_dpp_bootstrap_gen
, NULL
,
3639 cli_cmd_flag_sensitive
,
3640 "type=<qrcode> [chan=..] [mac=..] [info=..] [curve=..] [key=..] = generate DPP bootstrap information" },
3641 { "dpp_bootstrap_remove", wpa_cli_cmd_dpp_bootstrap_remove
, NULL
,
3643 "*|<id> = remove DPP bootstrap information" },
3644 { "dpp_bootstrap_get_uri", wpa_cli_cmd_dpp_bootstrap_get_uri
, NULL
,
3646 "<id> = get DPP bootstrap URI" },
3647 { "dpp_bootstrap_info", wpa_cli_cmd_dpp_bootstrap_info
, NULL
,
3649 "<id> = show DPP bootstrap information" },
3650 { "dpp_auth_init", wpa_cli_cmd_dpp_auth_init
, NULL
, cli_cmd_flag_none
,
3651 "peer=<id> [own=<id>] = initiate DPP bootstrapping" },
3652 { "dpp_listen", wpa_cli_cmd_dpp_listen
, NULL
, cli_cmd_flag_none
,
3653 "<freq in MHz> = start DPP listen" },
3654 { "dpp_stop_listen", wpa_cli_cmd_dpp_stop_listen
, NULL
,
3656 "= stop DPP listen" },
3657 { "dpp_configurator_add", wpa_cli_cmd_dpp_configurator_add
, NULL
,
3658 cli_cmd_flag_sensitive
,
3659 "[curve=..] [key=..] = add DPP configurator" },
3660 { "dpp_configurator_remove", wpa_cli_cmd_dpp_configurator_remove
, NULL
,
3662 "*|<id> = remove DPP configurator" },
3663 { "dpp_configurator_get_key", wpa_cli_cmd_dpp_configurator_get_key
,
3664 NULL
, cli_cmd_flag_none
,
3665 "<id> = Get DPP configurator's private key" },
3666 { "dpp_configurator_sign", wpa_cli_cmd_dpp_configurator_sign
, NULL
,
3668 "conf=<role> configurator=<id> = generate self DPP configuration" },
3669 { "dpp_pkex_add", wpa_cli_cmd_dpp_pkex_add
, NULL
,
3670 cli_cmd_flag_sensitive
,
3672 { "dpp_pkex_remove", wpa_cli_cmd_dpp_pkex_remove
, NULL
,
3674 "*|<id> = remove DPP pkex information" },
3675 #endif /* CONFIG_DPP */
3676 { NULL
, NULL
, NULL
, cli_cmd_flag_none
, NULL
}
3681 * Prints command usage, lines are padded with the specified string.
3683 static void print_cmd_help(const struct wpa_cli_cmd
*cmd
, const char *pad
)
3688 printf("%s%s ", pad
, cmd
->cmd
);
3689 for (n
= 0; (c
= cmd
->usage
[n
]); n
++) {
3698 static void print_help(const char *cmd
)
3701 printf("commands:\n");
3702 for (n
= 0; wpa_cli_commands
[n
].cmd
; n
++) {
3703 if (cmd
== NULL
|| str_starts(wpa_cli_commands
[n
].cmd
, cmd
))
3704 print_cmd_help(&wpa_cli_commands
[n
], " ");
3709 static int wpa_cli_edit_filter_history_cb(void *ctx
, const char *cmd
)
3711 const char *c
, *delim
;
3715 delim
= os_strchr(cmd
, ' ');
3719 len
= os_strlen(cmd
);
3721 for (n
= 0; (c
= wpa_cli_commands
[n
].cmd
); n
++) {
3722 if (os_strncasecmp(cmd
, c
, len
) == 0 && len
== os_strlen(c
))
3723 return (wpa_cli_commands
[n
].flags
&
3724 cli_cmd_flag_sensitive
);
3730 static char ** wpa_list_cmd_list(void)
3734 struct cli_txt_entry
*e
;
3736 count
= ARRAY_SIZE(wpa_cli_commands
);
3737 count
+= dl_list_len(&p2p_groups
);
3738 count
+= dl_list_len(&ifnames
);
3739 res
= os_calloc(count
+ 1, sizeof(char *));
3743 for (i
= 0; wpa_cli_commands
[i
].cmd
; i
++) {
3744 res
[i
] = os_strdup(wpa_cli_commands
[i
].cmd
);
3749 dl_list_for_each(e
, &p2p_groups
, struct cli_txt_entry
, list
) {
3750 size_t len
= 8 + os_strlen(e
->txt
);
3751 res
[i
] = os_malloc(len
);
3754 os_snprintf(res
[i
], len
, "ifname=%s", e
->txt
);
3758 dl_list_for_each(e
, &ifnames
, struct cli_txt_entry
, list
) {
3759 res
[i
] = os_strdup(e
->txt
);
3769 static char ** wpa_cli_cmd_completion(const char *cmd
, const char *str
,
3774 for (i
= 0; wpa_cli_commands
[i
].cmd
; i
++) {
3775 if (os_strcasecmp(wpa_cli_commands
[i
].cmd
, cmd
) == 0) {
3776 if (wpa_cli_commands
[i
].completion
)
3777 return wpa_cli_commands
[i
].completion(str
,
3780 printf("\r%s\n", wpa_cli_commands
[i
].usage
);
3790 static char ** wpa_cli_edit_completion_cb(void *ctx
, const char *str
, int pos
)
3796 if (pos
> 7 && os_strncasecmp(str
, "IFNAME=", 7) == 0) {
3797 end
= os_strchr(str
, ' ');
3798 if (end
&& pos
> end
- str
) {
3799 pos
-= end
- str
+ 1;
3804 end
= os_strchr(str
, ' ');
3805 if (end
== NULL
|| str
+ pos
< end
)
3806 return wpa_list_cmd_list();
3808 cmd
= os_malloc(pos
+ 1);
3811 os_memcpy(cmd
, str
, pos
);
3812 cmd
[end
- str
] = '\0';
3813 res
= wpa_cli_cmd_completion(cmd
, str
, pos
);
3819 static int wpa_request(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
3821 const struct wpa_cli_cmd
*cmd
, *match
= NULL
;
3825 if (argc
> 1 && os_strncasecmp(argv
[0], "IFNAME=", 7) == 0) {
3826 ifname_prefix
= argv
[0] + 7;
3830 ifname_prefix
= NULL
;
3836 cmd
= wpa_cli_commands
;
3838 if (os_strncasecmp(cmd
->cmd
, argv
[0], os_strlen(argv
[0])) == 0)
3841 if (os_strcasecmp(cmd
->cmd
, argv
[0]) == 0) {
3842 /* we have an exact match */
3852 printf("Ambiguous command '%s'; possible commands:", argv
[0]);
3853 cmd
= wpa_cli_commands
;
3855 if (os_strncasecmp(cmd
->cmd
, argv
[0],
3856 os_strlen(argv
[0])) == 0) {
3857 printf(" %s", cmd
->cmd
);
3863 } else if (count
== 0) {
3864 printf("Unknown command '%s'\n", argv
[0]);
3867 ret
= match
->handler(ctrl
, argc
- 1, &argv
[1]);
3874 static int wpa_cli_exec(const char *program
, const char *arg1
,
3881 /* If no interface is specified, set the global */
3885 len
= os_strlen(arg1
) + os_strlen(arg2
) + 2;
3886 arg
= os_malloc(len
);
3889 os_snprintf(arg
, len
, "%s %s", arg1
, arg2
);
3890 res
= os_exec(program
, arg
, 1);
3897 static void wpa_cli_action_process(const char *msg
)
3900 char *copy
= NULL
, *id
, *pos2
;
3901 const char *ifname
= ctrl_ifname
;
3902 char ifname_buf
[100];
3904 if (eloop_terminated())
3908 if (os_strncmp(pos
, "IFNAME=", 7) == 0) {
3910 end
= os_strchr(pos
+ 7, ' ');
3911 if (end
&& (unsigned int) (end
- pos
) < sizeof(ifname_buf
)) {
3913 os_memcpy(ifname_buf
, pos
, end
- pos
);
3914 ifname_buf
[end
- pos
] = '\0';
3915 ifname
= ifname_buf
;
3920 const char *prev
= pos
;
3922 pos
= os_strchr(pos
, '>');
3929 if (str_starts(pos
, WPA_EVENT_CONNECTED
)) {
3931 os_unsetenv("WPA_ID");
3932 os_unsetenv("WPA_ID_STR");
3933 os_unsetenv("WPA_CTRL_DIR");
3935 pos
= os_strstr(pos
, "[id=");
3937 copy
= os_strdup(pos
+ 4);
3941 while (*pos2
&& *pos2
!= ' ')
3945 os_setenv("WPA_ID", id
, 1);
3946 while (*pos2
&& *pos2
!= '=')
3951 while (*pos2
&& *pos2
!= ']')
3954 os_setenv("WPA_ID_STR", id
, 1);
3958 os_setenv("WPA_CTRL_DIR", ctrl_iface_dir
, 1);
3960 if (wpa_cli_connected
<= 0 || new_id
!= wpa_cli_last_id
) {
3961 wpa_cli_connected
= 1;
3962 wpa_cli_last_id
= new_id
;
3963 wpa_cli_exec(action_file
, ifname
, "CONNECTED");
3965 } else if (str_starts(pos
, WPA_EVENT_DISCONNECTED
)) {
3966 if (wpa_cli_connected
) {
3967 wpa_cli_connected
= 0;
3968 wpa_cli_exec(action_file
, ifname
, "DISCONNECTED");
3970 } else if (str_starts(pos
, WPA_EVENT_CHANNEL_SWITCH_STARTED
)) {
3971 wpa_cli_exec(action_file
, ctrl_ifname
, pos
);
3972 } else if (str_starts(pos
, AP_EVENT_ENABLED
)) {
3973 wpa_cli_exec(action_file
, ctrl_ifname
, pos
);
3974 } else if (str_starts(pos
, AP_EVENT_DISABLED
)) {
3975 wpa_cli_exec(action_file
, ctrl_ifname
, pos
);
3976 } else if (str_starts(pos
, MESH_GROUP_STARTED
)) {
3977 wpa_cli_exec(action_file
, ctrl_ifname
, pos
);
3978 } else if (str_starts(pos
, MESH_GROUP_REMOVED
)) {
3979 wpa_cli_exec(action_file
, ctrl_ifname
, pos
);
3980 } else if (str_starts(pos
, MESH_PEER_CONNECTED
)) {
3981 wpa_cli_exec(action_file
, ctrl_ifname
, pos
);
3982 } else if (str_starts(pos
, MESH_PEER_DISCONNECTED
)) {
3983 wpa_cli_exec(action_file
, ctrl_ifname
, pos
);
3984 } else if (str_starts(pos
, P2P_EVENT_GROUP_STARTED
)) {
3985 wpa_cli_exec(action_file
, ifname
, pos
);
3986 } else if (str_starts(pos
, P2P_EVENT_GROUP_REMOVED
)) {
3987 wpa_cli_exec(action_file
, ifname
, pos
);
3988 } else if (str_starts(pos
, P2P_EVENT_CROSS_CONNECT_ENABLE
)) {
3989 wpa_cli_exec(action_file
, ifname
, pos
);
3990 } else if (str_starts(pos
, P2P_EVENT_CROSS_CONNECT_DISABLE
)) {
3991 wpa_cli_exec(action_file
, ifname
, pos
);
3992 } else if (str_starts(pos
, P2P_EVENT_GO_NEG_FAILURE
)) {
3993 wpa_cli_exec(action_file
, ifname
, pos
);
3994 } else if (str_starts(pos
, WPS_EVENT_SUCCESS
)) {
3995 wpa_cli_exec(action_file
, ifname
, pos
);
3996 } else if (str_starts(pos
, WPS_EVENT_ACTIVE
)) {
3997 wpa_cli_exec(action_file
, ifname
, pos
);
3998 } else if (str_starts(pos
, WPS_EVENT_TIMEOUT
)) {
3999 wpa_cli_exec(action_file
, ifname
, pos
);
4000 } else if (str_starts(pos
, WPS_EVENT_FAIL
)) {
4001 wpa_cli_exec(action_file
, ifname
, pos
);
4002 } else if (str_starts(pos
, AP_STA_CONNECTED
)) {
4003 wpa_cli_exec(action_file
, ifname
, pos
);
4004 } else if (str_starts(pos
, AP_STA_DISCONNECTED
)) {
4005 wpa_cli_exec(action_file
, ifname
, pos
);
4006 } else if (str_starts(pos
, ESS_DISASSOC_IMMINENT
)) {
4007 wpa_cli_exec(action_file
, ifname
, pos
);
4008 } else if (str_starts(pos
, HS20_SUBSCRIPTION_REMEDIATION
)) {
4009 wpa_cli_exec(action_file
, ifname
, pos
);
4010 } else if (str_starts(pos
, HS20_DEAUTH_IMMINENT_NOTICE
)) {
4011 wpa_cli_exec(action_file
, ifname
, pos
);
4012 } else if (str_starts(pos
, HS20_T_C_ACCEPTANCE
)) {
4013 wpa_cli_exec(action_file
, ifname
, pos
);
4014 } else if (str_starts(pos
, WPA_EVENT_TERMINATING
)) {
4015 printf("wpa_supplicant is terminating - stop monitoring\n");
4021 #ifndef CONFIG_ANSI_C_EXTRA
4022 static void wpa_cli_action_cb(char *msg
, size_t len
)
4024 wpa_cli_action_process(msg
);
4026 #endif /* CONFIG_ANSI_C_EXTRA */
4029 static int wpa_cli_open_global_ctrl(void)
4031 #ifdef CONFIG_CTRL_IFACE_NAMED_PIPE
4032 ctrl_conn
= wpa_ctrl_open(NULL
);
4033 #else /* CONFIG_CTRL_IFACE_NAMED_PIPE */
4034 ctrl_conn
= wpa_ctrl_open(global
);
4035 #endif /* CONFIG_CTRL_IFACE_NAMED_PIPE */
4038 "Failed to connect to wpa_supplicant global interface: %s error: %s\n",
4039 global
, strerror(errno
));
4044 update_ifnames(ctrl_conn
);
4045 mon_conn
= wpa_ctrl_open(global
);
4047 if (wpa_ctrl_attach(mon_conn
) == 0) {
4048 wpa_cli_attached
= 1;
4049 eloop_register_read_sock(
4050 wpa_ctrl_get_fd(mon_conn
),
4051 wpa_cli_mon_receive
,
4054 printf("Failed to open monitor connection through global control interface\n");
4057 update_stations(ctrl_conn
);
4064 static void wpa_cli_reconnect(void)
4066 wpa_cli_close_connection();
4067 if ((global
&& wpa_cli_open_global_ctrl() < 0) ||
4068 (!global
&& wpa_cli_open_connection(ctrl_ifname
, 1) < 0))
4073 printf("\rConnection to wpa_supplicant re-established\n");
4075 update_stations(ctrl_conn
);
4080 static void cli_event(const char *str
)
4082 const char *start
, *s
;
4084 start
= os_strchr(str
, '>');
4090 if (str_starts(start
, WPA_EVENT_BSS_ADDED
)) {
4091 s
= os_strchr(start
, ' ');
4094 s
= os_strchr(s
+ 1, ' ');
4097 cli_txt_list_add(&bsses
, s
+ 1);
4101 if (str_starts(start
, WPA_EVENT_BSS_REMOVED
)) {
4102 s
= os_strchr(start
, ' ');
4105 s
= os_strchr(s
+ 1, ' ');
4108 cli_txt_list_del_addr(&bsses
, s
+ 1);
4113 if (str_starts(start
, P2P_EVENT_DEVICE_FOUND
)) {
4114 s
= os_strstr(start
, " p2p_dev_addr=");
4117 cli_txt_list_add_addr(&p2p_peers
, s
+ 14);
4121 if (str_starts(start
, P2P_EVENT_DEVICE_LOST
)) {
4122 s
= os_strstr(start
, " p2p_dev_addr=");
4125 cli_txt_list_del_addr(&p2p_peers
, s
+ 14);
4129 if (str_starts(start
, P2P_EVENT_GROUP_STARTED
)) {
4130 s
= os_strchr(start
, ' ');
4133 cli_txt_list_add_word(&p2p_groups
, s
+ 1, ' ');
4137 if (str_starts(start
, P2P_EVENT_GROUP_REMOVED
)) {
4138 s
= os_strchr(start
, ' ');
4141 cli_txt_list_del_word(&p2p_groups
, s
+ 1, ' ');
4144 #endif /* CONFIG_P2P */
4148 static int check_terminating(const char *msg
)
4150 const char *pos
= msg
;
4154 pos
= os_strchr(pos
, '>');
4161 if (str_starts(pos
, WPA_EVENT_TERMINATING
) && ctrl_conn
) {
4163 printf("\rConnection to wpa_supplicant lost - trying to "
4166 wpa_cli_attached
= 0;
4167 wpa_cli_close_connection();
4175 static void wpa_cli_recv_pending(struct wpa_ctrl
*ctrl
, int action_monitor
)
4177 if (ctrl_conn
== NULL
) {
4178 wpa_cli_reconnect();
4181 while (wpa_ctrl_pending(ctrl
) > 0) {
4183 size_t len
= sizeof(buf
) - 1;
4184 if (wpa_ctrl_recv(ctrl
, buf
, &len
) == 0) {
4187 wpa_cli_action_process(buf
);
4190 if (wpa_cli_show_event(buf
)) {
4192 printf("\r%s\n", buf
);
4196 if (interactive
&& check_terminating(buf
) > 0)
4200 printf("Could not read pending message.\n");
4205 if (wpa_ctrl_pending(ctrl
) < 0) {
4206 printf("Connection to wpa_supplicant lost - trying to "
4208 wpa_cli_reconnect();
4213 static void wpa_cli_ping(void *eloop_ctx
, void *timeout_ctx
)
4217 char *prefix
= ifname_prefix
;
4219 ifname_prefix
= NULL
;
4220 res
= _wpa_ctrl_command(ctrl_conn
, "PING", 0);
4221 ifname_prefix
= prefix
;
4223 printf("Connection to wpa_supplicant lost - trying to "
4225 wpa_cli_close_connection();
4229 wpa_cli_reconnect();
4230 eloop_register_timeout(ping_interval
, 0, wpa_cli_ping
, NULL
, NULL
);
4234 static void wpa_cli_mon_receive(int sock
, void *eloop_ctx
, void *sock_ctx
)
4236 wpa_cli_recv_pending(mon_conn
, 0);
4240 static void wpa_cli_edit_cmd_cb(void *ctx
, char *cmd
)
4242 char *argv
[max_args
];
4244 argc
= tokenize_cmd(cmd
, argv
);
4246 wpa_request(ctrl_conn
, argc
, argv
);
4250 static void wpa_cli_edit_eof_cb(void *ctx
)
4256 static int warning_displayed
= 0;
4257 static char *hfile
= NULL
;
4258 static int edit_started
= 0;
4260 static void start_edit(void)
4265 #ifdef CONFIG_CTRL_IFACE_UDP_REMOTE
4266 ps
= wpa_ctrl_get_remote_ifname(ctrl_conn
);
4267 #endif /* CONFIG_CTRL_IFACE_UDP_REMOTE */
4269 #ifdef CONFIG_WPA_CLI_HISTORY_DIR
4270 home
= CONFIG_WPA_CLI_HISTORY_DIR
;
4271 #else /* CONFIG_WPA_CLI_HISTORY_DIR */
4272 home
= getenv("HOME");
4273 #endif /* CONFIG_WPA_CLI_HISTORY_DIR */
4275 const char *fname
= ".wpa_cli_history";
4276 int hfile_len
= os_strlen(home
) + 1 + os_strlen(fname
) + 1;
4277 hfile
= os_malloc(hfile_len
);
4279 os_snprintf(hfile
, hfile_len
, "%s/%s", home
, fname
);
4282 if (edit_init(wpa_cli_edit_cmd_cb
, wpa_cli_edit_eof_cb
,
4283 wpa_cli_edit_completion_cb
, NULL
, hfile
, ps
) < 0) {
4289 eloop_register_timeout(ping_interval
, 0, wpa_cli_ping
, NULL
, NULL
);
4293 static void update_bssid_list(struct wpa_ctrl
*ctrl
)
4296 size_t len
= sizeof(buf
);
4298 const char *cmd
= "BSS RANGE=ALL MASK=0x2";
4303 ret
= wpa_ctrl_request(ctrl
, cmd
, os_strlen(cmd
), buf
, &len
, NULL
);
4310 pos
= os_strstr(pos
, "bssid=");
4314 end
= os_strchr(pos
, '\n');
4318 cli_txt_list_add(&bsses
, pos
);
4324 static void update_ifnames(struct wpa_ctrl
*ctrl
)
4327 size_t len
= sizeof(buf
);
4329 const char *cmd
= "INTERFACES";
4333 cli_txt_list_flush(&ifnames
);
4337 ret
= wpa_ctrl_request(ctrl
, cmd
, os_strlen(cmd
), buf
, &len
, NULL
);
4344 end
= os_strchr(pos
, '\n');
4348 ret
= os_snprintf(txt
, sizeof(txt
), "ifname=%s", pos
);
4349 if (!os_snprintf_error(sizeof(txt
), ret
))
4350 cli_txt_list_add(&ifnames
, txt
);
4356 static void update_creds(struct wpa_ctrl
*ctrl
)
4359 size_t len
= sizeof(buf
);
4361 const char *cmd
= "LIST_CREDS";
4365 cli_txt_list_flush(&creds
);
4369 ret
= wpa_ctrl_request(ctrl
, cmd
, os_strlen(cmd
), buf
, &len
, NULL
);
4376 end
= os_strchr(pos
, '\n');
4381 cli_txt_list_add_word(&creds
, pos
, '\t');
4388 static void update_networks(struct wpa_ctrl
*ctrl
)
4391 size_t len
= sizeof(buf
);
4393 const char *cmd
= "LIST_NETWORKS";
4397 cli_txt_list_flush(&networks
);
4401 ret
= wpa_ctrl_request(ctrl
, cmd
, os_strlen(cmd
), buf
, &len
, NULL
);
4408 end
= os_strchr(pos
, '\n');
4413 cli_txt_list_add_word(&networks
, pos
, '\t');
4420 static void update_stations(struct wpa_ctrl
*ctrl
)
4423 char addr
[32], cmd
[64];
4425 if (!ctrl
|| !interactive
)
4428 cli_txt_list_flush(&stations
);
4430 if (wpa_ctrl_command_sta(ctrl
, "STA-FIRST", addr
, sizeof(addr
), 0))
4433 if (os_strcmp(addr
, "") != 0)
4434 cli_txt_list_add(&stations
, addr
);
4435 os_snprintf(cmd
, sizeof(cmd
), "STA-NEXT %s", addr
);
4436 } while (wpa_ctrl_command_sta(ctrl
, cmd
, addr
, sizeof(addr
), 0) == 0);
4437 #endif /* CONFIG_AP */
4441 static void try_connection(void *eloop_ctx
, void *timeout_ctx
)
4446 if (ctrl_ifname
== NULL
)
4447 ctrl_ifname
= wpa_cli_get_default_ifname();
4449 if (wpa_cli_open_connection(ctrl_ifname
, 1)) {
4450 if (!warning_displayed
) {
4451 printf("Could not connect to wpa_supplicant: "
4453 ctrl_ifname
? ctrl_ifname
: "(nil)");
4454 warning_displayed
= 1;
4456 eloop_register_timeout(1, 0, try_connection
, NULL
, NULL
);
4460 update_bssid_list(ctrl_conn
);
4461 update_creds(ctrl_conn
);
4462 update_networks(ctrl_conn
);
4463 update_stations(ctrl_conn
);
4465 if (warning_displayed
)
4466 printf("Connection established.\n");
4473 static void wpa_cli_interactive(void)
4475 printf("\nInteractive mode\n\n");
4477 eloop_register_timeout(0, 0, try_connection
, NULL
, NULL
);
4479 eloop_cancel_timeout(try_connection
, NULL
, NULL
);
4481 cli_txt_list_flush(&p2p_peers
);
4482 cli_txt_list_flush(&p2p_groups
);
4483 cli_txt_list_flush(&bsses
);
4484 cli_txt_list_flush(&ifnames
);
4485 cli_txt_list_flush(&creds
);
4486 cli_txt_list_flush(&networks
);
4488 edit_deinit(hfile
, wpa_cli_edit_filter_history_cb
);
4490 eloop_cancel_timeout(wpa_cli_ping
, NULL
, NULL
);
4491 wpa_cli_close_connection();
4495 static void wpa_cli_action_ping(void *eloop_ctx
, void *timeout_ctx
)
4497 struct wpa_ctrl
*ctrl
= eloop_ctx
;
4501 /* verify that connection is still working */
4502 len
= sizeof(buf
) - 1;
4503 if (wpa_ctrl_request(ctrl
, "PING", 4, buf
, &len
,
4504 wpa_cli_action_cb
) < 0 ||
4505 len
< 4 || os_memcmp(buf
, "PONG", 4) != 0) {
4506 printf("wpa_supplicant did not reply to PING command - exiting\n");
4510 eloop_register_timeout(ping_interval
, 0, wpa_cli_action_ping
,
4515 static void wpa_cli_action_receive(int sock
, void *eloop_ctx
, void *sock_ctx
)
4517 struct wpa_ctrl
*ctrl
= eloop_ctx
;
4519 wpa_cli_recv_pending(ctrl
, 1);
4523 static void wpa_cli_action(struct wpa_ctrl
*ctrl
)
4525 #ifdef CONFIG_ANSI_C_EXTRA
4526 /* TODO: ANSI C version(?) */
4527 printf("Action processing not supported in ANSI C build.\n");
4528 #else /* CONFIG_ANSI_C_EXTRA */
4531 fd
= wpa_ctrl_get_fd(ctrl
);
4532 eloop_register_timeout(ping_interval
, 0, wpa_cli_action_ping
,
4534 eloop_register_read_sock(fd
, wpa_cli_action_receive
, ctrl
, NULL
);
4536 eloop_cancel_timeout(wpa_cli_action_ping
, ctrl
, NULL
);
4537 eloop_unregister_read_sock(fd
);
4538 #endif /* CONFIG_ANSI_C_EXTRA */
4542 static void wpa_cli_cleanup(void)
4544 wpa_cli_close_connection();
4546 os_daemonize_terminate(pid_file
);
4548 os_program_deinit();
4552 static void wpa_cli_terminate(int sig
, void *ctx
)
4558 static char * wpa_cli_get_default_ifname(void)
4560 char *ifname
= NULL
;
4563 char ifprop
[PROPERTY_VALUE_MAX
];
4564 if (property_get("wifi.interface", ifprop
, NULL
) != 0) {
4565 ifname
= os_strdup(ifprop
);
4566 printf("Using interface '%s'\n", ifname
? ifname
: "N/A");
4569 #ifdef CONFIG_CTRL_IFACE_UNIX
4570 struct dirent
*dent
;
4571 DIR *dir
= opendir(ctrl_iface_dir
);
4575 while ((dent
= readdir(dir
))) {
4576 #ifdef _DIRENT_HAVE_D_TYPE
4578 * Skip the file if it is not a socket. Also accept
4579 * DT_UNKNOWN (0) in case the C library or underlying
4580 * file system does not support d_type.
4582 if (dent
->d_type
!= DT_SOCK
&& dent
->d_type
!= DT_UNKNOWN
)
4584 #endif /* _DIRENT_HAVE_D_TYPE */
4585 if (os_strcmp(dent
->d_name
, ".") == 0 ||
4586 os_strcmp(dent
->d_name
, "..") == 0)
4588 printf("Selected interface '%s'\n", dent
->d_name
);
4589 ifname
= os_strdup(dent
->d_name
);
4593 #endif /* CONFIG_CTRL_IFACE_UNIX */
4595 #ifdef CONFIG_CTRL_IFACE_NAMED_PIPE
4596 char buf
[4096], *pos
;
4598 struct wpa_ctrl
*ctrl
;
4601 ctrl
= wpa_ctrl_open(NULL
);
4605 len
= sizeof(buf
) - 1;
4606 ret
= wpa_ctrl_request(ctrl
, "INTERFACES", 10, buf
, &len
, NULL
);
4609 pos
= os_strchr(buf
, '\n');
4612 ifname
= os_strdup(buf
);
4614 wpa_ctrl_close(ctrl
);
4615 #endif /* CONFIG_CTRL_IFACE_NAMED_PIPE */
4616 #endif /* ANDROID */
4622 int main(int argc
, char *argv
[])
4628 if (os_program_init())
4632 c
= getopt(argc
, argv
, "a:Bg:G:hi:p:P:s:v");
4637 action_file
= optarg
;
4646 ping_interval
= atoi(optarg
);
4652 printf("%s\n", wpa_cli_version
);
4655 os_free(ctrl_ifname
);
4656 ctrl_ifname
= os_strdup(optarg
);
4659 ctrl_iface_dir
= optarg
;
4665 client_socket_dir
= optarg
;
4673 interactive
= (argc
== optind
) && (action_file
== NULL
);
4676 printf("%s\n\n%s\n\n", wpa_cli_version
, cli_license
);
4681 if (global
&& wpa_cli_open_global_ctrl() < 0)
4684 eloop_register_signal_terminate(wpa_cli_terminate
, NULL
);
4686 if (ctrl_ifname
== NULL
)
4687 ctrl_ifname
= wpa_cli_get_default_ifname();
4690 wpa_cli_interactive();
4693 wpa_cli_open_connection(ctrl_ifname
, 0) < 0) {
4694 fprintf(stderr
, "Failed to connect to non-global "
4695 "ctrl_ifname: %s error: %s\n",
4696 ctrl_ifname
? ctrl_ifname
: "(nil)",
4702 if (wpa_ctrl_attach(ctrl_conn
) == 0) {
4703 wpa_cli_attached
= 1;
4705 printf("Warning: Failed to attach to "
4706 "wpa_supplicant.\n");
4711 if (daemonize
&& os_daemonize(pid_file
) && eloop_sock_requeue())
4715 wpa_cli_action(ctrl_conn
);
4717 ret
= wpa_request(ctrl_conn
, argc
- optind
,
4721 os_free(ctrl_ifname
);
4728 #else /* CONFIG_CTRL_IFACE */
4729 int main(int argc
, char *argv
[])
4731 printf("CONFIG_CTRL_IFACE not defined - wpa_cli disabled\n");
4734 #endif /* CONFIG_CTRL_IFACE */