]> git.ipfire.org Git - thirdparty/hostap.git/blame - wpa_supplicant/wpa_cli.c
projects / thirdparty / hostap.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
hostapd_cli: Process events received following control iface commands
[thirdparty/hostap.git] / wpa_supplicant / wpa_cli.c
CommitLineData
6fc6879b
JM		 1/*
2 * WPA Supplicant - command line interface for wpa_supplicant daemon
15c56067 3 * Copyright (c) 2004-2016, Jouni Malinen <j@w1.fi>
6fc6879b 4 *
0f3d578e
JM		 5 * This software may be distributed under the terms of the BSD license.
6 * See README for more details.
6fc6879b
JM		 7 */
8
9#include "includes.h"
10
11#ifdef CONFIG_CTRL_IFACE
12
13#ifdef CONFIG_CTRL_IFACE_UNIX
14#include <dirent.h>
15#endif /* CONFIG_CTRL_IFACE_UNIX */
6fc6879b 16
977c0796 17#include "common/cli.h"
90973fb2 18#include "common/wpa_ctrl.h"
cd101567
JM		 19#include "utils/common.h"
20#include "utils/eloop.h"
82a855bd 21#include "utils/edit.h"
a624f20b 22#include "utils/list.h"
90973fb2 23#include "common/version.h"
a8918e86 24#include "common/ieee802_11_defs.h"
b1001e4c
DS		 25#ifdef ANDROID
26#include <cutils/properties.h>
27#endif /* ANDROID */
6fc6879b
JM		 28
29
8b423edb 30static const char *const wpa_cli_version =
6fc6879b 31"wpa_cli v" VERSION_STR "\n"
15c56067 32"Copyright (c) 2004-2016, Jouni Malinen <j@w1.fi> and contributors";
6fc6879b 33
cdcb2d0e
PK		 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)"
39
6fc6879b 40static struct wpa_ctrl *ctrl_conn;
4a3ade4e 41static struct wpa_ctrl *mon_conn;
6fc6879b
JM		 42static int wpa_cli_quit = 0;
43static int wpa_cli_attached = 0;
02a3e5c0 44static int wpa_cli_connected = -1;
6fc6879b 45static int wpa_cli_last_id = 0;
c5c5817c
JM		 46#ifndef CONFIG_CTRL_IFACE_DIR
47#define CONFIG_CTRL_IFACE_DIR "/var/run/wpa_supplicant"
48#endif /* CONFIG_CTRL_IFACE_DIR */
49static const char *ctrl_iface_dir = CONFIG_CTRL_IFACE_DIR;
4ae71209 50static const char *client_socket_dir = NULL;
6fc6879b
JM		 51static char *ctrl_ifname = NULL;
52static const char *pid_file = NULL;
53static const char *action_file = NULL;
1cc84c1c 54static int ping_interval = 5;
4a3ade4e 55static int interactive = 0;
13b11ba7 56static char *ifname_prefix = NULL;
6fc6879b 57
a624f20b
JM		 58static DEFINE_DL_LIST(bsses); /* struct cli_txt_entry */
59static DEFINE_DL_LIST(p2p_peers); /* struct cli_txt_entry */
76788542 60static DEFINE_DL_LIST(p2p_groups); /* struct cli_txt_entry */
37620493 61static DEFINE_DL_LIST(ifnames); /* struct cli_txt_entry */
32a097fd 62static DEFINE_DL_LIST(networks); /* struct cli_txt_entry */
a624f20b 63
6fc6879b 64
2af4d404 65static void print_help(const char *cmd);
cd101567 66static void wpa_cli_mon_receive(int sock, void *eloop_ctx, void *sock_ctx);
d62aaa7d 67static void wpa_cli_close_connection(void);
8e897ae3 68static char * wpa_cli_get_default_ifname(void);
2af4d404 69static char ** wpa_list_cmd_list(void);
32a097fd 70static void update_networks(struct wpa_ctrl *ctrl);
dfa141b1
ER		 71
72
6fc6879b
JM		 73static void usage(void)
74{
75 printf("wpa_cli [-p<path to ctrl sockets>] [-i<ifname>] [-hvB] "
76 "[-a<action file>] \\\n"
4ae71209
MM		 77 " [-P<pid file>] [-g<global ctrl>] [-G<ping interval>] "
78 "\\\n"
79 " [-s<wpa_client_socket_file_path>] "
1cc84c1c 80 "[command..]\n"
6fc6879b
JM		 81 " -h = help (show this usage text)\n"
82 " -v = shown version information\n"
83 " -a = run in daemon mode executing the action file based on "
84 "events from\n"
85 " wpa_supplicant\n"
86 " -B = run a daemon in the background\n"
c5c5817c 87 " default path: " CONFIG_CTRL_IFACE_DIR "\n"
dfa141b1 88 " default interface: first interface found in socket path\n");
2af4d404 89 print_help(NULL);
6fc6879b
JM		 90}
91
92
f3f0f648
JM		 93static int wpa_cli_show_event(const char *event)
94{
95 const char *start;
96
97 start = os_strchr(event, '>');
98 if (start == NULL)
99 return 1;
100
101 start++;
102 /*
103 * Skip BSS added/removed events since they can be relatively frequent
104 * and are likely of not much use for an interactive user.
105 */
106 if (str_starts(start, WPA_EVENT_BSS_ADDED) ||
107 str_starts(start, WPA_EVENT_BSS_REMOVED))
108 return 0;
109
110 return 1;
111}
112
113
4a3ade4e 114static int wpa_cli_open_connection(const char *ifname, int attach)
6fc6879b
JM		 115{
116#if defined(CONFIG_CTRL_IFACE_UDP) || defined(CONFIG_CTRL_IFACE_NAMED_PIPE)
117 ctrl_conn = wpa_ctrl_open(ifname);
4a3ade4e
JM		 118 if (ctrl_conn == NULL)
119 return -1;
120
121 if (attach && interactive)
122 mon_conn = wpa_ctrl_open(ifname);
123 else
124 mon_conn = NULL;
6fc6879b 125#else /* CONFIG_CTRL_IFACE_UDP || CONFIG_CTRL_IFACE_NAMED_PIPE */
b1001e4c 126 char *cfile = NULL;
6fc6879b
JM		 127 int flen, res;
128
129 if (ifname == NULL)
4a3ade4e 130 return -1;
6fc6879b 131
b1001e4c
DS		 132#ifdef ANDROID
133 if (access(ctrl_iface_dir, F_OK) < 0) {
134 cfile = os_strdup(ifname);
135 if (cfile == NULL)
136 return -1;
137 }
138#endif /* ANDROID */
139
4ae71209
MM		 140 if (client_socket_dir && client_socket_dir[0] &&
141 access(client_socket_dir, F_OK) < 0) {
142 perror(client_socket_dir);
143 os_free(cfile);
144 return -1;
145 }
146
b1001e4c
DS		 147 if (cfile == NULL) {
148 flen = os_strlen(ctrl_iface_dir) + os_strlen(ifname) + 2;
149 cfile = os_malloc(flen);
150 if (cfile == NULL)
151 return -1;
152 res = os_snprintf(cfile, flen, "%s/%s", ctrl_iface_dir,
153 ifname);
d85e1fc8 154 if (os_snprintf_error(flen, res)) {
b1001e4c
DS		 155 os_free(cfile);
156 return -1;
157 }
6fc6879b
JM		 158 }
159
4ae71209 160 ctrl_conn = wpa_ctrl_open2(cfile, client_socket_dir);
4a3ade4e
JM		 161 if (ctrl_conn == NULL) {
162 os_free(cfile);
163 return -1;
164 }
165
166 if (attach && interactive)
4ae71209 167 mon_conn = wpa_ctrl_open2(cfile, client_socket_dir);
4a3ade4e
JM		 168 else
169 mon_conn = NULL;
6fc6879b 170 os_free(cfile);
6fc6879b 171#endif /* CONFIG_CTRL_IFACE_UDP || CONFIG_CTRL_IFACE_NAMED_PIPE */
4a3ade4e
JM		 172
173 if (mon_conn) {
174 if (wpa_ctrl_attach(mon_conn) == 0) {
175 wpa_cli_attached = 1;
cd101567
JM		 176 if (interactive)
177 eloop_register_read_sock(
178 wpa_ctrl_get_fd(mon_conn),
179 wpa_cli_mon_receive, NULL, NULL);
4a3ade4e
JM		 180 } else {
181 printf("Warning: Failed to attach to "
182 "wpa_supplicant.\n");
d62aaa7d 183 wpa_cli_close_connection();
4a3ade4e
JM		 184 return -1;
185 }
186 }
187
188 return 0;
6fc6879b
JM		 189}
190
191
192static void wpa_cli_close_connection(void)
193{
194 if (ctrl_conn == NULL)
195 return;
196
197 if (wpa_cli_attached) {
4a3ade4e 198 wpa_ctrl_detach(interactive ? mon_conn : ctrl_conn);
6fc6879b
JM		 199 wpa_cli_attached = 0;
200 }
201 wpa_ctrl_close(ctrl_conn);
202 ctrl_conn = NULL;
4a3ade4e 203 if (mon_conn) {
cd101567 204 eloop_unregister_read_sock(wpa_ctrl_get_fd(mon_conn));
4a3ade4e
JM		 205 wpa_ctrl_close(mon_conn);
206 mon_conn = NULL;
207 }
6fc6879b
JM		 208}
209
210
211static void wpa_cli_msg_cb(char *msg, size_t len)
212{
213 printf("%s\n", msg);
214}
215
216
217static int _wpa_ctrl_command(struct wpa_ctrl *ctrl, char *cmd, int print)
218{
aec309c4 219 char buf[4096];
6fc6879b
JM		 220 size_t len;
221 int ret;
222
223 if (ctrl_conn == NULL) {
224 printf("Not connected to wpa_supplicant - command dropped.\n");
225 return -1;
226 }
13b11ba7
JM		 227 if (ifname_prefix) {
228 os_snprintf(buf, sizeof(buf), "IFNAME=%s %s",
229 ifname_prefix, cmd);
230 buf[sizeof(buf) - 1] = '\0';
231 cmd = buf;
232 }
6fc6879b
JM		 233 len = sizeof(buf) - 1;
234 ret = wpa_ctrl_request(ctrl, cmd, os_strlen(cmd), buf, &len,
235 wpa_cli_msg_cb);
236 if (ret == -2) {
237 printf("'%s' command timed out.\n", cmd);
238 return -2;
239 } else if (ret < 0) {
240 printf("'%s' command failed.\n", cmd);
241 return -1;
242 }
243 if (print) {
244 buf[len] = '\0';
245 printf("%s", buf);
a432bafb
JM		 246 if (interactive && len > 0 && buf[len - 1] != '\n')
247 printf("\n");
6fc6879b
JM		 248 }
249 return 0;
250}
251
252
253static int wpa_ctrl_command(struct wpa_ctrl *ctrl, char *cmd)
254{
255 return _wpa_ctrl_command(ctrl, cmd, 1);
256}
257
258
0076869c
JM		 259static int wpa_cli_cmd(struct wpa_ctrl *ctrl, const char *cmd, int min_args,
260 int argc, char *argv[])
261{
28fcfb67 262 char buf[4096];
0076869c
JM		 263 if (argc < min_args) {
264 printf("Invalid %s command - at least %d argument%s "
265 "required.\n", cmd, min_args,
266 min_args > 1 ? "s are" : " is");
267 return -1;
268 }
269 if (write_cmd(buf, sizeof(buf), cmd, argc, argv) < 0)
270 return -1;
271 return wpa_ctrl_command(ctrl, buf);
272}
273
274
0eed2a8d
JD		 275static int wpa_cli_cmd_ifname(struct wpa_ctrl *ctrl, int argc, char *argv[])
276{
277 return wpa_ctrl_command(ctrl, "IFNAME");
278}
279
280
6fc6879b
JM		 281static int wpa_cli_cmd_status(struct wpa_ctrl *ctrl, int argc, char *argv[])
282{
0bc13468
JM		 283 if (argc > 0 && os_strcmp(argv[0], "verbose") == 0)
284 return wpa_ctrl_command(ctrl, "STATUS-VERBOSE");
285 if (argc > 0 && os_strcmp(argv[0], "wps") == 0)
286 return wpa_ctrl_command(ctrl, "STATUS-WPS");
a771c07d
JM		 287 if (argc > 0 && os_strcmp(argv[0], "driver") == 0)
288 return wpa_ctrl_command(ctrl, "STATUS-DRIVER");
2665c26f
DU		 289#ifdef ANDROID
290 if (argc > 0 && os_strcmp(argv[0], "no_events") == 0)
291 return wpa_ctrl_command(ctrl, "STATUS-NO_EVENTS");
292#endif /* ANDROID */
0bc13468 293 return wpa_ctrl_command(ctrl, "STATUS");
6fc6879b
JM		 294}
295
296
297static int wpa_cli_cmd_ping(struct wpa_ctrl *ctrl, int argc, char *argv[])
298{
299 return wpa_ctrl_command(ctrl, "PING");
300}
301
302
ac6912b5
BG		 303static int wpa_cli_cmd_relog(struct wpa_ctrl *ctrl, int argc, char *argv[])
304{
305 return wpa_ctrl_command(ctrl, "RELOG");
306}
307
308
77895cd9
JM		 309static int wpa_cli_cmd_note(struct wpa_ctrl *ctrl, int argc, char *argv[])
310{
0076869c 311 return wpa_cli_cmd(ctrl, "NOTE", 1, argc, argv);
77895cd9
JM		 312}
313
314
6fc6879b
JM		 315static int wpa_cli_cmd_mib(struct wpa_ctrl *ctrl, int argc, char *argv[])
316{
317 return wpa_ctrl_command(ctrl, "MIB");
318}
319
320
321static int wpa_cli_cmd_pmksa(struct wpa_ctrl *ctrl, int argc, char *argv[])
322{
323 return wpa_ctrl_command(ctrl, "PMKSA");
324}
325
326
79e2b1cc
AK		 327static int wpa_cli_cmd_pmksa_flush(struct wpa_ctrl *ctrl, int argc,
328 char *argv[])
329{
330 return wpa_ctrl_command(ctrl, "PMKSA_FLUSH");
331}
332
333
6fc6879b
JM		 334static int wpa_cli_cmd_help(struct wpa_ctrl *ctrl, int argc, char *argv[])
335{
2af4d404 336 print_help(argc > 0 ? argv[0] : NULL);
6fc6879b
JM		 337 return 0;
338}
339
340
2af4d404
JM		 341static char ** wpa_cli_complete_help(const char *str, int pos)
342{
343 int arg = get_cmd_arg_num(str, pos);
344 char **res = NULL;
345
346 switch (arg) {
347 case 1:
348 res = wpa_list_cmd_list();
349 break;
350 }
351
352 return res;
353}
354
355
6fc6879b
JM		 356static int wpa_cli_cmd_license(struct wpa_ctrl *ctrl, int argc, char *argv[])
357{
23c130e9 358 printf("%s\n\n%s\n", wpa_cli_version, cli_full_license);
6fc6879b
JM		 359 return 0;
360}
361
362
363static int wpa_cli_cmd_quit(struct wpa_ctrl *ctrl, int argc, char *argv[])
364{
365 wpa_cli_quit = 1;
cd101567
JM		 366 if (interactive)
367 eloop_terminate();
6fc6879b
JM		 368 return 0;
369}
370
371
6fc6879b
JM		 372static int wpa_cli_cmd_set(struct wpa_ctrl *ctrl, int argc, char *argv[])
373{
374 char cmd[256];
375 int res;
376
f1fb042c 377 if (argc == 1) {
40eac890 378 res = os_snprintf(cmd, sizeof(cmd), "SET %s ", argv[0]);
eeab4f2f 379 if (os_snprintf_error(sizeof(cmd), res)) {
f1fb042c
JM		 380 printf("Too long SET command.\n");
381 return -1;
382 }
383 return wpa_ctrl_command(ctrl, cmd);
6fc6879b 384 }
f1fb042c
JM		 385
386 return wpa_cli_cmd(ctrl, "SET", 2, argc, argv);
6fc6879b
JM		 387}
388
389
21565872
JM		 390static char ** wpa_cli_complete_set(const char *str, int pos)
391{
392 int arg = get_cmd_arg_num(str, pos);
393 const char *fields[] = {
394 /* runtime values */
395 "EAPOL::heldPeriod", "EAPOL::authPeriod", "EAPOL::startPeriod",
396 "EAPOL::maxStart", "dot11RSNAConfigPMKLifetime",
397 "dot11RSNAConfigPMKReauthThreshold", "dot11RSNAConfigSATimeout",
398 "wps_fragment_size", "wps_version_number", "ampdu",
399 "tdls_testing", "tdls_disabled", "pno", "radio_disabled",
400 "uapsd", "ps", "wifi_display", "bssid_filter", "disallow_aps",
401 "no_keep_alive",
402 /* global configuration parameters */
8ffaafae
MK		 403#ifdef CONFIG_CTRL_IFACE
404 "ctrl_interface", "no_ctrl_interface", "ctrl_interface_group",
405#endif /* CONFIG_CTRL_IFACE */
406 "eapol_version", "ap_scan", "bgscan",
407#ifdef CONFIG_MESH
408 "user_mpm", "max_peer_links", "mesh_max_inactivity",
ecd40fef 409 "dot11RSNASAERetransPeriod",
8ffaafae
MK		 410#endif /* CONFIG_MESH */
411 "disable_scan_offload", "fast_reauth", "opensc_engine_path",
412 "pkcs11_engine_path", "pkcs11_module_path", "openssl_ciphers",
413 "pcsc_reader", "pcsc_pin", "external_sim", "driver_param",
414 "dot11RSNAConfigPMKLifetime",
21565872
JM		 415 "dot11RSNAConfigPMKReauthThreshold",
416 "dot11RSNAConfigSATimeout",
8ffaafae
MK		 417#ifndef CONFIG_NO_CONFIG_WRITE
418 "update_config",
419#endif /* CONFIG_NO_CONFIG_WRITE */
420 "load_dynamic_eap",
421#ifdef CONFIG_WPS
422 "uuid", "device_name", "manufacturer", "model_name",
423 "model_number", "serial_number", "device_type", "os_version",
424 "config_methods", "wps_cred_processing", "wps_vendor_ext_m1",
425#endif /* CONFIG_WPS */
426#ifdef CONFIG_P2P
427 "sec_device_type",
21565872 428 "p2p_listen_reg_class", "p2p_listen_channel",
8ffaafae
MK		 429 "p2p_oper_reg_class", "p2p_oper_channel", "p2p_go_intent",
430 "p2p_ssid_postfix", "persistent_reconnect", "p2p_intra_bss",
431 "p2p_group_idle", "p2p_passphrase_len", "p2p_pref_chan",
432 "p2p_no_go_freq", "p2p_add_cli_chan",
433 "p2p_optimize_listen_chan", "p2p_go_ht40", "p2p_go_vht",
434 "p2p_disabled", "p2p_go_ctwindow", "p2p_no_group_iface",
435 "p2p_ignore_shared_freq", "ip_addr_go", "ip_addr_mask",
436 "ip_addr_start", "ip_addr_end",
437#endif /* CONFIG_P2P */
438 "country", "bss_max_count", "bss_expiration_age",
439 "bss_expiration_scan_count", "filter_ssids", "filter_rssi",
440 "max_num_sta", "disassoc_low_ack",
441#ifdef CONFIG_HS20
442 "hs20",
443#endif /* CONFIG_HS20 */
444 "interworking", "hessid", "access_network_type", "pbc_in_m1",
445 "autoscan", "wps_nfc_dev_pw_id", "wps_nfc_dh_pubkey",
446 "wps_nfc_dh_privkey", "wps_nfc_dev_pw", "ext_password_backend",
21565872 447 "p2p_go_max_inactivity", "auto_interworking", "okc", "pmf",
8ffaafae
MK		 448 "sae_groups", "dtim_period", "beacon_int",
449 "ap_vendor_elements", "ignore_old_scan_res", "freq_list",
450 "scan_cur_freq", "sched_scan_interval",
451 "tdls_external_control", "osu_dir", "wowlan_triggers",
452 "p2p_search_delay", "mac_addr", "rand_addr_lifetime",
453 "preassoc_mac_addr", "key_mgmt_offload", "passive_scan",
02adead5
MK		 454 "reassoc_same_bss_optim", "wps_priority",
455#ifdef CONFIG_TESTING_OPTIONS
456 "ignore_auth_resp",
457#endif /* CONFIG_TESTING_OPTIONS */
21565872 458 };
e7ecab4a 459 int i, num_fields = ARRAY_SIZE(fields);
21565872
JM		 460
461 if (arg == 1) {
462 char **res = os_calloc(num_fields + 1, sizeof(char *));
463 if (res == NULL)
464 return NULL;
465 for (i = 0; i < num_fields; i++) {
466 res[i] = os_strdup(fields[i]);
467 if (res[i] == NULL)
468 return res;
469 }
470 return res;
471 }
472
69aa3341
JM		 473 if (arg > 1 && os_strncasecmp(str, "set bssid_filter ", 17) == 0)
474 return cli_txt_list_array(&bsses);
475
21565872
JM		 476 return NULL;
477}
478
10263dc2
OO		 479static int wpa_cli_cmd_dump(struct wpa_ctrl *ctrl, int argc, char *argv[])
480{
481 return wpa_ctrl_command(ctrl, "DUMP");
482}
483
21565872 484
4d7aab78
EL		 485static int wpa_cli_cmd_driver_flags(struct wpa_ctrl *ctrl, int argc,
486 char *argv[])
487{
488 return wpa_ctrl_command(ctrl, "DRIVER_FLAGS");
489}
490
491
acec8d32
JM		 492static int wpa_cli_cmd_get(struct wpa_ctrl *ctrl, int argc, char *argv[])
493{
87c7ba84 494 return wpa_cli_cmd(ctrl, "GET", 1, argc, argv);
acec8d32
JM		 495}
496
497
0fd9d95f
MK		 498static char ** wpa_cli_complete_get(const char *str, int pos)
499{
500 int arg = get_cmd_arg_num(str, pos);
501 const char *fields[] = {
502#ifdef CONFIG_CTRL_IFACE
503 "ctrl_interface", "ctrl_interface_group",
504#endif /* CONFIG_CTRL_IFACE */
505 "eapol_version", "ap_scan",
506#ifdef CONFIG_MESH
507 "user_mpm", "max_peer_links", "mesh_max_inactivity",
508#endif /* CONFIG_MESH */
509 "disable_scan_offload", "fast_reauth", "opensc_engine_path",
510 "pkcs11_engine_path", "pkcs11_module_path", "openssl_ciphers",
511 "pcsc_reader", "pcsc_pin", "external_sim", "driver_param",
512 "dot11RSNAConfigPMKLifetime",
513 "dot11RSNAConfigPMKReauthThreshold",
514 "dot11RSNAConfigSATimeout",
515#ifndef CONFIG_NO_CONFIG_WRITE
516 "update_config",
517#endif /* CONFIG_NO_CONFIG_WRITE */
518#ifdef CONFIG_WPS
519 "device_name", "manufacturer", "model_name", "model_number",
520 "serial_number", "config_methods", "wps_cred_processing",
521#endif /* CONFIG_WPS */
522#ifdef CONFIG_P2P
523 "p2p_listen_reg_class", "p2p_listen_channel",
524 "p2p_oper_reg_class", "p2p_oper_channel", "p2p_go_intent",
525 "p2p_ssid_postfix", "persistent_reconnect", "p2p_intra_bss",
526 "p2p_group_idle", "p2p_passphrase_len", "p2p_add_cli_chan",
527 "p2p_optimize_listen_chan", "p2p_go_ht40", "p2p_go_vht",
528 "p2p_disabled", "p2p_go_ctwindow", "p2p_no_group_iface",
529 "p2p_ignore_shared_freq", "ip_addr_go", "ip_addr_mask",
530 "ip_addr_start", "ip_addr_end",
531#endif /* CONFIG_P2P */
532 "bss_max_count", "bss_expiration_age",
533 "bss_expiration_scan_count", "filter_ssids", "filter_rssi",
534 "max_num_sta", "disassoc_low_ack",
535#ifdef CONFIG_HS20
536 "hs20",
537#endif /* CONFIG_HS20 */
538 "interworking", "access_network_type", "pbc_in_m1", "autoscan",
539 "wps_nfc_dev_pw_id", "ext_password_backend",
540 "p2p_go_max_inactivity", "auto_interworking", "okc", "pmf",
541 "dtim_period", "beacon_int", "ignore_old_scan_res",
542 "scan_cur_freq", "sched_scan_interval",
543 "tdls_external_control", "osu_dir", "wowlan_triggers",
544 "p2p_search_delay", "mac_addr", "rand_addr_lifetime",
545 "preassoc_mac_addr", "key_mgmt_offload", "passive_scan",
546 "reassoc_same_bss_optim"
547 };
548 int i, num_fields = ARRAY_SIZE(fields);
549
550 if (arg == 1) {
551 char **res = os_calloc(num_fields + 1, sizeof(char *));
552 if (res == NULL)
553 return NULL;
554 for (i = 0; i < num_fields; i++) {
555 res[i] = os_strdup(fields[i]);
556 if (res[i] == NULL)
557 return res;
558 }
559 return res;
560 }
561
562 return NULL;
563}
564
565
6fc6879b
JM		 566static int wpa_cli_cmd_logoff(struct wpa_ctrl *ctrl, int argc, char *argv[])
567{
568 return wpa_ctrl_command(ctrl, "LOGOFF");
569}
570
571
572static int wpa_cli_cmd_logon(struct wpa_ctrl *ctrl, int argc, char *argv[])
573{
574 return wpa_ctrl_command(ctrl, "LOGON");
575}
576
577
578static int wpa_cli_cmd_reassociate(struct wpa_ctrl *ctrl, int argc,
579 char *argv[])
580{
581 return wpa_ctrl_command(ctrl, "REASSOCIATE");
582}
583
584
0f44ec8e
PQ		 585static int wpa_cli_cmd_reattach(struct wpa_ctrl *ctrl, int argc, char *argv[])
586{
587 return wpa_ctrl_command(ctrl, "REATTACH");
588}
589
590
6fc6879b
JM		 591static int wpa_cli_cmd_preauthenticate(struct wpa_ctrl *ctrl, int argc,
592 char *argv[])
593{
87c7ba84 594 return wpa_cli_cmd(ctrl, "PREAUTH", 1, argc, argv);
6fc6879b
JM		 595}
596
597
598static int wpa_cli_cmd_ap_scan(struct wpa_ctrl *ctrl, int argc, char *argv[])
599{
87c7ba84 600 return wpa_cli_cmd(ctrl, "AP_SCAN", 1, argc, argv);
6fc6879b
JM		 601}
602
603
67b9bd08
DS		 604static int wpa_cli_cmd_scan_interval(struct wpa_ctrl *ctrl, int argc,
605 char *argv[])
606{
87c7ba84 607 return wpa_cli_cmd(ctrl, "SCAN_INTERVAL", 1, argc, argv);
67b9bd08
DS		 608}
609
610
78633c37
SL		 611static int wpa_cli_cmd_bss_expire_age(struct wpa_ctrl *ctrl, int argc,
612 char *argv[])
613{
87c7ba84 614 return wpa_cli_cmd(ctrl, "BSS_EXPIRE_AGE", 1, argc, argv);
78633c37
SL		 615}
616
617
618static int wpa_cli_cmd_bss_expire_count(struct wpa_ctrl *ctrl, int argc,
619 char *argv[])
620{
87c7ba84 621 return wpa_cli_cmd(ctrl, "BSS_EXPIRE_COUNT", 1, argc, argv);
78633c37
SL		 622}
623
624
39ee845f
DS		 625static int wpa_cli_cmd_bss_flush(struct wpa_ctrl *ctrl, int argc, char *argv[])
626{
627 char cmd[256];
628 int res;
629
630 if (argc < 1)
631 res = os_snprintf(cmd, sizeof(cmd), "BSS_FLUSH 0");
632 else
633 res = os_snprintf(cmd, sizeof(cmd), "BSS_FLUSH %s", argv[0]);
eeab4f2f 634 if (os_snprintf_error(sizeof(cmd), res)) {
39ee845f
DS		 635 printf("Too long BSS_FLUSH command.\n");
636 return -1;
637 }
638 return wpa_ctrl_command(ctrl, cmd);
639}
640
641
6fc6879b
JM		 642static int wpa_cli_cmd_stkstart(struct wpa_ctrl *ctrl, int argc,
643 char *argv[])
644{
87c7ba84 645 return wpa_cli_cmd(ctrl, "STKSTART", 1, argc, argv);
6fc6879b
JM		 646}
647
648
649static int wpa_cli_cmd_ft_ds(struct wpa_ctrl *ctrl, int argc, char *argv[])
650{
87c7ba84 651 return wpa_cli_cmd(ctrl, "FT_DS", 1, argc, argv);
6fc6879b
JM		 652}
653
654
fcc60db4
JM		 655static int wpa_cli_cmd_wps_pbc(struct wpa_ctrl *ctrl, int argc, char *argv[])
656{
87c7ba84 657 return wpa_cli_cmd(ctrl, "WPS_PBC", 0, argc, argv);
fcc60db4
JM		 658}
659
660
661static int wpa_cli_cmd_wps_pin(struct wpa_ctrl *ctrl, int argc, char *argv[])
662{
fcc60db4
JM		 663 if (argc == 0) {
664 printf("Invalid WPS_PIN command: need one or two arguments:\n"
665 "- BSSID: use 'any' to select any\n"
666 "- PIN: optional, used only with devices that have no "
667 "display\n");
668 return -1;
669 }
670
87c7ba84 671 return wpa_cli_cmd(ctrl, "WPS_PIN", 1, argc, argv);
fcc60db4
JM		 672}
673
674
3981cb3c
JM		 675static int wpa_cli_cmd_wps_check_pin(struct wpa_ctrl *ctrl, int argc,
676 char *argv[])
677{
87c7ba84 678 return wpa_cli_cmd(ctrl, "WPS_CHECK_PIN", 1, argc, argv);
3981cb3c
JM		 679}
680
681
2f9929ff
AC		 682static int wpa_cli_cmd_wps_cancel(struct wpa_ctrl *ctrl, int argc,
683 char *argv[])
684{
685 return wpa_ctrl_command(ctrl, "WPS_CANCEL");
686}
687
688
71892384 689#ifdef CONFIG_WPS_NFC
3f2c8ba6
JM		 690
691static int wpa_cli_cmd_wps_nfc(struct wpa_ctrl *ctrl, int argc, char *argv[])
692{
87c7ba84 693 return wpa_cli_cmd(ctrl, "WPS_NFC", 0, argc, argv);
3f2c8ba6
JM		 694}
695
696
bbf41865
JM		 697static int wpa_cli_cmd_wps_nfc_config_token(struct wpa_ctrl *ctrl, int argc,
698 char *argv[])
699{
700 return wpa_cli_cmd(ctrl, "WPS_NFC_CONFIG_TOKEN", 1, argc, argv);
701}
702
703
3f2c8ba6
JM		 704static int wpa_cli_cmd_wps_nfc_token(struct wpa_ctrl *ctrl, int argc,
705 char *argv[])
706{
87c7ba84 707 return wpa_cli_cmd(ctrl, "WPS_NFC_TOKEN", 1, argc, argv);
3f2c8ba6 708}
d7645d23
JM		 709
710
711static int wpa_cli_cmd_wps_nfc_tag_read(struct wpa_ctrl *ctrl, int argc,
712 char *argv[])
713{
714 int ret;
715 char *buf;
716 size_t buflen;
717
718 if (argc != 1) {
719 printf("Invalid 'wps_nfc_tag_read' command - one argument "
720 "is required.\n");
721 return -1;
722 }
723
724 buflen = 18 + os_strlen(argv[0]);
725 buf = os_malloc(buflen);
726 if (buf == NULL)
727 return -1;
728 os_snprintf(buf, buflen, "WPS_NFC_TAG_READ %s", argv[0]);
729
730 ret = wpa_ctrl_command(ctrl, buf);
731 os_free(buf);
732
733 return ret;
734}
71892384 735
e65552dd
JM		 736
737static int wpa_cli_cmd_nfc_get_handover_req(struct wpa_ctrl *ctrl, int argc,
738 char *argv[])
739{
740 return wpa_cli_cmd(ctrl, "NFC_GET_HANDOVER_REQ", 2, argc, argv);
741}
742
743
744static int wpa_cli_cmd_nfc_get_handover_sel(struct wpa_ctrl *ctrl, int argc,
745 char *argv[])
746{
747 return wpa_cli_cmd(ctrl, "NFC_GET_HANDOVER_SEL", 2, argc, argv);
748}
749
750
e4758827
JM		 751static int wpa_cli_cmd_nfc_report_handover(struct wpa_ctrl *ctrl, int argc,
752 char *argv[])
753{
754 return wpa_cli_cmd(ctrl, "NFC_REPORT_HANDOVER", 4, argc, argv);
755}
756
71892384 757#endif /* CONFIG_WPS_NFC */
46bdb83a
MH		 758
759
fcc60db4
JM		 760static int wpa_cli_cmd_wps_reg(struct wpa_ctrl *ctrl, int argc, char *argv[])
761{
762 char cmd[256];
763 int res;
764
52eb293d
JM		 765 if (argc == 2)
766 res = os_snprintf(cmd, sizeof(cmd), "WPS_REG %s %s",
767 argv[0], argv[1]);
7d6640a6 768 else if (argc == 5 || argc == 6) {
d9d1b952 769 char ssid_hex[2 * SSID_MAX_LEN + 1];
52eb293d
JM		 770 char key_hex[2 * 64 + 1];
771 int i;
772
773 ssid_hex[0] = '\0';
d9d1b952 774 for (i = 0; i < SSID_MAX_LEN; i++) {
52eb293d
JM		 775 if (argv[2][i] == '\0')
776 break;
777 os_snprintf(&ssid_hex[i * 2], 3, "%02x", argv[2][i]);
778 }
779
780 key_hex[0] = '\0';
7d6640a6
JM		 781 if (argc == 6) {
782 for (i = 0; i < 64; i++) {
783 if (argv[5][i] == '\0')
784 break;
785 os_snprintf(&key_hex[i * 2], 3, "%02x",
786 argv[5][i]);
787 }
52eb293d
JM		 788 }
789
790 res = os_snprintf(cmd, sizeof(cmd),
791 "WPS_REG %s %s %s %s %s %s",
792 argv[0], argv[1], ssid_hex, argv[3], argv[4],
793 key_hex);
794 } else {
fcc60db4 795 printf("Invalid WPS_REG command: need two arguments:\n"
129eb428 796 "- BSSID of the target AP\n"
fcc60db4 797 "- AP PIN\n");
52eb293d
JM		 798 printf("Alternatively, six arguments can be used to "
799 "reconfigure the AP:\n"
129eb428 800 "- BSSID of the target AP\n"
52eb293d
JM		 801 "- AP PIN\n"
802 "- new SSID\n"
803 "- new auth (OPEN, WPAPSK, WPA2PSK)\n"
804 "- new encr (NONE, WEP, TKIP, CCMP)\n"
805 "- new key\n");
fcc60db4
JM		 806 return -1;
807 }
808
eeab4f2f 809 if (os_snprintf_error(sizeof(cmd), res)) {
fcc60db4
JM		 810 printf("Too long WPS_REG command.\n");
811 return -1;
812 }
813 return wpa_ctrl_command(ctrl, cmd);
814}
815
816
70d84f11
JM		 817static int wpa_cli_cmd_wps_ap_pin(struct wpa_ctrl *ctrl, int argc,
818 char *argv[])
819{
87c7ba84 820 return wpa_cli_cmd(ctrl, "WPS_AP_PIN", 1, argc, argv);
70d84f11
JM		 821}
822
823
e9bcfebf
JM		 824static int wpa_cli_cmd_wps_er_start(struct wpa_ctrl *ctrl, int argc,
825 char *argv[])
826{
87c7ba84 827 return wpa_cli_cmd(ctrl, "WPS_ER_START", 0, argc, argv);
e9bcfebf
JM		 828}
829
830
831static int wpa_cli_cmd_wps_er_stop(struct wpa_ctrl *ctrl, int argc,
832 char *argv[])
833{
834 return wpa_ctrl_command(ctrl, "WPS_ER_STOP");
835
836}
837
838
72df2f5f
JM		 839static int wpa_cli_cmd_wps_er_pin(struct wpa_ctrl *ctrl, int argc,
840 char *argv[])
841{
31fcea93
JM		 842 if (argc < 2) {
843 printf("Invalid WPS_ER_PIN command: need at least two "
844 "arguments:\n"
72df2f5f 845 "- UUID: use 'any' to select any\n"
31fcea93
JM		 846 "- PIN: Enrollee PIN\n"
847 "optional: - Enrollee MAC address\n");
72df2f5f
JM		 848 return -1;
849 }
850
87c7ba84 851 return wpa_cli_cmd(ctrl, "WPS_ER_PIN", 2, argc, argv);
72df2f5f
JM		 852}
853
854
564cd7fa
JM		 855static int wpa_cli_cmd_wps_er_pbc(struct wpa_ctrl *ctrl, int argc,
856 char *argv[])
857{
87c7ba84 858 return wpa_cli_cmd(ctrl, "WPS_ER_PBC", 1, argc, argv);
564cd7fa
JM		 859}
860
861
e64dcfd5
JM		 862static int wpa_cli_cmd_wps_er_learn(struct wpa_ctrl *ctrl, int argc,
863 char *argv[])
864{
e64dcfd5
JM		 865 if (argc != 2) {
866 printf("Invalid WPS_ER_LEARN command: need two arguments:\n"
867 "- UUID: specify which AP to use\n"
868 "- PIN: AP PIN\n");
869 return -1;
870 }
871
87c7ba84 872 return wpa_cli_cmd(ctrl, "WPS_ER_LEARN", 2, argc, argv);
e64dcfd5
JM		 873}
874
875
ef10f473
JM		 876static int wpa_cli_cmd_wps_er_set_config(struct wpa_ctrl *ctrl, int argc,
877 char *argv[])
878{
ef10f473
JM		 879 if (argc != 2) {
880 printf("Invalid WPS_ER_SET_CONFIG command: need two "
881 "arguments:\n"
882 "- UUID: specify which AP to use\n"
883 "- Network configuration id\n");
884 return -1;
885 }
886
87c7ba84 887 return wpa_cli_cmd(ctrl, "WPS_ER_SET_CONFIG", 2, argc, argv);
ef10f473
JM		 888}
889
890
7d6640a6
JM		 891static int wpa_cli_cmd_wps_er_config(struct wpa_ctrl *ctrl, int argc,
892 char *argv[])
893{
894 char cmd[256];
895 int res;
896
897 if (argc == 5 || argc == 6) {
d9d1b952 898 char ssid_hex[2 * SSID_MAX_LEN + 1];
7d6640a6
JM		 899 char key_hex[2 * 64 + 1];
900 int i;
901
902 ssid_hex[0] = '\0';
d9d1b952 903 for (i = 0; i < SSID_MAX_LEN; i++) {
7d6640a6
JM		 904 if (argv[2][i] == '\0')
905 break;
906 os_snprintf(&ssid_hex[i * 2], 3, "%02x", argv[2][i]);
907 }
908
909 key_hex[0] = '\0';
910 if (argc == 6) {
911 for (i = 0; i < 64; i++) {
912 if (argv[5][i] == '\0')
913 break;
914 os_snprintf(&key_hex[i * 2], 3, "%02x",
915 argv[5][i]);
916 }
917 }
918
919 res = os_snprintf(cmd, sizeof(cmd),
920 "WPS_ER_CONFIG %s %s %s %s %s %s",
921 argv[0], argv[1], ssid_hex, argv[3], argv[4],
922 key_hex);
923 } else {
924 printf("Invalid WPS_ER_CONFIG command: need six arguments:\n"
925 "- AP UUID\n"
926 "- AP PIN\n"
927 "- new SSID\n"
928 "- new auth (OPEN, WPAPSK, WPA2PSK)\n"
929 "- new encr (NONE, WEP, TKIP, CCMP)\n"
930 "- new key\n");
931 return -1;
932 }
933
eeab4f2f 934 if (os_snprintf_error(sizeof(cmd), res)) {
7d6640a6
JM		 935 printf("Too long WPS_ER_CONFIG command.\n");
936 return -1;
937 }
938 return wpa_ctrl_command(ctrl, cmd);
939}
940
941
1cea09a9
JM		 942#ifdef CONFIG_WPS_NFC
943static int wpa_cli_cmd_wps_er_nfc_config_token(struct wpa_ctrl *ctrl, int argc,
944 char *argv[])
945{
1cea09a9
JM		 946 if (argc != 2) {
947 printf("Invalid WPS_ER_NFC_CONFIG_TOKEN command: need two "
948 "arguments:\n"
949 "- WPS/NDEF: token format\n"
950 "- UUID: specify which AP to use\n");
951 return -1;
952 }
953
87c7ba84 954 return wpa_cli_cmd(ctrl, "WPS_ER_NFC_CONFIG_TOKEN", 2, argc, argv);
1cea09a9
JM		 955}
956#endif /* CONFIG_WPS_NFC */
957
958
11ef8d35
JM		 959static int wpa_cli_cmd_ibss_rsn(struct wpa_ctrl *ctrl, int argc, char *argv[])
960{
87c7ba84 961 return wpa_cli_cmd(ctrl, "IBSS_RSN", 1, argc, argv);
11ef8d35
JM		 962}
963
964
6fc6879b
JM		 965static int wpa_cli_cmd_level(struct wpa_ctrl *ctrl, int argc, char *argv[])
966{
87c7ba84 967 return wpa_cli_cmd(ctrl, "LEVEL", 1, argc, argv);
6fc6879b
JM		 968}
969
970
971static int wpa_cli_cmd_identity(struct wpa_ctrl *ctrl, int argc, char *argv[])
972{
973 char cmd[256], *pos, *end;
974 int i, ret;
975
976 if (argc < 2) {
977 printf("Invalid IDENTITY command: needs two arguments "
978 "(network id and identity)\n");
979 return -1;
980 }
981
982 end = cmd + sizeof(cmd);
983 pos = cmd;
984 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "IDENTITY-%s:%s",
985 argv[0], argv[1]);
d85e1fc8 986 if (os_snprintf_error(end - pos, ret)) {
6fc6879b
JM		 987 printf("Too long IDENTITY command.\n");
988 return -1;
989 }
990 pos += ret;
991 for (i = 2; i < argc; i++) {
992 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
d85e1fc8 993 if (os_snprintf_error(end - pos, ret)) {
6fc6879b
JM		 994 printf("Too long IDENTITY command.\n");
995 return -1;
996 }
997 pos += ret;
998 }
999
1000 return wpa_ctrl_command(ctrl, cmd);
1001}
1002
1003
1004static int wpa_cli_cmd_password(struct wpa_ctrl *ctrl, int argc, char *argv[])
1005{
1006 char cmd[256], *pos, *end;
1007 int i, ret;
1008
1009 if (argc < 2) {
1010 printf("Invalid PASSWORD command: needs two arguments "
1011 "(network id and password)\n");
1012 return -1;
1013 }
1014
1015 end = cmd + sizeof(cmd);
1016 pos = cmd;
1017 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "PASSWORD-%s:%s",
1018 argv[0], argv[1]);
d85e1fc8 1019 if (os_snprintf_error(end - pos, ret)) {
6fc6879b
JM		 1020 printf("Too long PASSWORD command.\n");
1021 return -1;
1022 }
1023 pos += ret;
1024 for (i = 2; i < argc; i++) {
1025 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
d85e1fc8 1026 if (os_snprintf_error(end - pos, ret)) {
6fc6879b
JM		 1027 printf("Too long PASSWORD command.\n");
1028 return -1;
1029 }
1030 pos += ret;
1031 }
1032
1033 return wpa_ctrl_command(ctrl, cmd);
1034}
1035
1036
1037static int wpa_cli_cmd_new_password(struct wpa_ctrl *ctrl, int argc,
1038 char *argv[])
1039{
1040 char cmd[256], *pos, *end;
1041 int i, ret;
1042
1043 if (argc < 2) {
1044 printf("Invalid NEW_PASSWORD command: needs two arguments "
1045 "(network id and password)\n");
1046 return -1;
1047 }
1048
1049 end = cmd + sizeof(cmd);
1050 pos = cmd;
1051 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "NEW_PASSWORD-%s:%s",
1052 argv[0], argv[1]);
d85e1fc8 1053 if (os_snprintf_error(end - pos, ret)) {
6fc6879b
JM		 1054 printf("Too long NEW_PASSWORD command.\n");
1055 return -1;
1056 }
1057 pos += ret;
1058 for (i = 2; i < argc; i++) {
1059 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
d85e1fc8 1060 if (os_snprintf_error(end - pos, ret)) {
6fc6879b
JM		 1061 printf("Too long NEW_PASSWORD command.\n");
1062 return -1;
1063 }
1064 pos += ret;
1065 }
1066
1067 return wpa_ctrl_command(ctrl, cmd);
1068}
1069
1070
1071static int wpa_cli_cmd_pin(struct wpa_ctrl *ctrl, int argc, char *argv[])
1072{
1073 char cmd[256], *pos, *end;
1074 int i, ret;
1075
1076 if (argc < 2) {
1077 printf("Invalid PIN command: needs two arguments "
1078 "(network id and pin)\n");
1079 return -1;
1080 }
1081
1082 end = cmd + sizeof(cmd);
1083 pos = cmd;
1084 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "PIN-%s:%s",
1085 argv[0], argv[1]);
d85e1fc8 1086 if (os_snprintf_error(end - pos, ret)) {
6fc6879b
JM		 1087 printf("Too long PIN command.\n");
1088 return -1;
1089 }
1090 pos += ret;
1091 for (i = 2; i < argc; i++) {
1092 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
d85e1fc8 1093 if (os_snprintf_error(end - pos, ret)) {
6fc6879b
JM		 1094 printf("Too long PIN command.\n");
1095 return -1;
1096 }
1097 pos += ret;
1098 }
1099 return wpa_ctrl_command(ctrl, cmd);
1100}
1101
1102
1103static int wpa_cli_cmd_otp(struct wpa_ctrl *ctrl, int argc, char *argv[])
1104{
1105 char cmd[256], *pos, *end;
1106 int i, ret;
1107
1108 if (argc < 2) {
1109 printf("Invalid OTP command: needs two arguments (network "
1110 "id and password)\n");
1111 return -1;
1112 }
1113
1114 end = cmd + sizeof(cmd);
1115 pos = cmd;
1116 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "OTP-%s:%s",
1117 argv[0], argv[1]);
d85e1fc8 1118 if (os_snprintf_error(end - pos, ret)) {
6fc6879b
JM		 1119 printf("Too long OTP command.\n");
1120 return -1;
1121 }
1122 pos += ret;
1123 for (i = 2; i < argc; i++) {
1124 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
d85e1fc8 1125 if (os_snprintf_error(end - pos, ret)) {
6fc6879b
JM		 1126 printf("Too long OTP command.\n");
1127 return -1;
1128 }
1129 pos += ret;
1130 }
1131
1132 return wpa_ctrl_command(ctrl, cmd);
1133}
1134
1135
a5d44ac0
JM		 1136static int wpa_cli_cmd_sim(struct wpa_ctrl *ctrl, int argc, char *argv[])
1137{
1138 char cmd[256], *pos, *end;
1139 int i, ret;
1140
1141 if (argc < 2) {
1142 printf("Invalid SIM command: needs two arguments "
1143 "(network id and SIM operation response)\n");
1144 return -1;
1145 }
1146
1147 end = cmd + sizeof(cmd);
1148 pos = cmd;
1149 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "SIM-%s:%s",
1150 argv[0], argv[1]);
d85e1fc8 1151 if (os_snprintf_error(end - pos, ret)) {
a5d44ac0
JM		 1152 printf("Too long SIM command.\n");
1153 return -1;
1154 }
1155 pos += ret;
1156 for (i = 2; i < argc; i++) {
1157 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
d85e1fc8 1158 if (os_snprintf_error(end - pos, ret)) {
a5d44ac0
JM		 1159 printf("Too long SIM command.\n");
1160 return -1;
1161 }
1162 pos += ret;
1163 }
1164 return wpa_ctrl_command(ctrl, cmd);
1165}
1166
1167
6fc6879b
JM		 1168static int wpa_cli_cmd_passphrase(struct wpa_ctrl *ctrl, int argc,
1169 char *argv[])
1170{
1171 char cmd[256], *pos, *end;
1172 int i, ret;
1173
1174 if (argc < 2) {
1175 printf("Invalid PASSPHRASE command: needs two arguments "
1176 "(network id and passphrase)\n");
1177 return -1;
1178 }
1179
1180 end = cmd + sizeof(cmd);
1181 pos = cmd;
1182 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "PASSPHRASE-%s:%s",
1183 argv[0], argv[1]);
d85e1fc8 1184 if (os_snprintf_error(end - pos, ret)) {
6fc6879b
JM		 1185 printf("Too long PASSPHRASE command.\n");
1186 return -1;
1187 }
1188 pos += ret;
1189 for (i = 2; i < argc; i++) {
1190 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
d85e1fc8 1191 if (os_snprintf_error(end - pos, ret)) {
6fc6879b
JM		 1192 printf("Too long PASSPHRASE command.\n");
1193 return -1;
1194 }
1195 pos += ret;
1196 }
1197
1198 return wpa_ctrl_command(ctrl, cmd);
1199}
1200
1201
1202static int wpa_cli_cmd_bssid(struct wpa_ctrl *ctrl, int argc, char *argv[])
1203{
6fc6879b
JM		 1204 if (argc < 2) {
1205 printf("Invalid BSSID command: needs two arguments (network "
1206 "id and BSSID)\n");
1207 return -1;
1208 }
1209
87c7ba84 1210 return wpa_cli_cmd(ctrl, "BSSID", 2, argc, argv);
6fc6879b
JM		 1211}
1212
1213
9aa10e2b
DS		 1214static int wpa_cli_cmd_blacklist(struct wpa_ctrl *ctrl, int argc, char *argv[])
1215{
87c7ba84
JM		 1216 return wpa_cli_cmd(ctrl, "BLACKLIST", 0, argc, argv);
1217}
9aa10e2b
DS		 1218
1219
0597a5b5
DS		 1220static int wpa_cli_cmd_log_level(struct wpa_ctrl *ctrl, int argc, char *argv[])
1221{
87c7ba84 1222 return wpa_cli_cmd(ctrl, "LOG_LEVEL", 0, argc, argv);
0597a5b5
DS		 1223}
1224
1225
6fc6879b
JM		 1226static int wpa_cli_cmd_list_networks(struct wpa_ctrl *ctrl, int argc,
1227 char *argv[])
1228{
1229 return wpa_ctrl_command(ctrl, "LIST_NETWORKS");
1230}
1231
1232
1233static int wpa_cli_cmd_select_network(struct wpa_ctrl *ctrl, int argc,
1234 char *argv[])
1235{
87c7ba84 1236 return wpa_cli_cmd(ctrl, "SELECT_NETWORK", 1, argc, argv);
6fc6879b
JM		 1237}
1238
1239
1240static int wpa_cli_cmd_enable_network(struct wpa_ctrl *ctrl, int argc,
1241 char *argv[])
1242{
87c7ba84 1243 return wpa_cli_cmd(ctrl, "ENABLE_NETWORK", 1, argc, argv);
6fc6879b
JM		 1244}
1245
1246
1247static int wpa_cli_cmd_disable_network(struct wpa_ctrl *ctrl, int argc,
1248 char *argv[])
1249{
87c7ba84 1250 return wpa_cli_cmd(ctrl, "DISABLE_NETWORK", 1, argc, argv);
6fc6879b
JM		 1251}
1252
1253
1254static int wpa_cli_cmd_add_network(struct wpa_ctrl *ctrl, int argc,
1255 char *argv[])
1256{
32a097fd 1257 int res = wpa_ctrl_command(ctrl, "ADD_NETWORK");
74197e0a
AO		 1258 if (interactive)
1259 update_networks(ctrl);
32a097fd 1260 return res;
6fc6879b
JM		 1261}
1262
1263
1264static int wpa_cli_cmd_remove_network(struct wpa_ctrl *ctrl, int argc,
1265 char *argv[])
1266{
32a097fd 1267 int res = wpa_cli_cmd(ctrl, "REMOVE_NETWORK", 1, argc, argv);
74197e0a
AO		 1268 if (interactive)
1269 update_networks(ctrl);
32a097fd 1270 return res;
6fc6879b
JM		 1271}
1272
1273
1274static void wpa_cli_show_network_variables(void)
1275{
1276 printf("set_network variables:\n"
1277 " ssid (network name, SSID)\n"
1278 " psk (WPA passphrase or pre-shared key)\n"
1279 " key_mgmt (key management protocol)\n"
1280 " identity (EAP identity)\n"
1281 " password (EAP password)\n"
1282 " ...\n"
1283 "\n"
1284 "Note: Values are entered in the same format as the "
1285 "configuration file is using,\n"
1286 "i.e., strings values need to be inside double quotation "
1287 "marks.\n"
1288 "For example: set_network 1 ssid \"network name\"\n"
1289 "\n"
1290 "Please see wpa_supplicant.conf documentation for full list "
1291 "of\navailable variables.\n");
1292}
1293
1294
1295static int wpa_cli_cmd_set_network(struct wpa_ctrl *ctrl, int argc,
1296 char *argv[])
1297{
6fc6879b
JM		 1298 if (argc == 0) {
1299 wpa_cli_show_network_variables();
1300 return 0;
1301 }
1302
af1dff8c 1303 if (argc < 3) {
6fc6879b
JM		 1304 printf("Invalid SET_NETWORK command: needs three arguments\n"
1305 "(network id, variable name, and value)\n");
1306 return -1;
1307 }
1308
87c7ba84 1309 return wpa_cli_cmd(ctrl, "SET_NETWORK", 3, argc, argv);
6fc6879b
JM		 1310}
1311
1312
1313static int wpa_cli_cmd_get_network(struct wpa_ctrl *ctrl, int argc,
1314 char *argv[])
1315{
6fc6879b
JM		 1316 if (argc == 0) {
1317 wpa_cli_show_network_variables();
1318 return 0;
1319 }
1320
1321 if (argc != 2) {
1322 printf("Invalid GET_NETWORK command: needs two arguments\n"
1323 "(network id and variable name)\n");
1324 return -1;
1325 }
1326
87c7ba84 1327 return wpa_cli_cmd(ctrl, "GET_NETWORK", 2, argc, argv);
6fc6879b
JM		 1328}
1329
1330
7e6cc908
MK		 1331static const char *network_fields[] = {
1332 "ssid", "scan_ssid", "bssid", "bssid_blacklist",
1333 "bssid_whitelist", "psk", "proto", "key_mgmt",
1334 "bg_scan_period", "pairwise", "group", "auth_alg", "scan_freq",
0f29bc68 1335 "freq_list", "max_oper_chwidth",
7e6cc908
MK		 1336#ifdef IEEE8021X_EAPOL
1337 "eap", "identity", "anonymous_identity", "password", "ca_cert",
1338 "ca_path", "client_cert", "private_key", "private_key_passwd",
1339 "dh_file", "subject_match", "altsubject_match",
1340 "domain_suffix_match", "domain_match", "ca_cert2", "ca_path2",
1341 "client_cert2", "private_key2", "private_key2_passwd",
1342 "dh_file2", "subject_match2", "altsubject_match2",
1343 "domain_suffix_match2", "domain_match2", "phase1", "phase2",
1344 "pcsc", "pin", "engine_id", "key_id", "cert_id", "ca_cert_id",
1345 "pin2", "engine2_id", "key2_id", "cert2_id", "ca_cert2_id",
1346 "engine", "engine2", "eapol_flags", "sim_num",
1347 "openssl_ciphers", "erp",
1348#endif /* IEEE8021X_EAPOL */
1349 "wep_key0", "wep_key1", "wep_key2", "wep_key3",
1350 "wep_tx_keyidx", "priority",
1351#ifdef IEEE8021X_EAPOL
1352 "eap_workaround", "pac_file", "fragment_size", "ocsp",
1353#endif /* IEEE8021X_EAPOL */
1354#ifdef CONFIG_MESH
1355 "mode", "no_auto_peer",
1356#else /* CONFIG_MESH */
1357 "mode",
1358#endif /* CONFIG_MESH */
1359 "proactive_key_caching", "disabled", "id_str",
1360#ifdef CONFIG_IEEE80211W
1361 "ieee80211w",
1362#endif /* CONFIG_IEEE80211W */
1363 "peerkey", "mixed_cell", "frequency", "fixed_freq",
1364#ifdef CONFIG_MESH
1365 "mesh_basic_rates", "dot11MeshMaxRetries",
1366 "dot11MeshRetryTimeout", "dot11MeshConfirmTimeout",
1367 "dot11MeshHoldingTimeout",
1368#endif /* CONFIG_MESH */
1369 "wpa_ptk_rekey", "bgscan", "ignore_broadcast_ssid",
1370#ifdef CONFIG_P2P
1371 "go_p2p_dev_addr", "p2p_client_list", "psk_list",
1372#endif /* CONFIG_P2P */
1373#ifdef CONFIG_HT_OVERRIDES
1374 "disable_ht", "disable_ht40", "disable_sgi", "disable_ldpc",
1375 "ht40_intolerant", "disable_max_amsdu", "ampdu_factor",
1376 "ampdu_density", "ht_mcs",
1377#endif /* CONFIG_HT_OVERRIDES */
1378#ifdef CONFIG_VHT_OVERRIDES
1379 "disable_vht", "vht_capa", "vht_capa_mask", "vht_rx_mcs_nss_1",
1380 "vht_rx_mcs_nss_2", "vht_rx_mcs_nss_3", "vht_rx_mcs_nss_4",
1381 "vht_rx_mcs_nss_5", "vht_rx_mcs_nss_6", "vht_rx_mcs_nss_7",
1382 "vht_rx_mcs_nss_8", "vht_tx_mcs_nss_1", "vht_tx_mcs_nss_2",
1383 "vht_tx_mcs_nss_3", "vht_tx_mcs_nss_4", "vht_tx_mcs_nss_5",
1384 "vht_tx_mcs_nss_6", "vht_tx_mcs_nss_7", "vht_tx_mcs_nss_8",
1385#endif /* CONFIG_VHT_OVERRIDES */
1386 "ap_max_inactivity", "dtim_period", "beacon_int",
1387#ifdef CONFIG_MACSEC
1388 "macsec_policy",
1389#endif /* CONFIG_MACSEC */
1390#ifdef CONFIG_HS20
1391 "update_identifier",
1392#endif /* CONFIG_HS20 */
b6317b41 1393 "mac_addr", "pbss", "wps_disabled"
7e6cc908
MK		 1394};
1395
1396
1397static char ** wpa_cli_complete_network(const char *str, int pos)
1398{
1399 int arg = get_cmd_arg_num(str, pos);
1400 int i, num_fields = ARRAY_SIZE(network_fields);
1401 char **res = NULL;
1402
1403 switch (arg) {
1404 case 1:
1405 res = cli_txt_list_array(&networks);
1406 break;
1407 case 2:
1408 res = os_calloc(num_fields + 1, sizeof(char *));
1409 if (res == NULL)
1410 return NULL;
1411 for (i = 0; i < num_fields; i++) {
1412 res[i] = os_strdup(network_fields[i]);
1413 if (res[i] == NULL)
1414 break;
1415 }
1416 }
1417 return res;
1418}
1419
1420
1ca6c0f1
MK		 1421static char ** wpa_cli_complete_network_id(const char *str, int pos)
1422{
1423 int arg = get_cmd_arg_num(str, pos);
1424 if (arg == 1)
1425 return cli_txt_list_array(&networks);
1426 return NULL;
1427}
1428
1429
1c330a2f
DS		 1430static int wpa_cli_cmd_dup_network(struct wpa_ctrl *ctrl, int argc,
1431 char *argv[])
1432{
1433 if (argc == 0) {
1434 wpa_cli_show_network_variables();
1435 return 0;
1436 }
1437
1438 if (argc < 3) {
1439 printf("Invalid DUP_NETWORK command: needs three arguments\n"
1440 "(src netid, dest netid, and variable name)\n");
1441 return -1;
1442 }
1443
1444 return wpa_cli_cmd(ctrl, "DUP_NETWORK", 3, argc, argv);
1445}
1446
1447
5a997b2f
MK		 1448static char ** wpa_cli_complete_dup_network(const char *str, int pos)
1449{
1450 int arg = get_cmd_arg_num(str, pos);
1451 int i, num_fields = ARRAY_SIZE(network_fields);
1452 char **res = NULL;
1453
1454 switch (arg) {
1455 case 1:
1456 case 2:
1457 res = cli_txt_list_array(&networks);
1458 break;
1459 case 3:
1460 res = os_calloc(num_fields + 1, sizeof(char *));
1461 if (res == NULL)
1462 return NULL;
1463 for (i = 0; i < num_fields; i++) {
1464 res[i] = os_strdup(network_fields[i]);
1465 if (res[i] == NULL)
1466 break;
1467 }
1468 }
1469 return res;
1470}
1471
1472
d94c9ee6
JM		 1473static int wpa_cli_cmd_list_creds(struct wpa_ctrl *ctrl, int argc,
1474 char *argv[])
1475{
1476 return wpa_ctrl_command(ctrl, "LIST_CREDS");
1477}
1478
1479
1480static int wpa_cli_cmd_add_cred(struct wpa_ctrl *ctrl, int argc, char *argv[])
1481{
1482 return wpa_ctrl_command(ctrl, "ADD_CRED");
1483}
1484
1485
1486static int wpa_cli_cmd_remove_cred(struct wpa_ctrl *ctrl, int argc,
1487 char *argv[])
1488{
87c7ba84 1489 return wpa_cli_cmd(ctrl, "REMOVE_CRED", 1, argc, argv);
d94c9ee6
JM		 1490}
1491
1492
1493static int wpa_cli_cmd_set_cred(struct wpa_ctrl *ctrl, int argc, char *argv[])
1494{
d94c9ee6
JM		 1495 if (argc != 3) {
1496 printf("Invalid SET_CRED command: needs three arguments\n"
1497 "(cred id, variable name, and value)\n");
1498 return -1;
1499 }
1500
87c7ba84 1501 return wpa_cli_cmd(ctrl, "SET_CRED", 3, argc, argv);
d94c9ee6
JM		 1502}
1503
1504
c880ab87
JM		 1505static int wpa_cli_cmd_get_cred(struct wpa_ctrl *ctrl, int argc, char *argv[])
1506{
1507 if (argc != 2) {
1508 printf("Invalid GET_CRED command: needs two arguments\n"
1509 "(cred id, variable name)\n");
1510 return -1;
1511 }
1512
1513 return wpa_cli_cmd(ctrl, "GET_CRED", 2, argc, argv);
1514}
1515
1516
6fc6879b
JM		 1517static int wpa_cli_cmd_disconnect(struct wpa_ctrl *ctrl, int argc,
1518 char *argv[])
1519{
1520 return wpa_ctrl_command(ctrl, "DISCONNECT");
1521}
1522
1523
1524static int wpa_cli_cmd_reconnect(struct wpa_ctrl *ctrl, int argc,
1525 char *argv[])
1526{
1527 return wpa_ctrl_command(ctrl, "RECONNECT");
1528}
1529
1530
1531static int wpa_cli_cmd_save_config(struct wpa_ctrl *ctrl, int argc,
1532 char *argv[])
1533{
1534 return wpa_ctrl_command(ctrl, "SAVE_CONFIG");
1535}
1536
1537
1538static int wpa_cli_cmd_scan(struct wpa_ctrl *ctrl, int argc, char *argv[])
1539{
66fe0f70 1540 return wpa_cli_cmd(ctrl, "SCAN", 0, argc, argv);
6fc6879b
JM		 1541}
1542
1543
1544static int wpa_cli_cmd_scan_results(struct wpa_ctrl *ctrl, int argc,
1545 char *argv[])
1546{
1547 return wpa_ctrl_command(ctrl, "SCAN_RESULTS");
1548}
1549
1550
2ea2166d
JM		 1551static int wpa_cli_cmd_abort_scan(struct wpa_ctrl *ctrl, int argc,
1552 char *argv[])
1553{
1554 return wpa_ctrl_command(ctrl, "ABORT_SCAN");
1555}
1556
1557
6fc6879b
JM		 1558static int wpa_cli_cmd_bss(struct wpa_ctrl *ctrl, int argc, char *argv[])
1559{
87c7ba84 1560 return wpa_cli_cmd(ctrl, "BSS", 1, argc, argv);
6fc6879b
JM		 1561}
1562
1563
a624f20b
JM		 1564static char ** wpa_cli_complete_bss(const char *str, int pos)
1565{
1566 int arg = get_cmd_arg_num(str, pos);
1567 char **res = NULL;
1568
1569 switch (arg) {
1570 case 1:
1571 res = cli_txt_list_array(&bsses);
1572 break;
1573 }
1574
1575 return res;
1576}
1577
1578
6fc6879b
JM		 1579static int wpa_cli_cmd_get_capability(struct wpa_ctrl *ctrl, int argc,
1580 char *argv[])
1581{
6fc6879b
JM		 1582 if (argc < 1 || argc > 2) {
1583 printf("Invalid GET_CAPABILITY command: need either one or "
1584 "two arguments\n");
1585 return -1;
1586 }
1587
1588 if ((argc == 2) && os_strcmp(argv[1], "strict") != 0) {
1589 printf("Invalid GET_CAPABILITY command: second argument, "
1590 "if any, must be 'strict'\n");
1591 return -1;
1592 }
1593
87c7ba84 1594 return wpa_cli_cmd(ctrl, "GET_CAPABILITY", 1, argc, argv);
6fc6879b
JM		 1595}
1596
1597
003fe581
MK		 1598static char ** wpa_cli_complete_get_capability(const char *str, int pos)
1599{
1600 int arg = get_cmd_arg_num(str, pos);
1601 const char *fields[] = {
1602 "eap", "pairwise", "group", "group_mgmt", "key_mgmt",
1603 "proto", "auth_alg", "modes", "channels", "freq",
1604#ifdef CONFIG_TDLS
1605 "tdls",
1606#endif /* CONFIG_TDLS */
1607#ifdef CONFIG_ERP
1608 "erp",
1609#endif /* CONFIG_ERP */
1610#ifdef CONFIG_FIPS
1611 "fips",
1612#endif /* CONFIG_FIPS */
1613#ifdef CONFIG_ACS
1614 "acs",
1615#endif /* CONFIG_ACS */
1616 };
1617 int i, num_fields = ARRAY_SIZE(fields);
1618 char **res = NULL;
1619
1620 if (arg == 1) {
1621 res = os_calloc(num_fields + 1, sizeof(char *));
1622 if (res == NULL)
1623 return NULL;
1624 for (i = 0; i < num_fields; i++) {
1625 res[i] = os_strdup(fields[i]);
1626 if (res[i] == NULL)
1627 return res;
1628 }
1629 }
1630 if (arg == 2) {
1631 res = os_calloc(1 + 1, sizeof(char *));
1632 if (res == NULL)
1633 return NULL;
1634 res[0] = os_strdup("strict");
1635 }
1636 return res;
1637}
1638
1639
6fc6879b
JM		 1640static int wpa_cli_list_interfaces(struct wpa_ctrl *ctrl)
1641{
1642 printf("Available interfaces:\n");
1643 return wpa_ctrl_command(ctrl, "INTERFACES");
1644}
1645
1646
1647static int wpa_cli_cmd_interface(struct wpa_ctrl *ctrl, int argc, char *argv[])
1648{
1649 if (argc < 1) {
1650 wpa_cli_list_interfaces(ctrl);
1651 return 0;
1652 }
1653
1654 wpa_cli_close_connection();
1655 os_free(ctrl_ifname);
1656 ctrl_ifname = os_strdup(argv[0]);
30f459c0
EL		 1657 if (!ctrl_ifname) {
1658 printf("Failed to allocate memory\n");
1659 return 0;
1660 }
6fc6879b 1661
2150c333 1662 if (wpa_cli_open_connection(ctrl_ifname, 1) == 0) {
6fc6879b 1663 printf("Connected to interface '%s.\n", ctrl_ifname);
6fc6879b
JM		 1664 } else {
1665 printf("Could not connect to interface '%s' - re-trying\n",
1666 ctrl_ifname);
1667 }
1668 return 0;
1669}
1670
1671
1672static int wpa_cli_cmd_reconfigure(struct wpa_ctrl *ctrl, int argc,
1673 char *argv[])
1674{
1675 return wpa_ctrl_command(ctrl, "RECONFIGURE");
1676}
1677
1678
1679static int wpa_cli_cmd_terminate(struct wpa_ctrl *ctrl, int argc,
1680 char *argv[])
1681{
1682 return wpa_ctrl_command(ctrl, "TERMINATE");
1683}
1684
1685
1686static int wpa_cli_cmd_interface_add(struct wpa_ctrl *ctrl, int argc,
1687 char *argv[])
1688{
1689 char cmd[256];
1690 int res;
1691
1692 if (argc < 1) {
1693 printf("Invalid INTERFACE_ADD command: needs at least one "
1694 "argument (interface name)\n"
1695 "All arguments: ifname confname driver ctrl_interface "
efa232f9 1696 "driver_param bridge_name [create]\n");
6fc6879b
JM		 1697 return -1;
1698 }
1699
1700 /*
1701 * INTERFACE_ADD <ifname>TAB<confname>TAB<driver>TAB<ctrl_interface>TAB
cadffacb 1702 * <driver_param>TAB<bridge_name>[TAB<create>[TAB<type>]]
6fc6879b
JM		 1703 */
1704 res = os_snprintf(cmd, sizeof(cmd),
cadffacb 1705 "INTERFACE_ADD %s\t%s\t%s\t%s\t%s\t%s\t%s\t%s",
6fc6879b
JM		 1706 argv[0],
1707 argc > 1 ? argv[1] : "", argc > 2 ? argv[2] : "",
1708 argc > 3 ? argv[3] : "", argc > 4 ? argv[4] : "",
cadffacb
AS		 1709 argc > 5 ? argv[5] : "", argc > 6 ? argv[6] : "",
1710 argc > 7 ? argv[7] : "");
d85e1fc8 1711 if (os_snprintf_error(sizeof(cmd), res))
6fc6879b
JM		 1712 return -1;
1713 cmd[sizeof(cmd) - 1] = '\0';
1714 return wpa_ctrl_command(ctrl, cmd);
1715}
1716
1717
1718static int wpa_cli_cmd_interface_remove(struct wpa_ctrl *ctrl, int argc,
1719 char *argv[])
1720{
87c7ba84 1721 return wpa_cli_cmd(ctrl, "INTERFACE_REMOVE", 1, argc, argv);
6fc6879b
JM		 1722}
1723
1724
4b4a8ae5
JM		 1725static int wpa_cli_cmd_interface_list(struct wpa_ctrl *ctrl, int argc,
1726 char *argv[])
1727{
1728 return wpa_ctrl_command(ctrl, "INTERFACE_LIST");
1729}
1730
1731
e653b622
JM		 1732#ifdef CONFIG_AP
1733static int wpa_cli_cmd_sta(struct wpa_ctrl *ctrl, int argc, char *argv[])
1734{
87c7ba84 1735 return wpa_cli_cmd(ctrl, "STA", 1, argc, argv);
e653b622
JM		 1736}
1737
1738
1739static int wpa_ctrl_command_sta(struct wpa_ctrl *ctrl, char *cmd,
1740 char *addr, size_t addr_len)
1741{
1742 char buf[4096], *pos;
1743 size_t len;
1744 int ret;
1745
1746 if (ctrl_conn == NULL) {
1747 printf("Not connected to hostapd - command dropped.\n");
1748 return -1;
1749 }
685ea2f6
EP		 1750 if (ifname_prefix) {
1751 os_snprintf(buf, sizeof(buf), "IFNAME=%s %s",
1752 ifname_prefix, cmd);
1753 buf[sizeof(buf) - 1] = '\0';
1754 cmd = buf;
1755 }
e653b622 1756 len = sizeof(buf) - 1;
024d018b 1757 ret = wpa_ctrl_request(ctrl, cmd, os_strlen(cmd), buf, &len,
e653b622
JM		 1758 wpa_cli_msg_cb);
1759 if (ret == -2) {
1760 printf("'%s' command timed out.\n", cmd);
1761 return -2;
1762 } else if (ret < 0) {
1763 printf("'%s' command failed.\n", cmd);
1764 return -1;
1765 }
1766
1767 buf[len] = '\0';
024d018b 1768 if (os_memcmp(buf, "FAIL", 4) == 0)
e653b622
JM		 1769 return -1;
1770 printf("%s", buf);
1771
1772 pos = buf;
1773 while (*pos != '\0' && *pos != '\n')
1774 pos++;
1775 *pos = '\0';
1776 os_strlcpy(addr, buf, addr_len);
1777 return 0;
1778}
1779
1780
1781static int wpa_cli_cmd_all_sta(struct wpa_ctrl *ctrl, int argc, char *argv[])
1782{
1783 char addr[32], cmd[64];
1784
1785 if (wpa_ctrl_command_sta(ctrl, "STA-FIRST", addr, sizeof(addr)))
1786 return 0;
1787 do {
e824cc46 1788 os_snprintf(cmd, sizeof(cmd), "STA-NEXT %s", addr);
e653b622
JM		 1789 } while (wpa_ctrl_command_sta(ctrl, cmd, addr, sizeof(addr)) == 0);
1790
1791 return -1;
1792}
e60b2951
JJ		 1793
1794
1795static int wpa_cli_cmd_deauthenticate(struct wpa_ctrl *ctrl, int argc,
1796 char *argv[])
1797{
87c7ba84 1798 return wpa_cli_cmd(ctrl, "DEAUTHENTICATE", 1, argc, argv);
e60b2951
JJ		 1799}
1800
1801
1802static int wpa_cli_cmd_disassociate(struct wpa_ctrl *ctrl, int argc,
1803 char *argv[])
1804{
87c7ba84 1805 return wpa_cli_cmd(ctrl, "DISASSOCIATE", 1, argc, argv);
e60b2951 1806}
334bf36a
AO		 1807
1808static int wpa_cli_cmd_chanswitch(struct wpa_ctrl *ctrl, int argc,
1809 char *argv[])
1810{
1811 return wpa_cli_cmd(ctrl, "CHAN_SWITCH", 2, argc, argv);
1812}
1813
e653b622
JM		 1814#endif /* CONFIG_AP */
1815
1816
207ef3fb
JM		 1817static int wpa_cli_cmd_suspend(struct wpa_ctrl *ctrl, int argc, char *argv[])
1818{
1819 return wpa_ctrl_command(ctrl, "SUSPEND");
1820}
1821
1822
1823static int wpa_cli_cmd_resume(struct wpa_ctrl *ctrl, int argc, char *argv[])
1824{
1825 return wpa_ctrl_command(ctrl, "RESUME");
1826}
1827
1828
9ff4de6d 1829#ifdef CONFIG_TESTING_OPTIONS
32d5295f
JM		 1830static int wpa_cli_cmd_drop_sa(struct wpa_ctrl *ctrl, int argc, char *argv[])
1831{
1832 return wpa_ctrl_command(ctrl, "DROP_SA");
1833}
9ff4de6d 1834#endif /* CONFIG_TESTING_OPTIONS */
32d5295f
JM		 1835
1836
86d4f806
JM		 1837static int wpa_cli_cmd_roam(struct wpa_ctrl *ctrl, int argc, char *argv[])
1838{
87c7ba84 1839 return wpa_cli_cmd(ctrl, "ROAM", 1, argc, argv);
86d4f806
JM		 1840}
1841
1842
603a3f34
JL		 1843#ifdef CONFIG_MESH
1844
5b78493f
MH		 1845static int wpa_cli_cmd_mesh_interface_add(struct wpa_ctrl *ctrl, int argc,
1846 char *argv[])
1847{
1848 return wpa_cli_cmd(ctrl, "MESH_INTERFACE_ADD", 0, argc, argv);
1849}
1850
1851
603a3f34
JL		 1852static int wpa_cli_cmd_mesh_group_add(struct wpa_ctrl *ctrl, int argc,
1853 char *argv[])
1854{
1855 return wpa_cli_cmd(ctrl, "MESH_GROUP_ADD", 1, argc, argv);
1856}
1857
1858
1859static int wpa_cli_cmd_mesh_group_remove(struct wpa_ctrl *ctrl, int argc,
1860 char *argv[])
1861{
1862 return wpa_cli_cmd(ctrl, "MESH_GROUP_REMOVE", 1, argc, argv);
1863}
1864
e174ef34
MH		 1865
1866static int wpa_cli_cmd_mesh_peer_remove(struct wpa_ctrl *ctrl, int argc,
1867 char *argv[])
1868{
1869 return wpa_cli_cmd(ctrl, "MESH_PEER_REMOVE", 1, argc, argv);
1870}
1871
2604edbf
MH		 1872
1873static int wpa_cli_cmd_mesh_peer_add(struct wpa_ctrl *ctrl, int argc,
1874 char *argv[])
1875{
1876 return wpa_cli_cmd(ctrl, "MESH_PEER_ADD", 1, argc, argv);
1877}
1878
603a3f34
JL		 1879#endif /* CONFIG_MESH */
1880
1881
57faa1ce
JM		 1882#ifdef CONFIG_P2P
1883
1884static int wpa_cli_cmd_p2p_find(struct wpa_ctrl *ctrl, int argc, char *argv[])
1885{
87c7ba84 1886 return wpa_cli_cmd(ctrl, "P2P_FIND", 0, argc, argv);
57faa1ce
JM		 1887}
1888
1889
01335e2c
JM		 1890static char ** wpa_cli_complete_p2p_find(const char *str, int pos)
1891{
1892 char **res = NULL;
1893 int arg = get_cmd_arg_num(str, pos);
1894
1895 res = os_calloc(6, sizeof(char *));
1896 if (res == NULL)
1897 return NULL;
1898 res[0] = os_strdup("type=social");
1899 if (res[0] == NULL) {
1900 os_free(res);
1901 return NULL;
1902 }
1903 res[1] = os_strdup("type=progressive");
1904 if (res[1] == NULL)
1905 return res;
1906 res[2] = os_strdup("delay=");
1907 if (res[2] == NULL)
1908 return res;
1909 res[3] = os_strdup("dev_id=");
1910 if (res[3] == NULL)
1911 return res;
1912 if (arg == 1)
1913 res[4] = os_strdup("[timeout]");
1914
1915 return res;
1916}
1917
1918
57faa1ce
JM		 1919static int wpa_cli_cmd_p2p_stop_find(struct wpa_ctrl *ctrl, int argc,
1920 char *argv[])
1921{
1922 return wpa_ctrl_command(ctrl, "P2P_STOP_FIND");
1923}
1924
1925
f309c18e
KV		 1926static int wpa_cli_cmd_p2p_asp_provision(struct wpa_ctrl *ctrl, int argc,
1927 char *argv[])
1928{
1929 return wpa_cli_cmd(ctrl, "P2P_ASP_PROVISION", 3, argc, argv);
1930}
1931
1932
1933static int wpa_cli_cmd_p2p_asp_provision_resp(struct wpa_ctrl *ctrl, int argc,
1934 char *argv[])
1935{
1936 return wpa_cli_cmd(ctrl, "P2P_ASP_PROVISION_RESP", 2, argc, argv);
1937}
1938
1939
57faa1ce
JM		 1940static int wpa_cli_cmd_p2p_connect(struct wpa_ctrl *ctrl, int argc,
1941 char *argv[])
1942{
87c7ba84 1943 return wpa_cli_cmd(ctrl, "P2P_CONNECT", 2, argc, argv);
57faa1ce
JM		 1944}
1945
1946
a624f20b
JM		 1947static char ** wpa_cli_complete_p2p_connect(const char *str, int pos)
1948{
1949 int arg = get_cmd_arg_num(str, pos);
1950 char **res = NULL;
1951
1952 switch (arg) {
1953 case 1:
1954 res = cli_txt_list_array(&p2p_peers);
1955 break;
1956 }
1957
1958 return res;
1959}
1960
1961
57faa1ce
JM		 1962static int wpa_cli_cmd_p2p_listen(struct wpa_ctrl *ctrl, int argc,
1963 char *argv[])
1964{
87c7ba84 1965 return wpa_cli_cmd(ctrl, "P2P_LISTEN", 0, argc, argv);
57faa1ce
JM		 1966}
1967
1968
1969static int wpa_cli_cmd_p2p_group_remove(struct wpa_ctrl *ctrl, int argc,
1970 char *argv[])
1971{
87c7ba84 1972 return wpa_cli_cmd(ctrl, "P2P_GROUP_REMOVE", 1, argc, argv);
57faa1ce
JM		 1973}
1974
1975
76788542
JM		 1976static char ** wpa_cli_complete_p2p_group_remove(const char *str, int pos)
1977{
1978 int arg = get_cmd_arg_num(str, pos);
1979 char **res = NULL;
1980
1981 switch (arg) {
1982 case 1:
1983 res = cli_txt_list_array(&p2p_groups);
1984 break;
1985 }
1986
1987 return res;
1988}
1989
1990
57faa1ce
JM		 1991static int wpa_cli_cmd_p2p_group_add(struct wpa_ctrl *ctrl, int argc,
1992 char *argv[])
1993{
87c7ba84 1994 return wpa_cli_cmd(ctrl, "P2P_GROUP_ADD", 0, argc, argv);
57faa1ce
JM		 1995}
1996
1997
57b38882
PK		 1998static int wpa_cli_cmd_p2p_group_member(struct wpa_ctrl *ctrl, int argc,
1999 char *argv[])
2000{
2001 return wpa_cli_cmd(ctrl, "P2P_GROUP_MEMBER", 1, argc, argv);
2002}
2003
2004
57faa1ce
JM		 2005static int wpa_cli_cmd_p2p_prov_disc(struct wpa_ctrl *ctrl, int argc,
2006 char *argv[])
2007{
8c5f7309
JJ		 2008 if (argc != 2 && argc != 3) {
2009 printf("Invalid P2P_PROV_DISC command: needs at least "
2010 "two arguments, address and config method\n"
2011 "(display, keypad, or pbc) and an optional join\n");
57faa1ce
JM		 2012 return -1;
2013 }
2014
87c7ba84 2015 return wpa_cli_cmd(ctrl, "P2P_PROV_DISC", 2, argc, argv);
57faa1ce
JM		 2016}
2017
2018
2019static int wpa_cli_cmd_p2p_get_passphrase(struct wpa_ctrl *ctrl, int argc,
2020 char *argv[])
2021{
2022 return wpa_ctrl_command(ctrl, "P2P_GET_PASSPHRASE");
2023}
2024
2025
2026static int wpa_cli_cmd_p2p_serv_disc_req(struct wpa_ctrl *ctrl, int argc,
2027 char *argv[])
2028{
2029 char cmd[4096];
57faa1ce 2030
5a4102ce 2031 if (argc < 2) {
57faa1ce 2032 printf("Invalid P2P_SERV_DISC_REQ command: needs two "
5a4102ce 2033 "or more arguments (address and TLVs)\n");
57faa1ce
JM		 2034 return -1;
2035 }
2036
87c7ba84 2037 if (write_cmd(cmd, sizeof(cmd), "P2P_SERV_DISC_REQ", argc, argv) < 0)
57faa1ce 2038 return -1;
57faa1ce
JM		 2039 return wpa_ctrl_command(ctrl, cmd);
2040}
2041
2042
2043static int wpa_cli_cmd_p2p_serv_disc_cancel_req(struct wpa_ctrl *ctrl,
2044 int argc, char *argv[])
2045{
87c7ba84 2046 return wpa_cli_cmd(ctrl, "P2P_SERV_DISC_CANCEL_REQ", 1, argc, argv);
57faa1ce
JM		 2047}
2048
2049
2050static int wpa_cli_cmd_p2p_serv_disc_resp(struct wpa_ctrl *ctrl, int argc,
2051 char *argv[])
2052{
2053 char cmd[4096];
2054 int res;
2055
2056 if (argc != 4) {
2057 printf("Invalid P2P_SERV_DISC_RESP command: needs four "
2058 "arguments (freq, address, dialog token, and TLVs)\n");
2059 return -1;
2060 }
2061
2062 res = os_snprintf(cmd, sizeof(cmd), "P2P_SERV_DISC_RESP %s %s %s %s",
2063 argv[0], argv[1], argv[2], argv[3]);
d85e1fc8 2064 if (os_snprintf_error(sizeof(cmd), res))
57faa1ce
JM		 2065 return -1;
2066 cmd[sizeof(cmd) - 1] = '\0';
2067 return wpa_ctrl_command(ctrl, cmd);
2068}
2069
2070
2071static int wpa_cli_cmd_p2p_service_update(struct wpa_ctrl *ctrl, int argc,
2072 char *argv[])
2073{
2074 return wpa_ctrl_command(ctrl, "P2P_SERVICE_UPDATE");
2075}
2076
2077
2078static int wpa_cli_cmd_p2p_serv_disc_external(struct wpa_ctrl *ctrl,
2079 int argc, char *argv[])
2080{
87c7ba84 2081 return wpa_cli_cmd(ctrl, "P2P_SERV_DISC_EXTERNAL", 1, argc, argv);
57faa1ce
JM		 2082}
2083
2084
2085static int wpa_cli_cmd_p2p_service_flush(struct wpa_ctrl *ctrl, int argc,
2086 char *argv[])
2087{
2088 return wpa_ctrl_command(ctrl, "P2P_SERVICE_FLUSH");
2089}
2090
2091
2092static int wpa_cli_cmd_p2p_service_add(struct wpa_ctrl *ctrl, int argc,
2093 char *argv[])
2094{
ae9d45f3
KV		 2095 if (argc < 3) {
2096 printf("Invalid P2P_SERVICE_ADD command: needs 3-6 arguments\n");
2097 return -1;
2098 }
57faa1ce 2099
ae9d45f3
KV		 2100 return wpa_cli_cmd(ctrl, "P2P_SERVICE_ADD", 3, argc, argv);
2101}
2102
2103
2104static int wpa_cli_cmd_p2p_service_rep(struct wpa_ctrl *ctrl, int argc,
2105 char *argv[])
2106{
2107 if (argc < 5 || argc > 6) {
2108 printf("Invalid P2P_SERVICE_REP command: needs 5-6 "
57faa1ce
JM		 2109 "arguments\n");
2110 return -1;
2111 }
2112
ae9d45f3 2113 return wpa_cli_cmd(ctrl, "P2P_SERVICE_REP", 5, argc, argv);
57faa1ce
JM		 2114}
2115
2116
2117static int wpa_cli_cmd_p2p_service_del(struct wpa_ctrl *ctrl, int argc,
2118 char *argv[])
2119{
2120 char cmd[4096];
2121 int res;
2122
2123 if (argc != 2 && argc != 3) {
2124 printf("Invalid P2P_SERVICE_DEL command: needs two or three "
2125 "arguments\n");
2126 return -1;
2127 }
2128
2129 if (argc == 3)
2130 res = os_snprintf(cmd, sizeof(cmd),
2131 "P2P_SERVICE_DEL %s %s %s",
2132 argv[0], argv[1], argv[2]);
2133 else
2134 res = os_snprintf(cmd, sizeof(cmd),
2135 "P2P_SERVICE_DEL %s %s",
2136 argv[0], argv[1]);
d85e1fc8 2137 if (os_snprintf_error(sizeof(cmd), res))
57faa1ce
JM		 2138 return -1;
2139 cmd[sizeof(cmd) - 1] = '\0';
2140 return wpa_ctrl_command(ctrl, cmd);
2141}
2142
2143
2144static int wpa_cli_cmd_p2p_reject(struct wpa_ctrl *ctrl,
2145 int argc, char *argv[])
2146{
87c7ba84 2147 return wpa_cli_cmd(ctrl, "P2P_REJECT", 1, argc, argv);
57faa1ce
JM		 2148}
2149
2150
2151static int wpa_cli_cmd_p2p_invite(struct wpa_ctrl *ctrl,
2152 int argc, char *argv[])
2153{
87c7ba84 2154 return wpa_cli_cmd(ctrl, "P2P_INVITE", 1, argc, argv);
57faa1ce
JM		 2155}
2156
2157
2158static int wpa_cli_cmd_p2p_peer(struct wpa_ctrl *ctrl, int argc, char *argv[])
2159{
87c7ba84 2160 return wpa_cli_cmd(ctrl, "P2P_PEER", 1, argc, argv);
57faa1ce
JM		 2161}
2162
2163
a624f20b
JM		 2164static char ** wpa_cli_complete_p2p_peer(const char *str, int pos)
2165{
2166 int arg = get_cmd_arg_num(str, pos);
2167 char **res = NULL;
2168
2169 switch (arg) {
2170 case 1:
2171 res = cli_txt_list_array(&p2p_peers);
2172 break;
2173 }
2174
2175 return res;
2176}
2177
2178
57faa1ce
JM		 2179static int wpa_ctrl_command_p2p_peer(struct wpa_ctrl *ctrl, char *cmd,
2180 char *addr, size_t addr_len,
2181 int discovered)
2182{
2183 char buf[4096], *pos;
2184 size_t len;
2185 int ret;
2186
2187 if (ctrl_conn == NULL)
2188 return -1;
2189 len = sizeof(buf) - 1;
024d018b 2190 ret = wpa_ctrl_request(ctrl, cmd, os_strlen(cmd), buf, &len,
57faa1ce
JM		 2191 wpa_cli_msg_cb);
2192 if (ret == -2) {
2193 printf("'%s' command timed out.\n", cmd);
2194 return -2;
2195 } else if (ret < 0) {
2196 printf("'%s' command failed.\n", cmd);
2197 return -1;
2198 }
2199
2200 buf[len] = '\0';
024d018b 2201 if (os_memcmp(buf, "FAIL", 4) == 0)
57faa1ce
JM		 2202 return -1;
2203
2204 pos = buf;
2205 while (*pos != '\0' && *pos != '\n')
2206 pos++;
2207 *pos++ = '\0';
2208 os_strlcpy(addr, buf, addr_len);
2209 if (!discovered || os_strstr(pos, "[PROBE_REQ_ONLY]") == NULL)
2210 printf("%s\n", addr);
2211 return 0;
2212}
2213
2214
2215static int wpa_cli_cmd_p2p_peers(struct wpa_ctrl *ctrl, int argc, char *argv[])
2216{
2217 char addr[32], cmd[64];
2218 int discovered;
2219
2220 discovered = argc > 0 && os_strcmp(argv[0], "discovered") == 0;
2221
2222 if (wpa_ctrl_command_p2p_peer(ctrl, "P2P_PEER FIRST",
2223 addr, sizeof(addr), discovered))
9a6ade33 2224 return -1;
57faa1ce
JM		 2225 do {
2226 os_snprintf(cmd, sizeof(cmd), "P2P_PEER NEXT-%s", addr);
2227 } while (wpa_ctrl_command_p2p_peer(ctrl, cmd, addr, sizeof(addr),
2228 discovered) == 0);
2229
9a6ade33 2230 return 0;
57faa1ce
JM		 2231}
2232
2233
2234static int wpa_cli_cmd_p2p_set(struct wpa_ctrl *ctrl, int argc, char *argv[])
2235{
87c7ba84 2236 return wpa_cli_cmd(ctrl, "P2P_SET", 2, argc, argv);
57faa1ce
JM		 2237}
2238
2239
698e921b
JM		 2240static char ** wpa_cli_complete_p2p_set(const char *str, int pos)
2241{
2242 int arg = get_cmd_arg_num(str, pos);
2243 const char *fields[] = {
2244 "discoverability",
2245 "managed",
2246 "listen_channel",
2247 "ssid_postfix",
2248 "noa",
2249 "ps",
2250 "oppps",
2251 "ctwindow",
2252 "disabled",
2253 "conc_pref",
2254 "force_long_sd",
2255 "peer_filter",
2256 "cross_connect",
2257 "go_apsd",
2258 "client_apsd",
2259 "disallow_freq",
2260 "disc_int",
05766ed8 2261 "per_sta_psk",
698e921b 2262 };
e7ecab4a 2263 int i, num_fields = ARRAY_SIZE(fields);
698e921b
JM		 2264
2265 if (arg == 1) {
2266 char **res = os_calloc(num_fields + 1, sizeof(char *));
2267 if (res == NULL)
2268 return NULL;
2269 for (i = 0; i < num_fields; i++) {
2270 res[i] = os_strdup(fields[i]);
2271 if (res[i] == NULL)
2272 return res;
2273 }
2274 return res;
2275 }
2276
2277 if (arg == 2 && os_strncasecmp(str, "p2p_set peer_filter ", 20) == 0)
2278 return cli_txt_list_array(&p2p_peers);
2279
2280 return NULL;
2281}
2282
2283
57faa1ce
JM		 2284static int wpa_cli_cmd_p2p_flush(struct wpa_ctrl *ctrl, int argc, char *argv[])
2285{
2286 return wpa_ctrl_command(ctrl, "P2P_FLUSH");
2287}
2288
2289
59eba7a2
JM		 2290static int wpa_cli_cmd_p2p_cancel(struct wpa_ctrl *ctrl, int argc,
2291 char *argv[])
2292{
2293 return wpa_ctrl_command(ctrl, "P2P_CANCEL");
2294}
2295
2296
9d562b79
SS		 2297static int wpa_cli_cmd_p2p_unauthorize(struct wpa_ctrl *ctrl, int argc,
2298 char *argv[])
2299{
87c7ba84 2300 return wpa_cli_cmd(ctrl, "P2P_UNAUTHORIZE", 1, argc, argv);
9d562b79
SS		 2301}
2302
2303
57faa1ce
JM		 2304static int wpa_cli_cmd_p2p_presence_req(struct wpa_ctrl *ctrl, int argc,
2305 char *argv[])
2306{
57faa1ce
JM		 2307 if (argc != 0 && argc != 2 && argc != 4) {
2308 printf("Invalid P2P_PRESENCE_REQ command: needs two arguments "
2309 "(preferred duration, interval; in microsecods).\n"
2310 "Optional second pair can be used to provide "
2311 "acceptable values.\n");
2312 return -1;
2313 }
2314
87c7ba84 2315 return wpa_cli_cmd(ctrl, "P2P_PRESENCE_REQ", 0, argc, argv);
57faa1ce
JM		 2316}
2317
2318
2319static int wpa_cli_cmd_p2p_ext_listen(struct wpa_ctrl *ctrl, int argc,
2320 char *argv[])
2321{
57faa1ce
JM		 2322 if (argc != 0 && argc != 2) {
2323 printf("Invalid P2P_EXT_LISTEN command: needs two arguments "
2324 "(availability period, availability interval; in "
2325 "millisecods).\n"
2326 "Extended Listen Timing can be cancelled with this "
2327 "command when used without parameters.\n");
2328 return -1;
2329 }
2330
87c7ba84 2331 return wpa_cli_cmd(ctrl, "P2P_EXT_LISTEN", 0, argc, argv);
57faa1ce
JM		 2332}
2333
f2c56602
JM		 2334
2335static int wpa_cli_cmd_p2p_remove_client(struct wpa_ctrl *ctrl, int argc,
2336 char *argv[])
2337{
2338 return wpa_cli_cmd(ctrl, "P2P_REMOVE_CLIENT", 1, argc, argv);
2339}
2340
cdcb2d0e
PK		 2341
2342static int wpa_cli_cmd_vendor_elem_add(struct wpa_ctrl *ctrl, int argc,
2343 char *argv[])
2344{
2345 return wpa_cli_cmd(ctrl, "VENDOR_ELEM_ADD", 2, argc, argv);
2346}
2347
2348
2349static int wpa_cli_cmd_vendor_elem_get(struct wpa_ctrl *ctrl, int argc,
2350 char *argv[])
2351{
2352 return wpa_cli_cmd(ctrl, "VENDOR_ELEM_GET", 1, argc, argv);
2353}
2354
2355
2356static int wpa_cli_cmd_vendor_elem_remove(struct wpa_ctrl *ctrl, int argc,
2357 char *argv[])
2358{
2359 return wpa_cli_cmd(ctrl, "VENDOR_ELEM_REMOVE", 2, argc, argv);
2360}
2361
57faa1ce
JM		 2362#endif /* CONFIG_P2P */
2363
9675ce35
JM		 2364#ifdef CONFIG_WIFI_DISPLAY
2365
2366static int wpa_cli_cmd_wfd_subelem_set(struct wpa_ctrl *ctrl, int argc,
2367 char *argv[])
2368{
2369 char cmd[100];
2370 int res;
2371
2372 if (argc != 1 && argc != 2) {
2373 printf("Invalid WFD_SUBELEM_SET command: needs one or two "
2374 "arguments (subelem, hexdump)\n");
2375 return -1;
2376 }
2377
2378 res = os_snprintf(cmd, sizeof(cmd), "WFD_SUBELEM_SET %s %s",
2379 argv[0], argc > 1 ? argv[1] : "");
d85e1fc8 2380 if (os_snprintf_error(sizeof(cmd), res))
9675ce35
JM		 2381 return -1;
2382 cmd[sizeof(cmd) - 1] = '\0';
2383 return wpa_ctrl_command(ctrl, cmd);
2384}
2385
2386
2387static int wpa_cli_cmd_wfd_subelem_get(struct wpa_ctrl *ctrl, int argc,
2388 char *argv[])
2389{
2390 char cmd[100];
2391 int res;
2392
2393 if (argc != 1) {
2394 printf("Invalid WFD_SUBELEM_GET command: needs one "
2395 "argument (subelem)\n");
2396 return -1;
2397 }
2398
2399 res = os_snprintf(cmd, sizeof(cmd), "WFD_SUBELEM_GET %s",
2400 argv[0]);
d85e1fc8 2401 if (os_snprintf_error(sizeof(cmd), res))
9675ce35
JM		 2402 return -1;
2403 cmd[sizeof(cmd) - 1] = '\0';
2404 return wpa_ctrl_command(ctrl, cmd);
2405}
2406#endif /* CONFIG_WIFI_DISPLAY */
2407
57faa1ce 2408
afc064fe
JM		 2409#ifdef CONFIG_INTERWORKING
2410static int wpa_cli_cmd_fetch_anqp(struct wpa_ctrl *ctrl, int argc,
2411 char *argv[])
2412{
2413 return wpa_ctrl_command(ctrl, "FETCH_ANQP");
2414}
2415
2416
2417static int wpa_cli_cmd_stop_fetch_anqp(struct wpa_ctrl *ctrl, int argc,
2418 char *argv[])
2419{
2420 return wpa_ctrl_command(ctrl, "STOP_FETCH_ANQP");
2421}
2422
2423
b02fe7ff
JM		 2424static int wpa_cli_cmd_interworking_select(struct wpa_ctrl *ctrl, int argc,
2425 char *argv[])
2426{
87c7ba84 2427 return wpa_cli_cmd(ctrl, "INTERWORKING_SELECT", 0, argc, argv);
b02fe7ff
JM		 2428}
2429
2430
2431static int wpa_cli_cmd_interworking_connect(struct wpa_ctrl *ctrl, int argc,
2432 char *argv[])
2433{
87c7ba84 2434 return wpa_cli_cmd(ctrl, "INTERWORKING_CONNECT", 1, argc, argv);
b02fe7ff
JM		 2435}
2436
2437
f91a512f
JM		 2438static int wpa_cli_cmd_interworking_add_network(struct wpa_ctrl *ctrl, int argc,
2439 char *argv[])
2440{
2441 return wpa_cli_cmd(ctrl, "INTERWORKING_ADD_NETWORK", 1, argc, argv);
2442}
2443
2444
afc064fe
JM		 2445static int wpa_cli_cmd_anqp_get(struct wpa_ctrl *ctrl, int argc, char *argv[])
2446{
87c7ba84 2447 return wpa_cli_cmd(ctrl, "ANQP_GET", 2, argc, argv);
afc064fe 2448}
b1f12296
JM		 2449
2450
2451static int wpa_cli_cmd_gas_request(struct wpa_ctrl *ctrl, int argc,
2452 char *argv[])
2453{
2454 return wpa_cli_cmd(ctrl, "GAS_REQUEST", 2, argc, argv);
2455}
2456
2457
2458static int wpa_cli_cmd_gas_response_get(struct wpa_ctrl *ctrl, int argc,
2459 char *argv[])
2460{
2461 return wpa_cli_cmd(ctrl, "GAS_RESPONSE_GET", 2, argc, argv);
2462}
afc064fe
JM		 2463#endif /* CONFIG_INTERWORKING */
2464
2465
a8918e86
JK		 2466#ifdef CONFIG_HS20
2467
2468static int wpa_cli_cmd_hs20_anqp_get(struct wpa_ctrl *ctrl, int argc,
2469 char *argv[])
2470{
87c7ba84 2471 return wpa_cli_cmd(ctrl, "HS20_ANQP_GET", 2, argc, argv);
a8918e86
JK		 2472}
2473
2474
2475static int wpa_cli_cmd_get_nai_home_realm_list(struct wpa_ctrl *ctrl, int argc,
2476 char *argv[])
2477{
2478 char cmd[512];
a8918e86
JK		 2479
2480 if (argc == 0) {
2481 printf("Command needs one or two arguments (dst mac addr and "
2482 "optional home realm)\n");
2483 return -1;
2484 }
2485
87c7ba84
JM		 2486 if (write_cmd(cmd, sizeof(cmd), "HS20_GET_NAI_HOME_REALM_LIST",
2487 argc, argv) < 0)
a8918e86 2488 return -1;
a8918e86
JK		 2489
2490 return wpa_ctrl_command(ctrl, cmd);
2491}
2492
184e110c
JM		 2493
2494static int wpa_cli_cmd_hs20_icon_request(struct wpa_ctrl *ctrl, int argc,
2495 char *argv[])
2496{
2497 char cmd[512];
2498
2499 if (argc < 2) {
2500 printf("Command needs two arguments (dst mac addr and "
2501 "icon name)\n");
2502 return -1;
2503 }
2504
2505 if (write_cmd(cmd, sizeof(cmd), "HS20_ICON_REQUEST", argc, argv) < 0)
2506 return -1;
2507
2508 return wpa_ctrl_command(ctrl, cmd);
2509}
2510
b572df86
JM		 2511
2512static int wpa_cli_cmd_fetch_osu(struct wpa_ctrl *ctrl, int argc, char *argv[])
2513{
2514 return wpa_ctrl_command(ctrl, "FETCH_OSU");
2515}
2516
2517
2518static int wpa_cli_cmd_cancel_fetch_osu(struct wpa_ctrl *ctrl, int argc,
2519 char *argv[])
2520{
2521 return wpa_ctrl_command(ctrl, "CANCEL_FETCH_OSU");
2522}
2523
a8918e86
JK		 2524#endif /* CONFIG_HS20 */
2525
2526
0d0a8ca1
AC		 2527static int wpa_cli_cmd_sta_autoconnect(struct wpa_ctrl *ctrl, int argc,
2528 char *argv[])
2529{
87c7ba84 2530 return wpa_cli_cmd(ctrl, "STA_AUTOCONNECT", 1, argc, argv);
0d0a8ca1
AC		 2531}
2532
2533
281ff0aa
GP		 2534static int wpa_cli_cmd_tdls_discover(struct wpa_ctrl *ctrl, int argc,
2535 char *argv[])
2536{
87c7ba84 2537 return wpa_cli_cmd(ctrl, "TDLS_DISCOVER", 1, argc, argv);
281ff0aa
GP		 2538}
2539
2540
2541static int wpa_cli_cmd_tdls_setup(struct wpa_ctrl *ctrl, int argc,
2542 char *argv[])
2543{
87c7ba84 2544 return wpa_cli_cmd(ctrl, "TDLS_SETUP", 1, argc, argv);
281ff0aa
GP		 2545}
2546
2547
2548static int wpa_cli_cmd_tdls_teardown(struct wpa_ctrl *ctrl, int argc,
2549 char *argv[])
2550{
87c7ba84 2551 return wpa_cli_cmd(ctrl, "TDLS_TEARDOWN", 1, argc, argv);
281ff0aa
GP		 2552}
2553
2554
4504621f
OG		 2555static int wpa_cli_cmd_tdls_link_status(struct wpa_ctrl *ctrl, int argc,
2556 char *argv[])
2557{
2558 return wpa_cli_cmd(ctrl, "TDLS_LINK_STATUS", 1, argc, argv);
2559}
2560
2561
df9d340c
MB		 2562static int wpa_cli_cmd_wmm_ac_addts(struct wpa_ctrl *ctrl, int argc,
2563 char *argv[])
2564{
2565 return wpa_cli_cmd(ctrl, "WMM_AC_ADDTS", 3, argc, argv);
2566}
2567
2568
2569static int wpa_cli_cmd_wmm_ac_delts(struct wpa_ctrl *ctrl, int argc,
2570 char *argv[])
2571{
2572 return wpa_cli_cmd(ctrl, "WMM_AC_DELTS", 1, argc, argv);
2573}
2574
2575
8506ea6f
MB		 2576static int wpa_cli_cmd_wmm_ac_status(struct wpa_ctrl *ctrl, int argc,
2577 char *argv[])
2578{
2579 return wpa_ctrl_command(ctrl, "WMM_AC_STATUS");
2580}
2581
2582
7db53bb8
AN		 2583static int wpa_cli_cmd_tdls_chan_switch(struct wpa_ctrl *ctrl, int argc,
2584 char *argv[])
2585{
2586 return wpa_cli_cmd(ctrl, "TDLS_CHAN_SWITCH", 2, argc, argv);
2587}
2588
2589
2590static int wpa_cli_cmd_tdls_cancel_chan_switch(struct wpa_ctrl *ctrl, int argc,
2591 char *argv[])
2592{
2593 return wpa_cli_cmd(ctrl, "TDLS_CANCEL_CHAN_SWITCH", 1, argc, argv);
2594}
2595
2596
60b24b0d
DS		 2597static int wpa_cli_cmd_signal_poll(struct wpa_ctrl *ctrl, int argc,
2598 char *argv[])
2599{
2600 return wpa_ctrl_command(ctrl, "SIGNAL_POLL");
2601}
2602
2603
96e8d831
DS		 2604static int wpa_cli_cmd_signal_monitor(struct wpa_ctrl *ctrl, int argc,
2605 char *argv[])
2606{
2607 return wpa_cli_cmd(ctrl, "SIGNAL_MONITOR", 0, argc, argv);
2608}
2609
2610
dc7785f8
YZ		 2611static int wpa_cli_cmd_pktcnt_poll(struct wpa_ctrl *ctrl, int argc,
2612 char *argv[])
2613{
2614 return wpa_ctrl_command(ctrl, "PKTCNT_POLL");
2615}
2616
2617
9482426e
JM		 2618static int wpa_cli_cmd_reauthenticate(struct wpa_ctrl *ctrl, int argc,
2619 char *argv[])
2620{
2621 return wpa_ctrl_command(ctrl, "REAUTHENTICATE");
2622}
2623
2624
2bdd8342
TB		 2625#ifdef CONFIG_AUTOSCAN
2626
2627static int wpa_cli_cmd_autoscan(struct wpa_ctrl *ctrl, int argc, char *argv[])
2628{
2bdd8342
TB		 2629 if (argc == 0)
2630 return wpa_ctrl_command(ctrl, "AUTOSCAN ");
2631
87c7ba84 2632 return wpa_cli_cmd(ctrl, "AUTOSCAN", 0, argc, argv);
2bdd8342
TB		 2633}
2634
2635#endif /* CONFIG_AUTOSCAN */
2636
2637
e9199e31
JM		 2638#ifdef CONFIG_WNM
2639
2640static int wpa_cli_cmd_wnm_sleep(struct wpa_ctrl *ctrl, int argc, char *argv[])
2641{
2642 return wpa_cli_cmd(ctrl, "WNM_SLEEP", 0, argc, argv);
2643}
2644
65bcd0a9
VK		 2645
2646static int wpa_cli_cmd_wnm_bss_query(struct wpa_ctrl *ctrl, int argc, char *argv[])
2647{
2648 return wpa_cli_cmd(ctrl, "WNM_BSS_QUERY", 1, argc, argv);
2649}
2650
e9199e31
JM		 2651#endif /* CONFIG_WNM */
2652
2653
27b80b5b
JM		 2654static int wpa_cli_cmd_raw(struct wpa_ctrl *ctrl, int argc, char *argv[])
2655{
2656 if (argc == 0)
2657 return -1;
2658 return wpa_cli_cmd(ctrl, argv[0], 0, argc - 1, &argv[1]);
2659}
2660
2661
5e2c3490
JM		 2662#ifdef ANDROID
2663static int wpa_cli_cmd_driver(struct wpa_ctrl *ctrl, int argc, char *argv[])
2664{
2665 return wpa_cli_cmd(ctrl, "DRIVER", 1, argc, argv);
2666}
2667#endif /* ANDROID */
2668
2669
adef8948
BL		 2670static int wpa_cli_cmd_vendor(struct wpa_ctrl *ctrl, int argc, char *argv[])
2671{
2672 return wpa_cli_cmd(ctrl, "VENDOR", 1, argc, argv);
2673}
2674
2675
acb54643
JM		 2676static int wpa_cli_cmd_flush(struct wpa_ctrl *ctrl, int argc, char *argv[])
2677{
2678 return wpa_ctrl_command(ctrl, "FLUSH");
2679}
2680
2681
1f965e62
JM		 2682static int wpa_cli_cmd_radio_work(struct wpa_ctrl *ctrl, int argc, char *argv[])
2683{
2684 return wpa_cli_cmd(ctrl, "RADIO_WORK", 1, argc, argv);
2685}
2686
2687
fad14af9
AK		 2688static int wpa_cli_cmd_neighbor_rep_request(struct wpa_ctrl *ctrl, int argc,
2689 char *argv[])
2690{
2691 return wpa_cli_cmd(ctrl, "NEIGHBOR_REP_REQUEST", 0, argc, argv);
2692}
2693
2694
65d9a5e2
JM		 2695static int wpa_cli_cmd_erp_flush(struct wpa_ctrl *ctrl, int argc, char *argv[])
2696{
2697 return wpa_ctrl_command(ctrl, "ERP_FLUSH");
2698}
2699
2700
8b48e320
IP		 2701static int wpa_cli_cmd_mac_rand_scan(struct wpa_ctrl *ctrl, int argc,
2702 char *argv[])
2703{
2704 return wpa_cli_cmd(ctrl, "MAC_RAND_SCAN", 1, argc, argv);
2705}
2706
2707
98342208
AK		 2708static int wpa_cli_cmd_get_pref_freq_list(struct wpa_ctrl *ctrl, int argc,
2709 char *argv[])
2710{
2711 return wpa_cli_cmd(ctrl, "GET_PREF_FREQ_LIST", 1, argc, argv);
2712}
2713
2714
a6f5b193
PX		 2715static int wpa_cli_cmd_p2p_lo_start(struct wpa_ctrl *ctrl, int argc,
2716 char *argv[])
2717{
2718 return wpa_cli_cmd(ctrl, "P2P_LO_START", 4, argc, argv);
2719}
2720
2721
2722static int wpa_cli_cmd_p2p_lo_stop(struct wpa_ctrl *ctrl, int argc,
2723 char *argv[])
2724{
2725 return wpa_cli_cmd(ctrl, "P2P_LO_STOP", 0, argc, argv);
2726}
2727
2728
40fd868c
ER		 2729enum wpa_cli_cmd_flags {
2730 cli_cmd_flag_none = 0x00,
2731 cli_cmd_flag_sensitive = 0x01
2732};
2733
6fc6879b
JM		 2734struct wpa_cli_cmd {
2735 const char *cmd;
2736 int (*handler)(struct wpa_ctrl *ctrl, int argc, char *argv[]);
b49039bd 2737 char ** (*completion)(const char *str, int pos);
40fd868c 2738 enum wpa_cli_cmd_flags flags;
dfa141b1 2739 const char *usage;
6fc6879b
JM		 2740};
2741
8b423edb 2742static const struct wpa_cli_cmd wpa_cli_commands[] = {
b49039bd 2743 { "status", wpa_cli_cmd_status, NULL,
dfa141b1
ER		 2744 cli_cmd_flag_none,
2745 "[verbose] = get current WPA/EAPOL/EAP status" },
b49039bd 2746 { "ifname", wpa_cli_cmd_ifname, NULL,
0eed2a8d
JD		 2747 cli_cmd_flag_none,
2748 "= get current interface name" },
b49039bd 2749 { "ping", wpa_cli_cmd_ping, NULL,
dfa141b1
ER		 2750 cli_cmd_flag_none,
2751 "= pings wpa_supplicant" },
b49039bd 2752 { "relog", wpa_cli_cmd_relog, NULL,
ac6912b5
BG		 2753 cli_cmd_flag_none,
2754 "= re-open log-file (allow rolling logs)" },
b49039bd 2755 { "note", wpa_cli_cmd_note, NULL,
77895cd9
JM		 2756 cli_cmd_flag_none,
2757 "<text> = add a note to wpa_supplicant debug log" },
b49039bd 2758 { "mib", wpa_cli_cmd_mib, NULL,
dfa141b1
ER		 2759 cli_cmd_flag_none,
2760 "= get MIB variables (dot1x, dot11)" },
2af4d404 2761 { "help", wpa_cli_cmd_help, wpa_cli_complete_help,
dfa141b1 2762 cli_cmd_flag_none,
2af4d404 2763 "[command] = show usage help" },
b49039bd 2764 { "interface", wpa_cli_cmd_interface, NULL,
dfa141b1
ER		 2765 cli_cmd_flag_none,
2766 "[ifname] = show interfaces/select interface" },
b49039bd 2767 { "level", wpa_cli_cmd_level, NULL,
dfa141b1
ER		 2768 cli_cmd_flag_none,
2769 "<debug level> = change debug level" },
b49039bd 2770 { "license", wpa_cli_cmd_license, NULL,
dfa141b1
ER		 2771 cli_cmd_flag_none,
2772 "= show full wpa_cli license" },
b49039bd 2773 { "quit", wpa_cli_cmd_quit, NULL,
dfa141b1
ER		 2774 cli_cmd_flag_none,
2775 "= exit wpa_cli" },
21565872 2776 { "set", wpa_cli_cmd_set, wpa_cli_complete_set,
dfa141b1
ER		 2777 cli_cmd_flag_none,
2778 "= set variables (shows list of variables when run without "
2779 "arguments)" },
10263dc2
OO		 2780 { "dump", wpa_cli_cmd_dump, NULL,
2781 cli_cmd_flag_none,
2782 "= dump config variables" },
0fd9d95f 2783 { "get", wpa_cli_cmd_get, wpa_cli_complete_get,
acec8d32
JM		 2784 cli_cmd_flag_none,
2785 "<name> = get information" },
4d7aab78
EL		 2786 { "driver_flags", wpa_cli_cmd_driver_flags, NULL,
2787 cli_cmd_flag_none,
2788 "= list driver flags" },
b49039bd 2789 { "logon", wpa_cli_cmd_logon, NULL,
dfa141b1
ER		 2790 cli_cmd_flag_none,
2791 "= IEEE 802.1X EAPOL state machine logon" },
b49039bd 2792 { "logoff", wpa_cli_cmd_logoff, NULL,
dfa141b1
ER		 2793 cli_cmd_flag_none,
2794 "= IEEE 802.1X EAPOL state machine logoff" },
b49039bd 2795 { "pmksa", wpa_cli_cmd_pmksa, NULL,
dfa141b1
ER		 2796 cli_cmd_flag_none,
2797 "= show PMKSA cache" },
79e2b1cc
AK		 2798 { "pmksa_flush", wpa_cli_cmd_pmksa_flush, NULL,
2799 cli_cmd_flag_none,
2800 "= flush PMKSA cache entries" },
b49039bd 2801 { "reassociate", wpa_cli_cmd_reassociate, NULL,
dfa141b1
ER		 2802 cli_cmd_flag_none,
2803 "= force reassociation" },
0f44ec8e
PQ		 2804 { "reattach", wpa_cli_cmd_reattach, NULL,
2805 cli_cmd_flag_none,
2806 "= force reassociation back to the same BSS" },
b49039bd 2807 { "preauthenticate", wpa_cli_cmd_preauthenticate, wpa_cli_complete_bss,
dfa141b1
ER		 2808 cli_cmd_flag_none,
2809 "<BSSID> = force preauthentication" },
b49039bd 2810 { "identity", wpa_cli_cmd_identity, NULL,
dfa141b1
ER		 2811 cli_cmd_flag_none,
2812 "<network id> <identity> = configure identity for an SSID" },
b49039bd 2813 { "password", wpa_cli_cmd_password, NULL,
dfa141b1
ER		 2814 cli_cmd_flag_sensitive,
2815 "<network id> <password> = configure password for an SSID" },
b49039bd 2816 { "new_password", wpa_cli_cmd_new_password, NULL,
dfa141b1
ER		 2817 cli_cmd_flag_sensitive,
2818 "<network id> <password> = change password for an SSID" },
b49039bd 2819 { "pin", wpa_cli_cmd_pin, NULL,
dfa141b1
ER		 2820 cli_cmd_flag_sensitive,
2821 "<network id> <pin> = configure pin for an SSID" },
b49039bd 2822 { "otp", wpa_cli_cmd_otp, NULL,
dfa141b1
ER		 2823 cli_cmd_flag_sensitive,
2824 "<network id> <password> = configure one-time-password for an SSID"
2825 },
b49039bd 2826 { "passphrase", wpa_cli_cmd_passphrase, NULL,
dfa141b1
ER		 2827 cli_cmd_flag_sensitive,
2828 "<network id> <passphrase> = configure private key passphrase\n"
2829 " for an SSID" },
a5d44ac0
JM		 2830 { "sim", wpa_cli_cmd_sim, NULL,
2831 cli_cmd_flag_sensitive,
2832 "<network id> <pin> = report SIM operation result" },
b49039bd 2833 { "bssid", wpa_cli_cmd_bssid, NULL,
dfa141b1
ER		 2834 cli_cmd_flag_none,
2835 "<network id> <BSSID> = set preferred BSSID for an SSID" },
b49039bd 2836 { "blacklist", wpa_cli_cmd_blacklist, wpa_cli_complete_bss,
9aa10e2b
DS		 2837 cli_cmd_flag_none,
2838 "<BSSID> = add a BSSID to the blacklist\n"
2839 "blacklist clear = clear the blacklist\n"
2840 "blacklist = display the blacklist" },
b49039bd 2841 { "log_level", wpa_cli_cmd_log_level, NULL,
0597a5b5
DS		 2842 cli_cmd_flag_none,
2843 "<level> [<timestamp>] = update the log level/timestamp\n"
2844 "log_level = display the current log level and log options" },
b49039bd 2845 { "list_networks", wpa_cli_cmd_list_networks, NULL,
dfa141b1
ER		 2846 cli_cmd_flag_none,
2847 "= list configured networks" },
1ca6c0f1
MK		 2848 { "select_network", wpa_cli_cmd_select_network,
2849 wpa_cli_complete_network_id,
dfa141b1
ER		 2850 cli_cmd_flag_none,
2851 "<network id> = select a network (disable others)" },
1ca6c0f1
MK		 2852 { "enable_network", wpa_cli_cmd_enable_network,
2853 wpa_cli_complete_network_id,
dfa141b1
ER		 2854 cli_cmd_flag_none,
2855 "<network id> = enable a network" },
1ca6c0f1
MK		 2856 { "disable_network", wpa_cli_cmd_disable_network,
2857 wpa_cli_complete_network_id,
dfa141b1
ER		 2858 cli_cmd_flag_none,
2859 "<network id> = disable a network" },
b49039bd 2860 { "add_network", wpa_cli_cmd_add_network, NULL,
dfa141b1
ER		 2861 cli_cmd_flag_none,
2862 "= add a network" },
1ca6c0f1
MK		 2863 { "remove_network", wpa_cli_cmd_remove_network,
2864 wpa_cli_complete_network_id,
dfa141b1
ER		 2865 cli_cmd_flag_none,
2866 "<network id> = remove a network" },
7e6cc908 2867 { "set_network", wpa_cli_cmd_set_network, wpa_cli_complete_network,
dfa141b1
ER		 2868 cli_cmd_flag_sensitive,
2869 "<network id> <variable> <value> = set network variables (shows\n"
2870 " list of variables when run without arguments)" },
7e6cc908 2871 { "get_network", wpa_cli_cmd_get_network, wpa_cli_complete_network,
dfa141b1
ER		 2872 cli_cmd_flag_none,
2873 "<network id> <variable> = get network variables" },
5a997b2f 2874 { "dup_network", wpa_cli_cmd_dup_network, wpa_cli_complete_dup_network,
1c330a2f
DS		 2875 cli_cmd_flag_none,
2876 "<src network id> <dst network id> <variable> = duplicate network variables"
2877 },
b49039bd 2878 { "list_creds", wpa_cli_cmd_list_creds, NULL,
d94c9ee6
JM		 2879 cli_cmd_flag_none,
2880 "= list configured credentials" },
b49039bd 2881 { "add_cred", wpa_cli_cmd_add_cred, NULL,
d94c9ee6
JM		 2882 cli_cmd_flag_none,
2883 "= add a credential" },
b49039bd 2884 { "remove_cred", wpa_cli_cmd_remove_cred, NULL,
d94c9ee6
JM		 2885 cli_cmd_flag_none,
2886 "<cred id> = remove a credential" },
b49039bd 2887 { "set_cred", wpa_cli_cmd_set_cred, NULL,
d94c9ee6
JM		 2888 cli_cmd_flag_sensitive,
2889 "<cred id> <variable> <value> = set credential variables" },
c880ab87
JM		 2890 { "get_cred", wpa_cli_cmd_get_cred, NULL,
2891 cli_cmd_flag_none,
2892 "<cred id> <variable> = get credential variables" },
b49039bd 2893 { "save_config", wpa_cli_cmd_save_config, NULL,
dfa141b1
ER		 2894 cli_cmd_flag_none,
2895 "= save the current configuration" },
b49039bd 2896 { "disconnect", wpa_cli_cmd_disconnect, NULL,
dfa141b1
ER		 2897 cli_cmd_flag_none,
2898 "= disconnect and wait for reassociate/reconnect command before\n"
2899 " connecting" },
b49039bd 2900 { "reconnect", wpa_cli_cmd_reconnect, NULL,
dfa141b1
ER		 2901 cli_cmd_flag_none,
2902 "= like reassociate, but only takes effect if already disconnected"
2903 },
b49039bd 2904 { "scan", wpa_cli_cmd_scan, NULL,
dfa141b1
ER		 2905 cli_cmd_flag_none,
2906 "= request new BSS scan" },
b49039bd 2907 { "scan_results", wpa_cli_cmd_scan_results, NULL,
dfa141b1
ER		 2908 cli_cmd_flag_none,
2909 "= get latest scan results" },
2ea2166d
JM		 2910 { "abort_scan", wpa_cli_cmd_abort_scan, NULL,
2911 cli_cmd_flag_none,
2912 "= request ongoing scan to be aborted" },
b49039bd 2913 { "bss", wpa_cli_cmd_bss, wpa_cli_complete_bss,
dfa141b1
ER		 2914 cli_cmd_flag_none,
2915 "<<idx> | <bssid>> = get detailed scan result info" },
003fe581
MK		 2916 { "get_capability", wpa_cli_cmd_get_capability,
2917 wpa_cli_complete_get_capability, cli_cmd_flag_none,
06060522 2918 "<eap/pairwise/group/key_mgmt/proto/auth_alg/channels/freq/modes> "
4839f7c7 2919 "= get capabilities" },
b49039bd 2920 { "reconfigure", wpa_cli_cmd_reconfigure, NULL,
dfa141b1
ER		 2921 cli_cmd_flag_none,
2922 "= force wpa_supplicant to re-read its configuration file" },
b49039bd 2923 { "terminate", wpa_cli_cmd_terminate, NULL,
dfa141b1
ER		 2924 cli_cmd_flag_none,
2925 "= terminate wpa_supplicant" },
b49039bd 2926 { "interface_add", wpa_cli_cmd_interface_add, NULL,
dfa141b1
ER		 2927 cli_cmd_flag_none,
2928 "<ifname> <confname> <driver> <ctrl_interface> <driver_param>\n"
cadffacb
AS		 2929 " <bridge_name> <create> <type> = adds new interface, all "
2930 "parameters but\n"
2931 " <ifname> are optional. Supported types are station ('sta') and "
2932 "AP ('ap')" },
b49039bd 2933 { "interface_remove", wpa_cli_cmd_interface_remove, NULL,
dfa141b1
ER		 2934 cli_cmd_flag_none,
2935 "<ifname> = removes the interface" },
b49039bd 2936 { "interface_list", wpa_cli_cmd_interface_list, NULL,
dfa141b1
ER		 2937 cli_cmd_flag_none,
2938 "= list available interfaces" },
b49039bd 2939 { "ap_scan", wpa_cli_cmd_ap_scan, NULL,
dfa141b1
ER		 2940 cli_cmd_flag_none,
2941 "<value> = set ap_scan parameter" },
b49039bd 2942 { "scan_interval", wpa_cli_cmd_scan_interval, NULL,
67b9bd08
DS		 2943 cli_cmd_flag_none,
2944 "<value> = set scan_interval parameter (in seconds)" },
b49039bd 2945 { "bss_expire_age", wpa_cli_cmd_bss_expire_age, NULL,
78633c37
SL		 2946 cli_cmd_flag_none,
2947 "<value> = set BSS expiration age parameter" },
b49039bd 2948 { "bss_expire_count", wpa_cli_cmd_bss_expire_count, NULL,
78633c37
SL		 2949 cli_cmd_flag_none,
2950 "<value> = set BSS expiration scan count parameter" },
b49039bd 2951 { "bss_flush", wpa_cli_cmd_bss_flush, NULL,
39ee845f
DS		 2952 cli_cmd_flag_none,
2953 "<value> = set BSS flush age (0 by default)" },
b49039bd 2954 { "stkstart", wpa_cli_cmd_stkstart, NULL,
dfa141b1
ER		 2955 cli_cmd_flag_none,
2956 "<addr> = request STK negotiation with <addr>" },
b49039bd 2957 { "ft_ds", wpa_cli_cmd_ft_ds, wpa_cli_complete_bss,
dfa141b1
ER		 2958 cli_cmd_flag_none,
2959 "<addr> = request over-the-DS FT with <addr>" },
b49039bd 2960 { "wps_pbc", wpa_cli_cmd_wps_pbc, wpa_cli_complete_bss,
dfa141b1
ER		 2961 cli_cmd_flag_none,
2962 "[BSSID] = start Wi-Fi Protected Setup: Push Button Configuration" },
b49039bd 2963 { "wps_pin", wpa_cli_cmd_wps_pin, wpa_cli_complete_bss,
dfa141b1
ER		 2964 cli_cmd_flag_sensitive,
2965 "<BSSID> [PIN] = start WPS PIN method (returns PIN, if not "
2966 "hardcoded)" },
b49039bd 2967 { "wps_check_pin", wpa_cli_cmd_wps_check_pin, NULL,
3981cb3c
JM		 2968 cli_cmd_flag_sensitive,
2969 "<PIN> = verify PIN checksum" },
b49039bd 2970 { "wps_cancel", wpa_cli_cmd_wps_cancel, NULL, cli_cmd_flag_none,
2f9929ff 2971 "Cancels the pending WPS operation" },
71892384 2972#ifdef CONFIG_WPS_NFC
b49039bd 2973 { "wps_nfc", wpa_cli_cmd_wps_nfc, wpa_cli_complete_bss,
3f2c8ba6
JM		 2974 cli_cmd_flag_none,
2975 "[BSSID] = start Wi-Fi Protected Setup: NFC" },
bbf41865
JM		 2976 { "wps_nfc_config_token", wpa_cli_cmd_wps_nfc_config_token, NULL,
2977 cli_cmd_flag_none,
2978 "<WPS|NDEF> = build configuration token" },
b49039bd 2979 { "wps_nfc_token", wpa_cli_cmd_wps_nfc_token, NULL,
3f2c8ba6
JM		 2980 cli_cmd_flag_none,
2981 "<WPS|NDEF> = create password token" },
b49039bd 2982 { "wps_nfc_tag_read", wpa_cli_cmd_wps_nfc_tag_read, NULL,
d7645d23
JM		 2983 cli_cmd_flag_sensitive,
2984 "<hexdump of payload> = report read NFC tag with WPS data" },
e65552dd
JM		 2985 { "nfc_get_handover_req", wpa_cli_cmd_nfc_get_handover_req, NULL,
2986 cli_cmd_flag_none,
2987 "<NDEF> <WPS> = create NFC handover request" },
2988 { "nfc_get_handover_sel", wpa_cli_cmd_nfc_get_handover_sel, NULL,
2989 cli_cmd_flag_none,
2990 "<NDEF> <WPS> = create NFC handover select" },
e4758827
JM		 2991 { "nfc_report_handover", wpa_cli_cmd_nfc_report_handover, NULL,
2992 cli_cmd_flag_none,
2993 "<role> <type> <hexdump of req> <hexdump of sel> = report completed "
2994 "NFC handover" },
71892384 2995#endif /* CONFIG_WPS_NFC */
b49039bd 2996 { "wps_reg", wpa_cli_cmd_wps_reg, wpa_cli_complete_bss,
dfa141b1
ER		 2997 cli_cmd_flag_sensitive,
2998 "<BSSID> <AP PIN> = start WPS Registrar to configure an AP" },
b49039bd 2999 { "wps_ap_pin", wpa_cli_cmd_wps_ap_pin, NULL,
70d84f11
JM		 3000 cli_cmd_flag_sensitive,
3001 "[params..] = enable/disable AP PIN" },
b49039bd 3002 { "wps_er_start", wpa_cli_cmd_wps_er_start, NULL,
e9bcfebf 3003 cli_cmd_flag_none,
08486685 3004 "[IP address] = start Wi-Fi Protected Setup External Registrar" },
b49039bd 3005 { "wps_er_stop", wpa_cli_cmd_wps_er_stop, NULL,
e9bcfebf
JM		 3006 cli_cmd_flag_none,
3007 "= stop Wi-Fi Protected Setup External Registrar" },
b49039bd 3008 { "wps_er_pin", wpa_cli_cmd_wps_er_pin, NULL,
72df2f5f
JM		 3009 cli_cmd_flag_sensitive,
3010 "<UUID> <PIN> = add an Enrollee PIN to External Registrar" },
b49039bd 3011 { "wps_er_pbc", wpa_cli_cmd_wps_er_pbc, NULL,
564cd7fa
JM		 3012 cli_cmd_flag_none,
3013 "<UUID> = accept an Enrollee PBC using External Registrar" },
b49039bd 3014 { "wps_er_learn", wpa_cli_cmd_wps_er_learn, NULL,
e64dcfd5
JM		 3015 cli_cmd_flag_sensitive,
3016 "<UUID> <PIN> = learn AP configuration" },
b49039bd 3017 { "wps_er_set_config", wpa_cli_cmd_wps_er_set_config, NULL,
ef10f473
JM		 3018 cli_cmd_flag_none,
3019 "<UUID> <network id> = set AP configuration for enrolling" },
b49039bd 3020 { "wps_er_config", wpa_cli_cmd_wps_er_config, NULL,
7d6640a6
JM		 3021 cli_cmd_flag_sensitive,
3022 "<UUID> <PIN> <SSID> <auth> <encr> <key> = configure AP" },
1cea09a9 3023#ifdef CONFIG_WPS_NFC
b49039bd 3024 { "wps_er_nfc_config_token", wpa_cli_cmd_wps_er_nfc_config_token, NULL,
1cea09a9
JM		 3025 cli_cmd_flag_none,
3026 "<WPS/NDEF> <UUID> = build NFC configuration token" },
3027#endif /* CONFIG_WPS_NFC */
b49039bd 3028 { "ibss_rsn", wpa_cli_cmd_ibss_rsn, NULL,
11ef8d35
JM		 3029 cli_cmd_flag_none,
3030 "<addr> = request RSN authentication with <addr> in IBSS" },
e653b622 3031#ifdef CONFIG_AP
b49039bd 3032 { "sta", wpa_cli_cmd_sta, NULL,
e653b622
JM		 3033 cli_cmd_flag_none,
3034 "<addr> = get information about an associated station (AP)" },
b49039bd 3035 { "all_sta", wpa_cli_cmd_all_sta, NULL,
e653b622
JM		 3036 cli_cmd_flag_none,
3037 "= get information about all associated stations (AP)" },
b49039bd 3038 { "deauthenticate", wpa_cli_cmd_deauthenticate, NULL,
e60b2951
JJ		 3039 cli_cmd_flag_none,
3040 "<addr> = deauthenticate a station" },
b49039bd 3041 { "disassociate", wpa_cli_cmd_disassociate, NULL,
e60b2951
JJ		 3042 cli_cmd_flag_none,
3043 "<addr> = disassociate a station" },
334bf36a
AO		 3044 { "chan_switch", wpa_cli_cmd_chanswitch, NULL,
3045 cli_cmd_flag_none,
3046 "<cs_count> <freq> [sec_channel_offset=] [center_freq1=]"
3047 " [center_freq2=] [bandwidth=] [blocktx] [ht|vht]"
3048 " = CSA parameters" },
e653b622 3049#endif /* CONFIG_AP */
b49039bd 3050 { "suspend", wpa_cli_cmd_suspend, NULL, cli_cmd_flag_none,
207ef3fb 3051 "= notification of suspend/hibernate" },
b49039bd 3052 { "resume", wpa_cli_cmd_resume, NULL, cli_cmd_flag_none,
207ef3fb 3053 "= notification of resume/thaw" },
9ff4de6d 3054#ifdef CONFIG_TESTING_OPTIONS
b49039bd 3055 { "drop_sa", wpa_cli_cmd_drop_sa, NULL, cli_cmd_flag_none,
32d5295f 3056 "= drop SA without deauth/disassoc (test command)" },
9ff4de6d 3057#endif /* CONFIG_TESTING_OPTIONS */
b49039bd 3058 { "roam", wpa_cli_cmd_roam, wpa_cli_complete_bss,
86d4f806
JM		 3059 cli_cmd_flag_none,
3060 "<addr> = roam to the specified BSS" },
603a3f34 3061#ifdef CONFIG_MESH
5b78493f
MH		 3062 { "mesh_interface_add", wpa_cli_cmd_mesh_interface_add, NULL,
3063 cli_cmd_flag_none,
3064 "[ifname] = Create a new mesh interface" },
603a3f34
JL		 3065 { "mesh_group_add", wpa_cli_cmd_mesh_group_add, NULL,
3066 cli_cmd_flag_none,
3067 "<network id> = join a mesh network (disable others)" },
3068 { "mesh_group_remove", wpa_cli_cmd_mesh_group_remove, NULL,
3069 cli_cmd_flag_none,
3070 "<ifname> = Remove mesh group interface" },
e174ef34
MH		 3071 { "mesh_peer_remove", wpa_cli_cmd_mesh_peer_remove, NULL,
3072 cli_cmd_flag_none,
3073 "<addr> = Remove a mesh peer" },
2604edbf
MH		 3074 { "mesh_peer_add", wpa_cli_cmd_mesh_peer_add, NULL,
3075 cli_cmd_flag_none,
9f2cf23e 3076 "<addr> [duration=<seconds>] = Add a mesh peer" },
603a3f34 3077#endif /* CONFIG_MESH */
57faa1ce 3078#ifdef CONFIG_P2P
01335e2c
JM		 3079 { "p2p_find", wpa_cli_cmd_p2p_find, wpa_cli_complete_p2p_find,
3080 cli_cmd_flag_none,
57faa1ce 3081 "[timeout] [type=*] = find P2P Devices for up-to timeout seconds" },
b49039bd 3082 { "p2p_stop_find", wpa_cli_cmd_p2p_stop_find, NULL, cli_cmd_flag_none,
57faa1ce 3083 "= stop P2P Devices search" },
f309c18e
KV		 3084 { "p2p_asp_provision", wpa_cli_cmd_p2p_asp_provision, NULL,
3085 cli_cmd_flag_none,
3086 "<addr> adv_id=<adv_id> conncap=<conncap> [info=<infodata>] = provision with a P2P ASP Device" },
3087 { "p2p_asp_provision_resp", wpa_cli_cmd_p2p_asp_provision_resp, NULL,
3088 cli_cmd_flag_none,
3089 "<addr> adv_id=<adv_id> [role<conncap>] [info=<infodata>] = provision with a P2P ASP Device" },
b49039bd
JM		 3090 { "p2p_connect", wpa_cli_cmd_p2p_connect, wpa_cli_complete_p2p_connect,
3091 cli_cmd_flag_none,
e2308e4b 3092 "<addr> <\"pbc\"|PIN> [ht40] = connect to a P2P Device" },
b49039bd 3093 { "p2p_listen", wpa_cli_cmd_p2p_listen, NULL, cli_cmd_flag_none,
57faa1ce 3094 "[timeout] = listen for P2P Devices for up-to timeout seconds" },
b49039bd
JM		 3095 { "p2p_group_remove", wpa_cli_cmd_p2p_group_remove,
3096 wpa_cli_complete_p2p_group_remove, cli_cmd_flag_none,
4d2ea6a6 3097 "<ifname> = remove P2P group interface (terminate group if GO)" },
b49039bd 3098 { "p2p_group_add", wpa_cli_cmd_p2p_group_add, NULL, cli_cmd_flag_none,
7aeac985 3099 "[ht40] = add a new P2P group (local end as GO)" },
57b38882
PK		 3100 { "p2p_group_member", wpa_cli_cmd_p2p_group_member, NULL,
3101 cli_cmd_flag_none,
3102 "<dev_addr> = Get peer interface address on local GO using peer Device Address" },
b49039bd
JM		 3103 { "p2p_prov_disc", wpa_cli_cmd_p2p_prov_disc,
3104 wpa_cli_complete_p2p_peer, cli_cmd_flag_none,
57faa1ce 3105 "<addr> <method> = request provisioning discovery" },
b49039bd 3106 { "p2p_get_passphrase", wpa_cli_cmd_p2p_get_passphrase, NULL,
57faa1ce
JM		 3107 cli_cmd_flag_none,
3108 "= get the passphrase for a group (GO only)" },
3109 { "p2p_serv_disc_req", wpa_cli_cmd_p2p_serv_disc_req,
b49039bd 3110 wpa_cli_complete_p2p_peer, cli_cmd_flag_none,
57faa1ce
JM		 3111 "<addr> <TLVs> = schedule service discovery request" },
3112 { "p2p_serv_disc_cancel_req", wpa_cli_cmd_p2p_serv_disc_cancel_req,
b49039bd 3113 NULL, cli_cmd_flag_none,
57faa1ce 3114 "<id> = cancel pending service discovery request" },
b49039bd 3115 { "p2p_serv_disc_resp", wpa_cli_cmd_p2p_serv_disc_resp, NULL,
57faa1ce
JM		 3116 cli_cmd_flag_none,
3117 "<freq> <addr> <dialog token> <TLVs> = service discovery response" },
b49039bd 3118 { "p2p_service_update", wpa_cli_cmd_p2p_service_update, NULL,
57faa1ce
JM		 3119 cli_cmd_flag_none,
3120 "= indicate change in local services" },
b49039bd 3121 { "p2p_serv_disc_external", wpa_cli_cmd_p2p_serv_disc_external, NULL,
57faa1ce
JM		 3122 cli_cmd_flag_none,
3123 "<external> = set external processing of service discovery" },
b49039bd 3124 { "p2p_service_flush", wpa_cli_cmd_p2p_service_flush, NULL,
57faa1ce
JM		 3125 cli_cmd_flag_none,
3126 "= remove all stored service entries" },
b49039bd 3127 { "p2p_service_add", wpa_cli_cmd_p2p_service_add, NULL,
57faa1ce 3128 cli_cmd_flag_none,
ae9d45f3 3129 "<bonjour|upnp|asp> <query|version> <response|service> = add a local "
57faa1ce 3130 "service" },
ae9d45f3
KV		 3131 { "p2p_service_rep", wpa_cli_cmd_p2p_service_rep, NULL,
3132 cli_cmd_flag_none,
3133 "asp <auto> <adv_id> <svc_state> <svc_string> [<svc_info>] = replace "
3134 "local ASP service" },
b49039bd 3135 { "p2p_service_del", wpa_cli_cmd_p2p_service_del, NULL,
57faa1ce
JM		 3136 cli_cmd_flag_none,
3137 "<bonjour|upnp> <query|version> [|service] = remove a local "
3138 "service" },
b49039bd 3139 { "p2p_reject", wpa_cli_cmd_p2p_reject, wpa_cli_complete_p2p_peer,
57faa1ce
JM		 3140 cli_cmd_flag_none,
3141 "<addr> = reject connection attempts from a specific peer" },
b49039bd 3142 { "p2p_invite", wpa_cli_cmd_p2p_invite, NULL,
57faa1ce
JM		 3143 cli_cmd_flag_none,
3144 "<cmd> [peer=addr] = invite peer" },
b49039bd 3145 { "p2p_peers", wpa_cli_cmd_p2p_peers, NULL, cli_cmd_flag_none,
57faa1ce
JM		 3146 "[discovered] = list known (optionally, only fully discovered) P2P "
3147 "peers" },
b49039bd
JM		 3148 { "p2p_peer", wpa_cli_cmd_p2p_peer, wpa_cli_complete_p2p_peer,
3149 cli_cmd_flag_none,
57faa1ce 3150 "<address> = show information about known P2P peer" },
698e921b
JM		 3151 { "p2p_set", wpa_cli_cmd_p2p_set, wpa_cli_complete_p2p_set,
3152 cli_cmd_flag_none,
57faa1ce 3153 "<field> <value> = set a P2P parameter" },
b49039bd 3154 { "p2p_flush", wpa_cli_cmd_p2p_flush, NULL, cli_cmd_flag_none,
57faa1ce 3155 "= flush P2P state" },
b49039bd 3156 { "p2p_cancel", wpa_cli_cmd_p2p_cancel, NULL, cli_cmd_flag_none,
59eba7a2 3157 "= cancel P2P group formation" },
b49039bd
JM		 3158 { "p2p_unauthorize", wpa_cli_cmd_p2p_unauthorize,
3159 wpa_cli_complete_p2p_peer, cli_cmd_flag_none,
9d562b79 3160 "<address> = unauthorize a peer" },
b49039bd
JM		 3161 { "p2p_presence_req", wpa_cli_cmd_p2p_presence_req, NULL,
3162 cli_cmd_flag_none,
57faa1ce
JM		 3163 "[<duration> <interval>] [<duration> <interval>] = request GO "
3164 "presence" },
b49039bd
JM		 3165 { "p2p_ext_listen", wpa_cli_cmd_p2p_ext_listen, NULL,
3166 cli_cmd_flag_none,
57faa1ce 3167 "[<period> <interval>] = set extended listen timing" },
f2c56602
JM		 3168 { "p2p_remove_client", wpa_cli_cmd_p2p_remove_client,
3169 wpa_cli_complete_p2p_peer, cli_cmd_flag_none,
3170 "<address|iface=address> = remove a peer from all groups" },
cdcb2d0e
PK		 3171 { "vendor_elem_add", wpa_cli_cmd_vendor_elem_add, NULL,
3172 cli_cmd_flag_none,
3173 "<frame id> <hexdump of elem(s)> = add vendor specific IEs to frame(s)\n"
3174 VENDOR_ELEM_FRAME_ID },
3175 { "vendor_elem_get", wpa_cli_cmd_vendor_elem_get, NULL,
3176 cli_cmd_flag_none,
3177 "<frame id> = get vendor specific IE(s) to frame(s)\n"
3178 VENDOR_ELEM_FRAME_ID },
3179 { "vendor_elem_remove", wpa_cli_cmd_vendor_elem_remove, NULL,
3180 cli_cmd_flag_none,
3181 "<frame id> <hexdump of elem(s)> = remove vendor specific IE(s) in frame(s)\n"
3182 VENDOR_ELEM_FRAME_ID },
57faa1ce 3183#endif /* CONFIG_P2P */
9675ce35
JM		 3184#ifdef CONFIG_WIFI_DISPLAY
3185 { "wfd_subelem_set", wpa_cli_cmd_wfd_subelem_set, NULL,
3186 cli_cmd_flag_none,
3187 "<subelem> [contents] = set Wi-Fi Display subelement" },
3188 { "wfd_subelem_get", wpa_cli_cmd_wfd_subelem_get, NULL,
3189 cli_cmd_flag_none,
3190 "<subelem> = get Wi-Fi Display subelement" },
3191#endif /* CONFIG_WIFI_DISPLAY */
afc064fe 3192#ifdef CONFIG_INTERWORKING
b49039bd 3193 { "fetch_anqp", wpa_cli_cmd_fetch_anqp, NULL, cli_cmd_flag_none,
afc064fe 3194 "= fetch ANQP information for all APs" },
b49039bd
JM		 3195 { "stop_fetch_anqp", wpa_cli_cmd_stop_fetch_anqp, NULL,
3196 cli_cmd_flag_none,
afc064fe 3197 "= stop fetch_anqp operation" },
b49039bd 3198 { "interworking_select", wpa_cli_cmd_interworking_select, NULL,
b02fe7ff
JM		 3199 cli_cmd_flag_none,
3200 "[auto] = perform Interworking network selection" },
3201 { "interworking_connect", wpa_cli_cmd_interworking_connect,
b49039bd 3202 wpa_cli_complete_bss, cli_cmd_flag_none,
b02fe7ff 3203 "<BSSID> = connect using Interworking credentials" },
f91a512f
JM		 3204 { "interworking_add_network", wpa_cli_cmd_interworking_add_network,
3205 wpa_cli_complete_bss, cli_cmd_flag_none,
3206 "<BSSID> = connect using Interworking credentials" },
b49039bd
JM		 3207 { "anqp_get", wpa_cli_cmd_anqp_get, wpa_cli_complete_bss,
3208 cli_cmd_flag_none,
afc064fe 3209 "<addr> <info id>[,<info id>]... = request ANQP information" },
b1f12296
JM		 3210 { "gas_request", wpa_cli_cmd_gas_request, wpa_cli_complete_bss,
3211 cli_cmd_flag_none,
3212 "<addr> <AdvProtoID> [QueryReq] = GAS request" },
3213 { "gas_response_get", wpa_cli_cmd_gas_response_get,
3214 wpa_cli_complete_bss, cli_cmd_flag_none,
3215 "<addr> <dialog token> [start,len] = Fetch last GAS response" },
afc064fe 3216#endif /* CONFIG_INTERWORKING */
a8918e86 3217#ifdef CONFIG_HS20
b49039bd
JM		 3218 { "hs20_anqp_get", wpa_cli_cmd_hs20_anqp_get, wpa_cli_complete_bss,
3219 cli_cmd_flag_none,
a8918e86
JK		 3220 "<addr> <subtype>[,<subtype>]... = request HS 2.0 ANQP information"
3221 },
3222 { "nai_home_realm_list", wpa_cli_cmd_get_nai_home_realm_list,
b49039bd 3223 wpa_cli_complete_bss, cli_cmd_flag_none,
a8918e86 3224 "<addr> <home realm> = get HS20 nai home realm list" },
184e110c
JM		 3225 { "hs20_icon_request", wpa_cli_cmd_hs20_icon_request,
3226 wpa_cli_complete_bss, cli_cmd_flag_none,
3227 "<addr> <icon name> = get Hotspot 2.0 OSU icon" },
b572df86
JM		 3228 { "fetch_osu", wpa_cli_cmd_fetch_osu, NULL, cli_cmd_flag_none,
3229 "= fetch OSU provider information from all APs" },
3230 { "cancel_fetch_osu", wpa_cli_cmd_cancel_fetch_osu, NULL,
3231 cli_cmd_flag_none,
3232 "= cancel fetch_osu command" },
a8918e86 3233#endif /* CONFIG_HS20 */
b49039bd
JM		 3234 { "sta_autoconnect", wpa_cli_cmd_sta_autoconnect, NULL,
3235 cli_cmd_flag_none,
0d0a8ca1 3236 "<0/1> = disable/enable automatic reconnection" },
b49039bd 3237 { "tdls_discover", wpa_cli_cmd_tdls_discover, NULL,
281ff0aa
GP		 3238 cli_cmd_flag_none,
3239 "<addr> = request TDLS discovery with <addr>" },
b49039bd 3240 { "tdls_setup", wpa_cli_cmd_tdls_setup, NULL,
281ff0aa
GP		 3241 cli_cmd_flag_none,
3242 "<addr> = request TDLS setup with <addr>" },
b49039bd 3243 { "tdls_teardown", wpa_cli_cmd_tdls_teardown, NULL,
281ff0aa
GP		 3244 cli_cmd_flag_none,
3245 "<addr> = tear down TDLS with <addr>" },
4504621f
OG		 3246 { "tdls_link_status", wpa_cli_cmd_tdls_link_status, NULL,
3247 cli_cmd_flag_none,
3248 "<addr> = TDLS link status with <addr>" },
df9d340c
MB		 3249 { "wmm_ac_addts", wpa_cli_cmd_wmm_ac_addts, NULL,
3250 cli_cmd_flag_none,
3251 "<uplink/downlink/bidi> <tsid=0..7> <up=0..7> [nominal_msdu_size=#] "
3252 "[mean_data_rate=#] [min_phy_rate=#] [sba=#] [fixed_nominal_msdu] "
3253 "= add WMM-AC traffic stream" },
3254 { "wmm_ac_delts", wpa_cli_cmd_wmm_ac_delts, NULL,
3255 cli_cmd_flag_none,
3256 "<tsid> = delete WMM-AC traffic stream" },
8506ea6f
MB		 3257 { "wmm_ac_status", wpa_cli_cmd_wmm_ac_status, NULL,
3258 cli_cmd_flag_none,
3259 "= show status for Wireless Multi-Media Admission-Control" },
7db53bb8
AN		 3260 { "tdls_chan_switch", wpa_cli_cmd_tdls_chan_switch, NULL,
3261 cli_cmd_flag_none,
3262 "<addr> <oper class> <freq> [sec_channel_offset=] [center_freq1=] "
3263 "[center_freq2=] [bandwidth=] [ht|vht] = enable channel switching "
3264 "with TDLS peer" },
3265 { "tdls_cancel_chan_switch", wpa_cli_cmd_tdls_cancel_chan_switch, NULL,
3266 cli_cmd_flag_none,
3267 "<addr> = disable channel switching with TDLS peer <addr>" },
b49039bd 3268 { "signal_poll", wpa_cli_cmd_signal_poll, NULL,
60b24b0d
DS		 3269 cli_cmd_flag_none,
3270 "= get signal parameters" },
96e8d831
DS		 3271 { "signal_monitor", wpa_cli_cmd_signal_monitor, NULL,
3272 cli_cmd_flag_none,
3273 "= set signal monitor parameters" },
dc7785f8
YZ		 3274 { "pktcnt_poll", wpa_cli_cmd_pktcnt_poll, NULL,
3275 cli_cmd_flag_none,
3276 "= get TX/RX packet counters" },
b49039bd
JM		 3277 { "reauthenticate", wpa_cli_cmd_reauthenticate, NULL,
3278 cli_cmd_flag_none,
9482426e 3279 "= trigger IEEE 802.1X/EAPOL reauthentication" },
2bdd8342 3280#ifdef CONFIG_AUTOSCAN
b49039bd 3281 { "autoscan", wpa_cli_cmd_autoscan, NULL, cli_cmd_flag_none,
2bdd8342
TB		 3282 "[params] = Set or unset (if none) autoscan parameters" },
3283#endif /* CONFIG_AUTOSCAN */
e9199e31
JM		 3284#ifdef CONFIG_WNM
3285 { "wnm_sleep", wpa_cli_cmd_wnm_sleep, NULL, cli_cmd_flag_none,
3286 "<enter/exit> [interval=#] = enter/exit WNM-Sleep mode" },
65bcd0a9 3287 { "wnm_bss_query", wpa_cli_cmd_wnm_bss_query, NULL, cli_cmd_flag_none,
9a493fab 3288 "<query reason> [list] = Send BSS Transition Management Query" },
e9199e31 3289#endif /* CONFIG_WNM */
b49039bd 3290 { "raw", wpa_cli_cmd_raw, NULL, cli_cmd_flag_sensitive,
27b80b5b 3291 "<params..> = Sent unprocessed command" },
acb54643
JM		 3292 { "flush", wpa_cli_cmd_flush, NULL, cli_cmd_flag_none,
3293 "= flush wpa_supplicant state" },
5e2c3490
JM		 3294#ifdef ANDROID
3295 { "driver", wpa_cli_cmd_driver, NULL, cli_cmd_flag_none,
3296 "<command> = driver private commands" },
3297#endif /* ANDROID */
1f965e62
JM		 3298 { "radio_work", wpa_cli_cmd_radio_work, NULL, cli_cmd_flag_none,
3299 "= radio_work <show/add/done>" },
adef8948
BL		 3300 { "vendor", wpa_cli_cmd_vendor, NULL, cli_cmd_flag_none,
3301 "<vendor id> <command id> [<hex formatted command argument>] = Send vendor command"
3302 },
66d21434
AK		 3303 { "neighbor_rep_request",
3304 wpa_cli_cmd_neighbor_rep_request, NULL, cli_cmd_flag_none,
d41a5352 3305 "[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)"
66d21434 3306 },
65d9a5e2
JM		 3307 { "erp_flush", wpa_cli_cmd_erp_flush, NULL, cli_cmd_flag_none,
3308 "= flush ERP keys" },
8b48e320
IP		 3309 { "mac_rand_scan",
3310 wpa_cli_cmd_mac_rand_scan, NULL, cli_cmd_flag_none,
3311 "<scan|sched|pno|all> enable=<0/1> [addr=mac-address "
3312 "mask=mac-address-mask] = scan MAC randomization"
3313 },
98342208
AK		 3314 { "get_pref_freq_list", wpa_cli_cmd_get_pref_freq_list, NULL,
3315 cli_cmd_flag_none,
3316 "<interface type> = retrieve preferred freq list for the specified interface type" },
a6f5b193
PX		 3317 { "p2p_lo_start", wpa_cli_cmd_p2p_lo_start, NULL,
3318 cli_cmd_flag_none,
3319 "<freq> <period> <interval> <count> = start P2P listen offload" },
3320 { "p2p_lo_stop", wpa_cli_cmd_p2p_lo_stop, NULL,
3321 cli_cmd_flag_none,
3322 "= stop P2P listen offload" },
b49039bd 3323 { NULL, NULL, NULL, cli_cmd_flag_none, NULL }
6fc6879b
JM		 3324};
3325
3326
dfa141b1
ER		 3327/*
3328 * Prints command usage, lines are padded with the specified string.
3329 */
8b423edb 3330static void print_cmd_help(const struct wpa_cli_cmd *cmd, const char *pad)
dfa141b1
ER		 3331{
3332 char c;
3333 size_t n;
3334
3335 printf("%s%s ", pad, cmd->cmd);
3336 for (n = 0; (c = cmd->usage[n]); n++) {
3337 printf("%c", c);
3338 if (c == '\n')
3339 printf("%s", pad);
3340 }
3341 printf("\n");
3342}
3343
3344
2af4d404 3345static void print_help(const char *cmd)
dfa141b1
ER		 3346{
3347 int n;
3348 printf("commands:\n");
2af4d404
JM		 3349 for (n = 0; wpa_cli_commands[n].cmd; n++) {
3350 if (cmd == NULL || str_starts(wpa_cli_commands[n].cmd, cmd))
3351 print_cmd_help(&wpa_cli_commands[n], " ");
3352 }
dfa141b1
ER		 3353}
3354
3355
e8ecb5fb 3356static int wpa_cli_edit_filter_history_cb(void *ctx, const char *cmd)
40fd868c
ER		 3357{
3358 const char *c, *delim;
3359 int n;
3360 size_t len;
3361
3362 delim = os_strchr(cmd, ' ');
3363 if (delim)
3364 len = delim - cmd;
3365 else
3366 len = os_strlen(cmd);
3367
3368 for (n = 0; (c = wpa_cli_commands[n].cmd); n++) {
3369 if (os_strncasecmp(cmd, c, len) == 0 && len == os_strlen(c))
3370 return (wpa_cli_commands[n].flags &
3371 cli_cmd_flag_sensitive);
3372 }
3373 return 0;
3374}
e8ecb5fb
JM		 3375
3376
3377static char ** wpa_list_cmd_list(void)
3378{
3379 char **res;
3380 int i, count;
37620493 3381 struct cli_txt_entry *e;
e8ecb5fb 3382
e7ecab4a 3383 count = ARRAY_SIZE(wpa_cli_commands);
37620493
JM		 3384 count += dl_list_len(&p2p_groups);
3385 count += dl_list_len(&ifnames);
3386 res = os_calloc(count + 1, sizeof(char *));
e8ecb5fb
JM		 3387 if (res == NULL)
3388 return NULL;
3389
3390 for (i = 0; wpa_cli_commands[i].cmd; i++) {
3391 res[i] = os_strdup(wpa_cli_commands[i].cmd);
3392 if (res[i] == NULL)
3393 break;
3394 }
3395
37620493
JM		 3396 dl_list_for_each(e, &p2p_groups, struct cli_txt_entry, list) {
3397 size_t len = 8 + os_strlen(e->txt);
3398 res[i] = os_malloc(len);
3399 if (res[i] == NULL)
3400 break;
3401 os_snprintf(res[i], len, "ifname=%s", e->txt);
3402 i++;
3403 }
3404
3405 dl_list_for_each(e, &ifnames, struct cli_txt_entry, list) {
3406 res[i] = os_strdup(e->txt);
3407 if (res[i] == NULL)
3408 break;
3409 i++;
3410 }
3411
e8ecb5fb
JM		 3412 return res;
3413}
3414
3415
3416static char ** wpa_cli_cmd_completion(const char *cmd, const char *str,
3417 int pos)
3418{
3419 int i;
3420
3421 for (i = 0; wpa_cli_commands[i].cmd; i++) {
3422 if (os_strcasecmp(wpa_cli_commands[i].cmd, cmd) == 0) {
e4f6873c
JM		 3423 if (wpa_cli_commands[i].completion)
3424 return wpa_cli_commands[i].completion(str,
3425 pos);
e8ecb5fb
JM		 3426 edit_clear_line();
3427 printf("\r%s\n", wpa_cli_commands[i].usage);
3428 edit_redraw();
3429 break;
3430 }
3431 }
3432
3433 return NULL;
3434}
3435
3436
3437static char ** wpa_cli_edit_completion_cb(void *ctx, const char *str, int pos)
3438{
3439 char **res;
3440 const char *end;
3441 char *cmd;
3442
37620493
JM		 3443 if (pos > 7 && os_strncasecmp(str, "IFNAME=", 7) == 0) {
3444 end = os_strchr(str, ' ');
3445 if (end && pos > end - str) {
3446 pos -= end - str + 1;
3447 str = end + 1;
3448 }
3449 }
3450
e8ecb5fb
JM		 3451 end = os_strchr(str, ' ');
3452 if (end == NULL || str + pos < end)
3453 return wpa_list_cmd_list();
3454
3455 cmd = os_malloc(pos + 1);
3456 if (cmd == NULL)
3457 return NULL;
3458 os_memcpy(cmd, str, pos);
3459 cmd[end - str] = '\0';
3460 res = wpa_cli_cmd_completion(cmd, str, pos);
3461 os_free(cmd);
3462 return res;
3463}
40fd868c
ER		 3464
3465
6fc6879b
JM		 3466static int wpa_request(struct wpa_ctrl *ctrl, int argc, char *argv[])
3467{
8b423edb 3468 const struct wpa_cli_cmd *cmd, *match = NULL;
6fc6879b
JM		 3469 int count;
3470 int ret = 0;
3471
13b11ba7
JM		 3472 if (argc > 1 && os_strncasecmp(argv[0], "IFNAME=", 7) == 0) {
3473 ifname_prefix = argv[0] + 7;
3474 argv = &argv[1];
3475 argc--;
3476 } else
3477 ifname_prefix = NULL;
3478
3479 if (argc == 0)
3480 return -1;
3481
6fc6879b
JM		 3482 count = 0;
3483 cmd = wpa_cli_commands;
3484 while (cmd->cmd) {
3485 if (os_strncasecmp(cmd->cmd, argv[0], os_strlen(argv[0])) == 0)
3486 {
3487 match = cmd;
3488 if (os_strcasecmp(cmd->cmd, argv[0]) == 0) {
3489 /* we have an exact match */
3490 count = 1;
3491 break;
3492 }
3493 count++;
3494 }
3495 cmd++;
3496 }
3497
3498 if (count > 1) {
3499 printf("Ambiguous command '%s'; possible commands:", argv[0]);
3500 cmd = wpa_cli_commands;
3501 while (cmd->cmd) {
3502 if (os_strncasecmp(cmd->cmd, argv[0],
3503 os_strlen(argv[0])) == 0) {
3504 printf(" %s", cmd->cmd);
3505 }
3506 cmd++;
3507 }
3508 printf("\n");
3509 ret = 1;
3510 } else if (count == 0) {
3511 printf("Unknown command '%s'\n", argv[0]);
3512 ret = 1;
3513 } else {
3514 ret = match->handler(ctrl, argc - 1, &argv[1]);
3515 }
3516
3517 return ret;
3518}
3519
3520
6fc6879b
JM		 3521static int wpa_cli_exec(const char *program, const char *arg1,
3522 const char *arg2)
3523{
c5f258de 3524 char *arg;
6fc6879b
JM		 3525 size_t len;
3526 int res;
3527
3c58df7a
IP		 3528 /* If no interface is specified, set the global */
3529 if (!arg1)
3530 arg1 = "global";
3531
c5f258de
JM		 3532 len = os_strlen(arg1) + os_strlen(arg2) + 2;
3533 arg = os_malloc(len);
3534 if (arg == NULL)
6fc6879b 3535 return -1;
c5f258de
JM		 3536 os_snprintf(arg, len, "%s %s", arg1, arg2);
3537 res = os_exec(program, arg, 1);
3538 os_free(arg);
6fc6879b 3539
c5f258de 3540 return res;
6fc6879b
JM		 3541}
3542
3543
3544static void wpa_cli_action_process(const char *msg)
3545{
3546 const char *pos;
3547 char *copy = NULL, *id, *pos2;
55c2bfa9
JM		 3548 const char *ifname = ctrl_ifname;
3549 char ifname_buf[100];
6fc6879b 3550
b525cbab
JM		 3551 if (eloop_terminated())
3552 return;
3553
6fc6879b 3554 pos = msg;
55c2bfa9
JM		 3555 if (os_strncmp(pos, "IFNAME=", 7) == 0) {
3556 const char *end;
3557 end = os_strchr(pos + 7, ' ');
3558 if (end && (unsigned int) (end - pos) < sizeof(ifname_buf)) {
3559 pos += 7;
3560 os_memcpy(ifname_buf, pos, end - pos);
3561 ifname_buf[end - pos] = '\0';
3562 ifname = ifname_buf;
3563 pos = end + 1;
3564 }
3565 }
6fc6879b 3566 if (*pos == '<') {
55c2bfa9 3567 const char *prev = pos;
6fc6879b
JM		 3568 /* skip priority */
3569 pos = os_strchr(pos, '>');
3570 if (pos)
3571 pos++;
3572 else
55c2bfa9 3573 pos = prev;
6fc6879b
JM		 3574 }
3575
a6d56a39 3576 if (str_starts(pos, WPA_EVENT_CONNECTED)) {
6fc6879b
JM		 3577 int new_id = -1;
3578 os_unsetenv("WPA_ID");
3579 os_unsetenv("WPA_ID_STR");
3580 os_unsetenv("WPA_CTRL_DIR");
3581
3582 pos = os_strstr(pos, "[id=");
3583 if (pos)
3584 copy = os_strdup(pos + 4);
3585
3586 if (copy) {
3587 pos2 = id = copy;
3588 while (*pos2 && *pos2 != ' ')
3589 pos2++;
3590 *pos2++ = '\0';
3591 new_id = atoi(id);
3592 os_setenv("WPA_ID", id, 1);
3593 while (*pos2 && *pos2 != '=')
3594 pos2++;
3595 if (*pos2 == '=')
3596 pos2++;
3597 id = pos2;
3598 while (*pos2 && *pos2 != ']')
3599 pos2++;
3600 *pos2 = '\0';
3601 os_setenv("WPA_ID_STR", id, 1);
3602 os_free(copy);
3603 }
3604
3605 os_setenv("WPA_CTRL_DIR", ctrl_iface_dir, 1);
3606
02a3e5c0 3607 if (wpa_cli_connected <= 0 || new_id != wpa_cli_last_id) {
6fc6879b
JM		 3608 wpa_cli_connected = 1;
3609 wpa_cli_last_id = new_id;
55c2bfa9 3610 wpa_cli_exec(action_file, ifname, "CONNECTED");
6fc6879b 3611 }
a6d56a39 3612 } else if (str_starts(pos, WPA_EVENT_DISCONNECTED)) {
6fc6879b
JM		 3613 if (wpa_cli_connected) {
3614 wpa_cli_connected = 0;
55c2bfa9 3615 wpa_cli_exec(action_file, ifname, "DISCONNECTED");
6fc6879b 3616 }
a6d56a39 3617 } else if (str_starts(pos, AP_EVENT_ENABLED)) {
8960afa4 3618 wpa_cli_exec(action_file, ctrl_ifname, pos);
a6d56a39 3619 } else if (str_starts(pos, AP_EVENT_DISABLED)) {
8960afa4 3620 wpa_cli_exec(action_file, ctrl_ifname, pos);
a6d56a39 3621 } else if (str_starts(pos, MESH_GROUP_STARTED)) {
44a1662a 3622 wpa_cli_exec(action_file, ctrl_ifname, pos);
a6d56a39 3623 } else if (str_starts(pos, MESH_GROUP_REMOVED)) {
44a1662a 3624 wpa_cli_exec(action_file, ctrl_ifname, pos);
a6d56a39 3625 } else if (str_starts(pos, MESH_PEER_CONNECTED)) {
44a1662a 3626 wpa_cli_exec(action_file, ctrl_ifname, pos);
a6d56a39 3627 } else if (str_starts(pos, MESH_PEER_DISCONNECTED)) {
44a1662a 3628 wpa_cli_exec(action_file, ctrl_ifname, pos);
a6d56a39 3629 } else if (str_starts(pos, P2P_EVENT_GROUP_STARTED)) {
55c2bfa9 3630 wpa_cli_exec(action_file, ifname, pos);
a6d56a39 3631 } else if (str_starts(pos, P2P_EVENT_GROUP_REMOVED)) {
55c2bfa9 3632 wpa_cli_exec(action_file, ifname, pos);
a6d56a39 3633 } else if (str_starts(pos, P2P_EVENT_CROSS_CONNECT_ENABLE)) {
55c2bfa9 3634 wpa_cli_exec(action_file, ifname, pos);
a6d56a39 3635 } else if (str_starts(pos, P2P_EVENT_CROSS_CONNECT_DISABLE)) {
55c2bfa9 3636 wpa_cli_exec(action_file, ifname, pos);
a6d56a39 3637 } else if (str_starts(pos, P2P_EVENT_GO_NEG_FAILURE)) {
55c2bfa9 3638 wpa_cli_exec(action_file, ifname, pos);
a6d56a39 3639 } else if (str_starts(pos, WPS_EVENT_SUCCESS)) {
55c2bfa9 3640 wpa_cli_exec(action_file, ifname, pos);
a6d56a39 3641 } else if (str_starts(pos, WPS_EVENT_FAIL)) {
55c2bfa9 3642 wpa_cli_exec(action_file, ifname, pos);
a6d56a39 3643 } else if (str_starts(pos, AP_STA_CONNECTED)) {
55c2bfa9 3644 wpa_cli_exec(action_file, ifname, pos);
a6d56a39 3645 } else if (str_starts(pos, AP_STA_DISCONNECTED)) {
55c2bfa9 3646 wpa_cli_exec(action_file, ifname, pos);
a6d56a39 3647 } else if (str_starts(pos, ESS_DISASSOC_IMMINENT)) {
55c2bfa9 3648 wpa_cli_exec(action_file, ifname, pos);
a6d56a39 3649 } else if (str_starts(pos, HS20_SUBSCRIPTION_REMEDIATION)) {
55c2bfa9 3650 wpa_cli_exec(action_file, ifname, pos);
a6d56a39 3651 } else if (str_starts(pos, HS20_DEAUTH_IMMINENT_NOTICE)) {
55c2bfa9 3652 wpa_cli_exec(action_file, ifname, pos);
a6d56a39 3653 } else if (str_starts(pos, WPA_EVENT_TERMINATING)) {
6fc6879b
JM		 3654 printf("wpa_supplicant is terminating - stop monitoring\n");
3655 wpa_cli_quit = 1;
3656 }
3657}
3658
3659
3660#ifndef CONFIG_ANSI_C_EXTRA
3661static void wpa_cli_action_cb(char *msg, size_t len)
3662{
3663 wpa_cli_action_process(msg);
3664}
3665#endif /* CONFIG_ANSI_C_EXTRA */
3666
3667
3668static void wpa_cli_reconnect(void)
3669{
3670 wpa_cli_close_connection();
059d3a90
JM		 3671 if (wpa_cli_open_connection(ctrl_ifname, 1) < 0)
3672 return;
3673
3674 if (interactive) {
3675 edit_clear_line();
3676 printf("\rConnection to wpa_supplicant re-established\n");
3677 edit_redraw();
3678 }
6fc6879b
JM		 3679}
3680
3681
a624f20b
JM		 3682static void cli_event(const char *str)
3683{
3684 const char *start, *s;
3685
3686 start = os_strchr(str, '>');
3687 if (start == NULL)
3688 return;
3689
3690 start++;
3691
3692 if (str_starts(start, WPA_EVENT_BSS_ADDED)) {
3693 s = os_strchr(start, ' ');
3694 if (s == NULL)
3695 return;
3696 s = os_strchr(s + 1, ' ');
3697 if (s == NULL)
3698 return;
3699 cli_txt_list_add(&bsses, s + 1);
3700 return;
3701 }
3702
3703 if (str_starts(start, WPA_EVENT_BSS_REMOVED)) {
3704 s = os_strchr(start, ' ');
3705 if (s == NULL)
3706 return;
3707 s = os_strchr(s + 1, ' ');
3708 if (s == NULL)
3709 return;
3710 cli_txt_list_del_addr(&bsses, s + 1);
3711 return;
3712 }
3713
3714#ifdef CONFIG_P2P
3715 if (str_starts(start, P2P_EVENT_DEVICE_FOUND)) {
3716 s = os_strstr(start, " p2p_dev_addr=");
3717 if (s == NULL)
3718 return;
3719 cli_txt_list_add_addr(&p2p_peers, s + 14);
3720 return;
3721 }
3722
3723 if (str_starts(start, P2P_EVENT_DEVICE_LOST)) {
3724 s = os_strstr(start, " p2p_dev_addr=");
3725 if (s == NULL)
3726 return;
3727 cli_txt_list_del_addr(&p2p_peers, s + 14);
3728 return;
3729 }
76788542
JM		 3730
3731 if (str_starts(start, P2P_EVENT_GROUP_STARTED)) {
3732 s = os_strchr(start, ' ');
3733 if (s == NULL)
3734 return;
9ccc10f5 3735 cli_txt_list_add_word(&p2p_groups, s + 1, ' ');
76788542
JM		 3736 return;
3737 }
3738
3739 if (str_starts(start, P2P_EVENT_GROUP_REMOVED)) {
3740 s = os_strchr(start, ' ');
3741 if (s == NULL)
3742 return;
9ccc10f5 3743 cli_txt_list_del_word(&p2p_groups, s + 1, ' ');
76788542
JM		 3744 return;
3745 }
a624f20b
JM		 3746#endif /* CONFIG_P2P */
3747}
3748
3749
059d3a90
JM		 3750static int check_terminating(const char *msg)
3751{
3752 const char *pos = msg;
3753
3754 if (*pos == '<') {
3755 /* skip priority */
3756 pos = os_strchr(pos, '>');
3757 if (pos)
3758 pos++;
3759 else
3760 pos = msg;
3761 }
3762
a6d56a39 3763 if (str_starts(pos, WPA_EVENT_TERMINATING) && ctrl_conn) {
059d3a90
JM		 3764 edit_clear_line();
3765 printf("\rConnection to wpa_supplicant lost - trying to "
3766 "reconnect\n");
3767 edit_redraw();
3768 wpa_cli_attached = 0;
3769 wpa_cli_close_connection();
3770 return 1;
3771 }
3772
3773 return 0;
3774}
3775
3776
cd101567 3777static void wpa_cli_recv_pending(struct wpa_ctrl *ctrl, int action_monitor)
6fc6879b 3778{
6fc6879b
JM		 3779 if (ctrl_conn == NULL) {
3780 wpa_cli_reconnect();
3781 return;
3782 }
3783 while (wpa_ctrl_pending(ctrl) > 0) {
063f8504 3784 char buf[4096];
6fc6879b
JM		 3785 size_t len = sizeof(buf) - 1;
3786 if (wpa_ctrl_recv(ctrl, buf, &len) == 0) {
3787 buf[len] = '\0';
3788 if (action_monitor)
3789 wpa_cli_action_process(buf);
3790 else {
a624f20b 3791 cli_event(buf);
f3f0f648 3792 if (wpa_cli_show_event(buf)) {
82a855bd 3793 edit_clear_line();
cd101567 3794 printf("\r%s\n", buf);
bdc45634 3795 edit_redraw();
f3f0f648 3796 }
059d3a90
JM		 3797
3798 if (interactive && check_terminating(buf) > 0)
3799 return;
6fc6879b
JM		 3800 }
3801 } else {
3802 printf("Could not read pending message.\n");
3803 break;
3804 }
3805 }
3806
3807 if (wpa_ctrl_pending(ctrl) < 0) {
3808 printf("Connection to wpa_supplicant lost - trying to "
3809 "reconnect\n");
3810 wpa_cli_reconnect();
3811 }
3812}
3813
6f1c6549 3814
cd101567
JM		 3815static void wpa_cli_ping(void *eloop_ctx, void *timeout_ctx)
3816{
fa0e9176
JM		 3817 if (ctrl_conn) {
3818 int res;
3819 char *prefix = ifname_prefix;
3820
3821 ifname_prefix = NULL;
3822 res = _wpa_ctrl_command(ctrl_conn, "PING", 0);
3823 ifname_prefix = prefix;
3824 if (res) {
3825 printf("Connection to wpa_supplicant lost - trying to "
3826 "reconnect\n");
3827 wpa_cli_close_connection();
3828 }
cd101567
JM		 3829 }
3830 if (!ctrl_conn)
3831 wpa_cli_reconnect();
3832 eloop_register_timeout(ping_interval, 0, wpa_cli_ping, NULL, NULL);
3833}
3834
3835
cd101567
JM		 3836static void wpa_cli_mon_receive(int sock, void *eloop_ctx, void *sock_ctx)
3837{
3838 wpa_cli_recv_pending(mon_conn, 0);
3839}
3840
3841
82a855bd 3842static void wpa_cli_edit_cmd_cb(void *ctx, char *cmd)
aee680e8
JM		 3843{
3844 char *argv[max_args];
3845 int argc;
82a855bd 3846 argc = tokenize_cmd(cmd, argv);
aee680e8
JM		 3847 if (argc)
3848 wpa_request(ctrl_conn, argc, argv);
aee680e8
JM		 3849}
3850
3851
82a855bd 3852static void wpa_cli_edit_eof_cb(void *ctx)
6f1c6549 3853{
82a855bd 3854 eloop_terminate();
cd101567
JM		 3855}
3856
3857
4be9f275
JM		 3858static int warning_displayed = 0;
3859static char *hfile = NULL;
3860static int edit_started = 0;
aee680e8 3861
4be9f275
JM		 3862static void start_edit(void)
3863{
3864 char *home;
db3a0322
JM		 3865 char *ps = NULL;
3866
3867#ifdef CONFIG_CTRL_IFACE_UDP_REMOTE
3868 ps = wpa_ctrl_get_remote_ifname(ctrl_conn);
3869#endif /* CONFIG_CTRL_IFACE_UDP_REMOTE */
cd101567 3870
ba87329d
MK		 3871#ifdef CONFIG_WPA_CLI_HISTORY_DIR
3872 home = CONFIG_WPA_CLI_HISTORY_DIR;
3873#else /* CONFIG_WPA_CLI_HISTORY_DIR */
8953e968 3874 home = getenv("HOME");
ba87329d 3875#endif /* CONFIG_WPA_CLI_HISTORY_DIR */
8953e968
JM		 3876 if (home) {
3877 const char *fname = ".wpa_cli_history";
3878 int hfile_len = os_strlen(home) + 1 + os_strlen(fname) + 1;
3879 hfile = os_malloc(hfile_len);
3880 if (hfile)
3881 os_snprintf(hfile, hfile_len, "%s/%s", home, fname);
3882 }
3883
4be9f275 3884 if (edit_init(wpa_cli_edit_cmd_cb, wpa_cli_edit_eof_cb,
db3a0322 3885 wpa_cli_edit_completion_cb, NULL, hfile, ps) < 0) {
4be9f275
JM		 3886 eloop_terminate();
3887 return;
3888 }
3889
3890 edit_started = 1;
cd101567 3891 eloop_register_timeout(ping_interval, 0, wpa_cli_ping, NULL, NULL);
4be9f275
JM		 3892}
3893
3894
9be37143
JM		 3895static void update_bssid_list(struct wpa_ctrl *ctrl)
3896{
3897 char buf[4096];
3898 size_t len = sizeof(buf);
3899 int ret;
3900 char *cmd = "BSS RANGE=ALL MASK=0x2";
3901 char *pos, *end;
3902
3903 if (ctrl == NULL)
3904 return;
3905 ret = wpa_ctrl_request(ctrl, cmd, os_strlen(cmd), buf, &len, NULL);
3906 if (ret < 0)
3907 return;
3908 buf[len] = '\0';
3909
3910 pos = buf;
3911 while (pos) {
3912 pos = os_strstr(pos, "bssid=");
3913 if (pos == NULL)
3914 break;
3915 pos += 6;
3916 end = os_strchr(pos, '\n');
3917 if (end == NULL)
3918 break;
3919 *end = '\0';
3920 cli_txt_list_add(&bsses, pos);
3921 pos = end + 1;
3922 }
3923}
3924
3925
37620493
JM		 3926static void update_ifnames(struct wpa_ctrl *ctrl)
3927{
3928 char buf[4096];
3929 size_t len = sizeof(buf);
3930 int ret;
3931 char *cmd = "INTERFACES";
3932 char *pos, *end;
3933 char txt[200];
3934
3935 cli_txt_list_flush(&ifnames);
3936
3937 if (ctrl == NULL)
3938 return;
3939 ret = wpa_ctrl_request(ctrl, cmd, os_strlen(cmd), buf, &len, NULL);
3940 if (ret < 0)
3941 return;
3942 buf[len] = '\0';
3943
3944 pos = buf;
3945 while (pos) {
3946 end = os_strchr(pos, '\n');
3947 if (end == NULL)
3948 break;
3949 *end = '\0';
3950 ret = os_snprintf(txt, sizeof(txt), "ifname=%s", pos);
a80ba67a 3951 if (!os_snprintf_error(sizeof(txt), ret))
37620493
JM		 3952 cli_txt_list_add(&ifnames, txt);
3953 pos = end + 1;
3954 }
3955}
3956
3957
32a097fd
MK		 3958static void update_networks(struct wpa_ctrl *ctrl)
3959{
3960 char buf[4096];
3961 size_t len = sizeof(buf);
3962 int ret;
3963 char *cmd = "LIST_NETWORKS";
3964 char *pos, *end;
3965 int header = 1;
3966
3967 cli_txt_list_flush(&networks);
3968
3969 if (ctrl == NULL)
3970 return;
3971 ret = wpa_ctrl_request(ctrl, cmd, os_strlen(cmd), buf, &len, NULL);
3972 if (ret < 0)
3973 return;
3974 buf[len] = '\0';
3975
3976 pos = buf;
3977 while (pos) {
3978 end = os_strchr(pos, '\n');
3979 if (end == NULL)
3980 break;
3981 *end = '\0';
3982 if (!header)
9ccc10f5 3983 cli_txt_list_add_word(&networks, pos, '\t');
32a097fd
MK		 3984 header = 0;
3985 pos = end + 1;
3986 }
3987}
3988
3989
4be9f275
JM		 3990static void try_connection(void *eloop_ctx, void *timeout_ctx)
3991{
6fd5ceaf
JM		 3992 if (ctrl_conn)
3993 goto done;
3994
8e897ae3
JM		 3995 if (ctrl_ifname == NULL)
3996 ctrl_ifname = wpa_cli_get_default_ifname();
3997
ddd0032e 3998 if (wpa_cli_open_connection(ctrl_ifname, 1)) {
4be9f275
JM		 3999 if (!warning_displayed) {
4000 printf("Could not connect to wpa_supplicant: "
30f459c0
EL		 4001 "%s - re-trying\n",
4002 ctrl_ifname ? ctrl_ifname : "(nil)");
4be9f275
JM		 4003 warning_displayed = 1;
4004 }
4005 eloop_register_timeout(1, 0, try_connection, NULL, NULL);
4006 return;
4007 }
4008
9be37143 4009 update_bssid_list(ctrl_conn);
32a097fd 4010 update_networks(ctrl_conn);
9be37143 4011
4be9f275
JM		 4012 if (warning_displayed)
4013 printf("Connection established.\n");
4014
6fd5ceaf 4015done:
4be9f275
JM		 4016 start_edit();
4017}
4018
cd101567 4019
4be9f275
JM		 4020static void wpa_cli_interactive(void)
4021{
4022 printf("\nInteractive mode\n\n");
4023
4024 eloop_register_timeout(0, 0, try_connection, NULL, NULL);
cd101567 4025 eloop_run();
4be9f275 4026 eloop_cancel_timeout(try_connection, NULL, NULL);
cd101567 4027
a624f20b 4028 cli_txt_list_flush(&p2p_peers);
76788542 4029 cli_txt_list_flush(&p2p_groups);
a624f20b 4030 cli_txt_list_flush(&bsses);
37620493 4031 cli_txt_list_flush(&ifnames);
32a097fd 4032 cli_txt_list_flush(&networks);
4be9f275
JM		 4033 if (edit_started)
4034 edit_deinit(hfile, wpa_cli_edit_filter_history_cb);
8953e968 4035 os_free(hfile);
cd101567
JM		 4036 eloop_cancel_timeout(wpa_cli_ping, NULL, NULL);
4037 wpa_cli_close_connection();
6f1c6549
JM		 4038}
4039
6fc6879b 4040
13f6f617
JM		 4041static void wpa_cli_action_ping(void *eloop_ctx, void *timeout_ctx)
4042{
4043 struct wpa_ctrl *ctrl = eloop_ctx;
4044 char buf[256];
4045 size_t len;
4046
4047 /* verify that connection is still working */
4048 len = sizeof(buf) - 1;
4049 if (wpa_ctrl_request(ctrl, "PING", 4, buf, &len,
4050 wpa_cli_action_cb) < 0 ||
4051 len < 4 || os_memcmp(buf, "PONG", 4) != 0) {
4052 printf("wpa_supplicant did not reply to PING command - exiting\n");
4053 eloop_terminate();
4054 return;
4055 }
4056 eloop_register_timeout(ping_interval, 0, wpa_cli_action_ping,
4057 ctrl, NULL);
4058}
4059
4060
4061static void wpa_cli_action_receive(int sock, void *eloop_ctx, void *sock_ctx)
4062{
4063 struct wpa_ctrl *ctrl = eloop_ctx;
4064
4065 wpa_cli_recv_pending(ctrl, 1);
4066}
4067
4068
6fc6879b
JM		 4069static void wpa_cli_action(struct wpa_ctrl *ctrl)
4070{
4071#ifdef CONFIG_ANSI_C_EXTRA
4072 /* TODO: ANSI C version(?) */
4073 printf("Action processing not supported in ANSI C build.\n");
4074#else /* CONFIG_ANSI_C_EXTRA */
13f6f617 4075 int fd;
6fc6879b
JM		 4076
4077 fd = wpa_ctrl_get_fd(ctrl);
13f6f617
JM		 4078 eloop_register_timeout(ping_interval, 0, wpa_cli_action_ping,
4079 ctrl, NULL);
4080 eloop_register_read_sock(fd, wpa_cli_action_receive, ctrl, NULL);
4081 eloop_run();
4082 eloop_cancel_timeout(wpa_cli_action_ping, ctrl, NULL);
4083 eloop_unregister_read_sock(fd);
6fc6879b
JM		 4084#endif /* CONFIG_ANSI_C_EXTRA */
4085}
4086
4087
4088static void wpa_cli_cleanup(void)
4089{
4090 wpa_cli_close_connection();
4091 if (pid_file)
4092 os_daemonize_terminate(pid_file);
4093
4094 os_program_deinit();
4095}
4096
4be9f275
JM		 4097
4098static void wpa_cli_terminate(int sig, void *ctx)
6fc6879b 4099{
4be9f275 4100 eloop_terminate();
6fc6879b
JM		 4101}
4102
4103
6fc6879b
JM		 4104static char * wpa_cli_get_default_ifname(void)
4105{
4106 char *ifname = NULL;
4107
884c649e
DU		 4108#ifdef ANDROID
4109 char ifprop[PROPERTY_VALUE_MAX];
4110 if (property_get("wifi.interface", ifprop, NULL) != 0) {
4111 ifname = os_strdup(ifprop);
4112 printf("Using interface '%s'\n", ifname ? ifname : "N/A");
4113 }
4114#else /* ANDROID */
6fc6879b
JM		 4115#ifdef CONFIG_CTRL_IFACE_UNIX
4116 struct dirent *dent;
4117 DIR *dir = opendir(ctrl_iface_dir);
b1001e4c 4118 if (!dir) {
6fc6879b 4119 return NULL;
b1001e4c 4120 }
6fc6879b
JM		 4121 while ((dent = readdir(dir))) {
4122#ifdef _DIRENT_HAVE_D_TYPE
4123 /*
4124 * Skip the file if it is not a socket. Also accept
4125 * DT_UNKNOWN (0) in case the C library or underlying
4126 * file system does not support d_type.
4127 */
4128 if (dent->d_type != DT_SOCK && dent->d_type != DT_UNKNOWN)
4129 continue;
4130#endif /* _DIRENT_HAVE_D_TYPE */
4131 if (os_strcmp(dent->d_name, ".") == 0 ||
4132 os_strcmp(dent->d_name, "..") == 0)
4133 continue;
4134 printf("Selected interface '%s'\n", dent->d_name);
4135 ifname = os_strdup(dent->d_name);
4136 break;
4137 }
4138 closedir(dir);
4139#endif /* CONFIG_CTRL_IFACE_UNIX */
4140
4141#ifdef CONFIG_CTRL_IFACE_NAMED_PIPE
89c7ac57 4142 char buf[4096], *pos;
6fc6879b
JM		 4143 size_t len;
4144 struct wpa_ctrl *ctrl;
4145 int ret;
4146
4147 ctrl = wpa_ctrl_open(NULL);
4148 if (ctrl == NULL)
4149 return NULL;
4150
4151 len = sizeof(buf) - 1;
4152 ret = wpa_ctrl_request(ctrl, "INTERFACES", 10, buf, &len, NULL);
4153 if (ret >= 0) {
4154 buf[len] = '\0';
4155 pos = os_strchr(buf, '\n');
4156 if (pos)
4157 *pos = '\0';
4158 ifname = os_strdup(buf);
4159 }
4160 wpa_ctrl_close(ctrl);
4161#endif /* CONFIG_CTRL_IFACE_NAMED_PIPE */
884c649e 4162#endif /* ANDROID */
6fc6879b
JM		 4163
4164 return ifname;
4165}
4166
4167
4168int main(int argc, char *argv[])
4169{
6fc6879b
JM		 4170 int c;
4171 int daemonize = 0;
4172 int ret = 0;
4173 const char *global = NULL;
4174
4175 if (os_program_init())
4176 return -1;
4177
4178 for (;;) {
4ae71209 4179 c = getopt(argc, argv, "a:Bg:G:hi:p:P:s:v");
6fc6879b
JM		 4180 if (c < 0)
4181 break;
4182 switch (c) {
4183 case 'a':
4184 action_file = optarg;
4185 break;
4186 case 'B':
4187 daemonize = 1;
4188 break;
4189 case 'g':
4190 global = optarg;
4191 break;
1cc84c1c
JM		 4192 case 'G':
4193 ping_interval = atoi(optarg);
4194 break;
6fc6879b
JM		 4195 case 'h':
4196 usage();
4197 return 0;
4198 case 'v':
4199 printf("%s\n", wpa_cli_version);
4200 return 0;
4201 case 'i':
4202 os_free(ctrl_ifname);
4203 ctrl_ifname = os_strdup(optarg);
4204 break;
4205 case 'p':
4206 ctrl_iface_dir = optarg;
4207 break;
4208 case 'P':
4209 pid_file = optarg;
4210 break;
4ae71209
MM		 4211 case 's':
4212 client_socket_dir = optarg;
4213 break;
6fc6879b
JM		 4214 default:
4215 usage();
4216 return -1;
4217 }
4218 }
4219
4220 interactive = (argc == optind) && (action_file == NULL);
4221
4222 if (interactive)
23c130e9 4223 printf("%s\n\n%s\n\n", wpa_cli_version, cli_license);
6fc6879b 4224
cd101567
JM		 4225 if (eloop_init())
4226 return -1;
4227
6fc6879b
JM		 4228 if (global) {
4229#ifdef CONFIG_CTRL_IFACE_NAMED_PIPE
4230 ctrl_conn = wpa_ctrl_open(NULL);
4231#else /* CONFIG_CTRL_IFACE_NAMED_PIPE */
4232 ctrl_conn = wpa_ctrl_open(global);
4233#endif /* CONFIG_CTRL_IFACE_NAMED_PIPE */
4234 if (ctrl_conn == NULL) {
5a49459e
BG		 4235 fprintf(stderr, "Failed to connect to wpa_supplicant "
4236 "global interface: %s error: %s\n",
4237 global, strerror(errno));
6fc6879b
JM		 4238 return -1;
4239 }
214e428b
JM		 4240
4241 if (interactive) {
37620493 4242 update_ifnames(ctrl_conn);
214e428b
JM		 4243 mon_conn = wpa_ctrl_open(global);
4244 if (mon_conn) {
4245 if (wpa_ctrl_attach(mon_conn) == 0) {
4246 wpa_cli_attached = 1;
4247 eloop_register_read_sock(
4248 wpa_ctrl_get_fd(mon_conn),
4249 wpa_cli_mon_receive,
4250 NULL, NULL);
4251 } else {
4252 printf("Failed to open monitor "
4253 "connection through global "
4254 "control interface\n");
4255 }
4256 }
4257 }
6fc6879b
JM		 4258 }
4259
4be9f275 4260 eloop_register_signal_terminate(wpa_cli_terminate, NULL);
6fc6879b 4261
4a3ade4e
JM		 4262 if (ctrl_ifname == NULL)
4263 ctrl_ifname = wpa_cli_get_default_ifname();
4264
4265 if (interactive) {
4be9f275 4266 wpa_cli_interactive();
4a3ade4e
JM		 4267 } else {
4268 if (!global &&
4269 wpa_cli_open_connection(ctrl_ifname, 0) < 0) {
5a49459e
BG		 4270 fprintf(stderr, "Failed to connect to non-global "
4271 "ctrl_ifname: %s error: %s\n",
30f459c0
EL		 4272 ctrl_ifname ? ctrl_ifname : "(nil)",
4273 strerror(errno));
4a3ade4e
JM		 4274 return -1;
4275 }
4276
4277 if (action_file) {
4278 if (wpa_ctrl_attach(ctrl_conn) == 0) {
4279 wpa_cli_attached = 1;
4280 } else {
4281 printf("Warning: Failed to attach to "
4282 "wpa_supplicant.\n");
6fc6879b 4283 return -1;
4a3ade4e 4284 }
6fc6879b 4285 }
6fc6879b 4286
2e69bdd1 4287 if (daemonize && os_daemonize(pid_file) && eloop_sock_requeue())
4be9f275 4288 return -1;
6fc6879b 4289
4be9f275
JM		 4290 if (action_file)
4291 wpa_cli_action(ctrl_conn);
4292 else
4293 ret = wpa_request(ctrl_conn, argc - optind,
4294 &argv[optind]);
4295 }
6fc6879b
JM		 4296
4297 os_free(ctrl_ifname);
cd101567 4298 eloop_destroy();
6fc6879b
JM		 4299 wpa_cli_cleanup();
4300
4301 return ret;
4302}
4303
4304#else /* CONFIG_CTRL_IFACE */
4305int main(int argc, char *argv[])
4306{
4307 printf("CONFIG_CTRL_IFACE not defined - wpa_cli disabled\n");
4308 return -1;
4309}
4310#endif /* CONFIG_CTRL_IFACE */
Unnamed repository; edit this file 'description' to name the repository.