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