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