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