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