]> git.ipfire.org Git - thirdparty/hostap.git/blob - wpa_supplicant/wpa_cli.c
projects / thirdparty / hostap.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
P2P: Add optional "ht40" argument for p2p_connect
[thirdparty/hostap.git] / wpa_supplicant / wpa_cli.c
1 /*
2 * WPA Supplicant - command line interface for wpa_supplicant daemon
3 * Copyright (c) 2004-2012, Jouni Malinen <j@w1.fi>
4 *
5 * This software may be distributed under the terms of the BSD license.
6 * See README for more details.
7 */
8
9 #include "includes.h"
10
11 #ifdef CONFIG_CTRL_IFACE
12
13 #ifdef CONFIG_CTRL_IFACE_UNIX
14 #include <dirent.h>
15 #endif /* CONFIG_CTRL_IFACE_UNIX */
16
17 #include "common/wpa_ctrl.h"
18 #include "utils/common.h"
19 #include "utils/eloop.h"
20 #include "utils/edit.h"
21 #include "utils/list.h"
22 #include "common/version.h"
23 #include "common/ieee802_11_defs.h"
24 #ifdef ANDROID
25 #include <cutils/properties.h>
26 #endif /* ANDROID */
27
28
29 static const char *wpa_cli_version =
30 "wpa_cli v" VERSION_STR "\n"
31 "Copyright (c) 2004-2012, Jouni Malinen <j@w1.fi> and contributors";
32
33
34 static const char *wpa_cli_license =
35 "This software may be distributed under the terms of the BSD license.\n"
36 "See README for more details.\n";
37
38 static const char *wpa_cli_full_license =
39 "This software may be distributed under the terms of the BSD license.\n"
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
69 static struct wpa_ctrl *ctrl_conn;
70 static struct wpa_ctrl *mon_conn;
71 static int wpa_cli_quit = 0;
72 static int wpa_cli_attached = 0;
73 static int wpa_cli_connected = 0;
74 static int wpa_cli_last_id = 0;
75 #ifndef CONFIG_CTRL_IFACE_DIR
76 #define CONFIG_CTRL_IFACE_DIR "/var/run/wpa_supplicant"
77 #endif /* CONFIG_CTRL_IFACE_DIR */
78 static const char *ctrl_iface_dir = CONFIG_CTRL_IFACE_DIR;
79 static char *ctrl_ifname = NULL;
80 static const char *pid_file = NULL;
81 static const char *action_file = NULL;
82 static int ping_interval = 5;
83 static int interactive = 0;
84
85 struct cli_txt_entry {
86 struct dl_list list;
87 char *txt;
88 };
89
90 static DEFINE_DL_LIST(bsses); /* struct cli_txt_entry */
91 static DEFINE_DL_LIST(p2p_peers); /* struct cli_txt_entry */
92 static DEFINE_DL_LIST(p2p_groups); /* struct cli_txt_entry */
93
94
95 static void print_help(void);
96 static void wpa_cli_mon_receive(int sock, void *eloop_ctx, void *sock_ctx);
97 static void wpa_cli_close_connection(void);
98 static char * wpa_cli_get_default_ifname(void);
99
100
101 static void usage(void)
102 {
103 printf("wpa_cli [-p<path to ctrl sockets>] [-i<ifname>] [-hvB] "
104 "[-a<action file>] \\\n"
105 " [-P<pid file>] [-g<global ctrl>] [-G<ping interval>] "
106 "[command..]\n"
107 " -h = help (show this usage text)\n"
108 " -v = shown version information\n"
109 " -a = run in daemon mode executing the action file based on "
110 "events from\n"
111 " wpa_supplicant\n"
112 " -B = run a daemon in the background\n"
113 " default path: " CONFIG_CTRL_IFACE_DIR "\n"
114 " default interface: first interface found in socket path\n");
115 print_help();
116 }
117
118
119 static void cli_txt_list_free(struct cli_txt_entry *e)
120 {
121 dl_list_del(&e->list);
122 os_free(e->txt);
123 os_free(e);
124 }
125
126
127 static void cli_txt_list_flush(struct dl_list *list)
128 {
129 struct cli_txt_entry *e;
130 while ((e = dl_list_first(list, struct cli_txt_entry, list)))
131 cli_txt_list_free(e);
132 }
133
134
135 static struct cli_txt_entry * cli_txt_list_get(struct dl_list *txt_list,
136 const char *txt)
137 {
138 struct cli_txt_entry *e;
139 dl_list_for_each(e, txt_list, struct cli_txt_entry, list) {
140 if (os_strcmp(e->txt, txt) == 0)
141 return e;
142 }
143 return NULL;
144 }
145
146
147 static void cli_txt_list_del(struct dl_list *txt_list, const char *txt)
148 {
149 struct cli_txt_entry *e;
150 e = cli_txt_list_get(txt_list, txt);
151 if (e)
152 cli_txt_list_free(e);
153 }
154
155
156 static void cli_txt_list_del_addr(struct dl_list *txt_list, const char *txt)
157 {
158 u8 addr[ETH_ALEN];
159 char buf[18];
160 if (hwaddr_aton(txt, addr) < 0)
161 return;
162 os_snprintf(buf, sizeof(buf), MACSTR, MAC2STR(addr));
163 cli_txt_list_del(txt_list, buf);
164 }
165
166
167 #ifdef CONFIG_P2P
168 static void cli_txt_list_del_word(struct dl_list *txt_list, const char *txt)
169 {
170 const char *end;
171 char *buf;
172 end = os_strchr(txt, ' ');
173 if (end == NULL)
174 end = txt + os_strlen(txt);
175 buf = os_malloc(end - txt + 1);
176 if (buf == NULL)
177 return;
178 os_memcpy(buf, txt, end - txt);
179 buf[end - txt] = '\0';
180 cli_txt_list_del(txt_list, buf);
181 os_free(buf);
182 }
183 #endif /* CONFIG_P2P */
184
185
186 static int cli_txt_list_add(struct dl_list *txt_list, const char *txt)
187 {
188 struct cli_txt_entry *e;
189 e = cli_txt_list_get(txt_list, txt);
190 if (e)
191 return 0;
192 e = os_zalloc(sizeof(*e));
193 if (e == NULL)
194 return -1;
195 e->txt = os_strdup(txt);
196 if (e->txt == NULL) {
197 os_free(e);
198 return -1;
199 }
200 dl_list_add(txt_list, &e->list);
201 return 0;
202 }
203
204
205 #ifdef CONFIG_P2P
206 static int cli_txt_list_add_addr(struct dl_list *txt_list, const char *txt)
207 {
208 u8 addr[ETH_ALEN];
209 char buf[18];
210 if (hwaddr_aton(txt, addr) < 0)
211 return -1;
212 os_snprintf(buf, sizeof(buf), MACSTR, MAC2STR(addr));
213 return cli_txt_list_add(txt_list, buf);
214 }
215
216
217 static int cli_txt_list_add_word(struct dl_list *txt_list, const char *txt)
218 {
219 const char *end;
220 char *buf;
221 int ret;
222 end = os_strchr(txt, ' ');
223 if (end == NULL)
224 end = txt + os_strlen(txt);
225 buf = os_malloc(end - txt + 1);
226 if (buf == NULL)
227 return -1;
228 os_memcpy(buf, txt, end - txt);
229 buf[end - txt] = '\0';
230 ret = cli_txt_list_add(txt_list, buf);
231 os_free(buf);
232 return ret;
233 }
234 #endif /* CONFIG_P2P */
235
236
237 static char ** cli_txt_list_array(struct dl_list *txt_list)
238 {
239 unsigned int i, count = dl_list_len(txt_list);
240 char **res;
241 struct cli_txt_entry *e;
242
243 res = os_calloc(count + 1, sizeof(char *));
244 if (res == NULL)
245 return NULL;
246
247 i = 0;
248 dl_list_for_each(e, txt_list, struct cli_txt_entry, list) {
249 res[i] = os_strdup(e->txt);
250 if (res[i] == NULL)
251 break;
252 i++;
253 }
254
255 return res;
256 }
257
258
259 static int get_cmd_arg_num(const char *str, int pos)
260 {
261 int arg = 0, i;
262
263 for (i = 0; i <= pos; i++) {
264 if (str[i] != ' ') {
265 arg++;
266 while (i <= pos && str[i] != ' ')
267 i++;
268 }
269 }
270
271 if (arg > 0)
272 arg--;
273 return arg;
274 }
275
276
277 static int str_starts(const char *src, const char *match)
278 {
279 return os_strncmp(src, match, os_strlen(match)) == 0;
280 }
281
282
283 static int wpa_cli_show_event(const char *event)
284 {
285 const char *start;
286
287 start = os_strchr(event, '>');
288 if (start == NULL)
289 return 1;
290
291 start++;
292 /*
293 * Skip BSS added/removed events since they can be relatively frequent
294 * and are likely of not much use for an interactive user.
295 */
296 if (str_starts(start, WPA_EVENT_BSS_ADDED) ||
297 str_starts(start, WPA_EVENT_BSS_REMOVED))
298 return 0;
299
300 return 1;
301 }
302
303
304 static int wpa_cli_open_connection(const char *ifname, int attach)
305 {
306 #if defined(CONFIG_CTRL_IFACE_UDP) || defined(CONFIG_CTRL_IFACE_NAMED_PIPE)
307 ctrl_conn = wpa_ctrl_open(ifname);
308 if (ctrl_conn == NULL)
309 return -1;
310
311 if (attach && interactive)
312 mon_conn = wpa_ctrl_open(ifname);
313 else
314 mon_conn = NULL;
315 #else /* CONFIG_CTRL_IFACE_UDP || CONFIG_CTRL_IFACE_NAMED_PIPE */
316 char *cfile = NULL;
317 int flen, res;
318
319 if (ifname == NULL)
320 return -1;
321
322 #ifdef ANDROID
323 if (access(ctrl_iface_dir, F_OK) < 0) {
324 cfile = os_strdup(ifname);
325 if (cfile == NULL)
326 return -1;
327 }
328 #endif /* ANDROID */
329
330 if (cfile == NULL) {
331 flen = os_strlen(ctrl_iface_dir) + os_strlen(ifname) + 2;
332 cfile = os_malloc(flen);
333 if (cfile == NULL)
334 return -1;
335 res = os_snprintf(cfile, flen, "%s/%s", ctrl_iface_dir,
336 ifname);
337 if (res < 0 || res >= flen) {
338 os_free(cfile);
339 return -1;
340 }
341 }
342
343 ctrl_conn = wpa_ctrl_open(cfile);
344 if (ctrl_conn == NULL) {
345 os_free(cfile);
346 return -1;
347 }
348
349 if (attach && interactive)
350 mon_conn = wpa_ctrl_open(cfile);
351 else
352 mon_conn = NULL;
353 os_free(cfile);
354 #endif /* CONFIG_CTRL_IFACE_UDP || CONFIG_CTRL_IFACE_NAMED_PIPE */
355
356 if (mon_conn) {
357 if (wpa_ctrl_attach(mon_conn) == 0) {
358 wpa_cli_attached = 1;
359 if (interactive)
360 eloop_register_read_sock(
361 wpa_ctrl_get_fd(mon_conn),
362 wpa_cli_mon_receive, NULL, NULL);
363 } else {
364 printf("Warning: Failed to attach to "
365 "wpa_supplicant.\n");
366 wpa_cli_close_connection();
367 return -1;
368 }
369 }
370
371 return 0;
372 }
373
374
375 static void wpa_cli_close_connection(void)
376 {
377 if (ctrl_conn == NULL)
378 return;
379
380 if (wpa_cli_attached) {
381 wpa_ctrl_detach(interactive ? mon_conn : ctrl_conn);
382 wpa_cli_attached = 0;
383 }
384 wpa_ctrl_close(ctrl_conn);
385 ctrl_conn = NULL;
386 if (mon_conn) {
387 eloop_unregister_read_sock(wpa_ctrl_get_fd(mon_conn));
388 wpa_ctrl_close(mon_conn);
389 mon_conn = NULL;
390 }
391 }
392
393
394 static void wpa_cli_msg_cb(char *msg, size_t len)
395 {
396 printf("%s\n", msg);
397 }
398
399
400 static int _wpa_ctrl_command(struct wpa_ctrl *ctrl, char *cmd, int print)
401 {
402 char buf[2048];
403 size_t len;
404 int ret;
405
406 if (ctrl_conn == NULL) {
407 printf("Not connected to wpa_supplicant - command dropped.\n");
408 return -1;
409 }
410 len = sizeof(buf) - 1;
411 ret = wpa_ctrl_request(ctrl, cmd, os_strlen(cmd), buf, &len,
412 wpa_cli_msg_cb);
413 if (ret == -2) {
414 printf("'%s' command timed out.\n", cmd);
415 return -2;
416 } else if (ret < 0) {
417 printf("'%s' command failed.\n", cmd);
418 return -1;
419 }
420 if (print) {
421 buf[len] = '\0';
422 printf("%s", buf);
423 if (interactive && len > 0 && buf[len - 1] != '\n')
424 printf("\n");
425 }
426 return 0;
427 }
428
429
430 static int wpa_ctrl_command(struct wpa_ctrl *ctrl, char *cmd)
431 {
432 return _wpa_ctrl_command(ctrl, cmd, 1);
433 }
434
435
436 static int write_cmd(char *buf, size_t buflen, const char *cmd, int argc,
437 char *argv[])
438 {
439 int i, res;
440 char *pos, *end;
441
442 pos = buf;
443 end = buf + buflen;
444
445 res = os_snprintf(pos, end - pos, "%s", cmd);
446 if (res < 0 || res >= end - pos)
447 goto fail;
448 pos += res;
449
450 for (i = 0; i < argc; i++) {
451 res = os_snprintf(pos, end - pos, " %s", argv[i]);
452 if (res < 0 || res >= end - pos)
453 goto fail;
454 pos += res;
455 }
456
457 buf[buflen - 1] = '\0';
458 return 0;
459
460 fail:
461 printf("Too long command\n");
462 return -1;
463 }
464
465
466 static int wpa_cli_cmd(struct wpa_ctrl *ctrl, const char *cmd, int min_args,
467 int argc, char *argv[])
468 {
469 char buf[256];
470 if (argc < min_args) {
471 printf("Invalid %s command - at least %d argument%s "
472 "required.\n", cmd, min_args,
473 min_args > 1 ? "s are" : " is");
474 return -1;
475 }
476 if (write_cmd(buf, sizeof(buf), cmd, argc, argv) < 0)
477 return -1;
478 return wpa_ctrl_command(ctrl, buf);
479 }
480
481
482 static int wpa_cli_cmd_ifname(struct wpa_ctrl *ctrl, int argc, char *argv[])
483 {
484 return wpa_ctrl_command(ctrl, "IFNAME");
485 }
486
487
488 static int wpa_cli_cmd_status(struct wpa_ctrl *ctrl, int argc, char *argv[])
489 {
490 if (argc > 0 && os_strcmp(argv[0], "verbose") == 0)
491 return wpa_ctrl_command(ctrl, "STATUS-VERBOSE");
492 if (argc > 0 && os_strcmp(argv[0], "wps") == 0)
493 return wpa_ctrl_command(ctrl, "STATUS-WPS");
494 return wpa_ctrl_command(ctrl, "STATUS");
495 }
496
497
498 static int wpa_cli_cmd_ping(struct wpa_ctrl *ctrl, int argc, char *argv[])
499 {
500 return wpa_ctrl_command(ctrl, "PING");
501 }
502
503
504 static int wpa_cli_cmd_relog(struct wpa_ctrl *ctrl, int argc, char *argv[])
505 {
506 return wpa_ctrl_command(ctrl, "RELOG");
507 }
508
509
510 static int wpa_cli_cmd_note(struct wpa_ctrl *ctrl, int argc, char *argv[])
511 {
512 return wpa_cli_cmd(ctrl, "NOTE", 1, argc, argv);
513 }
514
515
516 static int wpa_cli_cmd_mib(struct wpa_ctrl *ctrl, int argc, char *argv[])
517 {
518 return wpa_ctrl_command(ctrl, "MIB");
519 }
520
521
522 static int wpa_cli_cmd_pmksa(struct wpa_ctrl *ctrl, int argc, char *argv[])
523 {
524 return wpa_ctrl_command(ctrl, "PMKSA");
525 }
526
527
528 static int wpa_cli_cmd_help(struct wpa_ctrl *ctrl, int argc, char *argv[])
529 {
530 print_help();
531 return 0;
532 }
533
534
535 static int wpa_cli_cmd_license(struct wpa_ctrl *ctrl, int argc, char *argv[])
536 {
537 printf("%s\n\n%s\n", wpa_cli_version, wpa_cli_full_license);
538 return 0;
539 }
540
541
542 static int wpa_cli_cmd_quit(struct wpa_ctrl *ctrl, int argc, char *argv[])
543 {
544 wpa_cli_quit = 1;
545 if (interactive)
546 eloop_terminate();
547 return 0;
548 }
549
550
551 static void wpa_cli_show_variables(void)
552 {
553 printf("set variables:\n"
554 " EAPOL::heldPeriod (EAPOL state machine held period, "
555 "in seconds)\n"
556 " EAPOL::authPeriod (EAPOL state machine authentication "
557 "period, in seconds)\n"
558 " EAPOL::startPeriod (EAPOL state machine start period, in "
559 "seconds)\n"
560 " EAPOL::maxStart (EAPOL state machine maximum start "
561 "attempts)\n");
562 printf(" dot11RSNAConfigPMKLifetime (WPA/WPA2 PMK lifetime in "
563 "seconds)\n"
564 " dot11RSNAConfigPMKReauthThreshold (WPA/WPA2 reauthentication"
565 " threshold\n\tpercentage)\n"
566 " dot11RSNAConfigSATimeout (WPA/WPA2 timeout for completing "
567 "security\n\tassociation in seconds)\n");
568 }
569
570
571 static int wpa_cli_cmd_set(struct wpa_ctrl *ctrl, int argc, char *argv[])
572 {
573 char cmd[256];
574 int res;
575
576 if (argc == 0) {
577 wpa_cli_show_variables();
578 return 0;
579 }
580
581 if (argc != 1 && argc != 2) {
582 printf("Invalid SET command: needs two arguments (variable "
583 "name and value)\n");
584 return -1;
585 }
586
587 if (argc == 1)
588 res = os_snprintf(cmd, sizeof(cmd), "SET %s ", argv[0]);
589 else
590 res = os_snprintf(cmd, sizeof(cmd), "SET %s %s",
591 argv[0], argv[1]);
592 if (res < 0 || (size_t) res >= sizeof(cmd) - 1) {
593 printf("Too long SET command.\n");
594 return -1;
595 }
596 return wpa_ctrl_command(ctrl, cmd);
597 }
598
599
600 static int wpa_cli_cmd_get(struct wpa_ctrl *ctrl, int argc, char *argv[])
601 {
602 return wpa_cli_cmd(ctrl, "GET", 1, argc, argv);
603 }
604
605
606 static int wpa_cli_cmd_logoff(struct wpa_ctrl *ctrl, int argc, char *argv[])
607 {
608 return wpa_ctrl_command(ctrl, "LOGOFF");
609 }
610
611
612 static int wpa_cli_cmd_logon(struct wpa_ctrl *ctrl, int argc, char *argv[])
613 {
614 return wpa_ctrl_command(ctrl, "LOGON");
615 }
616
617
618 static int wpa_cli_cmd_reassociate(struct wpa_ctrl *ctrl, int argc,
619 char *argv[])
620 {
621 return wpa_ctrl_command(ctrl, "REASSOCIATE");
622 }
623
624
625 static int wpa_cli_cmd_preauthenticate(struct wpa_ctrl *ctrl, int argc,
626 char *argv[])
627 {
628 return wpa_cli_cmd(ctrl, "PREAUTH", 1, argc, argv);
629 }
630
631
632 static int wpa_cli_cmd_ap_scan(struct wpa_ctrl *ctrl, int argc, char *argv[])
633 {
634 return wpa_cli_cmd(ctrl, "AP_SCAN", 1, argc, argv);
635 }
636
637
638 static int wpa_cli_cmd_scan_interval(struct wpa_ctrl *ctrl, int argc,
639 char *argv[])
640 {
641 return wpa_cli_cmd(ctrl, "SCAN_INTERVAL", 1, argc, argv);
642 }
643
644
645 static int wpa_cli_cmd_bss_expire_age(struct wpa_ctrl *ctrl, int argc,
646 char *argv[])
647 {
648 return wpa_cli_cmd(ctrl, "BSS_EXPIRE_AGE", 1, argc, argv);
649 }
650
651
652 static int wpa_cli_cmd_bss_expire_count(struct wpa_ctrl *ctrl, int argc,
653 char *argv[])
654 {
655 return wpa_cli_cmd(ctrl, "BSS_EXPIRE_COUNT", 1, argc, argv);
656 }
657
658
659 static int wpa_cli_cmd_stkstart(struct wpa_ctrl *ctrl, int argc,
660 char *argv[])
661 {
662 return wpa_cli_cmd(ctrl, "STKSTART", 1, argc, argv);
663 }
664
665
666 static int wpa_cli_cmd_ft_ds(struct wpa_ctrl *ctrl, int argc, char *argv[])
667 {
668 return wpa_cli_cmd(ctrl, "FT_DS", 1, argc, argv);
669 }
670
671
672 static int wpa_cli_cmd_wps_pbc(struct wpa_ctrl *ctrl, int argc, char *argv[])
673 {
674 return wpa_cli_cmd(ctrl, "WPS_PBC", 0, argc, argv);
675 }
676
677
678 static int wpa_cli_cmd_wps_pin(struct wpa_ctrl *ctrl, int argc, char *argv[])
679 {
680 if (argc == 0) {
681 printf("Invalid WPS_PIN command: need one or two arguments:\n"
682 "- BSSID: use 'any' to select any\n"
683 "- PIN: optional, used only with devices that have no "
684 "display\n");
685 return -1;
686 }
687
688 return wpa_cli_cmd(ctrl, "WPS_PIN", 1, argc, argv);
689 }
690
691
692 static int wpa_cli_cmd_wps_check_pin(struct wpa_ctrl *ctrl, int argc,
693 char *argv[])
694 {
695 return wpa_cli_cmd(ctrl, "WPS_CHECK_PIN", 1, argc, argv);
696 }
697
698
699 static int wpa_cli_cmd_wps_cancel(struct wpa_ctrl *ctrl, int argc,
700 char *argv[])
701 {
702 return wpa_ctrl_command(ctrl, "WPS_CANCEL");
703 }
704
705
706 #ifdef CONFIG_WPS_OOB
707 static int wpa_cli_cmd_wps_oob(struct wpa_ctrl *ctrl, int argc, char *argv[])
708 {
709 if (argc != 3 && argc != 4) {
710 printf("Invalid WPS_OOB command: need three or four "
711 "arguments:\n"
712 "- DEV_TYPE: use 'ufd' or 'nfc'\n"
713 "- PATH: path of OOB device like '/mnt'\n"
714 "- METHOD: OOB method 'pin-e' or 'pin-r', "
715 "'cred'\n"
716 "- DEV_NAME: (only for NFC) device name like "
717 "'pn531'\n");
718 return -1;
719 }
720
721 return wpa_cli_cmd(ctrl, "WPS_OOB", 3, argc, argv);
722 }
723 #endif /* CONFIG_WPS_OOB */
724
725
726 #ifdef CONFIG_WPS_NFC
727
728 static int wpa_cli_cmd_wps_nfc(struct wpa_ctrl *ctrl, int argc, char *argv[])
729 {
730 return wpa_cli_cmd(ctrl, "WPS_NFC", 0, argc, argv);
731 }
732
733
734 static int wpa_cli_cmd_wps_nfc_token(struct wpa_ctrl *ctrl, int argc,
735 char *argv[])
736 {
737 return wpa_cli_cmd(ctrl, "WPS_NFC_TOKEN", 1, argc, argv);
738 }
739
740
741 static int wpa_cli_cmd_wps_nfc_tag_read(struct wpa_ctrl *ctrl, int argc,
742 char *argv[])
743 {
744 int ret;
745 char *buf;
746 size_t buflen;
747
748 if (argc != 1) {
749 printf("Invalid 'wps_nfc_tag_read' command - one argument "
750 "is required.\n");
751 return -1;
752 }
753
754 buflen = 18 + os_strlen(argv[0]);
755 buf = os_malloc(buflen);
756 if (buf == NULL)
757 return -1;
758 os_snprintf(buf, buflen, "WPS_NFC_TAG_READ %s", argv[0]);
759
760 ret = wpa_ctrl_command(ctrl, buf);
761 os_free(buf);
762
763 return ret;
764 }
765
766 #endif /* CONFIG_WPS_NFC */
767
768
769 static int wpa_cli_cmd_wps_reg(struct wpa_ctrl *ctrl, int argc, char *argv[])
770 {
771 char cmd[256];
772 int res;
773
774 if (argc == 2)
775 res = os_snprintf(cmd, sizeof(cmd), "WPS_REG %s %s",
776 argv[0], argv[1]);
777 else if (argc == 5 || argc == 6) {
778 char ssid_hex[2 * 32 + 1];
779 char key_hex[2 * 64 + 1];
780 int i;
781
782 ssid_hex[0] = '\0';
783 for (i = 0; i < 32; i++) {
784 if (argv[2][i] == '\0')
785 break;
786 os_snprintf(&ssid_hex[i * 2], 3, "%02x", argv[2][i]);
787 }
788
789 key_hex[0] = '\0';
790 if (argc == 6) {
791 for (i = 0; i < 64; i++) {
792 if (argv[5][i] == '\0')
793 break;
794 os_snprintf(&key_hex[i * 2], 3, "%02x",
795 argv[5][i]);
796 }
797 }
798
799 res = os_snprintf(cmd, sizeof(cmd),
800 "WPS_REG %s %s %s %s %s %s",
801 argv[0], argv[1], ssid_hex, argv[3], argv[4],
802 key_hex);
803 } else {
804 printf("Invalid WPS_REG command: need two arguments:\n"
805 "- BSSID of the target AP\n"
806 "- AP PIN\n");
807 printf("Alternatively, six arguments can be used to "
808 "reconfigure the AP:\n"
809 "- BSSID of the target AP\n"
810 "- AP PIN\n"
811 "- new SSID\n"
812 "- new auth (OPEN, WPAPSK, WPA2PSK)\n"
813 "- new encr (NONE, WEP, TKIP, CCMP)\n"
814 "- new key\n");
815 return -1;
816 }
817
818 if (res < 0 || (size_t) res >= sizeof(cmd) - 1) {
819 printf("Too long WPS_REG command.\n");
820 return -1;
821 }
822 return wpa_ctrl_command(ctrl, cmd);
823 }
824
825
826 static int wpa_cli_cmd_wps_ap_pin(struct wpa_ctrl *ctrl, int argc,
827 char *argv[])
828 {
829 return wpa_cli_cmd(ctrl, "WPS_AP_PIN", 1, argc, argv);
830 }
831
832
833 static int wpa_cli_cmd_wps_er_start(struct wpa_ctrl *ctrl, int argc,
834 char *argv[])
835 {
836 return wpa_cli_cmd(ctrl, "WPS_ER_START", 0, argc, argv);
837 }
838
839
840 static int wpa_cli_cmd_wps_er_stop(struct wpa_ctrl *ctrl, int argc,
841 char *argv[])
842 {
843 return wpa_ctrl_command(ctrl, "WPS_ER_STOP");
844
845 }
846
847
848 static int wpa_cli_cmd_wps_er_pin(struct wpa_ctrl *ctrl, int argc,
849 char *argv[])
850 {
851 if (argc < 2) {
852 printf("Invalid WPS_ER_PIN command: need at least two "
853 "arguments:\n"
854 "- UUID: use 'any' to select any\n"
855 "- PIN: Enrollee PIN\n"
856 "optional: - Enrollee MAC address\n");
857 return -1;
858 }
859
860 return wpa_cli_cmd(ctrl, "WPS_ER_PIN", 2, argc, argv);
861 }
862
863
864 static int wpa_cli_cmd_wps_er_pbc(struct wpa_ctrl *ctrl, int argc,
865 char *argv[])
866 {
867 return wpa_cli_cmd(ctrl, "WPS_ER_PBC", 1, argc, argv);
868 }
869
870
871 static int wpa_cli_cmd_wps_er_learn(struct wpa_ctrl *ctrl, int argc,
872 char *argv[])
873 {
874 if (argc != 2) {
875 printf("Invalid WPS_ER_LEARN command: need two arguments:\n"
876 "- UUID: specify which AP to use\n"
877 "- PIN: AP PIN\n");
878 return -1;
879 }
880
881 return wpa_cli_cmd(ctrl, "WPS_ER_LEARN", 2, argc, argv);
882 }
883
884
885 static int wpa_cli_cmd_wps_er_set_config(struct wpa_ctrl *ctrl, int argc,
886 char *argv[])
887 {
888 if (argc != 2) {
889 printf("Invalid WPS_ER_SET_CONFIG command: need two "
890 "arguments:\n"
891 "- UUID: specify which AP to use\n"
892 "- Network configuration id\n");
893 return -1;
894 }
895
896 return wpa_cli_cmd(ctrl, "WPS_ER_SET_CONFIG", 2, argc, argv);
897 }
898
899
900 static int wpa_cli_cmd_wps_er_config(struct wpa_ctrl *ctrl, int argc,
901 char *argv[])
902 {
903 char cmd[256];
904 int res;
905
906 if (argc == 5 || argc == 6) {
907 char ssid_hex[2 * 32 + 1];
908 char key_hex[2 * 64 + 1];
909 int i;
910
911 ssid_hex[0] = '\0';
912 for (i = 0; i < 32; i++) {
913 if (argv[2][i] == '\0')
914 break;
915 os_snprintf(&ssid_hex[i * 2], 3, "%02x", argv[2][i]);
916 }
917
918 key_hex[0] = '\0';
919 if (argc == 6) {
920 for (i = 0; i < 64; i++) {
921 if (argv[5][i] == '\0')
922 break;
923 os_snprintf(&key_hex[i * 2], 3, "%02x",
924 argv[5][i]);
925 }
926 }
927
928 res = os_snprintf(cmd, sizeof(cmd),
929 "WPS_ER_CONFIG %s %s %s %s %s %s",
930 argv[0], argv[1], ssid_hex, argv[3], argv[4],
931 key_hex);
932 } else {
933 printf("Invalid WPS_ER_CONFIG command: need six arguments:\n"
934 "- AP UUID\n"
935 "- AP PIN\n"
936 "- new SSID\n"
937 "- new auth (OPEN, WPAPSK, WPA2PSK)\n"
938 "- new encr (NONE, WEP, TKIP, CCMP)\n"
939 "- new key\n");
940 return -1;
941 }
942
943 if (res < 0 || (size_t) res >= sizeof(cmd) - 1) {
944 printf("Too long WPS_ER_CONFIG command.\n");
945 return -1;
946 }
947 return wpa_ctrl_command(ctrl, cmd);
948 }
949
950
951 #ifdef CONFIG_WPS_NFC
952 static int wpa_cli_cmd_wps_er_nfc_config_token(struct wpa_ctrl *ctrl, int argc,
953 char *argv[])
954 {
955 if (argc != 2) {
956 printf("Invalid WPS_ER_NFC_CONFIG_TOKEN command: need two "
957 "arguments:\n"
958 "- WPS/NDEF: token format\n"
959 "- UUID: specify which AP to use\n");
960 return -1;
961 }
962
963 return wpa_cli_cmd(ctrl, "WPS_ER_NFC_CONFIG_TOKEN", 2, argc, argv);
964 }
965 #endif /* CONFIG_WPS_NFC */
966
967
968 static int wpa_cli_cmd_ibss_rsn(struct wpa_ctrl *ctrl, int argc, char *argv[])
969 {
970 return wpa_cli_cmd(ctrl, "IBSS_RSN", 1, argc, argv);
971 }
972
973
974 static int wpa_cli_cmd_level(struct wpa_ctrl *ctrl, int argc, char *argv[])
975 {
976 return wpa_cli_cmd(ctrl, "LEVEL", 1, argc, argv);
977 }
978
979
980 static int wpa_cli_cmd_identity(struct wpa_ctrl *ctrl, int argc, char *argv[])
981 {
982 char cmd[256], *pos, *end;
983 int i, ret;
984
985 if (argc < 2) {
986 printf("Invalid IDENTITY command: needs two arguments "
987 "(network id and identity)\n");
988 return -1;
989 }
990
991 end = cmd + sizeof(cmd);
992 pos = cmd;
993 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "IDENTITY-%s:%s",
994 argv[0], argv[1]);
995 if (ret < 0 || ret >= end - pos) {
996 printf("Too long IDENTITY command.\n");
997 return -1;
998 }
999 pos += ret;
1000 for (i = 2; i < argc; i++) {
1001 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
1002 if (ret < 0 || ret >= end - pos) {
1003 printf("Too long IDENTITY command.\n");
1004 return -1;
1005 }
1006 pos += ret;
1007 }
1008
1009 return wpa_ctrl_command(ctrl, cmd);
1010 }
1011
1012
1013 static int wpa_cli_cmd_password(struct wpa_ctrl *ctrl, int argc, char *argv[])
1014 {
1015 char cmd[256], *pos, *end;
1016 int i, ret;
1017
1018 if (argc < 2) {
1019 printf("Invalid PASSWORD command: needs two arguments "
1020 "(network id and password)\n");
1021 return -1;
1022 }
1023
1024 end = cmd + sizeof(cmd);
1025 pos = cmd;
1026 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "PASSWORD-%s:%s",
1027 argv[0], argv[1]);
1028 if (ret < 0 || ret >= end - pos) {
1029 printf("Too long PASSWORD command.\n");
1030 return -1;
1031 }
1032 pos += ret;
1033 for (i = 2; i < argc; i++) {
1034 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
1035 if (ret < 0 || ret >= end - pos) {
1036 printf("Too long PASSWORD command.\n");
1037 return -1;
1038 }
1039 pos += ret;
1040 }
1041
1042 return wpa_ctrl_command(ctrl, cmd);
1043 }
1044
1045
1046 static int wpa_cli_cmd_new_password(struct wpa_ctrl *ctrl, int argc,
1047 char *argv[])
1048 {
1049 char cmd[256], *pos, *end;
1050 int i, ret;
1051
1052 if (argc < 2) {
1053 printf("Invalid NEW_PASSWORD command: needs two arguments "
1054 "(network id and password)\n");
1055 return -1;
1056 }
1057
1058 end = cmd + sizeof(cmd);
1059 pos = cmd;
1060 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "NEW_PASSWORD-%s:%s",
1061 argv[0], argv[1]);
1062 if (ret < 0 || ret >= end - pos) {
1063 printf("Too long NEW_PASSWORD command.\n");
1064 return -1;
1065 }
1066 pos += ret;
1067 for (i = 2; i < argc; i++) {
1068 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
1069 if (ret < 0 || ret >= end - pos) {
1070 printf("Too long NEW_PASSWORD command.\n");
1071 return -1;
1072 }
1073 pos += ret;
1074 }
1075
1076 return wpa_ctrl_command(ctrl, cmd);
1077 }
1078
1079
1080 static int wpa_cli_cmd_pin(struct wpa_ctrl *ctrl, int argc, char *argv[])
1081 {
1082 char cmd[256], *pos, *end;
1083 int i, ret;
1084
1085 if (argc < 2) {
1086 printf("Invalid PIN command: needs two arguments "
1087 "(network id and pin)\n");
1088 return -1;
1089 }
1090
1091 end = cmd + sizeof(cmd);
1092 pos = cmd;
1093 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "PIN-%s:%s",
1094 argv[0], argv[1]);
1095 if (ret < 0 || ret >= end - pos) {
1096 printf("Too long PIN command.\n");
1097 return -1;
1098 }
1099 pos += ret;
1100 for (i = 2; i < argc; i++) {
1101 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
1102 if (ret < 0 || ret >= end - pos) {
1103 printf("Too long PIN command.\n");
1104 return -1;
1105 }
1106 pos += ret;
1107 }
1108 return wpa_ctrl_command(ctrl, cmd);
1109 }
1110
1111
1112 static int wpa_cli_cmd_otp(struct wpa_ctrl *ctrl, int argc, char *argv[])
1113 {
1114 char cmd[256], *pos, *end;
1115 int i, ret;
1116
1117 if (argc < 2) {
1118 printf("Invalid OTP command: needs two arguments (network "
1119 "id and password)\n");
1120 return -1;
1121 }
1122
1123 end = cmd + sizeof(cmd);
1124 pos = cmd;
1125 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "OTP-%s:%s",
1126 argv[0], argv[1]);
1127 if (ret < 0 || ret >= end - pos) {
1128 printf("Too long OTP command.\n");
1129 return -1;
1130 }
1131 pos += ret;
1132 for (i = 2; i < argc; i++) {
1133 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
1134 if (ret < 0 || ret >= end - pos) {
1135 printf("Too long OTP command.\n");
1136 return -1;
1137 }
1138 pos += ret;
1139 }
1140
1141 return wpa_ctrl_command(ctrl, cmd);
1142 }
1143
1144
1145 static int wpa_cli_cmd_passphrase(struct wpa_ctrl *ctrl, int argc,
1146 char *argv[])
1147 {
1148 char cmd[256], *pos, *end;
1149 int i, ret;
1150
1151 if (argc < 2) {
1152 printf("Invalid PASSPHRASE command: needs two arguments "
1153 "(network id and passphrase)\n");
1154 return -1;
1155 }
1156
1157 end = cmd + sizeof(cmd);
1158 pos = cmd;
1159 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "PASSPHRASE-%s:%s",
1160 argv[0], argv[1]);
1161 if (ret < 0 || ret >= end - pos) {
1162 printf("Too long PASSPHRASE command.\n");
1163 return -1;
1164 }
1165 pos += ret;
1166 for (i = 2; i < argc; i++) {
1167 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
1168 if (ret < 0 || ret >= end - pos) {
1169 printf("Too long PASSPHRASE command.\n");
1170 return -1;
1171 }
1172 pos += ret;
1173 }
1174
1175 return wpa_ctrl_command(ctrl, cmd);
1176 }
1177
1178
1179 static int wpa_cli_cmd_bssid(struct wpa_ctrl *ctrl, int argc, char *argv[])
1180 {
1181 if (argc < 2) {
1182 printf("Invalid BSSID command: needs two arguments (network "
1183 "id and BSSID)\n");
1184 return -1;
1185 }
1186
1187 return wpa_cli_cmd(ctrl, "BSSID", 2, argc, argv);
1188 }
1189
1190
1191 static int wpa_cli_cmd_blacklist(struct wpa_ctrl *ctrl, int argc, char *argv[])
1192 {
1193 return wpa_cli_cmd(ctrl, "BLACKLIST", 0, argc, argv);
1194 }
1195
1196
1197 static int wpa_cli_cmd_log_level(struct wpa_ctrl *ctrl, int argc, char *argv[])
1198 {
1199 return wpa_cli_cmd(ctrl, "LOG_LEVEL", 0, argc, argv);
1200 }
1201
1202
1203 static int wpa_cli_cmd_list_networks(struct wpa_ctrl *ctrl, int argc,
1204 char *argv[])
1205 {
1206 return wpa_ctrl_command(ctrl, "LIST_NETWORKS");
1207 }
1208
1209
1210 static int wpa_cli_cmd_select_network(struct wpa_ctrl *ctrl, int argc,
1211 char *argv[])
1212 {
1213 return wpa_cli_cmd(ctrl, "SELECT_NETWORK", 1, argc, argv);
1214 }
1215
1216
1217 static int wpa_cli_cmd_enable_network(struct wpa_ctrl *ctrl, int argc,
1218 char *argv[])
1219 {
1220 return wpa_cli_cmd(ctrl, "ENABLE_NETWORK", 1, argc, argv);
1221 }
1222
1223
1224 static int wpa_cli_cmd_disable_network(struct wpa_ctrl *ctrl, int argc,
1225 char *argv[])
1226 {
1227 return wpa_cli_cmd(ctrl, "DISABLE_NETWORK", 1, argc, argv);
1228 }
1229
1230
1231 static int wpa_cli_cmd_add_network(struct wpa_ctrl *ctrl, int argc,
1232 char *argv[])
1233 {
1234 return wpa_ctrl_command(ctrl, "ADD_NETWORK");
1235 }
1236
1237
1238 static int wpa_cli_cmd_remove_network(struct wpa_ctrl *ctrl, int argc,
1239 char *argv[])
1240 {
1241 return wpa_cli_cmd(ctrl, "REMOVE_NETWORK", 1, argc, argv);
1242 }
1243
1244
1245 static void wpa_cli_show_network_variables(void)
1246 {
1247 printf("set_network variables:\n"
1248 " ssid (network name, SSID)\n"
1249 " psk (WPA passphrase or pre-shared key)\n"
1250 " key_mgmt (key management protocol)\n"
1251 " identity (EAP identity)\n"
1252 " password (EAP password)\n"
1253 " ...\n"
1254 "\n"
1255 "Note: Values are entered in the same format as the "
1256 "configuration file is using,\n"
1257 "i.e., strings values need to be inside double quotation "
1258 "marks.\n"
1259 "For example: set_network 1 ssid \"network name\"\n"
1260 "\n"
1261 "Please see wpa_supplicant.conf documentation for full list "
1262 "of\navailable variables.\n");
1263 }
1264
1265
1266 static int wpa_cli_cmd_set_network(struct wpa_ctrl *ctrl, int argc,
1267 char *argv[])
1268 {
1269 if (argc == 0) {
1270 wpa_cli_show_network_variables();
1271 return 0;
1272 }
1273
1274 if (argc != 3) {
1275 printf("Invalid SET_NETWORK command: needs three arguments\n"
1276 "(network id, variable name, and value)\n");
1277 return -1;
1278 }
1279
1280 return wpa_cli_cmd(ctrl, "SET_NETWORK", 3, argc, argv);
1281 }
1282
1283
1284 static int wpa_cli_cmd_get_network(struct wpa_ctrl *ctrl, int argc,
1285 char *argv[])
1286 {
1287 if (argc == 0) {
1288 wpa_cli_show_network_variables();
1289 return 0;
1290 }
1291
1292 if (argc != 2) {
1293 printf("Invalid GET_NETWORK command: needs two arguments\n"
1294 "(network id and variable name)\n");
1295 return -1;
1296 }
1297
1298 return wpa_cli_cmd(ctrl, "GET_NETWORK", 2, argc, argv);
1299 }
1300
1301
1302 static int wpa_cli_cmd_list_creds(struct wpa_ctrl *ctrl, int argc,
1303 char *argv[])
1304 {
1305 return wpa_ctrl_command(ctrl, "LIST_CREDS");
1306 }
1307
1308
1309 static int wpa_cli_cmd_add_cred(struct wpa_ctrl *ctrl, int argc, char *argv[])
1310 {
1311 return wpa_ctrl_command(ctrl, "ADD_CRED");
1312 }
1313
1314
1315 static int wpa_cli_cmd_remove_cred(struct wpa_ctrl *ctrl, int argc,
1316 char *argv[])
1317 {
1318 return wpa_cli_cmd(ctrl, "REMOVE_CRED", 1, argc, argv);
1319 }
1320
1321
1322 static int wpa_cli_cmd_set_cred(struct wpa_ctrl *ctrl, int argc, char *argv[])
1323 {
1324 if (argc != 3) {
1325 printf("Invalid SET_CRED command: needs three arguments\n"
1326 "(cred id, variable name, and value)\n");
1327 return -1;
1328 }
1329
1330 return wpa_cli_cmd(ctrl, "SET_CRED", 3, argc, argv);
1331 }
1332
1333
1334 static int wpa_cli_cmd_disconnect(struct wpa_ctrl *ctrl, int argc,
1335 char *argv[])
1336 {
1337 return wpa_ctrl_command(ctrl, "DISCONNECT");
1338 }
1339
1340
1341 static int wpa_cli_cmd_reconnect(struct wpa_ctrl *ctrl, int argc,
1342 char *argv[])
1343 {
1344 return wpa_ctrl_command(ctrl, "RECONNECT");
1345 }
1346
1347
1348 static int wpa_cli_cmd_save_config(struct wpa_ctrl *ctrl, int argc,
1349 char *argv[])
1350 {
1351 return wpa_ctrl_command(ctrl, "SAVE_CONFIG");
1352 }
1353
1354
1355 static int wpa_cli_cmd_scan(struct wpa_ctrl *ctrl, int argc, char *argv[])
1356 {
1357 return wpa_ctrl_command(ctrl, "SCAN");
1358 }
1359
1360
1361 static int wpa_cli_cmd_scan_results(struct wpa_ctrl *ctrl, int argc,
1362 char *argv[])
1363 {
1364 return wpa_ctrl_command(ctrl, "SCAN_RESULTS");
1365 }
1366
1367
1368 static int wpa_cli_cmd_bss(struct wpa_ctrl *ctrl, int argc, char *argv[])
1369 {
1370 return wpa_cli_cmd(ctrl, "BSS", 1, argc, argv);
1371 }
1372
1373
1374 static char ** wpa_cli_complete_bss(const char *str, int pos)
1375 {
1376 int arg = get_cmd_arg_num(str, pos);
1377 char **res = NULL;
1378
1379 switch (arg) {
1380 case 1:
1381 res = cli_txt_list_array(&bsses);
1382 break;
1383 }
1384
1385 return res;
1386 }
1387
1388
1389 static int wpa_cli_cmd_get_capability(struct wpa_ctrl *ctrl, int argc,
1390 char *argv[])
1391 {
1392 if (argc < 1 || argc > 2) {
1393 printf("Invalid GET_CAPABILITY command: need either one or "
1394 "two arguments\n");
1395 return -1;
1396 }
1397
1398 if ((argc == 2) && os_strcmp(argv[1], "strict") != 0) {
1399 printf("Invalid GET_CAPABILITY command: second argument, "
1400 "if any, must be 'strict'\n");
1401 return -1;
1402 }
1403
1404 return wpa_cli_cmd(ctrl, "GET_CAPABILITY", 1, argc, argv);
1405 }
1406
1407
1408 static int wpa_cli_list_interfaces(struct wpa_ctrl *ctrl)
1409 {
1410 printf("Available interfaces:\n");
1411 return wpa_ctrl_command(ctrl, "INTERFACES");
1412 }
1413
1414
1415 static int wpa_cli_cmd_interface(struct wpa_ctrl *ctrl, int argc, char *argv[])
1416 {
1417 if (argc < 1) {
1418 wpa_cli_list_interfaces(ctrl);
1419 return 0;
1420 }
1421
1422 wpa_cli_close_connection();
1423 os_free(ctrl_ifname);
1424 ctrl_ifname = os_strdup(argv[0]);
1425
1426 if (wpa_cli_open_connection(ctrl_ifname, 1)) {
1427 printf("Connected to interface '%s.\n", ctrl_ifname);
1428 } else {
1429 printf("Could not connect to interface '%s' - re-trying\n",
1430 ctrl_ifname);
1431 }
1432 return 0;
1433 }
1434
1435
1436 static int wpa_cli_cmd_reconfigure(struct wpa_ctrl *ctrl, int argc,
1437 char *argv[])
1438 {
1439 return wpa_ctrl_command(ctrl, "RECONFIGURE");
1440 }
1441
1442
1443 static int wpa_cli_cmd_terminate(struct wpa_ctrl *ctrl, int argc,
1444 char *argv[])
1445 {
1446 return wpa_ctrl_command(ctrl, "TERMINATE");
1447 }
1448
1449
1450 static int wpa_cli_cmd_interface_add(struct wpa_ctrl *ctrl, int argc,
1451 char *argv[])
1452 {
1453 char cmd[256];
1454 int res;
1455
1456 if (argc < 1) {
1457 printf("Invalid INTERFACE_ADD command: needs at least one "
1458 "argument (interface name)\n"
1459 "All arguments: ifname confname driver ctrl_interface "
1460 "driver_param bridge_name\n");
1461 return -1;
1462 }
1463
1464 /*
1465 * INTERFACE_ADD <ifname>TAB<confname>TAB<driver>TAB<ctrl_interface>TAB
1466 * <driver_param>TAB<bridge_name>
1467 */
1468 res = os_snprintf(cmd, sizeof(cmd),
1469 "INTERFACE_ADD %s\t%s\t%s\t%s\t%s\t%s",
1470 argv[0],
1471 argc > 1 ? argv[1] : "", argc > 2 ? argv[2] : "",
1472 argc > 3 ? argv[3] : "", argc > 4 ? argv[4] : "",
1473 argc > 5 ? argv[5] : "");
1474 if (res < 0 || (size_t) res >= sizeof(cmd))
1475 return -1;
1476 cmd[sizeof(cmd) - 1] = '\0';
1477 return wpa_ctrl_command(ctrl, cmd);
1478 }
1479
1480
1481 static int wpa_cli_cmd_interface_remove(struct wpa_ctrl *ctrl, int argc,
1482 char *argv[])
1483 {
1484 return wpa_cli_cmd(ctrl, "INTERFACE_REMOVE", 1, argc, argv);
1485 }
1486
1487
1488 static int wpa_cli_cmd_interface_list(struct wpa_ctrl *ctrl, int argc,
1489 char *argv[])
1490 {
1491 return wpa_ctrl_command(ctrl, "INTERFACE_LIST");
1492 }
1493
1494
1495 #ifdef CONFIG_AP
1496 static int wpa_cli_cmd_sta(struct wpa_ctrl *ctrl, int argc, char *argv[])
1497 {
1498 return wpa_cli_cmd(ctrl, "STA", 1, argc, argv);
1499 }
1500
1501
1502 static int wpa_ctrl_command_sta(struct wpa_ctrl *ctrl, char *cmd,
1503 char *addr, size_t addr_len)
1504 {
1505 char buf[4096], *pos;
1506 size_t len;
1507 int ret;
1508
1509 if (ctrl_conn == NULL) {
1510 printf("Not connected to hostapd - command dropped.\n");
1511 return -1;
1512 }
1513 len = sizeof(buf) - 1;
1514 ret = wpa_ctrl_request(ctrl, cmd, os_strlen(cmd), buf, &len,
1515 wpa_cli_msg_cb);
1516 if (ret == -2) {
1517 printf("'%s' command timed out.\n", cmd);
1518 return -2;
1519 } else if (ret < 0) {
1520 printf("'%s' command failed.\n", cmd);
1521 return -1;
1522 }
1523
1524 buf[len] = '\0';
1525 if (os_memcmp(buf, "FAIL", 4) == 0)
1526 return -1;
1527 printf("%s", buf);
1528
1529 pos = buf;
1530 while (*pos != '\0' && *pos != '\n')
1531 pos++;
1532 *pos = '\0';
1533 os_strlcpy(addr, buf, addr_len);
1534 return 0;
1535 }
1536
1537
1538 static int wpa_cli_cmd_all_sta(struct wpa_ctrl *ctrl, int argc, char *argv[])
1539 {
1540 char addr[32], cmd[64];
1541
1542 if (wpa_ctrl_command_sta(ctrl, "STA-FIRST", addr, sizeof(addr)))
1543 return 0;
1544 do {
1545 os_snprintf(cmd, sizeof(cmd), "STA-NEXT %s", addr);
1546 } while (wpa_ctrl_command_sta(ctrl, cmd, addr, sizeof(addr)) == 0);
1547
1548 return -1;
1549 }
1550
1551
1552 static int wpa_cli_cmd_deauthenticate(struct wpa_ctrl *ctrl, int argc,
1553 char *argv[])
1554 {
1555 return wpa_cli_cmd(ctrl, "DEAUTHENTICATE", 1, argc, argv);
1556 }
1557
1558
1559 static int wpa_cli_cmd_disassociate(struct wpa_ctrl *ctrl, int argc,
1560 char *argv[])
1561 {
1562 return wpa_cli_cmd(ctrl, "DISASSOCIATE", 1, argc, argv);
1563 }
1564 #endif /* CONFIG_AP */
1565
1566
1567 static int wpa_cli_cmd_suspend(struct wpa_ctrl *ctrl, int argc, char *argv[])
1568 {
1569 return wpa_ctrl_command(ctrl, "SUSPEND");
1570 }
1571
1572
1573 static int wpa_cli_cmd_resume(struct wpa_ctrl *ctrl, int argc, char *argv[])
1574 {
1575 return wpa_ctrl_command(ctrl, "RESUME");
1576 }
1577
1578
1579 static int wpa_cli_cmd_drop_sa(struct wpa_ctrl *ctrl, int argc, char *argv[])
1580 {
1581 return wpa_ctrl_command(ctrl, "DROP_SA");
1582 }
1583
1584
1585 static int wpa_cli_cmd_roam(struct wpa_ctrl *ctrl, int argc, char *argv[])
1586 {
1587 return wpa_cli_cmd(ctrl, "ROAM", 1, argc, argv);
1588 }
1589
1590
1591 #ifdef CONFIG_P2P
1592
1593 static int wpa_cli_cmd_p2p_find(struct wpa_ctrl *ctrl, int argc, char *argv[])
1594 {
1595 return wpa_cli_cmd(ctrl, "P2P_FIND", 0, argc, argv);
1596 }
1597
1598
1599 static int wpa_cli_cmd_p2p_stop_find(struct wpa_ctrl *ctrl, int argc,
1600 char *argv[])
1601 {
1602 return wpa_ctrl_command(ctrl, "P2P_STOP_FIND");
1603 }
1604
1605
1606 static int wpa_cli_cmd_p2p_connect(struct wpa_ctrl *ctrl, int argc,
1607 char *argv[])
1608 {
1609 return wpa_cli_cmd(ctrl, "P2P_CONNECT", 2, argc, argv);
1610 }
1611
1612
1613 static char ** wpa_cli_complete_p2p_connect(const char *str, int pos)
1614 {
1615 int arg = get_cmd_arg_num(str, pos);
1616 char **res = NULL;
1617
1618 switch (arg) {
1619 case 1:
1620 res = cli_txt_list_array(&p2p_peers);
1621 break;
1622 }
1623
1624 return res;
1625 }
1626
1627
1628 static int wpa_cli_cmd_p2p_listen(struct wpa_ctrl *ctrl, int argc,
1629 char *argv[])
1630 {
1631 return wpa_cli_cmd(ctrl, "P2P_LISTEN", 0, argc, argv);
1632 }
1633
1634
1635 static int wpa_cli_cmd_p2p_group_remove(struct wpa_ctrl *ctrl, int argc,
1636 char *argv[])
1637 {
1638 return wpa_cli_cmd(ctrl, "P2P_GROUP_REMOVE", 1, argc, argv);
1639 }
1640
1641
1642 static char ** wpa_cli_complete_p2p_group_remove(const char *str, int pos)
1643 {
1644 int arg = get_cmd_arg_num(str, pos);
1645 char **res = NULL;
1646
1647 switch (arg) {
1648 case 1:
1649 res = cli_txt_list_array(&p2p_groups);
1650 break;
1651 }
1652
1653 return res;
1654 }
1655
1656
1657 static int wpa_cli_cmd_p2p_group_add(struct wpa_ctrl *ctrl, int argc,
1658 char *argv[])
1659 {
1660 return wpa_cli_cmd(ctrl, "P2P_GROUP_ADD", 0, argc, argv);
1661 }
1662
1663
1664 static int wpa_cli_cmd_p2p_prov_disc(struct wpa_ctrl *ctrl, int argc,
1665 char *argv[])
1666 {
1667 if (argc != 2 && argc != 3) {
1668 printf("Invalid P2P_PROV_DISC command: needs at least "
1669 "two arguments, address and config method\n"
1670 "(display, keypad, or pbc) and an optional join\n");
1671 return -1;
1672 }
1673
1674 return wpa_cli_cmd(ctrl, "P2P_PROV_DISC", 2, argc, argv);
1675 }
1676
1677
1678 static int wpa_cli_cmd_p2p_get_passphrase(struct wpa_ctrl *ctrl, int argc,
1679 char *argv[])
1680 {
1681 return wpa_ctrl_command(ctrl, "P2P_GET_PASSPHRASE");
1682 }
1683
1684
1685 static int wpa_cli_cmd_p2p_serv_disc_req(struct wpa_ctrl *ctrl, int argc,
1686 char *argv[])
1687 {
1688 char cmd[4096];
1689
1690 if (argc != 2 && argc != 4) {
1691 printf("Invalid P2P_SERV_DISC_REQ command: needs two "
1692 "arguments (address and TLVs) or four arguments "
1693 "(address, \"upnp\", version, search target "
1694 "(SSDP ST:)\n");
1695 return -1;
1696 }
1697
1698 if (write_cmd(cmd, sizeof(cmd), "P2P_SERV_DISC_REQ", argc, argv) < 0)
1699 return -1;
1700 return wpa_ctrl_command(ctrl, cmd);
1701 }
1702
1703
1704 static int wpa_cli_cmd_p2p_serv_disc_cancel_req(struct wpa_ctrl *ctrl,
1705 int argc, char *argv[])
1706 {
1707 return wpa_cli_cmd(ctrl, "P2P_SERV_DISC_CANCEL_REQ", 1, argc, argv);
1708 }
1709
1710
1711 static int wpa_cli_cmd_p2p_serv_disc_resp(struct wpa_ctrl *ctrl, int argc,
1712 char *argv[])
1713 {
1714 char cmd[4096];
1715 int res;
1716
1717 if (argc != 4) {
1718 printf("Invalid P2P_SERV_DISC_RESP command: needs four "
1719 "arguments (freq, address, dialog token, and TLVs)\n");
1720 return -1;
1721 }
1722
1723 res = os_snprintf(cmd, sizeof(cmd), "P2P_SERV_DISC_RESP %s %s %s %s",
1724 argv[0], argv[1], argv[2], argv[3]);
1725 if (res < 0 || (size_t) res >= sizeof(cmd))
1726 return -1;
1727 cmd[sizeof(cmd) - 1] = '\0';
1728 return wpa_ctrl_command(ctrl, cmd);
1729 }
1730
1731
1732 static int wpa_cli_cmd_p2p_service_update(struct wpa_ctrl *ctrl, int argc,
1733 char *argv[])
1734 {
1735 return wpa_ctrl_command(ctrl, "P2P_SERVICE_UPDATE");
1736 }
1737
1738
1739 static int wpa_cli_cmd_p2p_serv_disc_external(struct wpa_ctrl *ctrl,
1740 int argc, char *argv[])
1741 {
1742 return wpa_cli_cmd(ctrl, "P2P_SERV_DISC_EXTERNAL", 1, argc, argv);
1743 }
1744
1745
1746 static int wpa_cli_cmd_p2p_service_flush(struct wpa_ctrl *ctrl, int argc,
1747 char *argv[])
1748 {
1749 return wpa_ctrl_command(ctrl, "P2P_SERVICE_FLUSH");
1750 }
1751
1752
1753 static int wpa_cli_cmd_p2p_service_add(struct wpa_ctrl *ctrl, int argc,
1754 char *argv[])
1755 {
1756 char cmd[4096];
1757 int res;
1758
1759 if (argc != 3 && argc != 4) {
1760 printf("Invalid P2P_SERVICE_ADD command: needs three or four "
1761 "arguments\n");
1762 return -1;
1763 }
1764
1765 if (argc == 4)
1766 res = os_snprintf(cmd, sizeof(cmd),
1767 "P2P_SERVICE_ADD %s %s %s %s",
1768 argv[0], argv[1], argv[2], argv[3]);
1769 else
1770 res = os_snprintf(cmd, sizeof(cmd),
1771 "P2P_SERVICE_ADD %s %s %s",
1772 argv[0], argv[1], argv[2]);
1773 if (res < 0 || (size_t) res >= sizeof(cmd))
1774 return -1;
1775 cmd[sizeof(cmd) - 1] = '\0';
1776 return wpa_ctrl_command(ctrl, cmd);
1777 }
1778
1779
1780 static int wpa_cli_cmd_p2p_service_del(struct wpa_ctrl *ctrl, int argc,
1781 char *argv[])
1782 {
1783 char cmd[4096];
1784 int res;
1785
1786 if (argc != 2 && argc != 3) {
1787 printf("Invalid P2P_SERVICE_DEL command: needs two or three "
1788 "arguments\n");
1789 return -1;
1790 }
1791
1792 if (argc == 3)
1793 res = os_snprintf(cmd, sizeof(cmd),
1794 "P2P_SERVICE_DEL %s %s %s",
1795 argv[0], argv[1], argv[2]);
1796 else
1797 res = os_snprintf(cmd, sizeof(cmd),
1798 "P2P_SERVICE_DEL %s %s",
1799 argv[0], argv[1]);
1800 if (res < 0 || (size_t) res >= sizeof(cmd))
1801 return -1;
1802 cmd[sizeof(cmd) - 1] = '\0';
1803 return wpa_ctrl_command(ctrl, cmd);
1804 }
1805
1806
1807 static int wpa_cli_cmd_p2p_reject(struct wpa_ctrl *ctrl,
1808 int argc, char *argv[])
1809 {
1810 return wpa_cli_cmd(ctrl, "P2P_REJECT", 1, argc, argv);
1811 }
1812
1813
1814 static int wpa_cli_cmd_p2p_invite(struct wpa_ctrl *ctrl,
1815 int argc, char *argv[])
1816 {
1817 return wpa_cli_cmd(ctrl, "P2P_INVITE", 1, argc, argv);
1818 }
1819
1820
1821 static int wpa_cli_cmd_p2p_peer(struct wpa_ctrl *ctrl, int argc, char *argv[])
1822 {
1823 return wpa_cli_cmd(ctrl, "P2P_PEER", 1, argc, argv);
1824 }
1825
1826
1827 static char ** wpa_cli_complete_p2p_peer(const char *str, int pos)
1828 {
1829 int arg = get_cmd_arg_num(str, pos);
1830 char **res = NULL;
1831
1832 switch (arg) {
1833 case 1:
1834 res = cli_txt_list_array(&p2p_peers);
1835 break;
1836 }
1837
1838 return res;
1839 }
1840
1841
1842 static int wpa_ctrl_command_p2p_peer(struct wpa_ctrl *ctrl, char *cmd,
1843 char *addr, size_t addr_len,
1844 int discovered)
1845 {
1846 char buf[4096], *pos;
1847 size_t len;
1848 int ret;
1849
1850 if (ctrl_conn == NULL)
1851 return -1;
1852 len = sizeof(buf) - 1;
1853 ret = wpa_ctrl_request(ctrl, cmd, os_strlen(cmd), buf, &len,
1854 wpa_cli_msg_cb);
1855 if (ret == -2) {
1856 printf("'%s' command timed out.\n", cmd);
1857 return -2;
1858 } else if (ret < 0) {
1859 printf("'%s' command failed.\n", cmd);
1860 return -1;
1861 }
1862
1863 buf[len] = '\0';
1864 if (os_memcmp(buf, "FAIL", 4) == 0)
1865 return -1;
1866
1867 pos = buf;
1868 while (*pos != '\0' && *pos != '\n')
1869 pos++;
1870 *pos++ = '\0';
1871 os_strlcpy(addr, buf, addr_len);
1872 if (!discovered || os_strstr(pos, "[PROBE_REQ_ONLY]") == NULL)
1873 printf("%s\n", addr);
1874 return 0;
1875 }
1876
1877
1878 static int wpa_cli_cmd_p2p_peers(struct wpa_ctrl *ctrl, int argc, char *argv[])
1879 {
1880 char addr[32], cmd[64];
1881 int discovered;
1882
1883 discovered = argc > 0 && os_strcmp(argv[0], "discovered") == 0;
1884
1885 if (wpa_ctrl_command_p2p_peer(ctrl, "P2P_PEER FIRST",
1886 addr, sizeof(addr), discovered))
1887 return -1;
1888 do {
1889 os_snprintf(cmd, sizeof(cmd), "P2P_PEER NEXT-%s", addr);
1890 } while (wpa_ctrl_command_p2p_peer(ctrl, cmd, addr, sizeof(addr),
1891 discovered) == 0);
1892
1893 return 0;
1894 }
1895
1896
1897 static int wpa_cli_cmd_p2p_set(struct wpa_ctrl *ctrl, int argc, char *argv[])
1898 {
1899 return wpa_cli_cmd(ctrl, "P2P_SET", 2, argc, argv);
1900 }
1901
1902
1903 static int wpa_cli_cmd_p2p_flush(struct wpa_ctrl *ctrl, int argc, char *argv[])
1904 {
1905 return wpa_ctrl_command(ctrl, "P2P_FLUSH");
1906 }
1907
1908
1909 static int wpa_cli_cmd_p2p_cancel(struct wpa_ctrl *ctrl, int argc,
1910 char *argv[])
1911 {
1912 return wpa_ctrl_command(ctrl, "P2P_CANCEL");
1913 }
1914
1915
1916 static int wpa_cli_cmd_p2p_unauthorize(struct wpa_ctrl *ctrl, int argc,
1917 char *argv[])
1918 {
1919 return wpa_cli_cmd(ctrl, "P2P_UNAUTHORIZE", 1, argc, argv);
1920 }
1921
1922
1923 static int wpa_cli_cmd_p2p_presence_req(struct wpa_ctrl *ctrl, int argc,
1924 char *argv[])
1925 {
1926 if (argc != 0 && argc != 2 && argc != 4) {
1927 printf("Invalid P2P_PRESENCE_REQ command: needs two arguments "
1928 "(preferred duration, interval; in microsecods).\n"
1929 "Optional second pair can be used to provide "
1930 "acceptable values.\n");
1931 return -1;
1932 }
1933
1934 return wpa_cli_cmd(ctrl, "P2P_PRESENCE_REQ", 0, argc, argv);
1935 }
1936
1937
1938 static int wpa_cli_cmd_p2p_ext_listen(struct wpa_ctrl *ctrl, int argc,
1939 char *argv[])
1940 {
1941 if (argc != 0 && argc != 2) {
1942 printf("Invalid P2P_EXT_LISTEN command: needs two arguments "
1943 "(availability period, availability interval; in "
1944 "millisecods).\n"
1945 "Extended Listen Timing can be cancelled with this "
1946 "command when used without parameters.\n");
1947 return -1;
1948 }
1949
1950 return wpa_cli_cmd(ctrl, "P2P_EXT_LISTEN", 0, argc, argv);
1951 }
1952
1953 #endif /* CONFIG_P2P */
1954
1955
1956 #ifdef CONFIG_INTERWORKING
1957 static int wpa_cli_cmd_fetch_anqp(struct wpa_ctrl *ctrl, int argc,
1958 char *argv[])
1959 {
1960 return wpa_ctrl_command(ctrl, "FETCH_ANQP");
1961 }
1962
1963
1964 static int wpa_cli_cmd_stop_fetch_anqp(struct wpa_ctrl *ctrl, int argc,
1965 char *argv[])
1966 {
1967 return wpa_ctrl_command(ctrl, "STOP_FETCH_ANQP");
1968 }
1969
1970
1971 static int wpa_cli_cmd_interworking_select(struct wpa_ctrl *ctrl, int argc,
1972 char *argv[])
1973 {
1974 return wpa_cli_cmd(ctrl, "INTERWORKING_SELECT", 0, argc, argv);
1975 }
1976
1977
1978 static int wpa_cli_cmd_interworking_connect(struct wpa_ctrl *ctrl, int argc,
1979 char *argv[])
1980 {
1981 return wpa_cli_cmd(ctrl, "INTERWORKING_CONNECT", 1, argc, argv);
1982 }
1983
1984
1985 static int wpa_cli_cmd_anqp_get(struct wpa_ctrl *ctrl, int argc, char *argv[])
1986 {
1987 return wpa_cli_cmd(ctrl, "ANQP_GET", 2, argc, argv);
1988 }
1989 #endif /* CONFIG_INTERWORKING */
1990
1991
1992 #ifdef CONFIG_HS20
1993
1994 static int wpa_cli_cmd_hs20_anqp_get(struct wpa_ctrl *ctrl, int argc,
1995 char *argv[])
1996 {
1997 return wpa_cli_cmd(ctrl, "HS20_ANQP_GET", 2, argc, argv);
1998 }
1999
2000
2001 static int wpa_cli_cmd_get_nai_home_realm_list(struct wpa_ctrl *ctrl, int argc,
2002 char *argv[])
2003 {
2004 char cmd[512];
2005
2006 if (argc == 0) {
2007 printf("Command needs one or two arguments (dst mac addr and "
2008 "optional home realm)\n");
2009 return -1;
2010 }
2011
2012 if (write_cmd(cmd, sizeof(cmd), "HS20_GET_NAI_HOME_REALM_LIST",
2013 argc, argv) < 0)
2014 return -1;
2015
2016 return wpa_ctrl_command(ctrl, cmd);
2017 }
2018
2019 #endif /* CONFIG_HS20 */
2020
2021
2022 static int wpa_cli_cmd_sta_autoconnect(struct wpa_ctrl *ctrl, int argc,
2023 char *argv[])
2024 {
2025 return wpa_cli_cmd(ctrl, "STA_AUTOCONNECT", 1, argc, argv);
2026 }
2027
2028
2029 static int wpa_cli_cmd_tdls_discover(struct wpa_ctrl *ctrl, int argc,
2030 char *argv[])
2031 {
2032 return wpa_cli_cmd(ctrl, "TDLS_DISCOVER", 1, argc, argv);
2033 }
2034
2035
2036 static int wpa_cli_cmd_tdls_setup(struct wpa_ctrl *ctrl, int argc,
2037 char *argv[])
2038 {
2039 return wpa_cli_cmd(ctrl, "TDLS_SETUP", 1, argc, argv);
2040 }
2041
2042
2043 static int wpa_cli_cmd_tdls_teardown(struct wpa_ctrl *ctrl, int argc,
2044 char *argv[])
2045 {
2046 return wpa_cli_cmd(ctrl, "TDLS_TEARDOWN", 1, argc, argv);
2047 }
2048
2049
2050 static int wpa_cli_cmd_signal_poll(struct wpa_ctrl *ctrl, int argc,
2051 char *argv[])
2052 {
2053 return wpa_ctrl_command(ctrl, "SIGNAL_POLL");
2054 }
2055
2056
2057 static int wpa_cli_cmd_reauthenticate(struct wpa_ctrl *ctrl, int argc,
2058 char *argv[])
2059 {
2060 return wpa_ctrl_command(ctrl, "REAUTHENTICATE");
2061 }
2062
2063
2064 #ifdef CONFIG_AUTOSCAN
2065
2066 static int wpa_cli_cmd_autoscan(struct wpa_ctrl *ctrl, int argc, char *argv[])
2067 {
2068 if (argc == 0)
2069 return wpa_ctrl_command(ctrl, "AUTOSCAN ");
2070
2071 return wpa_cli_cmd(ctrl, "AUTOSCAN", 0, argc, argv);
2072 }
2073
2074 #endif /* CONFIG_AUTOSCAN */
2075
2076
2077 enum wpa_cli_cmd_flags {
2078 cli_cmd_flag_none = 0x00,
2079 cli_cmd_flag_sensitive = 0x01
2080 };
2081
2082 struct wpa_cli_cmd {
2083 const char *cmd;
2084 int (*handler)(struct wpa_ctrl *ctrl, int argc, char *argv[]);
2085 enum wpa_cli_cmd_flags flags;
2086 const char *usage;
2087 };
2088
2089 static struct wpa_cli_cmd wpa_cli_commands[] = {
2090 { "status", wpa_cli_cmd_status,
2091 cli_cmd_flag_none,
2092 "[verbose] = get current WPA/EAPOL/EAP status" },
2093 { "ifname", wpa_cli_cmd_ifname,
2094 cli_cmd_flag_none,
2095 "= get current interface name" },
2096 { "ping", wpa_cli_cmd_ping,
2097 cli_cmd_flag_none,
2098 "= pings wpa_supplicant" },
2099 { "relog", wpa_cli_cmd_relog,
2100 cli_cmd_flag_none,
2101 "= re-open log-file (allow rolling logs)" },
2102 { "note", wpa_cli_cmd_note,
2103 cli_cmd_flag_none,
2104 "<text> = add a note to wpa_supplicant debug log" },
2105 { "mib", wpa_cli_cmd_mib,
2106 cli_cmd_flag_none,
2107 "= get MIB variables (dot1x, dot11)" },
2108 { "help", wpa_cli_cmd_help,
2109 cli_cmd_flag_none,
2110 "= show this usage help" },
2111 { "interface", wpa_cli_cmd_interface,
2112 cli_cmd_flag_none,
2113 "[ifname] = show interfaces/select interface" },
2114 { "level", wpa_cli_cmd_level,
2115 cli_cmd_flag_none,
2116 "<debug level> = change debug level" },
2117 { "license", wpa_cli_cmd_license,
2118 cli_cmd_flag_none,
2119 "= show full wpa_cli license" },
2120 { "quit", wpa_cli_cmd_quit,
2121 cli_cmd_flag_none,
2122 "= exit wpa_cli" },
2123 { "set", wpa_cli_cmd_set,
2124 cli_cmd_flag_none,
2125 "= set variables (shows list of variables when run without "
2126 "arguments)" },
2127 { "get", wpa_cli_cmd_get,
2128 cli_cmd_flag_none,
2129 "<name> = get information" },
2130 { "logon", wpa_cli_cmd_logon,
2131 cli_cmd_flag_none,
2132 "= IEEE 802.1X EAPOL state machine logon" },
2133 { "logoff", wpa_cli_cmd_logoff,
2134 cli_cmd_flag_none,
2135 "= IEEE 802.1X EAPOL state machine logoff" },
2136 { "pmksa", wpa_cli_cmd_pmksa,
2137 cli_cmd_flag_none,
2138 "= show PMKSA cache" },
2139 { "reassociate", wpa_cli_cmd_reassociate,
2140 cli_cmd_flag_none,
2141 "= force reassociation" },
2142 { "preauthenticate", wpa_cli_cmd_preauthenticate,
2143 cli_cmd_flag_none,
2144 "<BSSID> = force preauthentication" },
2145 { "identity", wpa_cli_cmd_identity,
2146 cli_cmd_flag_none,
2147 "<network id> <identity> = configure identity for an SSID" },
2148 { "password", wpa_cli_cmd_password,
2149 cli_cmd_flag_sensitive,
2150 "<network id> <password> = configure password for an SSID" },
2151 { "new_password", wpa_cli_cmd_new_password,
2152 cli_cmd_flag_sensitive,
2153 "<network id> <password> = change password for an SSID" },
2154 { "pin", wpa_cli_cmd_pin,
2155 cli_cmd_flag_sensitive,
2156 "<network id> <pin> = configure pin for an SSID" },
2157 { "otp", wpa_cli_cmd_otp,
2158 cli_cmd_flag_sensitive,
2159 "<network id> <password> = configure one-time-password for an SSID"
2160 },
2161 { "passphrase", wpa_cli_cmd_passphrase,
2162 cli_cmd_flag_sensitive,
2163 "<network id> <passphrase> = configure private key passphrase\n"
2164 " for an SSID" },
2165 { "bssid", wpa_cli_cmd_bssid,
2166 cli_cmd_flag_none,
2167 "<network id> <BSSID> = set preferred BSSID for an SSID" },
2168 { "blacklist", wpa_cli_cmd_blacklist,
2169 cli_cmd_flag_none,
2170 "<BSSID> = add a BSSID to the blacklist\n"
2171 "blacklist clear = clear the blacklist\n"
2172 "blacklist = display the blacklist" },
2173 { "log_level", wpa_cli_cmd_log_level,
2174 cli_cmd_flag_none,
2175 "<level> [<timestamp>] = update the log level/timestamp\n"
2176 "log_level = display the current log level and log options" },
2177 { "list_networks", wpa_cli_cmd_list_networks,
2178 cli_cmd_flag_none,
2179 "= list configured networks" },
2180 { "select_network", wpa_cli_cmd_select_network,
2181 cli_cmd_flag_none,
2182 "<network id> = select a network (disable others)" },
2183 { "enable_network", wpa_cli_cmd_enable_network,
2184 cli_cmd_flag_none,
2185 "<network id> = enable a network" },
2186 { "disable_network", wpa_cli_cmd_disable_network,
2187 cli_cmd_flag_none,
2188 "<network id> = disable a network" },
2189 { "add_network", wpa_cli_cmd_add_network,
2190 cli_cmd_flag_none,
2191 "= add a network" },
2192 { "remove_network", wpa_cli_cmd_remove_network,
2193 cli_cmd_flag_none,
2194 "<network id> = remove a network" },
2195 { "set_network", wpa_cli_cmd_set_network,
2196 cli_cmd_flag_sensitive,
2197 "<network id> <variable> <value> = set network variables (shows\n"
2198 " list of variables when run without arguments)" },
2199 { "get_network", wpa_cli_cmd_get_network,
2200 cli_cmd_flag_none,
2201 "<network id> <variable> = get network variables" },
2202 { "list_creds", wpa_cli_cmd_list_creds,
2203 cli_cmd_flag_none,
2204 "= list configured credentials" },
2205 { "add_cred", wpa_cli_cmd_add_cred,
2206 cli_cmd_flag_none,
2207 "= add a credential" },
2208 { "remove_cred", wpa_cli_cmd_remove_cred,
2209 cli_cmd_flag_none,
2210 "<cred id> = remove a credential" },
2211 { "set_cred", wpa_cli_cmd_set_cred,
2212 cli_cmd_flag_sensitive,
2213 "<cred id> <variable> <value> = set credential variables" },
2214 { "save_config", wpa_cli_cmd_save_config,
2215 cli_cmd_flag_none,
2216 "= save the current configuration" },
2217 { "disconnect", wpa_cli_cmd_disconnect,
2218 cli_cmd_flag_none,
2219 "= disconnect and wait for reassociate/reconnect command before\n"
2220 " connecting" },
2221 { "reconnect", wpa_cli_cmd_reconnect,
2222 cli_cmd_flag_none,
2223 "= like reassociate, but only takes effect if already disconnected"
2224 },
2225 { "scan", wpa_cli_cmd_scan,
2226 cli_cmd_flag_none,
2227 "= request new BSS scan" },
2228 { "scan_results", wpa_cli_cmd_scan_results,
2229 cli_cmd_flag_none,
2230 "= get latest scan results" },
2231 { "bss", wpa_cli_cmd_bss,
2232 cli_cmd_flag_none,
2233 "<<idx> | <bssid>> = get detailed scan result info" },
2234 { "get_capability", wpa_cli_cmd_get_capability,
2235 cli_cmd_flag_none,
2236 "<eap/pairwise/group/key_mgmt/proto/auth_alg/channels> "
2237 "= get capabilies" },
2238 { "reconfigure", wpa_cli_cmd_reconfigure,
2239 cli_cmd_flag_none,
2240 "= force wpa_supplicant to re-read its configuration file" },
2241 { "terminate", wpa_cli_cmd_terminate,
2242 cli_cmd_flag_none,
2243 "= terminate wpa_supplicant" },
2244 { "interface_add", wpa_cli_cmd_interface_add,
2245 cli_cmd_flag_none,
2246 "<ifname> <confname> <driver> <ctrl_interface> <driver_param>\n"
2247 " <bridge_name> = adds new interface, all parameters but <ifname>\n"
2248 " are optional" },
2249 { "interface_remove", wpa_cli_cmd_interface_remove,
2250 cli_cmd_flag_none,
2251 "<ifname> = removes the interface" },
2252 { "interface_list", wpa_cli_cmd_interface_list,
2253 cli_cmd_flag_none,
2254 "= list available interfaces" },
2255 { "ap_scan", wpa_cli_cmd_ap_scan,
2256 cli_cmd_flag_none,
2257 "<value> = set ap_scan parameter" },
2258 { "scan_interval", wpa_cli_cmd_scan_interval,
2259 cli_cmd_flag_none,
2260 "<value> = set scan_interval parameter (in seconds)" },
2261 { "bss_expire_age", wpa_cli_cmd_bss_expire_age,
2262 cli_cmd_flag_none,
2263 "<value> = set BSS expiration age parameter" },
2264 { "bss_expire_count", wpa_cli_cmd_bss_expire_count,
2265 cli_cmd_flag_none,
2266 "<value> = set BSS expiration scan count parameter" },
2267 { "stkstart", wpa_cli_cmd_stkstart,
2268 cli_cmd_flag_none,
2269 "<addr> = request STK negotiation with <addr>" },
2270 { "ft_ds", wpa_cli_cmd_ft_ds,
2271 cli_cmd_flag_none,
2272 "<addr> = request over-the-DS FT with <addr>" },
2273 { "wps_pbc", wpa_cli_cmd_wps_pbc,
2274 cli_cmd_flag_none,
2275 "[BSSID] = start Wi-Fi Protected Setup: Push Button Configuration" },
2276 { "wps_pin", wpa_cli_cmd_wps_pin,
2277 cli_cmd_flag_sensitive,
2278 "<BSSID> [PIN] = start WPS PIN method (returns PIN, if not "
2279 "hardcoded)" },
2280 { "wps_check_pin", wpa_cli_cmd_wps_check_pin,
2281 cli_cmd_flag_sensitive,
2282 "<PIN> = verify PIN checksum" },
2283 { "wps_cancel", wpa_cli_cmd_wps_cancel, cli_cmd_flag_none,
2284 "Cancels the pending WPS operation" },
2285 #ifdef CONFIG_WPS_OOB
2286 { "wps_oob", wpa_cli_cmd_wps_oob,
2287 cli_cmd_flag_sensitive,
2288 "<DEV_TYPE> <PATH> <METHOD> [DEV_NAME] = start WPS OOB" },
2289 #endif /* CONFIG_WPS_OOB */
2290 #ifdef CONFIG_WPS_NFC
2291 { "wps_nfc", wpa_cli_cmd_wps_nfc,
2292 cli_cmd_flag_none,
2293 "[BSSID] = start Wi-Fi Protected Setup: NFC" },
2294 { "wps_nfc_token", wpa_cli_cmd_wps_nfc_token,
2295 cli_cmd_flag_none,
2296 "<WPS|NDEF> = create password token" },
2297 { "wps_nfc_tag_read", wpa_cli_cmd_wps_nfc_tag_read,
2298 cli_cmd_flag_sensitive,
2299 "<hexdump of payload> = report read NFC tag with WPS data" },
2300 #endif /* CONFIG_WPS_NFC */
2301 { "wps_reg", wpa_cli_cmd_wps_reg,
2302 cli_cmd_flag_sensitive,
2303 "<BSSID> <AP PIN> = start WPS Registrar to configure an AP" },
2304 { "wps_ap_pin", wpa_cli_cmd_wps_ap_pin,
2305 cli_cmd_flag_sensitive,
2306 "[params..] = enable/disable AP PIN" },
2307 { "wps_er_start", wpa_cli_cmd_wps_er_start,
2308 cli_cmd_flag_none,
2309 "[IP address] = start Wi-Fi Protected Setup External Registrar" },
2310 { "wps_er_stop", wpa_cli_cmd_wps_er_stop,
2311 cli_cmd_flag_none,
2312 "= stop Wi-Fi Protected Setup External Registrar" },
2313 { "wps_er_pin", wpa_cli_cmd_wps_er_pin,
2314 cli_cmd_flag_sensitive,
2315 "<UUID> <PIN> = add an Enrollee PIN to External Registrar" },
2316 { "wps_er_pbc", wpa_cli_cmd_wps_er_pbc,
2317 cli_cmd_flag_none,
2318 "<UUID> = accept an Enrollee PBC using External Registrar" },
2319 { "wps_er_learn", wpa_cli_cmd_wps_er_learn,
2320 cli_cmd_flag_sensitive,
2321 "<UUID> <PIN> = learn AP configuration" },
2322 { "wps_er_set_config", wpa_cli_cmd_wps_er_set_config,
2323 cli_cmd_flag_none,
2324 "<UUID> <network id> = set AP configuration for enrolling" },
2325 { "wps_er_config", wpa_cli_cmd_wps_er_config,
2326 cli_cmd_flag_sensitive,
2327 "<UUID> <PIN> <SSID> <auth> <encr> <key> = configure AP" },
2328 #ifdef CONFIG_WPS_NFC
2329 { "wps_er_nfc_config_token", wpa_cli_cmd_wps_er_nfc_config_token,
2330 cli_cmd_flag_none,
2331 "<WPS/NDEF> <UUID> = build NFC configuration token" },
2332 #endif /* CONFIG_WPS_NFC */
2333 { "ibss_rsn", wpa_cli_cmd_ibss_rsn,
2334 cli_cmd_flag_none,
2335 "<addr> = request RSN authentication with <addr> in IBSS" },
2336 #ifdef CONFIG_AP
2337 { "sta", wpa_cli_cmd_sta,
2338 cli_cmd_flag_none,
2339 "<addr> = get information about an associated station (AP)" },
2340 { "all_sta", wpa_cli_cmd_all_sta,
2341 cli_cmd_flag_none,
2342 "= get information about all associated stations (AP)" },
2343 { "deauthenticate", wpa_cli_cmd_deauthenticate,
2344 cli_cmd_flag_none,
2345 "<addr> = deauthenticate a station" },
2346 { "disassociate", wpa_cli_cmd_disassociate,
2347 cli_cmd_flag_none,
2348 "<addr> = disassociate a station" },
2349 #endif /* CONFIG_AP */
2350 { "suspend", wpa_cli_cmd_suspend, cli_cmd_flag_none,
2351 "= notification of suspend/hibernate" },
2352 { "resume", wpa_cli_cmd_resume, cli_cmd_flag_none,
2353 "= notification of resume/thaw" },
2354 { "drop_sa", wpa_cli_cmd_drop_sa, cli_cmd_flag_none,
2355 "= drop SA without deauth/disassoc (test command)" },
2356 { "roam", wpa_cli_cmd_roam,
2357 cli_cmd_flag_none,
2358 "<addr> = roam to the specified BSS" },
2359 #ifdef CONFIG_P2P
2360 { "p2p_find", wpa_cli_cmd_p2p_find, cli_cmd_flag_none,
2361 "[timeout] [type=*] = find P2P Devices for up-to timeout seconds" },
2362 { "p2p_stop_find", wpa_cli_cmd_p2p_stop_find, cli_cmd_flag_none,
2363 "= stop P2P Devices search" },
2364 { "p2p_connect", wpa_cli_cmd_p2p_connect, cli_cmd_flag_none,
2365 "<addr> <\"pbc\"|PIN> [ht40] = connect to a P2P Device" },
2366 { "p2p_listen", wpa_cli_cmd_p2p_listen, cli_cmd_flag_none,
2367 "[timeout] = listen for P2P Devices for up-to timeout seconds" },
2368 { "p2p_group_remove", wpa_cli_cmd_p2p_group_remove, cli_cmd_flag_none,
2369 "<ifname> = remove P2P group interface (terminate group if GO)" },
2370 { "p2p_group_add", wpa_cli_cmd_p2p_group_add, cli_cmd_flag_none,
2371 "[ht40] = add a new P2P group (local end as GO)" },
2372 { "p2p_prov_disc", wpa_cli_cmd_p2p_prov_disc, cli_cmd_flag_none,
2373 "<addr> <method> = request provisioning discovery" },
2374 { "p2p_get_passphrase", wpa_cli_cmd_p2p_get_passphrase,
2375 cli_cmd_flag_none,
2376 "= get the passphrase for a group (GO only)" },
2377 { "p2p_serv_disc_req", wpa_cli_cmd_p2p_serv_disc_req,
2378 cli_cmd_flag_none,
2379 "<addr> <TLVs> = schedule service discovery request" },
2380 { "p2p_serv_disc_cancel_req", wpa_cli_cmd_p2p_serv_disc_cancel_req,
2381 cli_cmd_flag_none,
2382 "<id> = cancel pending service discovery request" },
2383 { "p2p_serv_disc_resp", wpa_cli_cmd_p2p_serv_disc_resp,
2384 cli_cmd_flag_none,
2385 "<freq> <addr> <dialog token> <TLVs> = service discovery response" },
2386 { "p2p_service_update", wpa_cli_cmd_p2p_service_update,
2387 cli_cmd_flag_none,
2388 "= indicate change in local services" },
2389 { "p2p_serv_disc_external", wpa_cli_cmd_p2p_serv_disc_external,
2390 cli_cmd_flag_none,
2391 "<external> = set external processing of service discovery" },
2392 { "p2p_service_flush", wpa_cli_cmd_p2p_service_flush,
2393 cli_cmd_flag_none,
2394 "= remove all stored service entries" },
2395 { "p2p_service_add", wpa_cli_cmd_p2p_service_add,
2396 cli_cmd_flag_none,
2397 "<bonjour|upnp> <query|version> <response|service> = add a local "
2398 "service" },
2399 { "p2p_service_del", wpa_cli_cmd_p2p_service_del,
2400 cli_cmd_flag_none,
2401 "<bonjour|upnp> <query|version> [|service] = remove a local "
2402 "service" },
2403 { "p2p_reject", wpa_cli_cmd_p2p_reject,
2404 cli_cmd_flag_none,
2405 "<addr> = reject connection attempts from a specific peer" },
2406 { "p2p_invite", wpa_cli_cmd_p2p_invite,
2407 cli_cmd_flag_none,
2408 "<cmd> [peer=addr] = invite peer" },
2409 { "p2p_peers", wpa_cli_cmd_p2p_peers, cli_cmd_flag_none,
2410 "[discovered] = list known (optionally, only fully discovered) P2P "
2411 "peers" },
2412 { "p2p_peer", wpa_cli_cmd_p2p_peer, cli_cmd_flag_none,
2413 "<address> = show information about known P2P peer" },
2414 { "p2p_set", wpa_cli_cmd_p2p_set, cli_cmd_flag_none,
2415 "<field> <value> = set a P2P parameter" },
2416 { "p2p_flush", wpa_cli_cmd_p2p_flush, cli_cmd_flag_none,
2417 "= flush P2P state" },
2418 { "p2p_cancel", wpa_cli_cmd_p2p_cancel, cli_cmd_flag_none,
2419 "= cancel P2P group formation" },
2420 { "p2p_unauthorize", wpa_cli_cmd_p2p_unauthorize, cli_cmd_flag_none,
2421 "<address> = unauthorize a peer" },
2422 { "p2p_presence_req", wpa_cli_cmd_p2p_presence_req, cli_cmd_flag_none,
2423 "[<duration> <interval>] [<duration> <interval>] = request GO "
2424 "presence" },
2425 { "p2p_ext_listen", wpa_cli_cmd_p2p_ext_listen, cli_cmd_flag_none,
2426 "[<period> <interval>] = set extended listen timing" },
2427 #endif /* CONFIG_P2P */
2428
2429 #ifdef CONFIG_INTERWORKING
2430 { "fetch_anqp", wpa_cli_cmd_fetch_anqp, cli_cmd_flag_none,
2431 "= fetch ANQP information for all APs" },
2432 { "stop_fetch_anqp", wpa_cli_cmd_stop_fetch_anqp, cli_cmd_flag_none,
2433 "= stop fetch_anqp operation" },
2434 { "interworking_select", wpa_cli_cmd_interworking_select,
2435 cli_cmd_flag_none,
2436 "[auto] = perform Interworking network selection" },
2437 { "interworking_connect", wpa_cli_cmd_interworking_connect,
2438 cli_cmd_flag_none,
2439 "<BSSID> = connect using Interworking credentials" },
2440 { "anqp_get", wpa_cli_cmd_anqp_get, cli_cmd_flag_none,
2441 "<addr> <info id>[,<info id>]... = request ANQP information" },
2442 #endif /* CONFIG_INTERWORKING */
2443 #ifdef CONFIG_HS20
2444 { "hs20_anqp_get", wpa_cli_cmd_hs20_anqp_get, cli_cmd_flag_none,
2445 "<addr> <subtype>[,<subtype>]... = request HS 2.0 ANQP information"
2446 },
2447 { "nai_home_realm_list", wpa_cli_cmd_get_nai_home_realm_list,
2448 cli_cmd_flag_none,
2449 "<addr> <home realm> = get HS20 nai home realm list" },
2450 #endif /* CONFIG_HS20 */
2451 { "sta_autoconnect", wpa_cli_cmd_sta_autoconnect, cli_cmd_flag_none,
2452 "<0/1> = disable/enable automatic reconnection" },
2453 { "tdls_discover", wpa_cli_cmd_tdls_discover,
2454 cli_cmd_flag_none,
2455 "<addr> = request TDLS discovery with <addr>" },
2456 { "tdls_setup", wpa_cli_cmd_tdls_setup,
2457 cli_cmd_flag_none,
2458 "<addr> = request TDLS setup with <addr>" },
2459 { "tdls_teardown", wpa_cli_cmd_tdls_teardown,
2460 cli_cmd_flag_none,
2461 "<addr> = tear down TDLS with <addr>" },
2462 { "signal_poll", wpa_cli_cmd_signal_poll,
2463 cli_cmd_flag_none,
2464 "= get signal parameters" },
2465 { "reauthenticate", wpa_cli_cmd_reauthenticate, cli_cmd_flag_none,
2466 "= trigger IEEE 802.1X/EAPOL reauthentication" },
2467 #ifdef CONFIG_AUTOSCAN
2468 { "autoscan", wpa_cli_cmd_autoscan, cli_cmd_flag_none,
2469 "[params] = Set or unset (if none) autoscan parameters" },
2470 #endif /* CONFIG_AUTOSCAN */
2471 { NULL, NULL, cli_cmd_flag_none, NULL }
2472 };
2473
2474
2475 /*
2476 * Prints command usage, lines are padded with the specified string.
2477 */
2478 static void print_cmd_help(struct wpa_cli_cmd *cmd, const char *pad)
2479 {
2480 char c;
2481 size_t n;
2482
2483 printf("%s%s ", pad, cmd->cmd);
2484 for (n = 0; (c = cmd->usage[n]); n++) {
2485 printf("%c", c);
2486 if (c == '\n')
2487 printf("%s", pad);
2488 }
2489 printf("\n");
2490 }
2491
2492
2493 static void print_help(void)
2494 {
2495 int n;
2496 printf("commands:\n");
2497 for (n = 0; wpa_cli_commands[n].cmd; n++)
2498 print_cmd_help(&wpa_cli_commands[n], " ");
2499 }
2500
2501
2502 static int wpa_cli_edit_filter_history_cb(void *ctx, const char *cmd)
2503 {
2504 const char *c, *delim;
2505 int n;
2506 size_t len;
2507
2508 delim = os_strchr(cmd, ' ');
2509 if (delim)
2510 len = delim - cmd;
2511 else
2512 len = os_strlen(cmd);
2513
2514 for (n = 0; (c = wpa_cli_commands[n].cmd); n++) {
2515 if (os_strncasecmp(cmd, c, len) == 0 && len == os_strlen(c))
2516 return (wpa_cli_commands[n].flags &
2517 cli_cmd_flag_sensitive);
2518 }
2519 return 0;
2520 }
2521
2522
2523 static char ** wpa_list_cmd_list(void)
2524 {
2525 char **res;
2526 int i, count;
2527
2528 count = sizeof(wpa_cli_commands) / sizeof(wpa_cli_commands[0]);
2529 res = os_calloc(count, sizeof(char *));
2530 if (res == NULL)
2531 return NULL;
2532
2533 for (i = 0; wpa_cli_commands[i].cmd; i++) {
2534 res[i] = os_strdup(wpa_cli_commands[i].cmd);
2535 if (res[i] == NULL)
2536 break;
2537 }
2538
2539 return res;
2540 }
2541
2542
2543 static char ** wpa_cli_cmd_completion(const char *cmd, const char *str,
2544 int pos)
2545 {
2546 int i;
2547
2548 if (os_strcasecmp(cmd, "bss") == 0)
2549 return wpa_cli_complete_bss(str, pos);
2550 #ifdef CONFIG_P2P
2551 if (os_strcasecmp(cmd, "p2p_connect") == 0)
2552 return wpa_cli_complete_p2p_connect(str, pos);
2553 if (os_strcasecmp(cmd, "p2p_peer") == 0)
2554 return wpa_cli_complete_p2p_peer(str, pos);
2555 if (os_strcasecmp(cmd, "p2p_group_remove") == 0)
2556 return wpa_cli_complete_p2p_group_remove(str, pos);
2557 #endif /* CONFIG_P2P */
2558
2559 for (i = 0; wpa_cli_commands[i].cmd; i++) {
2560 if (os_strcasecmp(wpa_cli_commands[i].cmd, cmd) == 0) {
2561 edit_clear_line();
2562 printf("\r%s\n", wpa_cli_commands[i].usage);
2563 edit_redraw();
2564 break;
2565 }
2566 }
2567
2568 return NULL;
2569 }
2570
2571
2572 static char ** wpa_cli_edit_completion_cb(void *ctx, const char *str, int pos)
2573 {
2574 char **res;
2575 const char *end;
2576 char *cmd;
2577
2578 end = os_strchr(str, ' ');
2579 if (end == NULL || str + pos < end)
2580 return wpa_list_cmd_list();
2581
2582 cmd = os_malloc(pos + 1);
2583 if (cmd == NULL)
2584 return NULL;
2585 os_memcpy(cmd, str, pos);
2586 cmd[end - str] = '\0';
2587 res = wpa_cli_cmd_completion(cmd, str, pos);
2588 os_free(cmd);
2589 return res;
2590 }
2591
2592
2593 static int wpa_request(struct wpa_ctrl *ctrl, int argc, char *argv[])
2594 {
2595 struct wpa_cli_cmd *cmd, *match = NULL;
2596 int count;
2597 int ret = 0;
2598
2599 count = 0;
2600 cmd = wpa_cli_commands;
2601 while (cmd->cmd) {
2602 if (os_strncasecmp(cmd->cmd, argv[0], os_strlen(argv[0])) == 0)
2603 {
2604 match = cmd;
2605 if (os_strcasecmp(cmd->cmd, argv[0]) == 0) {
2606 /* we have an exact match */
2607 count = 1;
2608 break;
2609 }
2610 count++;
2611 }
2612 cmd++;
2613 }
2614
2615 if (count > 1) {
2616 printf("Ambiguous command '%s'; possible commands:", argv[0]);
2617 cmd = wpa_cli_commands;
2618 while (cmd->cmd) {
2619 if (os_strncasecmp(cmd->cmd, argv[0],
2620 os_strlen(argv[0])) == 0) {
2621 printf(" %s", cmd->cmd);
2622 }
2623 cmd++;
2624 }
2625 printf("\n");
2626 ret = 1;
2627 } else if (count == 0) {
2628 printf("Unknown command '%s'\n", argv[0]);
2629 ret = 1;
2630 } else {
2631 ret = match->handler(ctrl, argc - 1, &argv[1]);
2632 }
2633
2634 return ret;
2635 }
2636
2637
2638 static int str_match(const char *a, const char *b)
2639 {
2640 return os_strncmp(a, b, os_strlen(b)) == 0;
2641 }
2642
2643
2644 static int wpa_cli_exec(const char *program, const char *arg1,
2645 const char *arg2)
2646 {
2647 char *cmd;
2648 size_t len;
2649 int res;
2650 int ret = 0;
2651
2652 len = os_strlen(program) + os_strlen(arg1) + os_strlen(arg2) + 3;
2653 cmd = os_malloc(len);
2654 if (cmd == NULL)
2655 return -1;
2656 res = os_snprintf(cmd, len, "%s %s %s", program, arg1, arg2);
2657 if (res < 0 || (size_t) res >= len) {
2658 os_free(cmd);
2659 return -1;
2660 }
2661 cmd[len - 1] = '\0';
2662 #ifndef _WIN32_WCE
2663 if (system(cmd) < 0)
2664 ret = -1;
2665 #endif /* _WIN32_WCE */
2666 os_free(cmd);
2667
2668 return ret;
2669 }
2670
2671
2672 static void wpa_cli_action_process(const char *msg)
2673 {
2674 const char *pos;
2675 char *copy = NULL, *id, *pos2;
2676
2677 pos = msg;
2678 if (*pos == '<') {
2679 /* skip priority */
2680 pos = os_strchr(pos, '>');
2681 if (pos)
2682 pos++;
2683 else
2684 pos = msg;
2685 }
2686
2687 if (str_match(pos, WPA_EVENT_CONNECTED)) {
2688 int new_id = -1;
2689 os_unsetenv("WPA_ID");
2690 os_unsetenv("WPA_ID_STR");
2691 os_unsetenv("WPA_CTRL_DIR");
2692
2693 pos = os_strstr(pos, "[id=");
2694 if (pos)
2695 copy = os_strdup(pos + 4);
2696
2697 if (copy) {
2698 pos2 = id = copy;
2699 while (*pos2 && *pos2 != ' ')
2700 pos2++;
2701 *pos2++ = '\0';
2702 new_id = atoi(id);
2703 os_setenv("WPA_ID", id, 1);
2704 while (*pos2 && *pos2 != '=')
2705 pos2++;
2706 if (*pos2 == '=')
2707 pos2++;
2708 id = pos2;
2709 while (*pos2 && *pos2 != ']')
2710 pos2++;
2711 *pos2 = '\0';
2712 os_setenv("WPA_ID_STR", id, 1);
2713 os_free(copy);
2714 }
2715
2716 os_setenv("WPA_CTRL_DIR", ctrl_iface_dir, 1);
2717
2718 if (!wpa_cli_connected || new_id != wpa_cli_last_id) {
2719 wpa_cli_connected = 1;
2720 wpa_cli_last_id = new_id;
2721 wpa_cli_exec(action_file, ctrl_ifname, "CONNECTED");
2722 }
2723 } else if (str_match(pos, WPA_EVENT_DISCONNECTED)) {
2724 if (wpa_cli_connected) {
2725 wpa_cli_connected = 0;
2726 wpa_cli_exec(action_file, ctrl_ifname, "DISCONNECTED");
2727 }
2728 } else if (str_match(pos, P2P_EVENT_GROUP_STARTED)) {
2729 wpa_cli_exec(action_file, ctrl_ifname, pos);
2730 } else if (str_match(pos, P2P_EVENT_GROUP_REMOVED)) {
2731 wpa_cli_exec(action_file, ctrl_ifname, pos);
2732 } else if (str_match(pos, P2P_EVENT_CROSS_CONNECT_ENABLE)) {
2733 wpa_cli_exec(action_file, ctrl_ifname, pos);
2734 } else if (str_match(pos, P2P_EVENT_CROSS_CONNECT_DISABLE)) {
2735 wpa_cli_exec(action_file, ctrl_ifname, pos);
2736 } else if (str_match(pos, P2P_EVENT_GO_NEG_FAILURE)) {
2737 wpa_cli_exec(action_file, ctrl_ifname, pos);
2738 } else if (str_match(pos, WPS_EVENT_SUCCESS)) {
2739 wpa_cli_exec(action_file, ctrl_ifname, pos);
2740 } else if (str_match(pos, WPS_EVENT_FAIL)) {
2741 wpa_cli_exec(action_file, ctrl_ifname, pos);
2742 } else if (str_match(pos, AP_STA_CONNECTED)) {
2743 wpa_cli_exec(action_file, ctrl_ifname, pos);
2744 } else if (str_match(pos, AP_STA_DISCONNECTED)) {
2745 wpa_cli_exec(action_file, ctrl_ifname, pos);
2746 } else if (str_match(pos, WPA_EVENT_TERMINATING)) {
2747 printf("wpa_supplicant is terminating - stop monitoring\n");
2748 wpa_cli_quit = 1;
2749 }
2750 }
2751
2752
2753 #ifndef CONFIG_ANSI_C_EXTRA
2754 static void wpa_cli_action_cb(char *msg, size_t len)
2755 {
2756 wpa_cli_action_process(msg);
2757 }
2758 #endif /* CONFIG_ANSI_C_EXTRA */
2759
2760
2761 static void wpa_cli_reconnect(void)
2762 {
2763 wpa_cli_close_connection();
2764 if (wpa_cli_open_connection(ctrl_ifname, 1) < 0)
2765 return;
2766
2767 if (interactive) {
2768 edit_clear_line();
2769 printf("\rConnection to wpa_supplicant re-established\n");
2770 edit_redraw();
2771 }
2772 }
2773
2774
2775 static void cli_event(const char *str)
2776 {
2777 const char *start, *s;
2778
2779 start = os_strchr(str, '>');
2780 if (start == NULL)
2781 return;
2782
2783 start++;
2784
2785 if (str_starts(start, WPA_EVENT_BSS_ADDED)) {
2786 s = os_strchr(start, ' ');
2787 if (s == NULL)
2788 return;
2789 s = os_strchr(s + 1, ' ');
2790 if (s == NULL)
2791 return;
2792 cli_txt_list_add(&bsses, s + 1);
2793 return;
2794 }
2795
2796 if (str_starts(start, WPA_EVENT_BSS_REMOVED)) {
2797 s = os_strchr(start, ' ');
2798 if (s == NULL)
2799 return;
2800 s = os_strchr(s + 1, ' ');
2801 if (s == NULL)
2802 return;
2803 cli_txt_list_del_addr(&bsses, s + 1);
2804 return;
2805 }
2806
2807 #ifdef CONFIG_P2P
2808 if (str_starts(start, P2P_EVENT_DEVICE_FOUND)) {
2809 s = os_strstr(start, " p2p_dev_addr=");
2810 if (s == NULL)
2811 return;
2812 cli_txt_list_add_addr(&p2p_peers, s + 14);
2813 return;
2814 }
2815
2816 if (str_starts(start, P2P_EVENT_DEVICE_LOST)) {
2817 s = os_strstr(start, " p2p_dev_addr=");
2818 if (s == NULL)
2819 return;
2820 cli_txt_list_del_addr(&p2p_peers, s + 14);
2821 return;
2822 }
2823
2824 if (str_starts(start, P2P_EVENT_GROUP_STARTED)) {
2825 s = os_strchr(start, ' ');
2826 if (s == NULL)
2827 return;
2828 cli_txt_list_add_word(&p2p_groups, s + 1);
2829 return;
2830 }
2831
2832 if (str_starts(start, P2P_EVENT_GROUP_REMOVED)) {
2833 s = os_strchr(start, ' ');
2834 if (s == NULL)
2835 return;
2836 cli_txt_list_del_word(&p2p_groups, s + 1);
2837 return;
2838 }
2839 #endif /* CONFIG_P2P */
2840 }
2841
2842
2843 static int check_terminating(const char *msg)
2844 {
2845 const char *pos = msg;
2846
2847 if (*pos == '<') {
2848 /* skip priority */
2849 pos = os_strchr(pos, '>');
2850 if (pos)
2851 pos++;
2852 else
2853 pos = msg;
2854 }
2855
2856 if (str_match(pos, WPA_EVENT_TERMINATING) && ctrl_conn) {
2857 edit_clear_line();
2858 printf("\rConnection to wpa_supplicant lost - trying to "
2859 "reconnect\n");
2860 edit_redraw();
2861 wpa_cli_attached = 0;
2862 wpa_cli_close_connection();
2863 return 1;
2864 }
2865
2866 return 0;
2867 }
2868
2869
2870 static void wpa_cli_recv_pending(struct wpa_ctrl *ctrl, int action_monitor)
2871 {
2872 if (ctrl_conn == NULL) {
2873 wpa_cli_reconnect();
2874 return;
2875 }
2876 while (wpa_ctrl_pending(ctrl) > 0) {
2877 char buf[256];
2878 size_t len = sizeof(buf) - 1;
2879 if (wpa_ctrl_recv(ctrl, buf, &len) == 0) {
2880 buf[len] = '\0';
2881 if (action_monitor)
2882 wpa_cli_action_process(buf);
2883 else {
2884 cli_event(buf);
2885 if (wpa_cli_show_event(buf)) {
2886 edit_clear_line();
2887 printf("\r%s\n", buf);
2888 edit_redraw();
2889 }
2890
2891 if (interactive && check_terminating(buf) > 0)
2892 return;
2893 }
2894 } else {
2895 printf("Could not read pending message.\n");
2896 break;
2897 }
2898 }
2899
2900 if (wpa_ctrl_pending(ctrl) < 0) {
2901 printf("Connection to wpa_supplicant lost - trying to "
2902 "reconnect\n");
2903 wpa_cli_reconnect();
2904 }
2905 }
2906
2907 #define max_args 10
2908
2909 static int tokenize_cmd(char *cmd, char *argv[])
2910 {
2911 char *pos;
2912 int argc = 0;
2913
2914 pos = cmd;
2915 for (;;) {
2916 while (*pos == ' ')
2917 pos++;
2918 if (*pos == '\0')
2919 break;
2920 argv[argc] = pos;
2921 argc++;
2922 if (argc == max_args)
2923 break;
2924 if (*pos == '"') {
2925 char *pos2 = os_strrchr(pos, '"');
2926 if (pos2)
2927 pos = pos2 + 1;
2928 }
2929 while (*pos != '\0' && *pos != ' ')
2930 pos++;
2931 if (*pos == ' ')
2932 *pos++ = '\0';
2933 }
2934
2935 return argc;
2936 }
2937
2938
2939 static void wpa_cli_ping(void *eloop_ctx, void *timeout_ctx)
2940 {
2941 if (ctrl_conn && _wpa_ctrl_command(ctrl_conn, "PING", 0)) {
2942 printf("Connection to wpa_supplicant lost - trying to "
2943 "reconnect\n");
2944 wpa_cli_close_connection();
2945 }
2946 if (!ctrl_conn)
2947 wpa_cli_reconnect();
2948 eloop_register_timeout(ping_interval, 0, wpa_cli_ping, NULL, NULL);
2949 }
2950
2951
2952 static void wpa_cli_mon_receive(int sock, void *eloop_ctx, void *sock_ctx)
2953 {
2954 wpa_cli_recv_pending(mon_conn, 0);
2955 }
2956
2957
2958 static void wpa_cli_edit_cmd_cb(void *ctx, char *cmd)
2959 {
2960 char *argv[max_args];
2961 int argc;
2962 argc = tokenize_cmd(cmd, argv);
2963 if (argc)
2964 wpa_request(ctrl_conn, argc, argv);
2965 }
2966
2967
2968 static void wpa_cli_edit_eof_cb(void *ctx)
2969 {
2970 eloop_terminate();
2971 }
2972
2973
2974 static int warning_displayed = 0;
2975 static char *hfile = NULL;
2976 static int edit_started = 0;
2977
2978 static void start_edit(void)
2979 {
2980 char *home;
2981 char *ps = NULL;
2982
2983 #ifdef CONFIG_CTRL_IFACE_UDP_REMOTE
2984 ps = wpa_ctrl_get_remote_ifname(ctrl_conn);
2985 #endif /* CONFIG_CTRL_IFACE_UDP_REMOTE */
2986
2987 home = getenv("HOME");
2988 if (home) {
2989 const char *fname = ".wpa_cli_history";
2990 int hfile_len = os_strlen(home) + 1 + os_strlen(fname) + 1;
2991 hfile = os_malloc(hfile_len);
2992 if (hfile)
2993 os_snprintf(hfile, hfile_len, "%s/%s", home, fname);
2994 }
2995
2996 if (edit_init(wpa_cli_edit_cmd_cb, wpa_cli_edit_eof_cb,
2997 wpa_cli_edit_completion_cb, NULL, hfile, ps) < 0) {
2998 eloop_terminate();
2999 return;
3000 }
3001
3002 edit_started = 1;
3003 eloop_register_timeout(ping_interval, 0, wpa_cli_ping, NULL, NULL);
3004 }
3005
3006
3007 static void try_connection(void *eloop_ctx, void *timeout_ctx)
3008 {
3009 if (ctrl_ifname == NULL)
3010 ctrl_ifname = wpa_cli_get_default_ifname();
3011
3012 if (!wpa_cli_open_connection(ctrl_ifname, 1) == 0) {
3013 if (!warning_displayed) {
3014 printf("Could not connect to wpa_supplicant: "
3015 "%s - re-trying\n", ctrl_ifname);
3016 warning_displayed = 1;
3017 }
3018 eloop_register_timeout(1, 0, try_connection, NULL, NULL);
3019 return;
3020 }
3021
3022 if (warning_displayed)
3023 printf("Connection established.\n");
3024
3025 start_edit();
3026 }
3027
3028
3029 static void wpa_cli_interactive(void)
3030 {
3031 printf("\nInteractive mode\n\n");
3032
3033 eloop_register_timeout(0, 0, try_connection, NULL, NULL);
3034 eloop_run();
3035 eloop_cancel_timeout(try_connection, NULL, NULL);
3036
3037 cli_txt_list_flush(&p2p_peers);
3038 cli_txt_list_flush(&p2p_groups);
3039 cli_txt_list_flush(&bsses);
3040 if (edit_started)
3041 edit_deinit(hfile, wpa_cli_edit_filter_history_cb);
3042 os_free(hfile);
3043 eloop_cancel_timeout(wpa_cli_ping, NULL, NULL);
3044 wpa_cli_close_connection();
3045 }
3046
3047
3048 static void wpa_cli_action(struct wpa_ctrl *ctrl)
3049 {
3050 #ifdef CONFIG_ANSI_C_EXTRA
3051 /* TODO: ANSI C version(?) */
3052 printf("Action processing not supported in ANSI C build.\n");
3053 #else /* CONFIG_ANSI_C_EXTRA */
3054 fd_set rfds;
3055 int fd, res;
3056 struct timeval tv;
3057 char buf[256]; /* note: large enough to fit in unsolicited messages */
3058 size_t len;
3059
3060 fd = wpa_ctrl_get_fd(ctrl);
3061
3062 while (!wpa_cli_quit) {
3063 FD_ZERO(&rfds);
3064 FD_SET(fd, &rfds);
3065 tv.tv_sec = ping_interval;
3066 tv.tv_usec = 0;
3067 res = select(fd + 1, &rfds, NULL, NULL, &tv);
3068 if (res < 0 && errno != EINTR) {
3069 perror("select");
3070 break;
3071 }
3072
3073 if (FD_ISSET(fd, &rfds))
3074 wpa_cli_recv_pending(ctrl, 1);
3075 else {
3076 /* verify that connection is still working */
3077 len = sizeof(buf) - 1;
3078 if (wpa_ctrl_request(ctrl, "PING", 4, buf, &len,
3079 wpa_cli_action_cb) < 0 ||
3080 len < 4 || os_memcmp(buf, "PONG", 4) != 0) {
3081 printf("wpa_supplicant did not reply to PING "
3082 "command - exiting\n");
3083 break;
3084 }
3085 }
3086 }
3087 #endif /* CONFIG_ANSI_C_EXTRA */
3088 }
3089
3090
3091 static void wpa_cli_cleanup(void)
3092 {
3093 wpa_cli_close_connection();
3094 if (pid_file)
3095 os_daemonize_terminate(pid_file);
3096
3097 os_program_deinit();
3098 }
3099
3100
3101 static void wpa_cli_terminate(int sig, void *ctx)
3102 {
3103 eloop_terminate();
3104 }
3105
3106
3107 static char * wpa_cli_get_default_ifname(void)
3108 {
3109 char *ifname = NULL;
3110
3111 #ifdef CONFIG_CTRL_IFACE_UNIX
3112 struct dirent *dent;
3113 DIR *dir = opendir(ctrl_iface_dir);
3114 if (!dir) {
3115 #ifdef ANDROID
3116 char ifprop[PROPERTY_VALUE_MAX];
3117 if (property_get("wifi.interface", ifprop, NULL) != 0) {
3118 ifname = os_strdup(ifprop);
3119 printf("Using interface '%s'\n", ifname);
3120 return ifname;
3121 }
3122 #endif /* ANDROID */
3123 return NULL;
3124 }
3125 while ((dent = readdir(dir))) {
3126 #ifdef _DIRENT_HAVE_D_TYPE
3127 /*
3128 * Skip the file if it is not a socket. Also accept
3129 * DT_UNKNOWN (0) in case the C library or underlying
3130 * file system does not support d_type.
3131 */
3132 if (dent->d_type != DT_SOCK && dent->d_type != DT_UNKNOWN)
3133 continue;
3134 #endif /* _DIRENT_HAVE_D_TYPE */
3135 if (os_strcmp(dent->d_name, ".") == 0 ||
3136 os_strcmp(dent->d_name, "..") == 0)
3137 continue;
3138 printf("Selected interface '%s'\n", dent->d_name);
3139 ifname = os_strdup(dent->d_name);
3140 break;
3141 }
3142 closedir(dir);
3143 #endif /* CONFIG_CTRL_IFACE_UNIX */
3144
3145 #ifdef CONFIG_CTRL_IFACE_NAMED_PIPE
3146 char buf[2048], *pos;
3147 size_t len;
3148 struct wpa_ctrl *ctrl;
3149 int ret;
3150
3151 ctrl = wpa_ctrl_open(NULL);
3152 if (ctrl == NULL)
3153 return NULL;
3154
3155 len = sizeof(buf) - 1;
3156 ret = wpa_ctrl_request(ctrl, "INTERFACES", 10, buf, &len, NULL);
3157 if (ret >= 0) {
3158 buf[len] = '\0';
3159 pos = os_strchr(buf, '\n');
3160 if (pos)
3161 *pos = '\0';
3162 ifname = os_strdup(buf);
3163 }
3164 wpa_ctrl_close(ctrl);
3165 #endif /* CONFIG_CTRL_IFACE_NAMED_PIPE */
3166
3167 return ifname;
3168 }
3169
3170
3171 int main(int argc, char *argv[])
3172 {
3173 int c;
3174 int daemonize = 0;
3175 int ret = 0;
3176 const char *global = NULL;
3177
3178 if (os_program_init())
3179 return -1;
3180
3181 for (;;) {
3182 c = getopt(argc, argv, "a:Bg:G:hi:p:P:v");
3183 if (c < 0)
3184 break;
3185 switch (c) {
3186 case 'a':
3187 action_file = optarg;
3188 break;
3189 case 'B':
3190 daemonize = 1;
3191 break;
3192 case 'g':
3193 global = optarg;
3194 break;
3195 case 'G':
3196 ping_interval = atoi(optarg);
3197 break;
3198 case 'h':
3199 usage();
3200 return 0;
3201 case 'v':
3202 printf("%s\n", wpa_cli_version);
3203 return 0;
3204 case 'i':
3205 os_free(ctrl_ifname);
3206 ctrl_ifname = os_strdup(optarg);
3207 break;
3208 case 'p':
3209 ctrl_iface_dir = optarg;
3210 break;
3211 case 'P':
3212 pid_file = optarg;
3213 break;
3214 default:
3215 usage();
3216 return -1;
3217 }
3218 }
3219
3220 interactive = (argc == optind) && (action_file == NULL);
3221
3222 if (interactive)
3223 printf("%s\n\n%s\n\n", wpa_cli_version, wpa_cli_license);
3224
3225 if (eloop_init())
3226 return -1;
3227
3228 if (global) {
3229 #ifdef CONFIG_CTRL_IFACE_NAMED_PIPE
3230 ctrl_conn = wpa_ctrl_open(NULL);
3231 #else /* CONFIG_CTRL_IFACE_NAMED_PIPE */
3232 ctrl_conn = wpa_ctrl_open(global);
3233 #endif /* CONFIG_CTRL_IFACE_NAMED_PIPE */
3234 if (ctrl_conn == NULL) {
3235 fprintf(stderr, "Failed to connect to wpa_supplicant "
3236 "global interface: %s error: %s\n",
3237 global, strerror(errno));
3238 return -1;
3239 }
3240 }
3241
3242 eloop_register_signal_terminate(wpa_cli_terminate, NULL);
3243
3244 if (ctrl_ifname == NULL)
3245 ctrl_ifname = wpa_cli_get_default_ifname();
3246
3247 if (interactive) {
3248 wpa_cli_interactive();
3249 } else {
3250 if (!global &&
3251 wpa_cli_open_connection(ctrl_ifname, 0) < 0) {
3252 fprintf(stderr, "Failed to connect to non-global "
3253 "ctrl_ifname: %s error: %s\n",
3254 ctrl_ifname, strerror(errno));
3255 return -1;
3256 }
3257
3258 if (action_file) {
3259 if (wpa_ctrl_attach(ctrl_conn) == 0) {
3260 wpa_cli_attached = 1;
3261 } else {
3262 printf("Warning: Failed to attach to "
3263 "wpa_supplicant.\n");
3264 return -1;
3265 }
3266 }
3267
3268 if (daemonize && os_daemonize(pid_file))
3269 return -1;
3270
3271 if (action_file)
3272 wpa_cli_action(ctrl_conn);
3273 else
3274 ret = wpa_request(ctrl_conn, argc - optind,
3275 &argv[optind]);
3276 }
3277
3278 os_free(ctrl_ifname);
3279 eloop_destroy();
3280 wpa_cli_cleanup();
3281
3282 return ret;
3283 }
3284
3285 #else /* CONFIG_CTRL_IFACE */
3286 int main(int argc, char *argv[])
3287 {
3288 printf("CONFIG_CTRL_IFACE not defined - wpa_cli disabled\n");
3289 return -1;
3290 }
3291 #endif /* CONFIG_CTRL_IFACE */
Unnamed repository; edit this file 'description' to name the repository.