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