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