blob: 51c9642e9023c77ac50be9b12877fec8fb215f31 [file] [log] [blame]
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001/*
2 * WPA Supplicant - command line interface for wpa_supplicant daemon
Hai Shalom74f70d42019-02-11 14:42:39 -08003 * Copyright (c) 2004-2019, Jouni Malinen <j@w1.fi>
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004 *
Dmitry Shmidtc5ec7f52012-03-06 16:33:24 -08005 * This software may be distributed under the terms of the BSD license.
6 * See README for more details.
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07007 */
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 */
16
Dmitry Shmidt7f2c7532016-08-15 09:48:12 -070017#include "common/cli.h"
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -070018#include "common/wpa_ctrl.h"
19#include "utils/common.h"
20#include "utils/eloop.h"
21#include "utils/edit.h"
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -080022#include "utils/list.h"
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -070023#include "common/version.h"
Dmitry Shmidt04949592012-07-19 12:16:46 -070024#include "common/ieee802_11_defs.h"
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -070025#ifdef ANDROID
26#include <cutils/properties.h>
27#endif /* ANDROID */
28
29
Dmitry Shmidt1d755d02015-04-28 10:34:29 -070030static const char *const wpa_cli_version =
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -070031"wpa_cli v" VERSION_STR "\n"
Hai Shalom74f70d42019-02-11 14:42:39 -080032"Copyright (c) 2004-2019, Jouni Malinen <j@w1.fi> and contributors";
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -070033
Dmitry Shmidtd80a4012015-11-05 16:35:40 -080034#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
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -070040static struct wpa_ctrl *ctrl_conn;
41static struct wpa_ctrl *mon_conn;
42static int wpa_cli_quit = 0;
43static int wpa_cli_attached = 0;
Dmitry Shmidt391c59f2013-09-03 12:16:28 -070044static int wpa_cli_connected = -1;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -070045static int wpa_cli_last_id = 0;
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;
Dmitry Shmidtd80a4012015-11-05 16:35:40 -080050static const char *client_socket_dir = NULL;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -070051static char *ctrl_ifname = NULL;
Hai Shalom74f70d42019-02-11 14:42:39 -080052static const char *global = NULL;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -070053static const char *pid_file = NULL;
54static const char *action_file = NULL;
Ahmed ElArabawy0ff61c52019-12-26 12:38:39 -080055static int reconnect = 0;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -070056static int ping_interval = 5;
57static int interactive = 0;
Dmitry Shmidtf7e0a992013-05-23 11:03:10 -070058static char *ifname_prefix = NULL;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -070059
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -080060static DEFINE_DL_LIST(bsses); /* struct cli_txt_entry */
61static DEFINE_DL_LIST(p2p_peers); /* struct cli_txt_entry */
62static DEFINE_DL_LIST(p2p_groups); /* struct cli_txt_entry */
Dmitry Shmidtf7e0a992013-05-23 11:03:10 -070063static DEFINE_DL_LIST(ifnames); /* struct cli_txt_entry */
Dmitry Shmidt912c6ec2015-03-30 13:16:51 -070064static DEFINE_DL_LIST(networks); /* struct cli_txt_entry */
Roshan Pius3a1667e2018-07-03 15:17:14 -070065static DEFINE_DL_LIST(creds); /* struct cli_txt_entry */
Dmitry Shmidt9839ecd2016-11-07 11:05:47 -080066#ifdef CONFIG_AP
67static DEFINE_DL_LIST(stations); /* struct cli_txt_entry */
68#endif /* CONFIG_AP */
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -080069
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -070070
Dmitry Shmidt61d9df32012-08-29 16:22:06 -070071static void print_help(const char *cmd);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -070072static void wpa_cli_mon_receive(int sock, void *eloop_ctx, void *sock_ctx);
Dmitry Shmidt61d9df32012-08-29 16:22:06 -070073static void wpa_cli_close_connection(void);
74static char * wpa_cli_get_default_ifname(void);
75static char ** wpa_list_cmd_list(void);
Roshan Pius3a1667e2018-07-03 15:17:14 -070076static void update_creds(struct wpa_ctrl *ctrl);
Dmitry Shmidt912c6ec2015-03-30 13:16:51 -070077static void update_networks(struct wpa_ctrl *ctrl);
Dmitry Shmidt9839ecd2016-11-07 11:05:47 -080078static void update_stations(struct wpa_ctrl *ctrl);
Hai Shalom74f70d42019-02-11 14:42:39 -080079static void update_ifnames(struct wpa_ctrl *ctrl);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -070080
81
82static void usage(void)
83{
Ahmed ElArabawy0ff61c52019-12-26 12:38:39 -080084 printf("wpa_cli [-p<path to ctrl sockets>] [-i<ifname>] [-hvBr] "
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -070085 "[-a<action file>] \\\n"
Dmitry Shmidtd80a4012015-11-05 16:35:40 -080086 " [-P<pid file>] [-g<global ctrl>] [-G<ping interval>] "
87 "\\\n"
88 " [-s<wpa_client_socket_file_path>] "
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -070089 "[command..]\n"
90 " -h = help (show this usage text)\n"
91 " -v = shown version information\n"
92 " -a = run in daemon mode executing the action file based on "
93 "events from\n"
94 " wpa_supplicant\n"
Ahmed ElArabawy0ff61c52019-12-26 12:38:39 -080095 " -r = try to reconnect when client socket is disconnected.\n"
96 " This is useful only when used with -a.\n"
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -070097 " -B = run a daemon in the background\n"
98 " default path: " CONFIG_CTRL_IFACE_DIR "\n"
99 " default interface: first interface found in socket path\n");
Dmitry Shmidt61d9df32012-08-29 16:22:06 -0700100 print_help(NULL);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700101}
102
103
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700104static int wpa_cli_show_event(const char *event)
105{
106 const char *start;
107
108 start = os_strchr(event, '>');
109 if (start == NULL)
110 return 1;
111
112 start++;
113 /*
114 * Skip BSS added/removed events since they can be relatively frequent
115 * and are likely of not much use for an interactive user.
116 */
117 if (str_starts(start, WPA_EVENT_BSS_ADDED) ||
118 str_starts(start, WPA_EVENT_BSS_REMOVED))
119 return 0;
120
121 return 1;
122}
123
124
125static int wpa_cli_open_connection(const char *ifname, int attach)
126{
127#if defined(CONFIG_CTRL_IFACE_UDP) || defined(CONFIG_CTRL_IFACE_NAMED_PIPE)
128 ctrl_conn = wpa_ctrl_open(ifname);
129 if (ctrl_conn == NULL)
130 return -1;
131
132 if (attach && interactive)
133 mon_conn = wpa_ctrl_open(ifname);
134 else
135 mon_conn = NULL;
136#else /* CONFIG_CTRL_IFACE_UDP || CONFIG_CTRL_IFACE_NAMED_PIPE */
137 char *cfile = NULL;
138 int flen, res;
139
140 if (ifname == NULL)
141 return -1;
142
143#ifdef ANDROID
144 if (access(ctrl_iface_dir, F_OK) < 0) {
145 cfile = os_strdup(ifname);
146 if (cfile == NULL)
147 return -1;
148 }
149#endif /* ANDROID */
150
Dmitry Shmidtd80a4012015-11-05 16:35:40 -0800151 if (client_socket_dir && client_socket_dir[0] &&
152 access(client_socket_dir, F_OK) < 0) {
153 perror(client_socket_dir);
154 os_free(cfile);
155 return -1;
156 }
157
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700158 if (cfile == NULL) {
159 flen = os_strlen(ctrl_iface_dir) + os_strlen(ifname) + 2;
160 cfile = os_malloc(flen);
161 if (cfile == NULL)
162 return -1;
163 res = os_snprintf(cfile, flen, "%s/%s", ctrl_iface_dir,
164 ifname);
Dmitry Shmidt6c0da2b2015-01-05 13:08:17 -0800165 if (os_snprintf_error(flen, res)) {
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700166 os_free(cfile);
167 return -1;
168 }
169 }
170
Dmitry Shmidtd80a4012015-11-05 16:35:40 -0800171 ctrl_conn = wpa_ctrl_open2(cfile, client_socket_dir);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700172 if (ctrl_conn == NULL) {
173 os_free(cfile);
174 return -1;
175 }
176
177 if (attach && interactive)
Dmitry Shmidtd80a4012015-11-05 16:35:40 -0800178 mon_conn = wpa_ctrl_open2(cfile, client_socket_dir);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700179 else
180 mon_conn = NULL;
181 os_free(cfile);
182#endif /* CONFIG_CTRL_IFACE_UDP || CONFIG_CTRL_IFACE_NAMED_PIPE */
183
184 if (mon_conn) {
185 if (wpa_ctrl_attach(mon_conn) == 0) {
186 wpa_cli_attached = 1;
187 if (interactive)
188 eloop_register_read_sock(
189 wpa_ctrl_get_fd(mon_conn),
190 wpa_cli_mon_receive, NULL, NULL);
191 } else {
192 printf("Warning: Failed to attach to "
193 "wpa_supplicant.\n");
Dmitry Shmidt61d9df32012-08-29 16:22:06 -0700194 wpa_cli_close_connection();
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700195 return -1;
196 }
197 }
198
199 return 0;
200}
201
202
203static void wpa_cli_close_connection(void)
204{
205 if (ctrl_conn == NULL)
206 return;
207
208 if (wpa_cli_attached) {
209 wpa_ctrl_detach(interactive ? mon_conn : ctrl_conn);
210 wpa_cli_attached = 0;
211 }
212 wpa_ctrl_close(ctrl_conn);
213 ctrl_conn = NULL;
214 if (mon_conn) {
215 eloop_unregister_read_sock(wpa_ctrl_get_fd(mon_conn));
216 wpa_ctrl_close(mon_conn);
217 mon_conn = NULL;
218 }
219}
220
221
222static void wpa_cli_msg_cb(char *msg, size_t len)
223{
224 printf("%s\n", msg);
225}
226
227
Dmitry Shmidt9839ecd2016-11-07 11:05:47 -0800228static int _wpa_ctrl_command(struct wpa_ctrl *ctrl, const char *cmd, int print)
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700229{
Dmitry Shmidtc97d8bf2011-08-30 11:10:13 -0700230 char buf[4096];
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700231 size_t len;
232 int ret;
233
234 if (ctrl_conn == NULL) {
235 printf("Not connected to wpa_supplicant - command dropped.\n");
236 return -1;
237 }
Dmitry Shmidtd3e385e2013-06-05 11:06:13 -0700238 if (ifname_prefix) {
239 os_snprintf(buf, sizeof(buf), "IFNAME=%s %s",
240 ifname_prefix, cmd);
241 buf[sizeof(buf) - 1] = '\0';
242 cmd = buf;
243 }
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700244 len = sizeof(buf) - 1;
245 ret = wpa_ctrl_request(ctrl, cmd, os_strlen(cmd), buf, &len,
246 wpa_cli_msg_cb);
247 if (ret == -2) {
248 printf("'%s' command timed out.\n", cmd);
249 return -2;
250 } else if (ret < 0) {
251 printf("'%s' command failed.\n", cmd);
252 return -1;
253 }
254 if (print) {
255 buf[len] = '\0';
256 printf("%s", buf);
257 if (interactive && len > 0 && buf[len - 1] != '\n')
258 printf("\n");
259 }
260 return 0;
261}
262
263
Dmitry Shmidt9839ecd2016-11-07 11:05:47 -0800264static int wpa_ctrl_command(struct wpa_ctrl *ctrl, const char *cmd)
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700265{
266 return _wpa_ctrl_command(ctrl, cmd, 1);
267}
268
269
Dmitry Shmidt61d9df32012-08-29 16:22:06 -0700270static int wpa_cli_cmd(struct wpa_ctrl *ctrl, const char *cmd, int min_args,
271 int argc, char *argv[])
272{
Dmitry Shmidt4b060592013-04-29 16:42:49 -0700273 char buf[4096];
Dmitry Shmidt61d9df32012-08-29 16:22:06 -0700274 if (argc < min_args) {
275 printf("Invalid %s command - at least %d argument%s "
276 "required.\n", cmd, min_args,
277 min_args > 1 ? "s are" : " is");
278 return -1;
279 }
280 if (write_cmd(buf, sizeof(buf), cmd, argc, argv) < 0)
281 return -1;
282 return wpa_ctrl_command(ctrl, buf);
283}
284
285
286static int wpa_cli_cmd_ifname(struct wpa_ctrl *ctrl, int argc, char *argv[])
287{
288 return wpa_ctrl_command(ctrl, "IFNAME");
289}
290
291
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700292static int wpa_cli_cmd_status(struct wpa_ctrl *ctrl, int argc, char *argv[])
293{
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -0800294 if (argc > 0 && os_strcmp(argv[0], "verbose") == 0)
295 return wpa_ctrl_command(ctrl, "STATUS-VERBOSE");
296 if (argc > 0 && os_strcmp(argv[0], "wps") == 0)
297 return wpa_ctrl_command(ctrl, "STATUS-WPS");
Dmitry Shmidt56052862013-10-04 10:23:25 -0700298 if (argc > 0 && os_strcmp(argv[0], "driver") == 0)
299 return wpa_ctrl_command(ctrl, "STATUS-DRIVER");
Dmitry Shmidtd80a4012015-11-05 16:35:40 -0800300#ifdef ANDROID
301 if (argc > 0 && os_strcmp(argv[0], "no_events") == 0)
302 return wpa_ctrl_command(ctrl, "STATUS-NO_EVENTS");
303#endif /* ANDROID */
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -0800304 return wpa_ctrl_command(ctrl, "STATUS");
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700305}
306
307
308static int wpa_cli_cmd_ping(struct wpa_ctrl *ctrl, int argc, char *argv[])
309{
310 return wpa_ctrl_command(ctrl, "PING");
311}
312
313
314static int wpa_cli_cmd_relog(struct wpa_ctrl *ctrl, int argc, char *argv[])
315{
316 return wpa_ctrl_command(ctrl, "RELOG");
317}
318
319
320static int wpa_cli_cmd_note(struct wpa_ctrl *ctrl, int argc, char *argv[])
321{
Dmitry Shmidt61d9df32012-08-29 16:22:06 -0700322 return wpa_cli_cmd(ctrl, "NOTE", 1, argc, argv);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700323}
324
325
326static int wpa_cli_cmd_mib(struct wpa_ctrl *ctrl, int argc, char *argv[])
327{
328 return wpa_ctrl_command(ctrl, "MIB");
329}
330
331
332static int wpa_cli_cmd_pmksa(struct wpa_ctrl *ctrl, int argc, char *argv[])
333{
334 return wpa_ctrl_command(ctrl, "PMKSA");
335}
336
337
Dmitry Shmidt661b4f72014-09-29 14:58:27 -0700338static int wpa_cli_cmd_pmksa_flush(struct wpa_ctrl *ctrl, int argc,
339 char *argv[])
340{
341 return wpa_ctrl_command(ctrl, "PMKSA_FLUSH");
342}
343
344
Dmitry Shmidt29333592017-01-09 12:27:11 -0800345#ifdef CONFIG_PMKSA_CACHE_EXTERNAL
346
347static int wpa_cli_cmd_pmksa_get(struct wpa_ctrl *ctrl, int argc, char *argv[])
348{
349 return wpa_cli_cmd(ctrl, "PMKSA_GET", 1, argc, argv);
350}
351
352
353static int wpa_cli_cmd_pmksa_add(struct wpa_ctrl *ctrl, int argc, char *argv[])
354{
355 return wpa_cli_cmd(ctrl, "PMKSA_ADD", 8, argc, argv);
356}
357
Paul Stewart092955c2017-02-06 09:13:09 -0800358
359#ifdef CONFIG_MESH
360
361static int wpa_cli_mesh_cmd_pmksa_get(struct wpa_ctrl *ctrl, int argc,
362 char *argv[])
363{
364 return wpa_cli_cmd(ctrl, "MESH_PMKSA_GET", 1, argc, argv);
365}
366
367
368static int wpa_cli_mesh_cmd_pmksa_add(struct wpa_ctrl *ctrl, int argc,
369 char *argv[])
370{
371 return wpa_cli_cmd(ctrl, "MESH_PMKSA_ADD", 4, argc, argv);
372}
373
374#endif /* CONFIG_MESH */
Dmitry Shmidt29333592017-01-09 12:27:11 -0800375#endif /* CONFIG_PMKSA_CACHE_EXTERNAL */
376
377
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700378static int wpa_cli_cmd_help(struct wpa_ctrl *ctrl, int argc, char *argv[])
379{
Dmitry Shmidt61d9df32012-08-29 16:22:06 -0700380 print_help(argc > 0 ? argv[0] : NULL);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700381 return 0;
382}
383
384
Dmitry Shmidt61d9df32012-08-29 16:22:06 -0700385static char ** wpa_cli_complete_help(const char *str, int pos)
386{
387 int arg = get_cmd_arg_num(str, pos);
388 char **res = NULL;
389
390 switch (arg) {
391 case 1:
392 res = wpa_list_cmd_list();
393 break;
394 }
395
396 return res;
397}
398
399
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700400static int wpa_cli_cmd_license(struct wpa_ctrl *ctrl, int argc, char *argv[])
401{
Dmitry Shmidt7f2c7532016-08-15 09:48:12 -0700402 printf("%s\n\n%s\n", wpa_cli_version, cli_full_license);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700403 return 0;
404}
405
406
407static int wpa_cli_cmd_quit(struct wpa_ctrl *ctrl, int argc, char *argv[])
408{
409 wpa_cli_quit = 1;
410 if (interactive)
411 eloop_terminate();
412 return 0;
413}
414
415
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700416static int wpa_cli_cmd_set(struct wpa_ctrl *ctrl, int argc, char *argv[])
417{
418 char cmd[256];
419 int res;
420
Dmitry Shmidt51b6ea82013-05-08 10:42:09 -0700421 if (argc == 1) {
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -0800422 res = os_snprintf(cmd, sizeof(cmd), "SET %s ", argv[0]);
Dmitry Shmidt6c0da2b2015-01-05 13:08:17 -0800423 if (os_snprintf_error(sizeof(cmd), res)) {
Dmitry Shmidt51b6ea82013-05-08 10:42:09 -0700424 printf("Too long SET command.\n");
425 return -1;
426 }
427 return wpa_ctrl_command(ctrl, cmd);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700428 }
Dmitry Shmidt51b6ea82013-05-08 10:42:09 -0700429
430 return wpa_cli_cmd(ctrl, "SET", 2, argc, argv);
431}
432
433
434static char ** wpa_cli_complete_set(const char *str, int pos)
435{
436 int arg = get_cmd_arg_num(str, pos);
437 const char *fields[] = {
438 /* runtime values */
439 "EAPOL::heldPeriod", "EAPOL::authPeriod", "EAPOL::startPeriod",
440 "EAPOL::maxStart", "dot11RSNAConfigPMKLifetime",
441 "dot11RSNAConfigPMKReauthThreshold", "dot11RSNAConfigSATimeout",
442 "wps_fragment_size", "wps_version_number", "ampdu",
443 "tdls_testing", "tdls_disabled", "pno", "radio_disabled",
444 "uapsd", "ps", "wifi_display", "bssid_filter", "disallow_aps",
445 "no_keep_alive",
446 /* global configuration parameters */
Dmitry Shmidtf73259c2015-03-17 11:00:54 -0700447#ifdef CONFIG_CTRL_IFACE
448 "ctrl_interface", "no_ctrl_interface", "ctrl_interface_group",
449#endif /* CONFIG_CTRL_IFACE */
450 "eapol_version", "ap_scan", "bgscan",
451#ifdef CONFIG_MESH
452 "user_mpm", "max_peer_links", "mesh_max_inactivity",
Dmitry Shmidtd80a4012015-11-05 16:35:40 -0800453 "dot11RSNASAERetransPeriod",
Dmitry Shmidtf73259c2015-03-17 11:00:54 -0700454#endif /* CONFIG_MESH */
455 "disable_scan_offload", "fast_reauth", "opensc_engine_path",
456 "pkcs11_engine_path", "pkcs11_module_path", "openssl_ciphers",
457 "pcsc_reader", "pcsc_pin", "external_sim", "driver_param",
458 "dot11RSNAConfigPMKLifetime",
Dmitry Shmidt51b6ea82013-05-08 10:42:09 -0700459 "dot11RSNAConfigPMKReauthThreshold",
460 "dot11RSNAConfigSATimeout",
Dmitry Shmidtf73259c2015-03-17 11:00:54 -0700461#ifndef CONFIG_NO_CONFIG_WRITE
462 "update_config",
463#endif /* CONFIG_NO_CONFIG_WRITE */
464 "load_dynamic_eap",
465#ifdef CONFIG_WPS
466 "uuid", "device_name", "manufacturer", "model_name",
467 "model_number", "serial_number", "device_type", "os_version",
468 "config_methods", "wps_cred_processing", "wps_vendor_ext_m1",
469#endif /* CONFIG_WPS */
470#ifdef CONFIG_P2P
471 "sec_device_type",
Dmitry Shmidt51b6ea82013-05-08 10:42:09 -0700472 "p2p_listen_reg_class", "p2p_listen_channel",
Dmitry Shmidtf73259c2015-03-17 11:00:54 -0700473 "p2p_oper_reg_class", "p2p_oper_channel", "p2p_go_intent",
474 "p2p_ssid_postfix", "persistent_reconnect", "p2p_intra_bss",
475 "p2p_group_idle", "p2p_passphrase_len", "p2p_pref_chan",
476 "p2p_no_go_freq", "p2p_add_cli_chan",
477 "p2p_optimize_listen_chan", "p2p_go_ht40", "p2p_go_vht",
478 "p2p_disabled", "p2p_go_ctwindow", "p2p_no_group_iface",
479 "p2p_ignore_shared_freq", "ip_addr_go", "ip_addr_mask",
Ahmed ElArabawy0ff61c52019-12-26 12:38:39 -0800480 "ip_addr_start", "ip_addr_end", "p2p_go_edmg",
Dmitry Shmidtf73259c2015-03-17 11:00:54 -0700481#endif /* CONFIG_P2P */
482 "country", "bss_max_count", "bss_expiration_age",
483 "bss_expiration_scan_count", "filter_ssids", "filter_rssi",
Roshan Pius3a1667e2018-07-03 15:17:14 -0700484 "max_num_sta", "disassoc_low_ack", "ap_isolate",
Dmitry Shmidtf73259c2015-03-17 11:00:54 -0700485#ifdef CONFIG_HS20
486 "hs20",
487#endif /* CONFIG_HS20 */
488 "interworking", "hessid", "access_network_type", "pbc_in_m1",
Dmitry Shmidtd2986c22017-10-23 14:22:09 -0700489 "go_interworking", "go_access_network_type", "go_internet",
490 "go_venue_group", "go_venue_type",
Dmitry Shmidtf73259c2015-03-17 11:00:54 -0700491 "autoscan", "wps_nfc_dev_pw_id", "wps_nfc_dh_pubkey",
492 "wps_nfc_dh_privkey", "wps_nfc_dev_pw", "ext_password_backend",
Dmitry Shmidt51b6ea82013-05-08 10:42:09 -0700493 "p2p_go_max_inactivity", "auto_interworking", "okc", "pmf",
Dmitry Shmidtf73259c2015-03-17 11:00:54 -0700494 "sae_groups", "dtim_period", "beacon_int",
495 "ap_vendor_elements", "ignore_old_scan_res", "freq_list",
496 "scan_cur_freq", "sched_scan_interval",
497 "tdls_external_control", "osu_dir", "wowlan_triggers",
498 "p2p_search_delay", "mac_addr", "rand_addr_lifetime",
499 "preassoc_mac_addr", "key_mgmt_offload", "passive_scan",
Dmitry Shmidtaca489e2016-09-28 15:44:14 -0700500 "reassoc_same_bss_optim", "wps_priority",
501#ifdef CONFIG_TESTING_OPTIONS
502 "ignore_auth_resp",
503#endif /* CONFIG_TESTING_OPTIONS */
Dmitry Shmidtebd93af2017-02-21 13:40:44 -0800504 "relative_rssi", "relative_band_adjust",
Hai Shalomfdcde762020-04-02 11:19:20 -0700505 "extended_key_id",
Dmitry Shmidt51b6ea82013-05-08 10:42:09 -0700506 };
Dmitry Shmidt68d0e3e2013-10-28 17:59:21 -0700507 int i, num_fields = ARRAY_SIZE(fields);
Dmitry Shmidt51b6ea82013-05-08 10:42:09 -0700508
509 if (arg == 1) {
510 char **res = os_calloc(num_fields + 1, sizeof(char *));
511 if (res == NULL)
512 return NULL;
513 for (i = 0; i < num_fields; i++) {
514 res[i] = os_strdup(fields[i]);
515 if (res[i] == NULL)
516 return res;
517 }
518 return res;
519 }
520
521 if (arg > 1 && os_strncasecmp(str, "set bssid_filter ", 17) == 0)
522 return cli_txt_list_array(&bsses);
523
524 return NULL;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700525}
526
Dmitry Shmidt7f656022015-02-25 14:36:37 -0800527static int wpa_cli_cmd_dump(struct wpa_ctrl *ctrl, int argc, char *argv[])
528{
529 return wpa_ctrl_command(ctrl, "DUMP");
530}
531
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700532
Dmitry Shmidt58d12ad2016-07-28 10:07:03 -0700533static int wpa_cli_cmd_driver_flags(struct wpa_ctrl *ctrl, int argc,
534 char *argv[])
535{
536 return wpa_ctrl_command(ctrl, "DRIVER_FLAGS");
537}
538
539
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700540static int wpa_cli_cmd_get(struct wpa_ctrl *ctrl, int argc, char *argv[])
541{
Dmitry Shmidt61d9df32012-08-29 16:22:06 -0700542 return wpa_cli_cmd(ctrl, "GET", 1, argc, argv);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700543}
544
545
Dmitry Shmidtf73259c2015-03-17 11:00:54 -0700546static char ** wpa_cli_complete_get(const char *str, int pos)
547{
548 int arg = get_cmd_arg_num(str, pos);
549 const char *fields[] = {
550#ifdef CONFIG_CTRL_IFACE
551 "ctrl_interface", "ctrl_interface_group",
552#endif /* CONFIG_CTRL_IFACE */
553 "eapol_version", "ap_scan",
554#ifdef CONFIG_MESH
555 "user_mpm", "max_peer_links", "mesh_max_inactivity",
556#endif /* CONFIG_MESH */
557 "disable_scan_offload", "fast_reauth", "opensc_engine_path",
558 "pkcs11_engine_path", "pkcs11_module_path", "openssl_ciphers",
559 "pcsc_reader", "pcsc_pin", "external_sim", "driver_param",
560 "dot11RSNAConfigPMKLifetime",
561 "dot11RSNAConfigPMKReauthThreshold",
562 "dot11RSNAConfigSATimeout",
563#ifndef CONFIG_NO_CONFIG_WRITE
564 "update_config",
565#endif /* CONFIG_NO_CONFIG_WRITE */
566#ifdef CONFIG_WPS
567 "device_name", "manufacturer", "model_name", "model_number",
568 "serial_number", "config_methods", "wps_cred_processing",
569#endif /* CONFIG_WPS */
570#ifdef CONFIG_P2P
571 "p2p_listen_reg_class", "p2p_listen_channel",
572 "p2p_oper_reg_class", "p2p_oper_channel", "p2p_go_intent",
573 "p2p_ssid_postfix", "persistent_reconnect", "p2p_intra_bss",
574 "p2p_group_idle", "p2p_passphrase_len", "p2p_add_cli_chan",
575 "p2p_optimize_listen_chan", "p2p_go_ht40", "p2p_go_vht",
576 "p2p_disabled", "p2p_go_ctwindow", "p2p_no_group_iface",
577 "p2p_ignore_shared_freq", "ip_addr_go", "ip_addr_mask",
578 "ip_addr_start", "ip_addr_end",
579#endif /* CONFIG_P2P */
580 "bss_max_count", "bss_expiration_age",
581 "bss_expiration_scan_count", "filter_ssids", "filter_rssi",
Roshan Pius3a1667e2018-07-03 15:17:14 -0700582 "max_num_sta", "disassoc_low_ack", "ap_isolate",
Dmitry Shmidtf73259c2015-03-17 11:00:54 -0700583#ifdef CONFIG_HS20
584 "hs20",
585#endif /* CONFIG_HS20 */
586 "interworking", "access_network_type", "pbc_in_m1", "autoscan",
Dmitry Shmidtd2986c22017-10-23 14:22:09 -0700587 "go_interworking", "go_access_network_type", "go_internet",
588 "go_venue_group", "go_venue_type",
Dmitry Shmidtf73259c2015-03-17 11:00:54 -0700589 "wps_nfc_dev_pw_id", "ext_password_backend",
590 "p2p_go_max_inactivity", "auto_interworking", "okc", "pmf",
591 "dtim_period", "beacon_int", "ignore_old_scan_res",
592 "scan_cur_freq", "sched_scan_interval",
Dmitry Shmidtd2986c22017-10-23 14:22:09 -0700593 "sched_scan_start_delay",
Dmitry Shmidtf73259c2015-03-17 11:00:54 -0700594 "tdls_external_control", "osu_dir", "wowlan_triggers",
595 "p2p_search_delay", "mac_addr", "rand_addr_lifetime",
596 "preassoc_mac_addr", "key_mgmt_offload", "passive_scan",
Hai Shalomfdcde762020-04-02 11:19:20 -0700597 "reassoc_same_bss_optim", "extended_key_id"
Dmitry Shmidtf73259c2015-03-17 11:00:54 -0700598 };
599 int i, num_fields = ARRAY_SIZE(fields);
600
601 if (arg == 1) {
602 char **res = os_calloc(num_fields + 1, sizeof(char *));
603 if (res == NULL)
604 return NULL;
605 for (i = 0; i < num_fields; i++) {
606 res[i] = os_strdup(fields[i]);
607 if (res[i] == NULL)
608 return res;
609 }
610 return res;
611 }
612
613 return NULL;
614}
615
616
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700617static int wpa_cli_cmd_logoff(struct wpa_ctrl *ctrl, int argc, char *argv[])
618{
619 return wpa_ctrl_command(ctrl, "LOGOFF");
620}
621
622
623static int wpa_cli_cmd_logon(struct wpa_ctrl *ctrl, int argc, char *argv[])
624{
625 return wpa_ctrl_command(ctrl, "LOGON");
626}
627
628
629static int wpa_cli_cmd_reassociate(struct wpa_ctrl *ctrl, int argc,
630 char *argv[])
631{
632 return wpa_ctrl_command(ctrl, "REASSOCIATE");
633}
634
635
Dmitry Shmidt98660862014-03-11 17:26:21 -0700636static int wpa_cli_cmd_reattach(struct wpa_ctrl *ctrl, int argc, char *argv[])
637{
638 return wpa_ctrl_command(ctrl, "REATTACH");
639}
640
641
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700642static int wpa_cli_cmd_preauthenticate(struct wpa_ctrl *ctrl, int argc,
643 char *argv[])
644{
Dmitry Shmidt61d9df32012-08-29 16:22:06 -0700645 return wpa_cli_cmd(ctrl, "PREAUTH", 1, argc, argv);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700646}
647
648
649static int wpa_cli_cmd_ap_scan(struct wpa_ctrl *ctrl, int argc, char *argv[])
650{
Dmitry Shmidt61d9df32012-08-29 16:22:06 -0700651 return wpa_cli_cmd(ctrl, "AP_SCAN", 1, argc, argv);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700652}
653
654
655static int wpa_cli_cmd_scan_interval(struct wpa_ctrl *ctrl, int argc,
656 char *argv[])
657{
Dmitry Shmidt61d9df32012-08-29 16:22:06 -0700658 return wpa_cli_cmd(ctrl, "SCAN_INTERVAL", 1, argc, argv);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700659}
660
661
662static int wpa_cli_cmd_bss_expire_age(struct wpa_ctrl *ctrl, int argc,
663 char *argv[])
664{
Dmitry Shmidt61d9df32012-08-29 16:22:06 -0700665 return wpa_cli_cmd(ctrl, "BSS_EXPIRE_AGE", 1, argc, argv);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700666}
667
668
669static int wpa_cli_cmd_bss_expire_count(struct wpa_ctrl *ctrl, int argc,
670 char *argv[])
671{
Dmitry Shmidt61d9df32012-08-29 16:22:06 -0700672 return wpa_cli_cmd(ctrl, "BSS_EXPIRE_COUNT", 1, argc, argv);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700673}
674
675
Dmitry Shmidtf48e4f92012-08-24 11:14:44 -0700676static int wpa_cli_cmd_bss_flush(struct wpa_ctrl *ctrl, int argc, char *argv[])
677{
678 char cmd[256];
679 int res;
680
681 if (argc < 1)
682 res = os_snprintf(cmd, sizeof(cmd), "BSS_FLUSH 0");
683 else
684 res = os_snprintf(cmd, sizeof(cmd), "BSS_FLUSH %s", argv[0]);
Dmitry Shmidt6c0da2b2015-01-05 13:08:17 -0800685 if (os_snprintf_error(sizeof(cmd), res)) {
Dmitry Shmidtf48e4f92012-08-24 11:14:44 -0700686 printf("Too long BSS_FLUSH command.\n");
687 return -1;
688 }
689 return wpa_ctrl_command(ctrl, cmd);
690}
691
692
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700693static int wpa_cli_cmd_ft_ds(struct wpa_ctrl *ctrl, int argc, char *argv[])
694{
Dmitry Shmidt61d9df32012-08-29 16:22:06 -0700695 return wpa_cli_cmd(ctrl, "FT_DS", 1, argc, argv);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700696}
697
698
699static int wpa_cli_cmd_wps_pbc(struct wpa_ctrl *ctrl, int argc, char *argv[])
700{
Dmitry Shmidt61d9df32012-08-29 16:22:06 -0700701 return wpa_cli_cmd(ctrl, "WPS_PBC", 0, argc, argv);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700702}
703
704
705static int wpa_cli_cmd_wps_pin(struct wpa_ctrl *ctrl, int argc, char *argv[])
706{
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700707 if (argc == 0) {
708 printf("Invalid WPS_PIN command: need one or two arguments:\n"
709 "- BSSID: use 'any' to select any\n"
710 "- PIN: optional, used only with devices that have no "
711 "display\n");
712 return -1;
713 }
714
Dmitry Shmidt61d9df32012-08-29 16:22:06 -0700715 return wpa_cli_cmd(ctrl, "WPS_PIN", 1, argc, argv);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700716}
717
718
719static int wpa_cli_cmd_wps_check_pin(struct wpa_ctrl *ctrl, int argc,
720 char *argv[])
721{
Dmitry Shmidt61d9df32012-08-29 16:22:06 -0700722 return wpa_cli_cmd(ctrl, "WPS_CHECK_PIN", 1, argc, argv);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700723}
724
725
726static int wpa_cli_cmd_wps_cancel(struct wpa_ctrl *ctrl, int argc,
727 char *argv[])
728{
729 return wpa_ctrl_command(ctrl, "WPS_CANCEL");
730}
731
732
Dmitry Shmidt04949592012-07-19 12:16:46 -0700733#ifdef CONFIG_WPS_NFC
734
735static int wpa_cli_cmd_wps_nfc(struct wpa_ctrl *ctrl, int argc, char *argv[])
736{
Dmitry Shmidt61d9df32012-08-29 16:22:06 -0700737 return wpa_cli_cmd(ctrl, "WPS_NFC", 0, argc, argv);
Dmitry Shmidt04949592012-07-19 12:16:46 -0700738}
739
740
Dmitry Shmidtf8623282013-02-20 14:34:59 -0800741static int wpa_cli_cmd_wps_nfc_config_token(struct wpa_ctrl *ctrl, int argc,
742 char *argv[])
743{
744 return wpa_cli_cmd(ctrl, "WPS_NFC_CONFIG_TOKEN", 1, argc, argv);
745}
746
747
Dmitry Shmidt04949592012-07-19 12:16:46 -0700748static int wpa_cli_cmd_wps_nfc_token(struct wpa_ctrl *ctrl, int argc,
749 char *argv[])
750{
Dmitry Shmidt61d9df32012-08-29 16:22:06 -0700751 return wpa_cli_cmd(ctrl, "WPS_NFC_TOKEN", 1, argc, argv);
Dmitry Shmidt04949592012-07-19 12:16:46 -0700752}
753
754
755static int wpa_cli_cmd_wps_nfc_tag_read(struct wpa_ctrl *ctrl, int argc,
756 char *argv[])
757{
758 int ret;
759 char *buf;
760 size_t buflen;
761
762 if (argc != 1) {
763 printf("Invalid 'wps_nfc_tag_read' command - one argument "
764 "is required.\n");
765 return -1;
766 }
767
768 buflen = 18 + os_strlen(argv[0]);
769 buf = os_malloc(buflen);
770 if (buf == NULL)
771 return -1;
772 os_snprintf(buf, buflen, "WPS_NFC_TAG_READ %s", argv[0]);
773
774 ret = wpa_ctrl_command(ctrl, buf);
775 os_free(buf);
776
777 return ret;
778}
779
Dmitry Shmidtd5e49232012-12-03 15:08:10 -0800780
781static int wpa_cli_cmd_nfc_get_handover_req(struct wpa_ctrl *ctrl, int argc,
782 char *argv[])
783{
784 return wpa_cli_cmd(ctrl, "NFC_GET_HANDOVER_REQ", 2, argc, argv);
785}
786
787
788static int wpa_cli_cmd_nfc_get_handover_sel(struct wpa_ctrl *ctrl, int argc,
789 char *argv[])
790{
791 return wpa_cli_cmd(ctrl, "NFC_GET_HANDOVER_SEL", 2, argc, argv);
792}
793
794
Dmitry Shmidtf8623282013-02-20 14:34:59 -0800795static int wpa_cli_cmd_nfc_report_handover(struct wpa_ctrl *ctrl, int argc,
796 char *argv[])
797{
798 return wpa_cli_cmd(ctrl, "NFC_REPORT_HANDOVER", 4, argc, argv);
799}
800
Dmitry Shmidt04949592012-07-19 12:16:46 -0700801#endif /* CONFIG_WPS_NFC */
802
803
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700804static int wpa_cli_cmd_wps_reg(struct wpa_ctrl *ctrl, int argc, char *argv[])
805{
806 char cmd[256];
807 int res;
808
809 if (argc == 2)
810 res = os_snprintf(cmd, sizeof(cmd), "WPS_REG %s %s",
811 argv[0], argv[1]);
812 else if (argc == 5 || argc == 6) {
Dmitry Shmidt9d9e6022015-04-23 10:34:55 -0700813 char ssid_hex[2 * SSID_MAX_LEN + 1];
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700814 char key_hex[2 * 64 + 1];
815 int i;
816
817 ssid_hex[0] = '\0';
Dmitry Shmidt9d9e6022015-04-23 10:34:55 -0700818 for (i = 0; i < SSID_MAX_LEN; i++) {
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700819 if (argv[2][i] == '\0')
820 break;
821 os_snprintf(&ssid_hex[i * 2], 3, "%02x", argv[2][i]);
822 }
823
824 key_hex[0] = '\0';
825 if (argc == 6) {
826 for (i = 0; i < 64; i++) {
827 if (argv[5][i] == '\0')
828 break;
829 os_snprintf(&key_hex[i * 2], 3, "%02x",
830 argv[5][i]);
831 }
832 }
833
834 res = os_snprintf(cmd, sizeof(cmd),
835 "WPS_REG %s %s %s %s %s %s",
836 argv[0], argv[1], ssid_hex, argv[3], argv[4],
837 key_hex);
838 } else {
839 printf("Invalid WPS_REG command: need two arguments:\n"
840 "- BSSID of the target AP\n"
841 "- AP PIN\n");
842 printf("Alternatively, six arguments can be used to "
843 "reconfigure the AP:\n"
844 "- BSSID of the target AP\n"
845 "- AP PIN\n"
846 "- new SSID\n"
847 "- new auth (OPEN, WPAPSK, WPA2PSK)\n"
848 "- new encr (NONE, WEP, TKIP, CCMP)\n"
849 "- new key\n");
850 return -1;
851 }
852
Dmitry Shmidt6c0da2b2015-01-05 13:08:17 -0800853 if (os_snprintf_error(sizeof(cmd), res)) {
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700854 printf("Too long WPS_REG command.\n");
855 return -1;
856 }
857 return wpa_ctrl_command(ctrl, cmd);
858}
859
860
861static int wpa_cli_cmd_wps_ap_pin(struct wpa_ctrl *ctrl, int argc,
862 char *argv[])
863{
Dmitry Shmidt61d9df32012-08-29 16:22:06 -0700864 return wpa_cli_cmd(ctrl, "WPS_AP_PIN", 1, argc, argv);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700865}
866
867
868static int wpa_cli_cmd_wps_er_start(struct wpa_ctrl *ctrl, int argc,
869 char *argv[])
870{
Dmitry Shmidt61d9df32012-08-29 16:22:06 -0700871 return wpa_cli_cmd(ctrl, "WPS_ER_START", 0, argc, argv);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700872}
873
874
875static int wpa_cli_cmd_wps_er_stop(struct wpa_ctrl *ctrl, int argc,
876 char *argv[])
877{
878 return wpa_ctrl_command(ctrl, "WPS_ER_STOP");
879
880}
881
882
883static int wpa_cli_cmd_wps_er_pin(struct wpa_ctrl *ctrl, int argc,
884 char *argv[])
885{
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700886 if (argc < 2) {
887 printf("Invalid WPS_ER_PIN command: need at least two "
888 "arguments:\n"
889 "- UUID: use 'any' to select any\n"
890 "- PIN: Enrollee PIN\n"
891 "optional: - Enrollee MAC address\n");
892 return -1;
893 }
894
Dmitry Shmidt61d9df32012-08-29 16:22:06 -0700895 return wpa_cli_cmd(ctrl, "WPS_ER_PIN", 2, argc, argv);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700896}
897
898
899static int wpa_cli_cmd_wps_er_pbc(struct wpa_ctrl *ctrl, int argc,
900 char *argv[])
901{
Dmitry Shmidt61d9df32012-08-29 16:22:06 -0700902 return wpa_cli_cmd(ctrl, "WPS_ER_PBC", 1, argc, argv);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700903}
904
905
906static int wpa_cli_cmd_wps_er_learn(struct wpa_ctrl *ctrl, int argc,
907 char *argv[])
908{
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700909 if (argc != 2) {
910 printf("Invalid WPS_ER_LEARN command: need two arguments:\n"
911 "- UUID: specify which AP to use\n"
912 "- PIN: AP PIN\n");
913 return -1;
914 }
915
Dmitry Shmidt61d9df32012-08-29 16:22:06 -0700916 return wpa_cli_cmd(ctrl, "WPS_ER_LEARN", 2, argc, argv);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700917}
918
919
920static int wpa_cli_cmd_wps_er_set_config(struct wpa_ctrl *ctrl, int argc,
921 char *argv[])
922{
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700923 if (argc != 2) {
924 printf("Invalid WPS_ER_SET_CONFIG command: need two "
925 "arguments:\n"
926 "- UUID: specify which AP to use\n"
927 "- Network configuration id\n");
928 return -1;
929 }
930
Dmitry Shmidt61d9df32012-08-29 16:22:06 -0700931 return wpa_cli_cmd(ctrl, "WPS_ER_SET_CONFIG", 2, argc, argv);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700932}
933
934
935static int wpa_cli_cmd_wps_er_config(struct wpa_ctrl *ctrl, int argc,
936 char *argv[])
937{
938 char cmd[256];
939 int res;
940
941 if (argc == 5 || argc == 6) {
Dmitry Shmidt9d9e6022015-04-23 10:34:55 -0700942 char ssid_hex[2 * SSID_MAX_LEN + 1];
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700943 char key_hex[2 * 64 + 1];
944 int i;
945
946 ssid_hex[0] = '\0';
Dmitry Shmidt9d9e6022015-04-23 10:34:55 -0700947 for (i = 0; i < SSID_MAX_LEN; i++) {
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700948 if (argv[2][i] == '\0')
949 break;
950 os_snprintf(&ssid_hex[i * 2], 3, "%02x", argv[2][i]);
951 }
952
953 key_hex[0] = '\0';
954 if (argc == 6) {
955 for (i = 0; i < 64; i++) {
956 if (argv[5][i] == '\0')
957 break;
958 os_snprintf(&key_hex[i * 2], 3, "%02x",
959 argv[5][i]);
960 }
961 }
962
963 res = os_snprintf(cmd, sizeof(cmd),
964 "WPS_ER_CONFIG %s %s %s %s %s %s",
965 argv[0], argv[1], ssid_hex, argv[3], argv[4],
966 key_hex);
967 } else {
968 printf("Invalid WPS_ER_CONFIG command: need six arguments:\n"
969 "- AP UUID\n"
970 "- AP PIN\n"
971 "- new SSID\n"
972 "- new auth (OPEN, WPAPSK, WPA2PSK)\n"
973 "- new encr (NONE, WEP, TKIP, CCMP)\n"
974 "- new key\n");
975 return -1;
976 }
977
Dmitry Shmidt6c0da2b2015-01-05 13:08:17 -0800978 if (os_snprintf_error(sizeof(cmd), res)) {
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700979 printf("Too long WPS_ER_CONFIG command.\n");
980 return -1;
981 }
982 return wpa_ctrl_command(ctrl, cmd);
983}
984
985
Dmitry Shmidt04949592012-07-19 12:16:46 -0700986#ifdef CONFIG_WPS_NFC
987static int wpa_cli_cmd_wps_er_nfc_config_token(struct wpa_ctrl *ctrl, int argc,
988 char *argv[])
989{
Dmitry Shmidt04949592012-07-19 12:16:46 -0700990 if (argc != 2) {
991 printf("Invalid WPS_ER_NFC_CONFIG_TOKEN command: need two "
992 "arguments:\n"
993 "- WPS/NDEF: token format\n"
994 "- UUID: specify which AP to use\n");
995 return -1;
996 }
997
Dmitry Shmidt61d9df32012-08-29 16:22:06 -0700998 return wpa_cli_cmd(ctrl, "WPS_ER_NFC_CONFIG_TOKEN", 2, argc, argv);
Dmitry Shmidt04949592012-07-19 12:16:46 -0700999}
1000#endif /* CONFIG_WPS_NFC */
1001
1002
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001003static int wpa_cli_cmd_ibss_rsn(struct wpa_ctrl *ctrl, int argc, char *argv[])
1004{
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07001005 return wpa_cli_cmd(ctrl, "IBSS_RSN", 1, argc, argv);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001006}
1007
1008
1009static int wpa_cli_cmd_level(struct wpa_ctrl *ctrl, int argc, char *argv[])
1010{
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07001011 return wpa_cli_cmd(ctrl, "LEVEL", 1, argc, argv);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001012}
1013
1014
1015static int wpa_cli_cmd_identity(struct wpa_ctrl *ctrl, int argc, char *argv[])
1016{
1017 char cmd[256], *pos, *end;
1018 int i, ret;
1019
1020 if (argc < 2) {
1021 printf("Invalid IDENTITY command: needs two arguments "
1022 "(network id and identity)\n");
1023 return -1;
1024 }
1025
1026 end = cmd + sizeof(cmd);
1027 pos = cmd;
1028 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "IDENTITY-%s:%s",
1029 argv[0], argv[1]);
Dmitry Shmidt6c0da2b2015-01-05 13:08:17 -08001030 if (os_snprintf_error(end - pos, ret)) {
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001031 printf("Too long IDENTITY command.\n");
1032 return -1;
1033 }
1034 pos += ret;
1035 for (i = 2; i < argc; i++) {
1036 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
Dmitry Shmidt6c0da2b2015-01-05 13:08:17 -08001037 if (os_snprintf_error(end - pos, ret)) {
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001038 printf("Too long IDENTITY command.\n");
1039 return -1;
1040 }
1041 pos += ret;
1042 }
1043
1044 return wpa_ctrl_command(ctrl, cmd);
1045}
1046
1047
1048static int wpa_cli_cmd_password(struct wpa_ctrl *ctrl, int argc, char *argv[])
1049{
1050 char cmd[256], *pos, *end;
1051 int i, ret;
1052
1053 if (argc < 2) {
1054 printf("Invalid PASSWORD command: needs two arguments "
1055 "(network id and password)\n");
1056 return -1;
1057 }
1058
1059 end = cmd + sizeof(cmd);
1060 pos = cmd;
1061 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "PASSWORD-%s:%s",
1062 argv[0], argv[1]);
Dmitry Shmidt6c0da2b2015-01-05 13:08:17 -08001063 if (os_snprintf_error(end - pos, ret)) {
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001064 printf("Too long PASSWORD command.\n");
1065 return -1;
1066 }
1067 pos += ret;
1068 for (i = 2; i < argc; i++) {
1069 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
Dmitry Shmidt6c0da2b2015-01-05 13:08:17 -08001070 if (os_snprintf_error(end - pos, ret)) {
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001071 printf("Too long PASSWORD command.\n");
1072 return -1;
1073 }
1074 pos += ret;
1075 }
1076
1077 return wpa_ctrl_command(ctrl, cmd);
1078}
1079
1080
1081static int wpa_cli_cmd_new_password(struct wpa_ctrl *ctrl, int argc,
1082 char *argv[])
1083{
1084 char cmd[256], *pos, *end;
1085 int i, ret;
1086
1087 if (argc < 2) {
1088 printf("Invalid NEW_PASSWORD command: needs two arguments "
1089 "(network id and password)\n");
1090 return -1;
1091 }
1092
1093 end = cmd + sizeof(cmd);
1094 pos = cmd;
1095 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "NEW_PASSWORD-%s:%s",
1096 argv[0], argv[1]);
Dmitry Shmidt6c0da2b2015-01-05 13:08:17 -08001097 if (os_snprintf_error(end - pos, ret)) {
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001098 printf("Too long NEW_PASSWORD command.\n");
1099 return -1;
1100 }
1101 pos += ret;
1102 for (i = 2; i < argc; i++) {
1103 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
Dmitry Shmidt6c0da2b2015-01-05 13:08:17 -08001104 if (os_snprintf_error(end - pos, ret)) {
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001105 printf("Too long NEW_PASSWORD command.\n");
1106 return -1;
1107 }
1108 pos += ret;
1109 }
1110
1111 return wpa_ctrl_command(ctrl, cmd);
1112}
1113
1114
1115static int wpa_cli_cmd_pin(struct wpa_ctrl *ctrl, int argc, char *argv[])
1116{
1117 char cmd[256], *pos, *end;
1118 int i, ret;
1119
1120 if (argc < 2) {
1121 printf("Invalid PIN command: needs two arguments "
1122 "(network id and pin)\n");
1123 return -1;
1124 }
1125
1126 end = cmd + sizeof(cmd);
1127 pos = cmd;
1128 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "PIN-%s:%s",
1129 argv[0], argv[1]);
Dmitry Shmidt6c0da2b2015-01-05 13:08:17 -08001130 if (os_snprintf_error(end - pos, ret)) {
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001131 printf("Too long PIN command.\n");
1132 return -1;
1133 }
1134 pos += ret;
1135 for (i = 2; i < argc; i++) {
1136 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
Dmitry Shmidt6c0da2b2015-01-05 13:08:17 -08001137 if (os_snprintf_error(end - pos, ret)) {
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001138 printf("Too long PIN command.\n");
1139 return -1;
1140 }
1141 pos += ret;
1142 }
1143 return wpa_ctrl_command(ctrl, cmd);
1144}
1145
1146
1147static int wpa_cli_cmd_otp(struct wpa_ctrl *ctrl, int argc, char *argv[])
1148{
1149 char cmd[256], *pos, *end;
1150 int i, ret;
1151
1152 if (argc < 2) {
1153 printf("Invalid OTP command: needs two arguments (network "
1154 "id and password)\n");
1155 return -1;
1156 }
1157
1158 end = cmd + sizeof(cmd);
1159 pos = cmd;
1160 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "OTP-%s:%s",
1161 argv[0], argv[1]);
Dmitry Shmidt6c0da2b2015-01-05 13:08:17 -08001162 if (os_snprintf_error(end - pos, ret)) {
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001163 printf("Too long OTP command.\n");
1164 return -1;
1165 }
1166 pos += ret;
1167 for (i = 2; i < argc; i++) {
1168 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
Dmitry Shmidt6c0da2b2015-01-05 13:08:17 -08001169 if (os_snprintf_error(end - pos, ret)) {
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001170 printf("Too long OTP command.\n");
1171 return -1;
1172 }
1173 pos += ret;
1174 }
1175
1176 return wpa_ctrl_command(ctrl, cmd);
1177}
1178
1179
Dmitry Shmidt051af732013-10-22 13:52:46 -07001180static int wpa_cli_cmd_sim(struct wpa_ctrl *ctrl, int argc, char *argv[])
1181{
1182 char cmd[256], *pos, *end;
1183 int i, ret;
1184
1185 if (argc < 2) {
1186 printf("Invalid SIM command: needs two arguments "
1187 "(network id and SIM operation response)\n");
1188 return -1;
1189 }
1190
1191 end = cmd + sizeof(cmd);
1192 pos = cmd;
1193 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "SIM-%s:%s",
1194 argv[0], argv[1]);
Dmitry Shmidt6c0da2b2015-01-05 13:08:17 -08001195 if (os_snprintf_error(end - pos, ret)) {
Dmitry Shmidt051af732013-10-22 13:52:46 -07001196 printf("Too long SIM command.\n");
1197 return -1;
1198 }
1199 pos += ret;
1200 for (i = 2; i < argc; i++) {
1201 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
Dmitry Shmidt6c0da2b2015-01-05 13:08:17 -08001202 if (os_snprintf_error(end - pos, ret)) {
Dmitry Shmidt051af732013-10-22 13:52:46 -07001203 printf("Too long SIM command.\n");
1204 return -1;
1205 }
1206 pos += ret;
1207 }
1208 return wpa_ctrl_command(ctrl, cmd);
1209}
1210
1211
Hai Shalom74f70d42019-02-11 14:42:39 -08001212static int wpa_cli_cmd_psk_passphrase(struct wpa_ctrl *ctrl, int argc,
1213 char *argv[])
1214{
1215 char cmd[256], *pos, *end;
1216 int i, ret;
1217
1218 if (argc < 2) {
1219 printf("Invalid PSK_PASSPHRASE command: needs two arguments (network id and PSK/passphrase)\n");
1220 return -1;
1221 }
1222
1223 end = cmd + sizeof(cmd);
1224 pos = cmd;
1225 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "PSK_PASSPHRASE-%s:%s",
1226 argv[0], argv[1]);
1227 if (os_snprintf_error(end - pos, ret)) {
1228 printf("Too long PSK_PASSPHRASE command.\n");
1229 return -1;
1230 }
1231 pos += ret;
1232 for (i = 2; i < argc; i++) {
1233 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
1234 if (os_snprintf_error(end - pos, ret)) {
1235 printf("Too long PSK_PASSPHRASE command.\n");
1236 return -1;
1237 }
1238 pos += ret;
1239 }
1240
1241 return wpa_ctrl_command(ctrl, cmd);
1242}
1243
1244
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001245static int wpa_cli_cmd_passphrase(struct wpa_ctrl *ctrl, int argc,
1246 char *argv[])
1247{
1248 char cmd[256], *pos, *end;
1249 int i, ret;
1250
1251 if (argc < 2) {
1252 printf("Invalid PASSPHRASE command: needs two arguments "
1253 "(network id and passphrase)\n");
1254 return -1;
1255 }
1256
1257 end = cmd + sizeof(cmd);
1258 pos = cmd;
1259 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "PASSPHRASE-%s:%s",
1260 argv[0], argv[1]);
Dmitry Shmidt6c0da2b2015-01-05 13:08:17 -08001261 if (os_snprintf_error(end - pos, ret)) {
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001262 printf("Too long PASSPHRASE command.\n");
1263 return -1;
1264 }
1265 pos += ret;
1266 for (i = 2; i < argc; i++) {
1267 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
Dmitry Shmidt6c0da2b2015-01-05 13:08:17 -08001268 if (os_snprintf_error(end - pos, ret)) {
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001269 printf("Too long PASSPHRASE command.\n");
1270 return -1;
1271 }
1272 pos += ret;
1273 }
1274
1275 return wpa_ctrl_command(ctrl, cmd);
1276}
1277
1278
1279static int wpa_cli_cmd_bssid(struct wpa_ctrl *ctrl, int argc, char *argv[])
1280{
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001281 if (argc < 2) {
1282 printf("Invalid BSSID command: needs two arguments (network "
1283 "id and BSSID)\n");
1284 return -1;
1285 }
1286
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07001287 return wpa_cli_cmd(ctrl, "BSSID", 2, argc, argv);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001288}
1289
1290
Dmitry Shmidt696359e2011-03-16 15:04:31 -07001291static int wpa_cli_cmd_blacklist(struct wpa_ctrl *ctrl, int argc, char *argv[])
1292{
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07001293 return wpa_cli_cmd(ctrl, "BLACKLIST", 0, argc, argv);
Dmitry Shmidt696359e2011-03-16 15:04:31 -07001294}
1295
1296
1297static int wpa_cli_cmd_log_level(struct wpa_ctrl *ctrl, int argc, char *argv[])
1298{
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07001299 return wpa_cli_cmd(ctrl, "LOG_LEVEL", 0, argc, argv);
Dmitry Shmidt696359e2011-03-16 15:04:31 -07001300}
1301
1302
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001303static int wpa_cli_cmd_list_networks(struct wpa_ctrl *ctrl, int argc,
1304 char *argv[])
1305{
Hai Shalomfdcde762020-04-02 11:19:20 -07001306 return wpa_cli_cmd(ctrl, "LIST_NETWORKS", 0, argc, argv);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001307}
1308
1309
1310static int wpa_cli_cmd_select_network(struct wpa_ctrl *ctrl, int argc,
1311 char *argv[])
1312{
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07001313 return wpa_cli_cmd(ctrl, "SELECT_NETWORK", 1, argc, argv);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001314}
1315
1316
1317static int wpa_cli_cmd_enable_network(struct wpa_ctrl *ctrl, int argc,
1318 char *argv[])
1319{
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07001320 return wpa_cli_cmd(ctrl, "ENABLE_NETWORK", 1, argc, argv);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001321}
1322
1323
1324static int wpa_cli_cmd_disable_network(struct wpa_ctrl *ctrl, int argc,
1325 char *argv[])
1326{
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07001327 return wpa_cli_cmd(ctrl, "DISABLE_NETWORK", 1, argc, argv);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001328}
1329
1330
1331static int wpa_cli_cmd_add_network(struct wpa_ctrl *ctrl, int argc,
1332 char *argv[])
1333{
Dmitry Shmidt912c6ec2015-03-30 13:16:51 -07001334 int res = wpa_ctrl_command(ctrl, "ADD_NETWORK");
Dmitry Shmidtcc00d5d2015-05-04 10:34:12 -07001335 if (interactive)
1336 update_networks(ctrl);
Dmitry Shmidt912c6ec2015-03-30 13:16:51 -07001337 return res;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001338}
1339
1340
1341static int wpa_cli_cmd_remove_network(struct wpa_ctrl *ctrl, int argc,
1342 char *argv[])
1343{
Dmitry Shmidt912c6ec2015-03-30 13:16:51 -07001344 int res = wpa_cli_cmd(ctrl, "REMOVE_NETWORK", 1, argc, argv);
Dmitry Shmidtcc00d5d2015-05-04 10:34:12 -07001345 if (interactive)
1346 update_networks(ctrl);
Dmitry Shmidt912c6ec2015-03-30 13:16:51 -07001347 return res;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001348}
1349
1350
1351static void wpa_cli_show_network_variables(void)
1352{
1353 printf("set_network variables:\n"
1354 " ssid (network name, SSID)\n"
1355 " psk (WPA passphrase or pre-shared key)\n"
1356 " key_mgmt (key management protocol)\n"
1357 " identity (EAP identity)\n"
1358 " password (EAP password)\n"
1359 " ...\n"
1360 "\n"
1361 "Note: Values are entered in the same format as the "
1362 "configuration file is using,\n"
1363 "i.e., strings values need to be inside double quotation "
1364 "marks.\n"
1365 "For example: set_network 1 ssid \"network name\"\n"
1366 "\n"
1367 "Please see wpa_supplicant.conf documentation for full list "
1368 "of\navailable variables.\n");
1369}
1370
1371
1372static int wpa_cli_cmd_set_network(struct wpa_ctrl *ctrl, int argc,
1373 char *argv[])
1374{
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001375 if (argc == 0) {
1376 wpa_cli_show_network_variables();
1377 return 0;
1378 }
1379
Dmitry Shmidtd5e49232012-12-03 15:08:10 -08001380 if (argc < 3) {
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001381 printf("Invalid SET_NETWORK command: needs three arguments\n"
1382 "(network id, variable name, and value)\n");
1383 return -1;
1384 }
1385
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07001386 return wpa_cli_cmd(ctrl, "SET_NETWORK", 3, argc, argv);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001387}
1388
1389
1390static int wpa_cli_cmd_get_network(struct wpa_ctrl *ctrl, int argc,
1391 char *argv[])
1392{
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001393 if (argc == 0) {
1394 wpa_cli_show_network_variables();
1395 return 0;
1396 }
1397
1398 if (argc != 2) {
1399 printf("Invalid GET_NETWORK command: needs two arguments\n"
1400 "(network id and variable name)\n");
1401 return -1;
1402 }
1403
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07001404 return wpa_cli_cmd(ctrl, "GET_NETWORK", 2, argc, argv);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001405}
1406
1407
Dmitry Shmidt912c6ec2015-03-30 13:16:51 -07001408static const char *network_fields[] = {
1409 "ssid", "scan_ssid", "bssid", "bssid_blacklist",
1410 "bssid_whitelist", "psk", "proto", "key_mgmt",
1411 "bg_scan_period", "pairwise", "group", "auth_alg", "scan_freq",
Dmitry Shmidtd2986c22017-10-23 14:22:09 -07001412 "freq_list", "max_oper_chwidth", "ht40", "vht", "vht_center_freq1",
Ahmed ElArabawy0ff61c52019-12-26 12:38:39 -08001413 "vht_center_freq2", "ht", "edmg",
Dmitry Shmidt912c6ec2015-03-30 13:16:51 -07001414#ifdef IEEE8021X_EAPOL
1415 "eap", "identity", "anonymous_identity", "password", "ca_cert",
1416 "ca_path", "client_cert", "private_key", "private_key_passwd",
1417 "dh_file", "subject_match", "altsubject_match",
Hai Shalom021b0b52019-04-10 11:17:58 -07001418 "check_cert_subject",
Dmitry Shmidt912c6ec2015-03-30 13:16:51 -07001419 "domain_suffix_match", "domain_match", "ca_cert2", "ca_path2",
1420 "client_cert2", "private_key2", "private_key2_passwd",
1421 "dh_file2", "subject_match2", "altsubject_match2",
Hai Shalom021b0b52019-04-10 11:17:58 -07001422 "check_cert_subject2",
Dmitry Shmidt912c6ec2015-03-30 13:16:51 -07001423 "domain_suffix_match2", "domain_match2", "phase1", "phase2",
1424 "pcsc", "pin", "engine_id", "key_id", "cert_id", "ca_cert_id",
1425 "pin2", "engine2_id", "key2_id", "cert2_id", "ca_cert2_id",
1426 "engine", "engine2", "eapol_flags", "sim_num",
1427 "openssl_ciphers", "erp",
1428#endif /* IEEE8021X_EAPOL */
1429 "wep_key0", "wep_key1", "wep_key2", "wep_key3",
1430 "wep_tx_keyidx", "priority",
1431#ifdef IEEE8021X_EAPOL
1432 "eap_workaround", "pac_file", "fragment_size", "ocsp",
1433#endif /* IEEE8021X_EAPOL */
Dmitry Shmidt912c6ec2015-03-30 13:16:51 -07001434 "mode",
Dmitry Shmidt912c6ec2015-03-30 13:16:51 -07001435 "proactive_key_caching", "disabled", "id_str",
Dmitry Shmidt912c6ec2015-03-30 13:16:51 -07001436 "ieee80211w",
Dmitry Shmidtd2986c22017-10-23 14:22:09 -07001437 "mixed_cell", "frequency", "fixed_freq",
Dmitry Shmidt912c6ec2015-03-30 13:16:51 -07001438#ifdef CONFIG_MESH
Hai Shalomc3565922019-10-28 11:58:20 -07001439 "no_auto_peer", "mesh_rssi_threshold",
Dmitry Shmidt912c6ec2015-03-30 13:16:51 -07001440 "mesh_basic_rates", "dot11MeshMaxRetries",
1441 "dot11MeshRetryTimeout", "dot11MeshConfirmTimeout",
1442 "dot11MeshHoldingTimeout",
1443#endif /* CONFIG_MESH */
1444 "wpa_ptk_rekey", "bgscan", "ignore_broadcast_ssid",
Hai Shalomfdcde762020-04-02 11:19:20 -07001445 "wpa_deny_ptk0_rekey",
Hai Shalomc3565922019-10-28 11:58:20 -07001446 "enable_edmg", "edmg_channel",
Dmitry Shmidt912c6ec2015-03-30 13:16:51 -07001447#ifdef CONFIG_P2P
1448 "go_p2p_dev_addr", "p2p_client_list", "psk_list",
1449#endif /* CONFIG_P2P */
1450#ifdef CONFIG_HT_OVERRIDES
1451 "disable_ht", "disable_ht40", "disable_sgi", "disable_ldpc",
1452 "ht40_intolerant", "disable_max_amsdu", "ampdu_factor",
Hai Shalom74f70d42019-02-11 14:42:39 -08001453 "ampdu_density", "ht_mcs", "rx_stbc", "tx_stbc",
Dmitry Shmidt912c6ec2015-03-30 13:16:51 -07001454#endif /* CONFIG_HT_OVERRIDES */
1455#ifdef CONFIG_VHT_OVERRIDES
1456 "disable_vht", "vht_capa", "vht_capa_mask", "vht_rx_mcs_nss_1",
1457 "vht_rx_mcs_nss_2", "vht_rx_mcs_nss_3", "vht_rx_mcs_nss_4",
1458 "vht_rx_mcs_nss_5", "vht_rx_mcs_nss_6", "vht_rx_mcs_nss_7",
1459 "vht_rx_mcs_nss_8", "vht_tx_mcs_nss_1", "vht_tx_mcs_nss_2",
1460 "vht_tx_mcs_nss_3", "vht_tx_mcs_nss_4", "vht_tx_mcs_nss_5",
1461 "vht_tx_mcs_nss_6", "vht_tx_mcs_nss_7", "vht_tx_mcs_nss_8",
1462#endif /* CONFIG_VHT_OVERRIDES */
Hai Shalomfdcde762020-04-02 11:19:20 -07001463#ifdef CONFIG_HE_OVERRIDES
1464 "disable_he",
1465#endif /* CONFIG_HE_OVERRIDES */
Dmitry Shmidt912c6ec2015-03-30 13:16:51 -07001466 "ap_max_inactivity", "dtim_period", "beacon_int",
1467#ifdef CONFIG_MACSEC
1468 "macsec_policy",
Dmitry Shmidtabb90a32016-12-05 15:34:39 -08001469 "macsec_integ_only",
Hai Shalom74f70d42019-02-11 14:42:39 -08001470 "macsec_replay_protect",
1471 "macsec_replay_window",
Dmitry Shmidtabb90a32016-12-05 15:34:39 -08001472 "macsec_port",
Dmitry Shmidt29333592017-01-09 12:27:11 -08001473 "mka_priority",
Dmitry Shmidt912c6ec2015-03-30 13:16:51 -07001474#endif /* CONFIG_MACSEC */
1475#ifdef CONFIG_HS20
1476 "update_identifier",
1477#endif /* CONFIG_HS20 */
Dmitry Shmidt849734c2016-05-27 09:59:01 -07001478 "mac_addr", "pbss", "wps_disabled"
Dmitry Shmidt912c6ec2015-03-30 13:16:51 -07001479};
1480
1481
1482static char ** wpa_cli_complete_network(const char *str, int pos)
1483{
1484 int arg = get_cmd_arg_num(str, pos);
1485 int i, num_fields = ARRAY_SIZE(network_fields);
1486 char **res = NULL;
1487
1488 switch (arg) {
1489 case 1:
1490 res = cli_txt_list_array(&networks);
1491 break;
1492 case 2:
1493 res = os_calloc(num_fields + 1, sizeof(char *));
1494 if (res == NULL)
1495 return NULL;
1496 for (i = 0; i < num_fields; i++) {
1497 res[i] = os_strdup(network_fields[i]);
1498 if (res[i] == NULL)
1499 break;
1500 }
1501 }
1502 return res;
1503}
1504
1505
1506static char ** wpa_cli_complete_network_id(const char *str, int pos)
1507{
1508 int arg = get_cmd_arg_num(str, pos);
1509 if (arg == 1)
1510 return cli_txt_list_array(&networks);
1511 return NULL;
1512}
1513
1514
Dmitry Shmidt684785c2014-05-12 13:34:29 -07001515static int wpa_cli_cmd_dup_network(struct wpa_ctrl *ctrl, int argc,
1516 char *argv[])
1517{
1518 if (argc == 0) {
1519 wpa_cli_show_network_variables();
1520 return 0;
1521 }
1522
1523 if (argc < 3) {
1524 printf("Invalid DUP_NETWORK command: needs three arguments\n"
1525 "(src netid, dest netid, and variable name)\n");
1526 return -1;
1527 }
1528
1529 return wpa_cli_cmd(ctrl, "DUP_NETWORK", 3, argc, argv);
1530}
1531
1532
Dmitry Shmidt912c6ec2015-03-30 13:16:51 -07001533static char ** wpa_cli_complete_dup_network(const char *str, int pos)
1534{
1535 int arg = get_cmd_arg_num(str, pos);
1536 int i, num_fields = ARRAY_SIZE(network_fields);
1537 char **res = NULL;
1538
1539 switch (arg) {
1540 case 1:
1541 case 2:
1542 res = cli_txt_list_array(&networks);
1543 break;
1544 case 3:
1545 res = os_calloc(num_fields + 1, sizeof(char *));
1546 if (res == NULL)
1547 return NULL;
1548 for (i = 0; i < num_fields; i++) {
1549 res[i] = os_strdup(network_fields[i]);
1550 if (res[i] == NULL)
1551 break;
1552 }
1553 }
1554 return res;
1555}
1556
1557
Dmitry Shmidt04949592012-07-19 12:16:46 -07001558static int wpa_cli_cmd_list_creds(struct wpa_ctrl *ctrl, int argc,
1559 char *argv[])
1560{
1561 return wpa_ctrl_command(ctrl, "LIST_CREDS");
1562}
1563
1564
1565static int wpa_cli_cmd_add_cred(struct wpa_ctrl *ctrl, int argc, char *argv[])
1566{
Roshan Pius3a1667e2018-07-03 15:17:14 -07001567 int res = wpa_ctrl_command(ctrl, "ADD_CRED");
1568 if (interactive)
1569 update_creds(ctrl);
1570 return res;
Dmitry Shmidt04949592012-07-19 12:16:46 -07001571}
1572
1573
1574static int wpa_cli_cmd_remove_cred(struct wpa_ctrl *ctrl, int argc,
1575 char *argv[])
1576{
Roshan Pius3a1667e2018-07-03 15:17:14 -07001577 int res = wpa_cli_cmd(ctrl, "REMOVE_CRED", 1, argc, argv);
1578 if (interactive)
1579 update_creds(ctrl);
1580 return res;
1581}
1582
1583
1584static const char * const cred_fields[] = {
1585 "temporary", "priority", "sp_priority", "pcsc", "eap",
1586 "update_identifier", "min_dl_bandwidth_home", "min_ul_bandwidth_home",
1587 "min_dl_bandwidth_roaming", "min_ul_bandwidth_roaming", "max_bss_load",
1588 "req_conn_capab", "ocsp", "sim_num", "realm", "username", "password",
1589 "ca_cert", "client_cert", "private_key", "private_key_passwd", "imsi",
1590 "milenage", "domain_suffix_match", "domain", "phase1", "phase2",
1591 "roaming_consortium", "required_roaming_consortium", "excluded_ssid",
1592 "roaming_partner", "provisioning_sp"
1593};
1594
1595
1596static char ** wpa_cli_complete_cred(const char *str, int pos)
1597{
1598 int arg = get_cmd_arg_num(str, pos);
1599 int i, num_fields = ARRAY_SIZE(cred_fields);
1600 char **res = NULL;
1601
1602 switch (arg) {
1603 case 1:
1604 res = cli_txt_list_array(&creds);
1605 break;
1606 case 2:
1607 res = os_calloc(num_fields + 1, sizeof(char *));
1608 if (res == NULL)
1609 return NULL;
1610 for (i = 0; i < num_fields; i++) {
1611 res[i] = os_strdup(cred_fields[i]);
1612 if (res[i] == NULL)
1613 break;
1614 }
1615 }
1616 return res;
Dmitry Shmidt04949592012-07-19 12:16:46 -07001617}
1618
1619
1620static int wpa_cli_cmd_set_cred(struct wpa_ctrl *ctrl, int argc, char *argv[])
1621{
Dmitry Shmidt04949592012-07-19 12:16:46 -07001622 if (argc != 3) {
1623 printf("Invalid SET_CRED command: needs three arguments\n"
1624 "(cred id, variable name, and value)\n");
1625 return -1;
1626 }
1627
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07001628 return wpa_cli_cmd(ctrl, "SET_CRED", 3, argc, argv);
Dmitry Shmidt04949592012-07-19 12:16:46 -07001629}
1630
1631
Dmitry Shmidt0cfd5f72014-04-04 14:48:05 -07001632static int wpa_cli_cmd_get_cred(struct wpa_ctrl *ctrl, int argc, char *argv[])
1633{
1634 if (argc != 2) {
1635 printf("Invalid GET_CRED command: needs two arguments\n"
1636 "(cred id, variable name)\n");
1637 return -1;
1638 }
1639
1640 return wpa_cli_cmd(ctrl, "GET_CRED", 2, argc, argv);
1641}
1642
1643
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001644static int wpa_cli_cmd_disconnect(struct wpa_ctrl *ctrl, int argc,
1645 char *argv[])
1646{
1647 return wpa_ctrl_command(ctrl, "DISCONNECT");
1648}
1649
1650
1651static int wpa_cli_cmd_reconnect(struct wpa_ctrl *ctrl, int argc,
1652 char *argv[])
1653{
1654 return wpa_ctrl_command(ctrl, "RECONNECT");
1655}
1656
1657
1658static int wpa_cli_cmd_save_config(struct wpa_ctrl *ctrl, int argc,
1659 char *argv[])
1660{
1661 return wpa_ctrl_command(ctrl, "SAVE_CONFIG");
1662}
1663
1664
1665static int wpa_cli_cmd_scan(struct wpa_ctrl *ctrl, int argc, char *argv[])
1666{
Dmitry Shmidt4b9d52f2013-02-05 17:44:43 -08001667 return wpa_cli_cmd(ctrl, "SCAN", 0, argc, argv);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001668}
1669
1670
1671static int wpa_cli_cmd_scan_results(struct wpa_ctrl *ctrl, int argc,
1672 char *argv[])
1673{
1674 return wpa_ctrl_command(ctrl, "SCAN_RESULTS");
1675}
1676
1677
Dmitry Shmidtd7ff03d2015-12-04 14:49:35 -08001678static int wpa_cli_cmd_abort_scan(struct wpa_ctrl *ctrl, int argc,
1679 char *argv[])
1680{
1681 return wpa_ctrl_command(ctrl, "ABORT_SCAN");
1682}
1683
1684
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001685static int wpa_cli_cmd_bss(struct wpa_ctrl *ctrl, int argc, char *argv[])
1686{
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07001687 return wpa_cli_cmd(ctrl, "BSS", 1, argc, argv);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001688}
1689
1690
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08001691static char ** wpa_cli_complete_bss(const char *str, int pos)
1692{
1693 int arg = get_cmd_arg_num(str, pos);
1694 char **res = NULL;
1695
1696 switch (arg) {
1697 case 1:
1698 res = cli_txt_list_array(&bsses);
1699 break;
1700 }
1701
1702 return res;
1703}
1704
1705
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001706static int wpa_cli_cmd_get_capability(struct wpa_ctrl *ctrl, int argc,
1707 char *argv[])
1708{
Hai Shalom4fbc08f2020-05-18 12:37:00 -07001709 if (argc < 1 || argc > 3) {
1710 printf("Invalid GET_CAPABILITY command: need at least one argument and max three arguments\n");
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001711 return -1;
1712 }
1713
Hai Shalom4fbc08f2020-05-18 12:37:00 -07001714 if (argc > 1 && os_strcmp(argv[0], "key_mgmt") != 0 &&
1715 os_strncmp(argv[1], "iftype=", 7) == 0) {
1716 printf("Invalid GET_CAPABILITY command: 'iftype=' param is allowed only for 'key_mgmt'\n");
1717 return -1;
1718 }
1719
1720 if (argc == 2 && os_strcmp(argv[1], "strict") != 0 &&
1721 os_strncmp(argv[1], "iftype=", 7) != 0) {
1722 printf("Invalid GET_CAPABILITY command: the second argument, if any, must be 'strict' OR 'iftype=<iftype_name>'\n");
1723 return -1;
1724 }
1725
1726 if (argc == 3 && os_strcmp(argv[2], "strict") != 0) {
1727 printf("Invalid GET_CAPABILITY command: the third argument, if any, must be 'strict'\n");
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001728 return -1;
1729 }
1730
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07001731 return wpa_cli_cmd(ctrl, "GET_CAPABILITY", 1, argc, argv);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001732}
1733
1734
Dmitry Shmidt7f2c7532016-08-15 09:48:12 -07001735static char ** wpa_cli_complete_get_capability(const char *str, int pos)
1736{
1737 int arg = get_cmd_arg_num(str, pos);
1738 const char *fields[] = {
1739 "eap", "pairwise", "group", "group_mgmt", "key_mgmt",
1740 "proto", "auth_alg", "modes", "channels", "freq",
1741#ifdef CONFIG_TDLS
1742 "tdls",
1743#endif /* CONFIG_TDLS */
1744#ifdef CONFIG_ERP
1745 "erp",
1746#endif /* CONFIG_ERP */
1747#ifdef CONFIG_FIPS
1748 "fips",
1749#endif /* CONFIG_FIPS */
1750#ifdef CONFIG_ACS
1751 "acs",
1752#endif /* CONFIG_ACS */
1753 };
Hai Shalom4fbc08f2020-05-18 12:37:00 -07001754 const char *iftypes[] = {
1755 "iftype=STATION", "iftype=AP", "iftype=P2P_CLIENT",
1756 "iftype=P2P_GO", "iftype=AP_VLAN", "iftype=IBSS", "iftype=NAN",
1757 "iftype=P2P_DEVICE", "iftype=MESH",
1758 };
Dmitry Shmidt7f2c7532016-08-15 09:48:12 -07001759 int i, num_fields = ARRAY_SIZE(fields);
Hai Shalom4fbc08f2020-05-18 12:37:00 -07001760 int num_iftypes = ARRAY_SIZE(iftypes);
Dmitry Shmidt7f2c7532016-08-15 09:48:12 -07001761 char **res = NULL;
1762
1763 if (arg == 1) {
1764 res = os_calloc(num_fields + 1, sizeof(char *));
1765 if (res == NULL)
1766 return NULL;
1767 for (i = 0; i < num_fields; i++) {
1768 res[i] = os_strdup(fields[i]);
1769 if (res[i] == NULL)
1770 return res;
1771 }
1772 }
1773 if (arg == 2) {
Hai Shalom4fbc08f2020-05-18 12:37:00 -07001774 /* the second argument can be "iftype=<iftype_name>" OR
1775 * "strict" */
1776 res = os_calloc(num_iftypes + 2, sizeof(char *));
1777 if (!res)
1778 return NULL;
1779 res[0] = os_strdup("strict");
1780 if (!res[0])
1781 return res;
1782 for (i = 0; i < num_iftypes; i++) {
1783 res[i + 1] = os_strdup(iftypes[i]);
1784 if (!res[i + 1])
1785 return res;
1786 }
1787 }
1788 if (arg == 3) {
Dmitry Shmidt7f2c7532016-08-15 09:48:12 -07001789 res = os_calloc(1 + 1, sizeof(char *));
1790 if (res == NULL)
1791 return NULL;
1792 res[0] = os_strdup("strict");
1793 }
1794 return res;
1795}
1796
1797
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001798static int wpa_cli_list_interfaces(struct wpa_ctrl *ctrl)
1799{
1800 printf("Available interfaces:\n");
1801 return wpa_ctrl_command(ctrl, "INTERFACES");
1802}
1803
1804
1805static int wpa_cli_cmd_interface(struct wpa_ctrl *ctrl, int argc, char *argv[])
1806{
1807 if (argc < 1) {
1808 wpa_cli_list_interfaces(ctrl);
1809 return 0;
1810 }
1811
1812 wpa_cli_close_connection();
1813 os_free(ctrl_ifname);
1814 ctrl_ifname = os_strdup(argv[0]);
Dmitry Shmidt2f74e362015-01-21 13:19:05 -08001815 if (!ctrl_ifname) {
1816 printf("Failed to allocate memory\n");
1817 return 0;
1818 }
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001819
Dmitry Shmidt413dde72014-04-11 10:23:22 -07001820 if (wpa_cli_open_connection(ctrl_ifname, 1) == 0) {
Hai Shalomfdcde762020-04-02 11:19:20 -07001821 printf("Connected to interface '%s'.\n", ctrl_ifname);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001822 } else {
1823 printf("Could not connect to interface '%s' - re-trying\n",
1824 ctrl_ifname);
1825 }
1826 return 0;
1827}
1828
1829
1830static int wpa_cli_cmd_reconfigure(struct wpa_ctrl *ctrl, int argc,
1831 char *argv[])
1832{
1833 return wpa_ctrl_command(ctrl, "RECONFIGURE");
1834}
1835
1836
1837static int wpa_cli_cmd_terminate(struct wpa_ctrl *ctrl, int argc,
1838 char *argv[])
1839{
1840 return wpa_ctrl_command(ctrl, "TERMINATE");
1841}
1842
1843
1844static int wpa_cli_cmd_interface_add(struct wpa_ctrl *ctrl, int argc,
1845 char *argv[])
1846{
1847 char cmd[256];
1848 int res;
1849
1850 if (argc < 1) {
1851 printf("Invalid INTERFACE_ADD command: needs at least one "
1852 "argument (interface name)\n"
1853 "All arguments: ifname confname driver ctrl_interface "
Dmitry Shmidt912c6ec2015-03-30 13:16:51 -07001854 "driver_param bridge_name [create]\n");
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001855 return -1;
1856 }
1857
1858 /*
1859 * INTERFACE_ADD <ifname>TAB<confname>TAB<driver>TAB<ctrl_interface>TAB
Dmitry Shmidtd7ff03d2015-12-04 14:49:35 -08001860 * <driver_param>TAB<bridge_name>[TAB<create>[TAB<type>]]
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001861 */
1862 res = os_snprintf(cmd, sizeof(cmd),
Dmitry Shmidtd7ff03d2015-12-04 14:49:35 -08001863 "INTERFACE_ADD %s\t%s\t%s\t%s\t%s\t%s\t%s\t%s",
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001864 argv[0],
1865 argc > 1 ? argv[1] : "", argc > 2 ? argv[2] : "",
1866 argc > 3 ? argv[3] : "", argc > 4 ? argv[4] : "",
Dmitry Shmidtd7ff03d2015-12-04 14:49:35 -08001867 argc > 5 ? argv[5] : "", argc > 6 ? argv[6] : "",
1868 argc > 7 ? argv[7] : "");
Dmitry Shmidt6c0da2b2015-01-05 13:08:17 -08001869 if (os_snprintf_error(sizeof(cmd), res))
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001870 return -1;
1871 cmd[sizeof(cmd) - 1] = '\0';
1872 return wpa_ctrl_command(ctrl, cmd);
1873}
1874
1875
1876static int wpa_cli_cmd_interface_remove(struct wpa_ctrl *ctrl, int argc,
1877 char *argv[])
1878{
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07001879 return wpa_cli_cmd(ctrl, "INTERFACE_REMOVE", 1, argc, argv);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001880}
1881
1882
1883static int wpa_cli_cmd_interface_list(struct wpa_ctrl *ctrl, int argc,
1884 char *argv[])
1885{
1886 return wpa_ctrl_command(ctrl, "INTERFACE_LIST");
1887}
1888
1889
1890#ifdef CONFIG_AP
1891static int wpa_cli_cmd_sta(struct wpa_ctrl *ctrl, int argc, char *argv[])
1892{
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07001893 return wpa_cli_cmd(ctrl, "STA", 1, argc, argv);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001894}
1895
1896
Dmitry Shmidt9839ecd2016-11-07 11:05:47 -08001897static char ** wpa_cli_complete_sta(const char *str, int pos)
1898{
1899 int arg = get_cmd_arg_num(str, pos);
1900 char **res = NULL;
1901
1902 switch (arg) {
1903 case 1:
1904 res = cli_txt_list_array(&stations);
1905 break;
1906 }
1907
1908 return res;
1909}
1910
1911
1912static int wpa_ctrl_command_sta(struct wpa_ctrl *ctrl, const char *cmd,
1913 char *addr, size_t addr_len, int print)
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001914{
1915 char buf[4096], *pos;
1916 size_t len;
1917 int ret;
1918
1919 if (ctrl_conn == NULL) {
1920 printf("Not connected to hostapd - command dropped.\n");
1921 return -1;
1922 }
Dmitry Shmidt7d56b752015-12-22 10:59:44 -08001923 if (ifname_prefix) {
1924 os_snprintf(buf, sizeof(buf), "IFNAME=%s %s",
1925 ifname_prefix, cmd);
1926 buf[sizeof(buf) - 1] = '\0';
1927 cmd = buf;
1928 }
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001929 len = sizeof(buf) - 1;
Dmitry Shmidt04949592012-07-19 12:16:46 -07001930 ret = wpa_ctrl_request(ctrl, cmd, os_strlen(cmd), buf, &len,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001931 wpa_cli_msg_cb);
1932 if (ret == -2) {
1933 printf("'%s' command timed out.\n", cmd);
1934 return -2;
1935 } else if (ret < 0) {
1936 printf("'%s' command failed.\n", cmd);
1937 return -1;
1938 }
1939
1940 buf[len] = '\0';
Dmitry Shmidtd2986c22017-10-23 14:22:09 -07001941 if (os_memcmp(buf, "FAIL", 4) == 0 ||
1942 os_memcmp(buf, "UNKNOWN COMMAND", 15) == 0)
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001943 return -1;
Dmitry Shmidt9839ecd2016-11-07 11:05:47 -08001944 if (print)
1945 printf("%s", buf);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001946
1947 pos = buf;
1948 while (*pos != '\0' && *pos != '\n')
1949 pos++;
1950 *pos = '\0';
1951 os_strlcpy(addr, buf, addr_len);
1952 return 0;
1953}
1954
1955
1956static int wpa_cli_cmd_all_sta(struct wpa_ctrl *ctrl, int argc, char *argv[])
1957{
1958 char addr[32], cmd[64];
1959
Dmitry Shmidt9839ecd2016-11-07 11:05:47 -08001960 if (wpa_ctrl_command_sta(ctrl, "STA-FIRST", addr, sizeof(addr), 1))
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001961 return 0;
1962 do {
1963 os_snprintf(cmd, sizeof(cmd), "STA-NEXT %s", addr);
Dmitry Shmidt9839ecd2016-11-07 11:05:47 -08001964 } while (wpa_ctrl_command_sta(ctrl, cmd, addr, sizeof(addr), 1) == 0);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001965
1966 return -1;
1967}
Dmitry Shmidt04949592012-07-19 12:16:46 -07001968
1969
Dmitry Shmidt9839ecd2016-11-07 11:05:47 -08001970static int wpa_cli_cmd_list_sta(struct wpa_ctrl *ctrl, int argc,
1971 char *argv[])
1972{
1973 char addr[32], cmd[64];
1974
1975 if (wpa_ctrl_command_sta(ctrl, "STA-FIRST", addr, sizeof(addr), 0))
1976 return 0;
1977 do {
1978 if (os_strcmp(addr, "") != 0)
1979 printf("%s\n", addr);
1980 os_snprintf(cmd, sizeof(cmd), "STA-NEXT %s", addr);
1981 } while (wpa_ctrl_command_sta(ctrl, cmd, addr, sizeof(addr), 0) == 0);
1982
1983 return 0;
1984}
1985
1986
Dmitry Shmidt04949592012-07-19 12:16:46 -07001987static int wpa_cli_cmd_deauthenticate(struct wpa_ctrl *ctrl, int argc,
1988 char *argv[])
1989{
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07001990 return wpa_cli_cmd(ctrl, "DEAUTHENTICATE", 1, argc, argv);
Dmitry Shmidt04949592012-07-19 12:16:46 -07001991}
1992
1993
Dmitry Shmidt9839ecd2016-11-07 11:05:47 -08001994static char ** wpa_cli_complete_deauthenticate(const char *str, int pos)
1995{
1996 int arg = get_cmd_arg_num(str, pos);
1997 char **res = NULL;
1998
1999 switch (arg) {
2000 case 1:
2001 res = cli_txt_list_array(&stations);
2002 break;
2003 }
2004
2005 return res;
2006}
2007
2008
Dmitry Shmidt04949592012-07-19 12:16:46 -07002009static int wpa_cli_cmd_disassociate(struct wpa_ctrl *ctrl, int argc,
2010 char *argv[])
2011{
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07002012 return wpa_cli_cmd(ctrl, "DISASSOCIATE", 1, argc, argv);
Dmitry Shmidt04949592012-07-19 12:16:46 -07002013}
Dmitry Shmidte0e48dc2013-11-18 12:00:06 -08002014
Dmitry Shmidt9839ecd2016-11-07 11:05:47 -08002015
2016static char ** wpa_cli_complete_disassociate(const char *str, int pos)
2017{
2018 int arg = get_cmd_arg_num(str, pos);
2019 char **res = NULL;
2020
2021 switch (arg) {
2022 case 1:
2023 res = cli_txt_list_array(&stations);
2024 break;
2025 }
2026
2027 return res;
2028}
2029
2030
Dmitry Shmidte0e48dc2013-11-18 12:00:06 -08002031static int wpa_cli_cmd_chanswitch(struct wpa_ctrl *ctrl, int argc,
2032 char *argv[])
2033{
2034 return wpa_cli_cmd(ctrl, "CHAN_SWITCH", 2, argc, argv);
2035}
2036
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002037#endif /* CONFIG_AP */
2038
2039
2040static int wpa_cli_cmd_suspend(struct wpa_ctrl *ctrl, int argc, char *argv[])
2041{
2042 return wpa_ctrl_command(ctrl, "SUSPEND");
2043}
2044
2045
2046static int wpa_cli_cmd_resume(struct wpa_ctrl *ctrl, int argc, char *argv[])
2047{
2048 return wpa_ctrl_command(ctrl, "RESUME");
2049}
2050
2051
Dmitry Shmidt21de2142014-04-08 10:50:52 -07002052#ifdef CONFIG_TESTING_OPTIONS
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002053static int wpa_cli_cmd_drop_sa(struct wpa_ctrl *ctrl, int argc, char *argv[])
2054{
2055 return wpa_ctrl_command(ctrl, "DROP_SA");
2056}
Dmitry Shmidt21de2142014-04-08 10:50:52 -07002057#endif /* CONFIG_TESTING_OPTIONS */
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002058
2059
2060static int wpa_cli_cmd_roam(struct wpa_ctrl *ctrl, int argc, char *argv[])
2061{
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07002062 return wpa_cli_cmd(ctrl, "ROAM", 1, argc, argv);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002063}
2064
2065
Dmitry Shmidt6c0da2b2015-01-05 13:08:17 -08002066#ifdef CONFIG_MESH
2067
2068static int wpa_cli_cmd_mesh_interface_add(struct wpa_ctrl *ctrl, int argc,
2069 char *argv[])
2070{
2071 return wpa_cli_cmd(ctrl, "MESH_INTERFACE_ADD", 0, argc, argv);
2072}
2073
2074
2075static int wpa_cli_cmd_mesh_group_add(struct wpa_ctrl *ctrl, int argc,
2076 char *argv[])
2077{
2078 return wpa_cli_cmd(ctrl, "MESH_GROUP_ADD", 1, argc, argv);
2079}
2080
2081
2082static int wpa_cli_cmd_mesh_group_remove(struct wpa_ctrl *ctrl, int argc,
2083 char *argv[])
2084{
2085 return wpa_cli_cmd(ctrl, "MESH_GROUP_REMOVE", 1, argc, argv);
2086}
2087
Dmitry Shmidte4663042016-04-04 10:07:49 -07002088
2089static int wpa_cli_cmd_mesh_peer_remove(struct wpa_ctrl *ctrl, int argc,
2090 char *argv[])
2091{
2092 return wpa_cli_cmd(ctrl, "MESH_PEER_REMOVE", 1, argc, argv);
2093}
2094
2095
2096static int wpa_cli_cmd_mesh_peer_add(struct wpa_ctrl *ctrl, int argc,
2097 char *argv[])
2098{
2099 return wpa_cli_cmd(ctrl, "MESH_PEER_ADD", 1, argc, argv);
2100}
2101
Hai Shalom81f62d82019-07-22 12:10:00 -07002102
2103static int wpa_cli_cmd_mesh_link_probe(struct wpa_ctrl *ctrl, int argc,
2104 char *argv[])
2105{
2106 return wpa_cli_cmd(ctrl, "MESH_LINK_PROBE", 1, argc, argv);
2107}
2108
Dmitry Shmidt6c0da2b2015-01-05 13:08:17 -08002109#endif /* CONFIG_MESH */
2110
2111
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002112#ifdef CONFIG_P2P
2113
2114static int wpa_cli_cmd_p2p_find(struct wpa_ctrl *ctrl, int argc, char *argv[])
2115{
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07002116 return wpa_cli_cmd(ctrl, "P2P_FIND", 0, argc, argv);
2117}
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002118
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002119
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07002120static char ** wpa_cli_complete_p2p_find(const char *str, int pos)
2121{
2122 char **res = NULL;
2123 int arg = get_cmd_arg_num(str, pos);
2124
2125 res = os_calloc(6, sizeof(char *));
2126 if (res == NULL)
2127 return NULL;
2128 res[0] = os_strdup("type=social");
2129 if (res[0] == NULL) {
2130 os_free(res);
2131 return NULL;
2132 }
2133 res[1] = os_strdup("type=progressive");
2134 if (res[1] == NULL)
2135 return res;
2136 res[2] = os_strdup("delay=");
2137 if (res[2] == NULL)
2138 return res;
2139 res[3] = os_strdup("dev_id=");
2140 if (res[3] == NULL)
2141 return res;
2142 if (arg == 1)
2143 res[4] = os_strdup("[timeout]");
2144
2145 return res;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002146}
2147
2148
2149static int wpa_cli_cmd_p2p_stop_find(struct wpa_ctrl *ctrl, int argc,
2150 char *argv[])
2151{
2152 return wpa_ctrl_command(ctrl, "P2P_STOP_FIND");
2153}
2154
2155
Dmitry Shmidt216983b2015-02-06 10:50:36 -08002156static int wpa_cli_cmd_p2p_asp_provision(struct wpa_ctrl *ctrl, int argc,
2157 char *argv[])
2158{
2159 return wpa_cli_cmd(ctrl, "P2P_ASP_PROVISION", 3, argc, argv);
2160}
2161
2162
2163static int wpa_cli_cmd_p2p_asp_provision_resp(struct wpa_ctrl *ctrl, int argc,
2164 char *argv[])
2165{
2166 return wpa_cli_cmd(ctrl, "P2P_ASP_PROVISION_RESP", 2, argc, argv);
2167}
2168
2169
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002170static int wpa_cli_cmd_p2p_connect(struct wpa_ctrl *ctrl, int argc,
2171 char *argv[])
2172{
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07002173 return wpa_cli_cmd(ctrl, "P2P_CONNECT", 2, argc, argv);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002174}
2175
2176
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08002177static char ** wpa_cli_complete_p2p_connect(const char *str, int pos)
2178{
2179 int arg = get_cmd_arg_num(str, pos);
2180 char **res = NULL;
2181
2182 switch (arg) {
2183 case 1:
2184 res = cli_txt_list_array(&p2p_peers);
2185 break;
2186 }
2187
2188 return res;
2189}
2190
2191
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002192static int wpa_cli_cmd_p2p_listen(struct wpa_ctrl *ctrl, int argc,
2193 char *argv[])
2194{
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07002195 return wpa_cli_cmd(ctrl, "P2P_LISTEN", 0, argc, argv);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002196}
2197
2198
2199static int wpa_cli_cmd_p2p_group_remove(struct wpa_ctrl *ctrl, int argc,
2200 char *argv[])
2201{
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07002202 return wpa_cli_cmd(ctrl, "P2P_GROUP_REMOVE", 1, argc, argv);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002203}
2204
2205
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08002206static char ** wpa_cli_complete_p2p_group_remove(const char *str, int pos)
2207{
2208 int arg = get_cmd_arg_num(str, pos);
2209 char **res = NULL;
2210
2211 switch (arg) {
2212 case 1:
2213 res = cli_txt_list_array(&p2p_groups);
2214 break;
2215 }
2216
2217 return res;
2218}
2219
2220
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002221static int wpa_cli_cmd_p2p_group_add(struct wpa_ctrl *ctrl, int argc,
2222 char *argv[])
2223{
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07002224 return wpa_cli_cmd(ctrl, "P2P_GROUP_ADD", 0, argc, argv);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002225}
2226
2227
Dmitry Shmidt849734c2016-05-27 09:59:01 -07002228static int wpa_cli_cmd_p2p_group_member(struct wpa_ctrl *ctrl, int argc,
2229 char *argv[])
2230{
2231 return wpa_cli_cmd(ctrl, "P2P_GROUP_MEMBER", 1, argc, argv);
2232}
2233
2234
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002235static int wpa_cli_cmd_p2p_prov_disc(struct wpa_ctrl *ctrl, int argc,
2236 char *argv[])
2237{
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08002238 if (argc != 2 && argc != 3) {
2239 printf("Invalid P2P_PROV_DISC command: needs at least "
2240 "two arguments, address and config method\n"
2241 "(display, keypad, or pbc) and an optional join\n");
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002242 return -1;
2243 }
2244
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07002245 return wpa_cli_cmd(ctrl, "P2P_PROV_DISC", 2, argc, argv);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002246}
2247
2248
2249static int wpa_cli_cmd_p2p_get_passphrase(struct wpa_ctrl *ctrl, int argc,
2250 char *argv[])
2251{
2252 return wpa_ctrl_command(ctrl, "P2P_GET_PASSPHRASE");
2253}
2254
2255
2256static int wpa_cli_cmd_p2p_serv_disc_req(struct wpa_ctrl *ctrl, int argc,
2257 char *argv[])
2258{
2259 char cmd[4096];
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002260
Dmitry Shmidt216983b2015-02-06 10:50:36 -08002261 if (argc < 2) {
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002262 printf("Invalid P2P_SERV_DISC_REQ command: needs two "
Dmitry Shmidt216983b2015-02-06 10:50:36 -08002263 "or more arguments (address and TLVs)\n");
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002264 return -1;
2265 }
2266
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07002267 if (write_cmd(cmd, sizeof(cmd), "P2P_SERV_DISC_REQ", argc, argv) < 0)
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002268 return -1;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002269 return wpa_ctrl_command(ctrl, cmd);
2270}
2271
2272
2273static int wpa_cli_cmd_p2p_serv_disc_cancel_req(struct wpa_ctrl *ctrl,
2274 int argc, char *argv[])
2275{
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07002276 return wpa_cli_cmd(ctrl, "P2P_SERV_DISC_CANCEL_REQ", 1, argc, argv);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002277}
2278
2279
2280static int wpa_cli_cmd_p2p_serv_disc_resp(struct wpa_ctrl *ctrl, int argc,
2281 char *argv[])
2282{
2283 char cmd[4096];
2284 int res;
2285
2286 if (argc != 4) {
2287 printf("Invalid P2P_SERV_DISC_RESP command: needs four "
2288 "arguments (freq, address, dialog token, and TLVs)\n");
2289 return -1;
2290 }
2291
2292 res = os_snprintf(cmd, sizeof(cmd), "P2P_SERV_DISC_RESP %s %s %s %s",
2293 argv[0], argv[1], argv[2], argv[3]);
Dmitry Shmidt6c0da2b2015-01-05 13:08:17 -08002294 if (os_snprintf_error(sizeof(cmd), res))
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002295 return -1;
2296 cmd[sizeof(cmd) - 1] = '\0';
2297 return wpa_ctrl_command(ctrl, cmd);
2298}
2299
2300
2301static int wpa_cli_cmd_p2p_service_update(struct wpa_ctrl *ctrl, int argc,
2302 char *argv[])
2303{
2304 return wpa_ctrl_command(ctrl, "P2P_SERVICE_UPDATE");
2305}
2306
2307
2308static int wpa_cli_cmd_p2p_serv_disc_external(struct wpa_ctrl *ctrl,
2309 int argc, char *argv[])
2310{
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07002311 return wpa_cli_cmd(ctrl, "P2P_SERV_DISC_EXTERNAL", 1, argc, argv);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002312}
2313
2314
2315static int wpa_cli_cmd_p2p_service_flush(struct wpa_ctrl *ctrl, int argc,
2316 char *argv[])
2317{
2318 return wpa_ctrl_command(ctrl, "P2P_SERVICE_FLUSH");
2319}
2320
2321
2322static int wpa_cli_cmd_p2p_service_add(struct wpa_ctrl *ctrl, int argc,
2323 char *argv[])
2324{
Dmitry Shmidt216983b2015-02-06 10:50:36 -08002325 if (argc < 3) {
2326 printf("Invalid P2P_SERVICE_ADD command: needs 3-6 arguments\n");
2327 return -1;
2328 }
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002329
Dmitry Shmidt216983b2015-02-06 10:50:36 -08002330 return wpa_cli_cmd(ctrl, "P2P_SERVICE_ADD", 3, argc, argv);
2331}
2332
2333
2334static int wpa_cli_cmd_p2p_service_rep(struct wpa_ctrl *ctrl, int argc,
2335 char *argv[])
2336{
2337 if (argc < 5 || argc > 6) {
2338 printf("Invalid P2P_SERVICE_REP command: needs 5-6 "
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002339 "arguments\n");
2340 return -1;
2341 }
2342
Dmitry Shmidt216983b2015-02-06 10:50:36 -08002343 return wpa_cli_cmd(ctrl, "P2P_SERVICE_REP", 5, argc, argv);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002344}
2345
2346
2347static int wpa_cli_cmd_p2p_service_del(struct wpa_ctrl *ctrl, int argc,
2348 char *argv[])
2349{
2350 char cmd[4096];
2351 int res;
2352
2353 if (argc != 2 && argc != 3) {
2354 printf("Invalid P2P_SERVICE_DEL command: needs two or three "
2355 "arguments\n");
2356 return -1;
2357 }
2358
2359 if (argc == 3)
2360 res = os_snprintf(cmd, sizeof(cmd),
2361 "P2P_SERVICE_DEL %s %s %s",
2362 argv[0], argv[1], argv[2]);
2363 else
2364 res = os_snprintf(cmd, sizeof(cmd),
2365 "P2P_SERVICE_DEL %s %s",
2366 argv[0], argv[1]);
Dmitry Shmidt6c0da2b2015-01-05 13:08:17 -08002367 if (os_snprintf_error(sizeof(cmd), res))
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002368 return -1;
2369 cmd[sizeof(cmd) - 1] = '\0';
2370 return wpa_ctrl_command(ctrl, cmd);
2371}
2372
2373
2374static int wpa_cli_cmd_p2p_reject(struct wpa_ctrl *ctrl,
2375 int argc, char *argv[])
2376{
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07002377 return wpa_cli_cmd(ctrl, "P2P_REJECT", 1, argc, argv);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002378}
2379
2380
2381static int wpa_cli_cmd_p2p_invite(struct wpa_ctrl *ctrl,
2382 int argc, char *argv[])
2383{
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07002384 return wpa_cli_cmd(ctrl, "P2P_INVITE", 1, argc, argv);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002385}
2386
2387
2388static int wpa_cli_cmd_p2p_peer(struct wpa_ctrl *ctrl, int argc, char *argv[])
2389{
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07002390 return wpa_cli_cmd(ctrl, "P2P_PEER", 1, argc, argv);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002391}
2392
2393
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08002394static char ** wpa_cli_complete_p2p_peer(const char *str, int pos)
2395{
2396 int arg = get_cmd_arg_num(str, pos);
2397 char **res = NULL;
2398
2399 switch (arg) {
2400 case 1:
2401 res = cli_txt_list_array(&p2p_peers);
2402 break;
2403 }
2404
2405 return res;
2406}
2407
2408
Dmitry Shmidt9839ecd2016-11-07 11:05:47 -08002409static int wpa_ctrl_command_p2p_peer(struct wpa_ctrl *ctrl, const char *cmd,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002410 char *addr, size_t addr_len,
2411 int discovered)
2412{
2413 char buf[4096], *pos;
2414 size_t len;
2415 int ret;
2416
2417 if (ctrl_conn == NULL)
2418 return -1;
2419 len = sizeof(buf) - 1;
Dmitry Shmidt04949592012-07-19 12:16:46 -07002420 ret = wpa_ctrl_request(ctrl, cmd, os_strlen(cmd), buf, &len,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002421 wpa_cli_msg_cb);
2422 if (ret == -2) {
2423 printf("'%s' command timed out.\n", cmd);
2424 return -2;
2425 } else if (ret < 0) {
2426 printf("'%s' command failed.\n", cmd);
2427 return -1;
2428 }
2429
2430 buf[len] = '\0';
Dmitry Shmidt04949592012-07-19 12:16:46 -07002431 if (os_memcmp(buf, "FAIL", 4) == 0)
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002432 return -1;
2433
2434 pos = buf;
2435 while (*pos != '\0' && *pos != '\n')
2436 pos++;
2437 *pos++ = '\0';
2438 os_strlcpy(addr, buf, addr_len);
2439 if (!discovered || os_strstr(pos, "[PROBE_REQ_ONLY]") == NULL)
2440 printf("%s\n", addr);
2441 return 0;
2442}
2443
2444
2445static int wpa_cli_cmd_p2p_peers(struct wpa_ctrl *ctrl, int argc, char *argv[])
2446{
2447 char addr[32], cmd[64];
2448 int discovered;
2449
2450 discovered = argc > 0 && os_strcmp(argv[0], "discovered") == 0;
2451
2452 if (wpa_ctrl_command_p2p_peer(ctrl, "P2P_PEER FIRST",
2453 addr, sizeof(addr), discovered))
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08002454 return -1;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002455 do {
2456 os_snprintf(cmd, sizeof(cmd), "P2P_PEER NEXT-%s", addr);
2457 } while (wpa_ctrl_command_p2p_peer(ctrl, cmd, addr, sizeof(addr),
2458 discovered) == 0);
2459
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08002460 return 0;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002461}
2462
2463
2464static int wpa_cli_cmd_p2p_set(struct wpa_ctrl *ctrl, int argc, char *argv[])
2465{
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07002466 return wpa_cli_cmd(ctrl, "P2P_SET", 2, argc, argv);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002467}
2468
2469
Dmitry Shmidt391c59f2013-09-03 12:16:28 -07002470static char ** wpa_cli_complete_p2p_set(const char *str, int pos)
2471{
2472 int arg = get_cmd_arg_num(str, pos);
2473 const char *fields[] = {
2474 "discoverability",
2475 "managed",
2476 "listen_channel",
2477 "ssid_postfix",
2478 "noa",
2479 "ps",
2480 "oppps",
2481 "ctwindow",
2482 "disabled",
2483 "conc_pref",
2484 "force_long_sd",
2485 "peer_filter",
2486 "cross_connect",
2487 "go_apsd",
2488 "client_apsd",
2489 "disallow_freq",
2490 "disc_int",
2491 "per_sta_psk",
2492 };
Dmitry Shmidt68d0e3e2013-10-28 17:59:21 -07002493 int i, num_fields = ARRAY_SIZE(fields);
Dmitry Shmidt391c59f2013-09-03 12:16:28 -07002494
2495 if (arg == 1) {
2496 char **res = os_calloc(num_fields + 1, sizeof(char *));
2497 if (res == NULL)
2498 return NULL;
2499 for (i = 0; i < num_fields; i++) {
2500 res[i] = os_strdup(fields[i]);
2501 if (res[i] == NULL)
2502 return res;
2503 }
2504 return res;
2505 }
2506
2507 if (arg == 2 && os_strncasecmp(str, "p2p_set peer_filter ", 20) == 0)
2508 return cli_txt_list_array(&p2p_peers);
2509
2510 return NULL;
2511}
2512
2513
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002514static int wpa_cli_cmd_p2p_flush(struct wpa_ctrl *ctrl, int argc, char *argv[])
2515{
2516 return wpa_ctrl_command(ctrl, "P2P_FLUSH");
2517}
2518
2519
2520static int wpa_cli_cmd_p2p_cancel(struct wpa_ctrl *ctrl, int argc,
2521 char *argv[])
2522{
2523 return wpa_ctrl_command(ctrl, "P2P_CANCEL");
2524}
2525
2526
2527static int wpa_cli_cmd_p2p_unauthorize(struct wpa_ctrl *ctrl, int argc,
2528 char *argv[])
2529{
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07002530 return wpa_cli_cmd(ctrl, "P2P_UNAUTHORIZE", 1, argc, argv);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002531}
2532
2533
2534static int wpa_cli_cmd_p2p_presence_req(struct wpa_ctrl *ctrl, int argc,
2535 char *argv[])
2536{
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002537 if (argc != 0 && argc != 2 && argc != 4) {
2538 printf("Invalid P2P_PRESENCE_REQ command: needs two arguments "
2539 "(preferred duration, interval; in microsecods).\n"
2540 "Optional second pair can be used to provide "
2541 "acceptable values.\n");
2542 return -1;
2543 }
2544
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07002545 return wpa_cli_cmd(ctrl, "P2P_PRESENCE_REQ", 0, argc, argv);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002546}
2547
2548
2549static int wpa_cli_cmd_p2p_ext_listen(struct wpa_ctrl *ctrl, int argc,
2550 char *argv[])
2551{
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002552 if (argc != 0 && argc != 2) {
2553 printf("Invalid P2P_EXT_LISTEN command: needs two arguments "
2554 "(availability period, availability interval; in "
2555 "millisecods).\n"
2556 "Extended Listen Timing can be cancelled with this "
2557 "command when used without parameters.\n");
2558 return -1;
2559 }
2560
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07002561 return wpa_cli_cmd(ctrl, "P2P_EXT_LISTEN", 0, argc, argv);
2562}
2563
Dmitry Shmidt391c59f2013-09-03 12:16:28 -07002564
2565static int wpa_cli_cmd_p2p_remove_client(struct wpa_ctrl *ctrl, int argc,
2566 char *argv[])
2567{
2568 return wpa_cli_cmd(ctrl, "P2P_REMOVE_CLIENT", 1, argc, argv);
2569}
2570
Roshan Pius3a1667e2018-07-03 15:17:14 -07002571#endif /* CONFIG_P2P */
2572
Dmitry Shmidtd80a4012015-11-05 16:35:40 -08002573
2574static int wpa_cli_cmd_vendor_elem_add(struct wpa_ctrl *ctrl, int argc,
2575 char *argv[])
2576{
2577 return wpa_cli_cmd(ctrl, "VENDOR_ELEM_ADD", 2, argc, argv);
2578}
2579
2580
2581static int wpa_cli_cmd_vendor_elem_get(struct wpa_ctrl *ctrl, int argc,
2582 char *argv[])
2583{
2584 return wpa_cli_cmd(ctrl, "VENDOR_ELEM_GET", 1, argc, argv);
2585}
2586
2587
2588static int wpa_cli_cmd_vendor_elem_remove(struct wpa_ctrl *ctrl, int argc,
2589 char *argv[])
2590{
2591 return wpa_cli_cmd(ctrl, "VENDOR_ELEM_REMOVE", 2, argc, argv);
2592}
2593
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07002594
2595#ifdef CONFIG_WIFI_DISPLAY
2596
2597static int wpa_cli_cmd_wfd_subelem_set(struct wpa_ctrl *ctrl, int argc,
2598 char *argv[])
2599{
2600 char cmd[100];
2601 int res;
2602
2603 if (argc != 1 && argc != 2) {
2604 printf("Invalid WFD_SUBELEM_SET command: needs one or two "
2605 "arguments (subelem, hexdump)\n");
2606 return -1;
2607 }
2608
2609 res = os_snprintf(cmd, sizeof(cmd), "WFD_SUBELEM_SET %s %s",
2610 argv[0], argc > 1 ? argv[1] : "");
Dmitry Shmidt6c0da2b2015-01-05 13:08:17 -08002611 if (os_snprintf_error(sizeof(cmd), res))
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002612 return -1;
2613 cmd[sizeof(cmd) - 1] = '\0';
2614 return wpa_ctrl_command(ctrl, cmd);
2615}
2616
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07002617
2618static int wpa_cli_cmd_wfd_subelem_get(struct wpa_ctrl *ctrl, int argc,
2619 char *argv[])
2620{
2621 char cmd[100];
2622 int res;
2623
2624 if (argc != 1) {
2625 printf("Invalid WFD_SUBELEM_GET command: needs one "
2626 "argument (subelem)\n");
2627 return -1;
2628 }
2629
2630 res = os_snprintf(cmd, sizeof(cmd), "WFD_SUBELEM_GET %s",
2631 argv[0]);
Dmitry Shmidt6c0da2b2015-01-05 13:08:17 -08002632 if (os_snprintf_error(sizeof(cmd), res))
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07002633 return -1;
2634 cmd[sizeof(cmd) - 1] = '\0';
2635 return wpa_ctrl_command(ctrl, cmd);
2636}
2637#endif /* CONFIG_WIFI_DISPLAY */
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002638
2639
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08002640#ifdef CONFIG_INTERWORKING
2641static int wpa_cli_cmd_fetch_anqp(struct wpa_ctrl *ctrl, int argc,
2642 char *argv[])
2643{
2644 return wpa_ctrl_command(ctrl, "FETCH_ANQP");
2645}
2646
2647
2648static int wpa_cli_cmd_stop_fetch_anqp(struct wpa_ctrl *ctrl, int argc,
2649 char *argv[])
2650{
2651 return wpa_ctrl_command(ctrl, "STOP_FETCH_ANQP");
2652}
2653
2654
2655static int wpa_cli_cmd_interworking_select(struct wpa_ctrl *ctrl, int argc,
2656 char *argv[])
2657{
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07002658 return wpa_cli_cmd(ctrl, "INTERWORKING_SELECT", 0, argc, argv);
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08002659}
2660
2661
2662static int wpa_cli_cmd_interworking_connect(struct wpa_ctrl *ctrl, int argc,
2663 char *argv[])
2664{
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07002665 return wpa_cli_cmd(ctrl, "INTERWORKING_CONNECT", 1, argc, argv);
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08002666}
2667
2668
Dmitry Shmidt7f656022015-02-25 14:36:37 -08002669static int wpa_cli_cmd_interworking_add_network(struct wpa_ctrl *ctrl, int argc,
2670 char *argv[])
2671{
2672 return wpa_cli_cmd(ctrl, "INTERWORKING_ADD_NETWORK", 1, argc, argv);
2673}
2674
2675
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08002676static int wpa_cli_cmd_anqp_get(struct wpa_ctrl *ctrl, int argc, char *argv[])
2677{
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07002678 return wpa_cli_cmd(ctrl, "ANQP_GET", 2, argc, argv);
2679}
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08002680
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08002681
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07002682static int wpa_cli_cmd_gas_request(struct wpa_ctrl *ctrl, int argc,
2683 char *argv[])
2684{
2685 return wpa_cli_cmd(ctrl, "GAS_REQUEST", 2, argc, argv);
2686}
2687
2688
2689static int wpa_cli_cmd_gas_response_get(struct wpa_ctrl *ctrl, int argc,
2690 char *argv[])
2691{
2692 return wpa_cli_cmd(ctrl, "GAS_RESPONSE_GET", 2, argc, argv);
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08002693}
2694#endif /* CONFIG_INTERWORKING */
2695
2696
Dmitry Shmidt04949592012-07-19 12:16:46 -07002697#ifdef CONFIG_HS20
2698
2699static int wpa_cli_cmd_hs20_anqp_get(struct wpa_ctrl *ctrl, int argc,
2700 char *argv[])
2701{
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07002702 return wpa_cli_cmd(ctrl, "HS20_ANQP_GET", 2, argc, argv);
Dmitry Shmidt04949592012-07-19 12:16:46 -07002703}
2704
2705
2706static int wpa_cli_cmd_get_nai_home_realm_list(struct wpa_ctrl *ctrl, int argc,
2707 char *argv[])
2708{
2709 char cmd[512];
Dmitry Shmidt04949592012-07-19 12:16:46 -07002710
2711 if (argc == 0) {
2712 printf("Command needs one or two arguments (dst mac addr and "
2713 "optional home realm)\n");
2714 return -1;
2715 }
2716
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07002717 if (write_cmd(cmd, sizeof(cmd), "HS20_GET_NAI_HOME_REALM_LIST",
2718 argc, argv) < 0)
Dmitry Shmidt04949592012-07-19 12:16:46 -07002719 return -1;
Dmitry Shmidt04949592012-07-19 12:16:46 -07002720
2721 return wpa_ctrl_command(ctrl, cmd);
2722}
2723
Dmitry Shmidtf21452a2014-02-26 10:55:25 -08002724
2725static int wpa_cli_cmd_hs20_icon_request(struct wpa_ctrl *ctrl, int argc,
2726 char *argv[])
2727{
2728 char cmd[512];
2729
2730 if (argc < 2) {
2731 printf("Command needs two arguments (dst mac addr and "
2732 "icon name)\n");
2733 return -1;
2734 }
2735
2736 if (write_cmd(cmd, sizeof(cmd), "HS20_ICON_REQUEST", argc, argv) < 0)
2737 return -1;
2738
2739 return wpa_ctrl_command(ctrl, cmd);
2740}
2741
2742
2743static int wpa_cli_cmd_fetch_osu(struct wpa_ctrl *ctrl, int argc, char *argv[])
2744{
2745 return wpa_ctrl_command(ctrl, "FETCH_OSU");
2746}
2747
2748
2749static int wpa_cli_cmd_cancel_fetch_osu(struct wpa_ctrl *ctrl, int argc,
2750 char *argv[])
2751{
2752 return wpa_ctrl_command(ctrl, "CANCEL_FETCH_OSU");
2753}
2754
Dmitry Shmidt04949592012-07-19 12:16:46 -07002755#endif /* CONFIG_HS20 */
2756
2757
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002758static int wpa_cli_cmd_sta_autoconnect(struct wpa_ctrl *ctrl, int argc,
2759 char *argv[])
2760{
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07002761 return wpa_cli_cmd(ctrl, "STA_AUTOCONNECT", 1, argc, argv);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002762}
2763
2764
2765static int wpa_cli_cmd_tdls_discover(struct wpa_ctrl *ctrl, int argc,
2766 char *argv[])
2767{
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07002768 return wpa_cli_cmd(ctrl, "TDLS_DISCOVER", 1, argc, argv);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002769}
2770
2771
2772static int wpa_cli_cmd_tdls_setup(struct wpa_ctrl *ctrl, int argc,
2773 char *argv[])
2774{
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07002775 return wpa_cli_cmd(ctrl, "TDLS_SETUP", 1, argc, argv);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002776}
2777
2778
2779static int wpa_cli_cmd_tdls_teardown(struct wpa_ctrl *ctrl, int argc,
2780 char *argv[])
2781{
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07002782 return wpa_cli_cmd(ctrl, "TDLS_TEARDOWN", 1, argc, argv);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002783}
2784
2785
Dmitry Shmidtcc00d5d2015-05-04 10:34:12 -07002786static int wpa_cli_cmd_tdls_link_status(struct wpa_ctrl *ctrl, int argc,
2787 char *argv[])
2788{
2789 return wpa_cli_cmd(ctrl, "TDLS_LINK_STATUS", 1, argc, argv);
2790}
2791
2792
Dmitry Shmidt6c0da2b2015-01-05 13:08:17 -08002793static int wpa_cli_cmd_wmm_ac_addts(struct wpa_ctrl *ctrl, int argc,
2794 char *argv[])
2795{
2796 return wpa_cli_cmd(ctrl, "WMM_AC_ADDTS", 3, argc, argv);
2797}
2798
2799
2800static int wpa_cli_cmd_wmm_ac_delts(struct wpa_ctrl *ctrl, int argc,
2801 char *argv[])
2802{
2803 return wpa_cli_cmd(ctrl, "WMM_AC_DELTS", 1, argc, argv);
2804}
2805
2806
2807static int wpa_cli_cmd_wmm_ac_status(struct wpa_ctrl *ctrl, int argc,
2808 char *argv[])
2809{
2810 return wpa_ctrl_command(ctrl, "WMM_AC_STATUS");
2811}
2812
2813
2814static int wpa_cli_cmd_tdls_chan_switch(struct wpa_ctrl *ctrl, int argc,
2815 char *argv[])
2816{
2817 return wpa_cli_cmd(ctrl, "TDLS_CHAN_SWITCH", 2, argc, argv);
2818}
2819
2820
2821static int wpa_cli_cmd_tdls_cancel_chan_switch(struct wpa_ctrl *ctrl, int argc,
2822 char *argv[])
2823{
2824 return wpa_cli_cmd(ctrl, "TDLS_CANCEL_CHAN_SWITCH", 1, argc, argv);
2825}
2826
2827
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002828static int wpa_cli_cmd_signal_poll(struct wpa_ctrl *ctrl, int argc,
2829 char *argv[])
2830{
2831 return wpa_ctrl_command(ctrl, "SIGNAL_POLL");
2832}
2833
2834
Dmitry Shmidt7d56b752015-12-22 10:59:44 -08002835static int wpa_cli_cmd_signal_monitor(struct wpa_ctrl *ctrl, int argc,
2836 char *argv[])
2837{
2838 return wpa_cli_cmd(ctrl, "SIGNAL_MONITOR", 0, argc, argv);
2839}
2840
2841
Yuhao Zhengfcd6f212012-07-27 10:37:52 -07002842static int wpa_cli_cmd_pktcnt_poll(struct wpa_ctrl *ctrl, int argc,
2843 char *argv[])
2844{
2845 return wpa_ctrl_command(ctrl, "PKTCNT_POLL");
2846}
2847
2848
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08002849static int wpa_cli_cmd_reauthenticate(struct wpa_ctrl *ctrl, int argc,
2850 char *argv[])
2851{
2852 return wpa_ctrl_command(ctrl, "REAUTHENTICATE");
2853}
2854
Dmitry Shmidt04949592012-07-19 12:16:46 -07002855
2856#ifdef CONFIG_AUTOSCAN
2857
2858static int wpa_cli_cmd_autoscan(struct wpa_ctrl *ctrl, int argc, char *argv[])
2859{
Dmitry Shmidt04949592012-07-19 12:16:46 -07002860 if (argc == 0)
2861 return wpa_ctrl_command(ctrl, "AUTOSCAN ");
2862
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07002863 return wpa_cli_cmd(ctrl, "AUTOSCAN", 0, argc, argv);
Dmitry Shmidt04949592012-07-19 12:16:46 -07002864}
2865
2866#endif /* CONFIG_AUTOSCAN */
2867
2868
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -08002869#ifdef CONFIG_WNM
2870
2871static int wpa_cli_cmd_wnm_sleep(struct wpa_ctrl *ctrl, int argc, char *argv[])
2872{
2873 return wpa_cli_cmd(ctrl, "WNM_SLEEP", 0, argc, argv);
2874}
2875
Dmitry Shmidt44c95782013-05-17 09:51:35 -07002876
2877static int wpa_cli_cmd_wnm_bss_query(struct wpa_ctrl *ctrl, int argc, char *argv[])
2878{
2879 return wpa_cli_cmd(ctrl, "WNM_BSS_QUERY", 1, argc, argv);
2880}
2881
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -08002882#endif /* CONFIG_WNM */
2883
2884
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07002885static int wpa_cli_cmd_raw(struct wpa_ctrl *ctrl, int argc, char *argv[])
2886{
2887 if (argc == 0)
2888 return -1;
2889 return wpa_cli_cmd(ctrl, argv[0], 0, argc - 1, &argv[1]);
2890}
2891
2892
Dmitry Shmidtc5ec7f52012-03-06 16:33:24 -08002893#ifdef ANDROID
Dmitry Shmidt0716c122011-04-08 15:03:17 -07002894static int wpa_cli_cmd_driver(struct wpa_ctrl *ctrl, int argc, char *argv[])
2895{
Dmitry Shmidt292b0c32013-11-22 12:54:42 -08002896 return wpa_cli_cmd(ctrl, "DRIVER", 1, argc, argv);
Dmitry Shmidt0716c122011-04-08 15:03:17 -07002897}
Dmitry Shmidt292b0c32013-11-22 12:54:42 -08002898#endif /* ANDROID */
Dmitry Shmidt0716c122011-04-08 15:03:17 -07002899
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07002900
Dmitry Shmidta38abf92014-03-06 13:38:44 -08002901static int wpa_cli_cmd_vendor(struct wpa_ctrl *ctrl, int argc, char *argv[])
2902{
2903 return wpa_cli_cmd(ctrl, "VENDOR", 1, argc, argv);
2904}
2905
2906
Dmitry Shmidt444d5672013-04-01 13:08:44 -07002907static int wpa_cli_cmd_flush(struct wpa_ctrl *ctrl, int argc, char *argv[])
2908{
2909 return wpa_ctrl_command(ctrl, "FLUSH");
2910}
2911
2912
Dmitry Shmidtfb79edc2014-01-10 10:45:54 -08002913static int wpa_cli_cmd_radio_work(struct wpa_ctrl *ctrl, int argc, char *argv[])
2914{
2915 return wpa_cli_cmd(ctrl, "RADIO_WORK", 1, argc, argv);
2916}
2917
2918
Dmitry Shmidt6c0da2b2015-01-05 13:08:17 -08002919static int wpa_cli_cmd_neighbor_rep_request(struct wpa_ctrl *ctrl, int argc,
2920 char *argv[])
2921{
2922 return wpa_cli_cmd(ctrl, "NEIGHBOR_REP_REQUEST", 0, argc, argv);
2923}
2924
2925
2926static int wpa_cli_cmd_erp_flush(struct wpa_ctrl *ctrl, int argc, char *argv[])
2927{
2928 return wpa_ctrl_command(ctrl, "ERP_FLUSH");
2929}
2930
2931
2932static int wpa_cli_cmd_mac_rand_scan(struct wpa_ctrl *ctrl, int argc,
2933 char *argv[])
2934{
2935 return wpa_cli_cmd(ctrl, "MAC_RAND_SCAN", 1, argc, argv);
2936}
2937
2938
Dmitry Shmidtd80a4012015-11-05 16:35:40 -08002939static int wpa_cli_cmd_get_pref_freq_list(struct wpa_ctrl *ctrl, int argc,
2940 char *argv[])
2941{
2942 return wpa_cli_cmd(ctrl, "GET_PREF_FREQ_LIST", 1, argc, argv);
2943}
2944
2945
Dmitry Shmidt58d12ad2016-07-28 10:07:03 -07002946static int wpa_cli_cmd_p2p_lo_start(struct wpa_ctrl *ctrl, int argc,
2947 char *argv[])
2948{
2949 return wpa_cli_cmd(ctrl, "P2P_LO_START", 4, argc, argv);
2950}
2951
2952
2953static int wpa_cli_cmd_p2p_lo_stop(struct wpa_ctrl *ctrl, int argc,
2954 char *argv[])
2955{
2956 return wpa_cli_cmd(ctrl, "P2P_LO_STOP", 0, argc, argv);
2957}
2958
2959
Dmitry Shmidtd2986c22017-10-23 14:22:09 -07002960#ifdef CONFIG_DPP
2961
2962static int wpa_cli_cmd_dpp_qr_code(struct wpa_ctrl *ctrl, int argc,
2963 char *argv[])
2964{
2965 return wpa_cli_cmd(ctrl, "DPP_QR_CODE", 1, argc, argv);
2966}
2967
2968
2969static int wpa_cli_cmd_dpp_bootstrap_gen(struct wpa_ctrl *ctrl, int argc,
2970 char *argv[])
2971{
2972 return wpa_cli_cmd(ctrl, "DPP_BOOTSTRAP_GEN", 1, argc, argv);
2973}
2974
2975
2976static int wpa_cli_cmd_dpp_bootstrap_remove(struct wpa_ctrl *ctrl, int argc,
2977 char *argv[])
2978{
2979 return wpa_cli_cmd(ctrl, "DPP_BOOTSTRAP_REMOVE", 1, argc, argv);
2980}
2981
2982
2983static int wpa_cli_cmd_dpp_bootstrap_get_uri(struct wpa_ctrl *ctrl, int argc,
2984 char *argv[])
2985{
2986 return wpa_cli_cmd(ctrl, "DPP_BOOTSTRAP_GET_URI", 1, argc, argv);
2987}
2988
2989
2990static int wpa_cli_cmd_dpp_bootstrap_info(struct wpa_ctrl *ctrl, int argc,
2991 char *argv[])
2992{
2993 return wpa_cli_cmd(ctrl, "DPP_BOOTSTRAP_INFO", 1, argc, argv);
2994}
2995
2996
Hai Shalom899fcc72020-10-19 14:38:18 -07002997static int wpa_cli_cmd_dpp_bootstrap_set(struct wpa_ctrl *ctrl, int argc,
2998 char *argv[])
2999{
3000 return wpa_cli_cmd(ctrl, "DPP_BOOTSTRAP_SET", 1, argc, argv);
3001}
3002
3003
Dmitry Shmidtd2986c22017-10-23 14:22:09 -07003004static int wpa_cli_cmd_dpp_auth_init(struct wpa_ctrl *ctrl, int argc,
3005 char *argv[])
3006{
3007 return wpa_cli_cmd(ctrl, "DPP_AUTH_INIT", 1, argc, argv);
3008}
3009
3010
3011static int wpa_cli_cmd_dpp_listen(struct wpa_ctrl *ctrl, int argc,
3012 char *argv[])
3013{
3014 return wpa_cli_cmd(ctrl, "DPP_LISTEN", 1, argc, argv);
3015}
3016
3017
3018static int wpa_cli_cmd_dpp_stop_listen(struct wpa_ctrl *ctrl, int argc,
3019 char *argv[])
3020{
3021 return wpa_ctrl_command(ctrl, "DPP_STOP_LISTEN");
3022}
3023
3024
3025static int wpa_cli_cmd_dpp_configurator_add(struct wpa_ctrl *ctrl, int argc,
3026 char *argv[])
3027{
3028 return wpa_cli_cmd(ctrl, "DPP_CONFIGURATOR_ADD", 0, argc, argv);
3029}
3030
3031
3032static int wpa_cli_cmd_dpp_configurator_remove(struct wpa_ctrl *ctrl, int argc,
3033 char *argv[])
3034{
3035 return wpa_cli_cmd(ctrl, "DPP_CONFIGURATOR_REMOVE", 1, argc, argv);
3036}
3037
3038
Roshan Pius3a1667e2018-07-03 15:17:14 -07003039static int wpa_cli_cmd_dpp_configurator_get_key(struct wpa_ctrl *ctrl, int argc,
3040 char *argv[])
3041{
3042 return wpa_cli_cmd(ctrl, "DPP_CONFIGURATOR_GET_KEY", 1, argc, argv);
3043}
3044
3045
Hai Shalom74f70d42019-02-11 14:42:39 -08003046static int wpa_cli_cmd_dpp_configurator_sign(struct wpa_ctrl *ctrl, int argc,
3047 char *argv[])
3048{
3049 return wpa_cli_cmd(ctrl, "DPP_CONFIGURATOR_SIGN", 1, argc, argv);
3050}
3051
3052
Dmitry Shmidtd2986c22017-10-23 14:22:09 -07003053static int wpa_cli_cmd_dpp_pkex_add(struct wpa_ctrl *ctrl, int argc,
3054 char *argv[])
3055{
3056 return wpa_cli_cmd(ctrl, "DPP_PKEX_ADD", 1, argc, argv);
3057}
3058
3059
3060static int wpa_cli_cmd_dpp_pkex_remove(struct wpa_ctrl *ctrl, int argc,
3061 char *argv[])
3062{
3063 return wpa_cli_cmd(ctrl, "DPP_PKEX_REMOVE", 1, argc, argv);
3064}
3065
Hai Shalom899fcc72020-10-19 14:38:18 -07003066
3067#ifdef CONFIG_DPP2
3068
3069static int wpa_cli_cmd_dpp_chirp(struct wpa_ctrl *ctrl, int argc,
3070 char *argv[])
3071{
3072 return wpa_cli_cmd(ctrl, "DPP_CHIRP", 1, argc, argv);
3073}
3074
3075
3076static int wpa_cli_cmd_dpp_stop_chirp(struct wpa_ctrl *ctrl, int argc,
3077 char *argv[])
3078{
3079 return wpa_ctrl_command(ctrl, "DPP_STOP_CHIRP");
3080}
3081
3082#endif /* CONFIG_DPP2 */
Dmitry Shmidtd2986c22017-10-23 14:22:09 -07003083#endif /* CONFIG_DPP */
3084
3085
Hai Shalom899fcc72020-10-19 14:38:18 -07003086static int wpa_ctrl_command_bss(struct wpa_ctrl *ctrl, const char *cmd)
3087{
3088 char buf[512], *pos, *bssid, *freq, *level, *flags, *ssid;
3089 size_t len;
3090 int ret, id = -1;
3091
3092 if (!ctrl_conn)
3093 return -1;
3094 len = sizeof(buf) - 1;
3095 ret = wpa_ctrl_request(ctrl, cmd, os_strlen(cmd), buf, &len,
3096 wpa_cli_msg_cb);
3097 if (ret == -2) {
3098 printf("'%s' command timed out.\n", cmd);
3099 return -2;
3100 } else if (ret < 0) {
3101 printf("'%s' command failed.\n", cmd);
3102 return -1;
3103 }
3104
3105 buf[len] = '\0';
3106 if (os_memcmp(buf, "FAIL", 4) == 0)
3107 return -1;
3108
3109 pos = buf;
3110 while (*pos != '\0') {
3111 if (str_starts(pos, "id="))
3112 id = atoi(pos + 3);
3113 if (str_starts(pos, "bssid="))
3114 bssid = pos + 6;
3115 if (str_starts(pos, "freq="))
3116 freq = pos + 5;
3117 if (str_starts(pos, "level="))
3118 level = pos + 6;
3119 if (str_starts(pos, "flags="))
3120 flags = pos + 6;
3121 if (str_starts(pos, "ssid="))
3122 ssid = pos + 5;
3123
3124 while (*pos != '\0' && *pos != '\n')
3125 pos++;
3126 *pos++ = '\0';
3127 }
3128 if (id != -1)
3129 printf("%s\t%s\t%s\t%s\t%s\n", bssid, freq, level, flags, ssid);
3130 return id;
3131}
3132
3133
3134static int wpa_cli_cmd_all_bss(struct wpa_ctrl *ctrl, int argc, char *argv[])
3135{
3136 char cmd[64];
3137 int id = -1;
3138 unsigned int mask;
3139
3140 printf("bssid / frequency / signal level / flags / ssid\n");
3141
3142 mask = WPA_BSS_MASK_ID | WPA_BSS_MASK_BSSID | WPA_BSS_MASK_FREQ |
3143 WPA_BSS_MASK_LEVEL | WPA_BSS_MASK_FLAGS | WPA_BSS_MASK_SSID;
3144 do {
3145 if (id < 0)
3146 os_snprintf(cmd, sizeof(cmd), "BSS FIRST MASK=0x%x",
3147 mask);
3148 else
3149 os_snprintf(cmd, sizeof(cmd), "BSS NEXT-%d MASK=0x%x",
3150 id, mask);
3151 id = wpa_ctrl_command_bss(ctrl, cmd);
3152 } while (id >= 0);
3153
3154 return 0;
3155}
3156
3157
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003158enum wpa_cli_cmd_flags {
3159 cli_cmd_flag_none = 0x00,
3160 cli_cmd_flag_sensitive = 0x01
3161};
3162
3163struct wpa_cli_cmd {
3164 const char *cmd;
3165 int (*handler)(struct wpa_ctrl *ctrl, int argc, char *argv[]);
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003166 char ** (*completion)(const char *str, int pos);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003167 enum wpa_cli_cmd_flags flags;
3168 const char *usage;
3169};
3170
Dmitry Shmidt1d755d02015-04-28 10:34:29 -07003171static const struct wpa_cli_cmd wpa_cli_commands[] = {
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003172 { "status", wpa_cli_cmd_status, NULL,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003173 cli_cmd_flag_none,
3174 "[verbose] = get current WPA/EAPOL/EAP status" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003175 { "ifname", wpa_cli_cmd_ifname, NULL,
3176 cli_cmd_flag_none,
3177 "= get current interface name" },
3178 { "ping", wpa_cli_cmd_ping, NULL,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003179 cli_cmd_flag_none,
3180 "= pings wpa_supplicant" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003181 { "relog", wpa_cli_cmd_relog, NULL,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003182 cli_cmd_flag_none,
3183 "= re-open log-file (allow rolling logs)" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003184 { "note", wpa_cli_cmd_note, NULL,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003185 cli_cmd_flag_none,
3186 "<text> = add a note to wpa_supplicant debug log" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003187 { "mib", wpa_cli_cmd_mib, NULL,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003188 cli_cmd_flag_none,
3189 "= get MIB variables (dot1x, dot11)" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003190 { "help", wpa_cli_cmd_help, wpa_cli_complete_help,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003191 cli_cmd_flag_none,
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003192 "[command] = show usage help" },
3193 { "interface", wpa_cli_cmd_interface, NULL,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003194 cli_cmd_flag_none,
3195 "[ifname] = show interfaces/select interface" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003196 { "level", wpa_cli_cmd_level, NULL,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003197 cli_cmd_flag_none,
3198 "<debug level> = change debug level" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003199 { "license", wpa_cli_cmd_license, NULL,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003200 cli_cmd_flag_none,
3201 "= show full wpa_cli license" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003202 { "quit", wpa_cli_cmd_quit, NULL,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003203 cli_cmd_flag_none,
3204 "= exit wpa_cli" },
Dmitry Shmidt51b6ea82013-05-08 10:42:09 -07003205 { "set", wpa_cli_cmd_set, wpa_cli_complete_set,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003206 cli_cmd_flag_none,
3207 "= set variables (shows list of variables when run without "
3208 "arguments)" },
Dmitry Shmidt7f656022015-02-25 14:36:37 -08003209 { "dump", wpa_cli_cmd_dump, NULL,
3210 cli_cmd_flag_none,
3211 "= dump config variables" },
Dmitry Shmidtf73259c2015-03-17 11:00:54 -07003212 { "get", wpa_cli_cmd_get, wpa_cli_complete_get,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003213 cli_cmd_flag_none,
3214 "<name> = get information" },
Dmitry Shmidt58d12ad2016-07-28 10:07:03 -07003215 { "driver_flags", wpa_cli_cmd_driver_flags, NULL,
3216 cli_cmd_flag_none,
3217 "= list driver flags" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003218 { "logon", wpa_cli_cmd_logon, NULL,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003219 cli_cmd_flag_none,
3220 "= IEEE 802.1X EAPOL state machine logon" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003221 { "logoff", wpa_cli_cmd_logoff, NULL,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003222 cli_cmd_flag_none,
3223 "= IEEE 802.1X EAPOL state machine logoff" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003224 { "pmksa", wpa_cli_cmd_pmksa, NULL,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003225 cli_cmd_flag_none,
3226 "= show PMKSA cache" },
Dmitry Shmidt661b4f72014-09-29 14:58:27 -07003227 { "pmksa_flush", wpa_cli_cmd_pmksa_flush, NULL,
3228 cli_cmd_flag_none,
3229 "= flush PMKSA cache entries" },
Dmitry Shmidt29333592017-01-09 12:27:11 -08003230#ifdef CONFIG_PMKSA_CACHE_EXTERNAL
3231 { "pmksa_get", wpa_cli_cmd_pmksa_get, NULL,
3232 cli_cmd_flag_none,
3233 "<network_id> = fetch all stored PMKSA cache entries" },
3234 { "pmksa_add", wpa_cli_cmd_pmksa_add, NULL,
3235 cli_cmd_flag_sensitive,
3236 "<network_id> <BSSID> <PMKID> <PMK> <reauth_time in seconds> <expiration in seconds> <akmp> <opportunistic> = store PMKSA cache entry from external storage" },
Paul Stewart092955c2017-02-06 09:13:09 -08003237#ifdef CONFIG_MESH
3238 { "mesh_pmksa_get", wpa_cli_mesh_cmd_pmksa_get, NULL,
3239 cli_cmd_flag_none,
3240 "<peer MAC address | any> = fetch all stored mesh PMKSA cache entries" },
3241 { "mesh_pmksa_add", wpa_cli_mesh_cmd_pmksa_add, NULL,
3242 cli_cmd_flag_sensitive,
3243 "<BSSID> <PMKID> <PMK> <expiration in seconds> = store mesh PMKSA cache entry from external storage" },
3244#endif /* CONFIG_MESH */
Dmitry Shmidt29333592017-01-09 12:27:11 -08003245#endif /* CONFIG_PMKSA_CACHE_EXTERNAL */
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003246 { "reassociate", wpa_cli_cmd_reassociate, NULL,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003247 cli_cmd_flag_none,
3248 "= force reassociation" },
Dmitry Shmidt98660862014-03-11 17:26:21 -07003249 { "reattach", wpa_cli_cmd_reattach, NULL,
3250 cli_cmd_flag_none,
3251 "= force reassociation back to the same BSS" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003252 { "preauthenticate", wpa_cli_cmd_preauthenticate, wpa_cli_complete_bss,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003253 cli_cmd_flag_none,
3254 "<BSSID> = force preauthentication" },
Dmitry Shmidt9839ecd2016-11-07 11:05:47 -08003255 { "identity", wpa_cli_cmd_identity, wpa_cli_complete_network_id,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003256 cli_cmd_flag_none,
3257 "<network id> <identity> = configure identity for an SSID" },
Dmitry Shmidt9839ecd2016-11-07 11:05:47 -08003258 { "password", wpa_cli_cmd_password, wpa_cli_complete_network_id,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003259 cli_cmd_flag_sensitive,
3260 "<network id> <password> = configure password for an SSID" },
Dmitry Shmidt9839ecd2016-11-07 11:05:47 -08003261 { "new_password", wpa_cli_cmd_new_password,
3262 wpa_cli_complete_network_id, cli_cmd_flag_sensitive,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003263 "<network id> <password> = change password for an SSID" },
Dmitry Shmidt9839ecd2016-11-07 11:05:47 -08003264 { "pin", wpa_cli_cmd_pin, wpa_cli_complete_network_id,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003265 cli_cmd_flag_sensitive,
3266 "<network id> <pin> = configure pin for an SSID" },
Dmitry Shmidt9839ecd2016-11-07 11:05:47 -08003267 { "otp", wpa_cli_cmd_otp, wpa_cli_complete_network_id,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003268 cli_cmd_flag_sensitive,
3269 "<network id> <password> = configure one-time-password for an SSID"
3270 },
Hai Shalom74f70d42019-02-11 14:42:39 -08003271 { "psk_passphrase", wpa_cli_cmd_psk_passphrase,
3272 wpa_cli_complete_network_id, cli_cmd_flag_sensitive,
3273 "<network id> <PSK/passphrase> = configure PSK/passphrase for an SSID" },
Dmitry Shmidt9839ecd2016-11-07 11:05:47 -08003274 { "passphrase", wpa_cli_cmd_passphrase, wpa_cli_complete_network_id,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003275 cli_cmd_flag_sensitive,
3276 "<network id> <passphrase> = configure private key passphrase\n"
3277 " for an SSID" },
Dmitry Shmidt9839ecd2016-11-07 11:05:47 -08003278 { "sim", wpa_cli_cmd_sim, wpa_cli_complete_network_id,
Dmitry Shmidt051af732013-10-22 13:52:46 -07003279 cli_cmd_flag_sensitive,
3280 "<network id> <pin> = report SIM operation result" },
Dmitry Shmidt9839ecd2016-11-07 11:05:47 -08003281 { "bssid", wpa_cli_cmd_bssid, wpa_cli_complete_network_id,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003282 cli_cmd_flag_none,
3283 "<network id> <BSSID> = set preferred BSSID for an SSID" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003284 { "blacklist", wpa_cli_cmd_blacklist, wpa_cli_complete_bss,
Dmitry Shmidt696359e2011-03-16 15:04:31 -07003285 cli_cmd_flag_none,
3286 "<BSSID> = add a BSSID to the blacklist\n"
3287 "blacklist clear = clear the blacklist\n"
3288 "blacklist = display the blacklist" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003289 { "log_level", wpa_cli_cmd_log_level, NULL,
Dmitry Shmidt696359e2011-03-16 15:04:31 -07003290 cli_cmd_flag_none,
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08003291 "<level> [<timestamp>] = update the log level/timestamp\n"
Dmitry Shmidt696359e2011-03-16 15:04:31 -07003292 "log_level = display the current log level and log options" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003293 { "list_networks", wpa_cli_cmd_list_networks, NULL,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003294 cli_cmd_flag_none,
3295 "= list configured networks" },
Dmitry Shmidt912c6ec2015-03-30 13:16:51 -07003296 { "select_network", wpa_cli_cmd_select_network,
3297 wpa_cli_complete_network_id,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003298 cli_cmd_flag_none,
3299 "<network id> = select a network (disable others)" },
Dmitry Shmidt912c6ec2015-03-30 13:16:51 -07003300 { "enable_network", wpa_cli_cmd_enable_network,
3301 wpa_cli_complete_network_id,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003302 cli_cmd_flag_none,
3303 "<network id> = enable a network" },
Dmitry Shmidt912c6ec2015-03-30 13:16:51 -07003304 { "disable_network", wpa_cli_cmd_disable_network,
3305 wpa_cli_complete_network_id,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003306 cli_cmd_flag_none,
3307 "<network id> = disable a network" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003308 { "add_network", wpa_cli_cmd_add_network, NULL,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003309 cli_cmd_flag_none,
3310 "= add a network" },
Dmitry Shmidt912c6ec2015-03-30 13:16:51 -07003311 { "remove_network", wpa_cli_cmd_remove_network,
3312 wpa_cli_complete_network_id,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003313 cli_cmd_flag_none,
3314 "<network id> = remove a network" },
Dmitry Shmidt912c6ec2015-03-30 13:16:51 -07003315 { "set_network", wpa_cli_cmd_set_network, wpa_cli_complete_network,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003316 cli_cmd_flag_sensitive,
3317 "<network id> <variable> <value> = set network variables (shows\n"
3318 " list of variables when run without arguments)" },
Dmitry Shmidt912c6ec2015-03-30 13:16:51 -07003319 { "get_network", wpa_cli_cmd_get_network, wpa_cli_complete_network,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003320 cli_cmd_flag_none,
3321 "<network id> <variable> = get network variables" },
Dmitry Shmidt912c6ec2015-03-30 13:16:51 -07003322 { "dup_network", wpa_cli_cmd_dup_network, wpa_cli_complete_dup_network,
Dmitry Shmidt684785c2014-05-12 13:34:29 -07003323 cli_cmd_flag_none,
3324 "<src network id> <dst network id> <variable> = duplicate network variables"
3325 },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003326 { "list_creds", wpa_cli_cmd_list_creds, NULL,
Dmitry Shmidt04949592012-07-19 12:16:46 -07003327 cli_cmd_flag_none,
3328 "= list configured credentials" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003329 { "add_cred", wpa_cli_cmd_add_cred, NULL,
Dmitry Shmidt04949592012-07-19 12:16:46 -07003330 cli_cmd_flag_none,
3331 "= add a credential" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003332 { "remove_cred", wpa_cli_cmd_remove_cred, NULL,
Dmitry Shmidt04949592012-07-19 12:16:46 -07003333 cli_cmd_flag_none,
3334 "<cred id> = remove a credential" },
Roshan Pius3a1667e2018-07-03 15:17:14 -07003335 { "set_cred", wpa_cli_cmd_set_cred, wpa_cli_complete_cred,
Dmitry Shmidt04949592012-07-19 12:16:46 -07003336 cli_cmd_flag_sensitive,
3337 "<cred id> <variable> <value> = set credential variables" },
Roshan Pius3a1667e2018-07-03 15:17:14 -07003338 { "get_cred", wpa_cli_cmd_get_cred, wpa_cli_complete_cred,
Dmitry Shmidt0cfd5f72014-04-04 14:48:05 -07003339 cli_cmd_flag_none,
3340 "<cred id> <variable> = get credential variables" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003341 { "save_config", wpa_cli_cmd_save_config, NULL,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003342 cli_cmd_flag_none,
3343 "= save the current configuration" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003344 { "disconnect", wpa_cli_cmd_disconnect, NULL,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003345 cli_cmd_flag_none,
3346 "= disconnect and wait for reassociate/reconnect command before\n"
3347 " connecting" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003348 { "reconnect", wpa_cli_cmd_reconnect, NULL,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003349 cli_cmd_flag_none,
3350 "= like reassociate, but only takes effect if already disconnected"
3351 },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003352 { "scan", wpa_cli_cmd_scan, NULL,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003353 cli_cmd_flag_none,
3354 "= request new BSS scan" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003355 { "scan_results", wpa_cli_cmd_scan_results, NULL,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003356 cli_cmd_flag_none,
3357 "= get latest scan results" },
Dmitry Shmidtd7ff03d2015-12-04 14:49:35 -08003358 { "abort_scan", wpa_cli_cmd_abort_scan, NULL,
3359 cli_cmd_flag_none,
3360 "= request ongoing scan to be aborted" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003361 { "bss", wpa_cli_cmd_bss, wpa_cli_complete_bss,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003362 cli_cmd_flag_none,
3363 "<<idx> | <bssid>> = get detailed scan result info" },
Dmitry Shmidt7f2c7532016-08-15 09:48:12 -07003364 { "get_capability", wpa_cli_cmd_get_capability,
3365 wpa_cli_complete_get_capability, cli_cmd_flag_none,
Dmitry Shmidt8da800a2013-04-24 12:57:01 -07003366 "<eap/pairwise/group/key_mgmt/proto/auth_alg/channels/freq/modes> "
Dmitry Shmidtaf9da312015-04-03 10:03:11 -07003367 "= get capabilities" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003368 { "reconfigure", wpa_cli_cmd_reconfigure, NULL,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003369 cli_cmd_flag_none,
3370 "= force wpa_supplicant to re-read its configuration file" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003371 { "terminate", wpa_cli_cmd_terminate, NULL,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003372 cli_cmd_flag_none,
3373 "= terminate wpa_supplicant" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003374 { "interface_add", wpa_cli_cmd_interface_add, NULL,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003375 cli_cmd_flag_none,
3376 "<ifname> <confname> <driver> <ctrl_interface> <driver_param>\n"
Dmitry Shmidtd7ff03d2015-12-04 14:49:35 -08003377 " <bridge_name> <create> <type> = adds new interface, all "
3378 "parameters but\n"
3379 " <ifname> are optional. Supported types are station ('sta') and "
3380 "AP ('ap')" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003381 { "interface_remove", wpa_cli_cmd_interface_remove, NULL,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003382 cli_cmd_flag_none,
3383 "<ifname> = removes the interface" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003384 { "interface_list", wpa_cli_cmd_interface_list, NULL,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003385 cli_cmd_flag_none,
3386 "= list available interfaces" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003387 { "ap_scan", wpa_cli_cmd_ap_scan, NULL,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003388 cli_cmd_flag_none,
3389 "<value> = set ap_scan parameter" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003390 { "scan_interval", wpa_cli_cmd_scan_interval, NULL,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003391 cli_cmd_flag_none,
3392 "<value> = set scan_interval parameter (in seconds)" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003393 { "bss_expire_age", wpa_cli_cmd_bss_expire_age, NULL,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003394 cli_cmd_flag_none,
3395 "<value> = set BSS expiration age parameter" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003396 { "bss_expire_count", wpa_cli_cmd_bss_expire_count, NULL,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003397 cli_cmd_flag_none,
3398 "<value> = set BSS expiration scan count parameter" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003399 { "bss_flush", wpa_cli_cmd_bss_flush, NULL,
Dmitry Shmidtf48e4f92012-08-24 11:14:44 -07003400 cli_cmd_flag_none,
3401 "<value> = set BSS flush age (0 by default)" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003402 { "ft_ds", wpa_cli_cmd_ft_ds, wpa_cli_complete_bss,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003403 cli_cmd_flag_none,
3404 "<addr> = request over-the-DS FT with <addr>" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003405 { "wps_pbc", wpa_cli_cmd_wps_pbc, wpa_cli_complete_bss,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003406 cli_cmd_flag_none,
3407 "[BSSID] = start Wi-Fi Protected Setup: Push Button Configuration" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003408 { "wps_pin", wpa_cli_cmd_wps_pin, wpa_cli_complete_bss,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003409 cli_cmd_flag_sensitive,
3410 "<BSSID> [PIN] = start WPS PIN method (returns PIN, if not "
3411 "hardcoded)" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003412 { "wps_check_pin", wpa_cli_cmd_wps_check_pin, NULL,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003413 cli_cmd_flag_sensitive,
3414 "<PIN> = verify PIN checksum" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003415 { "wps_cancel", wpa_cli_cmd_wps_cancel, NULL, cli_cmd_flag_none,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003416 "Cancels the pending WPS operation" },
Dmitry Shmidt04949592012-07-19 12:16:46 -07003417#ifdef CONFIG_WPS_NFC
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003418 { "wps_nfc", wpa_cli_cmd_wps_nfc, wpa_cli_complete_bss,
Dmitry Shmidt04949592012-07-19 12:16:46 -07003419 cli_cmd_flag_none,
3420 "[BSSID] = start Wi-Fi Protected Setup: NFC" },
Dmitry Shmidtf8623282013-02-20 14:34:59 -08003421 { "wps_nfc_config_token", wpa_cli_cmd_wps_nfc_config_token, NULL,
3422 cli_cmd_flag_none,
3423 "<WPS|NDEF> = build configuration token" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003424 { "wps_nfc_token", wpa_cli_cmd_wps_nfc_token, NULL,
Dmitry Shmidt04949592012-07-19 12:16:46 -07003425 cli_cmd_flag_none,
3426 "<WPS|NDEF> = create password token" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003427 { "wps_nfc_tag_read", wpa_cli_cmd_wps_nfc_tag_read, NULL,
Dmitry Shmidt04949592012-07-19 12:16:46 -07003428 cli_cmd_flag_sensitive,
3429 "<hexdump of payload> = report read NFC tag with WPS data" },
Dmitry Shmidtd5e49232012-12-03 15:08:10 -08003430 { "nfc_get_handover_req", wpa_cli_cmd_nfc_get_handover_req, NULL,
3431 cli_cmd_flag_none,
3432 "<NDEF> <WPS> = create NFC handover request" },
3433 { "nfc_get_handover_sel", wpa_cli_cmd_nfc_get_handover_sel, NULL,
3434 cli_cmd_flag_none,
3435 "<NDEF> <WPS> = create NFC handover select" },
Dmitry Shmidtf8623282013-02-20 14:34:59 -08003436 { "nfc_report_handover", wpa_cli_cmd_nfc_report_handover, NULL,
3437 cli_cmd_flag_none,
3438 "<role> <type> <hexdump of req> <hexdump of sel> = report completed "
3439 "NFC handover" },
Dmitry Shmidt04949592012-07-19 12:16:46 -07003440#endif /* CONFIG_WPS_NFC */
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003441 { "wps_reg", wpa_cli_cmd_wps_reg, wpa_cli_complete_bss,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003442 cli_cmd_flag_sensitive,
3443 "<BSSID> <AP PIN> = start WPS Registrar to configure an AP" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003444 { "wps_ap_pin", wpa_cli_cmd_wps_ap_pin, NULL,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003445 cli_cmd_flag_sensitive,
3446 "[params..] = enable/disable AP PIN" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003447 { "wps_er_start", wpa_cli_cmd_wps_er_start, NULL,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003448 cli_cmd_flag_none,
3449 "[IP address] = start Wi-Fi Protected Setup External Registrar" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003450 { "wps_er_stop", wpa_cli_cmd_wps_er_stop, NULL,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003451 cli_cmd_flag_none,
3452 "= stop Wi-Fi Protected Setup External Registrar" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003453 { "wps_er_pin", wpa_cli_cmd_wps_er_pin, NULL,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003454 cli_cmd_flag_sensitive,
3455 "<UUID> <PIN> = add an Enrollee PIN to External Registrar" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003456 { "wps_er_pbc", wpa_cli_cmd_wps_er_pbc, NULL,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003457 cli_cmd_flag_none,
3458 "<UUID> = accept an Enrollee PBC using External Registrar" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003459 { "wps_er_learn", wpa_cli_cmd_wps_er_learn, NULL,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003460 cli_cmd_flag_sensitive,
3461 "<UUID> <PIN> = learn AP configuration" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003462 { "wps_er_set_config", wpa_cli_cmd_wps_er_set_config, NULL,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003463 cli_cmd_flag_none,
3464 "<UUID> <network id> = set AP configuration for enrolling" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003465 { "wps_er_config", wpa_cli_cmd_wps_er_config, NULL,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003466 cli_cmd_flag_sensitive,
3467 "<UUID> <PIN> <SSID> <auth> <encr> <key> = configure AP" },
Dmitry Shmidt04949592012-07-19 12:16:46 -07003468#ifdef CONFIG_WPS_NFC
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003469 { "wps_er_nfc_config_token", wpa_cli_cmd_wps_er_nfc_config_token, NULL,
Dmitry Shmidt04949592012-07-19 12:16:46 -07003470 cli_cmd_flag_none,
3471 "<WPS/NDEF> <UUID> = build NFC configuration token" },
3472#endif /* CONFIG_WPS_NFC */
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003473 { "ibss_rsn", wpa_cli_cmd_ibss_rsn, NULL,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003474 cli_cmd_flag_none,
3475 "<addr> = request RSN authentication with <addr> in IBSS" },
3476#ifdef CONFIG_AP
Dmitry Shmidt9839ecd2016-11-07 11:05:47 -08003477 { "sta", wpa_cli_cmd_sta, wpa_cli_complete_sta,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003478 cli_cmd_flag_none,
3479 "<addr> = get information about an associated station (AP)" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003480 { "all_sta", wpa_cli_cmd_all_sta, NULL,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003481 cli_cmd_flag_none,
3482 "= get information about all associated stations (AP)" },
Dmitry Shmidt9839ecd2016-11-07 11:05:47 -08003483 { "list_sta", wpa_cli_cmd_list_sta, NULL,
Dmitry Shmidt04949592012-07-19 12:16:46 -07003484 cli_cmd_flag_none,
Dmitry Shmidt9839ecd2016-11-07 11:05:47 -08003485 "= list all stations (AP)" },
3486 { "deauthenticate", wpa_cli_cmd_deauthenticate,
3487 wpa_cli_complete_deauthenticate, cli_cmd_flag_none,
Dmitry Shmidt04949592012-07-19 12:16:46 -07003488 "<addr> = deauthenticate a station" },
Dmitry Shmidt9839ecd2016-11-07 11:05:47 -08003489 { "disassociate", wpa_cli_cmd_disassociate,
3490 wpa_cli_complete_disassociate, cli_cmd_flag_none,
Dmitry Shmidt04949592012-07-19 12:16:46 -07003491 "<addr> = disassociate a station" },
Dmitry Shmidte0e48dc2013-11-18 12:00:06 -08003492 { "chan_switch", wpa_cli_cmd_chanswitch, NULL,
3493 cli_cmd_flag_none,
3494 "<cs_count> <freq> [sec_channel_offset=] [center_freq1=]"
3495 " [center_freq2=] [bandwidth=] [blocktx] [ht|vht]"
3496 " = CSA parameters" },
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003497#endif /* CONFIG_AP */
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003498 { "suspend", wpa_cli_cmd_suspend, NULL, cli_cmd_flag_none,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003499 "= notification of suspend/hibernate" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003500 { "resume", wpa_cli_cmd_resume, NULL, cli_cmd_flag_none,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003501 "= notification of resume/thaw" },
Dmitry Shmidt21de2142014-04-08 10:50:52 -07003502#ifdef CONFIG_TESTING_OPTIONS
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003503 { "drop_sa", wpa_cli_cmd_drop_sa, NULL, cli_cmd_flag_none,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003504 "= drop SA without deauth/disassoc (test command)" },
Dmitry Shmidt21de2142014-04-08 10:50:52 -07003505#endif /* CONFIG_TESTING_OPTIONS */
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003506 { "roam", wpa_cli_cmd_roam, wpa_cli_complete_bss,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003507 cli_cmd_flag_none,
3508 "<addr> = roam to the specified BSS" },
Dmitry Shmidt6c0da2b2015-01-05 13:08:17 -08003509#ifdef CONFIG_MESH
3510 { "mesh_interface_add", wpa_cli_cmd_mesh_interface_add, NULL,
3511 cli_cmd_flag_none,
3512 "[ifname] = Create a new mesh interface" },
3513 { "mesh_group_add", wpa_cli_cmd_mesh_group_add, NULL,
3514 cli_cmd_flag_none,
3515 "<network id> = join a mesh network (disable others)" },
3516 { "mesh_group_remove", wpa_cli_cmd_mesh_group_remove, NULL,
3517 cli_cmd_flag_none,
3518 "<ifname> = Remove mesh group interface" },
Dmitry Shmidte4663042016-04-04 10:07:49 -07003519 { "mesh_peer_remove", wpa_cli_cmd_mesh_peer_remove, NULL,
3520 cli_cmd_flag_none,
3521 "<addr> = Remove a mesh peer" },
3522 { "mesh_peer_add", wpa_cli_cmd_mesh_peer_add, NULL,
3523 cli_cmd_flag_none,
3524 "<addr> [duration=<seconds>] = Add a mesh peer" },
Hai Shalom81f62d82019-07-22 12:10:00 -07003525 { "mesh_link_probe", wpa_cli_cmd_mesh_link_probe, NULL,
3526 cli_cmd_flag_none,
3527 "<addr> [payload=<hex dump of payload>] = Probe a mesh link for a given peer by injecting a frame." },
Dmitry Shmidt6c0da2b2015-01-05 13:08:17 -08003528#endif /* CONFIG_MESH */
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003529#ifdef CONFIG_P2P
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003530 { "p2p_find", wpa_cli_cmd_p2p_find, wpa_cli_complete_p2p_find,
3531 cli_cmd_flag_none,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003532 "[timeout] [type=*] = find P2P Devices for up-to timeout seconds" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003533 { "p2p_stop_find", wpa_cli_cmd_p2p_stop_find, NULL, cli_cmd_flag_none,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003534 "= stop P2P Devices search" },
Dmitry Shmidt216983b2015-02-06 10:50:36 -08003535 { "p2p_asp_provision", wpa_cli_cmd_p2p_asp_provision, NULL,
3536 cli_cmd_flag_none,
3537 "<addr> adv_id=<adv_id> conncap=<conncap> [info=<infodata>] = provision with a P2P ASP Device" },
3538 { "p2p_asp_provision_resp", wpa_cli_cmd_p2p_asp_provision_resp, NULL,
3539 cli_cmd_flag_none,
3540 "<addr> adv_id=<adv_id> [role<conncap>] [info=<infodata>] = provision with a P2P ASP Device" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003541 { "p2p_connect", wpa_cli_cmd_p2p_connect, wpa_cli_complete_p2p_connect,
3542 cli_cmd_flag_none,
3543 "<addr> <\"pbc\"|PIN> [ht40] = connect to a P2P Device" },
3544 { "p2p_listen", wpa_cli_cmd_p2p_listen, NULL, cli_cmd_flag_none,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003545 "[timeout] = listen for P2P Devices for up-to timeout seconds" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003546 { "p2p_group_remove", wpa_cli_cmd_p2p_group_remove,
3547 wpa_cli_complete_p2p_group_remove, cli_cmd_flag_none,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003548 "<ifname> = remove P2P group interface (terminate group if GO)" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003549 { "p2p_group_add", wpa_cli_cmd_p2p_group_add, NULL, cli_cmd_flag_none,
3550 "[ht40] = add a new P2P group (local end as GO)" },
Dmitry Shmidt849734c2016-05-27 09:59:01 -07003551 { "p2p_group_member", wpa_cli_cmd_p2p_group_member, NULL,
3552 cli_cmd_flag_none,
3553 "<dev_addr> = Get peer interface address on local GO using peer Device Address" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003554 { "p2p_prov_disc", wpa_cli_cmd_p2p_prov_disc,
3555 wpa_cli_complete_p2p_peer, cli_cmd_flag_none,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003556 "<addr> <method> = request provisioning discovery" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003557 { "p2p_get_passphrase", wpa_cli_cmd_p2p_get_passphrase, NULL,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003558 cli_cmd_flag_none,
3559 "= get the passphrase for a group (GO only)" },
3560 { "p2p_serv_disc_req", wpa_cli_cmd_p2p_serv_disc_req,
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003561 wpa_cli_complete_p2p_peer, cli_cmd_flag_none,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003562 "<addr> <TLVs> = schedule service discovery request" },
3563 { "p2p_serv_disc_cancel_req", wpa_cli_cmd_p2p_serv_disc_cancel_req,
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003564 NULL, cli_cmd_flag_none,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003565 "<id> = cancel pending service discovery request" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003566 { "p2p_serv_disc_resp", wpa_cli_cmd_p2p_serv_disc_resp, NULL,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003567 cli_cmd_flag_none,
3568 "<freq> <addr> <dialog token> <TLVs> = service discovery response" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003569 { "p2p_service_update", wpa_cli_cmd_p2p_service_update, NULL,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003570 cli_cmd_flag_none,
3571 "= indicate change in local services" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003572 { "p2p_serv_disc_external", wpa_cli_cmd_p2p_serv_disc_external, NULL,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003573 cli_cmd_flag_none,
3574 "<external> = set external processing of service discovery" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003575 { "p2p_service_flush", wpa_cli_cmd_p2p_service_flush, NULL,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003576 cli_cmd_flag_none,
3577 "= remove all stored service entries" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003578 { "p2p_service_add", wpa_cli_cmd_p2p_service_add, NULL,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003579 cli_cmd_flag_none,
Dmitry Shmidt216983b2015-02-06 10:50:36 -08003580 "<bonjour|upnp|asp> <query|version> <response|service> = add a local "
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003581 "service" },
Dmitry Shmidt216983b2015-02-06 10:50:36 -08003582 { "p2p_service_rep", wpa_cli_cmd_p2p_service_rep, NULL,
3583 cli_cmd_flag_none,
3584 "asp <auto> <adv_id> <svc_state> <svc_string> [<svc_info>] = replace "
3585 "local ASP service" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003586 { "p2p_service_del", wpa_cli_cmd_p2p_service_del, NULL,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003587 cli_cmd_flag_none,
3588 "<bonjour|upnp> <query|version> [|service] = remove a local "
3589 "service" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003590 { "p2p_reject", wpa_cli_cmd_p2p_reject, wpa_cli_complete_p2p_peer,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003591 cli_cmd_flag_none,
3592 "<addr> = reject connection attempts from a specific peer" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003593 { "p2p_invite", wpa_cli_cmd_p2p_invite, NULL,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003594 cli_cmd_flag_none,
3595 "<cmd> [peer=addr] = invite peer" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003596 { "p2p_peers", wpa_cli_cmd_p2p_peers, NULL, cli_cmd_flag_none,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003597 "[discovered] = list known (optionally, only fully discovered) P2P "
3598 "peers" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003599 { "p2p_peer", wpa_cli_cmd_p2p_peer, wpa_cli_complete_p2p_peer,
3600 cli_cmd_flag_none,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003601 "<address> = show information about known P2P peer" },
Dmitry Shmidt391c59f2013-09-03 12:16:28 -07003602 { "p2p_set", wpa_cli_cmd_p2p_set, wpa_cli_complete_p2p_set,
3603 cli_cmd_flag_none,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003604 "<field> <value> = set a P2P parameter" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003605 { "p2p_flush", wpa_cli_cmd_p2p_flush, NULL, cli_cmd_flag_none,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003606 "= flush P2P state" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003607 { "p2p_cancel", wpa_cli_cmd_p2p_cancel, NULL, cli_cmd_flag_none,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003608 "= cancel P2P group formation" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003609 { "p2p_unauthorize", wpa_cli_cmd_p2p_unauthorize,
3610 wpa_cli_complete_p2p_peer, cli_cmd_flag_none,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003611 "<address> = unauthorize a peer" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003612 { "p2p_presence_req", wpa_cli_cmd_p2p_presence_req, NULL,
3613 cli_cmd_flag_none,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003614 "[<duration> <interval>] [<duration> <interval>] = request GO "
3615 "presence" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003616 { "p2p_ext_listen", wpa_cli_cmd_p2p_ext_listen, NULL,
3617 cli_cmd_flag_none,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003618 "[<period> <interval>] = set extended listen timing" },
Dmitry Shmidt391c59f2013-09-03 12:16:28 -07003619 { "p2p_remove_client", wpa_cli_cmd_p2p_remove_client,
3620 wpa_cli_complete_p2p_peer, cli_cmd_flag_none,
3621 "<address|iface=address> = remove a peer from all groups" },
Roshan Pius3a1667e2018-07-03 15:17:14 -07003622#endif /* CONFIG_P2P */
Dmitry Shmidtd80a4012015-11-05 16:35:40 -08003623 { "vendor_elem_add", wpa_cli_cmd_vendor_elem_add, NULL,
3624 cli_cmd_flag_none,
3625 "<frame id> <hexdump of elem(s)> = add vendor specific IEs to frame(s)\n"
3626 VENDOR_ELEM_FRAME_ID },
3627 { "vendor_elem_get", wpa_cli_cmd_vendor_elem_get, NULL,
3628 cli_cmd_flag_none,
3629 "<frame id> = get vendor specific IE(s) to frame(s)\n"
3630 VENDOR_ELEM_FRAME_ID },
3631 { "vendor_elem_remove", wpa_cli_cmd_vendor_elem_remove, NULL,
3632 cli_cmd_flag_none,
3633 "<frame id> <hexdump of elem(s)> = remove vendor specific IE(s) in frame(s)\n"
3634 VENDOR_ELEM_FRAME_ID },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003635#ifdef CONFIG_WIFI_DISPLAY
3636 { "wfd_subelem_set", wpa_cli_cmd_wfd_subelem_set, NULL,
3637 cli_cmd_flag_none,
3638 "<subelem> [contents] = set Wi-Fi Display subelement" },
3639 { "wfd_subelem_get", wpa_cli_cmd_wfd_subelem_get, NULL,
3640 cli_cmd_flag_none,
3641 "<subelem> = get Wi-Fi Display subelement" },
3642#endif /* CONFIG_WIFI_DISPLAY */
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08003643#ifdef CONFIG_INTERWORKING
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003644 { "fetch_anqp", wpa_cli_cmd_fetch_anqp, NULL, cli_cmd_flag_none,
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08003645 "= fetch ANQP information for all APs" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003646 { "stop_fetch_anqp", wpa_cli_cmd_stop_fetch_anqp, NULL,
3647 cli_cmd_flag_none,
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08003648 "= stop fetch_anqp operation" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003649 { "interworking_select", wpa_cli_cmd_interworking_select, NULL,
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08003650 cli_cmd_flag_none,
3651 "[auto] = perform Interworking network selection" },
3652 { "interworking_connect", wpa_cli_cmd_interworking_connect,
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003653 wpa_cli_complete_bss, cli_cmd_flag_none,
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08003654 "<BSSID> = connect using Interworking credentials" },
Dmitry Shmidt7f656022015-02-25 14:36:37 -08003655 { "interworking_add_network", wpa_cli_cmd_interworking_add_network,
3656 wpa_cli_complete_bss, cli_cmd_flag_none,
3657 "<BSSID> = connect using Interworking credentials" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003658 { "anqp_get", wpa_cli_cmd_anqp_get, wpa_cli_complete_bss,
3659 cli_cmd_flag_none,
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08003660 "<addr> <info id>[,<info id>]... = request ANQP information" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003661 { "gas_request", wpa_cli_cmd_gas_request, wpa_cli_complete_bss,
3662 cli_cmd_flag_none,
3663 "<addr> <AdvProtoID> [QueryReq] = GAS request" },
3664 { "gas_response_get", wpa_cli_cmd_gas_response_get,
3665 wpa_cli_complete_bss, cli_cmd_flag_none,
3666 "<addr> <dialog token> [start,len] = Fetch last GAS response" },
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08003667#endif /* CONFIG_INTERWORKING */
Dmitry Shmidt04949592012-07-19 12:16:46 -07003668#ifdef CONFIG_HS20
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003669 { "hs20_anqp_get", wpa_cli_cmd_hs20_anqp_get, wpa_cli_complete_bss,
3670 cli_cmd_flag_none,
Dmitry Shmidt04949592012-07-19 12:16:46 -07003671 "<addr> <subtype>[,<subtype>]... = request HS 2.0 ANQP information"
3672 },
3673 { "nai_home_realm_list", wpa_cli_cmd_get_nai_home_realm_list,
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003674 wpa_cli_complete_bss, cli_cmd_flag_none,
Dmitry Shmidt04949592012-07-19 12:16:46 -07003675 "<addr> <home realm> = get HS20 nai home realm list" },
Dmitry Shmidtf21452a2014-02-26 10:55:25 -08003676 { "hs20_icon_request", wpa_cli_cmd_hs20_icon_request,
3677 wpa_cli_complete_bss, cli_cmd_flag_none,
3678 "<addr> <icon name> = get Hotspot 2.0 OSU icon" },
3679 { "fetch_osu", wpa_cli_cmd_fetch_osu, NULL, cli_cmd_flag_none,
3680 "= fetch OSU provider information from all APs" },
3681 { "cancel_fetch_osu", wpa_cli_cmd_cancel_fetch_osu, NULL,
3682 cli_cmd_flag_none,
3683 "= cancel fetch_osu command" },
Dmitry Shmidt04949592012-07-19 12:16:46 -07003684#endif /* CONFIG_HS20 */
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003685 { "sta_autoconnect", wpa_cli_cmd_sta_autoconnect, NULL,
3686 cli_cmd_flag_none,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003687 "<0/1> = disable/enable automatic reconnection" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003688 { "tdls_discover", wpa_cli_cmd_tdls_discover, NULL,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003689 cli_cmd_flag_none,
3690 "<addr> = request TDLS discovery with <addr>" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003691 { "tdls_setup", wpa_cli_cmd_tdls_setup, NULL,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003692 cli_cmd_flag_none,
3693 "<addr> = request TDLS setup with <addr>" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003694 { "tdls_teardown", wpa_cli_cmd_tdls_teardown, NULL,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003695 cli_cmd_flag_none,
3696 "<addr> = tear down TDLS with <addr>" },
Dmitry Shmidtcc00d5d2015-05-04 10:34:12 -07003697 { "tdls_link_status", wpa_cli_cmd_tdls_link_status, NULL,
3698 cli_cmd_flag_none,
3699 "<addr> = TDLS link status with <addr>" },
Dmitry Shmidt6c0da2b2015-01-05 13:08:17 -08003700 { "wmm_ac_addts", wpa_cli_cmd_wmm_ac_addts, NULL,
3701 cli_cmd_flag_none,
3702 "<uplink/downlink/bidi> <tsid=0..7> <up=0..7> [nominal_msdu_size=#] "
3703 "[mean_data_rate=#] [min_phy_rate=#] [sba=#] [fixed_nominal_msdu] "
3704 "= add WMM-AC traffic stream" },
3705 { "wmm_ac_delts", wpa_cli_cmd_wmm_ac_delts, NULL,
3706 cli_cmd_flag_none,
3707 "<tsid> = delete WMM-AC traffic stream" },
3708 { "wmm_ac_status", wpa_cli_cmd_wmm_ac_status, NULL,
3709 cli_cmd_flag_none,
3710 "= show status for Wireless Multi-Media Admission-Control" },
3711 { "tdls_chan_switch", wpa_cli_cmd_tdls_chan_switch, NULL,
3712 cli_cmd_flag_none,
3713 "<addr> <oper class> <freq> [sec_channel_offset=] [center_freq1=] "
3714 "[center_freq2=] [bandwidth=] [ht|vht] = enable channel switching "
3715 "with TDLS peer" },
3716 { "tdls_cancel_chan_switch", wpa_cli_cmd_tdls_cancel_chan_switch, NULL,
3717 cli_cmd_flag_none,
3718 "<addr> = disable channel switching with TDLS peer <addr>" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003719 { "signal_poll", wpa_cli_cmd_signal_poll, NULL,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003720 cli_cmd_flag_none,
3721 "= get signal parameters" },
Dmitry Shmidt7d56b752015-12-22 10:59:44 -08003722 { "signal_monitor", wpa_cli_cmd_signal_monitor, NULL,
3723 cli_cmd_flag_none,
3724 "= set signal monitor parameters" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003725 { "pktcnt_poll", wpa_cli_cmd_pktcnt_poll, NULL,
Yuhao Zhengfcd6f212012-07-27 10:37:52 -07003726 cli_cmd_flag_none,
3727 "= get TX/RX packet counters" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003728 { "reauthenticate", wpa_cli_cmd_reauthenticate, NULL,
3729 cli_cmd_flag_none,
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08003730 "= trigger IEEE 802.1X/EAPOL reauthentication" },
Dmitry Shmidt04949592012-07-19 12:16:46 -07003731#ifdef CONFIG_AUTOSCAN
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003732 { "autoscan", wpa_cli_cmd_autoscan, NULL, cli_cmd_flag_none,
Dmitry Shmidt04949592012-07-19 12:16:46 -07003733 "[params] = Set or unset (if none) autoscan parameters" },
3734#endif /* CONFIG_AUTOSCAN */
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -08003735#ifdef CONFIG_WNM
3736 { "wnm_sleep", wpa_cli_cmd_wnm_sleep, NULL, cli_cmd_flag_none,
3737 "<enter/exit> [interval=#] = enter/exit WNM-Sleep mode" },
Dmitry Shmidt44c95782013-05-17 09:51:35 -07003738 { "wnm_bss_query", wpa_cli_cmd_wnm_bss_query, NULL, cli_cmd_flag_none,
Dmitry Shmidtd2986c22017-10-23 14:22:09 -07003739 "<query reason> [list]"
3740 " [neighbor=<BSSID>,<BSSID information>,<operating class>,<channel number>,<PHY type>[,<hexdump of optional subelements>]"
3741 " = Send BSS Transition Management Query" },
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -08003742#endif /* CONFIG_WNM */
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003743 { "raw", wpa_cli_cmd_raw, NULL, cli_cmd_flag_sensitive,
3744 "<params..> = Sent unprocessed command" },
Dmitry Shmidt444d5672013-04-01 13:08:44 -07003745 { "flush", wpa_cli_cmd_flush, NULL, cli_cmd_flag_none,
3746 "= flush wpa_supplicant state" },
Dmitry Shmidtc5ec7f52012-03-06 16:33:24 -08003747#ifdef ANDROID
Dmitry Shmidt292b0c32013-11-22 12:54:42 -08003748 { "driver", wpa_cli_cmd_driver, NULL, cli_cmd_flag_none,
Dmitry Shmidt0716c122011-04-08 15:03:17 -07003749 "<command> = driver private commands" },
Dmitry Shmidt292b0c32013-11-22 12:54:42 -08003750#endif /* ANDROID */
Dmitry Shmidtfb79edc2014-01-10 10:45:54 -08003751 { "radio_work", wpa_cli_cmd_radio_work, NULL, cli_cmd_flag_none,
3752 "= radio_work <show/add/done>" },
Dmitry Shmidta38abf92014-03-06 13:38:44 -08003753 { "vendor", wpa_cli_cmd_vendor, NULL, cli_cmd_flag_none,
3754 "<vendor id> <command id> [<hex formatted command argument>] = Send vendor command"
3755 },
Dmitry Shmidt6c0da2b2015-01-05 13:08:17 -08003756 { "neighbor_rep_request",
3757 wpa_cli_cmd_neighbor_rep_request, NULL, cli_cmd_flag_none,
Dmitry Shmidt849734c2016-05-27 09:59:01 -07003758 "[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)"
Dmitry Shmidt6c0da2b2015-01-05 13:08:17 -08003759 },
3760 { "erp_flush", wpa_cli_cmd_erp_flush, NULL, cli_cmd_flag_none,
3761 "= flush ERP keys" },
3762 { "mac_rand_scan",
3763 wpa_cli_cmd_mac_rand_scan, NULL, cli_cmd_flag_none,
3764 "<scan|sched|pno|all> enable=<0/1> [addr=mac-address "
3765 "mask=mac-address-mask] = scan MAC randomization"
3766 },
Dmitry Shmidtd80a4012015-11-05 16:35:40 -08003767 { "get_pref_freq_list", wpa_cli_cmd_get_pref_freq_list, NULL,
3768 cli_cmd_flag_none,
3769 "<interface type> = retrieve preferred freq list for the specified interface type" },
Dmitry Shmidt58d12ad2016-07-28 10:07:03 -07003770 { "p2p_lo_start", wpa_cli_cmd_p2p_lo_start, NULL,
3771 cli_cmd_flag_none,
3772 "<freq> <period> <interval> <count> = start P2P listen offload" },
3773 { "p2p_lo_stop", wpa_cli_cmd_p2p_lo_stop, NULL,
3774 cli_cmd_flag_none,
3775 "= stop P2P listen offload" },
Dmitry Shmidtd2986c22017-10-23 14:22:09 -07003776#ifdef CONFIG_DPP
3777 { "dpp_qr_code", wpa_cli_cmd_dpp_qr_code, NULL, cli_cmd_flag_none,
3778 "report a scanned DPP URI from a QR Code" },
3779 { "dpp_bootstrap_gen", wpa_cli_cmd_dpp_bootstrap_gen, NULL,
3780 cli_cmd_flag_sensitive,
3781 "type=<qrcode> [chan=..] [mac=..] [info=..] [curve=..] [key=..] = generate DPP bootstrap information" },
3782 { "dpp_bootstrap_remove", wpa_cli_cmd_dpp_bootstrap_remove, NULL,
3783 cli_cmd_flag_none,
3784 "*|<id> = remove DPP bootstrap information" },
3785 { "dpp_bootstrap_get_uri", wpa_cli_cmd_dpp_bootstrap_get_uri, NULL,
3786 cli_cmd_flag_none,
3787 "<id> = get DPP bootstrap URI" },
3788 { "dpp_bootstrap_info", wpa_cli_cmd_dpp_bootstrap_info, NULL,
3789 cli_cmd_flag_none,
3790 "<id> = show DPP bootstrap information" },
Hai Shalom899fcc72020-10-19 14:38:18 -07003791 { "dpp_bootstrap_set", wpa_cli_cmd_dpp_bootstrap_set, NULL,
3792 cli_cmd_flag_none,
3793 "<id> [conf=..] [ssid=<SSID>] [ssid_charset=#] [psk=<PSK>] [pass=<passphrase>] [configurator=<id>] [conn_status=#] [akm_use_selector=<0|1>] [group_id=..] [expiry=#] [csrattrs=..] = set DPP configurator parameters" },
Dmitry Shmidtd2986c22017-10-23 14:22:09 -07003794 { "dpp_auth_init", wpa_cli_cmd_dpp_auth_init, NULL, cli_cmd_flag_none,
3795 "peer=<id> [own=<id>] = initiate DPP bootstrapping" },
3796 { "dpp_listen", wpa_cli_cmd_dpp_listen, NULL, cli_cmd_flag_none,
3797 "<freq in MHz> = start DPP listen" },
3798 { "dpp_stop_listen", wpa_cli_cmd_dpp_stop_listen, NULL,
3799 cli_cmd_flag_none,
3800 "= stop DPP listen" },
3801 { "dpp_configurator_add", wpa_cli_cmd_dpp_configurator_add, NULL,
3802 cli_cmd_flag_sensitive,
3803 "[curve=..] [key=..] = add DPP configurator" },
3804 { "dpp_configurator_remove", wpa_cli_cmd_dpp_configurator_remove, NULL,
3805 cli_cmd_flag_none,
3806 "*|<id> = remove DPP configurator" },
Roshan Pius3a1667e2018-07-03 15:17:14 -07003807 { "dpp_configurator_get_key", wpa_cli_cmd_dpp_configurator_get_key,
3808 NULL, cli_cmd_flag_none,
3809 "<id> = Get DPP configurator's private key" },
Hai Shalom74f70d42019-02-11 14:42:39 -08003810 { "dpp_configurator_sign", wpa_cli_cmd_dpp_configurator_sign, NULL,
3811 cli_cmd_flag_none,
3812 "conf=<role> configurator=<id> = generate self DPP configuration" },
Dmitry Shmidtd2986c22017-10-23 14:22:09 -07003813 { "dpp_pkex_add", wpa_cli_cmd_dpp_pkex_add, NULL,
3814 cli_cmd_flag_sensitive,
3815 "add PKEX code" },
3816 { "dpp_pkex_remove", wpa_cli_cmd_dpp_pkex_remove, NULL,
3817 cli_cmd_flag_none,
3818 "*|<id> = remove DPP pkex information" },
Hai Shalom899fcc72020-10-19 14:38:18 -07003819#ifdef CONFIG_DPP2
3820 { "dpp_chirp", wpa_cli_cmd_dpp_chirp, NULL,
3821 cli_cmd_flag_none,
3822 "own=<BI ID> iter=<count> = start DPP chirp" },
3823 { "dpp_stop_chirp", wpa_cli_cmd_dpp_stop_chirp, NULL,
3824 cli_cmd_flag_none,
3825 "= stop DPP chirp" },
3826#endif /* CONFIG_DPP2 */
Dmitry Shmidtd2986c22017-10-23 14:22:09 -07003827#endif /* CONFIG_DPP */
Hai Shalom899fcc72020-10-19 14:38:18 -07003828 { "all_bss", wpa_cli_cmd_all_bss, NULL, cli_cmd_flag_none,
3829 "= list all BSS entries (scan results)" },
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003830 { NULL, NULL, NULL, cli_cmd_flag_none, NULL }
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003831};
3832
3833
3834/*
3835 * Prints command usage, lines are padded with the specified string.
3836 */
Dmitry Shmidt1d755d02015-04-28 10:34:29 -07003837static void print_cmd_help(const struct wpa_cli_cmd *cmd, const char *pad)
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003838{
3839 char c;
3840 size_t n;
3841
3842 printf("%s%s ", pad, cmd->cmd);
3843 for (n = 0; (c = cmd->usage[n]); n++) {
3844 printf("%c", c);
3845 if (c == '\n')
3846 printf("%s", pad);
3847 }
3848 printf("\n");
3849}
3850
3851
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003852static void print_help(const char *cmd)
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003853{
3854 int n;
3855 printf("commands:\n");
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003856 for (n = 0; wpa_cli_commands[n].cmd; n++) {
3857 if (cmd == NULL || str_starts(wpa_cli_commands[n].cmd, cmd))
3858 print_cmd_help(&wpa_cli_commands[n], " ");
3859 }
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003860}
3861
3862
3863static int wpa_cli_edit_filter_history_cb(void *ctx, const char *cmd)
3864{
3865 const char *c, *delim;
3866 int n;
3867 size_t len;
3868
3869 delim = os_strchr(cmd, ' ');
3870 if (delim)
3871 len = delim - cmd;
3872 else
3873 len = os_strlen(cmd);
3874
3875 for (n = 0; (c = wpa_cli_commands[n].cmd); n++) {
3876 if (os_strncasecmp(cmd, c, len) == 0 && len == os_strlen(c))
3877 return (wpa_cli_commands[n].flags &
3878 cli_cmd_flag_sensitive);
3879 }
3880 return 0;
3881}
3882
3883
3884static char ** wpa_list_cmd_list(void)
3885{
3886 char **res;
3887 int i, count;
Dmitry Shmidtf7e0a992013-05-23 11:03:10 -07003888 struct cli_txt_entry *e;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003889
Dmitry Shmidt68d0e3e2013-10-28 17:59:21 -07003890 count = ARRAY_SIZE(wpa_cli_commands);
Dmitry Shmidtf7e0a992013-05-23 11:03:10 -07003891 count += dl_list_len(&p2p_groups);
3892 count += dl_list_len(&ifnames);
3893 res = os_calloc(count + 1, sizeof(char *));
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003894 if (res == NULL)
3895 return NULL;
3896
3897 for (i = 0; wpa_cli_commands[i].cmd; i++) {
3898 res[i] = os_strdup(wpa_cli_commands[i].cmd);
3899 if (res[i] == NULL)
3900 break;
3901 }
3902
Dmitry Shmidtf7e0a992013-05-23 11:03:10 -07003903 dl_list_for_each(e, &p2p_groups, struct cli_txt_entry, list) {
3904 size_t len = 8 + os_strlen(e->txt);
3905 res[i] = os_malloc(len);
3906 if (res[i] == NULL)
3907 break;
3908 os_snprintf(res[i], len, "ifname=%s", e->txt);
3909 i++;
3910 }
3911
3912 dl_list_for_each(e, &ifnames, struct cli_txt_entry, list) {
3913 res[i] = os_strdup(e->txt);
3914 if (res[i] == NULL)
3915 break;
3916 i++;
3917 }
3918
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003919 return res;
3920}
3921
3922
3923static char ** wpa_cli_cmd_completion(const char *cmd, const char *str,
3924 int pos)
3925{
3926 int i;
3927
3928 for (i = 0; wpa_cli_commands[i].cmd; i++) {
3929 if (os_strcasecmp(wpa_cli_commands[i].cmd, cmd) == 0) {
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003930 if (wpa_cli_commands[i].completion)
3931 return wpa_cli_commands[i].completion(str,
3932 pos);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003933 edit_clear_line();
3934 printf("\r%s\n", wpa_cli_commands[i].usage);
3935 edit_redraw();
3936 break;
3937 }
3938 }
3939
3940 return NULL;
3941}
3942
3943
3944static char ** wpa_cli_edit_completion_cb(void *ctx, const char *str, int pos)
3945{
3946 char **res;
3947 const char *end;
3948 char *cmd;
3949
Dmitry Shmidtf7e0a992013-05-23 11:03:10 -07003950 if (pos > 7 && os_strncasecmp(str, "IFNAME=", 7) == 0) {
3951 end = os_strchr(str, ' ');
3952 if (end && pos > end - str) {
3953 pos -= end - str + 1;
3954 str = end + 1;
3955 }
3956 }
3957
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003958 end = os_strchr(str, ' ');
3959 if (end == NULL || str + pos < end)
3960 return wpa_list_cmd_list();
3961
3962 cmd = os_malloc(pos + 1);
3963 if (cmd == NULL)
3964 return NULL;
3965 os_memcpy(cmd, str, pos);
3966 cmd[end - str] = '\0';
3967 res = wpa_cli_cmd_completion(cmd, str, pos);
3968 os_free(cmd);
3969 return res;
3970}
3971
3972
3973static int wpa_request(struct wpa_ctrl *ctrl, int argc, char *argv[])
3974{
Dmitry Shmidt1d755d02015-04-28 10:34:29 -07003975 const struct wpa_cli_cmd *cmd, *match = NULL;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003976 int count;
3977 int ret = 0;
3978
Dmitry Shmidtf7e0a992013-05-23 11:03:10 -07003979 if (argc > 1 && os_strncasecmp(argv[0], "IFNAME=", 7) == 0) {
3980 ifname_prefix = argv[0] + 7;
3981 argv = &argv[1];
3982 argc--;
3983 } else
3984 ifname_prefix = NULL;
3985
3986 if (argc == 0)
3987 return -1;
3988
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003989 count = 0;
3990 cmd = wpa_cli_commands;
3991 while (cmd->cmd) {
3992 if (os_strncasecmp(cmd->cmd, argv[0], os_strlen(argv[0])) == 0)
3993 {
3994 match = cmd;
3995 if (os_strcasecmp(cmd->cmd, argv[0]) == 0) {
3996 /* we have an exact match */
3997 count = 1;
3998 break;
3999 }
4000 count++;
4001 }
4002 cmd++;
4003 }
4004
4005 if (count > 1) {
4006 printf("Ambiguous command '%s'; possible commands:", argv[0]);
4007 cmd = wpa_cli_commands;
4008 while (cmd->cmd) {
4009 if (os_strncasecmp(cmd->cmd, argv[0],
4010 os_strlen(argv[0])) == 0) {
4011 printf(" %s", cmd->cmd);
4012 }
4013 cmd++;
4014 }
4015 printf("\n");
4016 ret = 1;
4017 } else if (count == 0) {
4018 printf("Unknown command '%s'\n", argv[0]);
4019 ret = 1;
4020 } else {
4021 ret = match->handler(ctrl, argc - 1, &argv[1]);
4022 }
4023
4024 return ret;
4025}
4026
4027
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004028static int wpa_cli_exec(const char *program, const char *arg1,
4029 const char *arg2)
4030{
Jouni Malinen772e12c2014-10-07 10:29:35 -07004031 char *arg;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004032 size_t len;
4033 int res;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004034
Dmitry Shmidt9c175262016-03-03 10:20:07 -08004035 /* If no interface is specified, set the global */
4036 if (!arg1)
4037 arg1 = "global";
4038
Jouni Malinen772e12c2014-10-07 10:29:35 -07004039 len = os_strlen(arg1) + os_strlen(arg2) + 2;
4040 arg = os_malloc(len);
4041 if (arg == NULL)
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004042 return -1;
Jouni Malinen772e12c2014-10-07 10:29:35 -07004043 os_snprintf(arg, len, "%s %s", arg1, arg2);
4044 res = os_exec(program, arg, 1);
4045 os_free(arg);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004046
Jouni Malinen772e12c2014-10-07 10:29:35 -07004047 return res;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004048}
4049
4050
4051static void wpa_cli_action_process(const char *msg)
4052{
4053 const char *pos;
4054 char *copy = NULL, *id, *pos2;
Dmitry Shmidt661b4f72014-09-29 14:58:27 -07004055 const char *ifname = ctrl_ifname;
4056 char ifname_buf[100];
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004057
Dmitry Shmidtd80a4012015-11-05 16:35:40 -08004058 if (eloop_terminated())
4059 return;
4060
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004061 pos = msg;
Dmitry Shmidt661b4f72014-09-29 14:58:27 -07004062 if (os_strncmp(pos, "IFNAME=", 7) == 0) {
4063 const char *end;
4064 end = os_strchr(pos + 7, ' ');
4065 if (end && (unsigned int) (end - pos) < sizeof(ifname_buf)) {
4066 pos += 7;
4067 os_memcpy(ifname_buf, pos, end - pos);
4068 ifname_buf[end - pos] = '\0';
4069 ifname = ifname_buf;
4070 pos = end + 1;
4071 }
4072 }
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004073 if (*pos == '<') {
Dmitry Shmidt661b4f72014-09-29 14:58:27 -07004074 const char *prev = pos;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004075 /* skip priority */
4076 pos = os_strchr(pos, '>');
4077 if (pos)
4078 pos++;
4079 else
Dmitry Shmidt661b4f72014-09-29 14:58:27 -07004080 pos = prev;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004081 }
4082
Dmitry Shmidt7f2c7532016-08-15 09:48:12 -07004083 if (str_starts(pos, WPA_EVENT_CONNECTED)) {
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004084 int new_id = -1;
4085 os_unsetenv("WPA_ID");
4086 os_unsetenv("WPA_ID_STR");
4087 os_unsetenv("WPA_CTRL_DIR");
4088
4089 pos = os_strstr(pos, "[id=");
4090 if (pos)
4091 copy = os_strdup(pos + 4);
4092
4093 if (copy) {
4094 pos2 = id = copy;
4095 while (*pos2 && *pos2 != ' ')
4096 pos2++;
4097 *pos2++ = '\0';
4098 new_id = atoi(id);
4099 os_setenv("WPA_ID", id, 1);
4100 while (*pos2 && *pos2 != '=')
4101 pos2++;
4102 if (*pos2 == '=')
4103 pos2++;
4104 id = pos2;
4105 while (*pos2 && *pos2 != ']')
4106 pos2++;
4107 *pos2 = '\0';
4108 os_setenv("WPA_ID_STR", id, 1);
4109 os_free(copy);
4110 }
4111
4112 os_setenv("WPA_CTRL_DIR", ctrl_iface_dir, 1);
4113
Dmitry Shmidt391c59f2013-09-03 12:16:28 -07004114 if (wpa_cli_connected <= 0 || new_id != wpa_cli_last_id) {
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004115 wpa_cli_connected = 1;
4116 wpa_cli_last_id = new_id;
Dmitry Shmidt661b4f72014-09-29 14:58:27 -07004117 wpa_cli_exec(action_file, ifname, "CONNECTED");
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004118 }
Dmitry Shmidt7f2c7532016-08-15 09:48:12 -07004119 } else if (str_starts(pos, WPA_EVENT_DISCONNECTED)) {
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004120 if (wpa_cli_connected) {
4121 wpa_cli_connected = 0;
Dmitry Shmidt661b4f72014-09-29 14:58:27 -07004122 wpa_cli_exec(action_file, ifname, "DISCONNECTED");
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004123 }
Hai Shalom81f62d82019-07-22 12:10:00 -07004124 } else if (str_starts(pos, WPA_EVENT_CHANNEL_SWITCH_STARTED)) {
4125 wpa_cli_exec(action_file, ctrl_ifname, pos);
Dmitry Shmidt7f2c7532016-08-15 09:48:12 -07004126 } else if (str_starts(pos, AP_EVENT_ENABLED)) {
Dmitry Shmidt849734c2016-05-27 09:59:01 -07004127 wpa_cli_exec(action_file, ctrl_ifname, pos);
Dmitry Shmidt7f2c7532016-08-15 09:48:12 -07004128 } else if (str_starts(pos, AP_EVENT_DISABLED)) {
Dmitry Shmidt849734c2016-05-27 09:59:01 -07004129 wpa_cli_exec(action_file, ctrl_ifname, pos);
Dmitry Shmidt7f2c7532016-08-15 09:48:12 -07004130 } else if (str_starts(pos, MESH_GROUP_STARTED)) {
Dmitry Shmidt6c0da2b2015-01-05 13:08:17 -08004131 wpa_cli_exec(action_file, ctrl_ifname, pos);
Dmitry Shmidt7f2c7532016-08-15 09:48:12 -07004132 } else if (str_starts(pos, MESH_GROUP_REMOVED)) {
Dmitry Shmidt6c0da2b2015-01-05 13:08:17 -08004133 wpa_cli_exec(action_file, ctrl_ifname, pos);
Dmitry Shmidt7f2c7532016-08-15 09:48:12 -07004134 } else if (str_starts(pos, MESH_PEER_CONNECTED)) {
Dmitry Shmidt6c0da2b2015-01-05 13:08:17 -08004135 wpa_cli_exec(action_file, ctrl_ifname, pos);
Dmitry Shmidt7f2c7532016-08-15 09:48:12 -07004136 } else if (str_starts(pos, MESH_PEER_DISCONNECTED)) {
Dmitry Shmidt6c0da2b2015-01-05 13:08:17 -08004137 wpa_cli_exec(action_file, ctrl_ifname, pos);
Dmitry Shmidt7f2c7532016-08-15 09:48:12 -07004138 } else if (str_starts(pos, P2P_EVENT_GROUP_STARTED)) {
Dmitry Shmidt661b4f72014-09-29 14:58:27 -07004139 wpa_cli_exec(action_file, ifname, pos);
Dmitry Shmidt7f2c7532016-08-15 09:48:12 -07004140 } else if (str_starts(pos, P2P_EVENT_GROUP_REMOVED)) {
Dmitry Shmidt661b4f72014-09-29 14:58:27 -07004141 wpa_cli_exec(action_file, ifname, pos);
Dmitry Shmidt7f2c7532016-08-15 09:48:12 -07004142 } else if (str_starts(pos, P2P_EVENT_CROSS_CONNECT_ENABLE)) {
Dmitry Shmidt661b4f72014-09-29 14:58:27 -07004143 wpa_cli_exec(action_file, ifname, pos);
Dmitry Shmidt7f2c7532016-08-15 09:48:12 -07004144 } else if (str_starts(pos, P2P_EVENT_CROSS_CONNECT_DISABLE)) {
Dmitry Shmidt661b4f72014-09-29 14:58:27 -07004145 wpa_cli_exec(action_file, ifname, pos);
Dmitry Shmidt7f2c7532016-08-15 09:48:12 -07004146 } else if (str_starts(pos, P2P_EVENT_GO_NEG_FAILURE)) {
Dmitry Shmidt661b4f72014-09-29 14:58:27 -07004147 wpa_cli_exec(action_file, ifname, pos);
Dmitry Shmidt7f2c7532016-08-15 09:48:12 -07004148 } else if (str_starts(pos, WPS_EVENT_SUCCESS)) {
Dmitry Shmidt661b4f72014-09-29 14:58:27 -07004149 wpa_cli_exec(action_file, ifname, pos);
Dmitry Shmidtd2986c22017-10-23 14:22:09 -07004150 } else if (str_starts(pos, WPS_EVENT_ACTIVE)) {
4151 wpa_cli_exec(action_file, ifname, pos);
Hai Shalomfdcde762020-04-02 11:19:20 -07004152 } else if (str_starts(pos, WPS_EVENT_PIN_ACTIVE)) {
4153 wpa_cli_exec(action_file, ifname, pos);
4154 } else if (str_starts(pos, WPS_EVENT_CANCEL)) {
4155 wpa_cli_exec(action_file, ifname, pos);
Dmitry Shmidtd2986c22017-10-23 14:22:09 -07004156 } else if (str_starts(pos, WPS_EVENT_TIMEOUT)) {
4157 wpa_cli_exec(action_file, ifname, pos);
Dmitry Shmidt7f2c7532016-08-15 09:48:12 -07004158 } else if (str_starts(pos, WPS_EVENT_FAIL)) {
Dmitry Shmidt661b4f72014-09-29 14:58:27 -07004159 wpa_cli_exec(action_file, ifname, pos);
Dmitry Shmidt7f2c7532016-08-15 09:48:12 -07004160 } else if (str_starts(pos, AP_STA_CONNECTED)) {
Dmitry Shmidt661b4f72014-09-29 14:58:27 -07004161 wpa_cli_exec(action_file, ifname, pos);
Dmitry Shmidt7f2c7532016-08-15 09:48:12 -07004162 } else if (str_starts(pos, AP_STA_DISCONNECTED)) {
Dmitry Shmidt661b4f72014-09-29 14:58:27 -07004163 wpa_cli_exec(action_file, ifname, pos);
Dmitry Shmidt7f2c7532016-08-15 09:48:12 -07004164 } else if (str_starts(pos, ESS_DISASSOC_IMMINENT)) {
Dmitry Shmidt661b4f72014-09-29 14:58:27 -07004165 wpa_cli_exec(action_file, ifname, pos);
Dmitry Shmidt7f2c7532016-08-15 09:48:12 -07004166 } else if (str_starts(pos, HS20_SUBSCRIPTION_REMEDIATION)) {
Dmitry Shmidt661b4f72014-09-29 14:58:27 -07004167 wpa_cli_exec(action_file, ifname, pos);
Dmitry Shmidt7f2c7532016-08-15 09:48:12 -07004168 } else if (str_starts(pos, HS20_DEAUTH_IMMINENT_NOTICE)) {
Dmitry Shmidt661b4f72014-09-29 14:58:27 -07004169 wpa_cli_exec(action_file, ifname, pos);
Roshan Pius3a1667e2018-07-03 15:17:14 -07004170 } else if (str_starts(pos, HS20_T_C_ACCEPTANCE)) {
4171 wpa_cli_exec(action_file, ifname, pos);
Hai Shalomc3565922019-10-28 11:58:20 -07004172 } else if (str_starts(pos, DPP_EVENT_CONF_RECEIVED)) {
4173 wpa_cli_exec(action_file, ifname, pos);
4174 } else if (str_starts(pos, DPP_EVENT_CONFOBJ_AKM)) {
4175 wpa_cli_exec(action_file, ifname, pos);
4176 } else if (str_starts(pos, DPP_EVENT_CONFOBJ_SSID)) {
4177 wpa_cli_exec(action_file, ifname, pos);
4178 } else if (str_starts(pos, DPP_EVENT_CONNECTOR)) {
4179 wpa_cli_exec(action_file, ifname, pos);
4180 } else if (str_starts(pos, DPP_EVENT_CONFOBJ_PASS)) {
4181 wpa_cli_exec(action_file, ifname, pos);
4182 } else if (str_starts(pos, DPP_EVENT_CONFOBJ_PSK)) {
4183 wpa_cli_exec(action_file, ifname, pos);
4184 } else if (str_starts(pos, DPP_EVENT_C_SIGN_KEY)) {
4185 wpa_cli_exec(action_file, ifname, pos);
4186 } else if (str_starts(pos, DPP_EVENT_NET_ACCESS_KEY)) {
4187 wpa_cli_exec(action_file, ifname, pos);
Dmitry Shmidt7f2c7532016-08-15 09:48:12 -07004188 } else if (str_starts(pos, WPA_EVENT_TERMINATING)) {
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004189 printf("wpa_supplicant is terminating - stop monitoring\n");
Ahmed ElArabawy0ff61c52019-12-26 12:38:39 -08004190 if (!reconnect)
4191 wpa_cli_quit = 1;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004192 }
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004193}
4194
4195
4196#ifndef CONFIG_ANSI_C_EXTRA
4197static void wpa_cli_action_cb(char *msg, size_t len)
4198{
4199 wpa_cli_action_process(msg);
4200}
4201#endif /* CONFIG_ANSI_C_EXTRA */
4202
4203
Hai Shalom74f70d42019-02-11 14:42:39 -08004204static int wpa_cli_open_global_ctrl(void)
4205{
4206#ifdef CONFIG_CTRL_IFACE_NAMED_PIPE
4207 ctrl_conn = wpa_ctrl_open(NULL);
4208#else /* CONFIG_CTRL_IFACE_NAMED_PIPE */
4209 ctrl_conn = wpa_ctrl_open(global);
4210#endif /* CONFIG_CTRL_IFACE_NAMED_PIPE */
4211 if (!ctrl_conn) {
4212 fprintf(stderr,
4213 "Failed to connect to wpa_supplicant global interface: %s error: %s\n",
4214 global, strerror(errno));
4215 return -1;
4216 }
4217
4218 if (interactive) {
4219 update_ifnames(ctrl_conn);
4220 mon_conn = wpa_ctrl_open(global);
4221 if (mon_conn) {
4222 if (wpa_ctrl_attach(mon_conn) == 0) {
4223 wpa_cli_attached = 1;
4224 eloop_register_read_sock(
4225 wpa_ctrl_get_fd(mon_conn),
4226 wpa_cli_mon_receive,
4227 NULL, NULL);
4228 } else {
4229 printf("Failed to open monitor connection through global control interface\n");
4230 }
4231 }
4232 update_stations(ctrl_conn);
4233 }
4234
4235 return 0;
4236}
4237
4238
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004239static void wpa_cli_reconnect(void)
4240{
4241 wpa_cli_close_connection();
Hai Shalom74f70d42019-02-11 14:42:39 -08004242 if ((global && wpa_cli_open_global_ctrl() < 0) ||
4243 (!global && wpa_cli_open_connection(ctrl_ifname, 1) < 0))
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07004244 return;
4245
4246 if (interactive) {
4247 edit_clear_line();
4248 printf("\rConnection to wpa_supplicant re-established\n");
4249 edit_redraw();
Dmitry Shmidt9839ecd2016-11-07 11:05:47 -08004250 update_stations(ctrl_conn);
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07004251 }
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004252}
4253
4254
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08004255static void cli_event(const char *str)
4256{
4257 const char *start, *s;
4258
4259 start = os_strchr(str, '>');
4260 if (start == NULL)
4261 return;
4262
4263 start++;
4264
4265 if (str_starts(start, WPA_EVENT_BSS_ADDED)) {
4266 s = os_strchr(start, ' ');
4267 if (s == NULL)
4268 return;
4269 s = os_strchr(s + 1, ' ');
4270 if (s == NULL)
4271 return;
4272 cli_txt_list_add(&bsses, s + 1);
4273 return;
4274 }
4275
4276 if (str_starts(start, WPA_EVENT_BSS_REMOVED)) {
4277 s = os_strchr(start, ' ');
4278 if (s == NULL)
4279 return;
4280 s = os_strchr(s + 1, ' ');
4281 if (s == NULL)
4282 return;
4283 cli_txt_list_del_addr(&bsses, s + 1);
4284 return;
4285 }
4286
4287#ifdef CONFIG_P2P
4288 if (str_starts(start, P2P_EVENT_DEVICE_FOUND)) {
4289 s = os_strstr(start, " p2p_dev_addr=");
4290 if (s == NULL)
4291 return;
4292 cli_txt_list_add_addr(&p2p_peers, s + 14);
4293 return;
4294 }
4295
4296 if (str_starts(start, P2P_EVENT_DEVICE_LOST)) {
4297 s = os_strstr(start, " p2p_dev_addr=");
4298 if (s == NULL)
4299 return;
4300 cli_txt_list_del_addr(&p2p_peers, s + 14);
4301 return;
4302 }
4303
4304 if (str_starts(start, P2P_EVENT_GROUP_STARTED)) {
4305 s = os_strchr(start, ' ');
4306 if (s == NULL)
4307 return;
Dmitry Shmidt912c6ec2015-03-30 13:16:51 -07004308 cli_txt_list_add_word(&p2p_groups, s + 1, ' ');
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08004309 return;
4310 }
4311
4312 if (str_starts(start, P2P_EVENT_GROUP_REMOVED)) {
4313 s = os_strchr(start, ' ');
4314 if (s == NULL)
4315 return;
Dmitry Shmidt912c6ec2015-03-30 13:16:51 -07004316 cli_txt_list_del_word(&p2p_groups, s + 1, ' ');
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08004317 return;
4318 }
4319#endif /* CONFIG_P2P */
4320}
4321
4322
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07004323static int check_terminating(const char *msg)
4324{
4325 const char *pos = msg;
4326
4327 if (*pos == '<') {
4328 /* skip priority */
4329 pos = os_strchr(pos, '>');
4330 if (pos)
4331 pos++;
4332 else
4333 pos = msg;
4334 }
4335
Dmitry Shmidt7f2c7532016-08-15 09:48:12 -07004336 if (str_starts(pos, WPA_EVENT_TERMINATING) && ctrl_conn) {
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07004337 edit_clear_line();
4338 printf("\rConnection to wpa_supplicant lost - trying to "
4339 "reconnect\n");
4340 edit_redraw();
4341 wpa_cli_attached = 0;
4342 wpa_cli_close_connection();
4343 return 1;
4344 }
4345
4346 return 0;
4347}
4348
4349
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004350static void wpa_cli_recv_pending(struct wpa_ctrl *ctrl, int action_monitor)
4351{
4352 if (ctrl_conn == NULL) {
4353 wpa_cli_reconnect();
4354 return;
4355 }
4356 while (wpa_ctrl_pending(ctrl) > 0) {
Dmitry Shmidt661b4f72014-09-29 14:58:27 -07004357 char buf[4096];
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004358 size_t len = sizeof(buf) - 1;
4359 if (wpa_ctrl_recv(ctrl, buf, &len) == 0) {
4360 buf[len] = '\0';
4361 if (action_monitor)
4362 wpa_cli_action_process(buf);
4363 else {
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08004364 cli_event(buf);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004365 if (wpa_cli_show_event(buf)) {
4366 edit_clear_line();
4367 printf("\r%s\n", buf);
4368 edit_redraw();
4369 }
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07004370
4371 if (interactive && check_terminating(buf) > 0)
4372 return;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004373 }
4374 } else {
4375 printf("Could not read pending message.\n");
4376 break;
4377 }
4378 }
4379
4380 if (wpa_ctrl_pending(ctrl) < 0) {
4381 printf("Connection to wpa_supplicant lost - trying to "
4382 "reconnect\n");
Ahmed ElArabawy0ff61c52019-12-26 12:38:39 -08004383 if (reconnect) {
4384 eloop_terminate();
4385 return;
4386 }
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004387 wpa_cli_reconnect();
4388 }
4389}
4390
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004391
4392static void wpa_cli_ping(void *eloop_ctx, void *timeout_ctx)
4393{
Dmitry Shmidt661b4f72014-09-29 14:58:27 -07004394 if (ctrl_conn) {
4395 int res;
4396 char *prefix = ifname_prefix;
4397
4398 ifname_prefix = NULL;
4399 res = _wpa_ctrl_command(ctrl_conn, "PING", 0);
4400 ifname_prefix = prefix;
4401 if (res) {
4402 printf("Connection to wpa_supplicant lost - trying to "
4403 "reconnect\n");
4404 wpa_cli_close_connection();
4405 }
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004406 }
4407 if (!ctrl_conn)
4408 wpa_cli_reconnect();
4409 eloop_register_timeout(ping_interval, 0, wpa_cli_ping, NULL, NULL);
4410}
4411
4412
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004413static void wpa_cli_mon_receive(int sock, void *eloop_ctx, void *sock_ctx)
4414{
4415 wpa_cli_recv_pending(mon_conn, 0);
4416}
4417
4418
4419static void wpa_cli_edit_cmd_cb(void *ctx, char *cmd)
4420{
4421 char *argv[max_args];
4422 int argc;
4423 argc = tokenize_cmd(cmd, argv);
4424 if (argc)
4425 wpa_request(ctrl_conn, argc, argv);
4426}
4427
4428
4429static void wpa_cli_edit_eof_cb(void *ctx)
4430{
4431 eloop_terminate();
4432}
4433
4434
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07004435static int warning_displayed = 0;
4436static char *hfile = NULL;
4437static int edit_started = 0;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004438
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07004439static void start_edit(void)
4440{
4441 char *home;
4442 char *ps = NULL;
4443
4444#ifdef CONFIG_CTRL_IFACE_UDP_REMOTE
4445 ps = wpa_ctrl_get_remote_ifname(ctrl_conn);
4446#endif /* CONFIG_CTRL_IFACE_UDP_REMOTE */
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004447
Dmitry Shmidt912c6ec2015-03-30 13:16:51 -07004448#ifdef CONFIG_WPA_CLI_HISTORY_DIR
4449 home = CONFIG_WPA_CLI_HISTORY_DIR;
4450#else /* CONFIG_WPA_CLI_HISTORY_DIR */
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004451 home = getenv("HOME");
Dmitry Shmidt912c6ec2015-03-30 13:16:51 -07004452#endif /* CONFIG_WPA_CLI_HISTORY_DIR */
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004453 if (home) {
4454 const char *fname = ".wpa_cli_history";
4455 int hfile_len = os_strlen(home) + 1 + os_strlen(fname) + 1;
4456 hfile = os_malloc(hfile_len);
4457 if (hfile)
4458 os_snprintf(hfile, hfile_len, "%s/%s", home, fname);
4459 }
4460
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07004461 if (edit_init(wpa_cli_edit_cmd_cb, wpa_cli_edit_eof_cb,
4462 wpa_cli_edit_completion_cb, NULL, hfile, ps) < 0) {
4463 eloop_terminate();
4464 return;
4465 }
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004466
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07004467 edit_started = 1;
4468 eloop_register_timeout(ping_interval, 0, wpa_cli_ping, NULL, NULL);
4469}
4470
4471
Dmitry Shmidt51b6ea82013-05-08 10:42:09 -07004472static void update_bssid_list(struct wpa_ctrl *ctrl)
4473{
4474 char buf[4096];
4475 size_t len = sizeof(buf);
4476 int ret;
Dmitry Shmidt9839ecd2016-11-07 11:05:47 -08004477 const char *cmd = "BSS RANGE=ALL MASK=0x2";
Dmitry Shmidt51b6ea82013-05-08 10:42:09 -07004478 char *pos, *end;
4479
4480 if (ctrl == NULL)
4481 return;
4482 ret = wpa_ctrl_request(ctrl, cmd, os_strlen(cmd), buf, &len, NULL);
4483 if (ret < 0)
4484 return;
4485 buf[len] = '\0';
4486
4487 pos = buf;
4488 while (pos) {
4489 pos = os_strstr(pos, "bssid=");
4490 if (pos == NULL)
4491 break;
4492 pos += 6;
4493 end = os_strchr(pos, '\n');
4494 if (end == NULL)
4495 break;
4496 *end = '\0';
4497 cli_txt_list_add(&bsses, pos);
4498 pos = end + 1;
4499 }
4500}
4501
4502
Dmitry Shmidtf7e0a992013-05-23 11:03:10 -07004503static void update_ifnames(struct wpa_ctrl *ctrl)
4504{
4505 char buf[4096];
4506 size_t len = sizeof(buf);
4507 int ret;
Dmitry Shmidt9839ecd2016-11-07 11:05:47 -08004508 const char *cmd = "INTERFACES";
Dmitry Shmidtf7e0a992013-05-23 11:03:10 -07004509 char *pos, *end;
4510 char txt[200];
4511
4512 cli_txt_list_flush(&ifnames);
4513
4514 if (ctrl == NULL)
4515 return;
4516 ret = wpa_ctrl_request(ctrl, cmd, os_strlen(cmd), buf, &len, NULL);
4517 if (ret < 0)
4518 return;
4519 buf[len] = '\0';
4520
4521 pos = buf;
4522 while (pos) {
4523 end = os_strchr(pos, '\n');
4524 if (end == NULL)
4525 break;
4526 *end = '\0';
4527 ret = os_snprintf(txt, sizeof(txt), "ifname=%s", pos);
Dmitry Shmidt6c0da2b2015-01-05 13:08:17 -08004528 if (!os_snprintf_error(sizeof(txt), ret))
Dmitry Shmidtf7e0a992013-05-23 11:03:10 -07004529 cli_txt_list_add(&ifnames, txt);
4530 pos = end + 1;
4531 }
4532}
4533
4534
Roshan Pius3a1667e2018-07-03 15:17:14 -07004535static void update_creds(struct wpa_ctrl *ctrl)
4536{
4537 char buf[4096];
4538 size_t len = sizeof(buf);
4539 int ret;
4540 const char *cmd = "LIST_CREDS";
4541 char *pos, *end;
4542 int header = 1;
4543
4544 cli_txt_list_flush(&creds);
4545
4546 if (ctrl == NULL)
4547 return;
4548 ret = wpa_ctrl_request(ctrl, cmd, os_strlen(cmd), buf, &len, NULL);
4549 if (ret < 0)
4550 return;
4551 buf[len] = '\0';
4552
4553 pos = buf;
4554 while (pos) {
4555 end = os_strchr(pos, '\n');
4556 if (end == NULL)
4557 break;
4558 *end = '\0';
4559 if (!header)
4560 cli_txt_list_add_word(&creds, pos, '\t');
4561 header = 0;
4562 pos = end + 1;
4563 }
4564}
4565
4566
Dmitry Shmidt912c6ec2015-03-30 13:16:51 -07004567static void update_networks(struct wpa_ctrl *ctrl)
4568{
4569 char buf[4096];
4570 size_t len = sizeof(buf);
4571 int ret;
Dmitry Shmidt9839ecd2016-11-07 11:05:47 -08004572 const char *cmd = "LIST_NETWORKS";
Dmitry Shmidt912c6ec2015-03-30 13:16:51 -07004573 char *pos, *end;
4574 int header = 1;
4575
4576 cli_txt_list_flush(&networks);
4577
4578 if (ctrl == NULL)
4579 return;
4580 ret = wpa_ctrl_request(ctrl, cmd, os_strlen(cmd), buf, &len, NULL);
4581 if (ret < 0)
4582 return;
4583 buf[len] = '\0';
4584
4585 pos = buf;
4586 while (pos) {
4587 end = os_strchr(pos, '\n');
4588 if (end == NULL)
4589 break;
4590 *end = '\0';
4591 if (!header)
4592 cli_txt_list_add_word(&networks, pos, '\t');
4593 header = 0;
4594 pos = end + 1;
4595 }
4596}
4597
4598
Dmitry Shmidt9839ecd2016-11-07 11:05:47 -08004599static void update_stations(struct wpa_ctrl *ctrl)
4600{
4601#ifdef CONFIG_AP
4602 char addr[32], cmd[64];
4603
4604 if (!ctrl || !interactive)
4605 return;
4606
4607 cli_txt_list_flush(&stations);
4608
4609 if (wpa_ctrl_command_sta(ctrl, "STA-FIRST", addr, sizeof(addr), 0))
4610 return;
4611 do {
4612 if (os_strcmp(addr, "") != 0)
4613 cli_txt_list_add(&stations, addr);
4614 os_snprintf(cmd, sizeof(cmd), "STA-NEXT %s", addr);
4615 } while (wpa_ctrl_command_sta(ctrl, cmd, addr, sizeof(addr), 0) == 0);
4616#endif /* CONFIG_AP */
4617}
4618
4619
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07004620static void try_connection(void *eloop_ctx, void *timeout_ctx)
4621{
Dmitry Shmidtb6e9aaf2013-05-20 14:49:44 -07004622 if (ctrl_conn)
4623 goto done;
4624
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07004625 if (ctrl_ifname == NULL)
4626 ctrl_ifname = wpa_cli_get_default_ifname();
4627
Dmitry Shmidt57c2d392016-02-23 13:40:19 -08004628 if (wpa_cli_open_connection(ctrl_ifname, 1)) {
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07004629 if (!warning_displayed) {
4630 printf("Could not connect to wpa_supplicant: "
Dmitry Shmidt2f74e362015-01-21 13:19:05 -08004631 "%s - re-trying\n",
4632 ctrl_ifname ? ctrl_ifname : "(nil)");
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07004633 warning_displayed = 1;
4634 }
4635 eloop_register_timeout(1, 0, try_connection, NULL, NULL);
4636 return;
4637 }
4638
Dmitry Shmidt51b6ea82013-05-08 10:42:09 -07004639 update_bssid_list(ctrl_conn);
Roshan Pius3a1667e2018-07-03 15:17:14 -07004640 update_creds(ctrl_conn);
Dmitry Shmidt912c6ec2015-03-30 13:16:51 -07004641 update_networks(ctrl_conn);
Dmitry Shmidt9839ecd2016-11-07 11:05:47 -08004642 update_stations(ctrl_conn);
Dmitry Shmidt51b6ea82013-05-08 10:42:09 -07004643
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07004644 if (warning_displayed)
4645 printf("Connection established.\n");
4646
Dmitry Shmidtb6e9aaf2013-05-20 14:49:44 -07004647done:
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07004648 start_edit();
4649}
4650
4651
4652static void wpa_cli_interactive(void)
4653{
4654 printf("\nInteractive mode\n\n");
4655
4656 eloop_register_timeout(0, 0, try_connection, NULL, NULL);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004657 eloop_run();
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07004658 eloop_cancel_timeout(try_connection, NULL, NULL);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004659
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08004660 cli_txt_list_flush(&p2p_peers);
4661 cli_txt_list_flush(&p2p_groups);
4662 cli_txt_list_flush(&bsses);
Dmitry Shmidtf7e0a992013-05-23 11:03:10 -07004663 cli_txt_list_flush(&ifnames);
Roshan Pius3a1667e2018-07-03 15:17:14 -07004664 cli_txt_list_flush(&creds);
Dmitry Shmidt912c6ec2015-03-30 13:16:51 -07004665 cli_txt_list_flush(&networks);
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07004666 if (edit_started)
4667 edit_deinit(hfile, wpa_cli_edit_filter_history_cb);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004668 os_free(hfile);
4669 eloop_cancel_timeout(wpa_cli_ping, NULL, NULL);
4670 wpa_cli_close_connection();
4671}
4672
4673
Dmitry Shmidta3dc3092015-06-23 11:21:28 -07004674static void wpa_cli_action_ping(void *eloop_ctx, void *timeout_ctx)
4675{
4676 struct wpa_ctrl *ctrl = eloop_ctx;
4677 char buf[256];
4678 size_t len;
4679
4680 /* verify that connection is still working */
4681 len = sizeof(buf) - 1;
4682 if (wpa_ctrl_request(ctrl, "PING", 4, buf, &len,
4683 wpa_cli_action_cb) < 0 ||
4684 len < 4 || os_memcmp(buf, "PONG", 4) != 0) {
4685 printf("wpa_supplicant did not reply to PING command - exiting\n");
4686 eloop_terminate();
4687 return;
4688 }
4689 eloop_register_timeout(ping_interval, 0, wpa_cli_action_ping,
4690 ctrl, NULL);
4691}
4692
4693
4694static void wpa_cli_action_receive(int sock, void *eloop_ctx, void *sock_ctx)
4695{
4696 struct wpa_ctrl *ctrl = eloop_ctx;
4697
4698 wpa_cli_recv_pending(ctrl, 1);
4699}
4700
4701
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004702static void wpa_cli_action(struct wpa_ctrl *ctrl)
4703{
4704#ifdef CONFIG_ANSI_C_EXTRA
4705 /* TODO: ANSI C version(?) */
4706 printf("Action processing not supported in ANSI C build.\n");
4707#else /* CONFIG_ANSI_C_EXTRA */
Dmitry Shmidta3dc3092015-06-23 11:21:28 -07004708 int fd;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004709
4710 fd = wpa_ctrl_get_fd(ctrl);
Dmitry Shmidta3dc3092015-06-23 11:21:28 -07004711 eloop_register_timeout(ping_interval, 0, wpa_cli_action_ping,
4712 ctrl, NULL);
4713 eloop_register_read_sock(fd, wpa_cli_action_receive, ctrl, NULL);
4714 eloop_run();
4715 eloop_cancel_timeout(wpa_cli_action_ping, ctrl, NULL);
4716 eloop_unregister_read_sock(fd);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004717#endif /* CONFIG_ANSI_C_EXTRA */
4718}
4719
4720
4721static void wpa_cli_cleanup(void)
4722{
4723 wpa_cli_close_connection();
4724 if (pid_file)
4725 os_daemonize_terminate(pid_file);
4726
4727 os_program_deinit();
4728}
4729
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07004730
4731static void wpa_cli_terminate(int sig, void *ctx)
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004732{
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07004733 eloop_terminate();
Ahmed ElArabawy0ff61c52019-12-26 12:38:39 -08004734 if (reconnect)
4735 wpa_cli_quit = 1;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004736}
4737
4738
4739static char * wpa_cli_get_default_ifname(void)
4740{
4741 char *ifname = NULL;
4742
Dmitry Shmidtd80a4012015-11-05 16:35:40 -08004743#ifdef ANDROID
4744 char ifprop[PROPERTY_VALUE_MAX];
4745 if (property_get("wifi.interface", ifprop, NULL) != 0) {
4746 ifname = os_strdup(ifprop);
4747 printf("Using interface '%s'\n", ifname ? ifname : "N/A");
4748 }
4749#else /* ANDROID */
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004750#ifdef CONFIG_CTRL_IFACE_UNIX
4751 struct dirent *dent;
4752 DIR *dir = opendir(ctrl_iface_dir);
4753 if (!dir) {
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004754 return NULL;
4755 }
4756 while ((dent = readdir(dir))) {
4757#ifdef _DIRENT_HAVE_D_TYPE
4758 /*
4759 * Skip the file if it is not a socket. Also accept
4760 * DT_UNKNOWN (0) in case the C library or underlying
4761 * file system does not support d_type.
4762 */
4763 if (dent->d_type != DT_SOCK && dent->d_type != DT_UNKNOWN)
4764 continue;
4765#endif /* _DIRENT_HAVE_D_TYPE */
Hai Shalomc3565922019-10-28 11:58:20 -07004766 /* Skip current/previous directory and special P2P Device
4767 * interfaces. */
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004768 if (os_strcmp(dent->d_name, ".") == 0 ||
Hai Shalomc3565922019-10-28 11:58:20 -07004769 os_strcmp(dent->d_name, "..") == 0 ||
4770 os_strncmp(dent->d_name, "p2p-dev-", 8) == 0)
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004771 continue;
4772 printf("Selected interface '%s'\n", dent->d_name);
4773 ifname = os_strdup(dent->d_name);
4774 break;
4775 }
4776 closedir(dir);
4777#endif /* CONFIG_CTRL_IFACE_UNIX */
4778
4779#ifdef CONFIG_CTRL_IFACE_NAMED_PIPE
Dmitry Shmidtb6e9aaf2013-05-20 14:49:44 -07004780 char buf[4096], *pos;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004781 size_t len;
4782 struct wpa_ctrl *ctrl;
4783 int ret;
4784
4785 ctrl = wpa_ctrl_open(NULL);
4786 if (ctrl == NULL)
4787 return NULL;
4788
4789 len = sizeof(buf) - 1;
4790 ret = wpa_ctrl_request(ctrl, "INTERFACES", 10, buf, &len, NULL);
4791 if (ret >= 0) {
4792 buf[len] = '\0';
4793 pos = os_strchr(buf, '\n');
4794 if (pos)
4795 *pos = '\0';
4796 ifname = os_strdup(buf);
4797 }
4798 wpa_ctrl_close(ctrl);
4799#endif /* CONFIG_CTRL_IFACE_NAMED_PIPE */
Dmitry Shmidtd80a4012015-11-05 16:35:40 -08004800#endif /* ANDROID */
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004801
4802 return ifname;
4803}
4804
4805
4806int main(int argc, char *argv[])
4807{
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004808 int c;
4809 int daemonize = 0;
4810 int ret = 0;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004811
4812 if (os_program_init())
4813 return -1;
4814
4815 for (;;) {
Ahmed ElArabawy0ff61c52019-12-26 12:38:39 -08004816 c = getopt(argc, argv, "a:Bg:G:hi:p:P:rs:v");
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004817 if (c < 0)
4818 break;
4819 switch (c) {
4820 case 'a':
4821 action_file = optarg;
4822 break;
4823 case 'B':
4824 daemonize = 1;
4825 break;
4826 case 'g':
4827 global = optarg;
4828 break;
4829 case 'G':
4830 ping_interval = atoi(optarg);
4831 break;
4832 case 'h':
4833 usage();
4834 return 0;
4835 case 'v':
4836 printf("%s\n", wpa_cli_version);
4837 return 0;
4838 case 'i':
4839 os_free(ctrl_ifname);
4840 ctrl_ifname = os_strdup(optarg);
4841 break;
4842 case 'p':
4843 ctrl_iface_dir = optarg;
4844 break;
4845 case 'P':
4846 pid_file = optarg;
4847 break;
Ahmed ElArabawy0ff61c52019-12-26 12:38:39 -08004848 case 'r':
4849 reconnect = 1;
4850 break;
Dmitry Shmidtd80a4012015-11-05 16:35:40 -08004851 case 's':
4852 client_socket_dir = optarg;
4853 break;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004854 default:
4855 usage();
4856 return -1;
4857 }
4858 }
4859
4860 interactive = (argc == optind) && (action_file == NULL);
4861
4862 if (interactive)
Dmitry Shmidt7f2c7532016-08-15 09:48:12 -07004863 printf("%s\n\n%s\n\n", wpa_cli_version, cli_license);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004864
4865 if (eloop_init())
4866 return -1;
4867
Hai Shalom74f70d42019-02-11 14:42:39 -08004868 if (global && wpa_cli_open_global_ctrl() < 0)
4869 return -1;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004870
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07004871 eloop_register_signal_terminate(wpa_cli_terminate, NULL);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004872
4873 if (ctrl_ifname == NULL)
4874 ctrl_ifname = wpa_cli_get_default_ifname();
4875
Ahmed ElArabawy0ff61c52019-12-26 12:38:39 -08004876 if (reconnect && action_file && ctrl_ifname) {
4877 while (!wpa_cli_quit) {
4878 if (ctrl_conn)
4879 wpa_cli_action(ctrl_conn);
4880 else
4881 os_sleep(1, 0);
4882 wpa_cli_close_connection();
4883 wpa_cli_open_connection(ctrl_ifname, 0);
4884 if (ctrl_conn) {
4885 if (wpa_ctrl_attach(ctrl_conn) != 0)
4886 wpa_cli_close_connection();
4887 else
4888 wpa_cli_attached = 1;
4889 }
4890 }
4891 } else if (interactive) {
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07004892 wpa_cli_interactive();
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004893 } else {
4894 if (!global &&
4895 wpa_cli_open_connection(ctrl_ifname, 0) < 0) {
Dmitry Shmidt04949592012-07-19 12:16:46 -07004896 fprintf(stderr, "Failed to connect to non-global "
4897 "ctrl_ifname: %s error: %s\n",
Dmitry Shmidt2f74e362015-01-21 13:19:05 -08004898 ctrl_ifname ? ctrl_ifname : "(nil)",
4899 strerror(errno));
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004900 return -1;
4901 }
4902
4903 if (action_file) {
4904 if (wpa_ctrl_attach(ctrl_conn) == 0) {
4905 wpa_cli_attached = 1;
4906 } else {
4907 printf("Warning: Failed to attach to "
4908 "wpa_supplicant.\n");
4909 return -1;
4910 }
4911 }
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07004912
Dmitry Shmidtb97e4282016-02-08 10:16:07 -08004913 if (daemonize && os_daemonize(pid_file) && eloop_sock_requeue())
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07004914 return -1;
4915
4916 if (action_file)
4917 wpa_cli_action(ctrl_conn);
4918 else
4919 ret = wpa_request(ctrl_conn, argc - optind,
4920 &argv[optind]);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004921 }
4922
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004923 os_free(ctrl_ifname);
4924 eloop_destroy();
4925 wpa_cli_cleanup();
4926
4927 return ret;
4928}
4929
4930#else /* CONFIG_CTRL_IFACE */
4931int main(int argc, char *argv[])
4932{
4933 printf("CONFIG_CTRL_IFACE not defined - wpa_cli disabled\n");
4934 return -1;
4935}
4936#endif /* CONFIG_CTRL_IFACE */