1 /*
2 * WPA Supplicant - command line interface for wpa_supplicant daemon
3 * Copyright (c) 2004-2022, Jouni Malinen <j@w1.fi>
4 *
5 * This software may be distributed under the terms of the BSD license.
6 * See README for more details.
7 */
8
9 #include "includes.h"
10
11 #ifdef CONFIG_CTRL_IFACE
12
13 #ifdef CONFIG_CTRL_IFACE_UNIX
14 #include <dirent.h>
15 #endif /* CONFIG_CTRL_IFACE_UNIX */
16
17 #include "common/cli.h"
18 #include "common/wpa_ctrl.h"
19 #include "utils/common.h"
20 #include "utils/eloop.h"
21 #include "utils/edit.h"
22 #include "utils/list.h"
23 #include "common/version.h"
24 #include "common/ieee802_11_defs.h"
25 #ifdef ANDROID
26 #include <cutils/properties.h>
27 #endif /* ANDROID */
28 #ifdef CONFIG_VENDOR_EXT
29 #include "vendor_ext_cli.h"
30 #endif
31
32 #define MAX_TEMP_BUFFER_LEN 4096
33 static const char *const wpa_cli_version =
34 "wpa_cli v" VERSION_STR "\n"
35 "Copyright (c) 2004-2022, Jouni Malinen <j@w1.fi> and contributors";
36
37 #define VENDOR_ELEM_FRAME_ID \
38 " 0: Probe Req (P2P), 1: Probe Resp (P2P) , 2: Probe Resp (GO), " \
39 "3: Beacon (GO), 4: PD Req, 5: PD Resp, 6: GO Neg Req, " \
40 "7: GO Neg Resp, 8: GO Neg Conf, 9: Inv Req, 10: Inv Resp, " \
41 "11: Assoc Req (P2P), 12: Assoc Resp (P2P)"
42
43 static struct wpa_ctrl *ctrl_conn;
44 static struct wpa_ctrl *mon_conn;
45 static int wpa_cli_quit = 0;
46 static int wpa_cli_attached = 0;
47 static int wpa_cli_connected = -1;
48 static int wpa_cli_last_id = 0;
49 #ifndef CONFIG_CTRL_IFACE_DIR
50 #define CONFIG_CTRL_IFACE_DIR "/var/run/wpa_supplicant"
51 #endif /* CONFIG_CTRL_IFACE_DIR */
52 static const char *ctrl_iface_dir = CONFIG_CTRL_IFACE_DIR;
53 static const char *client_socket_dir = NULL;
54 static char *ctrl_ifname = NULL;
55 static const char *global = NULL;
56 static const char *pid_file = NULL;
57 static const char *action_file = NULL;
58 static int reconnect = 0;
59 static int ping_interval = 5;
60 static int interactive = 0;
61 static char *ifname_prefix = NULL;
62 #ifdef CONFIG_EAP_AUTH
63 #define INIT_VAL 2
64 #endif
65
66 static DEFINE_DL_LIST(bsses); /* struct cli_txt_entry */
67 static DEFINE_DL_LIST(p2p_peers); /* struct cli_txt_entry */
68 static DEFINE_DL_LIST(p2p_groups); /* struct cli_txt_entry */
69 static DEFINE_DL_LIST(ifnames); /* struct cli_txt_entry */
70 static DEFINE_DL_LIST(networks); /* struct cli_txt_entry */
71 static DEFINE_DL_LIST(creds); /* struct cli_txt_entry */
72 #ifdef CONFIG_AP
73 static DEFINE_DL_LIST(stations); /* struct cli_txt_entry */
74 #endif /* CONFIG_AP */
75
76
77 static void print_help(const char *cmd);
78 static void wpa_cli_mon_receive(int sock, void *eloop_ctx, void *sock_ctx);
79 static void wpa_cli_close_connection(void);
80 static char * wpa_cli_get_default_ifname(void);
81 static char ** wpa_list_cmd_list(void);
82 static void update_creds(struct wpa_ctrl *ctrl);
83 static void update_networks(struct wpa_ctrl *ctrl);
84 static void update_stations(struct wpa_ctrl *ctrl);
85 static void update_ifnames(struct wpa_ctrl *ctrl);
86
87
usage(void)88 static void usage(void)
89 {
90 printf("wpa_cli [-p<path to ctrl sockets>] [-i<ifname>] [-hvBr] "
91 "[-a<action file>] \\\n"
92 " [-P<pid file>] [-g<global ctrl>] [-G<ping interval>] "
93 "\\\n"
94 " [-s<wpa_client_socket_file_path>] "
95 "[command..]\n"
96 " -h = help (show this usage text)\n"
97 " -v = shown version information\n"
98 " -a = run in daemon mode executing the action file based on "
99 "events from\n"
100 " wpa_supplicant\n"
101 " -r = try to reconnect when client socket is disconnected.\n"
102 " This is useful only when used with -a.\n"
103 " -B = run a daemon in the background\n"
104 " default path: " CONFIG_CTRL_IFACE_DIR "\n"
105 " default interface: first interface found in socket path\n");
106 print_help(NULL);
107 }
108
109
wpa_cli_show_event(const char * event)110 static int wpa_cli_show_event(const char *event)
111 {
112 const char *start;
113
114 start = os_strchr(event, '>');
115 if (start == NULL)
116 return 1;
117
118 start++;
119 /*
120 * Skip BSS added/removed events since they can be relatively frequent
121 * and are likely of not much use for an interactive user.
122 */
123 if (str_starts(start, WPA_EVENT_BSS_ADDED) ||
124 str_starts(start, WPA_EVENT_BSS_REMOVED))
125 return 0;
126
127 return 1;
128 }
129
130
wpa_cli_open_connection(const char * ifname,int attach)131 static int wpa_cli_open_connection(const char *ifname, int attach)
132 {
133 #if defined(CONFIG_CTRL_IFACE_UDP) || defined(CONFIG_CTRL_IFACE_NAMED_PIPE)
134 ctrl_conn = wpa_ctrl_open(ifname);
135 if (ctrl_conn == NULL)
136 return -1;
137
138 if (attach && interactive)
139 mon_conn = wpa_ctrl_open(ifname);
140 else
141 mon_conn = NULL;
142 #else /* CONFIG_CTRL_IFACE_UDP || CONFIG_CTRL_IFACE_NAMED_PIPE */
143 char *cfile = NULL;
144 int flen, res;
145
146 if (ifname == NULL)
147 return -1;
148
149 #ifdef ANDROID
150 if (access(ctrl_iface_dir, F_OK) < 0) {
151 cfile = os_strdup(ifname);
152 if (cfile == NULL)
153 return -1;
154 }
155 #endif /* ANDROID */
156
157 if (client_socket_dir && client_socket_dir[0] &&
158 access(client_socket_dir, F_OK) < 0) {
159 perror(client_socket_dir);
160 os_free(cfile);
161 return -1;
162 }
163
164 if (cfile == NULL) {
165 flen = os_strlen(ctrl_iface_dir) + os_strlen(ifname) + 2;
166 cfile = os_malloc(flen);
167 if (cfile == NULL)
168 return -1;
169 res = os_snprintf(cfile, flen, "%s/%s", ctrl_iface_dir,
170 ifname);
171 if (os_snprintf_error(flen, res)) {
172 os_free(cfile);
173 return -1;
174 }
175 }
176
177 ctrl_conn = wpa_ctrl_open2(cfile, client_socket_dir);
178 if (ctrl_conn == NULL) {
179 os_free(cfile);
180 return -1;
181 }
182
183 if (attach && interactive)
184 mon_conn = wpa_ctrl_open2(cfile, client_socket_dir);
185 else
186 mon_conn = NULL;
187 os_free(cfile);
188 #endif /* CONFIG_CTRL_IFACE_UDP || CONFIG_CTRL_IFACE_NAMED_PIPE */
189
190 if (mon_conn) {
191 if (wpa_ctrl_attach(mon_conn) == 0) {
192 wpa_cli_attached = 1;
193 if (interactive)
194 eloop_register_read_sock(
195 wpa_ctrl_get_fd(mon_conn),
196 wpa_cli_mon_receive, NULL, NULL);
197 } else {
198 printf("Warning: Failed to attach to "
199 "wpa_supplicant.\n");
200 wpa_cli_close_connection();
201 return -1;
202 }
203 }
204
205 return 0;
206 }
207
208
wpa_cli_close_connection(void)209 static void wpa_cli_close_connection(void)
210 {
211 if (ctrl_conn == NULL)
212 return;
213
214 if (wpa_cli_attached) {
215 wpa_ctrl_detach(interactive ? mon_conn : ctrl_conn);
216 wpa_cli_attached = 0;
217 }
218 wpa_ctrl_close(ctrl_conn);
219 ctrl_conn = NULL;
220 if (mon_conn) {
221 eloop_unregister_read_sock(wpa_ctrl_get_fd(mon_conn));
222 wpa_ctrl_close(mon_conn);
223 mon_conn = NULL;
224 }
225 }
226
227
wpa_cli_msg_cb(char * msg,size_t len)228 static void wpa_cli_msg_cb(char *msg, size_t len)
229 {
230 printf("%s\n", msg);
231 }
232
233
_wpa_ctrl_command(struct wpa_ctrl * ctrl,const char * cmd,int print)234 static int _wpa_ctrl_command(struct wpa_ctrl *ctrl, const char *cmd, int print)
235 {
236 char buf[4096];
237 size_t len;
238 int ret;
239
240 if (ctrl_conn == NULL) {
241 printf("Not connected to wpa_supplicant - command dropped.\n");
242 return -1;
243 }
244 if (ifname_prefix) {
245 os_snprintf(buf, sizeof(buf), "IFNAME=%s %s",
246 ifname_prefix, cmd);
247 buf[sizeof(buf) - 1] = '\0';
248 cmd = buf;
249 }
250 len = sizeof(buf) - 1;
251 ret = wpa_ctrl_request(ctrl, cmd, os_strlen(cmd), buf, &len,
252 wpa_cli_msg_cb);
253 if (ret == -2) {
254 printf("'%s' command timed out.\n", cmd);
255 return -2;
256 } else if (ret < 0) {
257 printf("'%s' command failed.\n", cmd);
258 return -1;
259 }
260 if (print) {
261 buf[len] = '\0';
262 printf("%s", buf);
263 if (interactive && len > 0 && buf[len - 1] != '\n')
264 printf("\n");
265 }
266 return 0;
267 }
268
269
wpa_ctrl_command(struct wpa_ctrl * ctrl,const char * cmd)270 static int wpa_ctrl_command(struct wpa_ctrl *ctrl, const char *cmd)
271 {
272 return _wpa_ctrl_command(ctrl, cmd, 1);
273 }
274
275
wpa_cli_cmd(struct wpa_ctrl * ctrl,const char * cmd,int min_args,int argc,char * argv[])276 static int wpa_cli_cmd(struct wpa_ctrl *ctrl, const char *cmd, int min_args,
277 int argc, char *argv[])
278 {
279 char buf[4096];
280 if (argc < min_args) {
281 printf("Invalid %s command - at least %d argument%s "
282 "required.\n", cmd, min_args,
283 min_args > 1 ? "s are" : " is");
284 return -1;
285 }
286 if (write_cmd(buf, sizeof(buf), cmd, argc, argv) < 0)
287 return -1;
288 return wpa_ctrl_command(ctrl, buf);
289 }
290
291 #ifdef CONFIG_VENDOR_EXT
wpa_vendor_ext_cli_cmd(struct wpa_ctrl * ctrl,const char * cmd,int min_args,int argc,char * argv[])292 int wpa_vendor_ext_cli_cmd(struct wpa_ctrl *ctrl, const char *cmd, int min_args, int argc, char *argv[])
293 {
294 return wpa_cli_cmd(ctrl, cmd, min_args, argc, argv);
295 }
296 #endif
297
wpa_cli_cmd_ifname(struct wpa_ctrl * ctrl,int argc,char * argv[])298 static int wpa_cli_cmd_ifname(struct wpa_ctrl *ctrl, int argc, char *argv[])
299 {
300 return wpa_ctrl_command(ctrl, "IFNAME");
301 }
302
303
wpa_cli_cmd_status(struct wpa_ctrl * ctrl,int argc,char * argv[])304 static int wpa_cli_cmd_status(struct wpa_ctrl *ctrl, int argc, char *argv[])
305 {
306 if (argc > 0 && os_strcmp(argv[0], "verbose") == 0)
307 return wpa_ctrl_command(ctrl, "STATUS-VERBOSE");
308 if (argc > 0 && os_strcmp(argv[0], "wps") == 0)
309 return wpa_ctrl_command(ctrl, "STATUS-WPS");
310 if (argc > 0 && os_strcmp(argv[0], "driver") == 0)
311 return wpa_ctrl_command(ctrl, "STATUS-DRIVER");
312 #ifdef ANDROID
313 if (argc > 0 && os_strcmp(argv[0], "no_events") == 0)
314 return wpa_ctrl_command(ctrl, "STATUS-NO_EVENTS");
315 #endif /* ANDROID */
316 return wpa_ctrl_command(ctrl, "STATUS");
317 }
318
319
wpa_cli_cmd_ping(struct wpa_ctrl * ctrl,int argc,char * argv[])320 static int wpa_cli_cmd_ping(struct wpa_ctrl *ctrl, int argc, char *argv[])
321 {
322 return wpa_ctrl_command(ctrl, "PING");
323 }
324
325
wpa_cli_cmd_relog(struct wpa_ctrl * ctrl,int argc,char * argv[])326 static int wpa_cli_cmd_relog(struct wpa_ctrl *ctrl, int argc, char *argv[])
327 {
328 return wpa_ctrl_command(ctrl, "RELOG");
329 }
330
331
wpa_cli_cmd_note(struct wpa_ctrl * ctrl,int argc,char * argv[])332 static int wpa_cli_cmd_note(struct wpa_ctrl *ctrl, int argc, char *argv[])
333 {
334 return wpa_cli_cmd(ctrl, "NOTE", 1, argc, argv);
335 }
336
337
wpa_cli_cmd_mib(struct wpa_ctrl * ctrl,int argc,char * argv[])338 static int wpa_cli_cmd_mib(struct wpa_ctrl *ctrl, int argc, char *argv[])
339 {
340 return wpa_ctrl_command(ctrl, "MIB");
341 }
342
343
wpa_cli_cmd_pmksa(struct wpa_ctrl * ctrl,int argc,char * argv[])344 static int wpa_cli_cmd_pmksa(struct wpa_ctrl *ctrl, int argc, char *argv[])
345 {
346 return wpa_ctrl_command(ctrl, "PMKSA");
347 }
348
349
wpa_cli_cmd_pmksa_flush(struct wpa_ctrl * ctrl,int argc,char * argv[])350 static int wpa_cli_cmd_pmksa_flush(struct wpa_ctrl *ctrl, int argc,
351 char *argv[])
352 {
353 return wpa_ctrl_command(ctrl, "PMKSA_FLUSH");
354 }
355
356
357 #ifdef CONFIG_PMKSA_CACHE_EXTERNAL
358
wpa_cli_cmd_pmksa_get(struct wpa_ctrl * ctrl,int argc,char * argv[])359 static int wpa_cli_cmd_pmksa_get(struct wpa_ctrl *ctrl, int argc, char *argv[])
360 {
361 return wpa_cli_cmd(ctrl, "PMKSA_GET", 1, argc, argv);
362 }
363
364
wpa_cli_cmd_pmksa_add(struct wpa_ctrl * ctrl,int argc,char * argv[])365 static int wpa_cli_cmd_pmksa_add(struct wpa_ctrl *ctrl, int argc, char *argv[])
366 {
367 return wpa_cli_cmd(ctrl, "PMKSA_ADD", 8, argc, argv);
368 }
369
370
371 #ifdef CONFIG_MESH
372
wpa_cli_mesh_cmd_pmksa_get(struct wpa_ctrl * ctrl,int argc,char * argv[])373 static int wpa_cli_mesh_cmd_pmksa_get(struct wpa_ctrl *ctrl, int argc,
374 char *argv[])
375 {
376 return wpa_cli_cmd(ctrl, "MESH_PMKSA_GET", 1, argc, argv);
377 }
378
379
wpa_cli_mesh_cmd_pmksa_add(struct wpa_ctrl * ctrl,int argc,char * argv[])380 static int wpa_cli_mesh_cmd_pmksa_add(struct wpa_ctrl *ctrl, int argc,
381 char *argv[])
382 {
383 return wpa_cli_cmd(ctrl, "MESH_PMKSA_ADD", 4, argc, argv);
384 }
385
386 #endif /* CONFIG_MESH */
387 #endif /* CONFIG_PMKSA_CACHE_EXTERNAL */
388
389
wpa_cli_cmd_help(struct wpa_ctrl * ctrl,int argc,char * argv[])390 static int wpa_cli_cmd_help(struct wpa_ctrl *ctrl, int argc, char *argv[])
391 {
392 print_help(argc > 0 ? argv[0] : NULL);
393 return 0;
394 }
395
396
wpa_cli_complete_help(const char * str,int pos)397 static char ** wpa_cli_complete_help(const char *str, int pos)
398 {
399 int arg = get_cmd_arg_num(str, pos);
400 char **res = NULL;
401
402 switch (arg) {
403 case 1:
404 res = wpa_list_cmd_list();
405 break;
406 }
407
408 return res;
409 }
410
411
wpa_cli_cmd_license(struct wpa_ctrl * ctrl,int argc,char * argv[])412 static int wpa_cli_cmd_license(struct wpa_ctrl *ctrl, int argc, char *argv[])
413 {
414 printf("%s\n\n%s\n", wpa_cli_version, cli_full_license);
415 return 0;
416 }
417
418
wpa_cli_cmd_quit(struct wpa_ctrl * ctrl,int argc,char * argv[])419 static int wpa_cli_cmd_quit(struct wpa_ctrl *ctrl, int argc, char *argv[])
420 {
421 wpa_cli_quit = 1;
422 if (interactive)
423 eloop_terminate();
424 return 0;
425 }
426
427 #ifdef CONFIG_MLD_PATCH_EXT
wpa_cli_cmd_mlo_status(struct wpa_ctrl * ctrl,int argc,char * argv[])428 static int wpa_cli_cmd_mlo_status(struct wpa_ctrl *ctrl, int argc, char *argv[])
429 {
430 return wpa_ctrl_command(ctrl, "MLO_STATUS");
431 }
432
433
wpa_cli_cmd_mlo_signal_poll(struct wpa_ctrl * ctrl,int argc,char * argv[])434 static int wpa_cli_cmd_mlo_signal_poll(struct wpa_ctrl *ctrl, int argc, char *argv[])
435 {
436 return wpa_ctrl_command(ctrl, "MLO_SIGNAL_POLL");
437 }
438 #endif
439
wpa_cli_cmd_set(struct wpa_ctrl * ctrl,int argc,char * argv[])440 static int wpa_cli_cmd_set(struct wpa_ctrl *ctrl, int argc, char *argv[])
441 {
442 char cmd[256];
443 int res;
444
445 if (argc == 1) {
446 res = os_snprintf(cmd, sizeof(cmd), "SET %s ", argv[0]);
447 if (os_snprintf_error(sizeof(cmd), res)) {
448 printf("Too long SET command.\n");
449 return -1;
450 }
451 return wpa_ctrl_command(ctrl, cmd);
452 }
453
454 return wpa_cli_cmd(ctrl, "SET", 2, argc, argv);
455 }
456
457
wpa_cli_complete_set(const char * str,int pos)458 static char ** wpa_cli_complete_set(const char *str, int pos)
459 {
460 int arg = get_cmd_arg_num(str, pos);
461 const char *fields[] = {
462 /* runtime values */
463 "EAPOL::heldPeriod", "EAPOL::authPeriod", "EAPOL::startPeriod",
464 "EAPOL::maxStart", "dot11RSNAConfigPMKLifetime",
465 "dot11RSNAConfigPMKReauthThreshold", "dot11RSNAConfigSATimeout",
466 "wps_fragment_size", "wps_version_number", "ampdu",
467 "tdls_testing", "tdls_disabled", "pno", "radio_disabled",
468 "uapsd", "ps", "wifi_display", "bssid_filter", "disallow_aps",
469 "no_keep_alive",
470 /* global configuration parameters */
471 #ifdef CONFIG_CTRL_IFACE
472 "ctrl_interface", "no_ctrl_interface", "ctrl_interface_group",
473 #endif /* CONFIG_CTRL_IFACE */
474 "eapol_version", "ap_scan", "bgscan",
475 #ifdef CONFIG_MESH
476 "user_mpm", "max_peer_links", "mesh_max_inactivity",
477 "dot11RSNASAERetransPeriod",
478 #endif /* CONFIG_MESH */
479 "disable_scan_offload", "fast_reauth", "opensc_engine_path",
480 "pkcs11_engine_path", "pkcs11_module_path", "openssl_ciphers",
481 "pcsc_reader", "pcsc_pin", "external_sim", "driver_param",
482 "dot11RSNAConfigPMKLifetime",
483 "dot11RSNAConfigPMKReauthThreshold",
484 "dot11RSNAConfigSATimeout",
485 #ifndef CONFIG_NO_CONFIG_WRITE
486 "update_config",
487 #endif /* CONFIG_NO_CONFIG_WRITE */
488 "load_dynamic_eap",
489 #ifdef CONFIG_WPS
490 "uuid", "device_name", "manufacturer", "model_name",
491 "model_number", "serial_number", "device_type", "os_version",
492 "config_methods", "wps_cred_processing", "wps_vendor_ext_m1",
493 #endif /* CONFIG_WPS */
494 #ifdef CONFIG_P2P
495 "sec_device_type",
496 "p2p_listen_reg_class", "p2p_listen_channel",
497 "p2p_oper_reg_class", "p2p_oper_channel", "p2p_go_intent",
498 "p2p_ssid_postfix", "persistent_reconnect", "p2p_intra_bss",
499 "p2p_group_idle", "p2p_passphrase_len", "p2p_pref_chan",
500 "p2p_no_go_freq", "p2p_add_cli_chan",
501 "p2p_optimize_listen_chan", "p2p_go_ht40", "p2p_go_vht",
502 "p2p_disabled", "p2p_go_ctwindow", "p2p_no_group_iface",
503 "p2p_ignore_shared_freq", "ip_addr_go", "ip_addr_mask",
504 "ip_addr_start", "ip_addr_end", "p2p_go_edmg",
505 #endif /* CONFIG_P2P */
506 "country", "bss_max_count", "bss_expiration_age",
507 "bss_expiration_scan_count", "filter_ssids", "filter_rssi",
508 "max_num_sta", "disassoc_low_ack", "ap_isolate",
509 #ifdef CONFIG_HS20
510 "hs20",
511 #endif /* CONFIG_HS20 */
512 "interworking", "hessid", "access_network_type", "pbc_in_m1",
513 "go_interworking", "go_access_network_type", "go_internet",
514 "go_venue_group", "go_venue_type",
515 "autoscan", "wps_nfc_dev_pw_id", "wps_nfc_dh_pubkey",
516 "wps_nfc_dh_privkey", "wps_nfc_dev_pw", "ext_password_backend",
517 "p2p_go_max_inactivity", "auto_interworking", "okc", "pmf",
518 "sae_groups", "dtim_period", "beacon_int",
519 "ap_vendor_elements", "ignore_old_scan_res", "freq_list",
520 "scan_cur_freq", "scan_res_valid_for_connect",
521 "sched_scan_interval",
522 "tdls_external_control", "osu_dir", "wowlan_triggers",
523 "p2p_search_delay", "mac_addr", "rand_addr_lifetime",
524 "preassoc_mac_addr", "key_mgmt_offload", "passive_scan",
525 "reassoc_same_bss_optim", "wps_priority",
526 "ap_assocresp_elements",
527 #ifdef CONFIG_TESTING_OPTIONS
528 "ignore_auth_resp",
529 #endif /* CONFIG_TESTING_OPTIONS */
530 "relative_rssi", "relative_band_adjust",
531 "extended_key_id",
532 };
533 int i, num_fields = ARRAY_SIZE(fields);
534
535 if (arg == 1) {
536 char **res = os_calloc(num_fields + 1, sizeof(char *));
537 if (res == NULL)
538 return NULL;
539 for (i = 0; i < num_fields; i++) {
540 res[i] = os_strdup(fields[i]);
541 if (res[i] == NULL)
542 return res;
543 }
544 return res;
545 }
546
547 if (arg > 1 && os_strncasecmp(str, "set bssid_filter ", 17) == 0)
548 return cli_txt_list_array(&bsses);
549
550 return NULL;
551 }
552
wpa_cli_cmd_dump(struct wpa_ctrl * ctrl,int argc,char * argv[])553 static int wpa_cli_cmd_dump(struct wpa_ctrl *ctrl, int argc, char *argv[])
554 {
555 return wpa_ctrl_command(ctrl, "DUMP");
556 }
557
558
wpa_cli_cmd_driver_flags(struct wpa_ctrl * ctrl,int argc,char * argv[])559 static int wpa_cli_cmd_driver_flags(struct wpa_ctrl *ctrl, int argc,
560 char *argv[])
561 {
562 return wpa_ctrl_command(ctrl, "DRIVER_FLAGS");
563 }
564
565
wpa_cli_cmd_get(struct wpa_ctrl * ctrl,int argc,char * argv[])566 static int wpa_cli_cmd_get(struct wpa_ctrl *ctrl, int argc, char *argv[])
567 {
568 return wpa_cli_cmd(ctrl, "GET", 1, argc, argv);
569 }
570
571
wpa_cli_complete_get(const char * str,int pos)572 static char ** wpa_cli_complete_get(const char *str, int pos)
573 {
574 int arg = get_cmd_arg_num(str, pos);
575 const char *fields[] = {
576 #ifdef CONFIG_CTRL_IFACE
577 "ctrl_interface", "ctrl_interface_group",
578 #endif /* CONFIG_CTRL_IFACE */
579 "eapol_version", "ap_scan",
580 #ifdef CONFIG_MESH
581 "user_mpm", "max_peer_links", "mesh_max_inactivity",
582 #endif /* CONFIG_MESH */
583 "disable_scan_offload", "fast_reauth", "opensc_engine_path",
584 "pkcs11_engine_path", "pkcs11_module_path", "openssl_ciphers",
585 "pcsc_reader", "pcsc_pin", "external_sim", "driver_param",
586 "dot11RSNAConfigPMKLifetime",
587 "dot11RSNAConfigPMKReauthThreshold",
588 "dot11RSNAConfigSATimeout",
589 #ifndef CONFIG_NO_CONFIG_WRITE
590 "update_config",
591 #endif /* CONFIG_NO_CONFIG_WRITE */
592 #ifdef CONFIG_WPS
593 "device_name", "manufacturer", "model_name", "model_number",
594 "serial_number", "config_methods", "wps_cred_processing",
595 #endif /* CONFIG_WPS */
596 #ifdef CONFIG_P2P
597 "p2p_listen_reg_class", "p2p_listen_channel",
598 "p2p_oper_reg_class", "p2p_oper_channel", "p2p_go_intent",
599 "p2p_ssid_postfix", "persistent_reconnect", "p2p_intra_bss",
600 "p2p_group_idle", "p2p_passphrase_len", "p2p_add_cli_chan",
601 "p2p_optimize_listen_chan", "p2p_go_ht40", "p2p_go_vht",
602 "p2p_disabled", "p2p_go_ctwindow", "p2p_no_group_iface",
603 "p2p_ignore_shared_freq", "ip_addr_go", "ip_addr_mask",
604 "ip_addr_start", "ip_addr_end",
605 #endif /* CONFIG_P2P */
606 "bss_max_count", "bss_expiration_age",
607 "bss_expiration_scan_count", "filter_ssids", "filter_rssi",
608 "max_num_sta", "disassoc_low_ack", "ap_isolate",
609 #ifdef CONFIG_HS20
610 "hs20",
611 #endif /* CONFIG_HS20 */
612 "interworking", "access_network_type", "pbc_in_m1", "autoscan",
613 "go_interworking", "go_access_network_type", "go_internet",
614 "go_venue_group", "go_venue_type",
615 "wps_nfc_dev_pw_id", "ext_password_backend",
616 "p2p_go_max_inactivity", "auto_interworking", "okc", "pmf",
617 "dtim_period", "beacon_int", "ignore_old_scan_res",
618 "scan_cur_freq", "scan_res_valid_for_connect",
619 "sched_scan_interval",
620 "sched_scan_start_delay",
621 "tdls_external_control", "osu_dir", "wowlan_triggers",
622 "p2p_search_delay", "mac_addr", "rand_addr_lifetime",
623 "preassoc_mac_addr", "key_mgmt_offload", "passive_scan",
624 "reassoc_same_bss_optim", "extended_key_id"
625 };
626 int i, num_fields = ARRAY_SIZE(fields);
627
628 if (arg == 1) {
629 char **res = os_calloc(num_fields + 1, sizeof(char *));
630 if (res == NULL)
631 return NULL;
632 for (i = 0; i < num_fields; i++) {
633 res[i] = os_strdup(fields[i]);
634 if (res[i] == NULL)
635 return res;
636 }
637 return res;
638 }
639
640 return NULL;
641 }
642
643
wpa_cli_cmd_logoff(struct wpa_ctrl * ctrl,int argc,char * argv[])644 static int wpa_cli_cmd_logoff(struct wpa_ctrl *ctrl, int argc, char *argv[])
645 {
646 return wpa_ctrl_command(ctrl, "LOGOFF");
647 }
648
649
wpa_cli_cmd_logon(struct wpa_ctrl * ctrl,int argc,char * argv[])650 static int wpa_cli_cmd_logon(struct wpa_ctrl *ctrl, int argc, char *argv[])
651 {
652 return wpa_ctrl_command(ctrl, "LOGON");
653 }
654
655
wpa_cli_cmd_reassociate(struct wpa_ctrl * ctrl,int argc,char * argv[])656 static int wpa_cli_cmd_reassociate(struct wpa_ctrl *ctrl, int argc,
657 char *argv[])
658 {
659 return wpa_ctrl_command(ctrl, "REASSOCIATE");
660 }
661
662
wpa_cli_cmd_reattach(struct wpa_ctrl * ctrl,int argc,char * argv[])663 static int wpa_cli_cmd_reattach(struct wpa_ctrl *ctrl, int argc, char *argv[])
664 {
665 return wpa_ctrl_command(ctrl, "REATTACH");
666 }
667
668
wpa_cli_cmd_preauthenticate(struct wpa_ctrl * ctrl,int argc,char * argv[])669 static int wpa_cli_cmd_preauthenticate(struct wpa_ctrl *ctrl, int argc,
670 char *argv[])
671 {
672 return wpa_cli_cmd(ctrl, "PREAUTH", 1, argc, argv);
673 }
674
675
wpa_cli_cmd_ap_scan(struct wpa_ctrl * ctrl,int argc,char * argv[])676 static int wpa_cli_cmd_ap_scan(struct wpa_ctrl *ctrl, int argc, char *argv[])
677 {
678 return wpa_cli_cmd(ctrl, "AP_SCAN", 1, argc, argv);
679 }
680
681
wpa_cli_cmd_scan_interval(struct wpa_ctrl * ctrl,int argc,char * argv[])682 static int wpa_cli_cmd_scan_interval(struct wpa_ctrl *ctrl, int argc,
683 char *argv[])
684 {
685 return wpa_cli_cmd(ctrl, "SCAN_INTERVAL", 1, argc, argv);
686 }
687
688
wpa_cli_cmd_bss_expire_age(struct wpa_ctrl * ctrl,int argc,char * argv[])689 static int wpa_cli_cmd_bss_expire_age(struct wpa_ctrl *ctrl, int argc,
690 char *argv[])
691 {
692 return wpa_cli_cmd(ctrl, "BSS_EXPIRE_AGE", 1, argc, argv);
693 }
694
695
wpa_cli_cmd_bss_expire_count(struct wpa_ctrl * ctrl,int argc,char * argv[])696 static int wpa_cli_cmd_bss_expire_count(struct wpa_ctrl *ctrl, int argc,
697 char *argv[])
698 {
699 return wpa_cli_cmd(ctrl, "BSS_EXPIRE_COUNT", 1, argc, argv);
700 }
701
702
wpa_cli_cmd_bss_flush(struct wpa_ctrl * ctrl,int argc,char * argv[])703 static int wpa_cli_cmd_bss_flush(struct wpa_ctrl *ctrl, int argc, char *argv[])
704 {
705 char cmd[256];
706 int res;
707
708 if (argc < 1)
709 res = os_snprintf(cmd, sizeof(cmd), "BSS_FLUSH 0");
710 else
711 res = os_snprintf(cmd, sizeof(cmd), "BSS_FLUSH %s", argv[0]);
712 if (os_snprintf_error(sizeof(cmd), res)) {
713 printf("Too long BSS_FLUSH command.\n");
714 return -1;
715 }
716 return wpa_ctrl_command(ctrl, cmd);
717 }
718
719
wpa_cli_cmd_ft_ds(struct wpa_ctrl * ctrl,int argc,char * argv[])720 static int wpa_cli_cmd_ft_ds(struct wpa_ctrl *ctrl, int argc, char *argv[])
721 {
722 return wpa_cli_cmd(ctrl, "FT_DS", 1, argc, argv);
723 }
724
725
wpa_cli_cmd_wps_pbc(struct wpa_ctrl * ctrl,int argc,char * argv[])726 static int wpa_cli_cmd_wps_pbc(struct wpa_ctrl *ctrl, int argc, char *argv[])
727 {
728 return wpa_cli_cmd(ctrl, "WPS_PBC", 0, argc, argv);
729 }
730
731
wpa_cli_cmd_wps_pin(struct wpa_ctrl * ctrl,int argc,char * argv[])732 static int wpa_cli_cmd_wps_pin(struct wpa_ctrl *ctrl, int argc, char *argv[])
733 {
734 if (argc == 0) {
735 printf("Invalid WPS_PIN command: need one or two arguments:\n"
736 "- BSSID: use 'any' to select any\n"
737 "- PIN: optional, used only with devices that have no "
738 "display\n");
739 return -1;
740 }
741
742 return wpa_cli_cmd(ctrl, "WPS_PIN", 1, argc, argv);
743 }
744
745
wpa_cli_cmd_wps_check_pin(struct wpa_ctrl * ctrl,int argc,char * argv[])746 static int wpa_cli_cmd_wps_check_pin(struct wpa_ctrl *ctrl, int argc,
747 char *argv[])
748 {
749 return wpa_cli_cmd(ctrl, "WPS_CHECK_PIN", 1, argc, argv);
750 }
751
752
wpa_cli_cmd_wps_cancel(struct wpa_ctrl * ctrl,int argc,char * argv[])753 static int wpa_cli_cmd_wps_cancel(struct wpa_ctrl *ctrl, int argc,
754 char *argv[])
755 {
756 return wpa_ctrl_command(ctrl, "WPS_CANCEL");
757 }
758
759
760 #ifdef CONFIG_WPS_NFC
761
wpa_cli_cmd_wps_nfc(struct wpa_ctrl * ctrl,int argc,char * argv[])762 static int wpa_cli_cmd_wps_nfc(struct wpa_ctrl *ctrl, int argc, char *argv[])
763 {
764 return wpa_cli_cmd(ctrl, "WPS_NFC", 0, argc, argv);
765 }
766
767
wpa_cli_cmd_wps_nfc_config_token(struct wpa_ctrl * ctrl,int argc,char * argv[])768 static int wpa_cli_cmd_wps_nfc_config_token(struct wpa_ctrl *ctrl, int argc,
769 char *argv[])
770 {
771 return wpa_cli_cmd(ctrl, "WPS_NFC_CONFIG_TOKEN", 1, argc, argv);
772 }
773
774
wpa_cli_cmd_wps_nfc_token(struct wpa_ctrl * ctrl,int argc,char * argv[])775 static int wpa_cli_cmd_wps_nfc_token(struct wpa_ctrl *ctrl, int argc,
776 char *argv[])
777 {
778 return wpa_cli_cmd(ctrl, "WPS_NFC_TOKEN", 1, argc, argv);
779 }
780
781
wpa_cli_cmd_wps_nfc_tag_read(struct wpa_ctrl * ctrl,int argc,char * argv[])782 static int wpa_cli_cmd_wps_nfc_tag_read(struct wpa_ctrl *ctrl, int argc,
783 char *argv[])
784 {
785 int ret;
786 char *buf;
787 size_t buflen;
788
789 if (argc != 1) {
790 printf("Invalid 'wps_nfc_tag_read' command - one argument "
791 "is required.\n");
792 return -1;
793 }
794
795 buflen = 18 + os_strlen(argv[0]);
796 buf = os_malloc(buflen);
797 if (buf == NULL)
798 return -1;
799 os_snprintf(buf, buflen, "WPS_NFC_TAG_READ %s", argv[0]);
800
801 ret = wpa_ctrl_command(ctrl, buf);
802 os_free(buf);
803
804 return ret;
805 }
806
807
wpa_cli_cmd_nfc_get_handover_req(struct wpa_ctrl * ctrl,int argc,char * argv[])808 static int wpa_cli_cmd_nfc_get_handover_req(struct wpa_ctrl *ctrl, int argc,
809 char *argv[])
810 {
811 return wpa_cli_cmd(ctrl, "NFC_GET_HANDOVER_REQ", 2, argc, argv);
812 }
813
814
wpa_cli_cmd_nfc_get_handover_sel(struct wpa_ctrl * ctrl,int argc,char * argv[])815 static int wpa_cli_cmd_nfc_get_handover_sel(struct wpa_ctrl *ctrl, int argc,
816 char *argv[])
817 {
818 return wpa_cli_cmd(ctrl, "NFC_GET_HANDOVER_SEL", 2, argc, argv);
819 }
820
821
wpa_cli_cmd_nfc_report_handover(struct wpa_ctrl * ctrl,int argc,char * argv[])822 static int wpa_cli_cmd_nfc_report_handover(struct wpa_ctrl *ctrl, int argc,
823 char *argv[])
824 {
825 return wpa_cli_cmd(ctrl, "NFC_REPORT_HANDOVER", 4, argc, argv);
826 }
827
828 #endif /* CONFIG_WPS_NFC */
829
830
wpa_cli_cmd_wps_reg(struct wpa_ctrl * ctrl,int argc,char * argv[])831 static int wpa_cli_cmd_wps_reg(struct wpa_ctrl *ctrl, int argc, char *argv[])
832 {
833 char cmd[256];
834 int res;
835
836 if (argc == 2)
837 res = os_snprintf(cmd, sizeof(cmd), "WPS_REG %s %s",
838 argv[0], argv[1]);
839 else if (argc == 5 || argc == 6) {
840 char ssid_hex[2 * SSID_MAX_LEN + 1];
841 char key_hex[2 * 64 + 1];
842 int i;
843
844 ssid_hex[0] = '\0';
845 for (i = 0; i < SSID_MAX_LEN; i++) {
846 if (argv[2][i] == '\0')
847 break;
848 os_snprintf(&ssid_hex[i * 2], 3, "%02x", argv[2][i]);
849 }
850
851 key_hex[0] = '\0';
852 if (argc == 6) {
853 for (i = 0; i < 64; i++) {
854 if (argv[5][i] == '\0')
855 break;
856 os_snprintf(&key_hex[i * 2], 3, "%02x",
857 argv[5][i]);
858 }
859 }
860
861 res = os_snprintf(cmd, sizeof(cmd),
862 "WPS_REG %s %s %s %s %s %s",
863 argv[0], argv[1], ssid_hex, argv[3], argv[4],
864 key_hex);
865 } else {
866 printf("Invalid WPS_REG command: need two arguments:\n"
867 "- BSSID of the target AP\n"
868 "- AP PIN\n");
869 printf("Alternatively, six arguments can be used to "
870 "reconfigure the AP:\n"
871 "- BSSID of the target AP\n"
872 "- AP PIN\n"
873 "- new SSID\n"
874 "- new auth (OPEN, WPAPSK, WPA2PSK)\n"
875 "- new encr (NONE, WEP, TKIP, CCMP)\n"
876 "- new key\n");
877 return -1;
878 }
879
880 if (os_snprintf_error(sizeof(cmd), res)) {
881 printf("Too long WPS_REG command.\n");
882 return -1;
883 }
884 return wpa_ctrl_command(ctrl, cmd);
885 }
886
887
wpa_cli_cmd_wps_ap_pin(struct wpa_ctrl * ctrl,int argc,char * argv[])888 static int wpa_cli_cmd_wps_ap_pin(struct wpa_ctrl *ctrl, int argc,
889 char *argv[])
890 {
891 return wpa_cli_cmd(ctrl, "WPS_AP_PIN", 1, argc, argv);
892 }
893
894
wpa_cli_cmd_wps_er_start(struct wpa_ctrl * ctrl,int argc,char * argv[])895 static int wpa_cli_cmd_wps_er_start(struct wpa_ctrl *ctrl, int argc,
896 char *argv[])
897 {
898 return wpa_cli_cmd(ctrl, "WPS_ER_START", 0, argc, argv);
899 }
900
901
wpa_cli_cmd_wps_er_stop(struct wpa_ctrl * ctrl,int argc,char * argv[])902 static int wpa_cli_cmd_wps_er_stop(struct wpa_ctrl *ctrl, int argc,
903 char *argv[])
904 {
905 return wpa_ctrl_command(ctrl, "WPS_ER_STOP");
906
907 }
908
909
wpa_cli_cmd_wps_er_pin(struct wpa_ctrl * ctrl,int argc,char * argv[])910 static int wpa_cli_cmd_wps_er_pin(struct wpa_ctrl *ctrl, int argc,
911 char *argv[])
912 {
913 if (argc < 2) {
914 printf("Invalid WPS_ER_PIN command: need at least two "
915 "arguments:\n"
916 "- UUID: use 'any' to select any\n"
917 "- PIN: Enrollee PIN\n"
918 "optional: - Enrollee MAC address\n");
919 return -1;
920 }
921
922 return wpa_cli_cmd(ctrl, "WPS_ER_PIN", 2, argc, argv);
923 }
924
925
wpa_cli_cmd_wps_er_pbc(struct wpa_ctrl * ctrl,int argc,char * argv[])926 static int wpa_cli_cmd_wps_er_pbc(struct wpa_ctrl *ctrl, int argc,
927 char *argv[])
928 {
929 return wpa_cli_cmd(ctrl, "WPS_ER_PBC", 1, argc, argv);
930 }
931
932
wpa_cli_cmd_wps_er_learn(struct wpa_ctrl * ctrl,int argc,char * argv[])933 static int wpa_cli_cmd_wps_er_learn(struct wpa_ctrl *ctrl, int argc,
934 char *argv[])
935 {
936 if (argc != 2) {
937 printf("Invalid WPS_ER_LEARN command: need two arguments:\n"
938 "- UUID: specify which AP to use\n"
939 "- PIN: AP PIN\n");
940 return -1;
941 }
942
943 return wpa_cli_cmd(ctrl, "WPS_ER_LEARN", 2, argc, argv);
944 }
945
946
wpa_cli_cmd_wps_er_set_config(struct wpa_ctrl * ctrl,int argc,char * argv[])947 static int wpa_cli_cmd_wps_er_set_config(struct wpa_ctrl *ctrl, int argc,
948 char *argv[])
949 {
950 if (argc != 2) {
951 printf("Invalid WPS_ER_SET_CONFIG command: need two "
952 "arguments:\n"
953 "- UUID: specify which AP to use\n"
954 "- Network configuration id\n");
955 return -1;
956 }
957
958 return wpa_cli_cmd(ctrl, "WPS_ER_SET_CONFIG", 2, argc, argv);
959 }
960
961
wpa_cli_cmd_wps_er_config(struct wpa_ctrl * ctrl,int argc,char * argv[])962 static int wpa_cli_cmd_wps_er_config(struct wpa_ctrl *ctrl, int argc,
963 char *argv[])
964 {
965 char cmd[256];
966 int res;
967
968 if (argc == 5 || argc == 6) {
969 char ssid_hex[2 * SSID_MAX_LEN + 1];
970 char key_hex[2 * 64 + 1];
971 int i;
972
973 ssid_hex[0] = '\0';
974 for (i = 0; i < SSID_MAX_LEN; i++) {
975 if (argv[2][i] == '\0')
976 break;
977 os_snprintf(&ssid_hex[i * 2], 3, "%02x", argv[2][i]);
978 }
979
980 key_hex[0] = '\0';
981 if (argc == 6) {
982 for (i = 0; i < 64; i++) {
983 if (argv[5][i] == '\0')
984 break;
985 os_snprintf(&key_hex[i * 2], 3, "%02x",
986 argv[5][i]);
987 }
988 }
989
990 res = os_snprintf(cmd, sizeof(cmd),
991 "WPS_ER_CONFIG %s %s %s %s %s %s",
992 argv[0], argv[1], ssid_hex, argv[3], argv[4],
993 key_hex);
994 } else {
995 printf("Invalid WPS_ER_CONFIG command: need six arguments:\n"
996 "- AP UUID\n"
997 "- AP PIN\n"
998 "- new SSID\n"
999 "- new auth (OPEN, WPAPSK, WPA2PSK)\n"
1000 "- new encr (NONE, WEP, TKIP, CCMP)\n"
1001 "- new key\n");
1002 return -1;
1003 }
1004
1005 if (os_snprintf_error(sizeof(cmd), res)) {
1006 printf("Too long WPS_ER_CONFIG command.\n");
1007 return -1;
1008 }
1009 return wpa_ctrl_command(ctrl, cmd);
1010 }
1011
1012
1013 #ifdef CONFIG_WPS_NFC
wpa_cli_cmd_wps_er_nfc_config_token(struct wpa_ctrl * ctrl,int argc,char * argv[])1014 static int wpa_cli_cmd_wps_er_nfc_config_token(struct wpa_ctrl *ctrl, int argc,
1015 char *argv[])
1016 {
1017 if (argc != 2) {
1018 printf("Invalid WPS_ER_NFC_CONFIG_TOKEN command: need two "
1019 "arguments:\n"
1020 "- WPS/NDEF: token format\n"
1021 "- UUID: specify which AP to use\n");
1022 return -1;
1023 }
1024
1025 return wpa_cli_cmd(ctrl, "WPS_ER_NFC_CONFIG_TOKEN", 2, argc, argv);
1026 }
1027 #endif /* CONFIG_WPS_NFC */
1028
1029
wpa_cli_cmd_ibss_rsn(struct wpa_ctrl * ctrl,int argc,char * argv[])1030 static int wpa_cli_cmd_ibss_rsn(struct wpa_ctrl *ctrl, int argc, char *argv[])
1031 {
1032 return wpa_cli_cmd(ctrl, "IBSS_RSN", 1, argc, argv);
1033 }
1034
1035
wpa_cli_cmd_level(struct wpa_ctrl * ctrl,int argc,char * argv[])1036 static int wpa_cli_cmd_level(struct wpa_ctrl *ctrl, int argc, char *argv[])
1037 {
1038 return wpa_cli_cmd(ctrl, "LEVEL", 1, argc, argv);
1039 }
1040
1041
wpa_cli_cmd_identity(struct wpa_ctrl * ctrl,int argc,char * argv[])1042 static int wpa_cli_cmd_identity(struct wpa_ctrl *ctrl, int argc, char *argv[])
1043 {
1044 char cmd[256], *pos, *end;
1045 int i, ret;
1046
1047 if (argc < 2) {
1048 printf("Invalid IDENTITY command: needs two arguments "
1049 "(network id and identity)\n");
1050 return -1;
1051 }
1052
1053 end = cmd + sizeof(cmd);
1054 pos = cmd;
1055 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "IDENTITY-%s:%s",
1056 argv[0], argv[1]);
1057 if (os_snprintf_error(end - pos, ret)) {
1058 printf("Too long IDENTITY command.\n");
1059 return -1;
1060 }
1061 pos += ret;
1062 for (i = 2; i < argc; i++) {
1063 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
1064 if (os_snprintf_error(end - pos, ret)) {
1065 printf("Too long IDENTITY command.\n");
1066 return -1;
1067 }
1068 pos += ret;
1069 }
1070
1071 return wpa_ctrl_command(ctrl, cmd);
1072 }
1073
1074 #ifdef CONFIG_EAP_AUTH
wpa_cli_cmd_sim_kc(struct wpa_ctrl * ctrl,int argc,char * argv[])1075 static int wpa_cli_cmd_sim_kc(struct wpa_ctrl *ctrl, int argc, char *argv[])
1076 {
1077 char cmd[256], *pos, *end;
1078 int i, ret;
1079
1080 if (argc < INIT_VAL) {
1081 printf("Invalid SIM_KC command: needs two arguments "
1082 "(network id and sim_kc)\n");
1083 return -1;
1084 }
1085
1086 end = cmd + sizeof(cmd);
1087 pos = cmd;
1088 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "SIM_KC-%s:%s",
1089 argv[0], argv[1]);
1090 if (os_snprintf_error(end - pos, ret)) {
1091 printf("Too long SIM_KC command.\n");
1092 return -1;
1093 }
1094 pos += ret;
1095 for (i = INIT_VAL; i < argc; i++) {
1096 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
1097 if (os_snprintf_error(end - pos, ret)) {
1098 printf("Too long SIM_KC command.\n");
1099 return -1;
1100 }
1101 pos += ret;
1102 }
1103
1104 return wpa_ctrl_command(ctrl, cmd);
1105 }
1106
wpa_cli_cmd_sim_sres(struct wpa_ctrl * ctrl,int argc,char * argv[])1107 static int wpa_cli_cmd_sim_sres(struct wpa_ctrl *ctrl, int argc, char *argv[])
1108 {
1109 char cmd[256], *pos, *end;
1110 int i, ret;
1111
1112 if (argc < INIT_VAL) {
1113 printf("Invalid SIM_SRES command: needs two arguments "
1114 "(network id and sim_sres)\n");
1115 return -1;
1116 }
1117
1118 end = cmd + sizeof(cmd);
1119 pos = cmd;
1120 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "SIM_SRES-%s:%s",
1121 argv[0], argv[1]);
1122 if (os_snprintf_error(end - pos, ret)) {
1123 printf("Too long SIM_SRES command.\n");
1124 return -1;
1125 }
1126 pos += ret;
1127 for (i = INIT_VAL; i < argc; i++) {
1128 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
1129 if (os_snprintf_error(end - pos, ret)) {
1130 printf("Too long SIM_SRES command.\n");
1131 return -1;
1132 }
1133 pos += ret;
1134 }
1135
1136 return wpa_ctrl_command(ctrl, cmd);
1137 }
1138
wpa_cli_cmd_param_ki(struct wpa_ctrl * ctrl,int argc,char * argv[])1139 static int wpa_cli_cmd_param_ki(struct wpa_ctrl *ctrl, int argc, char *argv[])
1140 {
1141 char cmd[256], *pos, *end;
1142 int i, ret;
1143
1144 if (argc < INIT_VAL) {
1145 printf("Invalid PARAM_KI command: needs two arguments "
1146 "(network id and param_ki)\n");
1147 return -1;
1148 }
1149
1150 end = cmd + sizeof(cmd);
1151 pos = cmd;
1152 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "PARAM_KI-%s:%s",
1153 argv[0], argv[1]);
1154 if (os_snprintf_error(end - pos, ret)) {
1155 printf("Too long PARAM_KI command.\n");
1156 return -1;
1157 }
1158 pos += ret;
1159 for (i = INIT_VAL; i < argc; i++) {
1160 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
1161 if (os_snprintf_error(end - pos, ret)) {
1162 printf("Too long PARAM_KI command.\n");
1163 return -1;
1164 }
1165 pos += ret;
1166 }
1167
1168 return wpa_ctrl_command(ctrl, cmd);
1169 }
1170
wpa_cli_cmd_param_opc(struct wpa_ctrl * ctrl,int argc,char * argv[])1171 static int wpa_cli_cmd_param_opc(struct wpa_ctrl *ctrl, int argc, char *argv[])
1172 {
1173 char cmd[256], *pos, *end;
1174 int i, ret;
1175
1176 if (argc < INIT_VAL) {
1177 printf("Invalid PARAM_OPC command: needs two arguments "
1178 "(network id and param_opc)\n");
1179 return -1;
1180 }
1181
1182 end = cmd + sizeof(cmd);
1183 pos = cmd;
1184 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "PARAM_OPC-%s:%s",
1185 argv[0], argv[1]);
1186 if (os_snprintf_error(end - pos, ret)) {
1187 printf("Too long PARAM_OPC command.\n");
1188 return -1;
1189 }
1190 pos += ret;
1191 for (i = INIT_VAL; i < argc; i++) {
1192 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
1193 if (os_snprintf_error(end - pos, ret)) {
1194 printf("Too long PARAM_OPC command.\n");
1195 return -1;
1196 }
1197 pos += ret;
1198 }
1199
1200 return wpa_ctrl_command(ctrl, cmd);
1201 }
1202
wpa_cli_cmd_param_amf(struct wpa_ctrl * ctrl,int argc,char * argv[])1203 static int wpa_cli_cmd_param_amf(struct wpa_ctrl *ctrl, int argc, char *argv[])
1204 {
1205 char cmd[256], *pos, *end;
1206 int i, ret;
1207
1208 if (argc < INIT_VAL) {
1209 printf("Invalid PARAM_AMF command: needs two arguments "
1210 "(network id and param_amf)\n");
1211 return -1;
1212 }
1213
1214 end = cmd + sizeof(cmd);
1215 pos = cmd;
1216 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "PARAM_AMF-%s:%s",
1217 argv[0], argv[1]);
1218 if (os_snprintf_error(end - pos, ret)) {
1219 printf("Too long PARAM_AMF command.\n");
1220 return -1;
1221 }
1222 pos += ret;
1223 for (i = INIT_VAL; i < argc; i++) {
1224 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
1225 if (os_snprintf_error(end - pos, ret)) {
1226 printf("Too long PARAM_AMF command.\n");
1227 return -1;
1228 }
1229 pos += ret;
1230 }
1231
1232 return wpa_ctrl_command(ctrl, cmd);
1233 }
1234
wpa_cli_cmd_param_sqn(struct wpa_ctrl * ctrl,int argc,char * argv[])1235 static int wpa_cli_cmd_param_sqn(struct wpa_ctrl *ctrl, int argc, char *argv[])
1236 {
1237 char cmd[256], *pos, *end;
1238 int i, ret;
1239
1240 if (argc < INIT_VAL) {
1241 printf("Invalid PARAM_SQN command: needs two arguments "
1242 "(network id and param_sqn)\n");
1243 return -1;
1244 }
1245
1246 end = cmd + sizeof(cmd);
1247 pos = cmd;
1248 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "PARAM_SQN-%s:%s",
1249 argv[0], argv[1]);
1250 if (os_snprintf_error(end - pos, ret)) {
1251 printf("Too long PARAM_SQN command.\n");
1252 return -1;
1253 }
1254 pos += ret;
1255 for (i = INIT_VAL; i < argc; i++) {
1256 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
1257 if (os_snprintf_error(end - pos, ret)) {
1258 printf("Too long PARAM_SQN command.\n");
1259 return -1;
1260 }
1261 pos += ret;
1262 }
1263
1264 return wpa_ctrl_command(ctrl, cmd);
1265 }
1266 #endif
1267
wpa_cli_cmd_password(struct wpa_ctrl * ctrl,int argc,char * argv[])1268 static int wpa_cli_cmd_password(struct wpa_ctrl *ctrl, int argc, char *argv[])
1269 {
1270 char cmd[256], *pos, *end;
1271 int i, ret;
1272
1273 if (argc < 2) {
1274 printf("Invalid PASSWORD command: needs two arguments "
1275 "(network id and password)\n");
1276 return -1;
1277 }
1278
1279 end = cmd + sizeof(cmd);
1280 pos = cmd;
1281 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "PASSWORD-%s:%s",
1282 argv[0], argv[1]);
1283 if (os_snprintf_error(end - pos, ret)) {
1284 printf("Too long PASSWORD command.\n");
1285 return -1;
1286 }
1287 pos += ret;
1288 for (i = 2; i < argc; i++) {
1289 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
1290 if (os_snprintf_error(end - pos, ret)) {
1291 printf("Too long PASSWORD command.\n");
1292 return -1;
1293 }
1294 pos += ret;
1295 }
1296
1297 return wpa_ctrl_command(ctrl, cmd);
1298 }
1299
1300
wpa_cli_cmd_new_password(struct wpa_ctrl * ctrl,int argc,char * argv[])1301 static int wpa_cli_cmd_new_password(struct wpa_ctrl *ctrl, int argc,
1302 char *argv[])
1303 {
1304 char cmd[256], *pos, *end;
1305 int i, ret;
1306
1307 if (argc < 2) {
1308 printf("Invalid NEW_PASSWORD command: needs two arguments "
1309 "(network id and password)\n");
1310 return -1;
1311 }
1312
1313 end = cmd + sizeof(cmd);
1314 pos = cmd;
1315 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "NEW_PASSWORD-%s:%s",
1316 argv[0], argv[1]);
1317 if (os_snprintf_error(end - pos, ret)) {
1318 printf("Too long NEW_PASSWORD command.\n");
1319 return -1;
1320 }
1321 pos += ret;
1322 for (i = 2; i < argc; i++) {
1323 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
1324 if (os_snprintf_error(end - pos, ret)) {
1325 printf("Too long NEW_PASSWORD command.\n");
1326 return -1;
1327 }
1328 pos += ret;
1329 }
1330
1331 return wpa_ctrl_command(ctrl, cmd);
1332 }
1333
1334
wpa_cli_cmd_pin(struct wpa_ctrl * ctrl,int argc,char * argv[])1335 static int wpa_cli_cmd_pin(struct wpa_ctrl *ctrl, int argc, char *argv[])
1336 {
1337 char cmd[256], *pos, *end;
1338 int i, ret;
1339
1340 if (argc < 2) {
1341 printf("Invalid PIN command: needs two arguments "
1342 "(network id and pin)\n");
1343 return -1;
1344 }
1345
1346 end = cmd + sizeof(cmd);
1347 pos = cmd;
1348 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "PIN-%s:%s",
1349 argv[0], argv[1]);
1350 if (os_snprintf_error(end - pos, ret)) {
1351 printf("Too long PIN command.\n");
1352 return -1;
1353 }
1354 pos += ret;
1355 for (i = 2; i < argc; i++) {
1356 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
1357 if (os_snprintf_error(end - pos, ret)) {
1358 printf("Too long PIN command.\n");
1359 return -1;
1360 }
1361 pos += ret;
1362 }
1363 return wpa_ctrl_command(ctrl, cmd);
1364 }
1365
1366
wpa_cli_cmd_otp(struct wpa_ctrl * ctrl,int argc,char * argv[])1367 static int wpa_cli_cmd_otp(struct wpa_ctrl *ctrl, int argc, char *argv[])
1368 {
1369 char cmd[256], *pos, *end;
1370 int i, ret;
1371
1372 if (argc < 2) {
1373 printf("Invalid OTP command: needs two arguments (network "
1374 "id and password)\n");
1375 return -1;
1376 }
1377
1378 end = cmd + sizeof(cmd);
1379 pos = cmd;
1380 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "OTP-%s:%s",
1381 argv[0], argv[1]);
1382 if (os_snprintf_error(end - pos, ret)) {
1383 printf("Too long OTP command.\n");
1384 return -1;
1385 }
1386 pos += ret;
1387 for (i = 2; i < argc; i++) {
1388 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
1389 if (os_snprintf_error(end - pos, ret)) {
1390 printf("Too long OTP command.\n");
1391 return -1;
1392 }
1393 pos += ret;
1394 }
1395
1396 return wpa_ctrl_command(ctrl, cmd);
1397 }
1398
1399
wpa_cli_cmd_sim(struct wpa_ctrl * ctrl,int argc,char * argv[])1400 static int wpa_cli_cmd_sim(struct wpa_ctrl *ctrl, int argc, char *argv[])
1401 {
1402 char cmd[256], *pos, *end;
1403 int i, ret;
1404
1405 if (argc < 2) {
1406 printf("Invalid SIM command: needs two arguments "
1407 "(network id and SIM operation response)\n");
1408 return -1;
1409 }
1410
1411 end = cmd + sizeof(cmd);
1412 pos = cmd;
1413 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "SIM-%s:%s",
1414 argv[0], argv[1]);
1415 if (os_snprintf_error(end - pos, ret)) {
1416 printf("Too long SIM command.\n");
1417 return -1;
1418 }
1419 pos += ret;
1420 for (i = 2; i < argc; i++) {
1421 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
1422 if (os_snprintf_error(end - pos, ret)) {
1423 printf("Too long SIM command.\n");
1424 return -1;
1425 }
1426 pos += ret;
1427 }
1428 return wpa_ctrl_command(ctrl, cmd);
1429 }
1430
1431
wpa_cli_cmd_psk_passphrase(struct wpa_ctrl * ctrl,int argc,char * argv[])1432 static int wpa_cli_cmd_psk_passphrase(struct wpa_ctrl *ctrl, int argc,
1433 char *argv[])
1434 {
1435 char cmd[256], *pos, *end;
1436 int i, ret;
1437
1438 if (argc < 2) {
1439 printf("Invalid PSK_PASSPHRASE command: needs two arguments (network id and PSK/passphrase)\n");
1440 return -1;
1441 }
1442
1443 end = cmd + sizeof(cmd);
1444 pos = cmd;
1445 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "PSK_PASSPHRASE-%s:%s",
1446 argv[0], argv[1]);
1447 if (os_snprintf_error(end - pos, ret)) {
1448 printf("Too long PSK_PASSPHRASE command.\n");
1449 return -1;
1450 }
1451 pos += ret;
1452 for (i = 2; i < argc; i++) {
1453 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
1454 if (os_snprintf_error(end - pos, ret)) {
1455 printf("Too long PSK_PASSPHRASE command.\n");
1456 return -1;
1457 }
1458 pos += ret;
1459 }
1460
1461 return wpa_ctrl_command(ctrl, cmd);
1462 }
1463
1464
wpa_cli_cmd_passphrase(struct wpa_ctrl * ctrl,int argc,char * argv[])1465 static int wpa_cli_cmd_passphrase(struct wpa_ctrl *ctrl, int argc,
1466 char *argv[])
1467 {
1468 char cmd[256], *pos, *end;
1469 int i, ret;
1470
1471 if (argc < 2) {
1472 printf("Invalid PASSPHRASE command: needs two arguments "
1473 "(network id and passphrase)\n");
1474 return -1;
1475 }
1476
1477 end = cmd + sizeof(cmd);
1478 pos = cmd;
1479 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "PASSPHRASE-%s:%s",
1480 argv[0], argv[1]);
1481 if (os_snprintf_error(end - pos, ret)) {
1482 printf("Too long PASSPHRASE command.\n");
1483 return -1;
1484 }
1485 pos += ret;
1486 for (i = 2; i < argc; i++) {
1487 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
1488 if (os_snprintf_error(end - pos, ret)) {
1489 printf("Too long PASSPHRASE command.\n");
1490 return -1;
1491 }
1492 pos += ret;
1493 }
1494
1495 return wpa_ctrl_command(ctrl, cmd);
1496 }
1497
1498
wpa_cli_cmd_bssid(struct wpa_ctrl * ctrl,int argc,char * argv[])1499 static int wpa_cli_cmd_bssid(struct wpa_ctrl *ctrl, int argc, char *argv[])
1500 {
1501 if (argc < 2) {
1502 printf("Invalid BSSID command: needs two arguments (network "
1503 "id and BSSID)\n");
1504 return -1;
1505 }
1506
1507 return wpa_cli_cmd(ctrl, "BSSID", 2, argc, argv);
1508 }
1509
1510
wpa_cli_cmd_bssid_ignore(struct wpa_ctrl * ctrl,int argc,char * argv[])1511 static int wpa_cli_cmd_bssid_ignore(struct wpa_ctrl *ctrl, int argc,
1512 char *argv[])
1513 {
1514 return wpa_cli_cmd(ctrl, "BSSID_IGNORE", 0, argc, argv);
1515 }
1516
1517
wpa_cli_cmd_log_level(struct wpa_ctrl * ctrl,int argc,char * argv[])1518 static int wpa_cli_cmd_log_level(struct wpa_ctrl *ctrl, int argc, char *argv[])
1519 {
1520 return wpa_cli_cmd(ctrl, "LOG_LEVEL", 0, argc, argv);
1521 }
1522
1523
wpa_cli_cmd_list_networks(struct wpa_ctrl * ctrl,int argc,char * argv[])1524 static int wpa_cli_cmd_list_networks(struct wpa_ctrl *ctrl, int argc,
1525 char *argv[])
1526 {
1527 return wpa_cli_cmd(ctrl, "LIST_NETWORKS", 0, argc, argv);
1528 }
1529
1530
wpa_cli_cmd_select_network(struct wpa_ctrl * ctrl,int argc,char * argv[])1531 static int wpa_cli_cmd_select_network(struct wpa_ctrl *ctrl, int argc,
1532 char *argv[])
1533 {
1534 return wpa_cli_cmd(ctrl, "SELECT_NETWORK", 1, argc, argv);
1535 }
1536
1537
wpa_cli_cmd_enable_network(struct wpa_ctrl * ctrl,int argc,char * argv[])1538 static int wpa_cli_cmd_enable_network(struct wpa_ctrl *ctrl, int argc,
1539 char *argv[])
1540 {
1541 return wpa_cli_cmd(ctrl, "ENABLE_NETWORK", 1, argc, argv);
1542 }
1543
1544
wpa_cli_cmd_disable_network(struct wpa_ctrl * ctrl,int argc,char * argv[])1545 static int wpa_cli_cmd_disable_network(struct wpa_ctrl *ctrl, int argc,
1546 char *argv[])
1547 {
1548 return wpa_cli_cmd(ctrl, "DISABLE_NETWORK", 1, argc, argv);
1549 }
1550
1551
wpa_cli_cmd_add_network(struct wpa_ctrl * ctrl,int argc,char * argv[])1552 static int wpa_cli_cmd_add_network(struct wpa_ctrl *ctrl, int argc,
1553 char *argv[])
1554 {
1555 int res = wpa_ctrl_command(ctrl, "ADD_NETWORK");
1556 if (interactive)
1557 update_networks(ctrl);
1558 return res;
1559 }
1560
1561
wpa_cli_cmd_remove_network(struct wpa_ctrl * ctrl,int argc,char * argv[])1562 static int wpa_cli_cmd_remove_network(struct wpa_ctrl *ctrl, int argc,
1563 char *argv[])
1564 {
1565 int res = wpa_cli_cmd(ctrl, "REMOVE_NETWORK", 1, argc, argv);
1566 if (interactive)
1567 update_networks(ctrl);
1568 return res;
1569 }
1570
1571
wpa_cli_show_network_variables(void)1572 static void wpa_cli_show_network_variables(void)
1573 {
1574 printf("set_network variables:\n"
1575 " ssid (network name, SSID)\n"
1576 " psk (WPA passphrase or pre-shared key)\n"
1577 " key_mgmt (key management protocol)\n"
1578 " identity (EAP identity)\n"
1579 " password (EAP password)\n"
1580 " ...\n"
1581 "\n"
1582 "Note: Values are entered in the same format as the "
1583 "configuration file is using,\n"
1584 "i.e., strings values need to be inside double quotation "
1585 "marks.\n"
1586 "For example: set_network 1 ssid \"network name\"\n"
1587 "\n"
1588 "Please see wpa_supplicant.conf documentation for full list "
1589 "of\navailable variables.\n");
1590 }
1591
1592
wpa_cli_cmd_set_network(struct wpa_ctrl * ctrl,int argc,char * argv[])1593 static int wpa_cli_cmd_set_network(struct wpa_ctrl *ctrl, int argc,
1594 char *argv[])
1595 {
1596 if (argc == 0) {
1597 wpa_cli_show_network_variables();
1598 return 0;
1599 }
1600
1601 if (argc < 3) {
1602 printf("Invalid SET_NETWORK command: needs three arguments\n"
1603 "(network id, variable name, and value)\n");
1604 return -1;
1605 }
1606 if (!disable_anonymized_print()) {
1607 char tempBuf[MAX_TEMP_BUFFER_LEN];
1608 write_cmd(tempBuf, sizeof(tempBuf), "SET_NETWORK", argc, argv);
1609 wpa_printf(MSG_INFO, "wpa_cli_cmd_set_network cmd: %s", os_strstr(tempBuf, "bssid") ?
1610 get_anonymized_result_setnetwork_for_bssid(tempBuf) : get_anonymized_result_setnetwork(tempBuf));
1611 }
1612
1613 return wpa_cli_cmd(ctrl, "SET_NETWORK", 3, argc, argv);
1614 }
1615
1616
wpa_cli_cmd_get_network(struct wpa_ctrl * ctrl,int argc,char * argv[])1617 static int wpa_cli_cmd_get_network(struct wpa_ctrl *ctrl, int argc,
1618 char *argv[])
1619 {
1620 if (argc == 0) {
1621 wpa_cli_show_network_variables();
1622 return 0;
1623 }
1624
1625 if (argc != 2) {
1626 printf("Invalid GET_NETWORK command: needs two arguments\n"
1627 "(network id and variable name)\n");
1628 return -1;
1629 }
1630
1631 return wpa_cli_cmd(ctrl, "GET_NETWORK", 2, argc, argv);
1632 }
1633
1634
1635 static const char *network_fields[] = {
1636 "ssid", "scan_ssid", "bssid", "bssid_ignore",
1637 "bssid_accept", "psk", "proto", "key_mgmt",
1638 "bg_scan_period", "pairwise", "group", "auth_alg", "scan_freq",
1639 "freq_list", "max_oper_chwidth", "ht40", "vht", "vht_center_freq1",
1640 "vht_center_freq2", "ht", "edmg",
1641 #ifdef IEEE8021X_EAPOL
1642 "eap", "identity", "anonymous_identity", "password", "ca_cert",
1643 "ca_path", "client_cert", "private_key", "private_key_passwd",
1644 "dh_file", "subject_match", "altsubject_match",
1645 "check_cert_subject",
1646 "domain_suffix_match", "domain_match", "ca_cert2", "ca_path2",
1647 "client_cert2", "private_key2", "private_key2_passwd",
1648 "dh_file2", "subject_match2", "altsubject_match2",
1649 "check_cert_subject2",
1650 "domain_suffix_match2", "domain_match2", "phase1", "phase2",
1651 "pcsc", "pin", "engine_id", "key_id", "cert_id", "ca_cert_id",
1652 "pin2", "engine2_id", "key2_id", "cert2_id", "ca_cert2_id",
1653 "engine", "engine2", "eapol_flags", "sim_num",
1654 "openssl_ciphers", "erp",
1655 #endif /* IEEE8021X_EAPOL */
1656 "wep_key0", "wep_key1", "wep_key2", "wep_key3",
1657 "wep_tx_keyidx", "priority",
1658 #ifdef IEEE8021X_EAPOL
1659 "eap_workaround", "pac_file", "fragment_size", "ocsp",
1660 #endif /* IEEE8021X_EAPOL */
1661 "mode",
1662 "proactive_key_caching", "disabled", "id_str",
1663 "ieee80211w",
1664 "mixed_cell", "frequency", "fixed_freq",
1665 #ifdef CONFIG_MESH
1666 "no_auto_peer", "mesh_rssi_threshold",
1667 "mesh_basic_rates", "dot11MeshMaxRetries",
1668 "dot11MeshRetryTimeout", "dot11MeshConfirmTimeout",
1669 "dot11MeshHoldingTimeout",
1670 #endif /* CONFIG_MESH */
1671 "wpa_ptk_rekey", "bgscan", "ignore_broadcast_ssid",
1672 "wpa_deny_ptk0_rekey",
1673 "enable_edmg", "edmg_channel",
1674 #ifdef CONFIG_P2P
1675 "go_p2p_dev_addr", "p2p_client_list", "psk_list",
1676 #endif /* CONFIG_P2P */
1677 #ifdef CONFIG_HT_OVERRIDES
1678 "disable_ht", "disable_ht40", "disable_sgi", "disable_ldpc",
1679 "ht40_intolerant", "disable_max_amsdu", "ampdu_factor",
1680 "ampdu_density", "ht_mcs", "rx_stbc", "tx_stbc",
1681 #endif /* CONFIG_HT_OVERRIDES */
1682 #ifdef CONFIG_VHT_OVERRIDES
1683 "disable_vht", "vht_capa", "vht_capa_mask", "vht_rx_mcs_nss_1",
1684 "vht_rx_mcs_nss_2", "vht_rx_mcs_nss_3", "vht_rx_mcs_nss_4",
1685 "vht_rx_mcs_nss_5", "vht_rx_mcs_nss_6", "vht_rx_mcs_nss_7",
1686 "vht_rx_mcs_nss_8", "vht_tx_mcs_nss_1", "vht_tx_mcs_nss_2",
1687 "vht_tx_mcs_nss_3", "vht_tx_mcs_nss_4", "vht_tx_mcs_nss_5",
1688 "vht_tx_mcs_nss_6", "vht_tx_mcs_nss_7", "vht_tx_mcs_nss_8",
1689 #endif /* CONFIG_VHT_OVERRIDES */
1690 #ifdef CONFIG_HE_OVERRIDES
1691 "disable_he",
1692 #endif /* CONFIG_HE_OVERRIDES */
1693 "ap_max_inactivity", "dtim_period", "beacon_int",
1694 #ifdef CONFIG_MACSEC
1695 "macsec_policy",
1696 "macsec_integ_only",
1697 "macsec_replay_protect",
1698 "macsec_replay_window",
1699 "macsec_port",
1700 "mka_priority",
1701 #endif /* CONFIG_MACSEC */
1702 #ifdef CONFIG_HS20
1703 "update_identifier",
1704 #endif /* CONFIG_HS20 */
1705 "mac_addr", "pbss", "wps_disabled"
1706 };
1707
1708
wpa_cli_complete_network(const char * str,int pos)1709 static char ** wpa_cli_complete_network(const char *str, int pos)
1710 {
1711 int arg = get_cmd_arg_num(str, pos);
1712 int i, num_fields = ARRAY_SIZE(network_fields);
1713 char **res = NULL;
1714
1715 switch (arg) {
1716 case 1:
1717 res = cli_txt_list_array(&networks);
1718 break;
1719 case 2:
1720 res = os_calloc(num_fields + 1, sizeof(char *));
1721 if (res == NULL)
1722 return NULL;
1723 for (i = 0; i < num_fields; i++) {
1724 res[i] = os_strdup(network_fields[i]);
1725 if (res[i] == NULL)
1726 break;
1727 }
1728 }
1729 return res;
1730 }
1731
1732
wpa_cli_complete_network_id(const char * str,int pos)1733 static char ** wpa_cli_complete_network_id(const char *str, int pos)
1734 {
1735 int arg = get_cmd_arg_num(str, pos);
1736 if (arg == 1)
1737 return cli_txt_list_array(&networks);
1738 return NULL;
1739 }
1740
1741
wpa_cli_cmd_dup_network(struct wpa_ctrl * ctrl,int argc,char * argv[])1742 static int wpa_cli_cmd_dup_network(struct wpa_ctrl *ctrl, int argc,
1743 char *argv[])
1744 {
1745 if (argc == 0) {
1746 wpa_cli_show_network_variables();
1747 return 0;
1748 }
1749
1750 if (argc < 3) {
1751 printf("Invalid DUP_NETWORK command: needs three arguments\n"
1752 "(src netid, dest netid, and variable name)\n");
1753 return -1;
1754 }
1755
1756 return wpa_cli_cmd(ctrl, "DUP_NETWORK", 3, argc, argv);
1757 }
1758
1759
wpa_cli_complete_dup_network(const char * str,int pos)1760 static char ** wpa_cli_complete_dup_network(const char *str, int pos)
1761 {
1762 int arg = get_cmd_arg_num(str, pos);
1763 int i, num_fields = ARRAY_SIZE(network_fields);
1764 char **res = NULL;
1765
1766 switch (arg) {
1767 case 1:
1768 case 2:
1769 res = cli_txt_list_array(&networks);
1770 break;
1771 case 3:
1772 res = os_calloc(num_fields + 1, sizeof(char *));
1773 if (res == NULL)
1774 return NULL;
1775 for (i = 0; i < num_fields; i++) {
1776 res[i] = os_strdup(network_fields[i]);
1777 if (res[i] == NULL)
1778 break;
1779 }
1780 }
1781 return res;
1782 }
1783
1784
wpa_cli_cmd_list_creds(struct wpa_ctrl * ctrl,int argc,char * argv[])1785 static int wpa_cli_cmd_list_creds(struct wpa_ctrl *ctrl, int argc,
1786 char *argv[])
1787 {
1788 return wpa_ctrl_command(ctrl, "LIST_CREDS");
1789 }
1790
1791
wpa_cli_cmd_add_cred(struct wpa_ctrl * ctrl,int argc,char * argv[])1792 static int wpa_cli_cmd_add_cred(struct wpa_ctrl *ctrl, int argc, char *argv[])
1793 {
1794 int res = wpa_ctrl_command(ctrl, "ADD_CRED");
1795 if (interactive)
1796 update_creds(ctrl);
1797 return res;
1798 }
1799
1800
wpa_cli_cmd_remove_cred(struct wpa_ctrl * ctrl,int argc,char * argv[])1801 static int wpa_cli_cmd_remove_cred(struct wpa_ctrl *ctrl, int argc,
1802 char *argv[])
1803 {
1804 int res = wpa_cli_cmd(ctrl, "REMOVE_CRED", 1, argc, argv);
1805 if (interactive)
1806 update_creds(ctrl);
1807 return res;
1808 }
1809
1810
1811 static const char * const cred_fields[] = {
1812 "temporary", "priority", "sp_priority", "pcsc", "eap",
1813 "update_identifier", "min_dl_bandwidth_home", "min_ul_bandwidth_home",
1814 "min_dl_bandwidth_roaming", "min_ul_bandwidth_roaming", "max_bss_load",
1815 "req_conn_capab", "ocsp", "sim_num", "realm", "username", "password",
1816 "ca_cert", "client_cert", "private_key", "private_key_passwd", "imsi",
1817 "ca_cert_id", "cert_id", "key_id", "engine_id", "engine",
1818 "milenage", "domain_suffix_match", "domain", "phase1", "phase2",
1819 "roaming_consortium", "required_roaming_consortium", "excluded_ssid",
1820 "roaming_partner", "provisioning_sp"
1821 };
1822
1823
wpa_cli_complete_cred(const char * str,int pos)1824 static char ** wpa_cli_complete_cred(const char *str, int pos)
1825 {
1826 int arg = get_cmd_arg_num(str, pos);
1827 int i, num_fields = ARRAY_SIZE(cred_fields);
1828 char **res = NULL;
1829
1830 switch (arg) {
1831 case 1:
1832 res = cli_txt_list_array(&creds);
1833 break;
1834 case 2:
1835 res = os_calloc(num_fields + 1, sizeof(char *));
1836 if (res == NULL)
1837 return NULL;
1838 for (i = 0; i < num_fields; i++) {
1839 res[i] = os_strdup(cred_fields[i]);
1840 if (res[i] == NULL)
1841 break;
1842 }
1843 }
1844 return res;
1845 }
1846
1847
wpa_cli_cmd_set_cred(struct wpa_ctrl * ctrl,int argc,char * argv[])1848 static int wpa_cli_cmd_set_cred(struct wpa_ctrl *ctrl, int argc, char *argv[])
1849 {
1850 if (argc != 3) {
1851 printf("Invalid SET_CRED command: needs three arguments\n"
1852 "(cred id, variable name, and value)\n");
1853 return -1;
1854 }
1855
1856 return wpa_cli_cmd(ctrl, "SET_CRED", 3, argc, argv);
1857 }
1858
1859
wpa_cli_cmd_get_cred(struct wpa_ctrl * ctrl,int argc,char * argv[])1860 static int wpa_cli_cmd_get_cred(struct wpa_ctrl *ctrl, int argc, char *argv[])
1861 {
1862 if (argc != 2) {
1863 printf("Invalid GET_CRED command: needs two arguments\n"
1864 "(cred id, variable name)\n");
1865 return -1;
1866 }
1867
1868 return wpa_cli_cmd(ctrl, "GET_CRED", 2, argc, argv);
1869 }
1870
1871
wpa_cli_cmd_disconnect(struct wpa_ctrl * ctrl,int argc,char * argv[])1872 static int wpa_cli_cmd_disconnect(struct wpa_ctrl *ctrl, int argc,
1873 char *argv[])
1874 {
1875 return wpa_ctrl_command(ctrl, "DISCONNECT");
1876 }
1877
1878
wpa_cli_cmd_reconnect(struct wpa_ctrl * ctrl,int argc,char * argv[])1879 static int wpa_cli_cmd_reconnect(struct wpa_ctrl *ctrl, int argc,
1880 char *argv[])
1881 {
1882 return wpa_ctrl_command(ctrl, "RECONNECT");
1883 }
1884
1885
wpa_cli_cmd_save_config(struct wpa_ctrl * ctrl,int argc,char * argv[])1886 static int wpa_cli_cmd_save_config(struct wpa_ctrl *ctrl, int argc,
1887 char *argv[])
1888 {
1889 return wpa_ctrl_command(ctrl, "SAVE_CONFIG");
1890 }
1891
1892
wpa_cli_cmd_scan(struct wpa_ctrl * ctrl,int argc,char * argv[])1893 static int wpa_cli_cmd_scan(struct wpa_ctrl *ctrl, int argc, char *argv[])
1894 {
1895 return wpa_cli_cmd(ctrl, "SCAN", 0, argc, argv);
1896 }
1897
1898
wpa_cli_cmd_scan_results(struct wpa_ctrl * ctrl,int argc,char * argv[])1899 static int wpa_cli_cmd_scan_results(struct wpa_ctrl *ctrl, int argc,
1900 char *argv[])
1901 {
1902 return wpa_ctrl_command(ctrl, "SCAN_RESULTS");
1903 }
1904
1905 #if defined(CONFIG_OPEN_HARMONY_PATCH) && defined(CONFIG_HILINK_OKC_STA)
wpa_cli_cmd_enable_hilink(struct wpa_ctrl * ctrl,int argc,char * argv[])1906 static int wpa_cli_cmd_enable_hilink(struct wpa_ctrl *ctrl, int argc, char *argv[])
1907 {
1908 return wpa_cli_cmd(ctrl, "ENABLE_HILINK", 2, argc, argv);
1909 }
1910 #endif
1911
wpa_cli_cmd_abort_scan(struct wpa_ctrl * ctrl,int argc,char * argv[])1912 static int wpa_cli_cmd_abort_scan(struct wpa_ctrl *ctrl, int argc,
1913 char *argv[])
1914 {
1915 return wpa_ctrl_command(ctrl, "ABORT_SCAN");
1916 }
1917
1918
wpa_cli_cmd_bss(struct wpa_ctrl * ctrl,int argc,char * argv[])1919 static int wpa_cli_cmd_bss(struct wpa_ctrl *ctrl, int argc, char *argv[])
1920 {
1921 return wpa_cli_cmd(ctrl, "BSS", 1, argc, argv);
1922 }
1923
1924
wpa_cli_complete_bss(const char * str,int pos)1925 static char ** wpa_cli_complete_bss(const char *str, int pos)
1926 {
1927 int arg = get_cmd_arg_num(str, pos);
1928 char **res = NULL;
1929
1930 switch (arg) {
1931 case 1:
1932 res = cli_txt_list_array(&bsses);
1933 break;
1934 }
1935
1936 return res;
1937 }
1938
1939
wpa_cli_cmd_get_capability(struct wpa_ctrl * ctrl,int argc,char * argv[])1940 static int wpa_cli_cmd_get_capability(struct wpa_ctrl *ctrl, int argc,
1941 char *argv[])
1942 {
1943 if (argc < 1 || argc > 3) {
1944 printf("Invalid GET_CAPABILITY command: need at least one argument and max three arguments\n");
1945 return -1;
1946 }
1947
1948 if (argc > 1 && os_strcmp(argv[0], "key_mgmt") != 0 &&
1949 os_strncmp(argv[1], "iftype=", 7) == 0) {
1950 printf("Invalid GET_CAPABILITY command: 'iftype=' param is allowed only for 'key_mgmt'\n");
1951 return -1;
1952 }
1953
1954 if (argc == 2 && os_strcmp(argv[1], "strict") != 0 &&
1955 os_strncmp(argv[1], "iftype=", 7) != 0) {
1956 printf("Invalid GET_CAPABILITY command: the second argument, if any, must be 'strict' OR 'iftype=<iftype_name>'\n");
1957 return -1;
1958 }
1959
1960 if (argc == 3 && os_strcmp(argv[2], "strict") != 0) {
1961 printf("Invalid GET_CAPABILITY command: the third argument, if any, must be 'strict'\n");
1962 return -1;
1963 }
1964
1965 return wpa_cli_cmd(ctrl, "GET_CAPABILITY", 1, argc, argv);
1966 }
1967
1968
wpa_cli_complete_get_capability(const char * str,int pos)1969 static char ** wpa_cli_complete_get_capability(const char *str, int pos)
1970 {
1971 int arg = get_cmd_arg_num(str, pos);
1972 const char *fields[] = {
1973 "eap", "pairwise", "group", "group_mgmt", "key_mgmt",
1974 "proto", "auth_alg", "modes", "channels", "freq",
1975 #ifdef CONFIG_TDLS
1976 "tdls",
1977 #endif /* CONFIG_TDLS */
1978 #ifdef CONFIG_ERP
1979 "erp",
1980 #endif /* CONFIG_ERP */
1981 #ifdef CONFIG_FIPS
1982 "fips",
1983 #endif /* CONFIG_FIPS */
1984 #ifdef CONFIG_ACS
1985 "acs",
1986 #endif /* CONFIG_ACS */
1987 };
1988 const char *iftypes[] = {
1989 "iftype=STATION", "iftype=AP", "iftype=P2P_CLIENT",
1990 "iftype=P2P_GO", "iftype=AP_VLAN", "iftype=IBSS", "iftype=NAN",
1991 "iftype=P2P_DEVICE", "iftype=MESH",
1992 };
1993 int i, num_fields = ARRAY_SIZE(fields);
1994 int num_iftypes = ARRAY_SIZE(iftypes);
1995 char **res = NULL;
1996
1997 if (arg == 1) {
1998 res = os_calloc(num_fields + 1, sizeof(char *));
1999 if (res == NULL)
2000 return NULL;
2001 for (i = 0; i < num_fields; i++) {
2002 res[i] = os_strdup(fields[i]);
2003 if (res[i] == NULL)
2004 return res;
2005 }
2006 }
2007 if (arg == 2) {
2008 /* the second argument can be "iftype=<iftype_name>" OR
2009 * "strict" */
2010 res = os_calloc(num_iftypes + 2, sizeof(char *));
2011 if (!res)
2012 return NULL;
2013 res[0] = os_strdup("strict");
2014 if (!res[0])
2015 return res;
2016 for (i = 0; i < num_iftypes; i++) {
2017 res[i + 1] = os_strdup(iftypes[i]);
2018 if (!res[i + 1])
2019 return res;
2020 }
2021 }
2022 if (arg == 3) {
2023 res = os_calloc(1 + 1, sizeof(char *));
2024 if (res == NULL)
2025 return NULL;
2026 res[0] = os_strdup("strict");
2027 }
2028 return res;
2029 }
2030
2031
wpa_cli_list_interfaces(struct wpa_ctrl * ctrl)2032 static int wpa_cli_list_interfaces(struct wpa_ctrl *ctrl)
2033 {
2034 printf("Available interfaces:\n");
2035 return wpa_ctrl_command(ctrl, "INTERFACES");
2036 }
2037
2038
wpa_cli_cmd_interface(struct wpa_ctrl * ctrl,int argc,char * argv[])2039 static int wpa_cli_cmd_interface(struct wpa_ctrl *ctrl, int argc, char *argv[])
2040 {
2041 if (argc < 1) {
2042 wpa_cli_list_interfaces(ctrl);
2043 return 0;
2044 }
2045
2046 wpa_cli_close_connection();
2047 os_free(ctrl_ifname);
2048 ctrl_ifname = os_strdup(argv[0]);
2049 if (!ctrl_ifname) {
2050 printf("Failed to allocate memory\n");
2051 return 0;
2052 }
2053
2054 if (wpa_cli_open_connection(ctrl_ifname, 1) == 0) {
2055 printf("Connected to interface '%s'.\n", ctrl_ifname);
2056 } else {
2057 printf("Could not connect to interface '%s' - re-trying\n",
2058 ctrl_ifname);
2059 }
2060 return 0;
2061 }
2062
2063
wpa_cli_cmd_reconfigure(struct wpa_ctrl * ctrl,int argc,char * argv[])2064 static int wpa_cli_cmd_reconfigure(struct wpa_ctrl *ctrl, int argc,
2065 char *argv[])
2066 {
2067 return wpa_ctrl_command(ctrl, "RECONFIGURE");
2068 }
2069
2070
wpa_cli_cmd_terminate(struct wpa_ctrl * ctrl,int argc,char * argv[])2071 static int wpa_cli_cmd_terminate(struct wpa_ctrl *ctrl, int argc,
2072 char *argv[])
2073 {
2074 return wpa_ctrl_command(ctrl, "TERMINATE");
2075 }
2076
2077
wpa_cli_cmd_interface_add(struct wpa_ctrl * ctrl,int argc,char * argv[])2078 static int wpa_cli_cmd_interface_add(struct wpa_ctrl *ctrl, int argc,
2079 char *argv[])
2080 {
2081 char cmd[256];
2082 int res;
2083
2084 if (argc < 1) {
2085 printf("Invalid INTERFACE_ADD command: needs at least one "
2086 "argument (interface name)\n"
2087 "All arguments: ifname confname driver ctrl_interface "
2088 "driver_param bridge_name [create]\n");
2089 return -1;
2090 }
2091
2092 /*
2093 * INTERFACE_ADD <ifname>TAB<confname>TAB<driver>TAB<ctrl_interface>TAB
2094 * <driver_param>TAB<bridge_name>[TAB<create>[TAB<type>]]
2095 */
2096 res = os_snprintf(cmd, sizeof(cmd),
2097 "INTERFACE_ADD %s\t%s\t%s\t%s\t%s\t%s\t%s\t%s",
2098 argv[0],
2099 argc > 1 ? argv[1] : "", argc > 2 ? argv[2] : "",
2100 argc > 3 ? argv[3] : "", argc > 4 ? argv[4] : "",
2101 argc > 5 ? argv[5] : "", argc > 6 ? argv[6] : "",
2102 argc > 7 ? argv[7] : "");
2103 if (os_snprintf_error(sizeof(cmd), res))
2104 return -1;
2105 cmd[sizeof(cmd) - 1] = '\0';
2106 return wpa_ctrl_command(ctrl, cmd);
2107 }
2108
2109
wpa_cli_cmd_interface_remove(struct wpa_ctrl * ctrl,int argc,char * argv[])2110 static int wpa_cli_cmd_interface_remove(struct wpa_ctrl *ctrl, int argc,
2111 char *argv[])
2112 {
2113 return wpa_cli_cmd(ctrl, "INTERFACE_REMOVE", 1, argc, argv);
2114 }
2115
2116
wpa_cli_cmd_interface_list(struct wpa_ctrl * ctrl,int argc,char * argv[])2117 static int wpa_cli_cmd_interface_list(struct wpa_ctrl *ctrl, int argc,
2118 char *argv[])
2119 {
2120 return wpa_ctrl_command(ctrl, "INTERFACE_LIST");
2121 }
2122
2123
2124 #ifdef CONFIG_AP
wpa_cli_cmd_sta(struct wpa_ctrl * ctrl,int argc,char * argv[])2125 static int wpa_cli_cmd_sta(struct wpa_ctrl *ctrl, int argc, char *argv[])
2126 {
2127 return wpa_cli_cmd(ctrl, "STA", 1, argc, argv);
2128 }
2129
2130
wpa_cli_complete_sta(const char * str,int pos)2131 static char ** wpa_cli_complete_sta(const char *str, int pos)
2132 {
2133 int arg = get_cmd_arg_num(str, pos);
2134 char **res = NULL;
2135
2136 switch (arg) {
2137 case 1:
2138 res = cli_txt_list_array(&stations);
2139 break;
2140 }
2141
2142 return res;
2143 }
2144
2145
wpa_ctrl_command_sta(struct wpa_ctrl * ctrl,const char * cmd,char * addr,size_t addr_len,int print)2146 static int wpa_ctrl_command_sta(struct wpa_ctrl *ctrl, const char *cmd,
2147 char *addr, size_t addr_len, int print)
2148 {
2149 char buf[4096], *pos;
2150 size_t len;
2151 int ret;
2152
2153 if (ctrl_conn == NULL) {
2154 printf("Not connected to hostapd - command dropped.\n");
2155 return -1;
2156 }
2157 if (ifname_prefix) {
2158 os_snprintf(buf, sizeof(buf), "IFNAME=%s %s",
2159 ifname_prefix, cmd);
2160 buf[sizeof(buf) - 1] = '\0';
2161 cmd = buf;
2162 }
2163 len = sizeof(buf) - 1;
2164 ret = wpa_ctrl_request(ctrl, cmd, os_strlen(cmd), buf, &len,
2165 wpa_cli_msg_cb);
2166 if (ret == -2) {
2167 printf("'%s' command timed out.\n", cmd);
2168 return -2;
2169 } else if (ret < 0) {
2170 printf("'%s' command failed.\n", cmd);
2171 return -1;
2172 }
2173
2174 buf[len] = '\0';
2175 if (os_memcmp(buf, "FAIL", 4) == 0 ||
2176 os_memcmp(buf, "UNKNOWN COMMAND", 15) == 0)
2177 return -1;
2178 if (print)
2179 printf("%s", buf);
2180
2181 pos = buf;
2182 while (*pos != '\0' && *pos != '\n')
2183 pos++;
2184 *pos = '\0';
2185 os_strlcpy(addr, buf, addr_len);
2186 return 0;
2187 }
2188
2189
wpa_cli_cmd_all_sta(struct wpa_ctrl * ctrl,int argc,char * argv[])2190 static int wpa_cli_cmd_all_sta(struct wpa_ctrl *ctrl, int argc, char *argv[])
2191 {
2192 char addr[32], cmd[64];
2193
2194 if (wpa_ctrl_command_sta(ctrl, "STA-FIRST", addr, sizeof(addr), 1))
2195 return 0;
2196 do {
2197 os_snprintf(cmd, sizeof(cmd), "STA-NEXT %s", addr);
2198 } while (wpa_ctrl_command_sta(ctrl, cmd, addr, sizeof(addr), 1) == 0);
2199
2200 return -1;
2201 }
2202
2203
wpa_cli_cmd_list_sta(struct wpa_ctrl * ctrl,int argc,char * argv[])2204 static int wpa_cli_cmd_list_sta(struct wpa_ctrl *ctrl, int argc,
2205 char *argv[])
2206 {
2207 char addr[32], cmd[64];
2208
2209 if (wpa_ctrl_command_sta(ctrl, "STA-FIRST", addr, sizeof(addr), 0))
2210 return 0;
2211 do {
2212 if (os_strcmp(addr, "") != 0)
2213 printf("%s\n", addr);
2214 os_snprintf(cmd, sizeof(cmd), "STA-NEXT %s", addr);
2215 } while (wpa_ctrl_command_sta(ctrl, cmd, addr, sizeof(addr), 0) == 0);
2216
2217 return 0;
2218 }
2219
2220
wpa_cli_cmd_deauthenticate(struct wpa_ctrl * ctrl,int argc,char * argv[])2221 static int wpa_cli_cmd_deauthenticate(struct wpa_ctrl *ctrl, int argc,
2222 char *argv[])
2223 {
2224 return wpa_cli_cmd(ctrl, "DEAUTHENTICATE", 1, argc, argv);
2225 }
2226
2227
wpa_cli_complete_deauthenticate(const char * str,int pos)2228 static char ** wpa_cli_complete_deauthenticate(const char *str, int pos)
2229 {
2230 int arg = get_cmd_arg_num(str, pos);
2231 char **res = NULL;
2232
2233 switch (arg) {
2234 case 1:
2235 res = cli_txt_list_array(&stations);
2236 break;
2237 }
2238
2239 return res;
2240 }
2241
2242
wpa_cli_cmd_disassociate(struct wpa_ctrl * ctrl,int argc,char * argv[])2243 static int wpa_cli_cmd_disassociate(struct wpa_ctrl *ctrl, int argc,
2244 char *argv[])
2245 {
2246 return wpa_cli_cmd(ctrl, "DISASSOCIATE", 1, argc, argv);
2247 }
2248
2249
wpa_cli_complete_disassociate(const char * str,int pos)2250 static char ** wpa_cli_complete_disassociate(const char *str, int pos)
2251 {
2252 int arg = get_cmd_arg_num(str, pos);
2253 char **res = NULL;
2254
2255 switch (arg) {
2256 case 1:
2257 res = cli_txt_list_array(&stations);
2258 break;
2259 }
2260
2261 return res;
2262 }
2263
2264
wpa_cli_cmd_chanswitch(struct wpa_ctrl * ctrl,int argc,char * argv[])2265 static int wpa_cli_cmd_chanswitch(struct wpa_ctrl *ctrl, int argc,
2266 char *argv[])
2267 {
2268 return wpa_cli_cmd(ctrl, "CHAN_SWITCH", 2, argc, argv);
2269 }
2270
2271
wpa_cli_cmd_update_beacon(struct wpa_ctrl * ctrl,int argc,char * argv[])2272 static int wpa_cli_cmd_update_beacon(struct wpa_ctrl *ctrl, int argc,
2273 char *argv[])
2274 {
2275 return wpa_ctrl_command(ctrl, "UPDATE_BEACON");
2276 }
2277
2278 #endif /* CONFIG_AP */
2279
2280
wpa_cli_cmd_suspend(struct wpa_ctrl * ctrl,int argc,char * argv[])2281 static int wpa_cli_cmd_suspend(struct wpa_ctrl *ctrl, int argc, char *argv[])
2282 {
2283 return wpa_ctrl_command(ctrl, "SUSPEND");
2284 }
2285
2286
wpa_cli_cmd_resume(struct wpa_ctrl * ctrl,int argc,char * argv[])2287 static int wpa_cli_cmd_resume(struct wpa_ctrl *ctrl, int argc, char *argv[])
2288 {
2289 return wpa_ctrl_command(ctrl, "RESUME");
2290 }
2291
2292
2293 #ifdef CONFIG_TESTING_OPTIONS
wpa_cli_cmd_drop_sa(struct wpa_ctrl * ctrl,int argc,char * argv[])2294 static int wpa_cli_cmd_drop_sa(struct wpa_ctrl *ctrl, int argc, char *argv[])
2295 {
2296 return wpa_ctrl_command(ctrl, "DROP_SA");
2297 }
2298 #endif /* CONFIG_TESTING_OPTIONS */
2299
2300
wpa_cli_cmd_roam(struct wpa_ctrl * ctrl,int argc,char * argv[])2301 static int wpa_cli_cmd_roam(struct wpa_ctrl *ctrl, int argc, char *argv[])
2302 {
2303 return wpa_cli_cmd(ctrl, "ROAM", 1, argc, argv);
2304 }
2305
2306
2307 #ifdef CONFIG_MESH
2308
wpa_cli_cmd_mesh_interface_add(struct wpa_ctrl * ctrl,int argc,char * argv[])2309 static int wpa_cli_cmd_mesh_interface_add(struct wpa_ctrl *ctrl, int argc,
2310 char *argv[])
2311 {
2312 return wpa_cli_cmd(ctrl, "MESH_INTERFACE_ADD", 0, argc, argv);
2313 }
2314
2315
wpa_cli_cmd_mesh_group_add(struct wpa_ctrl * ctrl,int argc,char * argv[])2316 static int wpa_cli_cmd_mesh_group_add(struct wpa_ctrl *ctrl, int argc,
2317 char *argv[])
2318 {
2319 return wpa_cli_cmd(ctrl, "MESH_GROUP_ADD", 1, argc, argv);
2320 }
2321
2322
wpa_cli_cmd_mesh_group_remove(struct wpa_ctrl * ctrl,int argc,char * argv[])2323 static int wpa_cli_cmd_mesh_group_remove(struct wpa_ctrl *ctrl, int argc,
2324 char *argv[])
2325 {
2326 return wpa_cli_cmd(ctrl, "MESH_GROUP_REMOVE", 1, argc, argv);
2327 }
2328
2329
wpa_cli_cmd_mesh_peer_remove(struct wpa_ctrl * ctrl,int argc,char * argv[])2330 static int wpa_cli_cmd_mesh_peer_remove(struct wpa_ctrl *ctrl, int argc,
2331 char *argv[])
2332 {
2333 return wpa_cli_cmd(ctrl, "MESH_PEER_REMOVE", 1, argc, argv);
2334 }
2335
2336
wpa_cli_cmd_mesh_peer_add(struct wpa_ctrl * ctrl,int argc,char * argv[])2337 static int wpa_cli_cmd_mesh_peer_add(struct wpa_ctrl *ctrl, int argc,
2338 char *argv[])
2339 {
2340 return wpa_cli_cmd(ctrl, "MESH_PEER_ADD", 1, argc, argv);
2341 }
2342
2343
wpa_cli_cmd_mesh_link_probe(struct wpa_ctrl * ctrl,int argc,char * argv[])2344 static int wpa_cli_cmd_mesh_link_probe(struct wpa_ctrl *ctrl, int argc,
2345 char *argv[])
2346 {
2347 return wpa_cli_cmd(ctrl, "MESH_LINK_PROBE", 1, argc, argv);
2348 }
2349
2350 #endif /* CONFIG_MESH */
2351
2352
2353 #ifdef CONFIG_P2P
2354
wpa_cli_cmd_p2p_find(struct wpa_ctrl * ctrl,int argc,char * argv[])2355 static int wpa_cli_cmd_p2p_find(struct wpa_ctrl *ctrl, int argc, char *argv[])
2356 {
2357 return wpa_cli_cmd(ctrl, "P2P_FIND", 0, argc, argv);
2358 }
2359
2360
wpa_cli_complete_p2p_find(const char * str,int pos)2361 static char ** wpa_cli_complete_p2p_find(const char *str, int pos)
2362 {
2363 char **res = NULL;
2364 int arg = get_cmd_arg_num(str, pos);
2365
2366 res = os_calloc(6, sizeof(char *));
2367 if (res == NULL)
2368 return NULL;
2369 res[0] = os_strdup("type=social");
2370 if (res[0] == NULL) {
2371 os_free(res);
2372 return NULL;
2373 }
2374 res[1] = os_strdup("type=progressive");
2375 if (res[1] == NULL)
2376 return res;
2377 res[2] = os_strdup("delay=");
2378 if (res[2] == NULL)
2379 return res;
2380 res[3] = os_strdup("dev_id=");
2381 if (res[3] == NULL)
2382 return res;
2383 if (arg == 1)
2384 res[4] = os_strdup("[timeout]");
2385
2386 return res;
2387 }
2388
2389
wpa_cli_cmd_p2p_stop_find(struct wpa_ctrl * ctrl,int argc,char * argv[])2390 static int wpa_cli_cmd_p2p_stop_find(struct wpa_ctrl *ctrl, int argc,
2391 char *argv[])
2392 {
2393 return wpa_ctrl_command(ctrl, "P2P_STOP_FIND");
2394 }
2395
2396
wpa_cli_cmd_p2p_asp_provision(struct wpa_ctrl * ctrl,int argc,char * argv[])2397 static int wpa_cli_cmd_p2p_asp_provision(struct wpa_ctrl *ctrl, int argc,
2398 char *argv[])
2399 {
2400 return wpa_cli_cmd(ctrl, "P2P_ASP_PROVISION", 3, argc, argv);
2401 }
2402
2403
wpa_cli_cmd_p2p_asp_provision_resp(struct wpa_ctrl * ctrl,int argc,char * argv[])2404 static int wpa_cli_cmd_p2p_asp_provision_resp(struct wpa_ctrl *ctrl, int argc,
2405 char *argv[])
2406 {
2407 return wpa_cli_cmd(ctrl, "P2P_ASP_PROVISION_RESP", 2, argc, argv);
2408 }
2409
2410
wpa_cli_cmd_p2p_connect(struct wpa_ctrl * ctrl,int argc,char * argv[])2411 static int wpa_cli_cmd_p2p_connect(struct wpa_ctrl *ctrl, int argc,
2412 char *argv[])
2413 {
2414 return wpa_cli_cmd(ctrl, "P2P_CONNECT", 2, argc, argv);
2415 }
2416
2417
wpa_cli_complete_p2p_connect(const char * str,int pos)2418 static char ** wpa_cli_complete_p2p_connect(const char *str, int pos)
2419 {
2420 int arg = get_cmd_arg_num(str, pos);
2421 char **res = NULL;
2422
2423 switch (arg) {
2424 case 1:
2425 res = cli_txt_list_array(&p2p_peers);
2426 break;
2427 }
2428
2429 return res;
2430 }
2431
2432
wpa_cli_cmd_p2p_listen(struct wpa_ctrl * ctrl,int argc,char * argv[])2433 static int wpa_cli_cmd_p2p_listen(struct wpa_ctrl *ctrl, int argc,
2434 char *argv[])
2435 {
2436 return wpa_cli_cmd(ctrl, "P2P_LISTEN", 0, argc, argv);
2437 }
2438
2439
wpa_cli_cmd_p2p_group_remove(struct wpa_ctrl * ctrl,int argc,char * argv[])2440 static int wpa_cli_cmd_p2p_group_remove(struct wpa_ctrl *ctrl, int argc,
2441 char *argv[])
2442 {
2443 return wpa_cli_cmd(ctrl, "P2P_GROUP_REMOVE", 1, argc, argv);
2444 }
2445
2446
wpa_cli_complete_p2p_group_remove(const char * str,int pos)2447 static char ** wpa_cli_complete_p2p_group_remove(const char *str, int pos)
2448 {
2449 int arg = get_cmd_arg_num(str, pos);
2450 char **res = NULL;
2451
2452 switch (arg) {
2453 case 1:
2454 res = cli_txt_list_array(&p2p_groups);
2455 break;
2456 }
2457
2458 return res;
2459 }
2460
2461
wpa_cli_cmd_p2p_group_add(struct wpa_ctrl * ctrl,int argc,char * argv[])2462 static int wpa_cli_cmd_p2p_group_add(struct wpa_ctrl *ctrl, int argc,
2463 char *argv[])
2464 {
2465 return wpa_cli_cmd(ctrl, "P2P_GROUP_ADD", 0, argc, argv);
2466 }
2467
2468
wpa_cli_cmd_p2p_group_member(struct wpa_ctrl * ctrl,int argc,char * argv[])2469 static int wpa_cli_cmd_p2p_group_member(struct wpa_ctrl *ctrl, int argc,
2470 char *argv[])
2471 {
2472 return wpa_cli_cmd(ctrl, "P2P_GROUP_MEMBER", 1, argc, argv);
2473 }
2474
2475
wpa_cli_cmd_p2p_prov_disc(struct wpa_ctrl * ctrl,int argc,char * argv[])2476 static int wpa_cli_cmd_p2p_prov_disc(struct wpa_ctrl *ctrl, int argc,
2477 char *argv[])
2478 {
2479 if (argc != 2 && argc != 3) {
2480 printf("Invalid P2P_PROV_DISC command: needs at least "
2481 "two arguments, address and config method\n"
2482 "(display, keypad, or pbc) and an optional join\n");
2483 return -1;
2484 }
2485
2486 return wpa_cli_cmd(ctrl, "P2P_PROV_DISC", 2, argc, argv);
2487 }
2488
2489
wpa_cli_cmd_p2p_get_passphrase(struct wpa_ctrl * ctrl,int argc,char * argv[])2490 static int wpa_cli_cmd_p2p_get_passphrase(struct wpa_ctrl *ctrl, int argc,
2491 char *argv[])
2492 {
2493 return wpa_ctrl_command(ctrl, "P2P_GET_PASSPHRASE");
2494 }
2495
2496
wpa_cli_cmd_p2p_serv_disc_req(struct wpa_ctrl * ctrl,int argc,char * argv[])2497 static int wpa_cli_cmd_p2p_serv_disc_req(struct wpa_ctrl *ctrl, int argc,
2498 char *argv[])
2499 {
2500 char cmd[4096];
2501
2502 if (argc < 2) {
2503 printf("Invalid P2P_SERV_DISC_REQ command: needs two "
2504 "or more arguments (address and TLVs)\n");
2505 return -1;
2506 }
2507
2508 if (write_cmd(cmd, sizeof(cmd), "P2P_SERV_DISC_REQ", argc, argv) < 0)
2509 return -1;
2510 return wpa_ctrl_command(ctrl, cmd);
2511 }
2512
2513
wpa_cli_cmd_p2p_serv_disc_cancel_req(struct wpa_ctrl * ctrl,int argc,char * argv[])2514 static int wpa_cli_cmd_p2p_serv_disc_cancel_req(struct wpa_ctrl *ctrl,
2515 int argc, char *argv[])
2516 {
2517 return wpa_cli_cmd(ctrl, "P2P_SERV_DISC_CANCEL_REQ", 1, argc, argv);
2518 }
2519
2520
wpa_cli_cmd_p2p_serv_disc_resp(struct wpa_ctrl * ctrl,int argc,char * argv[])2521 static int wpa_cli_cmd_p2p_serv_disc_resp(struct wpa_ctrl *ctrl, int argc,
2522 char *argv[])
2523 {
2524 char cmd[4096];
2525 int res;
2526
2527 if (argc != 4) {
2528 printf("Invalid P2P_SERV_DISC_RESP command: needs four "
2529 "arguments (freq, address, dialog token, and TLVs)\n");
2530 return -1;
2531 }
2532
2533 res = os_snprintf(cmd, sizeof(cmd), "P2P_SERV_DISC_RESP %s %s %s %s",
2534 argv[0], argv[1], argv[2], argv[3]);
2535 if (os_snprintf_error(sizeof(cmd), res))
2536 return -1;
2537 cmd[sizeof(cmd) - 1] = '\0';
2538 return wpa_ctrl_command(ctrl, cmd);
2539 }
2540
2541
wpa_cli_cmd_p2p_service_update(struct wpa_ctrl * ctrl,int argc,char * argv[])2542 static int wpa_cli_cmd_p2p_service_update(struct wpa_ctrl *ctrl, int argc,
2543 char *argv[])
2544 {
2545 return wpa_ctrl_command(ctrl, "P2P_SERVICE_UPDATE");
2546 }
2547
2548
wpa_cli_cmd_p2p_serv_disc_external(struct wpa_ctrl * ctrl,int argc,char * argv[])2549 static int wpa_cli_cmd_p2p_serv_disc_external(struct wpa_ctrl *ctrl,
2550 int argc, char *argv[])
2551 {
2552 return wpa_cli_cmd(ctrl, "P2P_SERV_DISC_EXTERNAL", 1, argc, argv);
2553 }
2554
2555
wpa_cli_cmd_p2p_service_flush(struct wpa_ctrl * ctrl,int argc,char * argv[])2556 static int wpa_cli_cmd_p2p_service_flush(struct wpa_ctrl *ctrl, int argc,
2557 char *argv[])
2558 {
2559 return wpa_ctrl_command(ctrl, "P2P_SERVICE_FLUSH");
2560 }
2561
2562
wpa_cli_cmd_p2p_service_add(struct wpa_ctrl * ctrl,int argc,char * argv[])2563 static int wpa_cli_cmd_p2p_service_add(struct wpa_ctrl *ctrl, int argc,
2564 char *argv[])
2565 {
2566 if (argc < 3) {
2567 printf("Invalid P2P_SERVICE_ADD command: needs 3-6 arguments\n");
2568 return -1;
2569 }
2570
2571 return wpa_cli_cmd(ctrl, "P2P_SERVICE_ADD", 3, argc, argv);
2572 }
2573
2574
wpa_cli_cmd_p2p_service_rep(struct wpa_ctrl * ctrl,int argc,char * argv[])2575 static int wpa_cli_cmd_p2p_service_rep(struct wpa_ctrl *ctrl, int argc,
2576 char *argv[])
2577 {
2578 if (argc < 5 || argc > 6) {
2579 printf("Invalid P2P_SERVICE_REP command: needs 5-6 "
2580 "arguments\n");
2581 return -1;
2582 }
2583
2584 return wpa_cli_cmd(ctrl, "P2P_SERVICE_REP", 5, argc, argv);
2585 }
2586
2587
wpa_cli_cmd_p2p_service_del(struct wpa_ctrl * ctrl,int argc,char * argv[])2588 static int wpa_cli_cmd_p2p_service_del(struct wpa_ctrl *ctrl, int argc,
2589 char *argv[])
2590 {
2591 char cmd[4096];
2592 int res;
2593
2594 if (argc != 2 && argc != 3) {
2595 printf("Invalid P2P_SERVICE_DEL command: needs two or three "
2596 "arguments\n");
2597 return -1;
2598 }
2599
2600 if (argc == 3)
2601 res = os_snprintf(cmd, sizeof(cmd),
2602 "P2P_SERVICE_DEL %s %s %s",
2603 argv[0], argv[1], argv[2]);
2604 else
2605 res = os_snprintf(cmd, sizeof(cmd),
2606 "P2P_SERVICE_DEL %s %s",
2607 argv[0], argv[1]);
2608 if (os_snprintf_error(sizeof(cmd), res))
2609 return -1;
2610 cmd[sizeof(cmd) - 1] = '\0';
2611 return wpa_ctrl_command(ctrl, cmd);
2612 }
2613
2614
wpa_cli_cmd_p2p_reject(struct wpa_ctrl * ctrl,int argc,char * argv[])2615 static int wpa_cli_cmd_p2p_reject(struct wpa_ctrl *ctrl,
2616 int argc, char *argv[])
2617 {
2618 return wpa_cli_cmd(ctrl, "P2P_REJECT", 1, argc, argv);
2619 }
2620
2621
wpa_cli_cmd_p2p_invite(struct wpa_ctrl * ctrl,int argc,char * argv[])2622 static int wpa_cli_cmd_p2p_invite(struct wpa_ctrl *ctrl,
2623 int argc, char *argv[])
2624 {
2625 return wpa_cli_cmd(ctrl, "P2P_INVITE", 1, argc, argv);
2626 }
2627
2628
wpa_cli_cmd_p2p_peer(struct wpa_ctrl * ctrl,int argc,char * argv[])2629 static int wpa_cli_cmd_p2p_peer(struct wpa_ctrl *ctrl, int argc, char *argv[])
2630 {
2631 return wpa_cli_cmd(ctrl, "P2P_PEER", 1, argc, argv);
2632 }
2633
2634
wpa_cli_complete_p2p_peer(const char * str,int pos)2635 static char ** wpa_cli_complete_p2p_peer(const char *str, int pos)
2636 {
2637 int arg = get_cmd_arg_num(str, pos);
2638 char **res = NULL;
2639
2640 switch (arg) {
2641 case 1:
2642 res = cli_txt_list_array(&p2p_peers);
2643 break;
2644 }
2645
2646 return res;
2647 }
2648
2649
wpa_ctrl_command_p2p_peer(struct wpa_ctrl * ctrl,const char * cmd,char * addr,size_t addr_len,int discovered)2650 static int wpa_ctrl_command_p2p_peer(struct wpa_ctrl *ctrl, const char *cmd,
2651 char *addr, size_t addr_len,
2652 int discovered)
2653 {
2654 char buf[4096], *pos;
2655 size_t len;
2656 int ret;
2657
2658 if (ctrl_conn == NULL)
2659 return -1;
2660 len = sizeof(buf) - 1;
2661 ret = wpa_ctrl_request(ctrl, cmd, os_strlen(cmd), buf, &len,
2662 wpa_cli_msg_cb);
2663 if (ret == -2) {
2664 printf("'%s' command timed out.\n", cmd);
2665 return -2;
2666 } else if (ret < 0) {
2667 printf("'%s' command failed.\n", cmd);
2668 return -1;
2669 }
2670
2671 buf[len] = '\0';
2672 if (os_memcmp(buf, "FAIL", 4) == 0)
2673 return -1;
2674
2675 pos = buf;
2676 while (*pos != '\0' && *pos != '\n')
2677 pos++;
2678 *pos++ = '\0';
2679 os_strlcpy(addr, buf, addr_len);
2680 if (!discovered || os_strstr(pos, "[PROBE_REQ_ONLY]") == NULL)
2681 printf("%s\n", addr);
2682 return 0;
2683 }
2684
2685
wpa_cli_cmd_p2p_peers(struct wpa_ctrl * ctrl,int argc,char * argv[])2686 static int wpa_cli_cmd_p2p_peers(struct wpa_ctrl *ctrl, int argc, char *argv[])
2687 {
2688 char addr[32], cmd[64];
2689 int discovered;
2690
2691 discovered = argc > 0 && os_strcmp(argv[0], "discovered") == 0;
2692
2693 if (wpa_ctrl_command_p2p_peer(ctrl, "P2P_PEER FIRST",
2694 addr, sizeof(addr), discovered))
2695 return -1;
2696 do {
2697 os_snprintf(cmd, sizeof(cmd), "P2P_PEER NEXT-%s", addr);
2698 } while (wpa_ctrl_command_p2p_peer(ctrl, cmd, addr, sizeof(addr),
2699 discovered) == 0);
2700
2701 return 0;
2702 }
2703
2704
wpa_cli_cmd_p2p_set(struct wpa_ctrl * ctrl,int argc,char * argv[])2705 static int wpa_cli_cmd_p2p_set(struct wpa_ctrl *ctrl, int argc, char *argv[])
2706 {
2707 return wpa_cli_cmd(ctrl, "P2P_SET", 2, argc, argv);
2708 }
2709
2710
wpa_cli_complete_p2p_set(const char * str,int pos)2711 static char ** wpa_cli_complete_p2p_set(const char *str, int pos)
2712 {
2713 int arg = get_cmd_arg_num(str, pos);
2714 const char *fields[] = {
2715 "discoverability",
2716 "managed",
2717 "listen_channel",
2718 "ssid_postfix",
2719 "noa",
2720 "ps",
2721 "oppps",
2722 "ctwindow",
2723 "disabled",
2724 "conc_pref",
2725 "force_long_sd",
2726 "peer_filter",
2727 "cross_connect",
2728 "go_apsd",
2729 "client_apsd",
2730 "disallow_freq",
2731 "disc_int",
2732 "per_sta_psk",
2733 };
2734 int i, num_fields = ARRAY_SIZE(fields);
2735
2736 if (arg == 1) {
2737 char **res = os_calloc(num_fields + 1, sizeof(char *));
2738 if (res == NULL)
2739 return NULL;
2740 for (i = 0; i < num_fields; i++) {
2741 res[i] = os_strdup(fields[i]);
2742 if (res[i] == NULL)
2743 return res;
2744 }
2745 return res;
2746 }
2747
2748 if (arg == 2 && os_strncasecmp(str, "p2p_set peer_filter ", 20) == 0)
2749 return cli_txt_list_array(&p2p_peers);
2750
2751 return NULL;
2752 }
2753
2754
wpa_cli_cmd_p2p_flush(struct wpa_ctrl * ctrl,int argc,char * argv[])2755 static int wpa_cli_cmd_p2p_flush(struct wpa_ctrl *ctrl, int argc, char *argv[])
2756 {
2757 return wpa_ctrl_command(ctrl, "P2P_FLUSH");
2758 }
2759
2760
wpa_cli_cmd_p2p_cancel(struct wpa_ctrl * ctrl,int argc,char * argv[])2761 static int wpa_cli_cmd_p2p_cancel(struct wpa_ctrl *ctrl, int argc,
2762 char *argv[])
2763 {
2764 return wpa_ctrl_command(ctrl, "P2P_CANCEL");
2765 }
2766
2767
wpa_cli_cmd_p2p_unauthorize(struct wpa_ctrl * ctrl,int argc,char * argv[])2768 static int wpa_cli_cmd_p2p_unauthorize(struct wpa_ctrl *ctrl, int argc,
2769 char *argv[])
2770 {
2771 return wpa_cli_cmd(ctrl, "P2P_UNAUTHORIZE", 1, argc, argv);
2772 }
2773
2774
wpa_cli_cmd_p2p_presence_req(struct wpa_ctrl * ctrl,int argc,char * argv[])2775 static int wpa_cli_cmd_p2p_presence_req(struct wpa_ctrl *ctrl, int argc,
2776 char *argv[])
2777 {
2778 if (argc != 0 && argc != 2 && argc != 4) {
2779 printf("Invalid P2P_PRESENCE_REQ command: needs two arguments "
2780 "(preferred duration, interval; in microsecods).\n"
2781 "Optional second pair can be used to provide "
2782 "acceptable values.\n");
2783 return -1;
2784 }
2785
2786 return wpa_cli_cmd(ctrl, "P2P_PRESENCE_REQ", 0, argc, argv);
2787 }
2788
2789
wpa_cli_cmd_p2p_ext_listen(struct wpa_ctrl * ctrl,int argc,char * argv[])2790 static int wpa_cli_cmd_p2p_ext_listen(struct wpa_ctrl *ctrl, int argc,
2791 char *argv[])
2792 {
2793 if (argc != 0 && argc != 2) {
2794 printf("Invalid P2P_EXT_LISTEN command: needs two arguments "
2795 "(availability period, availability interval; in "
2796 "millisecods).\n"
2797 "Extended Listen Timing can be cancelled with this "
2798 "command when used without parameters.\n");
2799 return -1;
2800 }
2801
2802 return wpa_cli_cmd(ctrl, "P2P_EXT_LISTEN", 0, argc, argv);
2803 }
2804
2805
wpa_cli_cmd_p2p_remove_client(struct wpa_ctrl * ctrl,int argc,char * argv[])2806 static int wpa_cli_cmd_p2p_remove_client(struct wpa_ctrl *ctrl, int argc,
2807 char *argv[])
2808 {
2809 return wpa_cli_cmd(ctrl, "P2P_REMOVE_CLIENT", 1, argc, argv);
2810 }
2811
2812 #endif /* CONFIG_P2P */
2813
2814
wpa_cli_cmd_vendor_elem_add(struct wpa_ctrl * ctrl,int argc,char * argv[])2815 static int wpa_cli_cmd_vendor_elem_add(struct wpa_ctrl *ctrl, int argc,
2816 char *argv[])
2817 {
2818 return wpa_cli_cmd(ctrl, "VENDOR_ELEM_ADD", 2, argc, argv);
2819 }
2820
2821
wpa_cli_cmd_vendor_elem_get(struct wpa_ctrl * ctrl,int argc,char * argv[])2822 static int wpa_cli_cmd_vendor_elem_get(struct wpa_ctrl *ctrl, int argc,
2823 char *argv[])
2824 {
2825 return wpa_cli_cmd(ctrl, "VENDOR_ELEM_GET", 1, argc, argv);
2826 }
2827
2828
wpa_cli_cmd_vendor_elem_remove(struct wpa_ctrl * ctrl,int argc,char * argv[])2829 static int wpa_cli_cmd_vendor_elem_remove(struct wpa_ctrl *ctrl, int argc,
2830 char *argv[])
2831 {
2832 return wpa_cli_cmd(ctrl, "VENDOR_ELEM_REMOVE", 2, argc, argv);
2833 }
2834
2835
2836 #ifdef CONFIG_WIFI_DISPLAY
2837
wpa_cli_cmd_wfd_subelem_set(struct wpa_ctrl * ctrl,int argc,char * argv[])2838 static int wpa_cli_cmd_wfd_subelem_set(struct wpa_ctrl *ctrl, int argc,
2839 char *argv[])
2840 {
2841 char cmd[100];
2842 int res;
2843
2844 if (argc != 1 && argc != 2) {
2845 printf("Invalid WFD_SUBELEM_SET command: needs one or two "
2846 "arguments (subelem, hexdump)\n");
2847 return -1;
2848 }
2849
2850 res = os_snprintf(cmd, sizeof(cmd), "WFD_SUBELEM_SET %s %s",
2851 argv[0], argc > 1 ? argv[1] : "");
2852 if (os_snprintf_error(sizeof(cmd), res))
2853 return -1;
2854 cmd[sizeof(cmd) - 1] = '\0';
2855 return wpa_ctrl_command(ctrl, cmd);
2856 }
2857
2858
wpa_cli_cmd_wfd_subelem_get(struct wpa_ctrl * ctrl,int argc,char * argv[])2859 static int wpa_cli_cmd_wfd_subelem_get(struct wpa_ctrl *ctrl, int argc,
2860 char *argv[])
2861 {
2862 char cmd[100];
2863 int res;
2864
2865 if (argc != 1) {
2866 printf("Invalid WFD_SUBELEM_GET command: needs one "
2867 "argument (subelem)\n");
2868 return -1;
2869 }
2870
2871 res = os_snprintf(cmd, sizeof(cmd), "WFD_SUBELEM_GET %s",
2872 argv[0]);
2873 if (os_snprintf_error(sizeof(cmd), res))
2874 return -1;
2875 cmd[sizeof(cmd) - 1] = '\0';
2876 return wpa_ctrl_command(ctrl, cmd);
2877 }
2878 #endif /* CONFIG_WIFI_DISPLAY */
2879
2880
2881 #ifdef CONFIG_INTERWORKING
wpa_cli_cmd_fetch_anqp(struct wpa_ctrl * ctrl,int argc,char * argv[])2882 static int wpa_cli_cmd_fetch_anqp(struct wpa_ctrl *ctrl, int argc,
2883 char *argv[])
2884 {
2885 return wpa_ctrl_command(ctrl, "FETCH_ANQP");
2886 }
2887
2888
wpa_cli_cmd_stop_fetch_anqp(struct wpa_ctrl * ctrl,int argc,char * argv[])2889 static int wpa_cli_cmd_stop_fetch_anqp(struct wpa_ctrl *ctrl, int argc,
2890 char *argv[])
2891 {
2892 return wpa_ctrl_command(ctrl, "STOP_FETCH_ANQP");
2893 }
2894
2895
wpa_cli_cmd_interworking_select(struct wpa_ctrl * ctrl,int argc,char * argv[])2896 static int wpa_cli_cmd_interworking_select(struct wpa_ctrl *ctrl, int argc,
2897 char *argv[])
2898 {
2899 return wpa_cli_cmd(ctrl, "INTERWORKING_SELECT", 0, argc, argv);
2900 }
2901
2902
wpa_cli_cmd_interworking_connect(struct wpa_ctrl * ctrl,int argc,char * argv[])2903 static int wpa_cli_cmd_interworking_connect(struct wpa_ctrl *ctrl, int argc,
2904 char *argv[])
2905 {
2906 return wpa_cli_cmd(ctrl, "INTERWORKING_CONNECT", 1, argc, argv);
2907 }
2908
2909
wpa_cli_cmd_interworking_add_network(struct wpa_ctrl * ctrl,int argc,char * argv[])2910 static int wpa_cli_cmd_interworking_add_network(struct wpa_ctrl *ctrl, int argc,
2911 char *argv[])
2912 {
2913 return wpa_cli_cmd(ctrl, "INTERWORKING_ADD_NETWORK", 1, argc, argv);
2914 }
2915
2916
wpa_cli_cmd_anqp_get(struct wpa_ctrl * ctrl,int argc,char * argv[])2917 static int wpa_cli_cmd_anqp_get(struct wpa_ctrl *ctrl, int argc, char *argv[])
2918 {
2919 return wpa_cli_cmd(ctrl, "ANQP_GET", 2, argc, argv);
2920 }
2921
2922
wpa_cli_cmd_gas_request(struct wpa_ctrl * ctrl,int argc,char * argv[])2923 static int wpa_cli_cmd_gas_request(struct wpa_ctrl *ctrl, int argc,
2924 char *argv[])
2925 {
2926 return wpa_cli_cmd(ctrl, "GAS_REQUEST", 2, argc, argv);
2927 }
2928
2929
wpa_cli_cmd_gas_response_get(struct wpa_ctrl * ctrl,int argc,char * argv[])2930 static int wpa_cli_cmd_gas_response_get(struct wpa_ctrl *ctrl, int argc,
2931 char *argv[])
2932 {
2933 return wpa_cli_cmd(ctrl, "GAS_RESPONSE_GET", 2, argc, argv);
2934 }
2935 #endif /* CONFIG_INTERWORKING */
2936
2937
2938 #ifdef CONFIG_HS20
2939
wpa_cli_cmd_hs20_anqp_get(struct wpa_ctrl * ctrl,int argc,char * argv[])2940 static int wpa_cli_cmd_hs20_anqp_get(struct wpa_ctrl *ctrl, int argc,
2941 char *argv[])
2942 {
2943 return wpa_cli_cmd(ctrl, "HS20_ANQP_GET", 2, argc, argv);
2944 }
2945
2946
wpa_cli_cmd_get_nai_home_realm_list(struct wpa_ctrl * ctrl,int argc,char * argv[])2947 static int wpa_cli_cmd_get_nai_home_realm_list(struct wpa_ctrl *ctrl, int argc,
2948 char *argv[])
2949 {
2950 char cmd[512];
2951
2952 if (argc == 0) {
2953 printf("Command needs one or two arguments (dst mac addr and "
2954 "optional home realm)\n");
2955 return -1;
2956 }
2957
2958 if (write_cmd(cmd, sizeof(cmd), "HS20_GET_NAI_HOME_REALM_LIST",
2959 argc, argv) < 0)
2960 return -1;
2961
2962 return wpa_ctrl_command(ctrl, cmd);
2963 }
2964
2965
wpa_cli_cmd_hs20_icon_request(struct wpa_ctrl * ctrl,int argc,char * argv[])2966 static int wpa_cli_cmd_hs20_icon_request(struct wpa_ctrl *ctrl, int argc,
2967 char *argv[])
2968 {
2969 char cmd[512];
2970
2971 if (argc < 2) {
2972 printf("Command needs two arguments (dst mac addr and "
2973 "icon name)\n");
2974 return -1;
2975 }
2976
2977 if (write_cmd(cmd, sizeof(cmd), "HS20_ICON_REQUEST", argc, argv) < 0)
2978 return -1;
2979
2980 return wpa_ctrl_command(ctrl, cmd);
2981 }
2982
2983
wpa_cli_cmd_fetch_osu(struct wpa_ctrl * ctrl,int argc,char * argv[])2984 static int wpa_cli_cmd_fetch_osu(struct wpa_ctrl *ctrl, int argc, char *argv[])
2985 {
2986 return wpa_ctrl_command(ctrl, "FETCH_OSU");
2987 }
2988
2989
wpa_cli_cmd_cancel_fetch_osu(struct wpa_ctrl * ctrl,int argc,char * argv[])2990 static int wpa_cli_cmd_cancel_fetch_osu(struct wpa_ctrl *ctrl, int argc,
2991 char *argv[])
2992 {
2993 return wpa_ctrl_command(ctrl, "CANCEL_FETCH_OSU");
2994 }
2995
2996 #endif /* CONFIG_HS20 */
2997
2998
wpa_cli_cmd_sta_autoconnect(struct wpa_ctrl * ctrl,int argc,char * argv[])2999 static int wpa_cli_cmd_sta_autoconnect(struct wpa_ctrl *ctrl, int argc,
3000 char *argv[])
3001 {
3002 return wpa_cli_cmd(ctrl, "STA_AUTOCONNECT", 1, argc, argv);
3003 }
3004
3005
wpa_cli_cmd_tdls_discover(struct wpa_ctrl * ctrl,int argc,char * argv[])3006 static int wpa_cli_cmd_tdls_discover(struct wpa_ctrl *ctrl, int argc,
3007 char *argv[])
3008 {
3009 return wpa_cli_cmd(ctrl, "TDLS_DISCOVER", 1, argc, argv);
3010 }
3011
3012
wpa_cli_cmd_tdls_setup(struct wpa_ctrl * ctrl,int argc,char * argv[])3013 static int wpa_cli_cmd_tdls_setup(struct wpa_ctrl *ctrl, int argc,
3014 char *argv[])
3015 {
3016 return wpa_cli_cmd(ctrl, "TDLS_SETUP", 1, argc, argv);
3017 }
3018
3019
wpa_cli_cmd_tdls_teardown(struct wpa_ctrl * ctrl,int argc,char * argv[])3020 static int wpa_cli_cmd_tdls_teardown(struct wpa_ctrl *ctrl, int argc,
3021 char *argv[])
3022 {
3023 return wpa_cli_cmd(ctrl, "TDLS_TEARDOWN", 1, argc, argv);
3024 }
3025
3026
wpa_cli_cmd_tdls_link_status(struct wpa_ctrl * ctrl,int argc,char * argv[])3027 static int wpa_cli_cmd_tdls_link_status(struct wpa_ctrl *ctrl, int argc,
3028 char *argv[])
3029 {
3030 return wpa_cli_cmd(ctrl, "TDLS_LINK_STATUS", 1, argc, argv);
3031 }
3032
3033
wpa_cli_cmd_wmm_ac_addts(struct wpa_ctrl * ctrl,int argc,char * argv[])3034 static int wpa_cli_cmd_wmm_ac_addts(struct wpa_ctrl *ctrl, int argc,
3035 char *argv[])
3036 {
3037 return wpa_cli_cmd(ctrl, "WMM_AC_ADDTS", 3, argc, argv);
3038 }
3039
3040
wpa_cli_cmd_wmm_ac_delts(struct wpa_ctrl * ctrl,int argc,char * argv[])3041 static int wpa_cli_cmd_wmm_ac_delts(struct wpa_ctrl *ctrl, int argc,
3042 char *argv[])
3043 {
3044 return wpa_cli_cmd(ctrl, "WMM_AC_DELTS", 1, argc, argv);
3045 }
3046
3047
wpa_cli_cmd_wmm_ac_status(struct wpa_ctrl * ctrl,int argc,char * argv[])3048 static int wpa_cli_cmd_wmm_ac_status(struct wpa_ctrl *ctrl, int argc,
3049 char *argv[])
3050 {
3051 return wpa_ctrl_command(ctrl, "WMM_AC_STATUS");
3052 }
3053
3054
wpa_cli_cmd_tdls_chan_switch(struct wpa_ctrl * ctrl,int argc,char * argv[])3055 static int wpa_cli_cmd_tdls_chan_switch(struct wpa_ctrl *ctrl, int argc,
3056 char *argv[])
3057 {
3058 return wpa_cli_cmd(ctrl, "TDLS_CHAN_SWITCH", 2, argc, argv);
3059 }
3060
3061
wpa_cli_cmd_tdls_cancel_chan_switch(struct wpa_ctrl * ctrl,int argc,char * argv[])3062 static int wpa_cli_cmd_tdls_cancel_chan_switch(struct wpa_ctrl *ctrl, int argc,
3063 char *argv[])
3064 {
3065 return wpa_cli_cmd(ctrl, "TDLS_CANCEL_CHAN_SWITCH", 1, argc, argv);
3066 }
3067
3068
wpa_cli_cmd_signal_poll(struct wpa_ctrl * ctrl,int argc,char * argv[])3069 static int wpa_cli_cmd_signal_poll(struct wpa_ctrl *ctrl, int argc,
3070 char *argv[])
3071 {
3072 return wpa_ctrl_command(ctrl, "SIGNAL_POLL");
3073 }
3074
3075
wpa_cli_cmd_signal_monitor(struct wpa_ctrl * ctrl,int argc,char * argv[])3076 static int wpa_cli_cmd_signal_monitor(struct wpa_ctrl *ctrl, int argc,
3077 char *argv[])
3078 {
3079 return wpa_cli_cmd(ctrl, "SIGNAL_MONITOR", 0, argc, argv);
3080 }
3081
3082
wpa_cli_cmd_pktcnt_poll(struct wpa_ctrl * ctrl,int argc,char * argv[])3083 static int wpa_cli_cmd_pktcnt_poll(struct wpa_ctrl *ctrl, int argc,
3084 char *argv[])
3085 {
3086 return wpa_ctrl_command(ctrl, "PKTCNT_POLL");
3087 }
3088
3089
wpa_cli_cmd_reauthenticate(struct wpa_ctrl * ctrl,int argc,char * argv[])3090 static int wpa_cli_cmd_reauthenticate(struct wpa_ctrl *ctrl, int argc,
3091 char *argv[])
3092 {
3093 return wpa_ctrl_command(ctrl, "REAUTHENTICATE");
3094 }
3095
3096
3097 #ifdef CONFIG_AUTOSCAN
3098
wpa_cli_cmd_autoscan(struct wpa_ctrl * ctrl,int argc,char * argv[])3099 static int wpa_cli_cmd_autoscan(struct wpa_ctrl *ctrl, int argc, char *argv[])
3100 {
3101 if (argc == 0)
3102 return wpa_ctrl_command(ctrl, "AUTOSCAN ");
3103
3104 return wpa_cli_cmd(ctrl, "AUTOSCAN", 0, argc, argv);
3105 }
3106
3107 #endif /* CONFIG_AUTOSCAN */
3108
3109
3110 #ifdef CONFIG_WNM
3111
wpa_cli_cmd_wnm_sleep(struct wpa_ctrl * ctrl,int argc,char * argv[])3112 static int wpa_cli_cmd_wnm_sleep(struct wpa_ctrl *ctrl, int argc, char *argv[])
3113 {
3114 return wpa_cli_cmd(ctrl, "WNM_SLEEP", 0, argc, argv);
3115 }
3116
3117
wpa_cli_cmd_wnm_bss_query(struct wpa_ctrl * ctrl,int argc,char * argv[])3118 static int wpa_cli_cmd_wnm_bss_query(struct wpa_ctrl *ctrl, int argc, char *argv[])
3119 {
3120 return wpa_cli_cmd(ctrl, "WNM_BSS_QUERY", 1, argc, argv);
3121 }
3122
3123 #endif /* CONFIG_WNM */
3124
3125
wpa_cli_cmd_raw(struct wpa_ctrl * ctrl,int argc,char * argv[])3126 static int wpa_cli_cmd_raw(struct wpa_ctrl *ctrl, int argc, char *argv[])
3127 {
3128 if (argc == 0)
3129 return -1;
3130 return wpa_cli_cmd(ctrl, argv[0], 0, argc - 1, &argv[1]);
3131 }
3132
3133
3134 #ifdef ANDROID
wpa_cli_cmd_driver(struct wpa_ctrl * ctrl,int argc,char * argv[])3135 static int wpa_cli_cmd_driver(struct wpa_ctrl *ctrl, int argc, char *argv[])
3136 {
3137 return wpa_cli_cmd(ctrl, "DRIVER", 1, argc, argv);
3138 }
3139 #endif /* ANDROID */
3140
3141
wpa_cli_cmd_vendor(struct wpa_ctrl * ctrl,int argc,char * argv[])3142 static int wpa_cli_cmd_vendor(struct wpa_ctrl *ctrl, int argc, char *argv[])
3143 {
3144 return wpa_cli_cmd(ctrl, "VENDOR", 1, argc, argv);
3145 }
3146
3147
wpa_cli_cmd_flush(struct wpa_ctrl * ctrl,int argc,char * argv[])3148 static int wpa_cli_cmd_flush(struct wpa_ctrl *ctrl, int argc, char *argv[])
3149 {
3150 return wpa_ctrl_command(ctrl, "FLUSH");
3151 }
3152
3153
wpa_cli_cmd_radio_work(struct wpa_ctrl * ctrl,int argc,char * argv[])3154 static int wpa_cli_cmd_radio_work(struct wpa_ctrl *ctrl, int argc, char *argv[])
3155 {
3156 return wpa_cli_cmd(ctrl, "RADIO_WORK", 1, argc, argv);
3157 }
3158
3159
wpa_cli_cmd_neighbor_rep_request(struct wpa_ctrl * ctrl,int argc,char * argv[])3160 static int wpa_cli_cmd_neighbor_rep_request(struct wpa_ctrl *ctrl, int argc,
3161 char *argv[])
3162 {
3163 return wpa_cli_cmd(ctrl, "NEIGHBOR_REP_REQUEST", 0, argc, argv);
3164 }
3165
3166
wpa_cli_cmd_twt_setup(struct wpa_ctrl * ctrl,int argc,char * argv[])3167 static int wpa_cli_cmd_twt_setup(struct wpa_ctrl *ctrl, int argc,
3168 char *argv[])
3169 {
3170 return wpa_cli_cmd(ctrl, "TWT_SETUP", 0, argc, argv);
3171 }
3172
3173
wpa_cli_cmd_twt_teardown(struct wpa_ctrl * ctrl,int argc,char * argv[])3174 static int wpa_cli_cmd_twt_teardown(struct wpa_ctrl *ctrl, int argc,
3175 char *argv[])
3176 {
3177 return wpa_cli_cmd(ctrl, "TWT_TEARDOWN", 0, argc, argv);
3178 }
3179
3180
wpa_cli_cmd_erp_flush(struct wpa_ctrl * ctrl,int argc,char * argv[])3181 static int wpa_cli_cmd_erp_flush(struct wpa_ctrl *ctrl, int argc, char *argv[])
3182 {
3183 return wpa_ctrl_command(ctrl, "ERP_FLUSH");
3184 }
3185
3186
wpa_cli_cmd_mac_rand_scan(struct wpa_ctrl * ctrl,int argc,char * argv[])3187 static int wpa_cli_cmd_mac_rand_scan(struct wpa_ctrl *ctrl, int argc,
3188 char *argv[])
3189 {
3190 return wpa_cli_cmd(ctrl, "MAC_RAND_SCAN", 1, argc, argv);
3191 }
3192
3193
wpa_cli_cmd_get_pref_freq_list(struct wpa_ctrl * ctrl,int argc,char * argv[])3194 static int wpa_cli_cmd_get_pref_freq_list(struct wpa_ctrl *ctrl, int argc,
3195 char *argv[])
3196 {
3197 return wpa_cli_cmd(ctrl, "GET_PREF_FREQ_LIST", 1, argc, argv);
3198 }
3199
3200
wpa_cli_cmd_p2p_lo_start(struct wpa_ctrl * ctrl,int argc,char * argv[])3201 static int wpa_cli_cmd_p2p_lo_start(struct wpa_ctrl *ctrl, int argc,
3202 char *argv[])
3203 {
3204 return wpa_cli_cmd(ctrl, "P2P_LO_START", 4, argc, argv);
3205 }
3206
3207
wpa_cli_cmd_p2p_lo_stop(struct wpa_ctrl * ctrl,int argc,char * argv[])3208 static int wpa_cli_cmd_p2p_lo_stop(struct wpa_ctrl *ctrl, int argc,
3209 char *argv[])
3210 {
3211 return wpa_cli_cmd(ctrl, "P2P_LO_STOP", 0, argc, argv);
3212 }
3213
3214 #ifdef CONFIG_MAGICLINK
wpa_cli_cmd_magiclink_connect(struct wpa_ctrl * ctrl,int argc,char * argv[])3215 static int wpa_cli_cmd_magiclink_connect(struct wpa_ctrl *ctrl, int argc,
3216 char *argv[])
3217 {
3218 return wpa_cli_cmd(ctrl, "MAGICLINK", 0, argc, argv);
3219 }
3220 #endif
3221
3222 #ifdef CONFIG_DPP
3223
wpa_cli_cmd_dpp_qr_code(struct wpa_ctrl * ctrl,int argc,char * argv[])3224 static int wpa_cli_cmd_dpp_qr_code(struct wpa_ctrl *ctrl, int argc,
3225 char *argv[])
3226 {
3227 return wpa_cli_cmd(ctrl, "DPP_QR_CODE", 1, argc, argv);
3228 }
3229
3230
wpa_cli_cmd_dpp_bootstrap_gen(struct wpa_ctrl * ctrl,int argc,char * argv[])3231 static int wpa_cli_cmd_dpp_bootstrap_gen(struct wpa_ctrl *ctrl, int argc,
3232 char *argv[])
3233 {
3234 return wpa_cli_cmd(ctrl, "DPP_BOOTSTRAP_GEN", 1, argc, argv);
3235 }
3236
3237
wpa_cli_cmd_dpp_bootstrap_remove(struct wpa_ctrl * ctrl,int argc,char * argv[])3238 static int wpa_cli_cmd_dpp_bootstrap_remove(struct wpa_ctrl *ctrl, int argc,
3239 char *argv[])
3240 {
3241 return wpa_cli_cmd(ctrl, "DPP_BOOTSTRAP_REMOVE", 1, argc, argv);
3242 }
3243
3244
wpa_cli_cmd_dpp_bootstrap_get_uri(struct wpa_ctrl * ctrl,int argc,char * argv[])3245 static int wpa_cli_cmd_dpp_bootstrap_get_uri(struct wpa_ctrl *ctrl, int argc,
3246 char *argv[])
3247 {
3248 return wpa_cli_cmd(ctrl, "DPP_BOOTSTRAP_GET_URI", 1, argc, argv);
3249 }
3250
3251
wpa_cli_cmd_dpp_bootstrap_info(struct wpa_ctrl * ctrl,int argc,char * argv[])3252 static int wpa_cli_cmd_dpp_bootstrap_info(struct wpa_ctrl *ctrl, int argc,
3253 char *argv[])
3254 {
3255 return wpa_cli_cmd(ctrl, "DPP_BOOTSTRAP_INFO", 1, argc, argv);
3256 }
3257
3258
wpa_cli_cmd_dpp_bootstrap_set(struct wpa_ctrl * ctrl,int argc,char * argv[])3259 static int wpa_cli_cmd_dpp_bootstrap_set(struct wpa_ctrl *ctrl, int argc,
3260 char *argv[])
3261 {
3262 return wpa_cli_cmd(ctrl, "DPP_BOOTSTRAP_SET", 1, argc, argv);
3263 }
3264
3265
wpa_cli_cmd_dpp_auth_init(struct wpa_ctrl * ctrl,int argc,char * argv[])3266 static int wpa_cli_cmd_dpp_auth_init(struct wpa_ctrl *ctrl, int argc,
3267 char *argv[])
3268 {
3269 return wpa_cli_cmd(ctrl, "DPP_AUTH_INIT", 1, argc, argv);
3270 }
3271
3272
wpa_cli_cmd_dpp_listen(struct wpa_ctrl * ctrl,int argc,char * argv[])3273 static int wpa_cli_cmd_dpp_listen(struct wpa_ctrl *ctrl, int argc,
3274 char *argv[])
3275 {
3276 return wpa_cli_cmd(ctrl, "DPP_LISTEN", 1, argc, argv);
3277 }
3278
3279
wpa_cli_cmd_dpp_stop_listen(struct wpa_ctrl * ctrl,int argc,char * argv[])3280 static int wpa_cli_cmd_dpp_stop_listen(struct wpa_ctrl *ctrl, int argc,
3281 char *argv[])
3282 {
3283 return wpa_ctrl_command(ctrl, "DPP_STOP_LISTEN");
3284 }
3285
3286
wpa_cli_cmd_dpp_configurator_add(struct wpa_ctrl * ctrl,int argc,char * argv[])3287 static int wpa_cli_cmd_dpp_configurator_add(struct wpa_ctrl *ctrl, int argc,
3288 char *argv[])
3289 {
3290 return wpa_cli_cmd(ctrl, "DPP_CONFIGURATOR_ADD", 0, argc, argv);
3291 }
3292
3293
wpa_cli_cmd_dpp_configurator_remove(struct wpa_ctrl * ctrl,int argc,char * argv[])3294 static int wpa_cli_cmd_dpp_configurator_remove(struct wpa_ctrl *ctrl, int argc,
3295 char *argv[])
3296 {
3297 return wpa_cli_cmd(ctrl, "DPP_CONFIGURATOR_REMOVE", 1, argc, argv);
3298 }
3299
3300
wpa_cli_cmd_dpp_configurator_get_key(struct wpa_ctrl * ctrl,int argc,char * argv[])3301 static int wpa_cli_cmd_dpp_configurator_get_key(struct wpa_ctrl *ctrl, int argc,
3302 char *argv[])
3303 {
3304 return wpa_cli_cmd(ctrl, "DPP_CONFIGURATOR_GET_KEY", 1, argc, argv);
3305 }
3306
3307
wpa_cli_cmd_dpp_configurator_sign(struct wpa_ctrl * ctrl,int argc,char * argv[])3308 static int wpa_cli_cmd_dpp_configurator_sign(struct wpa_ctrl *ctrl, int argc,
3309 char *argv[])
3310 {
3311 return wpa_cli_cmd(ctrl, "DPP_CONFIGURATOR_SIGN", 1, argc, argv);
3312 }
3313
3314
wpa_cli_cmd_dpp_pkex_add(struct wpa_ctrl * ctrl,int argc,char * argv[])3315 static int wpa_cli_cmd_dpp_pkex_add(struct wpa_ctrl *ctrl, int argc,
3316 char *argv[])
3317 {
3318 return wpa_cli_cmd(ctrl, "DPP_PKEX_ADD", 1, argc, argv);
3319 }
3320
3321
wpa_cli_cmd_dpp_pkex_remove(struct wpa_ctrl * ctrl,int argc,char * argv[])3322 static int wpa_cli_cmd_dpp_pkex_remove(struct wpa_ctrl *ctrl, int argc,
3323 char *argv[])
3324 {
3325 return wpa_cli_cmd(ctrl, "DPP_PKEX_REMOVE", 1, argc, argv);
3326 }
3327
3328
3329 #ifdef CONFIG_DPP2
3330
wpa_cli_cmd_dpp_controller_start(struct wpa_ctrl * ctrl,int argc,char * argv[])3331 static int wpa_cli_cmd_dpp_controller_start(struct wpa_ctrl *ctrl, int argc,
3332 char *argv[])
3333 {
3334 return wpa_cli_cmd(ctrl, "DPP_CONTROLLER_START", 1, argc, argv);
3335 }
3336
3337
wpa_cli_cmd_dpp_controller_stop(struct wpa_ctrl * ctrl,int argc,char * argv[])3338 static int wpa_cli_cmd_dpp_controller_stop(struct wpa_ctrl *ctrl, int argc,
3339 char *argv[])
3340 {
3341 return wpa_ctrl_command(ctrl, "DPP_CONTROLLER_STOP");
3342 }
3343
3344
wpa_cli_cmd_dpp_chirp(struct wpa_ctrl * ctrl,int argc,char * argv[])3345 static int wpa_cli_cmd_dpp_chirp(struct wpa_ctrl *ctrl, int argc,
3346 char *argv[])
3347 {
3348 return wpa_cli_cmd(ctrl, "DPP_CHIRP", 1, argc, argv);
3349 }
3350
3351
wpa_cli_cmd_dpp_stop_chirp(struct wpa_ctrl * ctrl,int argc,char * argv[])3352 static int wpa_cli_cmd_dpp_stop_chirp(struct wpa_ctrl *ctrl, int argc,
3353 char *argv[])
3354 {
3355 return wpa_ctrl_command(ctrl, "DPP_STOP_CHIRP");
3356 }
3357
3358 #endif /* CONFIG_DPP2 */
3359 #endif /* CONFIG_DPP */
3360
3361
wpa_ctrl_command_bss(struct wpa_ctrl * ctrl,const char * cmd)3362 static int wpa_ctrl_command_bss(struct wpa_ctrl *ctrl, const char *cmd)
3363 {
3364 char buf[512], *pos, *bssid = NULL, *freq = NULL, *level = NULL,
3365 *flags = NULL, *ssid = NULL;
3366 size_t len;
3367 int ret, id = -1;
3368
3369 if (!ctrl_conn)
3370 return -1;
3371 len = sizeof(buf) - 1;
3372 ret = wpa_ctrl_request(ctrl, cmd, os_strlen(cmd), buf, &len,
3373 wpa_cli_msg_cb);
3374 if (ret == -2) {
3375 printf("'%s' command timed out.\n", cmd);
3376 return -2;
3377 } else if (ret < 0) {
3378 printf("'%s' command failed.\n", cmd);
3379 return -1;
3380 }
3381
3382 buf[len] = '\0';
3383 if (os_memcmp(buf, "FAIL", 4) == 0)
3384 return -1;
3385
3386 pos = buf;
3387 while (*pos != '\0') {
3388 if (str_starts(pos, "id="))
3389 id = atoi(pos + 3);
3390 if (str_starts(pos, "bssid="))
3391 bssid = pos + 6;
3392 if (str_starts(pos, "freq="))
3393 freq = pos + 5;
3394 if (str_starts(pos, "level="))
3395 level = pos + 6;
3396 if (str_starts(pos, "flags="))
3397 flags = pos + 6;
3398 if (str_starts(pos, "ssid="))
3399 ssid = pos + 5;
3400
3401 while (*pos != '\0' && *pos != '\n')
3402 pos++;
3403 *pos++ = '\0';
3404 }
3405 if (id != -1)
3406 printf("%s\t%s\t%s\t%s\t%s\n", bssid ? bssid : "N/A",
3407 freq ? freq : "N/A", level ? level : "N/A",
3408 flags ? flags : "N/A", ssid ? ssid : "N/A");
3409 return id;
3410 }
3411
3412
wpa_cli_cmd_all_bss(struct wpa_ctrl * ctrl,int argc,char * argv[])3413 static int wpa_cli_cmd_all_bss(struct wpa_ctrl *ctrl, int argc, char *argv[])
3414 {
3415 char cmd[64];
3416 int id = -1;
3417 unsigned int mask;
3418
3419 printf("bssid / frequency / signal level / flags / ssid\n");
3420
3421 mask = WPA_BSS_MASK_ID | WPA_BSS_MASK_BSSID | WPA_BSS_MASK_FREQ |
3422 WPA_BSS_MASK_LEVEL | WPA_BSS_MASK_FLAGS | WPA_BSS_MASK_SSID;
3423 do {
3424 if (id < 0)
3425 os_snprintf(cmd, sizeof(cmd), "BSS FIRST MASK=0x%x",
3426 mask);
3427 else
3428 os_snprintf(cmd, sizeof(cmd), "BSS NEXT-%d MASK=0x%x",
3429 id, mask);
3430 id = wpa_ctrl_command_bss(ctrl, cmd);
3431 } while (id >= 0);
3432
3433 return 0;
3434 }
3435
3436
3437 #ifdef CONFIG_PASN
3438
wpa_cli_cmd_pasn_auth_start(struct wpa_ctrl * ctrl,int argc,char * argv[])3439 static int wpa_cli_cmd_pasn_auth_start(struct wpa_ctrl *ctrl, int argc,
3440 char *argv[])
3441 {
3442 return wpa_cli_cmd(ctrl, "PASN_AUTH_START", 4, argc, argv);
3443 }
3444
3445
wpa_cli_cmd_pasn_auth_stop(struct wpa_ctrl * ctrl,int argc,char * argv[])3446 static int wpa_cli_cmd_pasn_auth_stop(struct wpa_ctrl *ctrl, int argc,
3447 char *argv[])
3448 {
3449 return wpa_cli_cmd(ctrl, "PASN_AUTH_STOP", 0, argc, argv);
3450 }
3451
wpa_cli_cmd_ptksa_cache_list(struct wpa_ctrl * ctrl,int argc,char * argv[])3452 static int wpa_cli_cmd_ptksa_cache_list(struct wpa_ctrl *ctrl, int argc,
3453 char *argv[])
3454 {
3455 return wpa_cli_cmd(ctrl, "PTKSA_CACHE_LIST", 0, argc, argv);
3456 }
3457
3458
wpa_cli_cmd_pasn_deauth(struct wpa_ctrl * ctrl,int argc,char * argv[])3459 static int wpa_cli_cmd_pasn_deauth(struct wpa_ctrl *ctrl, int argc,
3460 char *argv[])
3461 {
3462 return wpa_cli_cmd(ctrl, "PASN_DEAUTH", 1, argc, argv);
3463 }
3464
3465 #endif /* CONFIG_PASN */
3466
3467
wpa_cli_cmd_mscs(struct wpa_ctrl * ctrl,int argc,char * argv[])3468 static int wpa_cli_cmd_mscs(struct wpa_ctrl *ctrl, int argc, char *argv[])
3469 {
3470 return wpa_cli_cmd(ctrl, "MSCS", 1, argc, argv);
3471 }
3472
3473
wpa_cli_cmd_scs(struct wpa_ctrl * ctrl,int argc,char * argv[])3474 static int wpa_cli_cmd_scs(struct wpa_ctrl *ctrl, int argc, char *argv[])
3475 {
3476 return wpa_cli_cmd(ctrl, "SCS", 2, argc, argv);
3477 }
3478
3479
wpa_cli_cmd_dscp_resp(struct wpa_ctrl * ctrl,int argc,char * argv[])3480 static int wpa_cli_cmd_dscp_resp(struct wpa_ctrl *ctrl, int argc, char *argv[])
3481 {
3482 return wpa_cli_cmd(ctrl, "DSCP_RESP", 1, argc, argv);
3483 }
3484
3485
wpa_cli_cmd_dscp_query(struct wpa_ctrl * ctrl,int argc,char * argv[])3486 static int wpa_cli_cmd_dscp_query(struct wpa_ctrl *ctrl, int argc, char *argv[])
3487 {
3488 return wpa_cli_cmd(ctrl, "DSCP_QUERY", 1, argc, argv);
3489 }
3490
3491
3492 enum wpa_cli_cmd_flags {
3493 cli_cmd_flag_none = 0x00,
3494 cli_cmd_flag_sensitive = 0x01
3495 };
3496
3497 struct wpa_cli_cmd {
3498 const char *cmd;
3499 int (*handler)(struct wpa_ctrl *ctrl, int argc, char *argv[]);
3500 char ** (*completion)(const char *str, int pos);
3501 enum wpa_cli_cmd_flags flags;
3502 const char *usage;
3503 };
3504
3505 static const struct wpa_cli_cmd wpa_cli_commands[] = {
3506 { "status", wpa_cli_cmd_status, NULL,
3507 cli_cmd_flag_none,
3508 "[verbose] = get current WPA/EAPOL/EAP status" },
3509 { "ifname", wpa_cli_cmd_ifname, NULL,
3510 cli_cmd_flag_none,
3511 "= get current interface name" },
3512 { "ping", wpa_cli_cmd_ping, NULL,
3513 cli_cmd_flag_none,
3514 "= pings wpa_supplicant" },
3515 { "relog", wpa_cli_cmd_relog, NULL,
3516 cli_cmd_flag_none,
3517 "= re-open log-file (allow rolling logs)" },
3518 { "note", wpa_cli_cmd_note, NULL,
3519 cli_cmd_flag_none,
3520 "<text> = add a note to wpa_supplicant debug log" },
3521 { "mib", wpa_cli_cmd_mib, NULL,
3522 cli_cmd_flag_none,
3523 "= get MIB variables (dot1x, dot11)" },
3524 { "help", wpa_cli_cmd_help, wpa_cli_complete_help,
3525 cli_cmd_flag_none,
3526 "[command] = show usage help" },
3527 { "interface", wpa_cli_cmd_interface, NULL,
3528 cli_cmd_flag_none,
3529 "[ifname] = show interfaces/select interface" },
3530 { "level", wpa_cli_cmd_level, NULL,
3531 cli_cmd_flag_none,
3532 "<debug level> = change debug level" },
3533 { "license", wpa_cli_cmd_license, NULL,
3534 cli_cmd_flag_none,
3535 "= show full wpa_cli license" },
3536 { "quit", wpa_cli_cmd_quit, NULL,
3537 cli_cmd_flag_none,
3538 "= exit wpa_cli" },
3539 { "set", wpa_cli_cmd_set, wpa_cli_complete_set,
3540 cli_cmd_flag_none,
3541 "= set variables (shows list of variables when run without "
3542 "arguments)" },
3543 { "dump", wpa_cli_cmd_dump, NULL,
3544 cli_cmd_flag_none,
3545 "= dump config variables" },
3546 { "get", wpa_cli_cmd_get, wpa_cli_complete_get,
3547 cli_cmd_flag_none,
3548 "<name> = get information" },
3549 { "driver_flags", wpa_cli_cmd_driver_flags, NULL,
3550 cli_cmd_flag_none,
3551 "= list driver flags" },
3552 { "logon", wpa_cli_cmd_logon, NULL,
3553 cli_cmd_flag_none,
3554 "= IEEE 802.1X EAPOL state machine logon" },
3555 { "logoff", wpa_cli_cmd_logoff, NULL,
3556 cli_cmd_flag_none,
3557 "= IEEE 802.1X EAPOL state machine logoff" },
3558 { "pmksa", wpa_cli_cmd_pmksa, NULL,
3559 cli_cmd_flag_none,
3560 "= show PMKSA cache" },
3561 { "pmksa_flush", wpa_cli_cmd_pmksa_flush, NULL,
3562 cli_cmd_flag_none,
3563 "= flush PMKSA cache entries" },
3564 #ifdef CONFIG_PMKSA_CACHE_EXTERNAL
3565 { "pmksa_get", wpa_cli_cmd_pmksa_get, NULL,
3566 cli_cmd_flag_none,
3567 "<network_id> = fetch all stored PMKSA cache entries" },
3568 { "pmksa_add", wpa_cli_cmd_pmksa_add, NULL,
3569 cli_cmd_flag_sensitive,
3570 "<network_id> <BSSID> <PMKID> <PMK> <reauth_time in seconds> <expiration in seconds> <akmp> <opportunistic> = store PMKSA cache entry from external storage" },
3571 #ifdef CONFIG_MESH
3572 { "mesh_pmksa_get", wpa_cli_mesh_cmd_pmksa_get, NULL,
3573 cli_cmd_flag_none,
3574 "<peer MAC address | any> = fetch all stored mesh PMKSA cache entries" },
3575 { "mesh_pmksa_add", wpa_cli_mesh_cmd_pmksa_add, NULL,
3576 cli_cmd_flag_sensitive,
3577 "<BSSID> <PMKID> <PMK> <expiration in seconds> = store mesh PMKSA cache entry from external storage" },
3578 #endif /* CONFIG_MESH */
3579 #endif /* CONFIG_PMKSA_CACHE_EXTERNAL */
3580 { "reassociate", wpa_cli_cmd_reassociate, NULL,
3581 cli_cmd_flag_none,
3582 "= force reassociation" },
3583 { "reattach", wpa_cli_cmd_reattach, NULL,
3584 cli_cmd_flag_none,
3585 "= force reassociation back to the same BSS" },
3586 { "preauthenticate", wpa_cli_cmd_preauthenticate, wpa_cli_complete_bss,
3587 cli_cmd_flag_none,
3588 "<BSSID> = force preauthentication" },
3589 { "identity", wpa_cli_cmd_identity, wpa_cli_complete_network_id,
3590 cli_cmd_flag_none,
3591 "<network id> <identity> = configure identity for an SSID" },
3592 #ifdef CONFIG_EAP_AUTH
3593 { "sim_kc", wpa_cli_cmd_sim_kc, wpa_cli_complete_network_id,
3594 cli_cmd_flag_none,
3595 "<network id> <sim_kc> = configure sim_kc for an SSID" },
3596 { "sim_sres", wpa_cli_cmd_sim_sres, wpa_cli_complete_network_id,
3597 cli_cmd_flag_none,
3598 "<network id> <sim_sres> = configure sim_sres for an SSID" },
3599 { "param_ki", wpa_cli_cmd_param_ki, wpa_cli_complete_network_id,
3600 cli_cmd_flag_none,
3601 "<network id> <param_ki> = configure param_ki for an SSID" },
3602 { "param_opc", wpa_cli_cmd_param_opc, wpa_cli_complete_network_id,
3603 cli_cmd_flag_none,
3604 "<network id> <param_opc> = configure param_opc for an SSID" },
3605 { "param_amf", wpa_cli_cmd_param_amf, wpa_cli_complete_network_id,
3606 cli_cmd_flag_none,
3607 "<network id> <param_amf> = configure param_amf for an SSID" },
3608 { "param_sqn", wpa_cli_cmd_param_sqn, wpa_cli_complete_network_id,
3609 cli_cmd_flag_none,
3610 "<network id> <param_sqn> = configure param_sqn for an SSID" },
3611 #endif
3612 { "password", wpa_cli_cmd_password, wpa_cli_complete_network_id,
3613 cli_cmd_flag_sensitive,
3614 "<network id> <password> = configure password for an SSID" },
3615 { "new_password", wpa_cli_cmd_new_password,
3616 wpa_cli_complete_network_id, cli_cmd_flag_sensitive,
3617 "<network id> <password> = change password for an SSID" },
3618 { "pin", wpa_cli_cmd_pin, wpa_cli_complete_network_id,
3619 cli_cmd_flag_sensitive,
3620 "<network id> <pin> = configure pin for an SSID" },
3621 { "otp", wpa_cli_cmd_otp, wpa_cli_complete_network_id,
3622 cli_cmd_flag_sensitive,
3623 "<network id> <password> = configure one-time-password for an SSID"
3624 },
3625 { "psk_passphrase", wpa_cli_cmd_psk_passphrase,
3626 wpa_cli_complete_network_id, cli_cmd_flag_sensitive,
3627 "<network id> <PSK/passphrase> = configure PSK/passphrase for an SSID" },
3628 { "passphrase", wpa_cli_cmd_passphrase, wpa_cli_complete_network_id,
3629 cli_cmd_flag_sensitive,
3630 "<network id> <passphrase> = configure private key passphrase\n"
3631 " for an SSID" },
3632 { "sim", wpa_cli_cmd_sim, wpa_cli_complete_network_id,
3633 cli_cmd_flag_sensitive,
3634 "<network id> <pin> = report SIM operation result" },
3635 { "bssid", wpa_cli_cmd_bssid, wpa_cli_complete_network_id,
3636 cli_cmd_flag_none,
3637 "<network id> <BSSID> = set preferred BSSID for an SSID" },
3638 { "bssid_ignore", wpa_cli_cmd_bssid_ignore, wpa_cli_complete_bss,
3639 cli_cmd_flag_none,
3640 "<BSSID> = add a BSSID to the list of temporarily ignored BSSs\n"
3641 "bssid_ignore clear = clear the list of temporarily ignored BSSIDs\n"
3642 "bssid_ignore = display the list of temporarily ignored BSSIDs" },
3643 { "blacklist", /* deprecated alias for bssid_ignore */
3644 wpa_cli_cmd_bssid_ignore, wpa_cli_complete_bss,
3645 cli_cmd_flag_none,
3646 "= deprecated alias for bssid_ignore" },
3647 { "log_level", wpa_cli_cmd_log_level, NULL,
3648 cli_cmd_flag_none,
3649 "<level> [<timestamp>] = update the log level/timestamp\n"
3650 "log_level = display the current log level and log options" },
3651 { "list_networks", wpa_cli_cmd_list_networks, NULL,
3652 cli_cmd_flag_none,
3653 "= list configured networks" },
3654 { "select_network", wpa_cli_cmd_select_network,
3655 wpa_cli_complete_network_id,
3656 cli_cmd_flag_none,
3657 "<network id> = select a network (disable others)" },
3658 { "enable_network", wpa_cli_cmd_enable_network,
3659 wpa_cli_complete_network_id,
3660 cli_cmd_flag_none,
3661 "<network id> = enable a network" },
3662 { "disable_network", wpa_cli_cmd_disable_network,
3663 wpa_cli_complete_network_id,
3664 cli_cmd_flag_none,
3665 "<network id> = disable a network" },
3666 { "add_network", wpa_cli_cmd_add_network, NULL,
3667 cli_cmd_flag_none,
3668 "= add a network" },
3669 { "remove_network", wpa_cli_cmd_remove_network,
3670 wpa_cli_complete_network_id,
3671 cli_cmd_flag_none,
3672 "<network id> = remove a network" },
3673 { "set_network", wpa_cli_cmd_set_network, wpa_cli_complete_network,
3674 cli_cmd_flag_sensitive,
3675 "<network id> <variable> <value> = set network variables (shows\n"
3676 " list of variables when run without arguments)" },
3677 { "get_network", wpa_cli_cmd_get_network, wpa_cli_complete_network,
3678 cli_cmd_flag_none,
3679 "<network id> <variable> = get network variables" },
3680 { "dup_network", wpa_cli_cmd_dup_network, wpa_cli_complete_dup_network,
3681 cli_cmd_flag_none,
3682 "<src network id> <dst network id> <variable> = duplicate network variables"
3683 },
3684 { "list_creds", wpa_cli_cmd_list_creds, NULL,
3685 cli_cmd_flag_none,
3686 "= list configured credentials" },
3687 { "add_cred", wpa_cli_cmd_add_cred, NULL,
3688 cli_cmd_flag_none,
3689 "= add a credential" },
3690 { "remove_cred", wpa_cli_cmd_remove_cred, NULL,
3691 cli_cmd_flag_none,
3692 "<cred id> = remove a credential" },
3693 { "set_cred", wpa_cli_cmd_set_cred, wpa_cli_complete_cred,
3694 cli_cmd_flag_sensitive,
3695 "<cred id> <variable> <value> = set credential variables" },
3696 { "get_cred", wpa_cli_cmd_get_cred, wpa_cli_complete_cred,
3697 cli_cmd_flag_none,
3698 "<cred id> <variable> = get credential variables" },
3699 { "save_config", wpa_cli_cmd_save_config, NULL,
3700 cli_cmd_flag_none,
3701 "= save the current configuration" },
3702 { "disconnect", wpa_cli_cmd_disconnect, NULL,
3703 cli_cmd_flag_none,
3704 "= disconnect and wait for reassociate/reconnect command before\n"
3705 " connecting" },
3706 { "reconnect", wpa_cli_cmd_reconnect, NULL,
3707 cli_cmd_flag_none,
3708 "= like reassociate, but only takes effect if already disconnected"
3709 },
3710 { "scan", wpa_cli_cmd_scan, NULL,
3711 cli_cmd_flag_none,
3712 "= request new BSS scan" },
3713 { "scan_results", wpa_cli_cmd_scan_results, NULL,
3714 cli_cmd_flag_none,
3715 "= get latest scan results" },
3716 { "abort_scan", wpa_cli_cmd_abort_scan, NULL,
3717 cli_cmd_flag_none,
3718 "= request ongoing scan to be aborted" },
3719 { "bss", wpa_cli_cmd_bss, wpa_cli_complete_bss,
3720 cli_cmd_flag_none,
3721 "<<idx> | <bssid>> = get detailed scan result info" },
3722 { "get_capability", wpa_cli_cmd_get_capability,
3723 wpa_cli_complete_get_capability, cli_cmd_flag_none,
3724 "<eap/pairwise/group/key_mgmt/proto/auth_alg/channels/freq/modes> "
3725 "= get capabilities" },
3726 { "reconfigure", wpa_cli_cmd_reconfigure, NULL,
3727 cli_cmd_flag_none,
3728 "= force wpa_supplicant to re-read its configuration file" },
3729 { "terminate", wpa_cli_cmd_terminate, NULL,
3730 cli_cmd_flag_none,
3731 "= terminate wpa_supplicant" },
3732 { "interface_add", wpa_cli_cmd_interface_add, NULL,
3733 cli_cmd_flag_none,
3734 "<ifname> <confname> <driver> <ctrl_interface> <driver_param>\n"
3735 " <bridge_name> <create> <type> = adds new interface, all "
3736 "parameters but\n"
3737 " <ifname> are optional. Supported types are station ('sta') and "
3738 "AP ('ap')" },
3739 { "interface_remove", wpa_cli_cmd_interface_remove, NULL,
3740 cli_cmd_flag_none,
3741 "<ifname> = removes the interface" },
3742 { "interface_list", wpa_cli_cmd_interface_list, NULL,
3743 cli_cmd_flag_none,
3744 "= list available interfaces" },
3745 { "ap_scan", wpa_cli_cmd_ap_scan, NULL,
3746 cli_cmd_flag_none,
3747 "<value> = set ap_scan parameter" },
3748 { "scan_interval", wpa_cli_cmd_scan_interval, NULL,
3749 cli_cmd_flag_none,
3750 "<value> = set scan_interval parameter (in seconds)" },
3751 { "bss_expire_age", wpa_cli_cmd_bss_expire_age, NULL,
3752 cli_cmd_flag_none,
3753 "<value> = set BSS expiration age parameter" },
3754 { "bss_expire_count", wpa_cli_cmd_bss_expire_count, NULL,
3755 cli_cmd_flag_none,
3756 "<value> = set BSS expiration scan count parameter" },
3757 { "bss_flush", wpa_cli_cmd_bss_flush, NULL,
3758 cli_cmd_flag_none,
3759 "<value> = set BSS flush age (0 by default)" },
3760 { "ft_ds", wpa_cli_cmd_ft_ds, wpa_cli_complete_bss,
3761 cli_cmd_flag_none,
3762 "<addr> = request over-the-DS FT with <addr>" },
3763 { "wps_pbc", wpa_cli_cmd_wps_pbc, wpa_cli_complete_bss,
3764 cli_cmd_flag_none,
3765 "[BSSID] = start Wi-Fi Protected Setup: Push Button Configuration" },
3766 { "wps_pin", wpa_cli_cmd_wps_pin, wpa_cli_complete_bss,
3767 cli_cmd_flag_sensitive,
3768 "<BSSID> [PIN] = start WPS PIN method (returns PIN, if not "
3769 "hardcoded)" },
3770 { "wps_check_pin", wpa_cli_cmd_wps_check_pin, NULL,
3771 cli_cmd_flag_sensitive,
3772 "<PIN> = verify PIN checksum" },
3773 { "wps_cancel", wpa_cli_cmd_wps_cancel, NULL, cli_cmd_flag_none,
3774 "Cancels the pending WPS operation" },
3775 #ifdef CONFIG_WPS_NFC
3776 { "wps_nfc", wpa_cli_cmd_wps_nfc, wpa_cli_complete_bss,
3777 cli_cmd_flag_none,
3778 "[BSSID] = start Wi-Fi Protected Setup: NFC" },
3779 { "wps_nfc_config_token", wpa_cli_cmd_wps_nfc_config_token, NULL,
3780 cli_cmd_flag_none,
3781 "<WPS|NDEF> = build configuration token" },
3782 { "wps_nfc_token", wpa_cli_cmd_wps_nfc_token, NULL,
3783 cli_cmd_flag_none,
3784 "<WPS|NDEF> = create password token" },
3785 { "wps_nfc_tag_read", wpa_cli_cmd_wps_nfc_tag_read, NULL,
3786 cli_cmd_flag_sensitive,
3787 "<hexdump of payload> = report read NFC tag with WPS data" },
3788 { "nfc_get_handover_req", wpa_cli_cmd_nfc_get_handover_req, NULL,
3789 cli_cmd_flag_none,
3790 "<NDEF> <WPS> = create NFC handover request" },
3791 { "nfc_get_handover_sel", wpa_cli_cmd_nfc_get_handover_sel, NULL,
3792 cli_cmd_flag_none,
3793 "<NDEF> <WPS> = create NFC handover select" },
3794 { "nfc_report_handover", wpa_cli_cmd_nfc_report_handover, NULL,
3795 cli_cmd_flag_none,
3796 "<role> <type> <hexdump of req> <hexdump of sel> = report completed "
3797 "NFC handover" },
3798 #endif /* CONFIG_WPS_NFC */
3799 { "wps_reg", wpa_cli_cmd_wps_reg, wpa_cli_complete_bss,
3800 cli_cmd_flag_sensitive,
3801 "<BSSID> <AP PIN> = start WPS Registrar to configure an AP" },
3802 { "wps_ap_pin", wpa_cli_cmd_wps_ap_pin, NULL,
3803 cli_cmd_flag_sensitive,
3804 "[params..] = enable/disable AP PIN" },
3805 { "wps_er_start", wpa_cli_cmd_wps_er_start, NULL,
3806 cli_cmd_flag_none,
3807 "[IP address] = start Wi-Fi Protected Setup External Registrar" },
3808 { "wps_er_stop", wpa_cli_cmd_wps_er_stop, NULL,
3809 cli_cmd_flag_none,
3810 "= stop Wi-Fi Protected Setup External Registrar" },
3811 { "wps_er_pin", wpa_cli_cmd_wps_er_pin, NULL,
3812 cli_cmd_flag_sensitive,
3813 "<UUID> <PIN> = add an Enrollee PIN to External Registrar" },
3814 { "wps_er_pbc", wpa_cli_cmd_wps_er_pbc, NULL,
3815 cli_cmd_flag_none,
3816 "<UUID> = accept an Enrollee PBC using External Registrar" },
3817 { "wps_er_learn", wpa_cli_cmd_wps_er_learn, NULL,
3818 cli_cmd_flag_sensitive,
3819 "<UUID> <PIN> = learn AP configuration" },
3820 { "wps_er_set_config", wpa_cli_cmd_wps_er_set_config, NULL,
3821 cli_cmd_flag_none,
3822 "<UUID> <network id> = set AP configuration for enrolling" },
3823 { "wps_er_config", wpa_cli_cmd_wps_er_config, NULL,
3824 cli_cmd_flag_sensitive,
3825 "<UUID> <PIN> <SSID> <auth> <encr> <key> = configure AP" },
3826 #ifdef CONFIG_WPS_NFC
3827 { "wps_er_nfc_config_token", wpa_cli_cmd_wps_er_nfc_config_token, NULL,
3828 cli_cmd_flag_none,
3829 "<WPS/NDEF> <UUID> = build NFC configuration token" },
3830 #endif /* CONFIG_WPS_NFC */
3831 { "ibss_rsn", wpa_cli_cmd_ibss_rsn, NULL,
3832 cli_cmd_flag_none,
3833 "<addr> = request RSN authentication with <addr> in IBSS" },
3834 #ifdef CONFIG_AP
3835 { "sta", wpa_cli_cmd_sta, wpa_cli_complete_sta,
3836 cli_cmd_flag_none,
3837 "<addr> = get information about an associated station (AP)" },
3838 { "all_sta", wpa_cli_cmd_all_sta, NULL,
3839 cli_cmd_flag_none,
3840 "= get information about all associated stations (AP)" },
3841 { "list_sta", wpa_cli_cmd_list_sta, NULL,
3842 cli_cmd_flag_none,
3843 "= list all stations (AP)" },
3844 { "deauthenticate", wpa_cli_cmd_deauthenticate,
3845 wpa_cli_complete_deauthenticate, cli_cmd_flag_none,
3846 "<addr> = deauthenticate a station" },
3847 { "disassociate", wpa_cli_cmd_disassociate,
3848 wpa_cli_complete_disassociate, cli_cmd_flag_none,
3849 "<addr> = disassociate a station" },
3850 { "chan_switch", wpa_cli_cmd_chanswitch, NULL,
3851 cli_cmd_flag_none,
3852 "<cs_count> <freq> [sec_channel_offset=] [center_freq1=]"
3853 " [center_freq2=] [bandwidth=] [blocktx] [ht|vht]"
3854 " = CSA parameters" },
3855 { "update_beacon", wpa_cli_cmd_update_beacon, NULL,
3856 cli_cmd_flag_none,
3857 "= update Beacon frame contents"},
3858 #endif /* CONFIG_AP */
3859 { "suspend", wpa_cli_cmd_suspend, NULL, cli_cmd_flag_none,
3860 "= notification of suspend/hibernate" },
3861 { "resume", wpa_cli_cmd_resume, NULL, cli_cmd_flag_none,
3862 "= notification of resume/thaw" },
3863 #ifdef CONFIG_TESTING_OPTIONS
3864 { "drop_sa", wpa_cli_cmd_drop_sa, NULL, cli_cmd_flag_none,
3865 "= drop SA without deauth/disassoc (test command)" },
3866 #endif /* CONFIG_TESTING_OPTIONS */
3867 { "roam", wpa_cli_cmd_roam, wpa_cli_complete_bss,
3868 cli_cmd_flag_none,
3869 "<addr> = roam to the specified BSS" },
3870 #ifdef CONFIG_MESH
3871 { "mesh_interface_add", wpa_cli_cmd_mesh_interface_add, NULL,
3872 cli_cmd_flag_none,
3873 "[ifname] = Create a new mesh interface" },
3874 { "mesh_group_add", wpa_cli_cmd_mesh_group_add, NULL,
3875 cli_cmd_flag_none,
3876 "<network id> = join a mesh network (disable others)" },
3877 { "mesh_group_remove", wpa_cli_cmd_mesh_group_remove, NULL,
3878 cli_cmd_flag_none,
3879 "<ifname> = Remove mesh group interface" },
3880 { "mesh_peer_remove", wpa_cli_cmd_mesh_peer_remove, NULL,
3881 cli_cmd_flag_none,
3882 "<addr> = Remove a mesh peer" },
3883 { "mesh_peer_add", wpa_cli_cmd_mesh_peer_add, NULL,
3884 cli_cmd_flag_none,
3885 "<addr> [duration=<seconds>] = Add a mesh peer" },
3886 { "mesh_link_probe", wpa_cli_cmd_mesh_link_probe, NULL,
3887 cli_cmd_flag_none,
3888 "<addr> [payload=<hex dump of payload>] = Probe a mesh link for a given peer by injecting a frame." },
3889 #endif /* CONFIG_MESH */
3890 #ifdef CONFIG_P2P
3891 { "p2p_find", wpa_cli_cmd_p2p_find, wpa_cli_complete_p2p_find,
3892 cli_cmd_flag_none,
3893 "[timeout] [type=*] = find P2P Devices for up-to timeout seconds" },
3894 { "p2p_stop_find", wpa_cli_cmd_p2p_stop_find, NULL, cli_cmd_flag_none,
3895 "= stop P2P Devices search" },
3896 { "p2p_asp_provision", wpa_cli_cmd_p2p_asp_provision, NULL,
3897 cli_cmd_flag_none,
3898 "<addr> adv_id=<adv_id> conncap=<conncap> [info=<infodata>] = provision with a P2P ASP Device" },
3899 { "p2p_asp_provision_resp", wpa_cli_cmd_p2p_asp_provision_resp, NULL,
3900 cli_cmd_flag_none,
3901 "<addr> adv_id=<adv_id> [role<conncap>] [info=<infodata>] = provision with a P2P ASP Device" },
3902 { "p2p_connect", wpa_cli_cmd_p2p_connect, wpa_cli_complete_p2p_connect,
3903 cli_cmd_flag_none,
3904 "<addr> <\"pbc\"|PIN> [ht40] = connect to a P2P Device" },
3905 { "p2p_listen", wpa_cli_cmd_p2p_listen, NULL, cli_cmd_flag_none,
3906 "[timeout] = listen for P2P Devices for up-to timeout seconds" },
3907 { "p2p_group_remove", wpa_cli_cmd_p2p_group_remove,
3908 wpa_cli_complete_p2p_group_remove, cli_cmd_flag_none,
3909 "<ifname> = remove P2P group interface (terminate group if GO)" },
3910 { "p2p_group_add", wpa_cli_cmd_p2p_group_add, NULL, cli_cmd_flag_none,
3911 "[ht40] = add a new P2P group (local end as GO)" },
3912 { "p2p_group_member", wpa_cli_cmd_p2p_group_member, NULL,
3913 cli_cmd_flag_none,
3914 "<dev_addr> = Get peer interface address on local GO using peer Device Address" },
3915 { "p2p_prov_disc", wpa_cli_cmd_p2p_prov_disc,
3916 wpa_cli_complete_p2p_peer, cli_cmd_flag_none,
3917 "<addr> <method> = request provisioning discovery" },
3918 { "p2p_get_passphrase", wpa_cli_cmd_p2p_get_passphrase, NULL,
3919 cli_cmd_flag_none,
3920 "= get the passphrase for a group (GO only)" },
3921 { "p2p_serv_disc_req", wpa_cli_cmd_p2p_serv_disc_req,
3922 wpa_cli_complete_p2p_peer, cli_cmd_flag_none,
3923 "<addr> <TLVs> = schedule service discovery request" },
3924 { "p2p_serv_disc_cancel_req", wpa_cli_cmd_p2p_serv_disc_cancel_req,
3925 NULL, cli_cmd_flag_none,
3926 "<id> = cancel pending service discovery request" },
3927 { "p2p_serv_disc_resp", wpa_cli_cmd_p2p_serv_disc_resp, NULL,
3928 cli_cmd_flag_none,
3929 "<freq> <addr> <dialog token> <TLVs> = service discovery response" },
3930 { "p2p_service_update", wpa_cli_cmd_p2p_service_update, NULL,
3931 cli_cmd_flag_none,
3932 "= indicate change in local services" },
3933 { "p2p_serv_disc_external", wpa_cli_cmd_p2p_serv_disc_external, NULL,
3934 cli_cmd_flag_none,
3935 "<external> = set external processing of service discovery" },
3936 { "p2p_service_flush", wpa_cli_cmd_p2p_service_flush, NULL,
3937 cli_cmd_flag_none,
3938 "= remove all stored service entries" },
3939 { "p2p_service_add", wpa_cli_cmd_p2p_service_add, NULL,
3940 cli_cmd_flag_none,
3941 "<bonjour|upnp|asp> <query|version> <response|service> = add a local "
3942 "service" },
3943 { "p2p_service_rep", wpa_cli_cmd_p2p_service_rep, NULL,
3944 cli_cmd_flag_none,
3945 "asp <auto> <adv_id> <svc_state> <svc_string> [<svc_info>] = replace "
3946 "local ASP service" },
3947 { "p2p_service_del", wpa_cli_cmd_p2p_service_del, NULL,
3948 cli_cmd_flag_none,
3949 "<bonjour|upnp> <query|version> [|service] = remove a local "
3950 "service" },
3951 { "p2p_reject", wpa_cli_cmd_p2p_reject, wpa_cli_complete_p2p_peer,
3952 cli_cmd_flag_none,
3953 "<addr> = reject connection attempts from a specific peer" },
3954 { "p2p_invite", wpa_cli_cmd_p2p_invite, NULL,
3955 cli_cmd_flag_none,
3956 "<cmd> [peer=addr] = invite peer" },
3957 { "p2p_peers", wpa_cli_cmd_p2p_peers, NULL, cli_cmd_flag_none,
3958 "[discovered] = list known (optionally, only fully discovered) P2P "
3959 "peers" },
3960 { "p2p_peer", wpa_cli_cmd_p2p_peer, wpa_cli_complete_p2p_peer,
3961 cli_cmd_flag_none,
3962 "<address> = show information about known P2P peer" },
3963 { "p2p_set", wpa_cli_cmd_p2p_set, wpa_cli_complete_p2p_set,
3964 cli_cmd_flag_none,
3965 "<field> <value> = set a P2P parameter" },
3966 { "p2p_flush", wpa_cli_cmd_p2p_flush, NULL, cli_cmd_flag_none,
3967 "= flush P2P state" },
3968 { "p2p_cancel", wpa_cli_cmd_p2p_cancel, NULL, cli_cmd_flag_none,
3969 "= cancel P2P group formation" },
3970 { "p2p_unauthorize", wpa_cli_cmd_p2p_unauthorize,
3971 wpa_cli_complete_p2p_peer, cli_cmd_flag_none,
3972 "<address> = unauthorize a peer" },
3973 { "p2p_presence_req", wpa_cli_cmd_p2p_presence_req, NULL,
3974 cli_cmd_flag_none,
3975 "[<duration> <interval>] [<duration> <interval>] = request GO "
3976 "presence" },
3977 { "p2p_ext_listen", wpa_cli_cmd_p2p_ext_listen, NULL,
3978 cli_cmd_flag_none,
3979 "[<period> <interval>] = set extended listen timing" },
3980 { "p2p_remove_client", wpa_cli_cmd_p2p_remove_client,
3981 wpa_cli_complete_p2p_peer, cli_cmd_flag_none,
3982 "<address|iface=address> = remove a peer from all groups" },
3983 #endif /* CONFIG_P2P */
3984 { "vendor_elem_add", wpa_cli_cmd_vendor_elem_add, NULL,
3985 cli_cmd_flag_none,
3986 "<frame id> <hexdump of elem(s)> = add vendor specific IEs to frame(s)\n"
3987 VENDOR_ELEM_FRAME_ID },
3988 { "vendor_elem_get", wpa_cli_cmd_vendor_elem_get, NULL,
3989 cli_cmd_flag_none,
3990 "<frame id> = get vendor specific IE(s) to frame(s)\n"
3991 VENDOR_ELEM_FRAME_ID },
3992 { "vendor_elem_remove", wpa_cli_cmd_vendor_elem_remove, NULL,
3993 cli_cmd_flag_none,
3994 "<frame id> <hexdump of elem(s)> = remove vendor specific IE(s) in frame(s)\n"
3995 VENDOR_ELEM_FRAME_ID },
3996 #ifdef CONFIG_WIFI_DISPLAY
3997 { "wfd_subelem_set", wpa_cli_cmd_wfd_subelem_set, NULL,
3998 cli_cmd_flag_none,
3999 "<subelem> [contents] = set Wi-Fi Display subelement" },
4000 { "wfd_subelem_get", wpa_cli_cmd_wfd_subelem_get, NULL,
4001 cli_cmd_flag_none,
4002 "<subelem> = get Wi-Fi Display subelement" },
4003 #endif /* CONFIG_WIFI_DISPLAY */
4004 #ifdef CONFIG_INTERWORKING
4005 { "fetch_anqp", wpa_cli_cmd_fetch_anqp, NULL, cli_cmd_flag_none,
4006 "= fetch ANQP information for all APs" },
4007 { "stop_fetch_anqp", wpa_cli_cmd_stop_fetch_anqp, NULL,
4008 cli_cmd_flag_none,
4009 "= stop fetch_anqp operation" },
4010 { "interworking_select", wpa_cli_cmd_interworking_select, NULL,
4011 cli_cmd_flag_none,
4012 "[auto] = perform Interworking network selection" },
4013 { "interworking_connect", wpa_cli_cmd_interworking_connect,
4014 wpa_cli_complete_bss, cli_cmd_flag_none,
4015 "<BSSID> = connect using Interworking credentials" },
4016 { "interworking_add_network", wpa_cli_cmd_interworking_add_network,
4017 wpa_cli_complete_bss, cli_cmd_flag_none,
4018 "<BSSID> = connect using Interworking credentials" },
4019 { "anqp_get", wpa_cli_cmd_anqp_get, wpa_cli_complete_bss,
4020 cli_cmd_flag_none,
4021 "<addr> <info id>[,<info id>]... = request ANQP information" },
4022 { "gas_request", wpa_cli_cmd_gas_request, wpa_cli_complete_bss,
4023 cli_cmd_flag_none,
4024 "<addr> <AdvProtoID> [QueryReq] = GAS request" },
4025 { "gas_response_get", wpa_cli_cmd_gas_response_get,
4026 wpa_cli_complete_bss, cli_cmd_flag_none,
4027 "<addr> <dialog token> [start,len] = Fetch last GAS response" },
4028 #endif /* CONFIG_INTERWORKING */
4029 #ifdef CONFIG_HS20
4030 { "hs20_anqp_get", wpa_cli_cmd_hs20_anqp_get, wpa_cli_complete_bss,
4031 cli_cmd_flag_none,
4032 "<addr> <subtype>[,<subtype>]... = request HS 2.0 ANQP information"
4033 },
4034 { "nai_home_realm_list", wpa_cli_cmd_get_nai_home_realm_list,
4035 wpa_cli_complete_bss, cli_cmd_flag_none,
4036 "<addr> <home realm> = get HS20 nai home realm list" },
4037 { "hs20_icon_request", wpa_cli_cmd_hs20_icon_request,
4038 wpa_cli_complete_bss, cli_cmd_flag_none,
4039 "<addr> <icon name> = get Hotspot 2.0 OSU icon" },
4040 { "fetch_osu", wpa_cli_cmd_fetch_osu, NULL, cli_cmd_flag_none,
4041 "= fetch OSU provider information from all APs" },
4042 { "cancel_fetch_osu", wpa_cli_cmd_cancel_fetch_osu, NULL,
4043 cli_cmd_flag_none,
4044 "= cancel fetch_osu command" },
4045 #endif /* CONFIG_HS20 */
4046 { "sta_autoconnect", wpa_cli_cmd_sta_autoconnect, NULL,
4047 cli_cmd_flag_none,
4048 "<0/1> = disable/enable automatic reconnection" },
4049 { "tdls_discover", wpa_cli_cmd_tdls_discover, NULL,
4050 cli_cmd_flag_none,
4051 "<addr> = request TDLS discovery with <addr>" },
4052 { "tdls_setup", wpa_cli_cmd_tdls_setup, NULL,
4053 cli_cmd_flag_none,
4054 "<addr> = request TDLS setup with <addr>" },
4055 { "tdls_teardown", wpa_cli_cmd_tdls_teardown, NULL,
4056 cli_cmd_flag_none,
4057 "<addr> = tear down TDLS with <addr>" },
4058 { "tdls_link_status", wpa_cli_cmd_tdls_link_status, NULL,
4059 cli_cmd_flag_none,
4060 "<addr> = TDLS link status with <addr>" },
4061 { "wmm_ac_addts", wpa_cli_cmd_wmm_ac_addts, NULL,
4062 cli_cmd_flag_none,
4063 "<uplink/downlink/bidi> <tsid=0..7> <up=0..7> [nominal_msdu_size=#] "
4064 "[mean_data_rate=#] [min_phy_rate=#] [sba=#] [fixed_nominal_msdu] "
4065 "= add WMM-AC traffic stream" },
4066 { "wmm_ac_delts", wpa_cli_cmd_wmm_ac_delts, NULL,
4067 cli_cmd_flag_none,
4068 "<tsid> = delete WMM-AC traffic stream" },
4069 { "wmm_ac_status", wpa_cli_cmd_wmm_ac_status, NULL,
4070 cli_cmd_flag_none,
4071 "= show status for Wireless Multi-Media Admission-Control" },
4072 { "tdls_chan_switch", wpa_cli_cmd_tdls_chan_switch, NULL,
4073 cli_cmd_flag_none,
4074 "<addr> <oper class> <freq> [sec_channel_offset=] [center_freq1=] "
4075 "[center_freq2=] [bandwidth=] [ht|vht] = enable channel switching "
4076 "with TDLS peer" },
4077 { "tdls_cancel_chan_switch", wpa_cli_cmd_tdls_cancel_chan_switch, NULL,
4078 cli_cmd_flag_none,
4079 "<addr> = disable channel switching with TDLS peer <addr>" },
4080 { "signal_poll", wpa_cli_cmd_signal_poll, NULL,
4081 cli_cmd_flag_none,
4082 "= get signal parameters" },
4083 { "signal_monitor", wpa_cli_cmd_signal_monitor, NULL,
4084 cli_cmd_flag_none,
4085 "= set signal monitor parameters" },
4086 { "pktcnt_poll", wpa_cli_cmd_pktcnt_poll, NULL,
4087 cli_cmd_flag_none,
4088 "= get TX/RX packet counters" },
4089 { "reauthenticate", wpa_cli_cmd_reauthenticate, NULL,
4090 cli_cmd_flag_none,
4091 "= trigger IEEE 802.1X/EAPOL reauthentication" },
4092 #ifdef CONFIG_AUTOSCAN
4093 { "autoscan", wpa_cli_cmd_autoscan, NULL, cli_cmd_flag_none,
4094 "[params] = Set or unset (if none) autoscan parameters" },
4095 #endif /* CONFIG_AUTOSCAN */
4096 #ifdef CONFIG_WNM
4097 { "wnm_sleep", wpa_cli_cmd_wnm_sleep, NULL, cli_cmd_flag_none,
4098 "<enter/exit> [interval=#] = enter/exit WNM-Sleep mode" },
4099 { "wnm_bss_query", wpa_cli_cmd_wnm_bss_query, NULL, cli_cmd_flag_none,
4100 "<query reason> [list]"
4101 " [neighbor=<BSSID>,<BSSID information>,<operating class>,<channel number>,<PHY type>[,<hexdump of optional subelements>]"
4102 " = Send BSS Transition Management Query" },
4103 #endif /* CONFIG_WNM */
4104 { "raw", wpa_cli_cmd_raw, NULL, cli_cmd_flag_sensitive,
4105 "<params..> = Sent unprocessed command" },
4106 { "flush", wpa_cli_cmd_flush, NULL, cli_cmd_flag_none,
4107 "= flush wpa_supplicant state" },
4108 #ifdef ANDROID
4109 { "driver", wpa_cli_cmd_driver, NULL, cli_cmd_flag_none,
4110 "<command> = driver private commands" },
4111 #endif /* ANDROID */
4112 { "radio_work", wpa_cli_cmd_radio_work, NULL, cli_cmd_flag_none,
4113 "= radio_work <show/add/done>" },
4114 { "vendor", wpa_cli_cmd_vendor, NULL, cli_cmd_flag_none,
4115 "<vendor id> <command id> [<hex formatted command argument>] = Send vendor command"
4116 },
4117 { "neighbor_rep_request",
4118 wpa_cli_cmd_neighbor_rep_request, NULL, cli_cmd_flag_none,
4119 "[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)"
4120 },
4121 { "twt_setup",
4122 wpa_cli_cmd_twt_setup, NULL, cli_cmd_flag_none,
4123 "[dialog=<token>] [exponent=<exponent>] [mantissa=<mantissa>] [min_twt=<Min TWT>] [setup_cmd=<setup-cmd>] [twt=<u64>] [requestor=0|1] [trigger=0|1] [implicit=0|1] [flow_type=0|1] [flow_id=<3-bit-id>] [protection=0|1] [twt_channel=<twt chanel id>] [control=<control-u8>] = Send TWT Setup frame"
4124 },
4125 { "twt_teardown",
4126 wpa_cli_cmd_twt_teardown, NULL, cli_cmd_flag_none,
4127 "[flags=<value>] = Send TWT Teardown frame"
4128 },
4129 { "erp_flush", wpa_cli_cmd_erp_flush, NULL, cli_cmd_flag_none,
4130 "= flush ERP keys" },
4131 { "mac_rand_scan",
4132 wpa_cli_cmd_mac_rand_scan, NULL, cli_cmd_flag_none,
4133 "<scan|sched|pno|all> enable=<0/1> [addr=mac-address "
4134 "mask=mac-address-mask] = scan MAC randomization"
4135 },
4136 { "get_pref_freq_list", wpa_cli_cmd_get_pref_freq_list, NULL,
4137 cli_cmd_flag_none,
4138 "<interface type> = retrieve preferred freq list for the specified interface type" },
4139 #if defined(CONFIG_OPEN_HARMONY_PATCH) && defined(CONFIG_HILINK_OKC_STA)
4140 { "enable_hilink", wpa_cli_cmd_enable_hilink, NULL,
4141 cli_cmd_flag_none, "enable=<0/1> bssid=<mac-address>" },
4142 #endif
4143 { "p2p_lo_start", wpa_cli_cmd_p2p_lo_start, NULL,
4144 cli_cmd_flag_none,
4145 "<freq> <period> <interval> <count> = start P2P listen offload" },
4146 { "p2p_lo_stop", wpa_cli_cmd_p2p_lo_stop, NULL,
4147 cli_cmd_flag_none,
4148 "= stop P2P listen offload" },
4149 #ifdef CONFIG_MAGICLINK
4150 { "magiclink_connect", wpa_cli_cmd_magiclink_connect, NULL,
4151 cli_cmd_flag_none,
4152 "= magiclink connect exist p2p group" },
4153 #endif
4154 #ifdef CONFIG_DPP
4155 { "dpp_qr_code", wpa_cli_cmd_dpp_qr_code, NULL, cli_cmd_flag_none,
4156 "report a scanned DPP URI from a QR Code" },
4157 { "dpp_bootstrap_gen", wpa_cli_cmd_dpp_bootstrap_gen, NULL,
4158 cli_cmd_flag_sensitive,
4159 "type=<qrcode> [chan=..] [mac=..] [info=..] [curve=..] [key=..] = generate DPP bootstrap information" },
4160 { "dpp_bootstrap_remove", wpa_cli_cmd_dpp_bootstrap_remove, NULL,
4161 cli_cmd_flag_none,
4162 "*|<id> = remove DPP bootstrap information" },
4163 { "dpp_bootstrap_get_uri", wpa_cli_cmd_dpp_bootstrap_get_uri, NULL,
4164 cli_cmd_flag_none,
4165 "<id> = get DPP bootstrap URI" },
4166 { "dpp_bootstrap_info", wpa_cli_cmd_dpp_bootstrap_info, NULL,
4167 cli_cmd_flag_none,
4168 "<id> = show DPP bootstrap information" },
4169 { "dpp_bootstrap_set", wpa_cli_cmd_dpp_bootstrap_set, NULL,
4170 cli_cmd_flag_none,
4171 "<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" },
4172 { "dpp_auth_init", wpa_cli_cmd_dpp_auth_init, NULL, cli_cmd_flag_none,
4173 "peer=<id> [own=<id>] = initiate DPP bootstrapping" },
4174 { "dpp_listen", wpa_cli_cmd_dpp_listen, NULL, cli_cmd_flag_none,
4175 "<freq in MHz> = start DPP listen" },
4176 { "dpp_stop_listen", wpa_cli_cmd_dpp_stop_listen, NULL,
4177 cli_cmd_flag_none,
4178 "= stop DPP listen" },
4179 { "dpp_configurator_add", wpa_cli_cmd_dpp_configurator_add, NULL,
4180 cli_cmd_flag_sensitive,
4181 "[curve=..] [key=..] = add DPP configurator" },
4182 { "dpp_configurator_remove", wpa_cli_cmd_dpp_configurator_remove, NULL,
4183 cli_cmd_flag_none,
4184 "*|<id> = remove DPP configurator" },
4185 { "dpp_configurator_get_key", wpa_cli_cmd_dpp_configurator_get_key,
4186 NULL, cli_cmd_flag_none,
4187 "<id> = Get DPP configurator's private key" },
4188 { "dpp_configurator_sign", wpa_cli_cmd_dpp_configurator_sign, NULL,
4189 cli_cmd_flag_none,
4190 "conf=<role> configurator=<id> = generate self DPP configuration" },
4191 { "dpp_pkex_add", wpa_cli_cmd_dpp_pkex_add, NULL,
4192 cli_cmd_flag_sensitive,
4193 "add PKEX code" },
4194 { "dpp_pkex_remove", wpa_cli_cmd_dpp_pkex_remove, NULL,
4195 cli_cmd_flag_none,
4196 "*|<id> = remove DPP pkex information" },
4197 #ifdef CONFIG_DPP2
4198 { "dpp_controller_start", wpa_cli_cmd_dpp_controller_start, NULL,
4199 cli_cmd_flag_none,
4200 "[tcp_port=<port>] [role=..] = start DPP controller" },
4201 { "dpp_controller_stop", wpa_cli_cmd_dpp_controller_stop, NULL,
4202 cli_cmd_flag_none,
4203 "= stop DPP controller" },
4204 { "dpp_chirp", wpa_cli_cmd_dpp_chirp, NULL,
4205 cli_cmd_flag_none,
4206 "own=<BI ID> iter=<count> = start DPP chirp" },
4207 { "dpp_stop_chirp", wpa_cli_cmd_dpp_stop_chirp, NULL,
4208 cli_cmd_flag_none,
4209 "= stop DPP chirp" },
4210 #endif /* CONFIG_DPP2 */
4211 #endif /* CONFIG_DPP */
4212 { "all_bss", wpa_cli_cmd_all_bss, NULL, cli_cmd_flag_none,
4213 "= list all BSS entries (scan results)" },
4214 #ifdef CONFIG_PASN
4215 { "pasn_auth_start", wpa_cli_cmd_pasn_auth_start, NULL,
4216 cli_cmd_flag_none,
4217 "bssid=<BSSID> akmp=<WPA key mgmt> cipher=<WPA cipher> group=<group> nid=<network id> = Start PASN authentication" },
4218 { "pasn_auth_stop", wpa_cli_cmd_pasn_auth_stop, NULL,
4219 cli_cmd_flag_none,
4220 "= Stop PASN authentication" },
4221 { "ptksa_cache_list", wpa_cli_cmd_ptksa_cache_list, NULL,
4222 cli_cmd_flag_none,
4223 "= Get the PTKSA Cache" },
4224 { "pasn_deauth", wpa_cli_cmd_pasn_deauth, NULL,
4225 cli_cmd_flag_none,
4226 "bssid=<BSSID> = Remove PASN PTKSA state" },
4227 #endif /* CONFIG_PASN */
4228 { "mscs", wpa_cli_cmd_mscs, NULL,
4229 cli_cmd_flag_none,
4230 "<add|remove|change> [up_bitmap=<hex byte>] [up_limit=<integer>] [stream_timeout=<in TUs>] [frame_classifier=<hex bytes>] = Configure MSCS request" },
4231 { "scs", wpa_cli_cmd_scs, NULL,
4232 cli_cmd_flag_none,
4233 "[scs_id=<decimal number>] <add|remove|change> [scs_up=<0-7>] [classifier_type=<4|10>] [classifier params based on classifier type] [tclas_processing=<0|1>] [scs_id=<decimal number>] ... = Send SCS request" },
4234 { "dscp_resp", wpa_cli_cmd_dscp_resp, NULL,
4235 cli_cmd_flag_none,
4236 "<[reset]>/<[solicited] [policy_id=1 status=0...]> [more] = Send DSCP response" },
4237 { "dscp_query", wpa_cli_cmd_dscp_query, NULL,
4238 cli_cmd_flag_none,
4239 "wildcard/domain_name=<string> = Send DSCP Query" },
4240 #ifdef CONFIG_VENDOR_EXT
4241 WPA_VENDOR_EXT_CMD_LIST,
4242 #endif
4243 #ifdef CONFIG_MLD_PATCH_EXT
4244 { "mlo_status", wpa_cli_cmd_mlo_status, NULL,
4245 cli_cmd_flag_none,
4246 "= get MLO status" },
4247 { "mlo_signal_poll", wpa_cli_cmd_mlo_signal_poll, NULL,
4248 cli_cmd_flag_none,
4249 "= get mlo signal parameters" },
4250 #endif
4251 { NULL, NULL, NULL, cli_cmd_flag_none, NULL }
4252 };
4253
4254
4255 /*
4256 * Prints command usage, lines are padded with the specified string.
4257 */
print_cmd_help(const struct wpa_cli_cmd * cmd,const char * pad)4258 static void print_cmd_help(const struct wpa_cli_cmd *cmd, const char *pad)
4259 {
4260 char c;
4261 size_t n;
4262
4263 printf("%s%s ", pad, cmd->cmd);
4264 for (n = 0; (c = cmd->usage[n]); n++) {
4265 printf("%c", c);
4266 if (c == '\n')
4267 printf("%s", pad);
4268 }
4269 printf("\n");
4270 }
4271
4272
print_help(const char * cmd)4273 static void print_help(const char *cmd)
4274 {
4275 int n;
4276 printf("commands:\n");
4277 for (n = 0; wpa_cli_commands[n].cmd; n++) {
4278 if (cmd == NULL || str_starts(wpa_cli_commands[n].cmd, cmd))
4279 print_cmd_help(&wpa_cli_commands[n], " ");
4280 }
4281 }
4282
4283
wpa_cli_edit_filter_history_cb(void * ctx,const char * cmd)4284 static int wpa_cli_edit_filter_history_cb(void *ctx, const char *cmd)
4285 {
4286 const char *c, *delim;
4287 int n;
4288 size_t len;
4289
4290 delim = os_strchr(cmd, ' ');
4291 if (delim)
4292 len = delim - cmd;
4293 else
4294 len = os_strlen(cmd);
4295
4296 for (n = 0; (c = wpa_cli_commands[n].cmd); n++) {
4297 if (os_strncasecmp(cmd, c, len) == 0 && len == os_strlen(c))
4298 return (wpa_cli_commands[n].flags &
4299 cli_cmd_flag_sensitive);
4300 }
4301 return 0;
4302 }
4303
4304
wpa_list_cmd_list(void)4305 static char ** wpa_list_cmd_list(void)
4306 {
4307 char **res;
4308 int i, count;
4309 struct cli_txt_entry *e;
4310
4311 count = ARRAY_SIZE(wpa_cli_commands);
4312 count += dl_list_len(&p2p_groups);
4313 count += dl_list_len(&ifnames);
4314 res = os_calloc(count + 1, sizeof(char *));
4315 if (res == NULL)
4316 return NULL;
4317
4318 for (i = 0; wpa_cli_commands[i].cmd; i++) {
4319 res[i] = os_strdup(wpa_cli_commands[i].cmd);
4320 if (res[i] == NULL)
4321 break;
4322 }
4323
4324 dl_list_for_each(e, &p2p_groups, struct cli_txt_entry, list) {
4325 size_t len = 8 + os_strlen(e->txt);
4326 res[i] = os_malloc(len);
4327 if (res[i] == NULL)
4328 break;
4329 os_snprintf(res[i], len, "ifname=%s", e->txt);
4330 i++;
4331 }
4332
4333 dl_list_for_each(e, &ifnames, struct cli_txt_entry, list) {
4334 res[i] = os_strdup(e->txt);
4335 if (res[i] == NULL)
4336 break;
4337 i++;
4338 }
4339
4340 return res;
4341 }
4342
4343
wpa_cli_cmd_completion(const char * cmd,const char * str,int pos)4344 static char ** wpa_cli_cmd_completion(const char *cmd, const char *str,
4345 int pos)
4346 {
4347 int i;
4348
4349 for (i = 0; wpa_cli_commands[i].cmd; i++) {
4350 if (os_strcasecmp(wpa_cli_commands[i].cmd, cmd) == 0) {
4351 if (wpa_cli_commands[i].completion)
4352 return wpa_cli_commands[i].completion(str,
4353 pos);
4354 edit_clear_line();
4355 printf("\r%s\n", wpa_cli_commands[i].usage);
4356 edit_redraw();
4357 break;
4358 }
4359 }
4360
4361 return NULL;
4362 }
4363
4364
wpa_cli_edit_completion_cb(void * ctx,const char * str,int pos)4365 static char ** wpa_cli_edit_completion_cb(void *ctx, const char *str, int pos)
4366 {
4367 char **res;
4368 const char *end;
4369 char *cmd;
4370
4371 if (pos > 7 && os_strncasecmp(str, "IFNAME=", 7) == 0) {
4372 end = os_strchr(str, ' ');
4373 if (end && pos > end - str) {
4374 pos -= end - str + 1;
4375 str = end + 1;
4376 }
4377 }
4378
4379 end = os_strchr(str, ' ');
4380 if (end == NULL || str + pos < end)
4381 return wpa_list_cmd_list();
4382
4383 cmd = os_malloc(pos + 1);
4384 if (cmd == NULL)
4385 return NULL;
4386 os_memcpy(cmd, str, pos);
4387 cmd[end - str] = '\0';
4388 res = wpa_cli_cmd_completion(cmd, str, pos);
4389 os_free(cmd);
4390 return res;
4391 }
4392
4393
wpa_request(struct wpa_ctrl * ctrl,int argc,char * argv[])4394 static int wpa_request(struct wpa_ctrl *ctrl, int argc, char *argv[])
4395 {
4396 const struct wpa_cli_cmd *cmd, *match = NULL;
4397 int count;
4398 int ret = 0;
4399
4400 if (argc > 1 && os_strncasecmp(argv[0], "IFNAME=", 7) == 0) {
4401 ifname_prefix = argv[0] + 7;
4402 argv = &argv[1];
4403 argc--;
4404 } else
4405 ifname_prefix = NULL;
4406
4407 if (argc == 0)
4408 return -1;
4409
4410 count = 0;
4411 cmd = wpa_cli_commands;
4412 while (cmd->cmd) {
4413 if (os_strncasecmp(cmd->cmd, argv[0], os_strlen(argv[0])) == 0)
4414 {
4415 match = cmd;
4416 if (os_strcasecmp(cmd->cmd, argv[0]) == 0) {
4417 /* we have an exact match */
4418 count = 1;
4419 break;
4420 }
4421 count++;
4422 }
4423 cmd++;
4424 }
4425
4426 if (count > 1) {
4427 printf("Ambiguous command '%s'; possible commands:", argv[0]);
4428 cmd = wpa_cli_commands;
4429 while (cmd->cmd) {
4430 if (os_strncasecmp(cmd->cmd, argv[0],
4431 os_strlen(argv[0])) == 0) {
4432 printf(" %s", cmd->cmd);
4433 }
4434 cmd++;
4435 }
4436 printf("\n");
4437 ret = 1;
4438 } else if (count == 0) {
4439 printf("Unknown command '%s'\n", argv[0]);
4440 ret = 1;
4441 } else {
4442 ret = match->handler(ctrl, argc - 1, &argv[1]);
4443 }
4444
4445 return ret;
4446 }
4447
4448
wpa_cli_exec(const char * program,const char * arg1,const char * arg2)4449 static int wpa_cli_exec(const char *program, const char *arg1,
4450 const char *arg2)
4451 {
4452 char *arg;
4453 size_t len;
4454 int res;
4455
4456 /* If no interface is specified, set the global */
4457 if (!arg1)
4458 arg1 = "global";
4459
4460 len = os_strlen(arg1) + os_strlen(arg2) + 2;
4461 arg = os_malloc(len);
4462 if (arg == NULL)
4463 return -1;
4464 os_snprintf(arg, len, "%s %s", arg1, arg2);
4465 res = os_exec(program, arg, 1);
4466 os_free(arg);
4467
4468 return res;
4469 }
4470
4471
wpa_cli_action_process(const char * msg)4472 static void wpa_cli_action_process(const char *msg)
4473 {
4474 const char *pos;
4475 char *copy = NULL, *id, *pos2;
4476 const char *ifname = ctrl_ifname;
4477 char ifname_buf[100];
4478
4479 if (eloop_terminated())
4480 return;
4481
4482 pos = msg;
4483 if (os_strncmp(pos, "IFNAME=", 7) == 0) {
4484 const char *end;
4485 end = os_strchr(pos + 7, ' ');
4486 if (end && (unsigned int) (end - pos) < sizeof(ifname_buf)) {
4487 pos += 7;
4488 os_memcpy(ifname_buf, pos, end - pos);
4489 ifname_buf[end - pos] = '\0';
4490 ifname = ifname_buf;
4491 pos = end + 1;
4492 }
4493 }
4494 if (*pos == '<') {
4495 const char *prev = pos;
4496 /* skip priority */
4497 pos = os_strchr(pos, '>');
4498 if (pos)
4499 pos++;
4500 else
4501 pos = prev;
4502 }
4503
4504 if (str_starts(pos, WPA_EVENT_CONNECTED)) {
4505 int new_id = -1;
4506 os_unsetenv("WPA_ID");
4507 os_unsetenv("WPA_ID_STR");
4508 os_unsetenv("WPA_CTRL_DIR");
4509
4510 pos = os_strstr(pos, "[id=");
4511 if (pos)
4512 copy = os_strdup(pos + 4);
4513
4514 if (copy) {
4515 pos2 = id = copy;
4516 while (*pos2 && *pos2 != ' ')
4517 pos2++;
4518 *pos2++ = '\0';
4519 new_id = atoi(id);
4520 os_setenv("WPA_ID", id, 1);
4521 while (*pos2 && *pos2 != '=')
4522 pos2++;
4523 if (*pos2 == '=')
4524 pos2++;
4525 id = pos2;
4526 while (*pos2 && *pos2 != ']')
4527 pos2++;
4528 *pos2 = '\0';
4529 os_setenv("WPA_ID_STR", id, 1);
4530 os_free(copy);
4531 }
4532
4533 os_setenv("WPA_CTRL_DIR", ctrl_iface_dir, 1);
4534
4535 if (wpa_cli_connected <= 0 || new_id != wpa_cli_last_id) {
4536 wpa_cli_connected = 1;
4537 wpa_cli_last_id = new_id;
4538 wpa_cli_exec(action_file, ifname, "CONNECTED");
4539 }
4540 } else if (str_starts(pos, WPA_EVENT_DISCONNECTED)) {
4541 if (wpa_cli_connected) {
4542 wpa_cli_connected = 0;
4543 wpa_cli_exec(action_file, ifname, "DISCONNECTED");
4544 }
4545 } else if (str_starts(pos, WPA_EVENT_CHANNEL_SWITCH_STARTED)) {
4546 wpa_cli_exec(action_file, ctrl_ifname, pos);
4547 } else if (str_starts(pos, AP_EVENT_ENABLED)) {
4548 wpa_cli_exec(action_file, ctrl_ifname, pos);
4549 } else if (str_starts(pos, AP_EVENT_DISABLED)) {
4550 wpa_cli_exec(action_file, ctrl_ifname, pos);
4551 } else if (str_starts(pos, MESH_GROUP_STARTED)) {
4552 wpa_cli_exec(action_file, ctrl_ifname, pos);
4553 } else if (str_starts(pos, MESH_GROUP_REMOVED)) {
4554 wpa_cli_exec(action_file, ctrl_ifname, pos);
4555 } else if (str_starts(pos, MESH_PEER_CONNECTED)) {
4556 wpa_cli_exec(action_file, ctrl_ifname, pos);
4557 } else if (str_starts(pos, MESH_PEER_DISCONNECTED)) {
4558 wpa_cli_exec(action_file, ctrl_ifname, pos);
4559 } else if (str_starts(pos, P2P_EVENT_GROUP_STARTED)) {
4560 wpa_cli_exec(action_file, ifname, pos);
4561 } else if (str_starts(pos, P2P_EVENT_GROUP_REMOVED)) {
4562 wpa_cli_exec(action_file, ifname, pos);
4563 } else if (str_starts(pos, P2P_EVENT_CROSS_CONNECT_ENABLE)) {
4564 wpa_cli_exec(action_file, ifname, pos);
4565 } else if (str_starts(pos, P2P_EVENT_CROSS_CONNECT_DISABLE)) {
4566 wpa_cli_exec(action_file, ifname, pos);
4567 } else if (str_starts(pos, P2P_EVENT_GO_NEG_FAILURE)) {
4568 wpa_cli_exec(action_file, ifname, pos);
4569 } else if (str_starts(pos, WPS_EVENT_SUCCESS)) {
4570 wpa_cli_exec(action_file, ifname, pos);
4571 } else if (str_starts(pos, WPS_EVENT_ACTIVE)) {
4572 wpa_cli_exec(action_file, ifname, pos);
4573 } else if (str_starts(pos, WPS_EVENT_OVERLAP)) {
4574 wpa_cli_exec(action_file, ifname, pos);
4575 } else if (str_starts(pos, WPS_EVENT_PIN_ACTIVE)) {
4576 wpa_cli_exec(action_file, ifname, pos);
4577 } else if (str_starts(pos, WPS_EVENT_CANCEL)) {
4578 wpa_cli_exec(action_file, ifname, pos);
4579 } else if (str_starts(pos, WPS_EVENT_TIMEOUT)) {
4580 wpa_cli_exec(action_file, ifname, pos);
4581 } else if (str_starts(pos, WPS_EVENT_FAIL)) {
4582 wpa_cli_exec(action_file, ifname, pos);
4583 } else if (str_starts(pos, AP_STA_CONNECTED)) {
4584 wpa_cli_exec(action_file, ifname, pos);
4585 } else if (str_starts(pos, AP_STA_DISCONNECTED)) {
4586 wpa_cli_exec(action_file, ifname, pos);
4587 } else if (str_starts(pos, ESS_DISASSOC_IMMINENT)) {
4588 wpa_cli_exec(action_file, ifname, pos);
4589 } else if (str_starts(pos, HS20_SUBSCRIPTION_REMEDIATION)) {
4590 wpa_cli_exec(action_file, ifname, pos);
4591 } else if (str_starts(pos, HS20_DEAUTH_IMMINENT_NOTICE)) {
4592 wpa_cli_exec(action_file, ifname, pos);
4593 } else if (str_starts(pos, HS20_T_C_ACCEPTANCE)) {
4594 wpa_cli_exec(action_file, ifname, pos);
4595 } else if (str_starts(pos, DPP_EVENT_CONF_RECEIVED)) {
4596 wpa_cli_exec(action_file, ifname, pos);
4597 } else if (str_starts(pos, DPP_EVENT_CONFOBJ_AKM)) {
4598 wpa_cli_exec(action_file, ifname, pos);
4599 } else if (str_starts(pos, DPP_EVENT_CONFOBJ_SSID)) {
4600 wpa_cli_exec(action_file, ifname, pos);
4601 } else if (str_starts(pos, DPP_EVENT_CONNECTOR)) {
4602 wpa_cli_exec(action_file, ifname, pos);
4603 } else if (str_starts(pos, DPP_EVENT_CONFOBJ_PASS)) {
4604 wpa_cli_exec(action_file, ifname, pos);
4605 } else if (str_starts(pos, DPP_EVENT_CONFOBJ_PSK)) {
4606 wpa_cli_exec(action_file, ifname, pos);
4607 } else if (str_starts(pos, DPP_EVENT_C_SIGN_KEY)) {
4608 wpa_cli_exec(action_file, ifname, pos);
4609 } else if (str_starts(pos, DPP_EVENT_NET_ACCESS_KEY)) {
4610 wpa_cli_exec(action_file, ifname, pos);
4611 } else if (str_starts(pos, WPA_EVENT_TERMINATING)) {
4612 printf("wpa_supplicant is terminating - stop monitoring\n");
4613 if (!reconnect)
4614 wpa_cli_quit = 1;
4615 }
4616 }
4617
4618
4619 #ifndef CONFIG_ANSI_C_EXTRA
wpa_cli_action_cb(char * msg,size_t len)4620 static void wpa_cli_action_cb(char *msg, size_t len)
4621 {
4622 wpa_cli_action_process(msg);
4623 }
4624 #endif /* CONFIG_ANSI_C_EXTRA */
4625
4626
wpa_cli_open_global_ctrl(void)4627 static int wpa_cli_open_global_ctrl(void)
4628 {
4629 #ifdef CONFIG_CTRL_IFACE_NAMED_PIPE
4630 ctrl_conn = wpa_ctrl_open(NULL);
4631 #else /* CONFIG_CTRL_IFACE_NAMED_PIPE */
4632 ctrl_conn = wpa_ctrl_open(global);
4633 #endif /* CONFIG_CTRL_IFACE_NAMED_PIPE */
4634 if (!ctrl_conn) {
4635 fprintf(stderr,
4636 "Failed to connect to wpa_supplicant global interface: %s error: %s\n",
4637 global, strerror(errno));
4638 return -1;
4639 }
4640
4641 if (interactive) {
4642 update_ifnames(ctrl_conn);
4643 mon_conn = wpa_ctrl_open(global);
4644 if (mon_conn) {
4645 if (wpa_ctrl_attach(mon_conn) == 0) {
4646 wpa_cli_attached = 1;
4647 eloop_register_read_sock(
4648 wpa_ctrl_get_fd(mon_conn),
4649 wpa_cli_mon_receive,
4650 NULL, NULL);
4651 } else {
4652 printf("Failed to open monitor connection through global control interface\n");
4653 }
4654 }
4655 update_stations(ctrl_conn);
4656 }
4657
4658 return 0;
4659 }
4660
4661
wpa_cli_reconnect(void)4662 static void wpa_cli_reconnect(void)
4663 {
4664 wpa_cli_close_connection();
4665 if ((global && wpa_cli_open_global_ctrl() < 0) ||
4666 (!global && wpa_cli_open_connection(ctrl_ifname, 1) < 0))
4667 return;
4668
4669 if (interactive) {
4670 edit_clear_line();
4671 printf("\rConnection to wpa_supplicant re-established\n");
4672 edit_redraw();
4673 update_stations(ctrl_conn);
4674 }
4675 }
4676
4677
cli_event(const char * str)4678 static void cli_event(const char *str)
4679 {
4680 const char *start, *s;
4681
4682 start = os_strchr(str, '>');
4683 if (start == NULL)
4684 return;
4685
4686 start++;
4687
4688 if (str_starts(start, WPA_EVENT_BSS_ADDED)) {
4689 s = os_strchr(start, ' ');
4690 if (s == NULL)
4691 return;
4692 s = os_strchr(s + 1, ' ');
4693 if (s == NULL)
4694 return;
4695 cli_txt_list_add(&bsses, s + 1);
4696 return;
4697 }
4698
4699 if (str_starts(start, WPA_EVENT_BSS_REMOVED)) {
4700 s = os_strchr(start, ' ');
4701 if (s == NULL)
4702 return;
4703 s = os_strchr(s + 1, ' ');
4704 if (s == NULL)
4705 return;
4706 cli_txt_list_del_addr(&bsses, s + 1);
4707 return;
4708 }
4709
4710 #ifdef CONFIG_P2P
4711 if (str_starts(start, P2P_EVENT_DEVICE_FOUND)) {
4712 s = os_strstr(start, " p2p_dev_addr=");
4713 if (s == NULL)
4714 return;
4715 cli_txt_list_add_addr(&p2p_peers, s + 14);
4716 return;
4717 }
4718
4719 if (str_starts(start, P2P_EVENT_DEVICE_LOST)) {
4720 s = os_strstr(start, " p2p_dev_addr=");
4721 if (s == NULL)
4722 return;
4723 cli_txt_list_del_addr(&p2p_peers, s + 14);
4724 return;
4725 }
4726
4727 if (str_starts(start, P2P_EVENT_GROUP_STARTED)) {
4728 s = os_strchr(start, ' ');
4729 if (s == NULL)
4730 return;
4731 cli_txt_list_add_word(&p2p_groups, s + 1, ' ');
4732 return;
4733 }
4734
4735 if (str_starts(start, P2P_EVENT_GROUP_REMOVED)) {
4736 s = os_strchr(start, ' ');
4737 if (s == NULL)
4738 return;
4739 cli_txt_list_del_word(&p2p_groups, s + 1, ' ');
4740 return;
4741 }
4742 #endif /* CONFIG_P2P */
4743 }
4744
4745
check_terminating(const char * msg)4746 static int check_terminating(const char *msg)
4747 {
4748 const char *pos = msg;
4749
4750 if (*pos == '<') {
4751 /* skip priority */
4752 pos = os_strchr(pos, '>');
4753 if (pos)
4754 pos++;
4755 else
4756 pos = msg;
4757 }
4758
4759 if (str_starts(pos, WPA_EVENT_TERMINATING) && ctrl_conn) {
4760 edit_clear_line();
4761 printf("\rConnection to wpa_supplicant lost - trying to "
4762 "reconnect\n");
4763 edit_redraw();
4764 wpa_cli_attached = 0;
4765 wpa_cli_close_connection();
4766 return 1;
4767 }
4768
4769 return 0;
4770 }
4771
4772
wpa_cli_recv_pending(struct wpa_ctrl * ctrl,int action_monitor)4773 static void wpa_cli_recv_pending(struct wpa_ctrl *ctrl, int action_monitor)
4774 {
4775 if (ctrl_conn == NULL) {
4776 wpa_cli_reconnect();
4777 return;
4778 }
4779 while (wpa_ctrl_pending(ctrl) > 0) {
4780 char buf[4096];
4781 size_t len = sizeof(buf) - 1;
4782 if (wpa_ctrl_recv(ctrl, buf, &len) == 0) {
4783 buf[len] = '\0';
4784 if (action_monitor)
4785 wpa_cli_action_process(buf);
4786 else {
4787 cli_event(buf);
4788 if (wpa_cli_show_event(buf)) {
4789 edit_clear_line();
4790 printf("\r%s\n", buf);
4791 edit_redraw();
4792 }
4793
4794 if (interactive && check_terminating(buf) > 0)
4795 return;
4796 }
4797 } else {
4798 printf("Could not read pending message.\n");
4799 break;
4800 }
4801 }
4802
4803 if (wpa_ctrl_pending(ctrl) < 0) {
4804 printf("Connection to wpa_supplicant lost - trying to "
4805 "reconnect\n");
4806 if (reconnect) {
4807 eloop_terminate();
4808 return;
4809 }
4810 wpa_cli_reconnect();
4811 }
4812 }
4813
4814
wpa_cli_ping(void * eloop_ctx,void * timeout_ctx)4815 static void wpa_cli_ping(void *eloop_ctx, void *timeout_ctx)
4816 {
4817 if (ctrl_conn) {
4818 int res;
4819 char *prefix = ifname_prefix;
4820
4821 ifname_prefix = NULL;
4822 res = _wpa_ctrl_command(ctrl_conn, "PING", 0);
4823 ifname_prefix = prefix;
4824 if (res) {
4825 printf("Connection to wpa_supplicant lost - trying to "
4826 "reconnect\n");
4827 wpa_cli_close_connection();
4828 }
4829 }
4830 if (!ctrl_conn)
4831 wpa_cli_reconnect();
4832 eloop_register_timeout(ping_interval, 0, wpa_cli_ping, NULL, NULL);
4833 }
4834
4835
wpa_cli_mon_receive(int sock,void * eloop_ctx,void * sock_ctx)4836 static void wpa_cli_mon_receive(int sock, void *eloop_ctx, void *sock_ctx)
4837 {
4838 wpa_cli_recv_pending(mon_conn, 0);
4839 }
4840
4841
wpa_cli_edit_cmd_cb(void * ctx,char * cmd)4842 static void wpa_cli_edit_cmd_cb(void *ctx, char *cmd)
4843 {
4844 char *argv[max_args];
4845 int argc;
4846 argc = tokenize_cmd(cmd, argv);
4847 if (argc)
4848 wpa_request(ctrl_conn, argc, argv);
4849 }
4850
4851
wpa_cli_edit_eof_cb(void * ctx)4852 static void wpa_cli_edit_eof_cb(void *ctx)
4853 {
4854 eloop_terminate();
4855 }
4856
4857
4858 static int warning_displayed = 0;
4859 static char *hfile = NULL;
4860 static int edit_started = 0;
4861
start_edit(void)4862 static void start_edit(void)
4863 {
4864 char *home;
4865 char *ps = NULL;
4866
4867 #ifdef CONFIG_CTRL_IFACE_UDP_REMOTE
4868 ps = wpa_ctrl_get_remote_ifname(ctrl_conn);
4869 #endif /* CONFIG_CTRL_IFACE_UDP_REMOTE */
4870
4871 #ifdef CONFIG_WPA_CLI_HISTORY_DIR
4872 home = CONFIG_WPA_CLI_HISTORY_DIR;
4873 #else /* CONFIG_WPA_CLI_HISTORY_DIR */
4874 home = getenv("HOME");
4875 #endif /* CONFIG_WPA_CLI_HISTORY_DIR */
4876 if (home) {
4877 const char *fname = ".wpa_cli_history";
4878 int hfile_len = os_strlen(home) + 1 + os_strlen(fname) + 1;
4879 hfile = os_malloc(hfile_len);
4880 if (hfile)
4881 os_snprintf(hfile, hfile_len, "%s/%s", home, fname);
4882 }
4883
4884 if (edit_init(wpa_cli_edit_cmd_cb, wpa_cli_edit_eof_cb,
4885 wpa_cli_edit_completion_cb, NULL, hfile, ps) < 0) {
4886 eloop_terminate();
4887 return;
4888 }
4889
4890 edit_started = 1;
4891 eloop_register_timeout(ping_interval, 0, wpa_cli_ping, NULL, NULL);
4892 }
4893
4894
update_bssid_list(struct wpa_ctrl * ctrl)4895 static void update_bssid_list(struct wpa_ctrl *ctrl)
4896 {
4897 char buf[4096];
4898 size_t len = sizeof(buf);
4899 int ret;
4900 const char *cmd = "BSS RANGE=ALL MASK=0x2";
4901 char *pos, *end;
4902
4903 if (ctrl == NULL)
4904 return;
4905 ret = wpa_ctrl_request(ctrl, cmd, os_strlen(cmd), buf, &len, NULL);
4906 if (ret < 0)
4907 return;
4908 buf[len] = '\0';
4909
4910 pos = buf;
4911 while (pos) {
4912 pos = os_strstr(pos, "bssid=");
4913 if (pos == NULL)
4914 break;
4915 pos += 6;
4916 end = os_strchr(pos, '\n');
4917 if (end == NULL)
4918 break;
4919 *end = '\0';
4920 cli_txt_list_add(&bsses, pos);
4921 pos = end + 1;
4922 }
4923 }
4924
4925
update_ifnames(struct wpa_ctrl * ctrl)4926 static void update_ifnames(struct wpa_ctrl *ctrl)
4927 {
4928 char buf[4096];
4929 size_t len = sizeof(buf);
4930 int ret;
4931 const char *cmd = "INTERFACES";
4932 char *pos, *end;
4933 char txt[200];
4934
4935 cli_txt_list_flush(&ifnames);
4936
4937 if (ctrl == NULL)
4938 return;
4939 ret = wpa_ctrl_request(ctrl, cmd, os_strlen(cmd), buf, &len, NULL);
4940 if (ret < 0)
4941 return;
4942 buf[len] = '\0';
4943
4944 pos = buf;
4945 while (pos) {
4946 end = os_strchr(pos, '\n');
4947 if (end == NULL)
4948 break;
4949 *end = '\0';
4950 ret = os_snprintf(txt, sizeof(txt), "ifname=%s", pos);
4951 if (!os_snprintf_error(sizeof(txt), ret))
4952 cli_txt_list_add(&ifnames, txt);
4953 pos = end + 1;
4954 }
4955 }
4956
4957
update_creds(struct wpa_ctrl * ctrl)4958 static void update_creds(struct wpa_ctrl *ctrl)
4959 {
4960 char buf[4096];
4961 size_t len = sizeof(buf);
4962 int ret;
4963 const char *cmd = "LIST_CREDS";
4964 char *pos, *end;
4965 int header = 1;
4966
4967 cli_txt_list_flush(&creds);
4968
4969 if (ctrl == NULL)
4970 return;
4971 ret = wpa_ctrl_request(ctrl, cmd, os_strlen(cmd), buf, &len, NULL);
4972 if (ret < 0)
4973 return;
4974 buf[len] = '\0';
4975
4976 pos = buf;
4977 while (pos) {
4978 end = os_strchr(pos, '\n');
4979 if (end == NULL)
4980 break;
4981 *end = '\0';
4982 if (!header)
4983 cli_txt_list_add_word(&creds, pos, '\t');
4984 header = 0;
4985 pos = end + 1;
4986 }
4987 }
4988
4989
update_networks(struct wpa_ctrl * ctrl)4990 static void update_networks(struct wpa_ctrl *ctrl)
4991 {
4992 char buf[4096];
4993 size_t len = sizeof(buf);
4994 int ret;
4995 const char *cmd = "LIST_NETWORKS";
4996 char *pos, *end;
4997 int header = 1;
4998
4999 cli_txt_list_flush(&networks);
5000
5001 if (ctrl == NULL)
5002 return;
5003 ret = wpa_ctrl_request(ctrl, cmd, os_strlen(cmd), buf, &len, NULL);
5004 if (ret < 0)
5005 return;
5006 buf[len] = '\0';
5007
5008 pos = buf;
5009 while (pos) {
5010 end = os_strchr(pos, '\n');
5011 if (end == NULL)
5012 break;
5013 *end = '\0';
5014 if (!header)
5015 cli_txt_list_add_word(&networks, pos, '\t');
5016 header = 0;
5017 pos = end + 1;
5018 }
5019 }
5020
5021
update_stations(struct wpa_ctrl * ctrl)5022 static void update_stations(struct wpa_ctrl *ctrl)
5023 {
5024 #ifdef CONFIG_AP
5025 char addr[32], cmd[64];
5026
5027 if (!ctrl || !interactive)
5028 return;
5029
5030 cli_txt_list_flush(&stations);
5031
5032 if (wpa_ctrl_command_sta(ctrl, "STA-FIRST", addr, sizeof(addr), 0))
5033 return;
5034 do {
5035 if (os_strcmp(addr, "") != 0)
5036 cli_txt_list_add(&stations, addr);
5037 os_snprintf(cmd, sizeof(cmd), "STA-NEXT %s", addr);
5038 } while (wpa_ctrl_command_sta(ctrl, cmd, addr, sizeof(addr), 0) == 0);
5039 #endif /* CONFIG_AP */
5040 }
5041
5042
try_connection(void * eloop_ctx,void * timeout_ctx)5043 static void try_connection(void *eloop_ctx, void *timeout_ctx)
5044 {
5045 if (ctrl_conn)
5046 goto done;
5047
5048 if (ctrl_ifname == NULL)
5049 ctrl_ifname = wpa_cli_get_default_ifname();
5050
5051 if (wpa_cli_open_connection(ctrl_ifname, 1)) {
5052 if (!warning_displayed) {
5053 printf("Could not connect to wpa_supplicant: "
5054 "%s - re-trying\n",
5055 ctrl_ifname ? ctrl_ifname : "(nil)");
5056 warning_displayed = 1;
5057 }
5058 eloop_register_timeout(1, 0, try_connection, NULL, NULL);
5059 return;
5060 }
5061
5062 update_bssid_list(ctrl_conn);
5063 update_creds(ctrl_conn);
5064 update_networks(ctrl_conn);
5065 update_stations(ctrl_conn);
5066
5067 if (warning_displayed)
5068 printf("Connection established.\n");
5069
5070 done:
5071 start_edit();
5072 }
5073
5074
wpa_cli_interactive(void)5075 static void wpa_cli_interactive(void)
5076 {
5077 printf("\nInteractive mode\n\n");
5078
5079 eloop_register_timeout(0, 0, try_connection, NULL, NULL);
5080 eloop_run();
5081 eloop_cancel_timeout(try_connection, NULL, NULL);
5082
5083 cli_txt_list_flush(&p2p_peers);
5084 cli_txt_list_flush(&p2p_groups);
5085 cli_txt_list_flush(&bsses);
5086 cli_txt_list_flush(&ifnames);
5087 cli_txt_list_flush(&creds);
5088 cli_txt_list_flush(&networks);
5089 if (edit_started)
5090 edit_deinit(hfile, wpa_cli_edit_filter_history_cb);
5091 os_free(hfile);
5092 eloop_cancel_timeout(wpa_cli_ping, NULL, NULL);
5093 wpa_cli_close_connection();
5094 }
5095
5096
wpa_cli_action_ping(void * eloop_ctx,void * timeout_ctx)5097 static void wpa_cli_action_ping(void *eloop_ctx, void *timeout_ctx)
5098 {
5099 struct wpa_ctrl *ctrl = eloop_ctx;
5100 char buf[256];
5101 size_t len;
5102
5103 /* verify that connection is still working */
5104 len = sizeof(buf) - 1;
5105 if (wpa_ctrl_request(ctrl, "PING", 4, buf, &len,
5106 wpa_cli_action_cb) < 0 ||
5107 len < 4 || os_memcmp(buf, "PONG", 4) != 0) {
5108 printf("wpa_supplicant did not reply to PING command - exiting\n");
5109 eloop_terminate();
5110 return;
5111 }
5112 eloop_register_timeout(ping_interval, 0, wpa_cli_action_ping,
5113 ctrl, NULL);
5114 }
5115
5116
wpa_cli_action_receive(int sock,void * eloop_ctx,void * sock_ctx)5117 static void wpa_cli_action_receive(int sock, void *eloop_ctx, void *sock_ctx)
5118 {
5119 struct wpa_ctrl *ctrl = eloop_ctx;
5120
5121 wpa_cli_recv_pending(ctrl, 1);
5122 }
5123
5124
wpa_cli_action(struct wpa_ctrl * ctrl)5125 static void wpa_cli_action(struct wpa_ctrl *ctrl)
5126 {
5127 #ifdef CONFIG_ANSI_C_EXTRA
5128 /* TODO: ANSI C version(?) */
5129 printf("Action processing not supported in ANSI C build.\n");
5130 #else /* CONFIG_ANSI_C_EXTRA */
5131 int fd;
5132
5133 fd = wpa_ctrl_get_fd(ctrl);
5134 eloop_register_timeout(ping_interval, 0, wpa_cli_action_ping,
5135 ctrl, NULL);
5136 eloop_register_read_sock(fd, wpa_cli_action_receive, ctrl, NULL);
5137 eloop_run();
5138 eloop_cancel_timeout(wpa_cli_action_ping, ctrl, NULL);
5139 eloop_unregister_read_sock(fd);
5140 #endif /* CONFIG_ANSI_C_EXTRA */
5141 }
5142
5143
wpa_cli_cleanup(void)5144 static void wpa_cli_cleanup(void)
5145 {
5146 wpa_cli_close_connection();
5147 if (pid_file)
5148 os_daemonize_terminate(pid_file);
5149
5150 os_program_deinit();
5151 }
5152
5153
wpa_cli_terminate(int sig,void * ctx)5154 static void wpa_cli_terminate(int sig, void *ctx)
5155 {
5156 eloop_terminate();
5157 if (reconnect)
5158 wpa_cli_quit = 1;
5159 }
5160
5161
wpa_cli_get_default_ifname(void)5162 static char * wpa_cli_get_default_ifname(void)
5163 {
5164 char *ifname = NULL;
5165
5166 #ifdef ANDROID
5167 char ifprop[PROPERTY_VALUE_MAX];
5168 if (property_get("wifi.interface", ifprop, NULL) != 0) {
5169 ifname = os_strdup(ifprop);
5170 printf("Using interface '%s'\n", ifname ? ifname : "N/A");
5171 }
5172 #else /* ANDROID */
5173 #ifdef CONFIG_CTRL_IFACE_UNIX
5174 struct dirent *dent;
5175 DIR *dir = opendir(ctrl_iface_dir);
5176 if (!dir) {
5177 return NULL;
5178 }
5179 while ((dent = readdir(dir))) {
5180 #ifdef _DIRENT_HAVE_D_TYPE
5181 /*
5182 * Skip the file if it is not a socket. Also accept
5183 * DT_UNKNOWN (0) in case the C library or underlying
5184 * file system does not support d_type.
5185 */
5186 if (dent->d_type != DT_SOCK && dent->d_type != DT_UNKNOWN)
5187 continue;
5188 #endif /* _DIRENT_HAVE_D_TYPE */
5189 /* Skip current/previous directory and special P2P Device
5190 * interfaces. */
5191 if (os_strcmp(dent->d_name, ".") == 0 ||
5192 os_strcmp(dent->d_name, "..") == 0 ||
5193 os_strncmp(dent->d_name, "p2p-dev-", 8) == 0)
5194 continue;
5195 printf("Selected interface '%s'\n", dent->d_name);
5196 ifname = os_strdup(dent->d_name);
5197 break;
5198 }
5199 closedir(dir);
5200 #endif /* CONFIG_CTRL_IFACE_UNIX */
5201
5202 #ifdef CONFIG_CTRL_IFACE_NAMED_PIPE
5203 char buf[4096], *pos;
5204 size_t len;
5205 struct wpa_ctrl *ctrl;
5206 int ret;
5207
5208 ctrl = wpa_ctrl_open(NULL);
5209 if (ctrl == NULL)
5210 return NULL;
5211
5212 len = sizeof(buf) - 1;
5213 ret = wpa_ctrl_request(ctrl, "INTERFACES", 10, buf, &len, NULL);
5214 if (ret >= 0) {
5215 buf[len] = '\0';
5216 pos = os_strchr(buf, '\n');
5217 if (pos)
5218 *pos = '\0';
5219 ifname = os_strdup(buf);
5220 }
5221 wpa_ctrl_close(ctrl);
5222 #endif /* CONFIG_CTRL_IFACE_NAMED_PIPE */
5223 #endif /* ANDROID */
5224
5225 return ifname;
5226 }
5227
5228
main(int argc,char * argv[])5229 int main(int argc, char *argv[])
5230 {
5231 int c;
5232 int daemonize = 0;
5233 int ret = 0;
5234
5235 if (os_program_init())
5236 return -1;
5237
5238 for (;;) {
5239 c = getopt(argc, argv, "a:Bg:G:hi:p:P:rs:v");
5240 if (c < 0)
5241 break;
5242 switch (c) {
5243 case 'a':
5244 action_file = optarg;
5245 break;
5246 case 'B':
5247 daemonize = 1;
5248 break;
5249 case 'g':
5250 global = optarg;
5251 break;
5252 case 'G':
5253 ping_interval = atoi(optarg);
5254 break;
5255 case 'h':
5256 usage();
5257 return 0;
5258 case 'v':
5259 printf("%s\n", wpa_cli_version);
5260 return 0;
5261 case 'i':
5262 os_free(ctrl_ifname);
5263 ctrl_ifname = os_strdup(optarg);
5264 break;
5265 case 'p':
5266 ctrl_iface_dir = optarg;
5267 break;
5268 case 'P':
5269 pid_file = optarg;
5270 break;
5271 case 'r':
5272 reconnect = 1;
5273 break;
5274 case 's':
5275 client_socket_dir = optarg;
5276 break;
5277 default:
5278 usage();
5279 return -1;
5280 }
5281 }
5282
5283 interactive = (argc == optind) && (action_file == NULL);
5284
5285 if (interactive)
5286 printf("%s\n\n%s\n\n", wpa_cli_version, cli_license);
5287
5288 if (eloop_init())
5289 return -1;
5290
5291 if (global && wpa_cli_open_global_ctrl() < 0)
5292 return -1;
5293
5294 eloop_register_signal_terminate(wpa_cli_terminate, NULL);
5295
5296 if (ctrl_ifname == NULL)
5297 ctrl_ifname = wpa_cli_get_default_ifname();
5298
5299 if (reconnect && action_file && ctrl_ifname) {
5300 while (!wpa_cli_quit) {
5301 if (ctrl_conn)
5302 wpa_cli_action(ctrl_conn);
5303 else
5304 os_sleep(1, 0);
5305 wpa_cli_close_connection();
5306 wpa_cli_open_connection(ctrl_ifname, 0);
5307 if (ctrl_conn) {
5308 if (wpa_ctrl_attach(ctrl_conn) != 0)
5309 wpa_cli_close_connection();
5310 else
5311 wpa_cli_attached = 1;
5312 }
5313 }
5314 } else if (interactive) {
5315 wpa_cli_interactive();
5316 } else {
5317 if (!global &&
5318 wpa_cli_open_connection(ctrl_ifname, 0) < 0) {
5319 fprintf(stderr, "Failed to connect to non-global "
5320 "ctrl_ifname: %s error: %s\n",
5321 ctrl_ifname ? ctrl_ifname : "(nil)",
5322 strerror(errno));
5323 return -1;
5324 }
5325
5326 if (action_file) {
5327 if (wpa_ctrl_attach(ctrl_conn) == 0) {
5328 wpa_cli_attached = 1;
5329 } else {
5330 printf("Warning: Failed to attach to "
5331 "wpa_supplicant.\n");
5332 return -1;
5333 }
5334 }
5335
5336 if (daemonize && os_daemonize(pid_file) && eloop_sock_requeue())
5337 return -1;
5338
5339 if (action_file)
5340 wpa_cli_action(ctrl_conn);
5341 else
5342 ret = wpa_request(ctrl_conn, argc - optind,
5343 &argv[optind]);
5344 }
5345
5346 os_free(ctrl_ifname);
5347 eloop_destroy();
5348 wpa_cli_cleanup();
5349
5350 return ret;
5351 }
5352
5353 #else /* CONFIG_CTRL_IFACE */
main(int argc,char * argv[])5354 int main(int argc, char *argv[])
5355 {
5356 printf("CONFIG_CTRL_IFACE not defined - wpa_cli disabled\n");
5357 return -1;
5358 }
5359 #endif /* CONFIG_CTRL_IFACE */
5360