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