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