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