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