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