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