2 * WPA Supplicant - command line interface for wpa_supplicant daemon
3 * Copyright (c) 2004-2010, Jouni Malinen <j@w1.fi>
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software Foundation.
9 * Alternatively, this software may be distributed under the terms of BSD
12 * See README and COPYING for more details.
16 #ifdef CONFIG_WPA_CLI_EDIT
18 #endif /* CONFIG_WPA_CLI_EDIT */
20 #ifdef CONFIG_CTRL_IFACE
22 #ifdef CONFIG_CTRL_IFACE_UNIX
24 #endif /* CONFIG_CTRL_IFACE_UNIX */
25 #ifdef CONFIG_READLINE
26 #include <readline/readline.h>
27 #include <readline/history.h>
28 #endif /* CONFIG_READLINE */
30 #include "common/wpa_ctrl.h"
31 #include "utils/common.h"
32 #include "utils/eloop.h"
33 #include "common/version.h"
36 static const char *wpa_cli_version
=
37 "wpa_cli v" VERSION_STR
"\n"
38 "Copyright (c) 2004-2010, Jouni Malinen <j@w1.fi> and contributors";
41 static const char *wpa_cli_license
=
42 "This program is free software. You can distribute it and/or modify it\n"
43 "under the terms of the GNU General Public License version 2.\n"
45 "Alternatively, this software may be distributed under the terms of the\n"
46 "BSD license. See README and COPYING for more details.\n";
48 static const char *wpa_cli_full_license
=
49 "This program is free software; you can redistribute it and/or modify\n"
50 "it under the terms of the GNU General Public License version 2 as\n"
51 "published by the Free Software Foundation.\n"
53 "This program is distributed in the hope that it will be useful,\n"
54 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
55 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
56 "GNU General Public License for more details.\n"
58 "You should have received a copy of the GNU General Public License\n"
59 "along with this program; if not, write to the Free Software\n"
60 "Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\n"
62 "Alternatively, this software may be distributed under the terms of the\n"
65 "Redistribution and use in source and binary forms, with or without\n"
66 "modification, are permitted provided that the following conditions are\n"
69 "1. Redistributions of source code must retain the above copyright\n"
70 " notice, this list of conditions and the following disclaimer.\n"
72 "2. Redistributions in binary form must reproduce the above copyright\n"
73 " notice, this list of conditions and the following disclaimer in the\n"
74 " documentation and/or other materials provided with the distribution.\n"
76 "3. Neither the name(s) of the above-listed copyright holder(s) nor the\n"
77 " names of its contributors may be used to endorse or promote products\n"
78 " derived from this software without specific prior written permission.\n"
80 "THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n"
81 "\"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n"
82 "LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n"
83 "A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n"
84 "OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n"
85 "SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n"
86 "LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n"
87 "DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n"
88 "THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n"
89 "(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n"
90 "OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n"
93 static struct wpa_ctrl
*ctrl_conn
;
94 static struct wpa_ctrl
*mon_conn
;
95 static int wpa_cli_quit
= 0;
96 static int wpa_cli_attached
= 0;
97 static int wpa_cli_connected
= 0;
98 static int wpa_cli_last_id
= 0;
99 static const char *ctrl_iface_dir
= "/var/run/wpa_supplicant";
100 static char *ctrl_ifname
= NULL
;
101 static const char *pid_file
= NULL
;
102 static const char *action_file
= NULL
;
103 static int ping_interval
= 5;
104 static int interactive
= 0;
105 #ifndef CONFIG_READLINE
106 #define CMD_BUF_LEN 256
107 static char cmdbuf
[CMD_BUF_LEN
];
108 static int cmdbuf_pos
= 0;
109 static int cmdbuf_len
= 0;
110 #endif /* CONFIG_READLINE */
111 #ifdef CONFIG_WPA_CLI_EDIT
112 #define CMD_HISTORY_LEN 20
113 static char history_buf
[CMD_HISTORY_LEN
][CMD_BUF_LEN
];
114 static int history_pos
= 0;
115 static int history_current
= 0;
116 #endif /* CONFIG_WPA_CLI_EDIT */
119 static void print_help(void);
120 static void wpa_cli_mon_receive(int sock
, void *eloop_ctx
, void *sock_ctx
);
123 static void usage(void)
125 printf("wpa_cli [-p<path to ctrl sockets>] [-i<ifname>] [-hvB] "
126 "[-a<action file>] \\\n"
127 " [-P<pid file>] [-g<global ctrl>] [-G<ping interval>] "
129 " -h = help (show this usage text)\n"
130 " -v = shown version information\n"
131 " -a = run in daemon mode executing the action file based on "
134 " -B = run a daemon in the background\n"
135 " default path: /var/run/wpa_supplicant\n"
136 " default interface: first interface found in socket path\n");
141 static void readline_redraw()
143 #ifdef CONFIG_READLINE
146 #else /* CONFIG_READLINE */
148 cmdbuf
[cmdbuf_len
] = '\0';
149 printf("\r> %s", cmdbuf
);
150 if (cmdbuf_pos
!= cmdbuf_len
) {
151 tmp
= cmdbuf
[cmdbuf_pos
];
152 cmdbuf
[cmdbuf_pos
] = '\0';
153 printf("\r> %s", cmdbuf
);
154 cmdbuf
[cmdbuf_pos
] = tmp
;
157 #endif /* CONFIG_READLINE */
161 static int str_starts(const char *src
, const char *match
)
163 return os_strncmp(src
, match
, os_strlen(match
)) == 0;
167 static int wpa_cli_show_event(const char *event
)
171 start
= os_strchr(event
, '>');
177 * Skip BSS added/removed events since they can be relatively frequent
178 * and are likely of not much use for an interactive user.
180 if (str_starts(start
, WPA_EVENT_BSS_ADDED
) ||
181 str_starts(start
, WPA_EVENT_BSS_REMOVED
))
188 static int wpa_cli_open_connection(const char *ifname
, int attach
)
190 #if defined(CONFIG_CTRL_IFACE_UDP) || defined(CONFIG_CTRL_IFACE_NAMED_PIPE)
191 ctrl_conn
= wpa_ctrl_open(ifname
);
192 if (ctrl_conn
== NULL
)
195 if (attach
&& interactive
)
196 mon_conn
= wpa_ctrl_open(ifname
);
199 #else /* CONFIG_CTRL_IFACE_UDP || CONFIG_CTRL_IFACE_NAMED_PIPE */
206 flen
= os_strlen(ctrl_iface_dir
) + os_strlen(ifname
) + 2;
207 cfile
= os_malloc(flen
);
210 res
= os_snprintf(cfile
, flen
, "%s/%s", ctrl_iface_dir
, ifname
);
211 if (res
< 0 || res
>= flen
) {
216 ctrl_conn
= wpa_ctrl_open(cfile
);
217 if (ctrl_conn
== NULL
) {
222 if (attach
&& interactive
)
223 mon_conn
= wpa_ctrl_open(cfile
);
227 #endif /* CONFIG_CTRL_IFACE_UDP || CONFIG_CTRL_IFACE_NAMED_PIPE */
230 if (wpa_ctrl_attach(mon_conn
) == 0) {
231 wpa_cli_attached
= 1;
233 eloop_register_read_sock(
234 wpa_ctrl_get_fd(mon_conn
),
235 wpa_cli_mon_receive
, NULL
, NULL
);
237 printf("Warning: Failed to attach to "
238 "wpa_supplicant.\n");
247 static void wpa_cli_close_connection(void)
249 if (ctrl_conn
== NULL
)
252 if (wpa_cli_attached
) {
253 wpa_ctrl_detach(interactive
? mon_conn
: ctrl_conn
);
254 wpa_cli_attached
= 0;
256 wpa_ctrl_close(ctrl_conn
);
259 eloop_unregister_read_sock(wpa_ctrl_get_fd(mon_conn
));
260 wpa_ctrl_close(mon_conn
);
266 static void wpa_cli_msg_cb(char *msg
, size_t len
)
272 static int _wpa_ctrl_command(struct wpa_ctrl
*ctrl
, char *cmd
, int print
)
278 if (ctrl_conn
== NULL
) {
279 printf("Not connected to wpa_supplicant - command dropped.\n");
282 len
= sizeof(buf
) - 1;
283 ret
= wpa_ctrl_request(ctrl
, cmd
, os_strlen(cmd
), buf
, &len
,
286 printf("'%s' command timed out.\n", cmd
);
288 } else if (ret
< 0) {
289 printf("'%s' command failed.\n", cmd
);
300 static int wpa_ctrl_command(struct wpa_ctrl
*ctrl
, char *cmd
)
302 return _wpa_ctrl_command(ctrl
, cmd
, 1);
306 static int wpa_cli_cmd_status(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
308 int verbose
= argc
> 0 && os_strcmp(argv
[0], "verbose") == 0;
309 return wpa_ctrl_command(ctrl
, verbose
? "STATUS-VERBOSE" : "STATUS");
313 static int wpa_cli_cmd_ping(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
315 return wpa_ctrl_command(ctrl
, "PING");
319 static int wpa_cli_cmd_note(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
325 ret
= os_snprintf(cmd
, sizeof(cmd
), "NOTE %s", argv
[0]);
326 if (ret
< 0 || (size_t) ret
>= sizeof(cmd
))
328 return wpa_ctrl_command(ctrl
, cmd
);
332 static int wpa_cli_cmd_mib(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
334 return wpa_ctrl_command(ctrl
, "MIB");
338 static int wpa_cli_cmd_pmksa(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
340 return wpa_ctrl_command(ctrl
, "PMKSA");
344 static int wpa_cli_cmd_help(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
351 static int wpa_cli_cmd_license(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
353 printf("%s\n\n%s\n", wpa_cli_version
, wpa_cli_full_license
);
358 static int wpa_cli_cmd_quit(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
367 static void wpa_cli_show_variables(void)
369 printf("set variables:\n"
370 " EAPOL::heldPeriod (EAPOL state machine held period, "
372 " EAPOL::authPeriod (EAPOL state machine authentication "
373 "period, in seconds)\n"
374 " EAPOL::startPeriod (EAPOL state machine start period, in "
376 " EAPOL::maxStart (EAPOL state machine maximum start "
378 printf(" dot11RSNAConfigPMKLifetime (WPA/WPA2 PMK lifetime in "
380 " dot11RSNAConfigPMKReauthThreshold (WPA/WPA2 reauthentication"
381 " threshold\n\tpercentage)\n"
382 " dot11RSNAConfigSATimeout (WPA/WPA2 timeout for completing "
383 "security\n\tassociation in seconds)\n");
387 static int wpa_cli_cmd_set(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
393 wpa_cli_show_variables();
398 printf("Invalid SET command: needs two arguments (variable "
399 "name and value)\n");
403 res
= os_snprintf(cmd
, sizeof(cmd
), "SET %s %s", argv
[0], argv
[1]);
404 if (res
< 0 || (size_t) res
>= sizeof(cmd
) - 1) {
405 printf("Too long SET command.\n");
408 return wpa_ctrl_command(ctrl
, cmd
);
412 static int wpa_cli_cmd_get(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
418 printf("Invalid GET command: need one argument (variable "
423 res
= os_snprintf(cmd
, sizeof(cmd
), "GET %s", argv
[0]);
424 if (res
< 0 || (size_t) res
>= sizeof(cmd
) - 1) {
425 printf("Too long GET command.\n");
428 return wpa_ctrl_command(ctrl
, cmd
);
432 static int wpa_cli_cmd_logoff(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
434 return wpa_ctrl_command(ctrl
, "LOGOFF");
438 static int wpa_cli_cmd_logon(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
440 return wpa_ctrl_command(ctrl
, "LOGON");
444 static int wpa_cli_cmd_reassociate(struct wpa_ctrl
*ctrl
, int argc
,
447 return wpa_ctrl_command(ctrl
, "REASSOCIATE");
451 static int wpa_cli_cmd_preauthenticate(struct wpa_ctrl
*ctrl
, int argc
,
458 printf("Invalid PREAUTH command: needs one argument "
463 res
= os_snprintf(cmd
, sizeof(cmd
), "PREAUTH %s", argv
[0]);
464 if (res
< 0 || (size_t) res
>= sizeof(cmd
) - 1) {
465 printf("Too long PREAUTH command.\n");
468 return wpa_ctrl_command(ctrl
, cmd
);
472 static int wpa_cli_cmd_ap_scan(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
478 printf("Invalid AP_SCAN command: needs one argument (ap_scan "
482 res
= os_snprintf(cmd
, sizeof(cmd
), "AP_SCAN %s", argv
[0]);
483 if (res
< 0 || (size_t) res
>= sizeof(cmd
) - 1) {
484 printf("Too long AP_SCAN command.\n");
487 return wpa_ctrl_command(ctrl
, cmd
);
491 static int wpa_cli_cmd_stkstart(struct wpa_ctrl
*ctrl
, int argc
,
498 printf("Invalid STKSTART command: needs one argument "
499 "(Peer STA MAC address)\n");
503 res
= os_snprintf(cmd
, sizeof(cmd
), "STKSTART %s", argv
[0]);
504 if (res
< 0 || (size_t) res
>= sizeof(cmd
) - 1) {
505 printf("Too long STKSTART command.\n");
508 return wpa_ctrl_command(ctrl
, cmd
);
512 static int wpa_cli_cmd_ft_ds(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
518 printf("Invalid FT_DS command: needs one argument "
519 "(Target AP MAC address)\n");
523 res
= os_snprintf(cmd
, sizeof(cmd
), "FT_DS %s", argv
[0]);
524 if (res
< 0 || (size_t) res
>= sizeof(cmd
) - 1) {
525 printf("Too long FT_DS command.\n");
528 return wpa_ctrl_command(ctrl
, cmd
);
532 static int wpa_cli_cmd_wps_pbc(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
539 return wpa_ctrl_command(ctrl
, "WPS_PBC");
543 res
= os_snprintf(cmd
, sizeof(cmd
), "WPS_PBC %s", argv
[0]);
544 if (res
< 0 || (size_t) res
>= sizeof(cmd
) - 1) {
545 printf("Too long WPS_PBC command.\n");
548 return wpa_ctrl_command(ctrl
, cmd
);
552 static int wpa_cli_cmd_wps_pin(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
558 printf("Invalid WPS_PIN command: need one or two arguments:\n"
559 "- BSSID: use 'any' to select any\n"
560 "- PIN: optional, used only with devices that have no "
566 /* Use dynamically generated PIN (returned as reply) */
567 res
= os_snprintf(cmd
, sizeof(cmd
), "WPS_PIN %s", argv
[0]);
568 if (res
< 0 || (size_t) res
>= sizeof(cmd
) - 1) {
569 printf("Too long WPS_PIN command.\n");
572 return wpa_ctrl_command(ctrl
, cmd
);
575 /* Use hardcoded PIN from a label */
576 res
= os_snprintf(cmd
, sizeof(cmd
), "WPS_PIN %s %s", argv
[0], argv
[1]);
577 if (res
< 0 || (size_t) res
>= sizeof(cmd
) - 1) {
578 printf("Too long WPS_PIN command.\n");
581 return wpa_ctrl_command(ctrl
, cmd
);
585 static int wpa_cli_cmd_wps_check_pin(struct wpa_ctrl
*ctrl
, int argc
,
591 if (argc
!= 1 && argc
!= 2) {
592 printf("Invalid WPS_CHECK_PIN command: needs one argument:\n"
593 "- PIN to be verified\n");
598 res
= os_snprintf(cmd
, sizeof(cmd
), "WPS_CHECK_PIN %s %s",
601 res
= os_snprintf(cmd
, sizeof(cmd
), "WPS_CHECK_PIN %s",
603 if (res
< 0 || (size_t) res
>= sizeof(cmd
) - 1) {
604 printf("Too long WPS_CHECK_PIN command.\n");
607 return wpa_ctrl_command(ctrl
, cmd
);
611 static int wpa_cli_cmd_wps_cancel(struct wpa_ctrl
*ctrl
, int argc
,
614 return wpa_ctrl_command(ctrl
, "WPS_CANCEL");
618 #ifdef CONFIG_WPS_OOB
619 static int wpa_cli_cmd_wps_oob(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
624 if (argc
!= 3 && argc
!= 4) {
625 printf("Invalid WPS_OOB command: need three or four "
627 "- DEV_TYPE: use 'ufd' or 'nfc'\n"
628 "- PATH: path of OOB device like '/mnt'\n"
629 "- METHOD: OOB method 'pin-e' or 'pin-r', "
631 "- DEV_NAME: (only for NFC) device name like "
637 res
= os_snprintf(cmd
, sizeof(cmd
), "WPS_OOB %s %s %s",
638 argv
[0], argv
[1], argv
[2]);
640 res
= os_snprintf(cmd
, sizeof(cmd
), "WPS_OOB %s %s %s %s",
641 argv
[0], argv
[1], argv
[2], argv
[3]);
642 if (res
< 0 || (size_t) res
>= sizeof(cmd
) - 1) {
643 printf("Too long WPS_OOB command.\n");
646 return wpa_ctrl_command(ctrl
, cmd
);
648 #endif /* CONFIG_WPS_OOB */
651 static int wpa_cli_cmd_wps_reg(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
657 res
= os_snprintf(cmd
, sizeof(cmd
), "WPS_REG %s %s",
659 else if (argc
== 5 || argc
== 6) {
660 char ssid_hex
[2 * 32 + 1];
661 char key_hex
[2 * 64 + 1];
665 for (i
= 0; i
< 32; i
++) {
666 if (argv
[2][i
] == '\0')
668 os_snprintf(&ssid_hex
[i
* 2], 3, "%02x", argv
[2][i
]);
673 for (i
= 0; i
< 64; i
++) {
674 if (argv
[5][i
] == '\0')
676 os_snprintf(&key_hex
[i
* 2], 3, "%02x",
681 res
= os_snprintf(cmd
, sizeof(cmd
),
682 "WPS_REG %s %s %s %s %s %s",
683 argv
[0], argv
[1], ssid_hex
, argv
[3], argv
[4],
686 printf("Invalid WPS_REG command: need two arguments:\n"
687 "- BSSID of the target AP\n"
689 printf("Alternatively, six arguments can be used to "
690 "reconfigure the AP:\n"
691 "- BSSID of the target AP\n"
694 "- new auth (OPEN, WPAPSK, WPA2PSK)\n"
695 "- new encr (NONE, WEP, TKIP, CCMP)\n"
700 if (res
< 0 || (size_t) res
>= sizeof(cmd
) - 1) {
701 printf("Too long WPS_REG command.\n");
704 return wpa_ctrl_command(ctrl
, cmd
);
708 static int wpa_cli_cmd_wps_er_start(struct wpa_ctrl
*ctrl
, int argc
,
713 os_snprintf(cmd
, sizeof(cmd
), "WPS_ER_START %s", argv
[0]);
714 return wpa_ctrl_command(ctrl
, cmd
);
716 return wpa_ctrl_command(ctrl
, "WPS_ER_START");
720 static int wpa_cli_cmd_wps_er_stop(struct wpa_ctrl
*ctrl
, int argc
,
723 return wpa_ctrl_command(ctrl
, "WPS_ER_STOP");
728 static int wpa_cli_cmd_wps_er_pin(struct wpa_ctrl
*ctrl
, int argc
,
735 printf("Invalid WPS_ER_PIN command: need at least two "
737 "- UUID: use 'any' to select any\n"
738 "- PIN: Enrollee PIN\n"
739 "optional: - Enrollee MAC address\n");
744 res
= os_snprintf(cmd
, sizeof(cmd
), "WPS_ER_PIN %s %s %s",
745 argv
[0], argv
[1], argv
[2]);
747 res
= os_snprintf(cmd
, sizeof(cmd
), "WPS_ER_PIN %s %s",
749 if (res
< 0 || (size_t) res
>= sizeof(cmd
) - 1) {
750 printf("Too long WPS_ER_PIN command.\n");
753 return wpa_ctrl_command(ctrl
, cmd
);
757 static int wpa_cli_cmd_wps_er_pbc(struct wpa_ctrl
*ctrl
, int argc
,
764 printf("Invalid WPS_ER_PBC command: need one argument:\n"
765 "- UUID: Specify the Enrollee\n");
769 res
= os_snprintf(cmd
, sizeof(cmd
), "WPS_ER_PBC %s",
771 if (res
< 0 || (size_t) res
>= sizeof(cmd
) - 1) {
772 printf("Too long WPS_ER_PBC command.\n");
775 return wpa_ctrl_command(ctrl
, cmd
);
779 static int wpa_cli_cmd_wps_er_learn(struct wpa_ctrl
*ctrl
, int argc
,
786 printf("Invalid WPS_ER_LEARN command: need two arguments:\n"
787 "- UUID: specify which AP to use\n"
792 res
= os_snprintf(cmd
, sizeof(cmd
), "WPS_ER_LEARN %s %s",
794 if (res
< 0 || (size_t) res
>= sizeof(cmd
) - 1) {
795 printf("Too long WPS_ER_LEARN command.\n");
798 return wpa_ctrl_command(ctrl
, cmd
);
802 static int wpa_cli_cmd_wps_er_set_config(struct wpa_ctrl
*ctrl
, int argc
,
809 printf("Invalid WPS_ER_SET_CONFIG command: need two "
811 "- UUID: specify which AP to use\n"
812 "- Network configuration id\n");
816 res
= os_snprintf(cmd
, sizeof(cmd
), "WPS_ER_SET_CONFIG %s %s",
818 if (res
< 0 || (size_t) res
>= sizeof(cmd
) - 1) {
819 printf("Too long WPS_ER_SET_CONFIG command.\n");
822 return wpa_ctrl_command(ctrl
, cmd
);
826 static int wpa_cli_cmd_wps_er_config(struct wpa_ctrl
*ctrl
, int argc
,
832 if (argc
== 5 || argc
== 6) {
833 char ssid_hex
[2 * 32 + 1];
834 char key_hex
[2 * 64 + 1];
838 for (i
= 0; i
< 32; i
++) {
839 if (argv
[2][i
] == '\0')
841 os_snprintf(&ssid_hex
[i
* 2], 3, "%02x", argv
[2][i
]);
846 for (i
= 0; i
< 64; i
++) {
847 if (argv
[5][i
] == '\0')
849 os_snprintf(&key_hex
[i
* 2], 3, "%02x",
854 res
= os_snprintf(cmd
, sizeof(cmd
),
855 "WPS_ER_CONFIG %s %s %s %s %s %s",
856 argv
[0], argv
[1], ssid_hex
, argv
[3], argv
[4],
859 printf("Invalid WPS_ER_CONFIG command: need six arguments:\n"
863 "- new auth (OPEN, WPAPSK, WPA2PSK)\n"
864 "- new encr (NONE, WEP, TKIP, CCMP)\n"
869 if (res
< 0 || (size_t) res
>= sizeof(cmd
) - 1) {
870 printf("Too long WPS_ER_CONFIG command.\n");
873 return wpa_ctrl_command(ctrl
, cmd
);
877 static int wpa_cli_cmd_ibss_rsn(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
883 printf("Invalid IBSS_RSN command: needs one argument "
884 "(Peer STA MAC address)\n");
888 res
= os_snprintf(cmd
, sizeof(cmd
), "IBSS_RSN %s", argv
[0]);
889 if (res
< 0 || (size_t) res
>= sizeof(cmd
) - 1) {
890 printf("Too long IBSS_RSN command.\n");
893 return wpa_ctrl_command(ctrl
, cmd
);
897 static int wpa_cli_cmd_level(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
903 printf("Invalid LEVEL command: needs one argument (debug "
907 res
= os_snprintf(cmd
, sizeof(cmd
), "LEVEL %s", argv
[0]);
908 if (res
< 0 || (size_t) res
>= sizeof(cmd
) - 1) {
909 printf("Too long LEVEL command.\n");
912 return wpa_ctrl_command(ctrl
, cmd
);
916 static int wpa_cli_cmd_identity(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
918 char cmd
[256], *pos
, *end
;
922 printf("Invalid IDENTITY command: needs two arguments "
923 "(network id and identity)\n");
927 end
= cmd
+ sizeof(cmd
);
929 ret
= os_snprintf(pos
, end
- pos
, WPA_CTRL_RSP
"IDENTITY-%s:%s",
931 if (ret
< 0 || ret
>= end
- pos
) {
932 printf("Too long IDENTITY command.\n");
936 for (i
= 2; i
< argc
; i
++) {
937 ret
= os_snprintf(pos
, end
- pos
, " %s", argv
[i
]);
938 if (ret
< 0 || ret
>= end
- pos
) {
939 printf("Too long IDENTITY command.\n");
945 return wpa_ctrl_command(ctrl
, cmd
);
949 static int wpa_cli_cmd_password(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
951 char cmd
[256], *pos
, *end
;
955 printf("Invalid PASSWORD command: needs two arguments "
956 "(network id and password)\n");
960 end
= cmd
+ sizeof(cmd
);
962 ret
= os_snprintf(pos
, end
- pos
, WPA_CTRL_RSP
"PASSWORD-%s:%s",
964 if (ret
< 0 || ret
>= end
- pos
) {
965 printf("Too long PASSWORD command.\n");
969 for (i
= 2; i
< argc
; i
++) {
970 ret
= os_snprintf(pos
, end
- pos
, " %s", argv
[i
]);
971 if (ret
< 0 || ret
>= end
- pos
) {
972 printf("Too long PASSWORD command.\n");
978 return wpa_ctrl_command(ctrl
, cmd
);
982 static int wpa_cli_cmd_new_password(struct wpa_ctrl
*ctrl
, int argc
,
985 char cmd
[256], *pos
, *end
;
989 printf("Invalid NEW_PASSWORD command: needs two arguments "
990 "(network id and password)\n");
994 end
= cmd
+ sizeof(cmd
);
996 ret
= os_snprintf(pos
, end
- pos
, WPA_CTRL_RSP
"NEW_PASSWORD-%s:%s",
998 if (ret
< 0 || ret
>= end
- pos
) {
999 printf("Too long NEW_PASSWORD command.\n");
1003 for (i
= 2; i
< argc
; i
++) {
1004 ret
= os_snprintf(pos
, end
- pos
, " %s", argv
[i
]);
1005 if (ret
< 0 || ret
>= end
- pos
) {
1006 printf("Too long NEW_PASSWORD command.\n");
1012 return wpa_ctrl_command(ctrl
, cmd
);
1016 static int wpa_cli_cmd_pin(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1018 char cmd
[256], *pos
, *end
;
1022 printf("Invalid PIN command: needs two arguments "
1023 "(network id and pin)\n");
1027 end
= cmd
+ sizeof(cmd
);
1029 ret
= os_snprintf(pos
, end
- pos
, WPA_CTRL_RSP
"PIN-%s:%s",
1031 if (ret
< 0 || ret
>= end
- pos
) {
1032 printf("Too long PIN command.\n");
1036 for (i
= 2; i
< argc
; i
++) {
1037 ret
= os_snprintf(pos
, end
- pos
, " %s", argv
[i
]);
1038 if (ret
< 0 || ret
>= end
- pos
) {
1039 printf("Too long PIN command.\n");
1044 return wpa_ctrl_command(ctrl
, cmd
);
1048 static int wpa_cli_cmd_otp(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1050 char cmd
[256], *pos
, *end
;
1054 printf("Invalid OTP command: needs two arguments (network "
1055 "id and password)\n");
1059 end
= cmd
+ sizeof(cmd
);
1061 ret
= os_snprintf(pos
, end
- pos
, WPA_CTRL_RSP
"OTP-%s:%s",
1063 if (ret
< 0 || ret
>= end
- pos
) {
1064 printf("Too long OTP command.\n");
1068 for (i
= 2; i
< argc
; i
++) {
1069 ret
= os_snprintf(pos
, end
- pos
, " %s", argv
[i
]);
1070 if (ret
< 0 || ret
>= end
- pos
) {
1071 printf("Too long OTP command.\n");
1077 return wpa_ctrl_command(ctrl
, cmd
);
1081 static int wpa_cli_cmd_passphrase(struct wpa_ctrl
*ctrl
, int argc
,
1084 char cmd
[256], *pos
, *end
;
1088 printf("Invalid PASSPHRASE command: needs two arguments "
1089 "(network id and passphrase)\n");
1093 end
= cmd
+ sizeof(cmd
);
1095 ret
= os_snprintf(pos
, end
- pos
, WPA_CTRL_RSP
"PASSPHRASE-%s:%s",
1097 if (ret
< 0 || ret
>= end
- pos
) {
1098 printf("Too long PASSPHRASE command.\n");
1102 for (i
= 2; i
< argc
; i
++) {
1103 ret
= os_snprintf(pos
, end
- pos
, " %s", argv
[i
]);
1104 if (ret
< 0 || ret
>= end
- pos
) {
1105 printf("Too long PASSPHRASE command.\n");
1111 return wpa_ctrl_command(ctrl
, cmd
);
1115 static int wpa_cli_cmd_bssid(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1117 char cmd
[256], *pos
, *end
;
1121 printf("Invalid BSSID command: needs two arguments (network "
1126 end
= cmd
+ sizeof(cmd
);
1128 ret
= os_snprintf(pos
, end
- pos
, "BSSID");
1129 if (ret
< 0 || ret
>= end
- pos
) {
1130 printf("Too long BSSID command.\n");
1134 for (i
= 0; i
< argc
; i
++) {
1135 ret
= os_snprintf(pos
, end
- pos
, " %s", argv
[i
]);
1136 if (ret
< 0 || ret
>= end
- pos
) {
1137 printf("Too long BSSID command.\n");
1143 return wpa_ctrl_command(ctrl
, cmd
);
1147 static int wpa_cli_cmd_list_networks(struct wpa_ctrl
*ctrl
, int argc
,
1150 return wpa_ctrl_command(ctrl
, "LIST_NETWORKS");
1154 static int wpa_cli_cmd_select_network(struct wpa_ctrl
*ctrl
, int argc
,
1161 printf("Invalid SELECT_NETWORK command: needs one argument "
1166 res
= os_snprintf(cmd
, sizeof(cmd
), "SELECT_NETWORK %s", argv
[0]);
1167 if (res
< 0 || (size_t) res
>= sizeof(cmd
))
1169 cmd
[sizeof(cmd
) - 1] = '\0';
1171 return wpa_ctrl_command(ctrl
, cmd
);
1175 static int wpa_cli_cmd_enable_network(struct wpa_ctrl
*ctrl
, int argc
,
1182 printf("Invalid ENABLE_NETWORK command: needs one argument "
1187 res
= os_snprintf(cmd
, sizeof(cmd
), "ENABLE_NETWORK %s", argv
[0]);
1188 if (res
< 0 || (size_t) res
>= sizeof(cmd
))
1190 cmd
[sizeof(cmd
) - 1] = '\0';
1192 return wpa_ctrl_command(ctrl
, cmd
);
1196 static int wpa_cli_cmd_disable_network(struct wpa_ctrl
*ctrl
, int argc
,
1203 printf("Invalid DISABLE_NETWORK command: needs one argument "
1208 res
= os_snprintf(cmd
, sizeof(cmd
), "DISABLE_NETWORK %s", argv
[0]);
1209 if (res
< 0 || (size_t) res
>= sizeof(cmd
))
1211 cmd
[sizeof(cmd
) - 1] = '\0';
1213 return wpa_ctrl_command(ctrl
, cmd
);
1217 static int wpa_cli_cmd_add_network(struct wpa_ctrl
*ctrl
, int argc
,
1220 return wpa_ctrl_command(ctrl
, "ADD_NETWORK");
1224 static int wpa_cli_cmd_remove_network(struct wpa_ctrl
*ctrl
, int argc
,
1231 printf("Invalid REMOVE_NETWORK command: needs one argument "
1236 res
= os_snprintf(cmd
, sizeof(cmd
), "REMOVE_NETWORK %s", argv
[0]);
1237 if (res
< 0 || (size_t) res
>= sizeof(cmd
))
1239 cmd
[sizeof(cmd
) - 1] = '\0';
1241 return wpa_ctrl_command(ctrl
, cmd
);
1245 static void wpa_cli_show_network_variables(void)
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"
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 "
1259 "For example: set_network 1 ssid \"network name\"\n"
1261 "Please see wpa_supplicant.conf documentation for full list "
1262 "of\navailable variables.\n");
1266 static int wpa_cli_cmd_set_network(struct wpa_ctrl
*ctrl
, int argc
,
1273 wpa_cli_show_network_variables();
1278 printf("Invalid SET_NETWORK command: needs three arguments\n"
1279 "(network id, variable name, and value)\n");
1283 res
= os_snprintf(cmd
, sizeof(cmd
), "SET_NETWORK %s %s %s",
1284 argv
[0], argv
[1], argv
[2]);
1285 if (res
< 0 || (size_t) res
>= sizeof(cmd
) - 1) {
1286 printf("Too long SET_NETWORK command.\n");
1289 return wpa_ctrl_command(ctrl
, cmd
);
1293 static int wpa_cli_cmd_get_network(struct wpa_ctrl
*ctrl
, int argc
,
1300 wpa_cli_show_network_variables();
1305 printf("Invalid GET_NETWORK command: needs two arguments\n"
1306 "(network id and variable name)\n");
1310 res
= os_snprintf(cmd
, sizeof(cmd
), "GET_NETWORK %s %s",
1312 if (res
< 0 || (size_t) res
>= sizeof(cmd
) - 1) {
1313 printf("Too long GET_NETWORK command.\n");
1316 return wpa_ctrl_command(ctrl
, cmd
);
1320 static int wpa_cli_cmd_disconnect(struct wpa_ctrl
*ctrl
, int argc
,
1323 return wpa_ctrl_command(ctrl
, "DISCONNECT");
1327 static int wpa_cli_cmd_reconnect(struct wpa_ctrl
*ctrl
, int argc
,
1330 return wpa_ctrl_command(ctrl
, "RECONNECT");
1334 static int wpa_cli_cmd_save_config(struct wpa_ctrl
*ctrl
, int argc
,
1337 return wpa_ctrl_command(ctrl
, "SAVE_CONFIG");
1341 static int wpa_cli_cmd_scan(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1343 return wpa_ctrl_command(ctrl
, "SCAN");
1347 static int wpa_cli_cmd_scan_results(struct wpa_ctrl
*ctrl
, int argc
,
1350 return wpa_ctrl_command(ctrl
, "SCAN_RESULTS");
1354 static int wpa_cli_cmd_bss(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1360 printf("Invalid BSS command: need one argument (index or "
1365 res
= os_snprintf(cmd
, sizeof(cmd
), "BSS %s", argv
[0]);
1366 if (res
< 0 || (size_t) res
>= sizeof(cmd
))
1368 cmd
[sizeof(cmd
) - 1] = '\0';
1370 return wpa_ctrl_command(ctrl
, cmd
);
1374 static int wpa_cli_cmd_get_capability(struct wpa_ctrl
*ctrl
, int argc
,
1380 if (argc
< 1 || argc
> 2) {
1381 printf("Invalid GET_CAPABILITY command: need either one or "
1386 if ((argc
== 2) && os_strcmp(argv
[1], "strict") != 0) {
1387 printf("Invalid GET_CAPABILITY command: second argument, "
1388 "if any, must be 'strict'\n");
1392 res
= os_snprintf(cmd
, sizeof(cmd
), "GET_CAPABILITY %s%s", argv
[0],
1393 (argc
== 2) ? " strict" : "");
1394 if (res
< 0 || (size_t) res
>= sizeof(cmd
))
1396 cmd
[sizeof(cmd
) - 1] = '\0';
1398 return wpa_ctrl_command(ctrl
, cmd
);
1402 static int wpa_cli_list_interfaces(struct wpa_ctrl
*ctrl
)
1404 printf("Available interfaces:\n");
1405 return wpa_ctrl_command(ctrl
, "INTERFACES");
1409 static int wpa_cli_cmd_interface(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1412 wpa_cli_list_interfaces(ctrl
);
1416 wpa_cli_close_connection();
1417 os_free(ctrl_ifname
);
1418 ctrl_ifname
= os_strdup(argv
[0]);
1420 if (wpa_cli_open_connection(ctrl_ifname
, 1)) {
1421 printf("Connected to interface '%s.\n", ctrl_ifname
);
1423 printf("Could not connect to interface '%s' - re-trying\n",
1430 static int wpa_cli_cmd_reconfigure(struct wpa_ctrl
*ctrl
, int argc
,
1433 return wpa_ctrl_command(ctrl
, "RECONFIGURE");
1437 static int wpa_cli_cmd_terminate(struct wpa_ctrl
*ctrl
, int argc
,
1440 return wpa_ctrl_command(ctrl
, "TERMINATE");
1444 static int wpa_cli_cmd_interface_add(struct wpa_ctrl
*ctrl
, int argc
,
1451 printf("Invalid INTERFACE_ADD command: needs at least one "
1452 "argument (interface name)\n"
1453 "All arguments: ifname confname driver ctrl_interface "
1454 "driver_param bridge_name\n");
1459 * INTERFACE_ADD <ifname>TAB<confname>TAB<driver>TAB<ctrl_interface>TAB
1460 * <driver_param>TAB<bridge_name>
1462 res
= os_snprintf(cmd
, sizeof(cmd
),
1463 "INTERFACE_ADD %s\t%s\t%s\t%s\t%s\t%s",
1465 argc
> 1 ? argv
[1] : "", argc
> 2 ? argv
[2] : "",
1466 argc
> 3 ? argv
[3] : "", argc
> 4 ? argv
[4] : "",
1467 argc
> 5 ? argv
[5] : "");
1468 if (res
< 0 || (size_t) res
>= sizeof(cmd
))
1470 cmd
[sizeof(cmd
) - 1] = '\0';
1471 return wpa_ctrl_command(ctrl
, cmd
);
1475 static int wpa_cli_cmd_interface_remove(struct wpa_ctrl
*ctrl
, int argc
,
1482 printf("Invalid INTERFACE_REMOVE command: needs one argument "
1483 "(interface name)\n");
1487 res
= os_snprintf(cmd
, sizeof(cmd
), "INTERFACE_REMOVE %s", argv
[0]);
1488 if (res
< 0 || (size_t) res
>= sizeof(cmd
))
1490 cmd
[sizeof(cmd
) - 1] = '\0';
1491 return wpa_ctrl_command(ctrl
, cmd
);
1495 static int wpa_cli_cmd_interface_list(struct wpa_ctrl
*ctrl
, int argc
,
1498 return wpa_ctrl_command(ctrl
, "INTERFACE_LIST");
1503 static int wpa_cli_cmd_sta(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1507 printf("Invalid 'sta' command - exactly one argument, STA "
1508 "address, is required.\n");
1511 os_snprintf(buf
, sizeof(buf
), "STA %s", argv
[0]);
1512 return wpa_ctrl_command(ctrl
, buf
);
1516 static int wpa_ctrl_command_sta(struct wpa_ctrl
*ctrl
, char *cmd
,
1517 char *addr
, size_t addr_len
)
1519 char buf
[4096], *pos
;
1523 if (ctrl_conn
== NULL
) {
1524 printf("Not connected to hostapd - command dropped.\n");
1527 len
= sizeof(buf
) - 1;
1528 ret
= wpa_ctrl_request(ctrl
, cmd
, strlen(cmd
), buf
, &len
,
1531 printf("'%s' command timed out.\n", cmd
);
1533 } else if (ret
< 0) {
1534 printf("'%s' command failed.\n", cmd
);
1539 if (memcmp(buf
, "FAIL", 4) == 0)
1544 while (*pos
!= '\0' && *pos
!= '\n')
1547 os_strlcpy(addr
, buf
, addr_len
);
1552 static int wpa_cli_cmd_all_sta(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1554 char addr
[32], cmd
[64];
1556 if (wpa_ctrl_command_sta(ctrl
, "STA-FIRST", addr
, sizeof(addr
)))
1559 os_snprintf(cmd
, sizeof(cmd
), "STA-NEXT %s", addr
);
1560 } while (wpa_ctrl_command_sta(ctrl
, cmd
, addr
, sizeof(addr
)) == 0);
1564 #endif /* CONFIG_AP */
1567 static int wpa_cli_cmd_suspend(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1569 return wpa_ctrl_command(ctrl
, "SUSPEND");
1573 static int wpa_cli_cmd_resume(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1575 return wpa_ctrl_command(ctrl
, "RESUME");
1579 static int wpa_cli_cmd_drop_sa(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1581 return wpa_ctrl_command(ctrl
, "DROP_SA");
1585 static int wpa_cli_cmd_roam(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1591 printf("Invalid ROAM command: needs one argument "
1592 "(target AP's BSSID)\n");
1596 res
= os_snprintf(cmd
, sizeof(cmd
), "ROAM %s", argv
[0]);
1597 if (res
< 0 || (size_t) res
>= sizeof(cmd
) - 1) {
1598 printf("Too long ROAM command.\n");
1601 return wpa_ctrl_command(ctrl
, cmd
);
1607 static int wpa_cli_cmd_p2p_find(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1613 return wpa_ctrl_command(ctrl
, "P2P_FIND");
1616 res
= os_snprintf(cmd
, sizeof(cmd
), "P2P_FIND %s %s",
1619 res
= os_snprintf(cmd
, sizeof(cmd
), "P2P_FIND %s", argv
[0]);
1620 if (res
< 0 || (size_t) res
>= sizeof(cmd
))
1622 cmd
[sizeof(cmd
) - 1] = '\0';
1623 return wpa_ctrl_command(ctrl
, cmd
);
1627 static int wpa_cli_cmd_p2p_stop_find(struct wpa_ctrl
*ctrl
, int argc
,
1630 return wpa_ctrl_command(ctrl
, "P2P_STOP_FIND");
1634 static int wpa_cli_cmd_p2p_connect(struct wpa_ctrl
*ctrl
, int argc
,
1641 printf("Invalid P2P_CONNECT command: needs at least two "
1642 "arguments (address and pbc/PIN)\n");
1647 res
= os_snprintf(cmd
, sizeof(cmd
),
1648 "P2P_CONNECT %s %s %s %s %s",
1649 argv
[0], argv
[1], argv
[2], argv
[3],
1652 res
= os_snprintf(cmd
, sizeof(cmd
), "P2P_CONNECT %s %s %s %s",
1653 argv
[0], argv
[1], argv
[2], argv
[3]);
1655 res
= os_snprintf(cmd
, sizeof(cmd
), "P2P_CONNECT %s %s %s",
1656 argv
[0], argv
[1], argv
[2]);
1658 res
= os_snprintf(cmd
, sizeof(cmd
), "P2P_CONNECT %s %s",
1660 if (res
< 0 || (size_t) res
>= sizeof(cmd
))
1662 cmd
[sizeof(cmd
) - 1] = '\0';
1663 return wpa_ctrl_command(ctrl
, cmd
);
1667 static int wpa_cli_cmd_p2p_listen(struct wpa_ctrl
*ctrl
, int argc
,
1674 return wpa_ctrl_command(ctrl
, "P2P_LISTEN");
1676 res
= os_snprintf(cmd
, sizeof(cmd
), "P2P_LISTEN %s", argv
[0]);
1677 if (res
< 0 || (size_t) res
>= sizeof(cmd
))
1679 cmd
[sizeof(cmd
) - 1] = '\0';
1680 return wpa_ctrl_command(ctrl
, cmd
);
1684 static int wpa_cli_cmd_p2p_group_remove(struct wpa_ctrl
*ctrl
, int argc
,
1691 printf("Invalid P2P_GROUP_REMOVE command: needs one argument "
1692 "(interface name)\n");
1696 res
= os_snprintf(cmd
, sizeof(cmd
), "P2P_GROUP_REMOVE %s", argv
[0]);
1697 if (res
< 0 || (size_t) res
>= sizeof(cmd
))
1699 cmd
[sizeof(cmd
) - 1] = '\0';
1700 return wpa_ctrl_command(ctrl
, cmd
);
1704 static int wpa_cli_cmd_p2p_group_add(struct wpa_ctrl
*ctrl
, int argc
,
1711 return wpa_ctrl_command(ctrl
, "P2P_GROUP_ADD");
1713 res
= os_snprintf(cmd
, sizeof(cmd
), "P2P_GROUP_ADD %s", argv
[0]);
1714 if (res
< 0 || (size_t) res
>= sizeof(cmd
))
1716 cmd
[sizeof(cmd
) - 1] = '\0';
1717 return wpa_ctrl_command(ctrl
, cmd
);
1721 static int wpa_cli_cmd_p2p_prov_disc(struct wpa_ctrl
*ctrl
, int argc
,
1728 printf("Invalid P2P_PROV_DISC command: needs two arguments "
1729 "(address and config method\n"
1730 "(display, keypad, or pbc)\n");
1734 res
= os_snprintf(cmd
, sizeof(cmd
), "P2P_PROV_DISC %s %s",
1736 if (res
< 0 || (size_t) res
>= sizeof(cmd
))
1738 cmd
[sizeof(cmd
) - 1] = '\0';
1739 return wpa_ctrl_command(ctrl
, cmd
);
1743 static int wpa_cli_cmd_p2p_get_passphrase(struct wpa_ctrl
*ctrl
, int argc
,
1746 return wpa_ctrl_command(ctrl
, "P2P_GET_PASSPHRASE");
1750 static int wpa_cli_cmd_p2p_serv_disc_req(struct wpa_ctrl
*ctrl
, int argc
,
1756 if (argc
!= 2 && argc
!= 4) {
1757 printf("Invalid P2P_SERV_DISC_REQ command: needs two "
1758 "arguments (address and TLVs) or four arguments "
1759 "(address, \"upnp\", version, search target "
1765 res
= os_snprintf(cmd
, sizeof(cmd
),
1766 "P2P_SERV_DISC_REQ %s %s %s %s",
1767 argv
[0], argv
[1], argv
[2], argv
[3]);
1769 res
= os_snprintf(cmd
, sizeof(cmd
), "P2P_SERV_DISC_REQ %s %s",
1771 if (res
< 0 || (size_t) res
>= sizeof(cmd
))
1773 cmd
[sizeof(cmd
) - 1] = '\0';
1774 return wpa_ctrl_command(ctrl
, cmd
);
1778 static int wpa_cli_cmd_p2p_serv_disc_cancel_req(struct wpa_ctrl
*ctrl
,
1779 int argc
, char *argv
[])
1785 printf("Invalid P2P_SERV_DISC_CANCEL_REQ command: needs one "
1786 "argument (pending request identifier)\n");
1790 res
= os_snprintf(cmd
, sizeof(cmd
), "P2P_SERV_DISC_CANCEL_REQ %s",
1792 if (res
< 0 || (size_t) res
>= sizeof(cmd
))
1794 cmd
[sizeof(cmd
) - 1] = '\0';
1795 return wpa_ctrl_command(ctrl
, cmd
);
1799 static int wpa_cli_cmd_p2p_serv_disc_resp(struct wpa_ctrl
*ctrl
, int argc
,
1806 printf("Invalid P2P_SERV_DISC_RESP command: needs four "
1807 "arguments (freq, address, dialog token, and TLVs)\n");
1811 res
= os_snprintf(cmd
, sizeof(cmd
), "P2P_SERV_DISC_RESP %s %s %s %s",
1812 argv
[0], argv
[1], argv
[2], argv
[3]);
1813 if (res
< 0 || (size_t) res
>= sizeof(cmd
))
1815 cmd
[sizeof(cmd
) - 1] = '\0';
1816 return wpa_ctrl_command(ctrl
, cmd
);
1820 static int wpa_cli_cmd_p2p_service_update(struct wpa_ctrl
*ctrl
, int argc
,
1823 return wpa_ctrl_command(ctrl
, "P2P_SERVICE_UPDATE");
1827 static int wpa_cli_cmd_p2p_serv_disc_external(struct wpa_ctrl
*ctrl
,
1828 int argc
, char *argv
[])
1834 printf("Invalid P2P_SERV_DISC_EXTERNAL command: needs one "
1835 "argument (external processing: 0/1)\n");
1839 res
= os_snprintf(cmd
, sizeof(cmd
), "P2P_SERV_DISC_EXTERNAL %s",
1841 if (res
< 0 || (size_t) res
>= sizeof(cmd
))
1843 cmd
[sizeof(cmd
) - 1] = '\0';
1844 return wpa_ctrl_command(ctrl
, cmd
);
1848 static int wpa_cli_cmd_p2p_service_flush(struct wpa_ctrl
*ctrl
, int argc
,
1851 return wpa_ctrl_command(ctrl
, "P2P_SERVICE_FLUSH");
1855 static int wpa_cli_cmd_p2p_service_add(struct wpa_ctrl
*ctrl
, int argc
,
1861 if (argc
!= 3 && argc
!= 4) {
1862 printf("Invalid P2P_SERVICE_ADD command: needs three or four "
1868 res
= os_snprintf(cmd
, sizeof(cmd
),
1869 "P2P_SERVICE_ADD %s %s %s %s",
1870 argv
[0], argv
[1], argv
[2], argv
[3]);
1872 res
= os_snprintf(cmd
, sizeof(cmd
),
1873 "P2P_SERVICE_ADD %s %s %s",
1874 argv
[0], argv
[1], argv
[2]);
1875 if (res
< 0 || (size_t) res
>= sizeof(cmd
))
1877 cmd
[sizeof(cmd
) - 1] = '\0';
1878 return wpa_ctrl_command(ctrl
, cmd
);
1882 static int wpa_cli_cmd_p2p_service_del(struct wpa_ctrl
*ctrl
, int argc
,
1888 if (argc
!= 2 && argc
!= 3) {
1889 printf("Invalid P2P_SERVICE_DEL command: needs two or three "
1895 res
= os_snprintf(cmd
, sizeof(cmd
),
1896 "P2P_SERVICE_DEL %s %s %s",
1897 argv
[0], argv
[1], argv
[2]);
1899 res
= os_snprintf(cmd
, sizeof(cmd
),
1900 "P2P_SERVICE_DEL %s %s",
1902 if (res
< 0 || (size_t) res
>= sizeof(cmd
))
1904 cmd
[sizeof(cmd
) - 1] = '\0';
1905 return wpa_ctrl_command(ctrl
, cmd
);
1909 static int wpa_cli_cmd_p2p_reject(struct wpa_ctrl
*ctrl
,
1910 int argc
, char *argv
[])
1916 printf("Invalid P2P_REJECT command: needs one argument "
1917 "(peer address)\n");
1921 res
= os_snprintf(cmd
, sizeof(cmd
), "P2P_REJECT %s", argv
[0]);
1922 if (res
< 0 || (size_t) res
>= sizeof(cmd
))
1924 cmd
[sizeof(cmd
) - 1] = '\0';
1925 return wpa_ctrl_command(ctrl
, cmd
);
1929 static int wpa_cli_cmd_p2p_invite(struct wpa_ctrl
*ctrl
,
1930 int argc
, char *argv
[])
1936 printf("Invalid P2P_INVITE command: needs at least one "
1942 res
= os_snprintf(cmd
, sizeof(cmd
), "P2P_INVITE %s %s %s",
1943 argv
[0], argv
[1], argv
[2]);
1945 res
= os_snprintf(cmd
, sizeof(cmd
), "P2P_INVITE %s %s",
1948 res
= os_snprintf(cmd
, sizeof(cmd
), "P2P_INVITE %s", argv
[0]);
1949 if (res
< 0 || (size_t) res
>= sizeof(cmd
))
1951 cmd
[sizeof(cmd
) - 1] = '\0';
1952 return wpa_ctrl_command(ctrl
, cmd
);
1956 static int wpa_cli_cmd_p2p_peer(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
1960 printf("Invalid 'p2p_peer' command - exactly one argument, "
1961 "P2P peer device address, is required.\n");
1964 os_snprintf(buf
, sizeof(buf
), "P2P_PEER %s", argv
[0]);
1965 return wpa_ctrl_command(ctrl
, buf
);
1969 static int wpa_ctrl_command_p2p_peer(struct wpa_ctrl
*ctrl
, char *cmd
,
1970 char *addr
, size_t addr_len
,
1973 char buf
[4096], *pos
;
1977 if (ctrl_conn
== NULL
)
1979 len
= sizeof(buf
) - 1;
1980 ret
= wpa_ctrl_request(ctrl
, cmd
, strlen(cmd
), buf
, &len
,
1983 printf("'%s' command timed out.\n", cmd
);
1985 } else if (ret
< 0) {
1986 printf("'%s' command failed.\n", cmd
);
1991 if (memcmp(buf
, "FAIL", 4) == 0)
1995 while (*pos
!= '\0' && *pos
!= '\n')
1998 os_strlcpy(addr
, buf
, addr_len
);
1999 if (!discovered
|| os_strstr(pos
, "[PROBE_REQ_ONLY]") == NULL
)
2000 printf("%s\n", addr
);
2005 static int wpa_cli_cmd_p2p_peers(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2007 char addr
[32], cmd
[64];
2010 discovered
= argc
> 0 && os_strcmp(argv
[0], "discovered") == 0;
2012 if (wpa_ctrl_command_p2p_peer(ctrl
, "P2P_PEER FIRST",
2013 addr
, sizeof(addr
), discovered
))
2016 os_snprintf(cmd
, sizeof(cmd
), "P2P_PEER NEXT-%s", addr
);
2017 } while (wpa_ctrl_command_p2p_peer(ctrl
, cmd
, addr
, sizeof(addr
),
2024 static int wpa_cli_cmd_p2p_set(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2030 printf("Invalid P2P_SET command: needs two arguments (field, "
2035 res
= os_snprintf(cmd
, sizeof(cmd
), "P2P_SET %s %s", argv
[0], argv
[1]);
2036 if (res
< 0 || (size_t) res
>= sizeof(cmd
))
2038 cmd
[sizeof(cmd
) - 1] = '\0';
2039 return wpa_ctrl_command(ctrl
, cmd
);
2043 static int wpa_cli_cmd_p2p_flush(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2045 return wpa_ctrl_command(ctrl
, "P2P_FLUSH");
2049 static int wpa_cli_cmd_p2p_cancel(struct wpa_ctrl
*ctrl
, int argc
,
2052 return wpa_ctrl_command(ctrl
, "P2P_CANCEL");
2056 static int wpa_cli_cmd_p2p_presence_req(struct wpa_ctrl
*ctrl
, int argc
,
2062 if (argc
!= 0 && argc
!= 2 && argc
!= 4) {
2063 printf("Invalid P2P_PRESENCE_REQ command: needs two arguments "
2064 "(preferred duration, interval; in microsecods).\n"
2065 "Optional second pair can be used to provide "
2066 "acceptable values.\n");
2071 res
= os_snprintf(cmd
, sizeof(cmd
),
2072 "P2P_PRESENCE_REQ %s %s %s %s",
2073 argv
[0], argv
[1], argv
[2], argv
[3]);
2075 res
= os_snprintf(cmd
, sizeof(cmd
), "P2P_PRESENCE_REQ %s %s",
2078 res
= os_snprintf(cmd
, sizeof(cmd
), "P2P_PRESENCE_REQ");
2079 if (res
< 0 || (size_t) res
>= sizeof(cmd
))
2081 cmd
[sizeof(cmd
) - 1] = '\0';
2082 return wpa_ctrl_command(ctrl
, cmd
);
2086 static int wpa_cli_cmd_p2p_ext_listen(struct wpa_ctrl
*ctrl
, int argc
,
2092 if (argc
!= 0 && argc
!= 2) {
2093 printf("Invalid P2P_EXT_LISTEN command: needs two arguments "
2094 "(availability period, availability interval; in "
2096 "Extended Listen Timing can be cancelled with this "
2097 "command when used without parameters.\n");
2102 res
= os_snprintf(cmd
, sizeof(cmd
), "P2P_EXT_LISTEN %s %s",
2105 res
= os_snprintf(cmd
, sizeof(cmd
), "P2P_EXT_LISTEN");
2106 if (res
< 0 || (size_t) res
>= sizeof(cmd
))
2108 cmd
[sizeof(cmd
) - 1] = '\0';
2109 return wpa_ctrl_command(ctrl
, cmd
);
2112 #endif /* CONFIG_P2P */
2115 static int wpa_cli_cmd_sta_autoconnect(struct wpa_ctrl
*ctrl
, int argc
,
2122 printf("Invalid STA_AUTOCONNECT command: needs one argument "
2123 "(0/1 = disable/enable automatic reconnection)\n");
2126 res
= os_snprintf(cmd
, sizeof(cmd
), "STA_AUTOCONNECT %s", argv
[0]);
2127 if (res
< 0 || (size_t) res
>= sizeof(cmd
) - 1) {
2128 printf("Too long STA_AUTOCONNECT command.\n");
2131 return wpa_ctrl_command(ctrl
, cmd
);
2135 enum wpa_cli_cmd_flags
{
2136 cli_cmd_flag_none
= 0x00,
2137 cli_cmd_flag_sensitive
= 0x01
2140 struct wpa_cli_cmd
{
2142 int (*handler
)(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[]);
2143 enum wpa_cli_cmd_flags flags
;
2147 static struct wpa_cli_cmd wpa_cli_commands
[] = {
2148 { "status", wpa_cli_cmd_status
,
2150 "[verbose] = get current WPA/EAPOL/EAP status" },
2151 { "ping", wpa_cli_cmd_ping
,
2153 "= pings wpa_supplicant" },
2154 { "note", wpa_cli_cmd_note
,
2156 "<text> = add a note to wpa_supplicant debug log" },
2157 { "mib", wpa_cli_cmd_mib
,
2159 "= get MIB variables (dot1x, dot11)" },
2160 { "help", wpa_cli_cmd_help
,
2162 "= show this usage help" },
2163 { "interface", wpa_cli_cmd_interface
,
2165 "[ifname] = show interfaces/select interface" },
2166 { "level", wpa_cli_cmd_level
,
2168 "<debug level> = change debug level" },
2169 { "license", wpa_cli_cmd_license
,
2171 "= show full wpa_cli license" },
2172 { "quit", wpa_cli_cmd_quit
,
2175 { "set", wpa_cli_cmd_set
,
2177 "= set variables (shows list of variables when run without "
2179 { "get", wpa_cli_cmd_get
,
2181 "<name> = get information" },
2182 { "logon", wpa_cli_cmd_logon
,
2184 "= IEEE 802.1X EAPOL state machine logon" },
2185 { "logoff", wpa_cli_cmd_logoff
,
2187 "= IEEE 802.1X EAPOL state machine logoff" },
2188 { "pmksa", wpa_cli_cmd_pmksa
,
2190 "= show PMKSA cache" },
2191 { "reassociate", wpa_cli_cmd_reassociate
,
2193 "= force reassociation" },
2194 { "preauthenticate", wpa_cli_cmd_preauthenticate
,
2196 "<BSSID> = force preauthentication" },
2197 { "identity", wpa_cli_cmd_identity
,
2199 "<network id> <identity> = configure identity for an SSID" },
2200 { "password", wpa_cli_cmd_password
,
2201 cli_cmd_flag_sensitive
,
2202 "<network id> <password> = configure password for an SSID" },
2203 { "new_password", wpa_cli_cmd_new_password
,
2204 cli_cmd_flag_sensitive
,
2205 "<network id> <password> = change password for an SSID" },
2206 { "pin", wpa_cli_cmd_pin
,
2207 cli_cmd_flag_sensitive
,
2208 "<network id> <pin> = configure pin for an SSID" },
2209 { "otp", wpa_cli_cmd_otp
,
2210 cli_cmd_flag_sensitive
,
2211 "<network id> <password> = configure one-time-password for an SSID"
2213 { "passphrase", wpa_cli_cmd_passphrase
,
2214 cli_cmd_flag_sensitive
,
2215 "<network id> <passphrase> = configure private key passphrase\n"
2217 { "bssid", wpa_cli_cmd_bssid
,
2219 "<network id> <BSSID> = set preferred BSSID for an SSID" },
2220 { "list_networks", wpa_cli_cmd_list_networks
,
2222 "= list configured networks" },
2223 { "select_network", wpa_cli_cmd_select_network
,
2225 "<network id> = select a network (disable others)" },
2226 { "enable_network", wpa_cli_cmd_enable_network
,
2228 "<network id> = enable a network" },
2229 { "disable_network", wpa_cli_cmd_disable_network
,
2231 "<network id> = disable a network" },
2232 { "add_network", wpa_cli_cmd_add_network
,
2234 "= add a network" },
2235 { "remove_network", wpa_cli_cmd_remove_network
,
2237 "<network id> = remove a network" },
2238 { "set_network", wpa_cli_cmd_set_network
,
2239 cli_cmd_flag_sensitive
,
2240 "<network id> <variable> <value> = set network variables (shows\n"
2241 " list of variables when run without arguments)" },
2242 { "get_network", wpa_cli_cmd_get_network
,
2244 "<network id> <variable> = get network variables" },
2245 { "save_config", wpa_cli_cmd_save_config
,
2247 "= save the current configuration" },
2248 { "disconnect", wpa_cli_cmd_disconnect
,
2250 "= disconnect and wait for reassociate/reconnect command before\n"
2252 { "reconnect", wpa_cli_cmd_reconnect
,
2254 "= like reassociate, but only takes effect if already disconnected"
2256 { "scan", wpa_cli_cmd_scan
,
2258 "= request new BSS scan" },
2259 { "scan_results", wpa_cli_cmd_scan_results
,
2261 "= get latest scan results" },
2262 { "bss", wpa_cli_cmd_bss
,
2264 "<<idx> | <bssid>> = get detailed scan result info" },
2265 { "get_capability", wpa_cli_cmd_get_capability
,
2267 "<eap/pairwise/group/key_mgmt/proto/auth_alg> = get capabilies" },
2268 { "reconfigure", wpa_cli_cmd_reconfigure
,
2270 "= force wpa_supplicant to re-read its configuration file" },
2271 { "terminate", wpa_cli_cmd_terminate
,
2273 "= terminate wpa_supplicant" },
2274 { "interface_add", wpa_cli_cmd_interface_add
,
2276 "<ifname> <confname> <driver> <ctrl_interface> <driver_param>\n"
2277 " <bridge_name> = adds new interface, all parameters but <ifname>\n"
2279 { "interface_remove", wpa_cli_cmd_interface_remove
,
2281 "<ifname> = removes the interface" },
2282 { "interface_list", wpa_cli_cmd_interface_list
,
2284 "= list available interfaces" },
2285 { "ap_scan", wpa_cli_cmd_ap_scan
,
2287 "<value> = set ap_scan parameter" },
2288 { "stkstart", wpa_cli_cmd_stkstart
,
2290 "<addr> = request STK negotiation with <addr>" },
2291 { "ft_ds", wpa_cli_cmd_ft_ds
,
2293 "<addr> = request over-the-DS FT with <addr>" },
2294 { "wps_pbc", wpa_cli_cmd_wps_pbc
,
2296 "[BSSID] = start Wi-Fi Protected Setup: Push Button Configuration" },
2297 { "wps_pin", wpa_cli_cmd_wps_pin
,
2298 cli_cmd_flag_sensitive
,
2299 "<BSSID> [PIN] = start WPS PIN method (returns PIN, if not "
2301 { "wps_check_pin", wpa_cli_cmd_wps_check_pin
,
2302 cli_cmd_flag_sensitive
,
2303 "<PIN> = verify PIN checksum" },
2304 { "wps_cancel", wpa_cli_cmd_wps_cancel
, cli_cmd_flag_none
,
2305 "Cancels the pending WPS operation" },
2306 #ifdef CONFIG_WPS_OOB
2307 { "wps_oob", wpa_cli_cmd_wps_oob
,
2308 cli_cmd_flag_sensitive
,
2309 "<DEV_TYPE> <PATH> <METHOD> [DEV_NAME] = start WPS OOB" },
2310 #endif /* CONFIG_WPS_OOB */
2311 { "wps_reg", wpa_cli_cmd_wps_reg
,
2312 cli_cmd_flag_sensitive
,
2313 "<BSSID> <AP PIN> = start WPS Registrar to configure an AP" },
2314 { "wps_er_start", wpa_cli_cmd_wps_er_start
,
2316 "[IP address] = start Wi-Fi Protected Setup External Registrar" },
2317 { "wps_er_stop", wpa_cli_cmd_wps_er_stop
,
2319 "= stop Wi-Fi Protected Setup External Registrar" },
2320 { "wps_er_pin", wpa_cli_cmd_wps_er_pin
,
2321 cli_cmd_flag_sensitive
,
2322 "<UUID> <PIN> = add an Enrollee PIN to External Registrar" },
2323 { "wps_er_pbc", wpa_cli_cmd_wps_er_pbc
,
2325 "<UUID> = accept an Enrollee PBC using External Registrar" },
2326 { "wps_er_learn", wpa_cli_cmd_wps_er_learn
,
2327 cli_cmd_flag_sensitive
,
2328 "<UUID> <PIN> = learn AP configuration" },
2329 { "wps_er_set_config", wpa_cli_cmd_wps_er_set_config
,
2331 "<UUID> <network id> = set AP configuration for enrolling" },
2332 { "wps_er_config", wpa_cli_cmd_wps_er_config
,
2333 cli_cmd_flag_sensitive
,
2334 "<UUID> <PIN> <SSID> <auth> <encr> <key> = configure AP" },
2335 { "ibss_rsn", wpa_cli_cmd_ibss_rsn
,
2337 "<addr> = request RSN authentication with <addr> in IBSS" },
2339 { "sta", wpa_cli_cmd_sta
,
2341 "<addr> = get information about an associated station (AP)" },
2342 { "all_sta", wpa_cli_cmd_all_sta
,
2344 "= get information about all associated stations (AP)" },
2345 #endif /* CONFIG_AP */
2346 { "suspend", wpa_cli_cmd_suspend
, cli_cmd_flag_none
,
2347 "= notification of suspend/hibernate" },
2348 { "resume", wpa_cli_cmd_resume
, cli_cmd_flag_none
,
2349 "= notification of resume/thaw" },
2350 { "drop_sa", wpa_cli_cmd_drop_sa
, cli_cmd_flag_none
,
2351 "= drop SA without deauth/disassoc (test command)" },
2352 { "roam", wpa_cli_cmd_roam
,
2354 "<addr> = roam to the specified BSS" },
2356 { "p2p_find", wpa_cli_cmd_p2p_find
, cli_cmd_flag_none
,
2357 "[timeout] [type=*] = find P2P Devices for up-to timeout seconds" },
2358 { "p2p_stop_find", wpa_cli_cmd_p2p_stop_find
, cli_cmd_flag_none
,
2359 "= stop P2P Devices search" },
2360 { "p2p_connect", wpa_cli_cmd_p2p_connect
, cli_cmd_flag_none
,
2361 "<addr> <\"pbc\"|PIN> = connect to a P2P Devices" },
2362 { "p2p_listen", wpa_cli_cmd_p2p_listen
, cli_cmd_flag_none
,
2363 "[timeout] = listen for P2P Devices for up-to timeout seconds" },
2364 { "p2p_group_remove", wpa_cli_cmd_p2p_group_remove
, cli_cmd_flag_none
,
2365 "<ifname> = remote P2P group interface (terminate group if GO)" },
2366 { "p2p_group_add", wpa_cli_cmd_p2p_group_add
, cli_cmd_flag_none
,
2367 "= add a new P2P group (local end as GO)" },
2368 { "p2p_prov_disc", wpa_cli_cmd_p2p_prov_disc
, cli_cmd_flag_none
,
2369 "<addr> <method> = request provisioning discovery" },
2370 { "p2p_get_passphrase", wpa_cli_cmd_p2p_get_passphrase
,
2372 "= get the passphrase for a group (GO only)" },
2373 { "p2p_serv_disc_req", wpa_cli_cmd_p2p_serv_disc_req
,
2375 "<addr> <TLVs> = schedule service discovery request" },
2376 { "p2p_serv_disc_cancel_req", wpa_cli_cmd_p2p_serv_disc_cancel_req
,
2378 "<id> = cancel pending service discovery request" },
2379 { "p2p_serv_disc_resp", wpa_cli_cmd_p2p_serv_disc_resp
,
2381 "<freq> <addr> <dialog token> <TLVs> = service discovery response" },
2382 { "p2p_service_update", wpa_cli_cmd_p2p_service_update
,
2384 "= indicate change in local services" },
2385 { "p2p_serv_disc_external", wpa_cli_cmd_p2p_serv_disc_external
,
2387 "<external> = set external processing of service discovery" },
2388 { "p2p_service_flush", wpa_cli_cmd_p2p_service_flush
,
2390 "= remove all stored service entries" },
2391 { "p2p_service_add", wpa_cli_cmd_p2p_service_add
,
2393 "<bonjour|upnp> <query|version> <response|service> = add a local "
2395 { "p2p_service_del", wpa_cli_cmd_p2p_service_del
,
2397 "<bonjour|upnp> <query|version> [|service] = remove a local "
2399 { "p2p_reject", wpa_cli_cmd_p2p_reject
,
2401 "<addr> = reject connection attempts from a specific peer" },
2402 { "p2p_invite", wpa_cli_cmd_p2p_invite
,
2404 "<cmd> [peer=addr] = invite peer" },
2405 { "p2p_peers", wpa_cli_cmd_p2p_peers
, cli_cmd_flag_none
,
2406 "[discovered] = list known (optionally, only fully discovered) P2P "
2408 { "p2p_peer", wpa_cli_cmd_p2p_peer
, cli_cmd_flag_none
,
2409 "<address> = show information about known P2P peer" },
2410 { "p2p_set", wpa_cli_cmd_p2p_set
, cli_cmd_flag_none
,
2411 "<field> <value> = set a P2P parameter" },
2412 { "p2p_flush", wpa_cli_cmd_p2p_flush
, cli_cmd_flag_none
,
2413 "= flush P2P state" },
2414 { "p2p_cancel", wpa_cli_cmd_p2p_cancel
, cli_cmd_flag_none
,
2415 "= cancel P2P group formation" },
2416 { "p2p_presence_req", wpa_cli_cmd_p2p_presence_req
, cli_cmd_flag_none
,
2417 "[<duration> <interval>] [<duration> <interval>] = request GO "
2419 { "p2p_ext_listen", wpa_cli_cmd_p2p_ext_listen
, cli_cmd_flag_none
,
2420 "[<period> <interval>] = set extended listen timing" },
2421 #endif /* CONFIG_P2P */
2422 { "sta_autoconnect", wpa_cli_cmd_sta_autoconnect
, cli_cmd_flag_none
,
2423 "<0/1> = disable/enable automatic reconnection" },
2424 { NULL
, NULL
, cli_cmd_flag_none
, NULL
}
2429 * Prints command usage, lines are padded with the specified string.
2431 static void print_cmd_help(struct wpa_cli_cmd
*cmd
, const char *pad
)
2436 printf("%s%s ", pad
, cmd
->cmd
);
2437 for (n
= 0; (c
= cmd
->usage
[n
]); n
++) {
2446 static void print_help(void)
2449 printf("commands:\n");
2450 for (n
= 0; wpa_cli_commands
[n
].cmd
; n
++)
2451 print_cmd_help(&wpa_cli_commands
[n
], " ");
2455 #ifdef CONFIG_READLINE
2456 static int cmd_has_sensitive_data(const char *cmd
)
2458 const char *c
, *delim
;
2462 delim
= os_strchr(cmd
, ' ');
2466 len
= os_strlen(cmd
);
2468 for (n
= 0; (c
= wpa_cli_commands
[n
].cmd
); n
++) {
2469 if (os_strncasecmp(cmd
, c
, len
) == 0 && len
== os_strlen(c
))
2470 return (wpa_cli_commands
[n
].flags
&
2471 cli_cmd_flag_sensitive
);
2475 #endif /* CONFIG_READLINE */
2478 static int wpa_request(struct wpa_ctrl
*ctrl
, int argc
, char *argv
[])
2480 struct wpa_cli_cmd
*cmd
, *match
= NULL
;
2485 cmd
= wpa_cli_commands
;
2487 if (os_strncasecmp(cmd
->cmd
, argv
[0], os_strlen(argv
[0])) == 0)
2490 if (os_strcasecmp(cmd
->cmd
, argv
[0]) == 0) {
2491 /* we have an exact match */
2501 printf("Ambiguous command '%s'; possible commands:", argv
[0]);
2502 cmd
= wpa_cli_commands
;
2504 if (os_strncasecmp(cmd
->cmd
, argv
[0],
2505 os_strlen(argv
[0])) == 0) {
2506 printf(" %s", cmd
->cmd
);
2512 } else if (count
== 0) {
2513 printf("Unknown command '%s'\n", argv
[0]);
2516 ret
= match
->handler(ctrl
, argc
- 1, &argv
[1]);
2523 static int str_match(const char *a
, const char *b
)
2525 return os_strncmp(a
, b
, os_strlen(b
)) == 0;
2529 static int wpa_cli_exec(const char *program
, const char *arg1
,
2537 len
= os_strlen(program
) + os_strlen(arg1
) + os_strlen(arg2
) + 3;
2538 cmd
= os_malloc(len
);
2541 res
= os_snprintf(cmd
, len
, "%s %s %s", program
, arg1
, arg2
);
2542 if (res
< 0 || (size_t) res
>= len
) {
2546 cmd
[len
- 1] = '\0';
2548 if (system(cmd
) < 0)
2550 #endif /* _WIN32_WCE */
2557 static void wpa_cli_action_process(const char *msg
)
2560 char *copy
= NULL
, *id
, *pos2
;
2565 pos
= os_strchr(pos
, '>');
2572 if (str_match(pos
, WPA_EVENT_CONNECTED
)) {
2574 os_unsetenv("WPA_ID");
2575 os_unsetenv("WPA_ID_STR");
2576 os_unsetenv("WPA_CTRL_DIR");
2578 pos
= os_strstr(pos
, "[id=");
2580 copy
= os_strdup(pos
+ 4);
2584 while (*pos2
&& *pos2
!= ' ')
2588 os_setenv("WPA_ID", id
, 1);
2589 while (*pos2
&& *pos2
!= '=')
2594 while (*pos2
&& *pos2
!= ']')
2597 os_setenv("WPA_ID_STR", id
, 1);
2601 os_setenv("WPA_CTRL_DIR", ctrl_iface_dir
, 1);
2603 if (!wpa_cli_connected
|| new_id
!= wpa_cli_last_id
) {
2604 wpa_cli_connected
= 1;
2605 wpa_cli_last_id
= new_id
;
2606 wpa_cli_exec(action_file
, ctrl_ifname
, "CONNECTED");
2608 } else if (str_match(pos
, WPA_EVENT_DISCONNECTED
)) {
2609 if (wpa_cli_connected
) {
2610 wpa_cli_connected
= 0;
2611 wpa_cli_exec(action_file
, ctrl_ifname
, "DISCONNECTED");
2613 } else if (str_match(pos
, P2P_EVENT_GROUP_STARTED
)) {
2614 wpa_cli_exec(action_file
, ctrl_ifname
, pos
);
2615 } else if (str_match(pos
, P2P_EVENT_GROUP_REMOVED
)) {
2616 wpa_cli_exec(action_file
, ctrl_ifname
, pos
);
2617 } else if (str_match(pos
, P2P_EVENT_CROSS_CONNECT_ENABLE
)) {
2618 wpa_cli_exec(action_file
, ctrl_ifname
, pos
);
2619 } else if (str_match(pos
, P2P_EVENT_CROSS_CONNECT_DISABLE
)) {
2620 wpa_cli_exec(action_file
, ctrl_ifname
, pos
);
2621 } else if (str_match(pos
, WPS_EVENT_SUCCESS
)) {
2622 wpa_cli_exec(action_file
, ctrl_ifname
, pos
);
2623 } else if (str_match(pos
, WPS_EVENT_FAIL
)) {
2624 wpa_cli_exec(action_file
, ctrl_ifname
, pos
);
2625 } else if (str_match(pos
, WPA_EVENT_TERMINATING
)) {
2626 printf("wpa_supplicant is terminating - stop monitoring\n");
2632 #ifndef CONFIG_ANSI_C_EXTRA
2633 static void wpa_cli_action_cb(char *msg
, size_t len
)
2635 wpa_cli_action_process(msg
);
2637 #endif /* CONFIG_ANSI_C_EXTRA */
2640 static void wpa_cli_reconnect(void)
2642 wpa_cli_close_connection();
2643 wpa_cli_open_connection(ctrl_ifname
, 1);
2647 static void wpa_cli_recv_pending(struct wpa_ctrl
*ctrl
, int action_monitor
)
2649 if (ctrl_conn
== NULL
) {
2650 wpa_cli_reconnect();
2653 while (wpa_ctrl_pending(ctrl
) > 0) {
2655 size_t len
= sizeof(buf
) - 1;
2656 if (wpa_ctrl_recv(ctrl
, buf
, &len
) == 0) {
2659 wpa_cli_action_process(buf
);
2661 if (wpa_cli_show_event(buf
)) {
2662 printf("\r%s\n", buf
);
2667 printf("Could not read pending message.\n");
2672 if (wpa_ctrl_pending(ctrl
) < 0) {
2673 printf("Connection to wpa_supplicant lost - trying to "
2675 wpa_cli_reconnect();
2681 static int tokenize_cmd(char *cmd
, char *argv
[])
2694 if (argc
== max_args
)
2697 char *pos2
= os_strrchr(pos
, '"');
2701 while (*pos
!= '\0' && *pos
!= ' ')
2711 static void trunc_nl(char *str
)
2714 while (*pos
!= '\0') {
2724 static void wpa_cli_ping(void *eloop_ctx
, void *timeout_ctx
)
2726 if (ctrl_conn
&& _wpa_ctrl_command(ctrl_conn
, "PING", 0)) {
2727 printf("Connection to wpa_supplicant lost - trying to "
2729 wpa_cli_close_connection();
2732 wpa_cli_reconnect();
2733 eloop_register_timeout(ping_interval
, 0, wpa_cli_ping
, NULL
, NULL
);
2737 static void wpa_cli_eloop_terminate(int sig
, void *signal_ctx
)
2743 static void wpa_cli_mon_receive(int sock
, void *eloop_ctx
, void *sock_ctx
)
2745 wpa_cli_recv_pending(mon_conn
, 0);
2749 #ifdef CONFIG_READLINE
2751 static char * wpa_cli_cmd_gen(const char *text
, int state
)
2758 len
= os_strlen(text
);
2761 while ((cmd
= wpa_cli_commands
[i
].cmd
)) {
2763 if (os_strncasecmp(cmd
, text
, len
) == 0)
2771 static char * wpa_cli_dummy_gen(const char *text
, int state
)
2775 for (i
= 0; wpa_cli_commands
[i
].cmd
; i
++) {
2776 const char *cmd
= wpa_cli_commands
[i
].cmd
;
2777 size_t len
= os_strlen(cmd
);
2778 if (os_strncasecmp(rl_line_buffer
, cmd
, len
) == 0 &&
2779 rl_line_buffer
[len
] == ' ') {
2780 printf("\n%s\n", wpa_cli_commands
[i
].usage
);
2786 rl_attempted_completion_over
= 1;
2791 static char * wpa_cli_status_gen(const char *text
, int state
)
2801 len
= os_strlen(text
);
2804 while ((t
= options
[i
])) {
2806 if (os_strncasecmp(t
, text
, len
) == 0)
2810 rl_attempted_completion_over
= 1;
2815 static char ** wpa_cli_completion(const char *text
, int start
, int end
)
2817 char * (*func
)(const char *text
, int state
);
2820 func
= wpa_cli_cmd_gen
;
2821 else if (os_strncasecmp(rl_line_buffer
, "status ", 7) == 0)
2822 func
= wpa_cli_status_gen
;
2824 func
= wpa_cli_dummy_gen
;
2825 return rl_completion_matches(text
, func
);
2829 static void wpa_cli_read_char(int sock
, void *eloop_ctx
, void *sock_ctx
)
2831 rl_callback_read_char();
2835 static void readline_cmd_handler(char *cmd
)
2838 char *argv
[max_args
];
2842 while (next_history())
2844 h
= previous_history();
2845 if (h
== NULL
|| os_strcmp(cmd
, h
->line
) != 0)
2854 argc
= tokenize_cmd(cmd
, argv
);
2856 wpa_request(ctrl_conn
, argc
, argv
);
2860 static void wpa_cli_interactive(void)
2862 char *home
, *hfile
= NULL
;
2864 printf("\nInteractive mode\n\n");
2866 rl_attempted_completion_function
= wpa_cli_completion
;
2867 home
= getenv("HOME");
2869 const char *fname
= ".wpa_cli_history";
2870 int hfile_len
= os_strlen(home
) + 1 + os_strlen(fname
) + 1;
2871 hfile
= os_malloc(hfile_len
);
2874 res
= os_snprintf(hfile
, hfile_len
, "%s/%s", home
,
2876 if (res
>= 0 && res
< hfile_len
) {
2877 hfile
[hfile_len
- 1] = '\0';
2878 read_history(hfile
);
2879 stifle_history(100);
2884 eloop_register_signal_terminate(wpa_cli_eloop_terminate
, NULL
);
2885 eloop_register_read_sock(STDIN_FILENO
, wpa_cli_read_char
, NULL
, NULL
);
2886 eloop_register_timeout(ping_interval
, 0, wpa_cli_ping
, NULL
, NULL
);
2888 rl_callback_handler_install("> ", readline_cmd_handler
);
2892 rl_callback_handler_remove();
2894 eloop_unregister_read_sock(STDIN_FILENO
);
2895 eloop_cancel_timeout(wpa_cli_ping
, NULL
, NULL
);
2896 wpa_cli_close_connection();
2899 /* Save command history, excluding lines that may contain
2903 while ((h
= current_history())) {
2905 while (*p
== ' ' || *p
== '\t')
2907 if (cmd_has_sensitive_data(p
)) {
2908 h
= remove_history(where_history());
2918 write_history(hfile
);
2923 #else /* CONFIG_READLINE */
2925 #ifdef CONFIG_WPA_CLI_EDIT
2927 static void wpa_cli_clear_line(void)
2931 for (i
= 0; i
< cmdbuf_len
+ 2; i
++)
2936 static void move_start(void)
2943 static void move_end(void)
2945 cmdbuf_pos
= cmdbuf_len
;
2950 static void move_left(void)
2952 if (cmdbuf_pos
> 0) {
2959 static void move_right(void)
2961 if (cmdbuf_pos
< cmdbuf_len
) {
2968 static void move_word_left(void)
2970 while (cmdbuf_pos
> 0 && cmdbuf
[cmdbuf_pos
- 1] == ' ')
2972 while (cmdbuf_pos
> 0 && cmdbuf
[cmdbuf_pos
- 1] != ' ')
2978 static void move_word_right(void)
2980 while (cmdbuf_pos
< cmdbuf_len
&& cmdbuf
[cmdbuf_pos
] == ' ')
2982 while (cmdbuf_pos
< cmdbuf_len
&& cmdbuf
[cmdbuf_pos
] != ' ')
2988 static void delete_left(void)
2990 if (cmdbuf_pos
== 0)
2993 wpa_cli_clear_line();
2994 os_memmove(cmdbuf
+ cmdbuf_pos
- 1, cmdbuf
+ cmdbuf_pos
,
2995 cmdbuf_len
- cmdbuf_pos
);
3002 static void delete_current(void)
3004 if (cmdbuf_pos
== cmdbuf_len
)
3007 wpa_cli_clear_line();
3008 os_memmove(cmdbuf
+ cmdbuf_pos
, cmdbuf
+ cmdbuf_pos
+ 1,
3009 cmdbuf_len
- cmdbuf_pos
);
3015 static void delete_word(void)
3017 wpa_cli_clear_line();
3018 while (cmdbuf_len
> 0 && cmdbuf
[cmdbuf_len
- 1] == ' ')
3020 while (cmdbuf_len
> 0 && cmdbuf
[cmdbuf_len
- 1] != ' ')
3026 static void clear_left(void)
3028 if (cmdbuf_pos
== 0)
3031 wpa_cli_clear_line();
3032 os_memmove(cmdbuf
, cmdbuf
+ cmdbuf_pos
, cmdbuf_len
- cmdbuf_pos
);
3033 cmdbuf_len
-= cmdbuf_pos
;
3039 static void clear_right(void)
3041 if (cmdbuf_pos
== cmdbuf_len
)
3044 wpa_cli_clear_line();
3045 cmdbuf_len
= cmdbuf_pos
;
3050 static void history_add(const char *str
)
3057 if (history_pos
== 0)
3058 prev
= CMD_HISTORY_LEN
- 1;
3060 prev
= history_pos
- 1;
3061 if (os_strcmp(history_buf
[prev
], str
) == 0)
3064 os_strlcpy(history_buf
[history_pos
], str
, CMD_BUF_LEN
);
3066 if (history_pos
== CMD_HISTORY_LEN
)
3068 history_current
= history_pos
;
3072 static void history_prev(void)
3076 if (history_current
== (history_pos
+ 1) % CMD_HISTORY_LEN
)
3079 pos
= history_current
;
3081 if (history_current
== history_pos
&& cmdbuf_len
) {
3082 cmdbuf
[cmdbuf_len
] = '\0';
3083 history_add(cmdbuf
);
3089 pos
= CMD_HISTORY_LEN
- 1;
3090 if (history_buf
[pos
][0] == '\0')
3092 history_current
= pos
;
3094 wpa_cli_clear_line();
3095 cmdbuf_len
= cmdbuf_pos
= os_strlen(history_buf
[history_current
]);
3096 os_memcpy(cmdbuf
, history_buf
[history_current
], cmdbuf_len
);
3101 static void history_next(void)
3103 if (history_current
== history_pos
)
3107 if (history_current
== CMD_HISTORY_LEN
)
3108 history_current
= 0;
3110 wpa_cli_clear_line();
3111 cmdbuf_len
= cmdbuf_pos
= os_strlen(history_buf
[history_current
]);
3112 os_memcpy(cmdbuf
, history_buf
[history_current
], cmdbuf_len
);
3117 static void history_debug_dump(void)
3120 wpa_cli_clear_line();
3122 p
= (history_pos
+ 1) % CMD_HISTORY_LEN
;
3124 printf("[%d%s%s] %s\n",
3125 p
, p
== history_current
? "C" : "",
3126 p
== history_pos
? "P" : "", history_buf
[p
]);
3127 if (p
== history_pos
)
3130 if (p
== CMD_HISTORY_LEN
)
3137 static void insert_char(int c
)
3139 if (c
< 32 && c
> 255) {
3140 printf("[%d]\n", c
);
3144 if (cmdbuf_len
>= (int) sizeof(cmdbuf
) - 1)
3146 if (cmdbuf_len
== cmdbuf_pos
) {
3147 cmdbuf
[cmdbuf_pos
++] = c
;
3152 os_memmove(cmdbuf
+ cmdbuf_pos
+ 1, cmdbuf
+ cmdbuf_pos
,
3153 cmdbuf_len
- cmdbuf_pos
);
3154 cmdbuf
[cmdbuf_pos
++] = c
;
3161 static void process_cmd(void)
3163 char *argv
[max_args
];
3166 if (cmdbuf_len
== 0) {
3172 cmdbuf
[cmdbuf_len
] = '\0';
3173 history_add(cmdbuf
);
3177 argc
= tokenize_cmd(cmdbuf
, argv
);
3179 wpa_request(ctrl_conn
, argc
, argv
);
3185 static void wpa_cli_read_char(int sock
, void *eloop_ctx
, void *sock_ctx
)
3188 unsigned char buf
[1];
3190 static int esc
= -1;
3191 static char esc_buf
[6];
3193 res
= read(sock
, buf
, 1);
3204 printf("{ESC%s}[0]\n", esc_buf
);
3209 esc_buf
[esc
] = '\0';
3215 if (esc
== 2 && esc_buf
[0] == '[' && c
>= 'A' && c
<= 'Z') {
3220 case 'B': /* down */
3223 case 'C': /* right */
3226 case 'D': /* left */
3232 case 'H': /* home */
3236 printf("{ESC%s}[1]\n", esc_buf
);
3244 if (esc
> 1 && esc_buf
[0] == '[') {
3245 if ((c
>= '0' && c
<= '9') || c
== ';')
3248 if (esc_buf
[1] == '1' && esc_buf
[2] == ';' &&
3249 esc_buf
[3] == '5') {
3250 switch (esc_buf
[4]) {
3251 case 'A': /* Ctrl-Up */
3252 case 'B': /* Ctrl-Down */
3254 case 'C': /* Ctrl-Right */
3257 case 'D': /* Ctrl-Left */
3261 printf("{ESC%s}[2]\n", esc_buf
);
3271 switch (atoi(&esc_buf
[1])) {
3272 case 2: /* Insert */
3274 case 3: /* Delete */
3277 case 5: /* Page Up */
3278 case 6: /* Page Down */
3289 printf("{ESC%s}[3]\n", esc_buf
);
3295 printf("{ESC%s}[4]\n", esc_buf
);
3304 if (esc
> 1 && esc_buf
[0] == 'O') {
3305 switch (esc_buf
[1]) {
3307 history_debug_dump();
3314 printf("{ESC%s}[5]\n", esc_buf
);
3323 printf("{ESC%s}[6]\n", esc_buf
);
3334 if (cmdbuf_len
> 0) {
3344 case 8: /* ^H = BS */
3347 case 9: /* ^I = TAB */
3363 /* TODO: search history */
3383 #else /* CONFIG_WPA_CLI_EDIT */
3385 static void wpa_cli_read_char(int sock
, void *eloop_ctx
, void *sock_ctx
)
3387 char *argv
[max_args
];
3390 unsigned char buf
[1];
3393 res
= read(sock
, buf
, 1);
3402 if (c
== '\r' || c
== '\n') {
3403 cmdbuf
[cmdbuf_pos
] = '\0';
3406 argc
= tokenize_cmd(cmdbuf
, argv
);
3408 wpa_request(ctrl_conn
, argc
, argv
);
3414 if (c
>= 32 && c
<= 255) {
3415 if (cmdbuf_pos
< (int) sizeof(cmdbuf
) - 1) {
3416 cmdbuf
[cmdbuf_pos
++] = c
;
3421 #endif /* CONFIG_WPA_CLI_EDIT */
3424 static void wpa_cli_interactive(void)
3426 #ifdef CONFIG_WPA_CLI_EDIT
3427 struct termios prevt
, newt
;
3428 #endif /* CONFIG_WPA_CLI_EDIT */
3430 printf("\nInteractive mode\n\n");
3434 eloop_register_signal_terminate(wpa_cli_eloop_terminate
, NULL
);
3435 eloop_register_read_sock(STDIN_FILENO
, wpa_cli_read_char
, NULL
, NULL
);
3436 eloop_register_timeout(ping_interval
, 0, wpa_cli_ping
, NULL
, NULL
);
3438 #ifdef CONFIG_WPA_CLI_EDIT
3439 os_memset(history_buf
, 0, sizeof(history_buf
));
3441 tcgetattr(STDIN_FILENO
, &prevt
);
3443 newt
.c_lflag
&= ~(ICANON
| ECHO
);
3444 tcsetattr(STDIN_FILENO
, TCSANOW
, &newt
);
3445 #endif /* CONFIG_WPA_CLI_EDIT */
3452 eloop_unregister_read_sock(STDIN_FILENO
);
3453 eloop_cancel_timeout(wpa_cli_ping
, NULL
, NULL
);
3454 wpa_cli_close_connection();
3456 #ifdef CONFIG_WPA_CLI_EDIT
3457 tcsetattr(STDIN_FILENO
, TCSANOW
, &prevt
);
3458 #endif /* CONFIG_WPA_CLI_EDIT */
3461 #endif /* CONFIG_READLINE */
3464 static void wpa_cli_action(struct wpa_ctrl
*ctrl
)
3466 #ifdef CONFIG_ANSI_C_EXTRA
3467 /* TODO: ANSI C version(?) */
3468 printf("Action processing not supported in ANSI C build.\n");
3469 #else /* CONFIG_ANSI_C_EXTRA */
3473 char buf
[256]; /* note: large enough to fit in unsolicited messages */
3476 fd
= wpa_ctrl_get_fd(ctrl
);
3478 while (!wpa_cli_quit
) {
3481 tv
.tv_sec
= ping_interval
;
3483 res
= select(fd
+ 1, &rfds
, NULL
, NULL
, &tv
);
3484 if (res
< 0 && errno
!= EINTR
) {
3489 if (FD_ISSET(fd
, &rfds
))
3490 wpa_cli_recv_pending(ctrl
, 1);
3492 /* verify that connection is still working */
3493 len
= sizeof(buf
) - 1;
3494 if (wpa_ctrl_request(ctrl
, "PING", 4, buf
, &len
,
3495 wpa_cli_action_cb
) < 0 ||
3496 len
< 4 || os_memcmp(buf
, "PONG", 4) != 0) {
3497 printf("wpa_supplicant did not reply to PING "
3498 "command - exiting\n");
3503 #endif /* CONFIG_ANSI_C_EXTRA */
3507 static void wpa_cli_cleanup(void)
3509 wpa_cli_close_connection();
3511 os_daemonize_terminate(pid_file
);
3513 os_program_deinit();
3516 static void wpa_cli_terminate(int sig
)
3523 static char * wpa_cli_get_default_ifname(void)
3525 char *ifname
= NULL
;
3527 #ifdef CONFIG_CTRL_IFACE_UNIX
3528 struct dirent
*dent
;
3529 DIR *dir
= opendir(ctrl_iface_dir
);
3532 while ((dent
= readdir(dir
))) {
3533 #ifdef _DIRENT_HAVE_D_TYPE
3535 * Skip the file if it is not a socket. Also accept
3536 * DT_UNKNOWN (0) in case the C library or underlying
3537 * file system does not support d_type.
3539 if (dent
->d_type
!= DT_SOCK
&& dent
->d_type
!= DT_UNKNOWN
)
3541 #endif /* _DIRENT_HAVE_D_TYPE */
3542 if (os_strcmp(dent
->d_name
, ".") == 0 ||
3543 os_strcmp(dent
->d_name
, "..") == 0)
3545 printf("Selected interface '%s'\n", dent
->d_name
);
3546 ifname
= os_strdup(dent
->d_name
);
3550 #endif /* CONFIG_CTRL_IFACE_UNIX */
3552 #ifdef CONFIG_CTRL_IFACE_NAMED_PIPE
3553 char buf
[2048], *pos
;
3555 struct wpa_ctrl
*ctrl
;
3558 ctrl
= wpa_ctrl_open(NULL
);
3562 len
= sizeof(buf
) - 1;
3563 ret
= wpa_ctrl_request(ctrl
, "INTERFACES", 10, buf
, &len
, NULL
);
3566 pos
= os_strchr(buf
, '\n');
3569 ifname
= os_strdup(buf
);
3571 wpa_ctrl_close(ctrl
);
3572 #endif /* CONFIG_CTRL_IFACE_NAMED_PIPE */
3578 int main(int argc
, char *argv
[])
3580 int warning_displayed
= 0;
3584 const char *global
= NULL
;
3586 if (os_program_init())
3590 c
= getopt(argc
, argv
, "a:Bg:G:hi:p:P:v");
3595 action_file
= optarg
;
3604 ping_interval
= atoi(optarg
);
3610 printf("%s\n", wpa_cli_version
);
3613 os_free(ctrl_ifname
);
3614 ctrl_ifname
= os_strdup(optarg
);
3617 ctrl_iface_dir
= optarg
;
3628 interactive
= (argc
== optind
) && (action_file
== NULL
);
3631 printf("%s\n\n%s\n\n", wpa_cli_version
, wpa_cli_license
);
3637 #ifdef CONFIG_CTRL_IFACE_NAMED_PIPE
3638 ctrl_conn
= wpa_ctrl_open(NULL
);
3639 #else /* CONFIG_CTRL_IFACE_NAMED_PIPE */
3640 ctrl_conn
= wpa_ctrl_open(global
);
3641 #endif /* CONFIG_CTRL_IFACE_NAMED_PIPE */
3642 if (ctrl_conn
== NULL
) {
3643 perror("Failed to connect to wpa_supplicant - "
3650 signal(SIGINT
, wpa_cli_terminate
);
3651 signal(SIGTERM
, wpa_cli_terminate
);
3652 #endif /* _WIN32_WCE */
3654 if (ctrl_ifname
== NULL
)
3655 ctrl_ifname
= wpa_cli_get_default_ifname();
3659 if (wpa_cli_open_connection(ctrl_ifname
, 1) == 0) {
3660 if (warning_displayed
)
3661 printf("Connection established.\n");
3665 if (!warning_displayed
) {
3666 printf("Could not connect to wpa_supplicant - "
3668 warning_displayed
= 1;
3675 wpa_cli_open_connection(ctrl_ifname
, 0) < 0) {
3676 perror("Failed to connect to wpa_supplicant - "
3682 if (wpa_ctrl_attach(ctrl_conn
) == 0) {
3683 wpa_cli_attached
= 1;
3685 printf("Warning: Failed to attach to "
3686 "wpa_supplicant.\n");
3692 if (daemonize
&& os_daemonize(pid_file
))
3696 wpa_cli_interactive();
3697 else if (action_file
)
3698 wpa_cli_action(ctrl_conn
);
3700 ret
= wpa_request(ctrl_conn
, argc
- optind
, &argv
[optind
]);
3702 os_free(ctrl_ifname
);
3709 #else /* CONFIG_CTRL_IFACE */
3710 int main(int argc
, char *argv
[])
3712 printf("CONFIG_CTRL_IFACE not defined - wpa_cli disabled\n");
3715 #endif /* CONFIG_CTRL_IFACE */