]> git.ipfire.org Git - thirdparty/hostap.git/blame - wpa_supplicant/wpa_cli.c
projects / thirdparty / hostap.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
tests: INTERWORKING_ADD_NETWORK
[thirdparty/hostap.git] / wpa_supplicant / wpa_cli.c
CommitLineData
6fc6879b
JM		 1/*
2 * WPA Supplicant - command line interface for wpa_supplicant daemon
937403b5 3 * Copyright (c) 2004-2015, Jouni Malinen <j@w1.fi>
6fc6879b 4 *
0f3d578e
JM		 5 * This software may be distributed under the terms of the BSD license.
6 * See README for more details.
6fc6879b
JM		 7 */
8
9#include "includes.h"
10
11#ifdef CONFIG_CTRL_IFACE
12
13#ifdef CONFIG_CTRL_IFACE_UNIX
14#include <dirent.h>
15#endif /* CONFIG_CTRL_IFACE_UNIX */
6fc6879b 16
90973fb2 17#include "common/wpa_ctrl.h"
cd101567
JM		 18#include "utils/common.h"
19#include "utils/eloop.h"
82a855bd 20#include "utils/edit.h"
a624f20b 21#include "utils/list.h"
90973fb2 22#include "common/version.h"
a8918e86 23#include "common/ieee802_11_defs.h"
b1001e4c
DS		 24#ifdef ANDROID
25#include <cutils/properties.h>
26#endif /* ANDROID */
6fc6879b
JM		 27
28
29static const char *wpa_cli_version =
30"wpa_cli v" VERSION_STR "\n"
937403b5 31"Copyright (c) 2004-2015, Jouni Malinen <j@w1.fi> and contributors";
6fc6879b
JM		 32
33
34static const char *wpa_cli_license =
331f89ff
JM		 35"This software may be distributed under the terms of the BSD license.\n"
36"See README for more details.\n";
6fc6879b
JM		 37
38static const char *wpa_cli_full_license =
331f89ff 39"This software may be distributed under the terms of the BSD license.\n"
6fc6879b
JM		 40"\n"
41"Redistribution and use in source and binary forms, with or without\n"
42"modification, are permitted provided that the following conditions are\n"
43"met:\n"
44"\n"
45"1. Redistributions of source code must retain the above copyright\n"
46" notice, this list of conditions and the following disclaimer.\n"
47"\n"
48"2. Redistributions in binary form must reproduce the above copyright\n"
49" notice, this list of conditions and the following disclaimer in the\n"
50" documentation and/or other materials provided with the distribution.\n"
51"\n"
52"3. Neither the name(s) of the above-listed copyright holder(s) nor the\n"
53" names of its contributors may be used to endorse or promote products\n"
54" derived from this software without specific prior written permission.\n"
55"\n"
56"THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n"
57"\"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n"
58"LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n"
59"A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n"
60"OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n"
61"SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n"
62"LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n"
63"DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n"
64"THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n"
65"(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n"
66"OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n"
67"\n";
68
6fc6879b 69static struct wpa_ctrl *ctrl_conn;
4a3ade4e 70static struct wpa_ctrl *mon_conn;
6fc6879b
JM		 71static int wpa_cli_quit = 0;
72static int wpa_cli_attached = 0;
02a3e5c0 73static int wpa_cli_connected = -1;
6fc6879b 74static int wpa_cli_last_id = 0;
c5c5817c
JM		 75#ifndef CONFIG_CTRL_IFACE_DIR
76#define CONFIG_CTRL_IFACE_DIR "/var/run/wpa_supplicant"
77#endif /* CONFIG_CTRL_IFACE_DIR */
78static const char *ctrl_iface_dir = CONFIG_CTRL_IFACE_DIR;
6fc6879b
JM		 79static char *ctrl_ifname = NULL;
80static const char *pid_file = NULL;
81static const char *action_file = NULL;
1cc84c1c 82static int ping_interval = 5;
4a3ade4e 83static int interactive = 0;
13b11ba7 84static char *ifname_prefix = NULL;
6fc6879b 85
a624f20b
JM		 86struct cli_txt_entry {
87 struct dl_list list;
88 char *txt;
89};
90
91static DEFINE_DL_LIST(bsses); /* struct cli_txt_entry */
92static DEFINE_DL_LIST(p2p_peers); /* struct cli_txt_entry */
76788542 93static DEFINE_DL_LIST(p2p_groups); /* struct cli_txt_entry */
37620493 94static DEFINE_DL_LIST(ifnames); /* struct cli_txt_entry */
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]);
30f459c0
EL		 1580 if (!ctrl_ifname) {
1581 printf("Failed to allocate memory\n");
1582 return 0;
1583 }
6fc6879b 1584
2150c333 1585 if (wpa_cli_open_connection(ctrl_ifname, 1) == 0) {
6fc6879b 1586 printf("Connected to interface '%s.\n", ctrl_ifname);
6fc6879b
JM		 1587 } else {
1588 printf("Could not connect to interface '%s' - re-trying\n",
1589 ctrl_ifname);
1590 }
1591 return 0;
1592}
1593
1594
1595static int wpa_cli_cmd_reconfigure(struct wpa_ctrl *ctrl, int argc,
1596 char *argv[])
1597{
1598 return wpa_ctrl_command(ctrl, "RECONFIGURE");
1599}
1600
1601
1602static int wpa_cli_cmd_terminate(struct wpa_ctrl *ctrl, int argc,
1603 char *argv[])
1604{
1605 return wpa_ctrl_command(ctrl, "TERMINATE");
1606}
1607
1608
1609static int wpa_cli_cmd_interface_add(struct wpa_ctrl *ctrl, int argc,
1610 char *argv[])
1611{
1612 char cmd[256];
1613 int res;
1614
1615 if (argc < 1) {
1616 printf("Invalid INTERFACE_ADD command: needs at least one "
1617 "argument (interface name)\n"
1618 "All arguments: ifname confname driver ctrl_interface "
1619 "driver_param bridge_name\n");
1620 return -1;
1621 }
1622
1623 /*
1624 * INTERFACE_ADD <ifname>TAB<confname>TAB<driver>TAB<ctrl_interface>TAB
1625 * <driver_param>TAB<bridge_name>
1626 */
1627 res = os_snprintf(cmd, sizeof(cmd),
1628 "INTERFACE_ADD %s\t%s\t%s\t%s\t%s\t%s",
1629 argv[0],
1630 argc > 1 ? argv[1] : "", argc > 2 ? argv[2] : "",
1631 argc > 3 ? argv[3] : "", argc > 4 ? argv[4] : "",
1632 argc > 5 ? argv[5] : "");
d85e1fc8 1633 if (os_snprintf_error(sizeof(cmd), res))
6fc6879b
JM		 1634 return -1;
1635 cmd[sizeof(cmd) - 1] = '\0';
1636 return wpa_ctrl_command(ctrl, cmd);
1637}
1638
1639
1640static int wpa_cli_cmd_interface_remove(struct wpa_ctrl *ctrl, int argc,
1641 char *argv[])
1642{
87c7ba84 1643 return wpa_cli_cmd(ctrl, "INTERFACE_REMOVE", 1, argc, argv);
6fc6879b
JM		 1644}
1645
1646
4b4a8ae5
JM		 1647static int wpa_cli_cmd_interface_list(struct wpa_ctrl *ctrl, int argc,
1648 char *argv[])
1649{
1650 return wpa_ctrl_command(ctrl, "INTERFACE_LIST");
1651}
1652
1653
e653b622
JM		 1654#ifdef CONFIG_AP
1655static int wpa_cli_cmd_sta(struct wpa_ctrl *ctrl, int argc, char *argv[])
1656{
87c7ba84 1657 return wpa_cli_cmd(ctrl, "STA", 1, argc, argv);
e653b622
JM		 1658}
1659
1660
1661static int wpa_ctrl_command_sta(struct wpa_ctrl *ctrl, char *cmd,
1662 char *addr, size_t addr_len)
1663{
1664 char buf[4096], *pos;
1665 size_t len;
1666 int ret;
1667
1668 if (ctrl_conn == NULL) {
1669 printf("Not connected to hostapd - command dropped.\n");
1670 return -1;
1671 }
1672 len = sizeof(buf) - 1;
024d018b 1673 ret = wpa_ctrl_request(ctrl, cmd, os_strlen(cmd), buf, &len,
e653b622
JM		 1674 wpa_cli_msg_cb);
1675 if (ret == -2) {
1676 printf("'%s' command timed out.\n", cmd);
1677 return -2;
1678 } else if (ret < 0) {
1679 printf("'%s' command failed.\n", cmd);
1680 return -1;
1681 }
1682
1683 buf[len] = '\0';
024d018b 1684 if (os_memcmp(buf, "FAIL", 4) == 0)
e653b622
JM		 1685 return -1;
1686 printf("%s", buf);
1687
1688 pos = buf;
1689 while (*pos != '\0' && *pos != '\n')
1690 pos++;
1691 *pos = '\0';
1692 os_strlcpy(addr, buf, addr_len);
1693 return 0;
1694}
1695
1696
1697static int wpa_cli_cmd_all_sta(struct wpa_ctrl *ctrl, int argc, char *argv[])
1698{
1699 char addr[32], cmd[64];
1700
1701 if (wpa_ctrl_command_sta(ctrl, "STA-FIRST", addr, sizeof(addr)))
1702 return 0;
1703 do {
e824cc46 1704 os_snprintf(cmd, sizeof(cmd), "STA-NEXT %s", addr);
e653b622
JM		 1705 } while (wpa_ctrl_command_sta(ctrl, cmd, addr, sizeof(addr)) == 0);
1706
1707 return -1;
1708}
e60b2951
JJ		 1709
1710
1711static int wpa_cli_cmd_deauthenticate(struct wpa_ctrl *ctrl, int argc,
1712 char *argv[])
1713{
87c7ba84 1714 return wpa_cli_cmd(ctrl, "DEAUTHENTICATE", 1, argc, argv);
e60b2951
JJ		 1715}
1716
1717
1718static int wpa_cli_cmd_disassociate(struct wpa_ctrl *ctrl, int argc,
1719 char *argv[])
1720{
87c7ba84 1721 return wpa_cli_cmd(ctrl, "DISASSOCIATE", 1, argc, argv);
e60b2951 1722}
334bf36a
AO		 1723
1724static int wpa_cli_cmd_chanswitch(struct wpa_ctrl *ctrl, int argc,
1725 char *argv[])
1726{
1727 return wpa_cli_cmd(ctrl, "CHAN_SWITCH", 2, argc, argv);
1728}
1729
e653b622
JM		 1730#endif /* CONFIG_AP */
1731
1732
207ef3fb
JM		 1733static int wpa_cli_cmd_suspend(struct wpa_ctrl *ctrl, int argc, char *argv[])
1734{
1735 return wpa_ctrl_command(ctrl, "SUSPEND");
1736}
1737
1738
1739static int wpa_cli_cmd_resume(struct wpa_ctrl *ctrl, int argc, char *argv[])
1740{
1741 return wpa_ctrl_command(ctrl, "RESUME");
1742}
1743
1744
9ff4de6d 1745#ifdef CONFIG_TESTING_OPTIONS
32d5295f
JM		 1746static int wpa_cli_cmd_drop_sa(struct wpa_ctrl *ctrl, int argc, char *argv[])
1747{
1748 return wpa_ctrl_command(ctrl, "DROP_SA");
1749}
9ff4de6d 1750#endif /* CONFIG_TESTING_OPTIONS */
32d5295f
JM		 1751
1752
86d4f806
JM		 1753static int wpa_cli_cmd_roam(struct wpa_ctrl *ctrl, int argc, char *argv[])
1754{
87c7ba84 1755 return wpa_cli_cmd(ctrl, "ROAM", 1, argc, argv);
86d4f806
JM		 1756}
1757
1758
603a3f34
JL		 1759#ifdef CONFIG_MESH
1760
5b78493f
MH		 1761static int wpa_cli_cmd_mesh_interface_add(struct wpa_ctrl *ctrl, int argc,
1762 char *argv[])
1763{
1764 return wpa_cli_cmd(ctrl, "MESH_INTERFACE_ADD", 0, argc, argv);
1765}
1766
1767
603a3f34
JL		 1768static int wpa_cli_cmd_mesh_group_add(struct wpa_ctrl *ctrl, int argc,
1769 char *argv[])
1770{
1771 return wpa_cli_cmd(ctrl, "MESH_GROUP_ADD", 1, argc, argv);
1772}
1773
1774
1775static int wpa_cli_cmd_mesh_group_remove(struct wpa_ctrl *ctrl, int argc,
1776 char *argv[])
1777{
1778 return wpa_cli_cmd(ctrl, "MESH_GROUP_REMOVE", 1, argc, argv);
1779}
1780
1781#endif /* CONFIG_MESH */
1782
1783
57faa1ce
JM		 1784#ifdef CONFIG_P2P
1785
1786static int wpa_cli_cmd_p2p_find(struct wpa_ctrl *ctrl, int argc, char *argv[])
1787{
87c7ba84 1788 return wpa_cli_cmd(ctrl, "P2P_FIND", 0, argc, argv);
57faa1ce
JM		 1789}
1790
1791
01335e2c
JM		 1792static char ** wpa_cli_complete_p2p_find(const char *str, int pos)
1793{
1794 char **res = NULL;
1795 int arg = get_cmd_arg_num(str, pos);
1796
1797 res = os_calloc(6, sizeof(char *));
1798 if (res == NULL)
1799 return NULL;
1800 res[0] = os_strdup("type=social");
1801 if (res[0] == NULL) {
1802 os_free(res);
1803 return NULL;
1804 }
1805 res[1] = os_strdup("type=progressive");
1806 if (res[1] == NULL)
1807 return res;
1808 res[2] = os_strdup("delay=");
1809 if (res[2] == NULL)
1810 return res;
1811 res[3] = os_strdup("dev_id=");
1812 if (res[3] == NULL)
1813 return res;
1814 if (arg == 1)
1815 res[4] = os_strdup("[timeout]");
1816
1817 return res;
1818}
1819
1820
57faa1ce
JM		 1821static int wpa_cli_cmd_p2p_stop_find(struct wpa_ctrl *ctrl, int argc,
1822 char *argv[])
1823{
1824 return wpa_ctrl_command(ctrl, "P2P_STOP_FIND");
1825}
1826
1827
f309c18e
KV		 1828static int wpa_cli_cmd_p2p_asp_provision(struct wpa_ctrl *ctrl, int argc,
1829 char *argv[])
1830{
1831 return wpa_cli_cmd(ctrl, "P2P_ASP_PROVISION", 3, argc, argv);
1832}
1833
1834
1835static int wpa_cli_cmd_p2p_asp_provision_resp(struct wpa_ctrl *ctrl, int argc,
1836 char *argv[])
1837{
1838 return wpa_cli_cmd(ctrl, "P2P_ASP_PROVISION_RESP", 2, argc, argv);
1839}
1840
1841
57faa1ce
JM		 1842static int wpa_cli_cmd_p2p_connect(struct wpa_ctrl *ctrl, int argc,
1843 char *argv[])
1844{
87c7ba84 1845 return wpa_cli_cmd(ctrl, "P2P_CONNECT", 2, argc, argv);
57faa1ce
JM		 1846}
1847
1848
a624f20b
JM		 1849static char ** wpa_cli_complete_p2p_connect(const char *str, int pos)
1850{
1851 int arg = get_cmd_arg_num(str, pos);
1852 char **res = NULL;
1853
1854 switch (arg) {
1855 case 1:
1856 res = cli_txt_list_array(&p2p_peers);
1857 break;
1858 }
1859
1860 return res;
1861}
1862
1863
57faa1ce
JM		 1864static int wpa_cli_cmd_p2p_listen(struct wpa_ctrl *ctrl, int argc,
1865 char *argv[])
1866{
87c7ba84 1867 return wpa_cli_cmd(ctrl, "P2P_LISTEN", 0, argc, argv);
57faa1ce
JM		 1868}
1869
1870
1871static int wpa_cli_cmd_p2p_group_remove(struct wpa_ctrl *ctrl, int argc,
1872 char *argv[])
1873{
87c7ba84 1874 return wpa_cli_cmd(ctrl, "P2P_GROUP_REMOVE", 1, argc, argv);
57faa1ce
JM		 1875}
1876
1877
76788542
JM		 1878static char ** wpa_cli_complete_p2p_group_remove(const char *str, int pos)
1879{
1880 int arg = get_cmd_arg_num(str, pos);
1881 char **res = NULL;
1882
1883 switch (arg) {
1884 case 1:
1885 res = cli_txt_list_array(&p2p_groups);
1886 break;
1887 }
1888
1889 return res;
1890}
1891
1892
57faa1ce
JM		 1893static int wpa_cli_cmd_p2p_group_add(struct wpa_ctrl *ctrl, int argc,
1894 char *argv[])
1895{
87c7ba84 1896 return wpa_cli_cmd(ctrl, "P2P_GROUP_ADD", 0, argc, argv);
57faa1ce
JM		 1897}
1898
1899
1900static int wpa_cli_cmd_p2p_prov_disc(struct wpa_ctrl *ctrl, int argc,
1901 char *argv[])
1902{
8c5f7309
JJ		 1903 if (argc != 2 && argc != 3) {
1904 printf("Invalid P2P_PROV_DISC command: needs at least "
1905 "two arguments, address and config method\n"
1906 "(display, keypad, or pbc) and an optional join\n");
57faa1ce
JM		 1907 return -1;
1908 }
1909
87c7ba84 1910 return wpa_cli_cmd(ctrl, "P2P_PROV_DISC", 2, argc, argv);
57faa1ce
JM		 1911}
1912
1913
1914static int wpa_cli_cmd_p2p_get_passphrase(struct wpa_ctrl *ctrl, int argc,
1915 char *argv[])
1916{
1917 return wpa_ctrl_command(ctrl, "P2P_GET_PASSPHRASE");
1918}
1919
1920
1921static int wpa_cli_cmd_p2p_serv_disc_req(struct wpa_ctrl *ctrl, int argc,
1922 char *argv[])
1923{
1924 char cmd[4096];
57faa1ce 1925
5a4102ce 1926 if (argc < 2) {
57faa1ce 1927 printf("Invalid P2P_SERV_DISC_REQ command: needs two "
5a4102ce 1928 "or more arguments (address and TLVs)\n");
57faa1ce
JM		 1929 return -1;
1930 }
1931
87c7ba84 1932 if (write_cmd(cmd, sizeof(cmd), "P2P_SERV_DISC_REQ", argc, argv) < 0)
57faa1ce 1933 return -1;
57faa1ce
JM		 1934 return wpa_ctrl_command(ctrl, cmd);
1935}
1936
1937
1938static int wpa_cli_cmd_p2p_serv_disc_cancel_req(struct wpa_ctrl *ctrl,
1939 int argc, char *argv[])
1940{
87c7ba84 1941 return wpa_cli_cmd(ctrl, "P2P_SERV_DISC_CANCEL_REQ", 1, argc, argv);
57faa1ce
JM		 1942}
1943
1944
1945static int wpa_cli_cmd_p2p_serv_disc_resp(struct wpa_ctrl *ctrl, int argc,
1946 char *argv[])
1947{
1948 char cmd[4096];
1949 int res;
1950
1951 if (argc != 4) {
1952 printf("Invalid P2P_SERV_DISC_RESP command: needs four "
1953 "arguments (freq, address, dialog token, and TLVs)\n");
1954 return -1;
1955 }
1956
1957 res = os_snprintf(cmd, sizeof(cmd), "P2P_SERV_DISC_RESP %s %s %s %s",
1958 argv[0], argv[1], argv[2], argv[3]);
d85e1fc8 1959 if (os_snprintf_error(sizeof(cmd), res))
57faa1ce
JM		 1960 return -1;
1961 cmd[sizeof(cmd) - 1] = '\0';
1962 return wpa_ctrl_command(ctrl, cmd);
1963}
1964
1965
1966static int wpa_cli_cmd_p2p_service_update(struct wpa_ctrl *ctrl, int argc,
1967 char *argv[])
1968{
1969 return wpa_ctrl_command(ctrl, "P2P_SERVICE_UPDATE");
1970}
1971
1972
1973static int wpa_cli_cmd_p2p_serv_disc_external(struct wpa_ctrl *ctrl,
1974 int argc, char *argv[])
1975{
87c7ba84 1976 return wpa_cli_cmd(ctrl, "P2P_SERV_DISC_EXTERNAL", 1, argc, argv);
57faa1ce
JM		 1977}
1978
1979
1980static int wpa_cli_cmd_p2p_service_flush(struct wpa_ctrl *ctrl, int argc,
1981 char *argv[])
1982{
1983 return wpa_ctrl_command(ctrl, "P2P_SERVICE_FLUSH");
1984}
1985
1986
1987static int wpa_cli_cmd_p2p_service_add(struct wpa_ctrl *ctrl, int argc,
1988 char *argv[])
1989{
ae9d45f3
KV		 1990 if (argc < 3) {
1991 printf("Invalid P2P_SERVICE_ADD command: needs 3-6 arguments\n");
1992 return -1;
1993 }
57faa1ce 1994
ae9d45f3
KV		 1995 return wpa_cli_cmd(ctrl, "P2P_SERVICE_ADD", 3, argc, argv);
1996}
1997
1998
1999static int wpa_cli_cmd_p2p_service_rep(struct wpa_ctrl *ctrl, int argc,
2000 char *argv[])
2001{
2002 if (argc < 5 || argc > 6) {
2003 printf("Invalid P2P_SERVICE_REP command: needs 5-6 "
57faa1ce
JM		 2004 "arguments\n");
2005 return -1;
2006 }
2007
ae9d45f3 2008 return wpa_cli_cmd(ctrl, "P2P_SERVICE_REP", 5, argc, argv);
57faa1ce
JM		 2009}
2010
2011
2012static int wpa_cli_cmd_p2p_service_del(struct wpa_ctrl *ctrl, int argc,
2013 char *argv[])
2014{
2015 char cmd[4096];
2016 int res;
2017
2018 if (argc != 2 && argc != 3) {
2019 printf("Invalid P2P_SERVICE_DEL command: needs two or three "
2020 "arguments\n");
2021 return -1;
2022 }
2023
2024 if (argc == 3)
2025 res = os_snprintf(cmd, sizeof(cmd),
2026 "P2P_SERVICE_DEL %s %s %s",
2027 argv[0], argv[1], argv[2]);
2028 else
2029 res = os_snprintf(cmd, sizeof(cmd),
2030 "P2P_SERVICE_DEL %s %s",
2031 argv[0], argv[1]);
d85e1fc8 2032 if (os_snprintf_error(sizeof(cmd), res))
57faa1ce
JM		 2033 return -1;
2034 cmd[sizeof(cmd) - 1] = '\0';
2035 return wpa_ctrl_command(ctrl, cmd);
2036}
2037
2038
2039static int wpa_cli_cmd_p2p_reject(struct wpa_ctrl *ctrl,
2040 int argc, char *argv[])
2041{
87c7ba84 2042 return wpa_cli_cmd(ctrl, "P2P_REJECT", 1, argc, argv);
57faa1ce
JM		 2043}
2044
2045
2046static int wpa_cli_cmd_p2p_invite(struct wpa_ctrl *ctrl,
2047 int argc, char *argv[])
2048{
87c7ba84 2049 return wpa_cli_cmd(ctrl, "P2P_INVITE", 1, argc, argv);
57faa1ce
JM		 2050}
2051
2052
2053static int wpa_cli_cmd_p2p_peer(struct wpa_ctrl *ctrl, int argc, char *argv[])
2054{
87c7ba84 2055 return wpa_cli_cmd(ctrl, "P2P_PEER", 1, argc, argv);
57faa1ce
JM		 2056}
2057
2058
a624f20b
JM		 2059static char ** wpa_cli_complete_p2p_peer(const char *str, int pos)
2060{
2061 int arg = get_cmd_arg_num(str, pos);
2062 char **res = NULL;
2063
2064 switch (arg) {
2065 case 1:
2066 res = cli_txt_list_array(&p2p_peers);
2067 break;
2068 }
2069
2070 return res;
2071}
2072
2073
57faa1ce
JM		 2074static int wpa_ctrl_command_p2p_peer(struct wpa_ctrl *ctrl, char *cmd,
2075 char *addr, size_t addr_len,
2076 int discovered)
2077{
2078 char buf[4096], *pos;
2079 size_t len;
2080 int ret;
2081
2082 if (ctrl_conn == NULL)
2083 return -1;
2084 len = sizeof(buf) - 1;
024d018b 2085 ret = wpa_ctrl_request(ctrl, cmd, os_strlen(cmd), buf, &len,
57faa1ce
JM		 2086 wpa_cli_msg_cb);
2087 if (ret == -2) {
2088 printf("'%s' command timed out.\n", cmd);
2089 return -2;
2090 } else if (ret < 0) {
2091 printf("'%s' command failed.\n", cmd);
2092 return -1;
2093 }
2094
2095 buf[len] = '\0';
024d018b 2096 if (os_memcmp(buf, "FAIL", 4) == 0)
57faa1ce
JM		 2097 return -1;
2098
2099 pos = buf;
2100 while (*pos != '\0' && *pos != '\n')
2101 pos++;
2102 *pos++ = '\0';
2103 os_strlcpy(addr, buf, addr_len);
2104 if (!discovered || os_strstr(pos, "[PROBE_REQ_ONLY]") == NULL)
2105 printf("%s\n", addr);
2106 return 0;
2107}
2108
2109
2110static int wpa_cli_cmd_p2p_peers(struct wpa_ctrl *ctrl, int argc, char *argv[])
2111{
2112 char addr[32], cmd[64];
2113 int discovered;
2114
2115 discovered = argc > 0 && os_strcmp(argv[0], "discovered") == 0;
2116
2117 if (wpa_ctrl_command_p2p_peer(ctrl, "P2P_PEER FIRST",
2118 addr, sizeof(addr), discovered))
9a6ade33 2119 return -1;
57faa1ce
JM		 2120 do {
2121 os_snprintf(cmd, sizeof(cmd), "P2P_PEER NEXT-%s", addr);
2122 } while (wpa_ctrl_command_p2p_peer(ctrl, cmd, addr, sizeof(addr),
2123 discovered) == 0);
2124
9a6ade33 2125 return 0;
57faa1ce
JM		 2126}
2127
2128
2129static int wpa_cli_cmd_p2p_set(struct wpa_ctrl *ctrl, int argc, char *argv[])
2130{
87c7ba84 2131 return wpa_cli_cmd(ctrl, "P2P_SET", 2, argc, argv);
57faa1ce
JM		 2132}
2133
2134
698e921b
JM		 2135static char ** wpa_cli_complete_p2p_set(const char *str, int pos)
2136{
2137 int arg = get_cmd_arg_num(str, pos);
2138 const char *fields[] = {
2139 "discoverability",
2140 "managed",
2141 "listen_channel",
2142 "ssid_postfix",
2143 "noa",
2144 "ps",
2145 "oppps",
2146 "ctwindow",
2147 "disabled",
2148 "conc_pref",
2149 "force_long_sd",
2150 "peer_filter",
2151 "cross_connect",
2152 "go_apsd",
2153 "client_apsd",
2154 "disallow_freq",
2155 "disc_int",
05766ed8 2156 "per_sta_psk",
698e921b 2157 };
e7ecab4a 2158 int i, num_fields = ARRAY_SIZE(fields);
698e921b
JM		 2159
2160 if (arg == 1) {
2161 char **res = os_calloc(num_fields + 1, sizeof(char *));
2162 if (res == NULL)
2163 return NULL;
2164 for (i = 0; i < num_fields; i++) {
2165 res[i] = os_strdup(fields[i]);
2166 if (res[i] == NULL)
2167 return res;
2168 }
2169 return res;
2170 }
2171
2172 if (arg == 2 && os_strncasecmp(str, "p2p_set peer_filter ", 20) == 0)
2173 return cli_txt_list_array(&p2p_peers);
2174
2175 return NULL;
2176}
2177
2178
57faa1ce
JM		 2179static int wpa_cli_cmd_p2p_flush(struct wpa_ctrl *ctrl, int argc, char *argv[])
2180{
2181 return wpa_ctrl_command(ctrl, "P2P_FLUSH");
2182}
2183
2184
59eba7a2
JM		 2185static int wpa_cli_cmd_p2p_cancel(struct wpa_ctrl *ctrl, int argc,
2186 char *argv[])
2187{
2188 return wpa_ctrl_command(ctrl, "P2P_CANCEL");
2189}
2190
2191
9d562b79
SS		 2192static int wpa_cli_cmd_p2p_unauthorize(struct wpa_ctrl *ctrl, int argc,
2193 char *argv[])
2194{
87c7ba84 2195 return wpa_cli_cmd(ctrl, "P2P_UNAUTHORIZE", 1, argc, argv);
9d562b79
SS		 2196}
2197
2198
57faa1ce
JM		 2199static int wpa_cli_cmd_p2p_presence_req(struct wpa_ctrl *ctrl, int argc,
2200 char *argv[])
2201{
57faa1ce
JM		 2202 if (argc != 0 && argc != 2 && argc != 4) {
2203 printf("Invalid P2P_PRESENCE_REQ command: needs two arguments "
2204 "(preferred duration, interval; in microsecods).\n"
2205 "Optional second pair can be used to provide "
2206 "acceptable values.\n");
2207 return -1;
2208 }
2209
87c7ba84 2210 return wpa_cli_cmd(ctrl, "P2P_PRESENCE_REQ", 0, argc, argv);
57faa1ce
JM		 2211}
2212
2213
2214static int wpa_cli_cmd_p2p_ext_listen(struct wpa_ctrl *ctrl, int argc,
2215 char *argv[])
2216{
57faa1ce
JM		 2217 if (argc != 0 && argc != 2) {
2218 printf("Invalid P2P_EXT_LISTEN command: needs two arguments "
2219 "(availability period, availability interval; in "
2220 "millisecods).\n"
2221 "Extended Listen Timing can be cancelled with this "
2222 "command when used without parameters.\n");
2223 return -1;
2224 }
2225
87c7ba84 2226 return wpa_cli_cmd(ctrl, "P2P_EXT_LISTEN", 0, argc, argv);
57faa1ce
JM		 2227}
2228
f2c56602
JM		 2229
2230static int wpa_cli_cmd_p2p_remove_client(struct wpa_ctrl *ctrl, int argc,
2231 char *argv[])
2232{
2233 return wpa_cli_cmd(ctrl, "P2P_REMOVE_CLIENT", 1, argc, argv);
2234}
2235
57faa1ce
JM		 2236#endif /* CONFIG_P2P */
2237
9675ce35
JM		 2238#ifdef CONFIG_WIFI_DISPLAY
2239
2240static int wpa_cli_cmd_wfd_subelem_set(struct wpa_ctrl *ctrl, int argc,
2241 char *argv[])
2242{
2243 char cmd[100];
2244 int res;
2245
2246 if (argc != 1 && argc != 2) {
2247 printf("Invalid WFD_SUBELEM_SET command: needs one or two "
2248 "arguments (subelem, hexdump)\n");
2249 return -1;
2250 }
2251
2252 res = os_snprintf(cmd, sizeof(cmd), "WFD_SUBELEM_SET %s %s",
2253 argv[0], argc > 1 ? argv[1] : "");
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
2260
2261static int wpa_cli_cmd_wfd_subelem_get(struct wpa_ctrl *ctrl, int argc,
2262 char *argv[])
2263{
2264 char cmd[100];
2265 int res;
2266
2267 if (argc != 1) {
2268 printf("Invalid WFD_SUBELEM_GET command: needs one "
2269 "argument (subelem)\n");
2270 return -1;
2271 }
2272
2273 res = os_snprintf(cmd, sizeof(cmd), "WFD_SUBELEM_GET %s",
2274 argv[0]);
d85e1fc8 2275 if (os_snprintf_error(sizeof(cmd), res))
9675ce35
JM		 2276 return -1;
2277 cmd[sizeof(cmd) - 1] = '\0';
2278 return wpa_ctrl_command(ctrl, cmd);
2279}
2280#endif /* CONFIG_WIFI_DISPLAY */
2281
57faa1ce 2282
afc064fe
JM		 2283#ifdef CONFIG_INTERWORKING
2284static int wpa_cli_cmd_fetch_anqp(struct wpa_ctrl *ctrl, int argc,
2285 char *argv[])
2286{
2287 return wpa_ctrl_command(ctrl, "FETCH_ANQP");
2288}
2289
2290
2291static int wpa_cli_cmd_stop_fetch_anqp(struct wpa_ctrl *ctrl, int argc,
2292 char *argv[])
2293{
2294 return wpa_ctrl_command(ctrl, "STOP_FETCH_ANQP");
2295}
2296
2297
b02fe7ff
JM		 2298static int wpa_cli_cmd_interworking_select(struct wpa_ctrl *ctrl, int argc,
2299 char *argv[])
2300{
87c7ba84 2301 return wpa_cli_cmd(ctrl, "INTERWORKING_SELECT", 0, argc, argv);
b02fe7ff
JM		 2302}
2303
2304
2305static int wpa_cli_cmd_interworking_connect(struct wpa_ctrl *ctrl, int argc,
2306 char *argv[])
2307{
87c7ba84 2308 return wpa_cli_cmd(ctrl, "INTERWORKING_CONNECT", 1, argc, argv);
b02fe7ff
JM		 2309}
2310
2311
f91a512f
JM		 2312static int wpa_cli_cmd_interworking_add_network(struct wpa_ctrl *ctrl, int argc,
2313 char *argv[])
2314{
2315 return wpa_cli_cmd(ctrl, "INTERWORKING_ADD_NETWORK", 1, argc, argv);
2316}
2317
2318
afc064fe
JM		 2319static int wpa_cli_cmd_anqp_get(struct wpa_ctrl *ctrl, int argc, char *argv[])
2320{
87c7ba84 2321 return wpa_cli_cmd(ctrl, "ANQP_GET", 2, argc, argv);
afc064fe 2322}
b1f12296
JM		 2323
2324
2325static int wpa_cli_cmd_gas_request(struct wpa_ctrl *ctrl, int argc,
2326 char *argv[])
2327{
2328 return wpa_cli_cmd(ctrl, "GAS_REQUEST", 2, argc, argv);
2329}
2330
2331
2332static int wpa_cli_cmd_gas_response_get(struct wpa_ctrl *ctrl, int argc,
2333 char *argv[])
2334{
2335 return wpa_cli_cmd(ctrl, "GAS_RESPONSE_GET", 2, argc, argv);
2336}
afc064fe
JM		 2337#endif /* CONFIG_INTERWORKING */
2338
2339
a8918e86
JK		 2340#ifdef CONFIG_HS20
2341
2342static int wpa_cli_cmd_hs20_anqp_get(struct wpa_ctrl *ctrl, int argc,
2343 char *argv[])
2344{
87c7ba84 2345 return wpa_cli_cmd(ctrl, "HS20_ANQP_GET", 2, argc, argv);
a8918e86
JK		 2346}
2347
2348
2349static int wpa_cli_cmd_get_nai_home_realm_list(struct wpa_ctrl *ctrl, int argc,
2350 char *argv[])
2351{
2352 char cmd[512];
a8918e86
JK		 2353
2354 if (argc == 0) {
2355 printf("Command needs one or two arguments (dst mac addr and "
2356 "optional home realm)\n");
2357 return -1;
2358 }
2359
87c7ba84
JM		 2360 if (write_cmd(cmd, sizeof(cmd), "HS20_GET_NAI_HOME_REALM_LIST",
2361 argc, argv) < 0)
a8918e86 2362 return -1;
a8918e86
JK		 2363
2364 return wpa_ctrl_command(ctrl, cmd);
2365}
2366
184e110c
JM		 2367
2368static int wpa_cli_cmd_hs20_icon_request(struct wpa_ctrl *ctrl, int argc,
2369 char *argv[])
2370{
2371 char cmd[512];
2372
2373 if (argc < 2) {
2374 printf("Command needs two arguments (dst mac addr and "
2375 "icon name)\n");
2376 return -1;
2377 }
2378
2379 if (write_cmd(cmd, sizeof(cmd), "HS20_ICON_REQUEST", argc, argv) < 0)
2380 return -1;
2381
2382 return wpa_ctrl_command(ctrl, cmd);
2383}
2384
b572df86
JM		 2385
2386static int wpa_cli_cmd_fetch_osu(struct wpa_ctrl *ctrl, int argc, char *argv[])
2387{
2388 return wpa_ctrl_command(ctrl, "FETCH_OSU");
2389}
2390
2391
2392static int wpa_cli_cmd_cancel_fetch_osu(struct wpa_ctrl *ctrl, int argc,
2393 char *argv[])
2394{
2395 return wpa_ctrl_command(ctrl, "CANCEL_FETCH_OSU");
2396}
2397
a8918e86
JK		 2398#endif /* CONFIG_HS20 */
2399
2400
0d0a8ca1
AC		 2401static int wpa_cli_cmd_sta_autoconnect(struct wpa_ctrl *ctrl, int argc,
2402 char *argv[])
2403{
87c7ba84 2404 return wpa_cli_cmd(ctrl, "STA_AUTOCONNECT", 1, argc, argv);
0d0a8ca1
AC		 2405}
2406
2407
281ff0aa
GP		 2408static int wpa_cli_cmd_tdls_discover(struct wpa_ctrl *ctrl, int argc,
2409 char *argv[])
2410{
87c7ba84 2411 return wpa_cli_cmd(ctrl, "TDLS_DISCOVER", 1, argc, argv);
281ff0aa
GP		 2412}
2413
2414
2415static int wpa_cli_cmd_tdls_setup(struct wpa_ctrl *ctrl, int argc,
2416 char *argv[])
2417{
87c7ba84 2418 return wpa_cli_cmd(ctrl, "TDLS_SETUP", 1, argc, argv);
281ff0aa
GP		 2419}
2420
2421
2422static int wpa_cli_cmd_tdls_teardown(struct wpa_ctrl *ctrl, int argc,
2423 char *argv[])
2424{
87c7ba84 2425 return wpa_cli_cmd(ctrl, "TDLS_TEARDOWN", 1, argc, argv);
281ff0aa
GP		 2426}
2427
2428
df9d340c
MB		 2429static int wpa_cli_cmd_wmm_ac_addts(struct wpa_ctrl *ctrl, int argc,
2430 char *argv[])
2431{
2432 return wpa_cli_cmd(ctrl, "WMM_AC_ADDTS", 3, argc, argv);
2433}
2434
2435
2436static int wpa_cli_cmd_wmm_ac_delts(struct wpa_ctrl *ctrl, int argc,
2437 char *argv[])
2438{
2439 return wpa_cli_cmd(ctrl, "WMM_AC_DELTS", 1, argc, argv);
2440}
2441
2442
8506ea6f
MB		 2443static int wpa_cli_cmd_wmm_ac_status(struct wpa_ctrl *ctrl, int argc,
2444 char *argv[])
2445{
2446 return wpa_ctrl_command(ctrl, "WMM_AC_STATUS");
2447}
2448
2449
7db53bb8
AN		 2450static int wpa_cli_cmd_tdls_chan_switch(struct wpa_ctrl *ctrl, int argc,
2451 char *argv[])
2452{
2453 return wpa_cli_cmd(ctrl, "TDLS_CHAN_SWITCH", 2, argc, argv);
2454}
2455
2456
2457static int wpa_cli_cmd_tdls_cancel_chan_switch(struct wpa_ctrl *ctrl, int argc,
2458 char *argv[])
2459{
2460 return wpa_cli_cmd(ctrl, "TDLS_CANCEL_CHAN_SWITCH", 1, argc, argv);
2461}
2462
2463
60b24b0d
DS		 2464static int wpa_cli_cmd_signal_poll(struct wpa_ctrl *ctrl, int argc,
2465 char *argv[])
2466{
2467 return wpa_ctrl_command(ctrl, "SIGNAL_POLL");
2468}
2469
2470
dc7785f8
YZ		 2471static int wpa_cli_cmd_pktcnt_poll(struct wpa_ctrl *ctrl, int argc,
2472 char *argv[])
2473{
2474 return wpa_ctrl_command(ctrl, "PKTCNT_POLL");
2475}
2476
2477
9482426e
JM		 2478static int wpa_cli_cmd_reauthenticate(struct wpa_ctrl *ctrl, int argc,
2479 char *argv[])
2480{
2481 return wpa_ctrl_command(ctrl, "REAUTHENTICATE");
2482}
2483
2484
2bdd8342
TB		 2485#ifdef CONFIG_AUTOSCAN
2486
2487static int wpa_cli_cmd_autoscan(struct wpa_ctrl *ctrl, int argc, char *argv[])
2488{
2bdd8342
TB		 2489 if (argc == 0)
2490 return wpa_ctrl_command(ctrl, "AUTOSCAN ");
2491
87c7ba84 2492 return wpa_cli_cmd(ctrl, "AUTOSCAN", 0, argc, argv);
2bdd8342
TB		 2493}
2494
2495#endif /* CONFIG_AUTOSCAN */
2496
2497
e9199e31
JM		 2498#ifdef CONFIG_WNM
2499
2500static int wpa_cli_cmd_wnm_sleep(struct wpa_ctrl *ctrl, int argc, char *argv[])
2501{
2502 return wpa_cli_cmd(ctrl, "WNM_SLEEP", 0, argc, argv);
2503}
2504
65bcd0a9
VK		 2505
2506static int wpa_cli_cmd_wnm_bss_query(struct wpa_ctrl *ctrl, int argc, char *argv[])
2507{
2508 return wpa_cli_cmd(ctrl, "WNM_BSS_QUERY", 1, argc, argv);
2509}
2510
e9199e31
JM		 2511#endif /* CONFIG_WNM */
2512
2513
27b80b5b
JM		 2514static int wpa_cli_cmd_raw(struct wpa_ctrl *ctrl, int argc, char *argv[])
2515{
2516 if (argc == 0)
2517 return -1;
2518 return wpa_cli_cmd(ctrl, argv[0], 0, argc - 1, &argv[1]);
2519}
2520
2521
5e2c3490
JM		 2522#ifdef ANDROID
2523static int wpa_cli_cmd_driver(struct wpa_ctrl *ctrl, int argc, char *argv[])
2524{
2525 return wpa_cli_cmd(ctrl, "DRIVER", 1, argc, argv);
2526}
2527#endif /* ANDROID */
2528
2529
adef8948
BL		 2530static int wpa_cli_cmd_vendor(struct wpa_ctrl *ctrl, int argc, char *argv[])
2531{
2532 return wpa_cli_cmd(ctrl, "VENDOR", 1, argc, argv);
2533}
2534
2535
acb54643
JM		 2536static int wpa_cli_cmd_flush(struct wpa_ctrl *ctrl, int argc, char *argv[])
2537{
2538 return wpa_ctrl_command(ctrl, "FLUSH");
2539}
2540
2541
1f965e62
JM		 2542static int wpa_cli_cmd_radio_work(struct wpa_ctrl *ctrl, int argc, char *argv[])
2543{
2544 return wpa_cli_cmd(ctrl, "RADIO_WORK", 1, argc, argv);
2545}
2546
2547
fad14af9
AK		 2548static int wpa_cli_cmd_neighbor_rep_request(struct wpa_ctrl *ctrl, int argc,
2549 char *argv[])
2550{
2551 return wpa_cli_cmd(ctrl, "NEIGHBOR_REP_REQUEST", 0, argc, argv);
2552}
2553
2554
65d9a5e2
JM		 2555static int wpa_cli_cmd_erp_flush(struct wpa_ctrl *ctrl, int argc, char *argv[])
2556{
2557 return wpa_ctrl_command(ctrl, "ERP_FLUSH");
2558}
2559
2560
8b48e320
IP		 2561static int wpa_cli_cmd_mac_rand_scan(struct wpa_ctrl *ctrl, int argc,
2562 char *argv[])
2563{
2564 return wpa_cli_cmd(ctrl, "MAC_RAND_SCAN", 1, argc, argv);
2565}
2566
2567
40fd868c
ER		 2568enum wpa_cli_cmd_flags {
2569 cli_cmd_flag_none = 0x00,
2570 cli_cmd_flag_sensitive = 0x01
2571};
2572
6fc6879b
JM		 2573struct wpa_cli_cmd {
2574 const char *cmd;
2575 int (*handler)(struct wpa_ctrl *ctrl, int argc, char *argv[]);
b49039bd 2576 char ** (*completion)(const char *str, int pos);
40fd868c 2577 enum wpa_cli_cmd_flags flags;
dfa141b1 2578 const char *usage;
6fc6879b
JM		 2579};
2580
2581static struct wpa_cli_cmd wpa_cli_commands[] = {
b49039bd 2582 { "status", wpa_cli_cmd_status, NULL,
dfa141b1
ER		 2583 cli_cmd_flag_none,
2584 "[verbose] = get current WPA/EAPOL/EAP status" },
b49039bd 2585 { "ifname", wpa_cli_cmd_ifname, NULL,
0eed2a8d
JD		 2586 cli_cmd_flag_none,
2587 "= get current interface name" },
b49039bd 2588 { "ping", wpa_cli_cmd_ping, NULL,
dfa141b1
ER		 2589 cli_cmd_flag_none,
2590 "= pings wpa_supplicant" },
b49039bd 2591 { "relog", wpa_cli_cmd_relog, NULL,
ac6912b5
BG		 2592 cli_cmd_flag_none,
2593 "= re-open log-file (allow rolling logs)" },
b49039bd 2594 { "note", wpa_cli_cmd_note, NULL,
77895cd9
JM		 2595 cli_cmd_flag_none,
2596 "<text> = add a note to wpa_supplicant debug log" },
b49039bd 2597 { "mib", wpa_cli_cmd_mib, NULL,
dfa141b1
ER		 2598 cli_cmd_flag_none,
2599 "= get MIB variables (dot1x, dot11)" },
2af4d404 2600 { "help", wpa_cli_cmd_help, wpa_cli_complete_help,
dfa141b1 2601 cli_cmd_flag_none,
2af4d404 2602 "[command] = show usage help" },
b49039bd 2603 { "interface", wpa_cli_cmd_interface, NULL,
dfa141b1
ER		 2604 cli_cmd_flag_none,
2605 "[ifname] = show interfaces/select interface" },
b49039bd 2606 { "level", wpa_cli_cmd_level, NULL,
dfa141b1
ER		 2607 cli_cmd_flag_none,
2608 "<debug level> = change debug level" },
b49039bd 2609 { "license", wpa_cli_cmd_license, NULL,
dfa141b1
ER		 2610 cli_cmd_flag_none,
2611 "= show full wpa_cli license" },
b49039bd 2612 { "quit", wpa_cli_cmd_quit, NULL,
dfa141b1
ER		 2613 cli_cmd_flag_none,
2614 "= exit wpa_cli" },
21565872 2615 { "set", wpa_cli_cmd_set, wpa_cli_complete_set,
dfa141b1
ER		 2616 cli_cmd_flag_none,
2617 "= set variables (shows list of variables when run without "
2618 "arguments)" },
b49039bd 2619 { "get", wpa_cli_cmd_get, NULL,
acec8d32
JM		 2620 cli_cmd_flag_none,
2621 "<name> = get information" },
b49039bd 2622 { "logon", wpa_cli_cmd_logon, NULL,
dfa141b1
ER		 2623 cli_cmd_flag_none,
2624 "= IEEE 802.1X EAPOL state machine logon" },
b49039bd 2625 { "logoff", wpa_cli_cmd_logoff, NULL,
dfa141b1
ER		 2626 cli_cmd_flag_none,
2627 "= IEEE 802.1X EAPOL state machine logoff" },
b49039bd 2628 { "pmksa", wpa_cli_cmd_pmksa, NULL,
dfa141b1
ER		 2629 cli_cmd_flag_none,
2630 "= show PMKSA cache" },
79e2b1cc
AK		 2631 { "pmksa_flush", wpa_cli_cmd_pmksa_flush, NULL,
2632 cli_cmd_flag_none,
2633 "= flush PMKSA cache entries" },
b49039bd 2634 { "reassociate", wpa_cli_cmd_reassociate, NULL,
dfa141b1
ER		 2635 cli_cmd_flag_none,
2636 "= force reassociation" },
0f44ec8e
PQ		 2637 { "reattach", wpa_cli_cmd_reattach, NULL,
2638 cli_cmd_flag_none,
2639 "= force reassociation back to the same BSS" },
b49039bd 2640 { "preauthenticate", wpa_cli_cmd_preauthenticate, wpa_cli_complete_bss,
dfa141b1
ER		 2641 cli_cmd_flag_none,
2642 "<BSSID> = force preauthentication" },
b49039bd 2643 { "identity", wpa_cli_cmd_identity, NULL,
dfa141b1
ER		 2644 cli_cmd_flag_none,
2645 "<network id> <identity> = configure identity for an SSID" },
b49039bd 2646 { "password", wpa_cli_cmd_password, NULL,
dfa141b1
ER		 2647 cli_cmd_flag_sensitive,
2648 "<network id> <password> = configure password for an SSID" },
b49039bd 2649 { "new_password", wpa_cli_cmd_new_password, NULL,
dfa141b1
ER		 2650 cli_cmd_flag_sensitive,
2651 "<network id> <password> = change password for an SSID" },
b49039bd 2652 { "pin", wpa_cli_cmd_pin, NULL,
dfa141b1
ER		 2653 cli_cmd_flag_sensitive,
2654 "<network id> <pin> = configure pin for an SSID" },
b49039bd 2655 { "otp", wpa_cli_cmd_otp, NULL,
dfa141b1
ER		 2656 cli_cmd_flag_sensitive,
2657 "<network id> <password> = configure one-time-password for an SSID"
2658 },
b49039bd 2659 { "passphrase", wpa_cli_cmd_passphrase, NULL,
dfa141b1
ER		 2660 cli_cmd_flag_sensitive,
2661 "<network id> <passphrase> = configure private key passphrase\n"
2662 " for an SSID" },
a5d44ac0
JM		 2663 { "sim", wpa_cli_cmd_sim, NULL,
2664 cli_cmd_flag_sensitive,
2665 "<network id> <pin> = report SIM operation result" },
b49039bd 2666 { "bssid", wpa_cli_cmd_bssid, NULL,
dfa141b1
ER		 2667 cli_cmd_flag_none,
2668 "<network id> <BSSID> = set preferred BSSID for an SSID" },
b49039bd 2669 { "blacklist", wpa_cli_cmd_blacklist, wpa_cli_complete_bss,
9aa10e2b
DS		 2670 cli_cmd_flag_none,
2671 "<BSSID> = add a BSSID to the blacklist\n"
2672 "blacklist clear = clear the blacklist\n"
2673 "blacklist = display the blacklist" },
b49039bd 2674 { "log_level", wpa_cli_cmd_log_level, NULL,
0597a5b5
DS		 2675 cli_cmd_flag_none,
2676 "<level> [<timestamp>] = update the log level/timestamp\n"
2677 "log_level = display the current log level and log options" },
b49039bd 2678 { "list_networks", wpa_cli_cmd_list_networks, NULL,
dfa141b1
ER		 2679 cli_cmd_flag_none,
2680 "= list configured networks" },
b49039bd 2681 { "select_network", wpa_cli_cmd_select_network, NULL,
dfa141b1
ER		 2682 cli_cmd_flag_none,
2683 "<network id> = select a network (disable others)" },
b49039bd 2684 { "enable_network", wpa_cli_cmd_enable_network, NULL,
dfa141b1
ER		 2685 cli_cmd_flag_none,
2686 "<network id> = enable a network" },
b49039bd 2687 { "disable_network", wpa_cli_cmd_disable_network, NULL,
dfa141b1
ER		 2688 cli_cmd_flag_none,
2689 "<network id> = disable a network" },
b49039bd 2690 { "add_network", wpa_cli_cmd_add_network, NULL,
dfa141b1
ER		 2691 cli_cmd_flag_none,
2692 "= add a network" },
b49039bd 2693 { "remove_network", wpa_cli_cmd_remove_network, NULL,
dfa141b1
ER		 2694 cli_cmd_flag_none,
2695 "<network id> = remove a network" },
b49039bd 2696 { "set_network", wpa_cli_cmd_set_network, NULL,
dfa141b1
ER		 2697 cli_cmd_flag_sensitive,
2698 "<network id> <variable> <value> = set network variables (shows\n"
2699 " list of variables when run without arguments)" },
b49039bd 2700 { "get_network", wpa_cli_cmd_get_network, NULL,
dfa141b1
ER		 2701 cli_cmd_flag_none,
2702 "<network id> <variable> = get network variables" },
1c330a2f
DS		 2703 { "dup_network", wpa_cli_cmd_dup_network, NULL,
2704 cli_cmd_flag_none,
2705 "<src network id> <dst network id> <variable> = duplicate network variables"
2706 },
b49039bd 2707 { "list_creds", wpa_cli_cmd_list_creds, NULL,
d94c9ee6
JM		 2708 cli_cmd_flag_none,
2709 "= list configured credentials" },
b49039bd 2710 { "add_cred", wpa_cli_cmd_add_cred, NULL,
d94c9ee6
JM		 2711 cli_cmd_flag_none,
2712 "= add a credential" },
b49039bd 2713 { "remove_cred", wpa_cli_cmd_remove_cred, NULL,
d94c9ee6
JM		 2714 cli_cmd_flag_none,
2715 "<cred id> = remove a credential" },
b49039bd 2716 { "set_cred", wpa_cli_cmd_set_cred, NULL,
d94c9ee6
JM		 2717 cli_cmd_flag_sensitive,
2718 "<cred id> <variable> <value> = set credential variables" },
c880ab87
JM		 2719 { "get_cred", wpa_cli_cmd_get_cred, NULL,
2720 cli_cmd_flag_none,
2721 "<cred id> <variable> = get credential variables" },
b49039bd 2722 { "save_config", wpa_cli_cmd_save_config, NULL,
dfa141b1
ER		 2723 cli_cmd_flag_none,
2724 "= save the current configuration" },
b49039bd 2725 { "disconnect", wpa_cli_cmd_disconnect, NULL,
dfa141b1
ER		 2726 cli_cmd_flag_none,
2727 "= disconnect and wait for reassociate/reconnect command before\n"
2728 " connecting" },
b49039bd 2729 { "reconnect", wpa_cli_cmd_reconnect, NULL,
dfa141b1
ER		 2730 cli_cmd_flag_none,
2731 "= like reassociate, but only takes effect if already disconnected"
2732 },
b49039bd 2733 { "scan", wpa_cli_cmd_scan, NULL,
dfa141b1
ER		 2734 cli_cmd_flag_none,
2735 "= request new BSS scan" },
b49039bd 2736 { "scan_results", wpa_cli_cmd_scan_results, NULL,
dfa141b1
ER		 2737 cli_cmd_flag_none,
2738 "= get latest scan results" },
b49039bd 2739 { "bss", wpa_cli_cmd_bss, wpa_cli_complete_bss,
dfa141b1
ER		 2740 cli_cmd_flag_none,
2741 "<<idx> | <bssid>> = get detailed scan result info" },
b49039bd 2742 { "get_capability", wpa_cli_cmd_get_capability, NULL,
dfa141b1 2743 cli_cmd_flag_none,
06060522 2744 "<eap/pairwise/group/key_mgmt/proto/auth_alg/channels/freq/modes> "
35aa088a 2745 "= get capabilies" },
b49039bd 2746 { "reconfigure", wpa_cli_cmd_reconfigure, NULL,
dfa141b1
ER		 2747 cli_cmd_flag_none,
2748 "= force wpa_supplicant to re-read its configuration file" },
b49039bd 2749 { "terminate", wpa_cli_cmd_terminate, NULL,
dfa141b1
ER		 2750 cli_cmd_flag_none,
2751 "= terminate wpa_supplicant" },
b49039bd 2752 { "interface_add", wpa_cli_cmd_interface_add, NULL,
dfa141b1
ER		 2753 cli_cmd_flag_none,
2754 "<ifname> <confname> <driver> <ctrl_interface> <driver_param>\n"
2755 " <bridge_name> = adds new interface, all parameters but <ifname>\n"
2756 " are optional" },
b49039bd 2757 { "interface_remove", wpa_cli_cmd_interface_remove, NULL,
dfa141b1
ER		 2758 cli_cmd_flag_none,
2759 "<ifname> = removes the interface" },
b49039bd 2760 { "interface_list", wpa_cli_cmd_interface_list, NULL,
dfa141b1
ER		 2761 cli_cmd_flag_none,
2762 "= list available interfaces" },
b49039bd 2763 { "ap_scan", wpa_cli_cmd_ap_scan, NULL,
dfa141b1
ER		 2764 cli_cmd_flag_none,
2765 "<value> = set ap_scan parameter" },
b49039bd 2766 { "scan_interval", wpa_cli_cmd_scan_interval, NULL,
67b9bd08
DS		 2767 cli_cmd_flag_none,
2768 "<value> = set scan_interval parameter (in seconds)" },
b49039bd 2769 { "bss_expire_age", wpa_cli_cmd_bss_expire_age, NULL,
78633c37
SL		 2770 cli_cmd_flag_none,
2771 "<value> = set BSS expiration age parameter" },
b49039bd 2772 { "bss_expire_count", wpa_cli_cmd_bss_expire_count, NULL,
78633c37
SL		 2773 cli_cmd_flag_none,
2774 "<value> = set BSS expiration scan count parameter" },
b49039bd 2775 { "bss_flush", wpa_cli_cmd_bss_flush, NULL,
39ee845f
DS		 2776 cli_cmd_flag_none,
2777 "<value> = set BSS flush age (0 by default)" },
b49039bd 2778 { "stkstart", wpa_cli_cmd_stkstart, NULL,
dfa141b1
ER		 2779 cli_cmd_flag_none,
2780 "<addr> = request STK negotiation with <addr>" },
b49039bd 2781 { "ft_ds", wpa_cli_cmd_ft_ds, wpa_cli_complete_bss,
dfa141b1
ER		 2782 cli_cmd_flag_none,
2783 "<addr> = request over-the-DS FT with <addr>" },
b49039bd 2784 { "wps_pbc", wpa_cli_cmd_wps_pbc, wpa_cli_complete_bss,
dfa141b1
ER		 2785 cli_cmd_flag_none,
2786 "[BSSID] = start Wi-Fi Protected Setup: Push Button Configuration" },
b49039bd 2787 { "wps_pin", wpa_cli_cmd_wps_pin, wpa_cli_complete_bss,
dfa141b1
ER		 2788 cli_cmd_flag_sensitive,
2789 "<BSSID> [PIN] = start WPS PIN method (returns PIN, if not "
2790 "hardcoded)" },
b49039bd 2791 { "wps_check_pin", wpa_cli_cmd_wps_check_pin, NULL,
3981cb3c
JM		 2792 cli_cmd_flag_sensitive,
2793 "<PIN> = verify PIN checksum" },
b49039bd 2794 { "wps_cancel", wpa_cli_cmd_wps_cancel, NULL, cli_cmd_flag_none,
2f9929ff 2795 "Cancels the pending WPS operation" },
71892384 2796#ifdef CONFIG_WPS_NFC
b49039bd 2797 { "wps_nfc", wpa_cli_cmd_wps_nfc, wpa_cli_complete_bss,
3f2c8ba6
JM		 2798 cli_cmd_flag_none,
2799 "[BSSID] = start Wi-Fi Protected Setup: NFC" },
bbf41865
JM		 2800 { "wps_nfc_config_token", wpa_cli_cmd_wps_nfc_config_token, NULL,
2801 cli_cmd_flag_none,
2802 "<WPS|NDEF> = build configuration token" },
b49039bd 2803 { "wps_nfc_token", wpa_cli_cmd_wps_nfc_token, NULL,
3f2c8ba6
JM		 2804 cli_cmd_flag_none,
2805 "<WPS|NDEF> = create password token" },
b49039bd 2806 { "wps_nfc_tag_read", wpa_cli_cmd_wps_nfc_tag_read, NULL,
d7645d23
JM		 2807 cli_cmd_flag_sensitive,
2808 "<hexdump of payload> = report read NFC tag with WPS data" },
e65552dd
JM		 2809 { "nfc_get_handover_req", wpa_cli_cmd_nfc_get_handover_req, NULL,
2810 cli_cmd_flag_none,
2811 "<NDEF> <WPS> = create NFC handover request" },
2812 { "nfc_get_handover_sel", wpa_cli_cmd_nfc_get_handover_sel, NULL,
2813 cli_cmd_flag_none,
2814 "<NDEF> <WPS> = create NFC handover select" },
e4758827
JM		 2815 { "nfc_report_handover", wpa_cli_cmd_nfc_report_handover, NULL,
2816 cli_cmd_flag_none,
2817 "<role> <type> <hexdump of req> <hexdump of sel> = report completed "
2818 "NFC handover" },
71892384 2819#endif /* CONFIG_WPS_NFC */
b49039bd 2820 { "wps_reg", wpa_cli_cmd_wps_reg, wpa_cli_complete_bss,
dfa141b1
ER		 2821 cli_cmd_flag_sensitive,
2822 "<BSSID> <AP PIN> = start WPS Registrar to configure an AP" },
b49039bd 2823 { "wps_ap_pin", wpa_cli_cmd_wps_ap_pin, NULL,
70d84f11
JM		 2824 cli_cmd_flag_sensitive,
2825 "[params..] = enable/disable AP PIN" },
b49039bd 2826 { "wps_er_start", wpa_cli_cmd_wps_er_start, NULL,
e9bcfebf 2827 cli_cmd_flag_none,
08486685 2828 "[IP address] = start Wi-Fi Protected Setup External Registrar" },
b49039bd 2829 { "wps_er_stop", wpa_cli_cmd_wps_er_stop, NULL,
e9bcfebf
JM		 2830 cli_cmd_flag_none,
2831 "= stop Wi-Fi Protected Setup External Registrar" },
b49039bd 2832 { "wps_er_pin", wpa_cli_cmd_wps_er_pin, NULL,
72df2f5f
JM		 2833 cli_cmd_flag_sensitive,
2834 "<UUID> <PIN> = add an Enrollee PIN to External Registrar" },
b49039bd 2835 { "wps_er_pbc", wpa_cli_cmd_wps_er_pbc, NULL,
564cd7fa
JM		 2836 cli_cmd_flag_none,
2837 "<UUID> = accept an Enrollee PBC using External Registrar" },
b49039bd 2838 { "wps_er_learn", wpa_cli_cmd_wps_er_learn, NULL,
e64dcfd5
JM		 2839 cli_cmd_flag_sensitive,
2840 "<UUID> <PIN> = learn AP configuration" },
b49039bd 2841 { "wps_er_set_config", wpa_cli_cmd_wps_er_set_config, NULL,
ef10f473
JM		 2842 cli_cmd_flag_none,
2843 "<UUID> <network id> = set AP configuration for enrolling" },
b49039bd 2844 { "wps_er_config", wpa_cli_cmd_wps_er_config, NULL,
7d6640a6
JM		 2845 cli_cmd_flag_sensitive,
2846 "<UUID> <PIN> <SSID> <auth> <encr> <key> = configure AP" },
1cea09a9 2847#ifdef CONFIG_WPS_NFC
b49039bd 2848 { "wps_er_nfc_config_token", wpa_cli_cmd_wps_er_nfc_config_token, NULL,
1cea09a9
JM		 2849 cli_cmd_flag_none,
2850 "<WPS/NDEF> <UUID> = build NFC configuration token" },
2851#endif /* CONFIG_WPS_NFC */
b49039bd 2852 { "ibss_rsn", wpa_cli_cmd_ibss_rsn, NULL,
11ef8d35
JM		 2853 cli_cmd_flag_none,
2854 "<addr> = request RSN authentication with <addr> in IBSS" },
e653b622 2855#ifdef CONFIG_AP
b49039bd 2856 { "sta", wpa_cli_cmd_sta, NULL,
e653b622
JM		 2857 cli_cmd_flag_none,
2858 "<addr> = get information about an associated station (AP)" },
b49039bd 2859 { "all_sta", wpa_cli_cmd_all_sta, NULL,
e653b622
JM		 2860 cli_cmd_flag_none,
2861 "= get information about all associated stations (AP)" },
b49039bd 2862 { "deauthenticate", wpa_cli_cmd_deauthenticate, NULL,
e60b2951
JJ		 2863 cli_cmd_flag_none,
2864 "<addr> = deauthenticate a station" },
b49039bd 2865 { "disassociate", wpa_cli_cmd_disassociate, NULL,
e60b2951
JJ		 2866 cli_cmd_flag_none,
2867 "<addr> = disassociate a station" },
334bf36a
AO		 2868 { "chan_switch", wpa_cli_cmd_chanswitch, NULL,
2869 cli_cmd_flag_none,
2870 "<cs_count> <freq> [sec_channel_offset=] [center_freq1=]"
2871 " [center_freq2=] [bandwidth=] [blocktx] [ht|vht]"
2872 " = CSA parameters" },
e653b622 2873#endif /* CONFIG_AP */
b49039bd 2874 { "suspend", wpa_cli_cmd_suspend, NULL, cli_cmd_flag_none,
207ef3fb 2875 "= notification of suspend/hibernate" },
b49039bd 2876 { "resume", wpa_cli_cmd_resume, NULL, cli_cmd_flag_none,
207ef3fb 2877 "= notification of resume/thaw" },
9ff4de6d 2878#ifdef CONFIG_TESTING_OPTIONS
b49039bd 2879 { "drop_sa", wpa_cli_cmd_drop_sa, NULL, cli_cmd_flag_none,
32d5295f 2880 "= drop SA without deauth/disassoc (test command)" },
9ff4de6d 2881#endif /* CONFIG_TESTING_OPTIONS */
b49039bd 2882 { "roam", wpa_cli_cmd_roam, wpa_cli_complete_bss,
86d4f806
JM		 2883 cli_cmd_flag_none,
2884 "<addr> = roam to the specified BSS" },
603a3f34 2885#ifdef CONFIG_MESH
5b78493f
MH		 2886 { "mesh_interface_add", wpa_cli_cmd_mesh_interface_add, NULL,
2887 cli_cmd_flag_none,
2888 "[ifname] = Create a new mesh interface" },
603a3f34
JL		 2889 { "mesh_group_add", wpa_cli_cmd_mesh_group_add, NULL,
2890 cli_cmd_flag_none,
2891 "<network id> = join a mesh network (disable others)" },
2892 { "mesh_group_remove", wpa_cli_cmd_mesh_group_remove, NULL,
2893 cli_cmd_flag_none,
2894 "<ifname> = Remove mesh group interface" },
2895#endif /* CONFIG_MESH */
57faa1ce 2896#ifdef CONFIG_P2P
01335e2c
JM		 2897 { "p2p_find", wpa_cli_cmd_p2p_find, wpa_cli_complete_p2p_find,
2898 cli_cmd_flag_none,
57faa1ce 2899 "[timeout] [type=*] = find P2P Devices for up-to timeout seconds" },
b49039bd 2900 { "p2p_stop_find", wpa_cli_cmd_p2p_stop_find, NULL, cli_cmd_flag_none,
57faa1ce 2901 "= stop P2P Devices search" },
f309c18e
KV		 2902 { "p2p_asp_provision", wpa_cli_cmd_p2p_asp_provision, NULL,
2903 cli_cmd_flag_none,
2904 "<addr> adv_id=<adv_id> conncap=<conncap> [info=<infodata>] = provision with a P2P ASP Device" },
2905 { "p2p_asp_provision_resp", wpa_cli_cmd_p2p_asp_provision_resp, NULL,
2906 cli_cmd_flag_none,
2907 "<addr> adv_id=<adv_id> [role<conncap>] [info=<infodata>] = provision with a P2P ASP Device" },
b49039bd
JM		 2908 { "p2p_connect", wpa_cli_cmd_p2p_connect, wpa_cli_complete_p2p_connect,
2909 cli_cmd_flag_none,
e2308e4b 2910 "<addr> <\"pbc\"|PIN> [ht40] = connect to a P2P Device" },
b49039bd 2911 { "p2p_listen", wpa_cli_cmd_p2p_listen, NULL, cli_cmd_flag_none,
57faa1ce 2912 "[timeout] = listen for P2P Devices for up-to timeout seconds" },
b49039bd
JM		 2913 { "p2p_group_remove", wpa_cli_cmd_p2p_group_remove,
2914 wpa_cli_complete_p2p_group_remove, cli_cmd_flag_none,
4d2ea6a6 2915 "<ifname> = remove P2P group interface (terminate group if GO)" },
b49039bd 2916 { "p2p_group_add", wpa_cli_cmd_p2p_group_add, NULL, cli_cmd_flag_none,
7aeac985 2917 "[ht40] = add a new P2P group (local end as GO)" },
b49039bd
JM		 2918 { "p2p_prov_disc", wpa_cli_cmd_p2p_prov_disc,
2919 wpa_cli_complete_p2p_peer, cli_cmd_flag_none,
57faa1ce 2920 "<addr> <method> = request provisioning discovery" },
b49039bd 2921 { "p2p_get_passphrase", wpa_cli_cmd_p2p_get_passphrase, NULL,
57faa1ce
JM		 2922 cli_cmd_flag_none,
2923 "= get the passphrase for a group (GO only)" },
2924 { "p2p_serv_disc_req", wpa_cli_cmd_p2p_serv_disc_req,
b49039bd 2925 wpa_cli_complete_p2p_peer, cli_cmd_flag_none,
57faa1ce
JM		 2926 "<addr> <TLVs> = schedule service discovery request" },
2927 { "p2p_serv_disc_cancel_req", wpa_cli_cmd_p2p_serv_disc_cancel_req,
b49039bd 2928 NULL, cli_cmd_flag_none,
57faa1ce 2929 "<id> = cancel pending service discovery request" },
b49039bd 2930 { "p2p_serv_disc_resp", wpa_cli_cmd_p2p_serv_disc_resp, NULL,
57faa1ce
JM		 2931 cli_cmd_flag_none,
2932 "<freq> <addr> <dialog token> <TLVs> = service discovery response" },
b49039bd 2933 { "p2p_service_update", wpa_cli_cmd_p2p_service_update, NULL,
57faa1ce
JM		 2934 cli_cmd_flag_none,
2935 "= indicate change in local services" },
b49039bd 2936 { "p2p_serv_disc_external", wpa_cli_cmd_p2p_serv_disc_external, NULL,
57faa1ce
JM		 2937 cli_cmd_flag_none,
2938 "<external> = set external processing of service discovery" },
b49039bd 2939 { "p2p_service_flush", wpa_cli_cmd_p2p_service_flush, NULL,
57faa1ce
JM		 2940 cli_cmd_flag_none,
2941 "= remove all stored service entries" },
b49039bd 2942 { "p2p_service_add", wpa_cli_cmd_p2p_service_add, NULL,
57faa1ce 2943 cli_cmd_flag_none,
ae9d45f3 2944 "<bonjour|upnp|asp> <query|version> <response|service> = add a local "
57faa1ce 2945 "service" },
ae9d45f3
KV		 2946 { "p2p_service_rep", wpa_cli_cmd_p2p_service_rep, NULL,
2947 cli_cmd_flag_none,
2948 "asp <auto> <adv_id> <svc_state> <svc_string> [<svc_info>] = replace "
2949 "local ASP service" },
b49039bd 2950 { "p2p_service_del", wpa_cli_cmd_p2p_service_del, NULL,
57faa1ce
JM		 2951 cli_cmd_flag_none,
2952 "<bonjour|upnp> <query|version> [|service] = remove a local "
2953 "service" },
b49039bd 2954 { "p2p_reject", wpa_cli_cmd_p2p_reject, wpa_cli_complete_p2p_peer,
57faa1ce
JM		 2955 cli_cmd_flag_none,
2956 "<addr> = reject connection attempts from a specific peer" },
b49039bd 2957 { "p2p_invite", wpa_cli_cmd_p2p_invite, NULL,
57faa1ce
JM		 2958 cli_cmd_flag_none,
2959 "<cmd> [peer=addr] = invite peer" },
b49039bd 2960 { "p2p_peers", wpa_cli_cmd_p2p_peers, NULL, cli_cmd_flag_none,
57faa1ce
JM		 2961 "[discovered] = list known (optionally, only fully discovered) P2P "
2962 "peers" },
b49039bd
JM		 2963 { "p2p_peer", wpa_cli_cmd_p2p_peer, wpa_cli_complete_p2p_peer,
2964 cli_cmd_flag_none,
57faa1ce 2965 "<address> = show information about known P2P peer" },
698e921b
JM		 2966 { "p2p_set", wpa_cli_cmd_p2p_set, wpa_cli_complete_p2p_set,
2967 cli_cmd_flag_none,
57faa1ce 2968 "<field> <value> = set a P2P parameter" },
b49039bd 2969 { "p2p_flush", wpa_cli_cmd_p2p_flush, NULL, cli_cmd_flag_none,
57faa1ce 2970 "= flush P2P state" },
b49039bd 2971 { "p2p_cancel", wpa_cli_cmd_p2p_cancel, NULL, cli_cmd_flag_none,
59eba7a2 2972 "= cancel P2P group formation" },
b49039bd
JM		 2973 { "p2p_unauthorize", wpa_cli_cmd_p2p_unauthorize,
2974 wpa_cli_complete_p2p_peer, cli_cmd_flag_none,
9d562b79 2975 "<address> = unauthorize a peer" },
b49039bd
JM		 2976 { "p2p_presence_req", wpa_cli_cmd_p2p_presence_req, NULL,
2977 cli_cmd_flag_none,
57faa1ce
JM		 2978 "[<duration> <interval>] [<duration> <interval>] = request GO "
2979 "presence" },
b49039bd
JM		 2980 { "p2p_ext_listen", wpa_cli_cmd_p2p_ext_listen, NULL,
2981 cli_cmd_flag_none,
57faa1ce 2982 "[<period> <interval>] = set extended listen timing" },
f2c56602
JM		 2983 { "p2p_remove_client", wpa_cli_cmd_p2p_remove_client,
2984 wpa_cli_complete_p2p_peer, cli_cmd_flag_none,
2985 "<address|iface=address> = remove a peer from all groups" },
57faa1ce 2986#endif /* CONFIG_P2P */
9675ce35
JM		 2987#ifdef CONFIG_WIFI_DISPLAY
2988 { "wfd_subelem_set", wpa_cli_cmd_wfd_subelem_set, NULL,
2989 cli_cmd_flag_none,
2990 "<subelem> [contents] = set Wi-Fi Display subelement" },
2991 { "wfd_subelem_get", wpa_cli_cmd_wfd_subelem_get, NULL,
2992 cli_cmd_flag_none,
2993 "<subelem> = get Wi-Fi Display subelement" },
2994#endif /* CONFIG_WIFI_DISPLAY */
afc064fe 2995#ifdef CONFIG_INTERWORKING
b49039bd 2996 { "fetch_anqp", wpa_cli_cmd_fetch_anqp, NULL, cli_cmd_flag_none,
afc064fe 2997 "= fetch ANQP information for all APs" },
b49039bd
JM		 2998 { "stop_fetch_anqp", wpa_cli_cmd_stop_fetch_anqp, NULL,
2999 cli_cmd_flag_none,
afc064fe 3000 "= stop fetch_anqp operation" },
b49039bd 3001 { "interworking_select", wpa_cli_cmd_interworking_select, NULL,
b02fe7ff
JM		 3002 cli_cmd_flag_none,
3003 "[auto] = perform Interworking network selection" },
3004 { "interworking_connect", wpa_cli_cmd_interworking_connect,
b49039bd 3005 wpa_cli_complete_bss, cli_cmd_flag_none,
b02fe7ff 3006 "<BSSID> = connect using Interworking credentials" },
f91a512f
JM		 3007 { "interworking_add_network", wpa_cli_cmd_interworking_add_network,
3008 wpa_cli_complete_bss, cli_cmd_flag_none,
3009 "<BSSID> = connect using Interworking credentials" },
b49039bd
JM		 3010 { "anqp_get", wpa_cli_cmd_anqp_get, wpa_cli_complete_bss,
3011 cli_cmd_flag_none,
afc064fe 3012 "<addr> <info id>[,<info id>]... = request ANQP information" },
b1f12296
JM		 3013 { "gas_request", wpa_cli_cmd_gas_request, wpa_cli_complete_bss,
3014 cli_cmd_flag_none,
3015 "<addr> <AdvProtoID> [QueryReq] = GAS request" },
3016 { "gas_response_get", wpa_cli_cmd_gas_response_get,
3017 wpa_cli_complete_bss, cli_cmd_flag_none,
3018 "<addr> <dialog token> [start,len] = Fetch last GAS response" },
afc064fe 3019#endif /* CONFIG_INTERWORKING */
a8918e86 3020#ifdef CONFIG_HS20
b49039bd
JM		 3021 { "hs20_anqp_get", wpa_cli_cmd_hs20_anqp_get, wpa_cli_complete_bss,
3022 cli_cmd_flag_none,
a8918e86
JK		 3023 "<addr> <subtype>[,<subtype>]... = request HS 2.0 ANQP information"
3024 },
3025 { "nai_home_realm_list", wpa_cli_cmd_get_nai_home_realm_list,
b49039bd 3026 wpa_cli_complete_bss, cli_cmd_flag_none,
a8918e86 3027 "<addr> <home realm> = get HS20 nai home realm list" },
184e110c
JM		 3028 { "hs20_icon_request", wpa_cli_cmd_hs20_icon_request,
3029 wpa_cli_complete_bss, cli_cmd_flag_none,
3030 "<addr> <icon name> = get Hotspot 2.0 OSU icon" },
b572df86
JM		 3031 { "fetch_osu", wpa_cli_cmd_fetch_osu, NULL, cli_cmd_flag_none,
3032 "= fetch OSU provider information from all APs" },
3033 { "cancel_fetch_osu", wpa_cli_cmd_cancel_fetch_osu, NULL,
3034 cli_cmd_flag_none,
3035 "= cancel fetch_osu command" },
a8918e86 3036#endif /* CONFIG_HS20 */
b49039bd
JM		 3037 { "sta_autoconnect", wpa_cli_cmd_sta_autoconnect, NULL,
3038 cli_cmd_flag_none,
0d0a8ca1 3039 "<0/1> = disable/enable automatic reconnection" },
b49039bd 3040 { "tdls_discover", wpa_cli_cmd_tdls_discover, NULL,
281ff0aa
GP		 3041 cli_cmd_flag_none,
3042 "<addr> = request TDLS discovery with <addr>" },
b49039bd 3043 { "tdls_setup", wpa_cli_cmd_tdls_setup, NULL,
281ff0aa
GP		 3044 cli_cmd_flag_none,
3045 "<addr> = request TDLS setup with <addr>" },
b49039bd 3046 { "tdls_teardown", wpa_cli_cmd_tdls_teardown, NULL,
281ff0aa
GP		 3047 cli_cmd_flag_none,
3048 "<addr> = tear down TDLS with <addr>" },
df9d340c
MB		 3049 { "wmm_ac_addts", wpa_cli_cmd_wmm_ac_addts, NULL,
3050 cli_cmd_flag_none,
3051 "<uplink/downlink/bidi> <tsid=0..7> <up=0..7> [nominal_msdu_size=#] "
3052 "[mean_data_rate=#] [min_phy_rate=#] [sba=#] [fixed_nominal_msdu] "
3053 "= add WMM-AC traffic stream" },
3054 { "wmm_ac_delts", wpa_cli_cmd_wmm_ac_delts, NULL,
3055 cli_cmd_flag_none,
3056 "<tsid> = delete WMM-AC traffic stream" },
8506ea6f
MB		 3057 { "wmm_ac_status", wpa_cli_cmd_wmm_ac_status, NULL,
3058 cli_cmd_flag_none,
3059 "= show status for Wireless Multi-Media Admission-Control" },
7db53bb8
AN		 3060 { "tdls_chan_switch", wpa_cli_cmd_tdls_chan_switch, NULL,
3061 cli_cmd_flag_none,
3062 "<addr> <oper class> <freq> [sec_channel_offset=] [center_freq1=] "
3063 "[center_freq2=] [bandwidth=] [ht|vht] = enable channel switching "
3064 "with TDLS peer" },
3065 { "tdls_cancel_chan_switch", wpa_cli_cmd_tdls_cancel_chan_switch, NULL,
3066 cli_cmd_flag_none,
3067 "<addr> = disable channel switching with TDLS peer <addr>" },
b49039bd 3068 { "signal_poll", wpa_cli_cmd_signal_poll, NULL,
60b24b0d
DS		 3069 cli_cmd_flag_none,
3070 "= get signal parameters" },
dc7785f8
YZ		 3071 { "pktcnt_poll", wpa_cli_cmd_pktcnt_poll, NULL,
3072 cli_cmd_flag_none,
3073 "= get TX/RX packet counters" },
b49039bd
JM		 3074 { "reauthenticate", wpa_cli_cmd_reauthenticate, NULL,
3075 cli_cmd_flag_none,
9482426e 3076 "= trigger IEEE 802.1X/EAPOL reauthentication" },
2bdd8342 3077#ifdef CONFIG_AUTOSCAN
b49039bd 3078 { "autoscan", wpa_cli_cmd_autoscan, NULL, cli_cmd_flag_none,
2bdd8342
TB		 3079 "[params] = Set or unset (if none) autoscan parameters" },
3080#endif /* CONFIG_AUTOSCAN */
e9199e31
JM		 3081#ifdef CONFIG_WNM
3082 { "wnm_sleep", wpa_cli_cmd_wnm_sleep, NULL, cli_cmd_flag_none,
3083 "<enter/exit> [interval=#] = enter/exit WNM-Sleep mode" },
65bcd0a9
VK		 3084 { "wnm_bss_query", wpa_cli_cmd_wnm_bss_query, NULL, cli_cmd_flag_none,
3085 "<query reason> = Send BSS Transition Management Query" },
e9199e31 3086#endif /* CONFIG_WNM */
b49039bd 3087 { "raw", wpa_cli_cmd_raw, NULL, cli_cmd_flag_sensitive,
27b80b5b 3088 "<params..> = Sent unprocessed command" },
acb54643
JM		 3089 { "flush", wpa_cli_cmd_flush, NULL, cli_cmd_flag_none,
3090 "= flush wpa_supplicant state" },
5e2c3490
JM		 3091#ifdef ANDROID
3092 { "driver", wpa_cli_cmd_driver, NULL, cli_cmd_flag_none,
3093 "<command> = driver private commands" },
3094#endif /* ANDROID */
1f965e62
JM		 3095 { "radio_work", wpa_cli_cmd_radio_work, NULL, cli_cmd_flag_none,
3096 "= radio_work <show/add/done>" },
adef8948
BL		 3097 { "vendor", wpa_cli_cmd_vendor, NULL, cli_cmd_flag_none,
3098 "<vendor id> <command id> [<hex formatted command argument>] = Send vendor command"
3099 },
66d21434
AK		 3100 { "neighbor_rep_request",
3101 wpa_cli_cmd_neighbor_rep_request, NULL, cli_cmd_flag_none,
3102 "[ssid=<SSID>] = Trigger request to AP for neighboring AP report "
3103 "(with optional given SSID, default: current SSID)"
3104 },
65d9a5e2
JM		 3105 { "erp_flush", wpa_cli_cmd_erp_flush, NULL, cli_cmd_flag_none,
3106 "= flush ERP keys" },
8b48e320
IP		 3107 { "mac_rand_scan",
3108 wpa_cli_cmd_mac_rand_scan, NULL, cli_cmd_flag_none,
3109 "<scan|sched|pno|all> enable=<0/1> [addr=mac-address "
3110 "mask=mac-address-mask] = scan MAC randomization"
3111 },
b49039bd 3112 { NULL, NULL, NULL, cli_cmd_flag_none, NULL }
6fc6879b
JM		 3113};
3114
3115
dfa141b1
ER		 3116/*
3117 * Prints command usage, lines are padded with the specified string.
3118 */
3119static void print_cmd_help(struct wpa_cli_cmd *cmd, const char *pad)
3120{
3121 char c;
3122 size_t n;
3123
3124 printf("%s%s ", pad, cmd->cmd);
3125 for (n = 0; (c = cmd->usage[n]); n++) {
3126 printf("%c", c);
3127 if (c == '\n')
3128 printf("%s", pad);
3129 }
3130 printf("\n");
3131}
3132
3133
2af4d404 3134static void print_help(const char *cmd)
dfa141b1
ER		 3135{
3136 int n;
3137 printf("commands:\n");
2af4d404
JM		 3138 for (n = 0; wpa_cli_commands[n].cmd; n++) {
3139 if (cmd == NULL || str_starts(wpa_cli_commands[n].cmd, cmd))
3140 print_cmd_help(&wpa_cli_commands[n], " ");
3141 }
dfa141b1
ER		 3142}
3143
3144
e8ecb5fb 3145static int wpa_cli_edit_filter_history_cb(void *ctx, const char *cmd)
40fd868c
ER		 3146{
3147 const char *c, *delim;
3148 int n;
3149 size_t len;
3150
3151 delim = os_strchr(cmd, ' ');
3152 if (delim)
3153 len = delim - cmd;
3154 else
3155 len = os_strlen(cmd);
3156
3157 for (n = 0; (c = wpa_cli_commands[n].cmd); n++) {
3158 if (os_strncasecmp(cmd, c, len) == 0 && len == os_strlen(c))
3159 return (wpa_cli_commands[n].flags &
3160 cli_cmd_flag_sensitive);
3161 }
3162 return 0;
3163}
e8ecb5fb
JM		 3164
3165
3166static char ** wpa_list_cmd_list(void)
3167{
3168 char **res;
3169 int i, count;
37620493 3170 struct cli_txt_entry *e;
e8ecb5fb 3171
e7ecab4a 3172 count = ARRAY_SIZE(wpa_cli_commands);
37620493
JM		 3173 count += dl_list_len(&p2p_groups);
3174 count += dl_list_len(&ifnames);
3175 res = os_calloc(count + 1, sizeof(char *));
e8ecb5fb
JM		 3176 if (res == NULL)
3177 return NULL;
3178
3179 for (i = 0; wpa_cli_commands[i].cmd; i++) {
3180 res[i] = os_strdup(wpa_cli_commands[i].cmd);
3181 if (res[i] == NULL)
3182 break;
3183 }
3184
37620493
JM		 3185 dl_list_for_each(e, &p2p_groups, struct cli_txt_entry, list) {
3186 size_t len = 8 + os_strlen(e->txt);
3187 res[i] = os_malloc(len);
3188 if (res[i] == NULL)
3189 break;
3190 os_snprintf(res[i], len, "ifname=%s", e->txt);
3191 i++;
3192 }
3193
3194 dl_list_for_each(e, &ifnames, struct cli_txt_entry, list) {
3195 res[i] = os_strdup(e->txt);
3196 if (res[i] == NULL)
3197 break;
3198 i++;
3199 }
3200
e8ecb5fb
JM		 3201 return res;
3202}
3203
3204
3205static char ** wpa_cli_cmd_completion(const char *cmd, const char *str,
3206 int pos)
3207{
3208 int i;
3209
3210 for (i = 0; wpa_cli_commands[i].cmd; i++) {
3211 if (os_strcasecmp(wpa_cli_commands[i].cmd, cmd) == 0) {
e4f6873c
JM		 3212 if (wpa_cli_commands[i].completion)
3213 return wpa_cli_commands[i].completion(str,
3214 pos);
e8ecb5fb
JM		 3215 edit_clear_line();
3216 printf("\r%s\n", wpa_cli_commands[i].usage);
3217 edit_redraw();
3218 break;
3219 }
3220 }
3221
3222 return NULL;
3223}
3224
3225
3226static char ** wpa_cli_edit_completion_cb(void *ctx, const char *str, int pos)
3227{
3228 char **res;
3229 const char *end;
3230 char *cmd;
3231
37620493
JM		 3232 if (pos > 7 && os_strncasecmp(str, "IFNAME=", 7) == 0) {
3233 end = os_strchr(str, ' ');
3234 if (end && pos > end - str) {
3235 pos -= end - str + 1;
3236 str = end + 1;
3237 }
3238 }
3239
e8ecb5fb
JM		 3240 end = os_strchr(str, ' ');
3241 if (end == NULL || str + pos < end)
3242 return wpa_list_cmd_list();
3243
3244 cmd = os_malloc(pos + 1);
3245 if (cmd == NULL)
3246 return NULL;
3247 os_memcpy(cmd, str, pos);
3248 cmd[end - str] = '\0';
3249 res = wpa_cli_cmd_completion(cmd, str, pos);
3250 os_free(cmd);
3251 return res;
3252}
40fd868c
ER		 3253
3254
6fc6879b
JM		 3255static int wpa_request(struct wpa_ctrl *ctrl, int argc, char *argv[])
3256{
3257 struct wpa_cli_cmd *cmd, *match = NULL;
3258 int count;
3259 int ret = 0;
3260
13b11ba7
JM		 3261 if (argc > 1 && os_strncasecmp(argv[0], "IFNAME=", 7) == 0) {
3262 ifname_prefix = argv[0] + 7;
3263 argv = &argv[1];
3264 argc--;
3265 } else
3266 ifname_prefix = NULL;
3267
3268 if (argc == 0)
3269 return -1;
3270
6fc6879b
JM		 3271 count = 0;
3272 cmd = wpa_cli_commands;
3273 while (cmd->cmd) {
3274 if (os_strncasecmp(cmd->cmd, argv[0], os_strlen(argv[0])) == 0)
3275 {
3276 match = cmd;
3277 if (os_strcasecmp(cmd->cmd, argv[0]) == 0) {
3278 /* we have an exact match */
3279 count = 1;
3280 break;
3281 }
3282 count++;
3283 }
3284 cmd++;
3285 }
3286
3287 if (count > 1) {
3288 printf("Ambiguous command '%s'; possible commands:", argv[0]);
3289 cmd = wpa_cli_commands;
3290 while (cmd->cmd) {
3291 if (os_strncasecmp(cmd->cmd, argv[0],
3292 os_strlen(argv[0])) == 0) {
3293 printf(" %s", cmd->cmd);
3294 }
3295 cmd++;
3296 }
3297 printf("\n");
3298 ret = 1;
3299 } else if (count == 0) {
3300 printf("Unknown command '%s'\n", argv[0]);
3301 ret = 1;
3302 } else {
3303 ret = match->handler(ctrl, argc - 1, &argv[1]);
3304 }
3305
3306 return ret;
3307}
3308
3309
3310static int str_match(const char *a, const char *b)
3311{
3312 return os_strncmp(a, b, os_strlen(b)) == 0;
3313}
3314
3315
3316static int wpa_cli_exec(const char *program, const char *arg1,
3317 const char *arg2)
3318{
c5f258de 3319 char *arg;
6fc6879b
JM		 3320 size_t len;
3321 int res;
3322
c5f258de
JM		 3323 len = os_strlen(arg1) + os_strlen(arg2) + 2;
3324 arg = os_malloc(len);
3325 if (arg == NULL)
6fc6879b 3326 return -1;
c5f258de
JM		 3327 os_snprintf(arg, len, "%s %s", arg1, arg2);
3328 res = os_exec(program, arg, 1);
3329 os_free(arg);
6fc6879b 3330
c5f258de 3331 return res;
6fc6879b
JM		 3332}
3333
3334
3335static void wpa_cli_action_process(const char *msg)
3336{
3337 const char *pos;
3338 char *copy = NULL, *id, *pos2;
55c2bfa9
JM		 3339 const char *ifname = ctrl_ifname;
3340 char ifname_buf[100];
6fc6879b
JM		 3341
3342 pos = msg;
55c2bfa9
JM		 3343 if (os_strncmp(pos, "IFNAME=", 7) == 0) {
3344 const char *end;
3345 end = os_strchr(pos + 7, ' ');
3346 if (end && (unsigned int) (end - pos) < sizeof(ifname_buf)) {
3347 pos += 7;
3348 os_memcpy(ifname_buf, pos, end - pos);
3349 ifname_buf[end - pos] = '\0';
3350 ifname = ifname_buf;
3351 pos = end + 1;
3352 }
3353 }
6fc6879b 3354 if (*pos == '<') {
55c2bfa9 3355 const char *prev = pos;
6fc6879b
JM		 3356 /* skip priority */
3357 pos = os_strchr(pos, '>');
3358 if (pos)
3359 pos++;
3360 else
55c2bfa9 3361 pos = prev;
6fc6879b
JM		 3362 }
3363
3364 if (str_match(pos, WPA_EVENT_CONNECTED)) {
3365 int new_id = -1;
3366 os_unsetenv("WPA_ID");
3367 os_unsetenv("WPA_ID_STR");
3368 os_unsetenv("WPA_CTRL_DIR");
3369
3370 pos = os_strstr(pos, "[id=");
3371 if (pos)
3372 copy = os_strdup(pos + 4);
3373
3374 if (copy) {
3375 pos2 = id = copy;
3376 while (*pos2 && *pos2 != ' ')
3377 pos2++;
3378 *pos2++ = '\0';
3379 new_id = atoi(id);
3380 os_setenv("WPA_ID", id, 1);
3381 while (*pos2 && *pos2 != '=')
3382 pos2++;
3383 if (*pos2 == '=')
3384 pos2++;
3385 id = pos2;
3386 while (*pos2 && *pos2 != ']')
3387 pos2++;
3388 *pos2 = '\0';
3389 os_setenv("WPA_ID_STR", id, 1);
3390 os_free(copy);
3391 }
3392
3393 os_setenv("WPA_CTRL_DIR", ctrl_iface_dir, 1);
3394
02a3e5c0 3395 if (wpa_cli_connected <= 0 || new_id != wpa_cli_last_id) {
6fc6879b
JM		 3396 wpa_cli_connected = 1;
3397 wpa_cli_last_id = new_id;
55c2bfa9 3398 wpa_cli_exec(action_file, ifname, "CONNECTED");
6fc6879b
JM		 3399 }
3400 } else if (str_match(pos, WPA_EVENT_DISCONNECTED)) {
3401 if (wpa_cli_connected) {
3402 wpa_cli_connected = 0;
55c2bfa9 3403 wpa_cli_exec(action_file, ifname, "DISCONNECTED");
6fc6879b 3404 }
44a1662a
MH		 3405 } else if (str_match(pos, MESH_GROUP_STARTED)) {
3406 wpa_cli_exec(action_file, ctrl_ifname, pos);
3407 } else if (str_match(pos, MESH_GROUP_REMOVED)) {
3408 wpa_cli_exec(action_file, ctrl_ifname, pos);
3409 } else if (str_match(pos, MESH_PEER_CONNECTED)) {
3410 wpa_cli_exec(action_file, ctrl_ifname, pos);
3411 } else if (str_match(pos, MESH_PEER_DISCONNECTED)) {
3412 wpa_cli_exec(action_file, ctrl_ifname, pos);
42f0101b 3413 } else if (str_match(pos, P2P_EVENT_GROUP_STARTED)) {
55c2bfa9 3414 wpa_cli_exec(action_file, ifname, pos);
42f0101b 3415 } else if (str_match(pos, P2P_EVENT_GROUP_REMOVED)) {
55c2bfa9 3416 wpa_cli_exec(action_file, ifname, pos);
72044390 3417 } else if (str_match(pos, P2P_EVENT_CROSS_CONNECT_ENABLE)) {
55c2bfa9 3418 wpa_cli_exec(action_file, ifname, pos);
72044390 3419 } else if (str_match(pos, P2P_EVENT_CROSS_CONNECT_DISABLE)) {
55c2bfa9 3420 wpa_cli_exec(action_file, ifname, pos);
e670738a 3421 } else if (str_match(pos, P2P_EVENT_GO_NEG_FAILURE)) {
55c2bfa9 3422 wpa_cli_exec(action_file, ifname, pos);
876103dc 3423 } else if (str_match(pos, WPS_EVENT_SUCCESS)) {
55c2bfa9 3424 wpa_cli_exec(action_file, ifname, pos);
876103dc 3425 } else if (str_match(pos, WPS_EVENT_FAIL)) {
55c2bfa9 3426 wpa_cli_exec(action_file, ifname, pos);
653c4893 3427 } else if (str_match(pos, AP_STA_CONNECTED)) {
55c2bfa9 3428 wpa_cli_exec(action_file, ifname, pos);
653c4893 3429 } else if (str_match(pos, AP_STA_DISCONNECTED)) {
55c2bfa9 3430 wpa_cli_exec(action_file, ifname, pos);
ae8535b6 3431 } else if (str_match(pos, ESS_DISASSOC_IMMINENT)) {
55c2bfa9 3432 wpa_cli_exec(action_file, ifname, pos);
95a3ea94 3433 } else if (str_match(pos, HS20_SUBSCRIPTION_REMEDIATION)) {
55c2bfa9 3434 wpa_cli_exec(action_file, ifname, pos);
7ef69479 3435 } else if (str_match(pos, HS20_DEAUTH_IMMINENT_NOTICE)) {
55c2bfa9 3436 wpa_cli_exec(action_file, ifname, pos);
6fc6879b
JM		 3437 } else if (str_match(pos, WPA_EVENT_TERMINATING)) {
3438 printf("wpa_supplicant is terminating - stop monitoring\n");
3439 wpa_cli_quit = 1;
3440 }
3441}
3442
3443
3444#ifndef CONFIG_ANSI_C_EXTRA
3445static void wpa_cli_action_cb(char *msg, size_t len)
3446{
3447 wpa_cli_action_process(msg);
3448}
3449#endif /* CONFIG_ANSI_C_EXTRA */
3450
3451
3452static void wpa_cli_reconnect(void)
3453{
3454 wpa_cli_close_connection();
059d3a90
JM		 3455 if (wpa_cli_open_connection(ctrl_ifname, 1) < 0)
3456 return;
3457
3458 if (interactive) {
3459 edit_clear_line();
3460 printf("\rConnection to wpa_supplicant re-established\n");
3461 edit_redraw();
3462 }
6fc6879b
JM		 3463}
3464
3465
a624f20b
JM		 3466static void cli_event(const char *str)
3467{
3468 const char *start, *s;
3469
3470 start = os_strchr(str, '>');
3471 if (start == NULL)
3472 return;
3473
3474 start++;
3475
3476 if (str_starts(start, WPA_EVENT_BSS_ADDED)) {
3477 s = os_strchr(start, ' ');
3478 if (s == NULL)
3479 return;
3480 s = os_strchr(s + 1, ' ');
3481 if (s == NULL)
3482 return;
3483 cli_txt_list_add(&bsses, s + 1);
3484 return;
3485 }
3486
3487 if (str_starts(start, WPA_EVENT_BSS_REMOVED)) {
3488 s = os_strchr(start, ' ');
3489 if (s == NULL)
3490 return;
3491 s = os_strchr(s + 1, ' ');
3492 if (s == NULL)
3493 return;
3494 cli_txt_list_del_addr(&bsses, s + 1);
3495 return;
3496 }
3497
3498#ifdef CONFIG_P2P
3499 if (str_starts(start, P2P_EVENT_DEVICE_FOUND)) {
3500 s = os_strstr(start, " p2p_dev_addr=");
3501 if (s == NULL)
3502 return;
3503 cli_txt_list_add_addr(&p2p_peers, s + 14);
3504 return;
3505 }
3506
3507 if (str_starts(start, P2P_EVENT_DEVICE_LOST)) {
3508 s = os_strstr(start, " p2p_dev_addr=");
3509 if (s == NULL)
3510 return;
3511 cli_txt_list_del_addr(&p2p_peers, s + 14);
3512 return;
3513 }
76788542
JM		 3514
3515 if (str_starts(start, P2P_EVENT_GROUP_STARTED)) {
3516 s = os_strchr(start, ' ');
3517 if (s == NULL)
3518 return;
3519 cli_txt_list_add_word(&p2p_groups, s + 1);
3520 return;
3521 }
3522
3523 if (str_starts(start, P2P_EVENT_GROUP_REMOVED)) {
3524 s = os_strchr(start, ' ');
3525 if (s == NULL)
3526 return;
3527 cli_txt_list_del_word(&p2p_groups, s + 1);
3528 return;
3529 }
a624f20b
JM		 3530#endif /* CONFIG_P2P */
3531}
3532
3533
059d3a90
JM		 3534static int check_terminating(const char *msg)
3535{
3536 const char *pos = msg;
3537
3538 if (*pos == '<') {
3539 /* skip priority */
3540 pos = os_strchr(pos, '>');
3541 if (pos)
3542 pos++;
3543 else
3544 pos = msg;
3545 }
3546
3547 if (str_match(pos, WPA_EVENT_TERMINATING) && ctrl_conn) {
3548 edit_clear_line();
3549 printf("\rConnection to wpa_supplicant lost - trying to "
3550 "reconnect\n");
3551 edit_redraw();
3552 wpa_cli_attached = 0;
3553 wpa_cli_close_connection();
3554 return 1;
3555 }
3556
3557 return 0;
3558}
3559
3560
cd101567 3561static void wpa_cli_recv_pending(struct wpa_ctrl *ctrl, int action_monitor)
6fc6879b 3562{
6fc6879b
JM		 3563 if (ctrl_conn == NULL) {
3564 wpa_cli_reconnect();
3565 return;
3566 }
3567 while (wpa_ctrl_pending(ctrl) > 0) {
063f8504 3568 char buf[4096];
6fc6879b
JM		 3569 size_t len = sizeof(buf) - 1;
3570 if (wpa_ctrl_recv(ctrl, buf, &len) == 0) {
3571 buf[len] = '\0';
3572 if (action_monitor)
3573 wpa_cli_action_process(buf);
3574 else {
a624f20b 3575 cli_event(buf);
f3f0f648 3576 if (wpa_cli_show_event(buf)) {
82a855bd 3577 edit_clear_line();
cd101567 3578 printf("\r%s\n", buf);
bdc45634 3579 edit_redraw();
f3f0f648 3580 }
059d3a90
JM		 3581
3582 if (interactive && check_terminating(buf) > 0)
3583 return;
6fc6879b
JM		 3584 }
3585 } else {
3586 printf("Could not read pending message.\n");
3587 break;
3588 }
3589 }
3590
3591 if (wpa_ctrl_pending(ctrl) < 0) {
3592 printf("Connection to wpa_supplicant lost - trying to "
3593 "reconnect\n");
3594 wpa_cli_reconnect();
3595 }
3596}
3597
6f1c6549
JM		 3598#define max_args 10
3599
3600static int tokenize_cmd(char *cmd, char *argv[])
3601{
3602 char *pos;
3603 int argc = 0;
3604
3605 pos = cmd;
3606 for (;;) {
3607 while (*pos == ' ')
3608 pos++;
3609 if (*pos == '\0')
3610 break;
3611 argv[argc] = pos;
3612 argc++;
3613 if (argc == max_args)
3614 break;
3615 if (*pos == '"') {
3616 char *pos2 = os_strrchr(pos, '"');
3617 if (pos2)
3618 pos = pos2 + 1;
3619 }
3620 while (*pos != '\0' && *pos != ' ')
3621 pos++;
3622 if (*pos == ' ')
3623 *pos++ = '\0';
3624 }
3625
3626 return argc;
3627}
3628
3629
cd101567
JM		 3630static void wpa_cli_ping(void *eloop_ctx, void *timeout_ctx)
3631{
fa0e9176
JM		 3632 if (ctrl_conn) {
3633 int res;
3634 char *prefix = ifname_prefix;
3635
3636 ifname_prefix = NULL;
3637 res = _wpa_ctrl_command(ctrl_conn, "PING", 0);
3638 ifname_prefix = prefix;
3639 if (res) {
3640 printf("Connection to wpa_supplicant lost - trying to "
3641 "reconnect\n");
3642 wpa_cli_close_connection();
3643 }
cd101567
JM		 3644 }
3645 if (!ctrl_conn)
3646 wpa_cli_reconnect();
3647 eloop_register_timeout(ping_interval, 0, wpa_cli_ping, NULL, NULL);
3648}
3649
3650
cd101567
JM		 3651static void wpa_cli_mon_receive(int sock, void *eloop_ctx, void *sock_ctx)
3652{
3653 wpa_cli_recv_pending(mon_conn, 0);
3654}
3655
3656
82a855bd 3657static void wpa_cli_edit_cmd_cb(void *ctx, char *cmd)
aee680e8
JM		 3658{
3659 char *argv[max_args];
3660 int argc;
82a855bd 3661 argc = tokenize_cmd(cmd, argv);
aee680e8
JM		 3662 if (argc)
3663 wpa_request(ctrl_conn, argc, argv);
aee680e8
JM		 3664}
3665
3666
82a855bd 3667static void wpa_cli_edit_eof_cb(void *ctx)
6f1c6549 3668{
82a855bd 3669 eloop_terminate();
cd101567
JM		 3670}
3671
3672
4be9f275
JM		 3673static int warning_displayed = 0;
3674static char *hfile = NULL;
3675static int edit_started = 0;
aee680e8 3676
4be9f275
JM		 3677static void start_edit(void)
3678{
3679 char *home;
db3a0322
JM		 3680 char *ps = NULL;
3681
3682#ifdef CONFIG_CTRL_IFACE_UDP_REMOTE
3683 ps = wpa_ctrl_get_remote_ifname(ctrl_conn);
3684#endif /* CONFIG_CTRL_IFACE_UDP_REMOTE */
cd101567 3685
8953e968
JM		 3686 home = getenv("HOME");
3687 if (home) {
3688 const char *fname = ".wpa_cli_history";
3689 int hfile_len = os_strlen(home) + 1 + os_strlen(fname) + 1;
3690 hfile = os_malloc(hfile_len);
3691 if (hfile)
3692 os_snprintf(hfile, hfile_len, "%s/%s", home, fname);
3693 }
3694
4be9f275 3695 if (edit_init(wpa_cli_edit_cmd_cb, wpa_cli_edit_eof_cb,
db3a0322 3696 wpa_cli_edit_completion_cb, NULL, hfile, ps) < 0) {
4be9f275
JM		 3697 eloop_terminate();
3698 return;
3699 }
3700
3701 edit_started = 1;
cd101567 3702 eloop_register_timeout(ping_interval, 0, wpa_cli_ping, NULL, NULL);
4be9f275
JM		 3703}
3704
3705
9be37143
JM		 3706static void update_bssid_list(struct wpa_ctrl *ctrl)
3707{
3708 char buf[4096];
3709 size_t len = sizeof(buf);
3710 int ret;
3711 char *cmd = "BSS RANGE=ALL MASK=0x2";
3712 char *pos, *end;
3713
3714 if (ctrl == NULL)
3715 return;
3716 ret = wpa_ctrl_request(ctrl, cmd, os_strlen(cmd), buf, &len, NULL);
3717 if (ret < 0)
3718 return;
3719 buf[len] = '\0';
3720
3721 pos = buf;
3722 while (pos) {
3723 pos = os_strstr(pos, "bssid=");
3724 if (pos == NULL)
3725 break;
3726 pos += 6;
3727 end = os_strchr(pos, '\n');
3728 if (end == NULL)
3729 break;
3730 *end = '\0';
3731 cli_txt_list_add(&bsses, pos);
3732 pos = end + 1;
3733 }
3734}
3735
3736
37620493
JM		 3737static void update_ifnames(struct wpa_ctrl *ctrl)
3738{
3739 char buf[4096];
3740 size_t len = sizeof(buf);
3741 int ret;
3742 char *cmd = "INTERFACES";
3743 char *pos, *end;
3744 char txt[200];
3745
3746 cli_txt_list_flush(&ifnames);
3747
3748 if (ctrl == NULL)
3749 return;
3750 ret = wpa_ctrl_request(ctrl, cmd, os_strlen(cmd), buf, &len, NULL);
3751 if (ret < 0)
3752 return;
3753 buf[len] = '\0';
3754
3755 pos = buf;
3756 while (pos) {
3757 end = os_strchr(pos, '\n');
3758 if (end == NULL)
3759 break;
3760 *end = '\0';
3761 ret = os_snprintf(txt, sizeof(txt), "ifname=%s", pos);
a80ba67a 3762 if (!os_snprintf_error(sizeof(txt), ret))
37620493
JM		 3763 cli_txt_list_add(&ifnames, txt);
3764 pos = end + 1;
3765 }
3766}
3767
3768
4be9f275
JM		 3769static void try_connection(void *eloop_ctx, void *timeout_ctx)
3770{
6fd5ceaf
JM		 3771 if (ctrl_conn)
3772 goto done;
3773
8e897ae3
JM		 3774 if (ctrl_ifname == NULL)
3775 ctrl_ifname = wpa_cli_get_default_ifname();
3776
4be9f275
JM		 3777 if (!wpa_cli_open_connection(ctrl_ifname, 1) == 0) {
3778 if (!warning_displayed) {
3779 printf("Could not connect to wpa_supplicant: "
30f459c0
EL		 3780 "%s - re-trying\n",
3781 ctrl_ifname ? ctrl_ifname : "(nil)");
4be9f275
JM		 3782 warning_displayed = 1;
3783 }
3784 eloop_register_timeout(1, 0, try_connection, NULL, NULL);
3785 return;
3786 }
3787
9be37143
JM		 3788 update_bssid_list(ctrl_conn);
3789
4be9f275
JM		 3790 if (warning_displayed)
3791 printf("Connection established.\n");
3792
6fd5ceaf 3793done:
4be9f275
JM		 3794 start_edit();
3795}
3796
cd101567 3797
4be9f275
JM		 3798static void wpa_cli_interactive(void)
3799{
3800 printf("\nInteractive mode\n\n");
3801
3802 eloop_register_timeout(0, 0, try_connection, NULL, NULL);
cd101567 3803 eloop_run();
4be9f275 3804 eloop_cancel_timeout(try_connection, NULL, NULL);
cd101567 3805
a624f20b 3806 cli_txt_list_flush(&p2p_peers);
76788542 3807 cli_txt_list_flush(&p2p_groups);
a624f20b 3808 cli_txt_list_flush(&bsses);
37620493 3809 cli_txt_list_flush(&ifnames);
4be9f275
JM		 3810 if (edit_started)
3811 edit_deinit(hfile, wpa_cli_edit_filter_history_cb);
8953e968 3812 os_free(hfile);
cd101567
JM		 3813 eloop_cancel_timeout(wpa_cli_ping, NULL, NULL);
3814 wpa_cli_close_connection();
6f1c6549
JM		 3815}
3816
6fc6879b
JM		 3817
3818static void wpa_cli_action(struct wpa_ctrl *ctrl)
3819{
3820#ifdef CONFIG_ANSI_C_EXTRA
3821 /* TODO: ANSI C version(?) */
3822 printf("Action processing not supported in ANSI C build.\n");
3823#else /* CONFIG_ANSI_C_EXTRA */
3824 fd_set rfds;
3825 int fd, res;
3826 struct timeval tv;
3827 char buf[256]; /* note: large enough to fit in unsolicited messages */
3828 size_t len;
3829
3830 fd = wpa_ctrl_get_fd(ctrl);
3831
3832 while (!wpa_cli_quit) {
3833 FD_ZERO(&rfds);
3834 FD_SET(fd, &rfds);
1cc84c1c 3835 tv.tv_sec = ping_interval;
6fc6879b
JM		 3836 tv.tv_usec = 0;
3837 res = select(fd + 1, &rfds, NULL, NULL, &tv);
3838 if (res < 0 && errno != EINTR) {
3839 perror("select");
3840 break;
3841 }
3842
3843 if (FD_ISSET(fd, &rfds))
cd101567 3844 wpa_cli_recv_pending(ctrl, 1);
6fc6879b
JM		 3845 else {
3846 /* verify that connection is still working */
3847 len = sizeof(buf) - 1;
3848 if (wpa_ctrl_request(ctrl, "PING", 4, buf, &len,
3849 wpa_cli_action_cb) < 0 ||
3850 len < 4 || os_memcmp(buf, "PONG", 4) != 0) {
3851 printf("wpa_supplicant did not reply to PING "
3852 "command - exiting\n");
3853 break;
3854 }
3855 }
3856 }
3857#endif /* CONFIG_ANSI_C_EXTRA */
3858}
3859
3860
3861static void wpa_cli_cleanup(void)
3862{
3863 wpa_cli_close_connection();
3864 if (pid_file)
3865 os_daemonize_terminate(pid_file);
3866
3867 os_program_deinit();
3868}
3869
4be9f275
JM		 3870
3871static void wpa_cli_terminate(int sig, void *ctx)
6fc6879b 3872{
4be9f275 3873 eloop_terminate();
6fc6879b
JM		 3874}
3875
3876
6fc6879b
JM		 3877static char * wpa_cli_get_default_ifname(void)
3878{
3879 char *ifname = NULL;
3880
3881#ifdef CONFIG_CTRL_IFACE_UNIX
3882 struct dirent *dent;
3883 DIR *dir = opendir(ctrl_iface_dir);
b1001e4c
DS		 3884 if (!dir) {
3885#ifdef ANDROID
3886 char ifprop[PROPERTY_VALUE_MAX];
3887 if (property_get("wifi.interface", ifprop, NULL) != 0) {
3888 ifname = os_strdup(ifprop);
3889 printf("Using interface '%s'\n", ifname);
3890 return ifname;
3891 }
3892#endif /* ANDROID */
6fc6879b 3893 return NULL;
b1001e4c 3894 }
6fc6879b
JM		 3895 while ((dent = readdir(dir))) {
3896#ifdef _DIRENT_HAVE_D_TYPE
3897 /*
3898 * Skip the file if it is not a socket. Also accept
3899 * DT_UNKNOWN (0) in case the C library or underlying
3900 * file system does not support d_type.
3901 */
3902 if (dent->d_type != DT_SOCK && dent->d_type != DT_UNKNOWN)
3903 continue;
3904#endif /* _DIRENT_HAVE_D_TYPE */
3905 if (os_strcmp(dent->d_name, ".") == 0 ||
3906 os_strcmp(dent->d_name, "..") == 0)
3907 continue;
3908 printf("Selected interface '%s'\n", dent->d_name);
3909 ifname = os_strdup(dent->d_name);
3910 break;
3911 }
3912 closedir(dir);
3913#endif /* CONFIG_CTRL_IFACE_UNIX */
3914
3915#ifdef CONFIG_CTRL_IFACE_NAMED_PIPE
89c7ac57 3916 char buf[4096], *pos;
6fc6879b
JM		 3917 size_t len;
3918 struct wpa_ctrl *ctrl;
3919 int ret;
3920
3921 ctrl = wpa_ctrl_open(NULL);
3922 if (ctrl == NULL)
3923 return NULL;
3924
3925 len = sizeof(buf) - 1;
3926 ret = wpa_ctrl_request(ctrl, "INTERFACES", 10, buf, &len, NULL);
3927 if (ret >= 0) {
3928 buf[len] = '\0';
3929 pos = os_strchr(buf, '\n');
3930 if (pos)
3931 *pos = '\0';
3932 ifname = os_strdup(buf);
3933 }
3934 wpa_ctrl_close(ctrl);
3935#endif /* CONFIG_CTRL_IFACE_NAMED_PIPE */
3936
3937 return ifname;
3938}
3939
3940
3941int main(int argc, char *argv[])
3942{
6fc6879b
JM		 3943 int c;
3944 int daemonize = 0;
3945 int ret = 0;
3946 const char *global = NULL;
3947
3948 if (os_program_init())
3949 return -1;
3950
3951 for (;;) {
1cc84c1c 3952 c = getopt(argc, argv, "a:Bg:G:hi:p:P:v");
6fc6879b
JM		 3953 if (c < 0)
3954 break;
3955 switch (c) {
3956 case 'a':
3957 action_file = optarg;
3958 break;
3959 case 'B':
3960 daemonize = 1;
3961 break;
3962 case 'g':
3963 global = optarg;
3964 break;
1cc84c1c
JM		 3965 case 'G':
3966 ping_interval = atoi(optarg);
3967 break;
6fc6879b
JM		 3968 case 'h':
3969 usage();
3970 return 0;
3971 case 'v':
3972 printf("%s\n", wpa_cli_version);
3973 return 0;
3974 case 'i':
3975 os_free(ctrl_ifname);
3976 ctrl_ifname = os_strdup(optarg);
3977 break;
3978 case 'p':
3979 ctrl_iface_dir = optarg;
3980 break;
3981 case 'P':
3982 pid_file = optarg;
3983 break;
3984 default:
3985 usage();
3986 return -1;
3987 }
3988 }
3989
3990 interactive = (argc == optind) && (action_file == NULL);
3991
3992 if (interactive)
3993 printf("%s\n\n%s\n\n", wpa_cli_version, wpa_cli_license);
3994
cd101567
JM		 3995 if (eloop_init())
3996 return -1;
3997
6fc6879b
JM		 3998 if (global) {
3999#ifdef CONFIG_CTRL_IFACE_NAMED_PIPE
4000 ctrl_conn = wpa_ctrl_open(NULL);
4001#else /* CONFIG_CTRL_IFACE_NAMED_PIPE */
4002 ctrl_conn = wpa_ctrl_open(global);
4003#endif /* CONFIG_CTRL_IFACE_NAMED_PIPE */
4004 if (ctrl_conn == NULL) {
5a49459e
BG		 4005 fprintf(stderr, "Failed to connect to wpa_supplicant "
4006 "global interface: %s error: %s\n",
4007 global, strerror(errno));
6fc6879b
JM		 4008 return -1;
4009 }
214e428b
JM		 4010
4011 if (interactive) {
37620493 4012 update_ifnames(ctrl_conn);
214e428b
JM		 4013 mon_conn = wpa_ctrl_open(global);
4014 if (mon_conn) {
4015 if (wpa_ctrl_attach(mon_conn) == 0) {
4016 wpa_cli_attached = 1;
4017 eloop_register_read_sock(
4018 wpa_ctrl_get_fd(mon_conn),
4019 wpa_cli_mon_receive,
4020 NULL, NULL);
4021 } else {
4022 printf("Failed to open monitor "
4023 "connection through global "
4024 "control interface\n");
4025 }
4026 }
4027 }
6fc6879b
JM		 4028 }
4029
4be9f275 4030 eloop_register_signal_terminate(wpa_cli_terminate, NULL);
6fc6879b 4031
4a3ade4e
JM		 4032 if (ctrl_ifname == NULL)
4033 ctrl_ifname = wpa_cli_get_default_ifname();
4034
4035 if (interactive) {
4be9f275 4036 wpa_cli_interactive();
4a3ade4e
JM		 4037 } else {
4038 if (!global &&
4039 wpa_cli_open_connection(ctrl_ifname, 0) < 0) {
5a49459e
BG		 4040 fprintf(stderr, "Failed to connect to non-global "
4041 "ctrl_ifname: %s error: %s\n",
30f459c0
EL		 4042 ctrl_ifname ? ctrl_ifname : "(nil)",
4043 strerror(errno));
4a3ade4e
JM		 4044 return -1;
4045 }
4046
4047 if (action_file) {
4048 if (wpa_ctrl_attach(ctrl_conn) == 0) {
4049 wpa_cli_attached = 1;
4050 } else {
4051 printf("Warning: Failed to attach to "
4052 "wpa_supplicant.\n");
6fc6879b 4053 return -1;
4a3ade4e 4054 }
6fc6879b 4055 }
6fc6879b 4056
4be9f275
JM		 4057 if (daemonize && os_daemonize(pid_file))
4058 return -1;
6fc6879b 4059
4be9f275
JM		 4060 if (action_file)
4061 wpa_cli_action(ctrl_conn);
4062 else
4063 ret = wpa_request(ctrl_conn, argc - optind,
4064 &argv[optind]);
4065 }
6fc6879b
JM		 4066
4067 os_free(ctrl_ifname);
cd101567 4068 eloop_destroy();
6fc6879b
JM		 4069 wpa_cli_cleanup();
4070
4071 return ret;
4072}
4073
4074#else /* CONFIG_CTRL_IFACE */
4075int main(int argc, char *argv[])
4076{
4077 printf("CONFIG_CTRL_IFACE not defined - wpa_cli disabled\n");
4078 return -1;
4079}
4080#endif /* CONFIG_CTRL_IFACE */
Unnamed repository; edit this file 'description' to name the repository.