2 * WPA Supplicant - command line interface for wpa_supplicant daemon
3 * Copyright (c) 2004-2009, 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.
17 #ifdef CONFIG_CTRL_IFACE
19 #ifdef CONFIG_CTRL_IFACE_UNIX
21 #endif /* CONFIG_CTRL_IFACE_UNIX */
22 #ifdef CONFIG_READLINE
23 #include <readline/readline.h>
24 #include <readline/history.h>
25 #endif /* CONFIG_READLINE */
32 static const char *wpa_cli_version =
33 "wpa_cli v" VERSION_STR "\n"
34 "Copyright (c) 2004-2009, Jouni Malinen <j@w1.fi> and contributors";
37 static const char *wpa_cli_license =
38 "This program is free software. You can distribute it and/or modify it\n"
39 "under the terms of the GNU General Public License version 2.\n"
41 "Alternatively, this software may be distributed under the terms of the\n"
42 "BSD license. See README and COPYING for more details.\n";
44 static const char *wpa_cli_full_license =
45 "This program is free software; you can redistribute it and/or modify\n"
46 "it under the terms of the GNU General Public License version 2 as\n"
47 "published by the Free Software Foundation.\n"
49 "This program is distributed in the hope that it will be useful,\n"
50 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
51 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
52 "GNU General Public License for more details.\n"
54 "You should have received a copy of the GNU General Public License\n"
55 "along with this program; if not, write to the Free Software\n"
56 "Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\n"
58 "Alternatively, this software may be distributed under the terms of the\n"
61 "Redistribution and use in source and binary forms, with or without\n"
62 "modification, are permitted provided that the following conditions are\n"
65 "1. Redistributions of source code must retain the above copyright\n"
66 " notice, this list of conditions and the following disclaimer.\n"
68 "2. Redistributions in binary form must reproduce the above copyright\n"
69 " notice, this list of conditions and the following disclaimer in the\n"
70 " documentation and/or other materials provided with the distribution.\n"
72 "3. Neither the name(s) of the above-listed copyright holder(s) nor the\n"
73 " names of its contributors may be used to endorse or promote products\n"
74 " derived from this software without specific prior written permission.\n"
76 "THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n"
77 "\"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n"
78 "LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n"
79 "A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n"
80 "OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n"
81 "SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n"
82 "LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n"
83 "DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n"
84 "THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n"
85 "(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n"
86 "OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n"
89 static struct wpa_ctrl *ctrl_conn;
90 static int wpa_cli_quit = 0;
91 static int wpa_cli_attached = 0;
92 static int wpa_cli_connected = 0;
93 static int wpa_cli_last_id = 0;
94 static const char *ctrl_iface_dir = "/var/run/wpa_supplicant";
95 static char *ctrl_ifname = NULL;
96 static const char *pid_file = NULL;
97 static const char *action_file = NULL;
98 static int ping_interval = 5;
101 static void print_help();
104 static void usage(void)
106 printf("wpa_cli [-p<path to ctrl sockets>] [-i<ifname>] [-hvB] "
107 "[-a<action file>] \\\n"
108 " [-P<pid file>] [-g<global ctrl>] [-G<ping interval>] "
110 " -h = help (show this usage text)\n"
111 " -v = shown version information\n"
112 " -a = run in daemon mode executing the action file based on "
115 " -B = run a daemon in the background\n"
116 " default path: /var/run/wpa_supplicant\n"
117 " default interface: first interface found in socket path\n");
122 static struct wpa_ctrl * wpa_cli_open_connection(const char *ifname)
124 #if defined(CONFIG_CTRL_IFACE_UDP) || defined(CONFIG_CTRL_IFACE_NAMED_PIPE)
125 ctrl_conn = wpa_ctrl_open(ifname);
127 #else /* CONFIG_CTRL_IFACE_UDP || CONFIG_CTRL_IFACE_NAMED_PIPE */
134 flen = os_strlen(ctrl_iface_dir) + os_strlen(ifname) + 2;
135 cfile = os_malloc(flen);
138 res = os_snprintf(cfile, flen, "%s/%s", ctrl_iface_dir, ifname);
139 if (res < 0 || res >= flen) {
144 ctrl_conn = wpa_ctrl_open(cfile);
147 #endif /* CONFIG_CTRL_IFACE_UDP || CONFIG_CTRL_IFACE_NAMED_PIPE */
151 static void wpa_cli_close_connection(void)
153 if (ctrl_conn == NULL)
156 if (wpa_cli_attached) {
157 wpa_ctrl_detach(ctrl_conn);
158 wpa_cli_attached = 0;
160 wpa_ctrl_close(ctrl_conn);
165 static void wpa_cli_msg_cb(char *msg, size_t len)
171 static int _wpa_ctrl_command(struct wpa_ctrl *ctrl, char *cmd, int print)
177 if (ctrl_conn == NULL) {
178 printf("Not connected to wpa_supplicant - command dropped.\n");
181 len = sizeof(buf) - 1;
182 ret = wpa_ctrl_request(ctrl, cmd, os_strlen(cmd), buf, &len,
185 printf("'%s' command timed out.\n", cmd);
187 } else if (ret < 0) {
188 printf("'%s' command failed.\n", cmd);
199 static int wpa_ctrl_command(struct wpa_ctrl *ctrl, char *cmd)
201 return _wpa_ctrl_command(ctrl, cmd, 1);
205 static int wpa_cli_cmd_status(struct wpa_ctrl *ctrl, int argc, char *argv[])
207 int verbose = argc > 0 && os_strcmp(argv[0], "verbose") == 0;
208 return wpa_ctrl_command(ctrl, verbose ? "STATUS-VERBOSE" : "STATUS");
212 static int wpa_cli_cmd_ping(struct wpa_ctrl *ctrl, int argc, char *argv[])
214 return wpa_ctrl_command(ctrl, "PING");
218 static int wpa_cli_cmd_mib(struct wpa_ctrl *ctrl, int argc, char *argv[])
220 return wpa_ctrl_command(ctrl, "MIB");
224 static int wpa_cli_cmd_pmksa(struct wpa_ctrl *ctrl, int argc, char *argv[])
226 return wpa_ctrl_command(ctrl, "PMKSA");
230 static int wpa_cli_cmd_help(struct wpa_ctrl *ctrl, int argc, char *argv[])
237 static int wpa_cli_cmd_license(struct wpa_ctrl *ctrl, int argc, char *argv[])
239 printf("%s\n\n%s\n", wpa_cli_version, wpa_cli_full_license);
244 static int wpa_cli_cmd_quit(struct wpa_ctrl *ctrl, int argc, char *argv[])
251 static void wpa_cli_show_variables(void)
253 printf("set variables:\n"
254 " EAPOL::heldPeriod (EAPOL state machine held period, "
256 " EAPOL::authPeriod (EAPOL state machine authentication "
257 "period, in seconds)\n"
258 " EAPOL::startPeriod (EAPOL state machine start period, in "
260 " EAPOL::maxStart (EAPOL state machine maximum start "
262 printf(" dot11RSNAConfigPMKLifetime (WPA/WPA2 PMK lifetime in "
264 " dot11RSNAConfigPMKReauthThreshold (WPA/WPA2 reauthentication"
265 " threshold\n\tpercentage)\n"
266 " dot11RSNAConfigSATimeout (WPA/WPA2 timeout for completing "
267 "security\n\tassociation in seconds)\n");
271 static int wpa_cli_cmd_set(struct wpa_ctrl *ctrl, int argc, char *argv[])
277 wpa_cli_show_variables();
282 printf("Invalid SET command: needs two arguments (variable "
283 "name and value)\n");
287 res = os_snprintf(cmd, sizeof(cmd), "SET %s %s", argv[0], argv[1]);
288 if (res < 0 || (size_t) res >= sizeof(cmd) - 1) {
289 printf("Too long SET command.\n");
292 return wpa_ctrl_command(ctrl, cmd);
296 static int wpa_cli_cmd_logoff(struct wpa_ctrl *ctrl, int argc, char *argv[])
298 return wpa_ctrl_command(ctrl, "LOGOFF");
302 static int wpa_cli_cmd_logon(struct wpa_ctrl *ctrl, int argc, char *argv[])
304 return wpa_ctrl_command(ctrl, "LOGON");
308 static int wpa_cli_cmd_reassociate(struct wpa_ctrl *ctrl, int argc,
311 return wpa_ctrl_command(ctrl, "REASSOCIATE");
315 static int wpa_cli_cmd_preauthenticate(struct wpa_ctrl *ctrl, int argc,
322 printf("Invalid PREAUTH command: needs one argument "
327 res = os_snprintf(cmd, sizeof(cmd), "PREAUTH %s", argv[0]);
328 if (res < 0 || (size_t) res >= sizeof(cmd) - 1) {
329 printf("Too long PREAUTH command.\n");
332 return wpa_ctrl_command(ctrl, cmd);
336 static int wpa_cli_cmd_ap_scan(struct wpa_ctrl *ctrl, int argc, char *argv[])
342 printf("Invalid AP_SCAN command: needs one argument (ap_scan "
346 res = os_snprintf(cmd, sizeof(cmd), "AP_SCAN %s", argv[0]);
347 if (res < 0 || (size_t) res >= sizeof(cmd) - 1) {
348 printf("Too long AP_SCAN command.\n");
351 return wpa_ctrl_command(ctrl, cmd);
355 static int wpa_cli_cmd_stkstart(struct wpa_ctrl *ctrl, int argc,
362 printf("Invalid STKSTART command: needs one argument "
363 "(Peer STA MAC address)\n");
367 res = os_snprintf(cmd, sizeof(cmd), "STKSTART %s", argv[0]);
368 if (res < 0 || (size_t) res >= sizeof(cmd) - 1) {
369 printf("Too long STKSTART command.\n");
372 return wpa_ctrl_command(ctrl, cmd);
376 static int wpa_cli_cmd_ft_ds(struct wpa_ctrl *ctrl, int argc, char *argv[])
382 printf("Invalid FT_DS command: needs one argument "
383 "(Target AP MAC address)\n");
387 res = os_snprintf(cmd, sizeof(cmd), "FT_DS %s", argv[0]);
388 if (res < 0 || (size_t) res >= sizeof(cmd) - 1) {
389 printf("Too long FT_DS command.\n");
392 return wpa_ctrl_command(ctrl, cmd);
396 static int wpa_cli_cmd_wps_pbc(struct wpa_ctrl *ctrl, int argc, char *argv[])
403 return wpa_ctrl_command(ctrl, "WPS_PBC");
407 res = os_snprintf(cmd, sizeof(cmd), "WPS_PBC %s", argv[0]);
408 if (res < 0 || (size_t) res >= sizeof(cmd) - 1) {
409 printf("Too long WPS_PBC command.\n");
412 return wpa_ctrl_command(ctrl, cmd);
416 static int wpa_cli_cmd_wps_pin(struct wpa_ctrl *ctrl, int argc, char *argv[])
422 printf("Invalid WPS_PIN command: need one or two arguments:\n"
423 "- BSSID: use 'any' to select any\n"
424 "- PIN: optional, used only with devices that have no "
430 /* Use dynamically generated PIN (returned as reply) */
431 res = os_snprintf(cmd, sizeof(cmd), "WPS_PIN %s", argv[0]);
432 if (res < 0 || (size_t) res >= sizeof(cmd) - 1) {
433 printf("Too long WPS_PIN command.\n");
436 return wpa_ctrl_command(ctrl, cmd);
439 /* Use hardcoded PIN from a label */
440 res = os_snprintf(cmd, sizeof(cmd), "WPS_PIN %s %s", argv[0], argv[1]);
441 if (res < 0 || (size_t) res >= sizeof(cmd) - 1) {
442 printf("Too long WPS_PIN command.\n");
445 return wpa_ctrl_command(ctrl, cmd);
449 static int wpa_cli_cmd_wps_reg(struct wpa_ctrl *ctrl, int argc, char *argv[])
455 printf("Invalid WPS_REG command: need two arguments:\n"
456 "- BSSID: use 'any' to select any\n"
461 res = os_snprintf(cmd, sizeof(cmd), "WPS_REG %s %s", argv[0], argv[1]);
462 if (res < 0 || (size_t) res >= sizeof(cmd) - 1) {
463 printf("Too long WPS_REG command.\n");
466 return wpa_ctrl_command(ctrl, cmd);
470 static int wpa_cli_cmd_level(struct wpa_ctrl *ctrl, int argc, char *argv[])
476 printf("Invalid LEVEL command: needs one argument (debug "
480 res = os_snprintf(cmd, sizeof(cmd), "LEVEL %s", argv[0]);
481 if (res < 0 || (size_t) res >= sizeof(cmd) - 1) {
482 printf("Too long LEVEL command.\n");
485 return wpa_ctrl_command(ctrl, cmd);
489 static int wpa_cli_cmd_identity(struct wpa_ctrl *ctrl, int argc, char *argv[])
491 char cmd[256], *pos, *end;
495 printf("Invalid IDENTITY command: needs two arguments "
496 "(network id and identity)\n");
500 end = cmd + sizeof(cmd);
502 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "IDENTITY-%s:%s",
504 if (ret < 0 || ret >= end - pos) {
505 printf("Too long IDENTITY command.\n");
509 for (i = 2; i < argc; i++) {
510 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
511 if (ret < 0 || ret >= end - pos) {
512 printf("Too long IDENTITY command.\n");
518 return wpa_ctrl_command(ctrl, cmd);
522 static int wpa_cli_cmd_password(struct wpa_ctrl *ctrl, int argc, char *argv[])
524 char cmd[256], *pos, *end;
528 printf("Invalid PASSWORD command: needs two arguments "
529 "(network id and password)\n");
533 end = cmd + sizeof(cmd);
535 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "PASSWORD-%s:%s",
537 if (ret < 0 || ret >= end - pos) {
538 printf("Too long PASSWORD command.\n");
542 for (i = 2; i < argc; i++) {
543 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
544 if (ret < 0 || ret >= end - pos) {
545 printf("Too long PASSWORD command.\n");
551 return wpa_ctrl_command(ctrl, cmd);
555 static int wpa_cli_cmd_new_password(struct wpa_ctrl *ctrl, int argc,
558 char cmd[256], *pos, *end;
562 printf("Invalid NEW_PASSWORD command: needs two arguments "
563 "(network id and password)\n");
567 end = cmd + sizeof(cmd);
569 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "NEW_PASSWORD-%s:%s",
571 if (ret < 0 || ret >= end - pos) {
572 printf("Too long NEW_PASSWORD command.\n");
576 for (i = 2; i < argc; i++) {
577 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
578 if (ret < 0 || ret >= end - pos) {
579 printf("Too long NEW_PASSWORD command.\n");
585 return wpa_ctrl_command(ctrl, cmd);
589 static int wpa_cli_cmd_pin(struct wpa_ctrl *ctrl, int argc, char *argv[])
591 char cmd[256], *pos, *end;
595 printf("Invalid PIN command: needs two arguments "
596 "(network id and pin)\n");
600 end = cmd + sizeof(cmd);
602 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "PIN-%s:%s",
604 if (ret < 0 || ret >= end - pos) {
605 printf("Too long PIN command.\n");
609 for (i = 2; i < argc; i++) {
610 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
611 if (ret < 0 || ret >= end - pos) {
612 printf("Too long PIN command.\n");
617 return wpa_ctrl_command(ctrl, cmd);
621 static int wpa_cli_cmd_otp(struct wpa_ctrl *ctrl, int argc, char *argv[])
623 char cmd[256], *pos, *end;
627 printf("Invalid OTP command: needs two arguments (network "
628 "id and password)\n");
632 end = cmd + sizeof(cmd);
634 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "OTP-%s:%s",
636 if (ret < 0 || ret >= end - pos) {
637 printf("Too long OTP command.\n");
641 for (i = 2; i < argc; i++) {
642 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
643 if (ret < 0 || ret >= end - pos) {
644 printf("Too long OTP command.\n");
650 return wpa_ctrl_command(ctrl, cmd);
654 static int wpa_cli_cmd_passphrase(struct wpa_ctrl *ctrl, int argc,
657 char cmd[256], *pos, *end;
661 printf("Invalid PASSPHRASE command: needs two arguments "
662 "(network id and passphrase)\n");
666 end = cmd + sizeof(cmd);
668 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "PASSPHRASE-%s:%s",
670 if (ret < 0 || ret >= end - pos) {
671 printf("Too long PASSPHRASE command.\n");
675 for (i = 2; i < argc; i++) {
676 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
677 if (ret < 0 || ret >= end - pos) {
678 printf("Too long PASSPHRASE command.\n");
684 return wpa_ctrl_command(ctrl, cmd);
688 static int wpa_cli_cmd_bssid(struct wpa_ctrl *ctrl, int argc, char *argv[])
690 char cmd[256], *pos, *end;
694 printf("Invalid BSSID command: needs two arguments (network "
699 end = cmd + sizeof(cmd);
701 ret = os_snprintf(pos, end - pos, "BSSID");
702 if (ret < 0 || ret >= end - pos) {
703 printf("Too long BSSID command.\n");
707 for (i = 0; i < argc; i++) {
708 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
709 if (ret < 0 || ret >= end - pos) {
710 printf("Too long BSSID command.\n");
716 return wpa_ctrl_command(ctrl, cmd);
720 static int wpa_cli_cmd_list_networks(struct wpa_ctrl *ctrl, int argc,
723 return wpa_ctrl_command(ctrl, "LIST_NETWORKS");
727 static int wpa_cli_cmd_select_network(struct wpa_ctrl *ctrl, int argc,
734 printf("Invalid SELECT_NETWORK command: needs one argument "
739 res = os_snprintf(cmd, sizeof(cmd), "SELECT_NETWORK %s", argv[0]);
740 if (res < 0 || (size_t) res >= sizeof(cmd))
742 cmd[sizeof(cmd) - 1] = '\0';
744 return wpa_ctrl_command(ctrl, cmd);
748 static int wpa_cli_cmd_enable_network(struct wpa_ctrl *ctrl, int argc,
755 printf("Invalid ENABLE_NETWORK command: needs one argument "
760 res = os_snprintf(cmd, sizeof(cmd), "ENABLE_NETWORK %s", argv[0]);
761 if (res < 0 || (size_t) res >= sizeof(cmd))
763 cmd[sizeof(cmd) - 1] = '\0';
765 return wpa_ctrl_command(ctrl, cmd);
769 static int wpa_cli_cmd_disable_network(struct wpa_ctrl *ctrl, int argc,
776 printf("Invalid DISABLE_NETWORK command: needs one argument "
781 res = os_snprintf(cmd, sizeof(cmd), "DISABLE_NETWORK %s", argv[0]);
782 if (res < 0 || (size_t) res >= sizeof(cmd))
784 cmd[sizeof(cmd) - 1] = '\0';
786 return wpa_ctrl_command(ctrl, cmd);
790 static int wpa_cli_cmd_add_network(struct wpa_ctrl *ctrl, int argc,
793 return wpa_ctrl_command(ctrl, "ADD_NETWORK");
797 static int wpa_cli_cmd_remove_network(struct wpa_ctrl *ctrl, int argc,
804 printf("Invalid REMOVE_NETWORK command: needs one argument "
809 res = os_snprintf(cmd, sizeof(cmd), "REMOVE_NETWORK %s", argv[0]);
810 if (res < 0 || (size_t) res >= sizeof(cmd))
812 cmd[sizeof(cmd) - 1] = '\0';
814 return wpa_ctrl_command(ctrl, cmd);
818 static void wpa_cli_show_network_variables(void)
820 printf("set_network variables:\n"
821 " ssid (network name, SSID)\n"
822 " psk (WPA passphrase or pre-shared key)\n"
823 " key_mgmt (key management protocol)\n"
824 " identity (EAP identity)\n"
825 " password (EAP password)\n"
828 "Note: Values are entered in the same format as the "
829 "configuration file is using,\n"
830 "i.e., strings values need to be inside double quotation "
832 "For example: set_network 1 ssid \"network name\"\n"
834 "Please see wpa_supplicant.conf documentation for full list "
835 "of\navailable variables.\n");
839 static int wpa_cli_cmd_set_network(struct wpa_ctrl *ctrl, int argc,
846 wpa_cli_show_network_variables();
851 printf("Invalid SET_NETWORK command: needs three arguments\n"
852 "(network id, variable name, and value)\n");
856 res = os_snprintf(cmd, sizeof(cmd), "SET_NETWORK %s %s %s",
857 argv[0], argv[1], argv[2]);
858 if (res < 0 || (size_t) res >= sizeof(cmd) - 1) {
859 printf("Too long SET_NETWORK command.\n");
862 return wpa_ctrl_command(ctrl, cmd);
866 static int wpa_cli_cmd_get_network(struct wpa_ctrl *ctrl, int argc,
873 wpa_cli_show_network_variables();
878 printf("Invalid GET_NETWORK command: needs two arguments\n"
879 "(network id and variable name)\n");
883 res = os_snprintf(cmd, sizeof(cmd), "GET_NETWORK %s %s",
885 if (res < 0 || (size_t) res >= sizeof(cmd) - 1) {
886 printf("Too long GET_NETWORK command.\n");
889 return wpa_ctrl_command(ctrl, cmd);
893 static int wpa_cli_cmd_disconnect(struct wpa_ctrl *ctrl, int argc,
896 return wpa_ctrl_command(ctrl, "DISCONNECT");
900 static int wpa_cli_cmd_reconnect(struct wpa_ctrl *ctrl, int argc,
903 return wpa_ctrl_command(ctrl, "RECONNECT");
907 static int wpa_cli_cmd_save_config(struct wpa_ctrl *ctrl, int argc,
910 return wpa_ctrl_command(ctrl, "SAVE_CONFIG");
914 static int wpa_cli_cmd_scan(struct wpa_ctrl *ctrl, int argc, char *argv[])
916 return wpa_ctrl_command(ctrl, "SCAN");
920 static int wpa_cli_cmd_scan_results(struct wpa_ctrl *ctrl, int argc,
923 return wpa_ctrl_command(ctrl, "SCAN_RESULTS");
927 static int wpa_cli_cmd_bss(struct wpa_ctrl *ctrl, int argc, char *argv[])
933 printf("Invalid BSS command: need one argument (index or "
938 res = os_snprintf(cmd, sizeof(cmd), "BSS %s", argv[0]);
939 if (res < 0 || (size_t) res >= sizeof(cmd))
941 cmd[sizeof(cmd) - 1] = '\0';
943 return wpa_ctrl_command(ctrl, cmd);
947 static int wpa_cli_cmd_get_capability(struct wpa_ctrl *ctrl, int argc,
953 if (argc < 1 || argc > 2) {
954 printf("Invalid GET_CAPABILITY command: need either one or "
959 if ((argc == 2) && os_strcmp(argv[1], "strict") != 0) {
960 printf("Invalid GET_CAPABILITY command: second argument, "
961 "if any, must be 'strict'\n");
965 res = os_snprintf(cmd, sizeof(cmd), "GET_CAPABILITY %s%s", argv[0],
966 (argc == 2) ? " strict" : "");
967 if (res < 0 || (size_t) res >= sizeof(cmd))
969 cmd[sizeof(cmd) - 1] = '\0';
971 return wpa_ctrl_command(ctrl, cmd);
975 static int wpa_cli_list_interfaces(struct wpa_ctrl *ctrl)
977 printf("Available interfaces:\n");
978 return wpa_ctrl_command(ctrl, "INTERFACES");
982 static int wpa_cli_cmd_interface(struct wpa_ctrl *ctrl, int argc, char *argv[])
985 wpa_cli_list_interfaces(ctrl);
989 wpa_cli_close_connection();
990 os_free(ctrl_ifname);
991 ctrl_ifname = os_strdup(argv[0]);
993 if (wpa_cli_open_connection(ctrl_ifname)) {
994 printf("Connected to interface '%s.\n", ctrl_ifname);
995 if (wpa_ctrl_attach(ctrl_conn) == 0) {
996 wpa_cli_attached = 1;
998 printf("Warning: Failed to attach to "
999 "wpa_supplicant.\n");
1002 printf("Could not connect to interface '%s' - re-trying\n",
1009 static int wpa_cli_cmd_reconfigure(struct wpa_ctrl *ctrl, int argc,
1012 return wpa_ctrl_command(ctrl, "RECONFIGURE");
1016 static int wpa_cli_cmd_terminate(struct wpa_ctrl *ctrl, int argc,
1019 return wpa_ctrl_command(ctrl, "TERMINATE");
1023 static int wpa_cli_cmd_interface_add(struct wpa_ctrl *ctrl, int argc,
1030 printf("Invalid INTERFACE_ADD command: needs at least one "
1031 "argument (interface name)\n"
1032 "All arguments: ifname confname driver ctrl_interface "
1033 "driver_param bridge_name\n");
1038 * INTERFACE_ADD <ifname>TAB<confname>TAB<driver>TAB<ctrl_interface>TAB
1039 * <driver_param>TAB<bridge_name>
1041 res = os_snprintf(cmd, sizeof(cmd),
1042 "INTERFACE_ADD %s\t%s\t%s\t%s\t%s\t%s",
1044 argc > 1 ? argv[1] : "", argc > 2 ? argv[2] : "",
1045 argc > 3 ? argv[3] : "", argc > 4 ? argv[4] : "",
1046 argc > 5 ? argv[5] : "");
1047 if (res < 0 || (size_t) res >= sizeof(cmd))
1049 cmd[sizeof(cmd) - 1] = '\0';
1050 return wpa_ctrl_command(ctrl, cmd);
1054 static int wpa_cli_cmd_interface_remove(struct wpa_ctrl *ctrl, int argc,
1061 printf("Invalid INTERFACE_REMOVE command: needs one argument "
1062 "(interface name)\n");
1066 res = os_snprintf(cmd, sizeof(cmd), "INTERFACE_REMOVE %s", argv[0]);
1067 if (res < 0 || (size_t) res >= sizeof(cmd))
1069 cmd[sizeof(cmd) - 1] = '\0';
1070 return wpa_ctrl_command(ctrl, cmd);
1074 static int wpa_cli_cmd_interface_list(struct wpa_ctrl *ctrl, int argc,
1077 return wpa_ctrl_command(ctrl, "INTERFACE_LIST");
1081 enum wpa_cli_cmd_flags {
1082 cli_cmd_flag_none = 0x00,
1083 cli_cmd_flag_sensitive = 0x01
1086 struct wpa_cli_cmd {
1088 int (*handler)(struct wpa_ctrl *ctrl, int argc, char *argv[]);
1089 enum wpa_cli_cmd_flags flags;
1093 static struct wpa_cli_cmd wpa_cli_commands[] = {
1094 { "status", wpa_cli_cmd_status,
1096 "[verbose] = get current WPA/EAPOL/EAP status" },
1097 { "ping", wpa_cli_cmd_ping,
1099 "= pings wpa_supplicant" },
1100 { "mib", wpa_cli_cmd_mib,
1102 "= get MIB variables (dot1x, dot11)" },
1103 { "help", wpa_cli_cmd_help,
1105 "= show this usage help" },
1106 { "interface", wpa_cli_cmd_interface,
1108 "[ifname] = show interfaces/select interface" },
1109 { "level", wpa_cli_cmd_level,
1111 "<debug level> = change debug level" },
1112 { "license", wpa_cli_cmd_license,
1114 "= show full wpa_cli license" },
1115 { "quit", wpa_cli_cmd_quit,
1118 { "set", wpa_cli_cmd_set,
1120 "= set variables (shows list of variables when run without "
1122 { "logon", wpa_cli_cmd_logon,
1124 "= IEEE 802.1X EAPOL state machine logon" },
1125 { "logoff", wpa_cli_cmd_logoff,
1127 "= IEEE 802.1X EAPOL state machine logoff" },
1128 { "pmksa", wpa_cli_cmd_pmksa,
1130 "= show PMKSA cache" },
1131 { "reassociate", wpa_cli_cmd_reassociate,
1133 "= force reassociation" },
1134 { "preauthenticate", wpa_cli_cmd_preauthenticate,
1136 "<BSSID> = force preauthentication" },
1137 { "identity", wpa_cli_cmd_identity,
1139 "<network id> <identity> = configure identity for an SSID" },
1140 { "password", wpa_cli_cmd_password,
1141 cli_cmd_flag_sensitive,
1142 "<network id> <password> = configure password for an SSID" },
1143 { "new_password", wpa_cli_cmd_new_password,
1144 cli_cmd_flag_sensitive,
1145 "<network id> <password> = change password for an SSID" },
1146 { "pin", wpa_cli_cmd_pin,
1147 cli_cmd_flag_sensitive,
1148 "<network id> <pin> = configure pin for an SSID" },
1149 { "otp", wpa_cli_cmd_otp,
1150 cli_cmd_flag_sensitive,
1151 "<network id> <password> = configure one-time-password for an SSID"
1153 { "passphrase", wpa_cli_cmd_passphrase,
1154 cli_cmd_flag_sensitive,
1155 "<network id> <passphrase> = configure private key passphrase\n"
1157 { "bssid", wpa_cli_cmd_bssid,
1159 "<network id> <BSSID> = set preferred BSSID for an SSID" },
1160 { "list_networks", wpa_cli_cmd_list_networks,
1162 "= list configured networks" },
1163 { "select_network", wpa_cli_cmd_select_network,
1165 "<network id> = select a network (disable others)" },
1166 { "enable_network", wpa_cli_cmd_enable_network,
1168 "<network id> = enable a network" },
1169 { "disable_network", wpa_cli_cmd_disable_network,
1171 "<network id> = disable a network" },
1172 { "add_network", wpa_cli_cmd_add_network,
1174 "= add a network" },
1175 { "remove_network", wpa_cli_cmd_remove_network,
1177 "<network id> = remove a network" },
1178 { "set_network", wpa_cli_cmd_set_network,
1179 cli_cmd_flag_sensitive,
1180 "<network id> <variable> <value> = set network variables (shows\n"
1181 " list of variables when run without arguments)" },
1182 { "get_network", wpa_cli_cmd_get_network,
1184 "<network id> <variable> = get network variables" },
1185 { "save_config", wpa_cli_cmd_save_config,
1187 "= save the current configuration" },
1188 { "disconnect", wpa_cli_cmd_disconnect,
1190 "= disconnect and wait for reassociate/reconnect command before\n"
1192 { "reconnect", wpa_cli_cmd_reconnect,
1194 "= like reassociate, but only takes effect if already disconnected"
1196 { "scan", wpa_cli_cmd_scan,
1198 "= request new BSS scan" },
1199 { "scan_results", wpa_cli_cmd_scan_results,
1201 "= get latest scan results" },
1202 { "bss", wpa_cli_cmd_bss,
1204 "<<idx> | <bssid>> = get detailed scan result info" },
1205 { "get_capability", wpa_cli_cmd_get_capability,
1207 "<eap/pairwise/group/key_mgmt/proto/auth_alg> = get capabilies" },
1208 { "reconfigure", wpa_cli_cmd_reconfigure,
1210 "= force wpa_supplicant to re-read its configuration file" },
1211 { "terminate", wpa_cli_cmd_terminate,
1213 "= terminate wpa_supplicant" },
1214 { "interface_add", wpa_cli_cmd_interface_add,
1216 "<ifname> <confname> <driver> <ctrl_interface> <driver_param>\n"
1217 " <bridge_name> = adds new interface, all parameters but <ifname>\n"
1219 { "interface_remove", wpa_cli_cmd_interface_remove,
1221 "<ifname> = removes the interface" },
1222 { "interface_list", wpa_cli_cmd_interface_list,
1224 "= list available interfaces" },
1225 { "ap_scan", wpa_cli_cmd_ap_scan,
1227 "<value> = set ap_scan parameter" },
1228 { "stkstart", wpa_cli_cmd_stkstart,
1230 "<addr> = request STK negotiation with <addr>" },
1231 { "ft_ds", wpa_cli_cmd_ft_ds,
1233 "<addr> = request over-the-DS FT with <addr>" },
1234 { "wps_pbc", wpa_cli_cmd_wps_pbc,
1236 "[BSSID] = start Wi-Fi Protected Setup: Push Button Configuration" },
1237 { "wps_pin", wpa_cli_cmd_wps_pin,
1238 cli_cmd_flag_sensitive,
1239 "<BSSID> [PIN] = start WPS PIN method (returns PIN, if not "
1241 { "wps_reg", wpa_cli_cmd_wps_reg,
1242 cli_cmd_flag_sensitive,
1243 "<BSSID> <AP PIN> = start WPS Registrar to configure an AP" },
1244 { NULL, NULL, cli_cmd_flag_none, NULL }
1249 * Prints command usage, lines are padded with the specified string.
1251 static void print_cmd_help(struct wpa_cli_cmd *cmd, const char *pad)
1256 printf("%s%s ", pad, cmd->cmd);
1257 for (n = 0; (c = cmd->usage[n]); n++) {
1266 static void print_help(void)
1269 printf("commands:\n");
1270 for (n = 0; wpa_cli_commands[n].cmd; n++)
1271 print_cmd_help(&wpa_cli_commands[n], " ");
1275 #ifdef CONFIG_READLINE
1276 static int cmd_has_sensitive_data(const char *cmd)
1278 const char *c, *delim;
1282 delim = os_strchr(cmd, ' ');
1286 len = os_strlen(cmd);
1288 for (n = 0; (c = wpa_cli_commands[n].cmd); n++) {
1289 if (os_strncasecmp(cmd, c, len) == 0 && len == os_strlen(c))
1290 return (wpa_cli_commands[n].flags &
1291 cli_cmd_flag_sensitive);
1295 #endif /* CONFIG_READLINE */
1298 static int wpa_request(struct wpa_ctrl *ctrl, int argc, char *argv[])
1300 struct wpa_cli_cmd *cmd, *match = NULL;
1305 cmd = wpa_cli_commands;
1307 if (os_strncasecmp(cmd->cmd, argv[0], os_strlen(argv[0])) == 0)
1310 if (os_strcasecmp(cmd->cmd, argv[0]) == 0) {
1311 /* we have an exact match */
1321 printf("Ambiguous command '%s'; possible commands:", argv[0]);
1322 cmd = wpa_cli_commands;
1324 if (os_strncasecmp(cmd->cmd, argv[0],
1325 os_strlen(argv[0])) == 0) {
1326 printf(" %s", cmd->cmd);
1332 } else if (count == 0) {
1333 printf("Unknown command '%s'\n", argv[0]);
1336 ret = match->handler(ctrl, argc - 1, &argv[1]);
1343 static int str_match(const char *a, const char *b)
1345 return os_strncmp(a, b, os_strlen(b)) == 0;
1349 static int wpa_cli_exec(const char *program, const char *arg1,
1357 len = os_strlen(program) + os_strlen(arg1) + os_strlen(arg2) + 3;
1358 cmd = os_malloc(len);
1361 res = os_snprintf(cmd, len, "%s %s %s", program, arg1, arg2);
1362 if (res < 0 || (size_t) res >= len) {
1366 cmd[len - 1] = '\0';
1368 if (system(cmd) < 0)
1370 #endif /* _WIN32_WCE */
1377 static void wpa_cli_action_process(const char *msg)
1380 char *copy = NULL, *id, *pos2;
1385 pos = os_strchr(pos, '>');
1392 if (str_match(pos, WPA_EVENT_CONNECTED)) {
1394 os_unsetenv("WPA_ID");
1395 os_unsetenv("WPA_ID_STR");
1396 os_unsetenv("WPA_CTRL_DIR");
1398 pos = os_strstr(pos, "[id=");
1400 copy = os_strdup(pos + 4);
1404 while (*pos2 && *pos2 != ' ')
1408 os_setenv("WPA_ID", id, 1);
1409 while (*pos2 && *pos2 != '=')
1414 while (*pos2 && *pos2 != ']')
1417 os_setenv("WPA_ID_STR", id, 1);
1421 os_setenv("WPA_CTRL_DIR", ctrl_iface_dir, 1);
1423 if (!wpa_cli_connected || new_id != wpa_cli_last_id) {
1424 wpa_cli_connected = 1;
1425 wpa_cli_last_id = new_id;
1426 wpa_cli_exec(action_file, ctrl_ifname, "CONNECTED");
1428 } else if (str_match(pos, WPA_EVENT_DISCONNECTED)) {
1429 if (wpa_cli_connected) {
1430 wpa_cli_connected = 0;
1431 wpa_cli_exec(action_file, ctrl_ifname, "DISCONNECTED");
1433 } else if (str_match(pos, WPA_EVENT_TERMINATING)) {
1434 printf("wpa_supplicant is terminating - stop monitoring\n");
1440 #ifndef CONFIG_ANSI_C_EXTRA
1441 static void wpa_cli_action_cb(char *msg, size_t len)
1443 wpa_cli_action_process(msg);
1445 #endif /* CONFIG_ANSI_C_EXTRA */
1448 static void wpa_cli_reconnect(void)
1450 wpa_cli_close_connection();
1451 ctrl_conn = wpa_cli_open_connection(ctrl_ifname);
1453 printf("Connection to wpa_supplicant re-established\n");
1454 if (wpa_ctrl_attach(ctrl_conn) == 0) {
1455 wpa_cli_attached = 1;
1457 printf("Warning: Failed to attach to "
1458 "wpa_supplicant.\n");
1464 static void wpa_cli_recv_pending(struct wpa_ctrl *ctrl, int in_read,
1468 if (ctrl_conn == NULL) {
1469 wpa_cli_reconnect();
1472 while (wpa_ctrl_pending(ctrl) > 0) {
1474 size_t len = sizeof(buf) - 1;
1475 if (wpa_ctrl_recv(ctrl, buf, &len) == 0) {
1478 wpa_cli_action_process(buf);
1480 if (in_read && first)
1483 printf("%s\n", buf);
1486 printf("Could not read pending message.\n");
1491 if (wpa_ctrl_pending(ctrl) < 0) {
1492 printf("Connection to wpa_supplicant lost - trying to "
1494 wpa_cli_reconnect();
1499 #ifdef CONFIG_READLINE
1500 static char * wpa_cli_cmd_gen(const char *text, int state)
1507 len = os_strlen(text);
1510 while ((cmd = wpa_cli_commands[i].cmd)) {
1512 if (os_strncasecmp(cmd, text, len) == 0)
1513 return os_strdup(cmd);
1520 static char * wpa_cli_dummy_gen(const char *text, int state)
1526 static char ** wpa_cli_completion(const char *text, int start, int end)
1528 return rl_completion_matches(text, start == 0 ?
1529 wpa_cli_cmd_gen : wpa_cli_dummy_gen);
1531 #endif /* CONFIG_READLINE */
1534 static void wpa_cli_interactive(void)
1537 char cmdbuf[256], *cmd, *argv[max_args], *pos;
1539 #ifdef CONFIG_READLINE
1540 char *home, *hfile = NULL;
1541 #endif /* CONFIG_READLINE */
1543 printf("\nInteractive mode\n\n");
1545 #ifdef CONFIG_READLINE
1546 rl_attempted_completion_function = wpa_cli_completion;
1547 home = getenv("HOME");
1549 const char *fname = ".wpa_cli_history";
1550 int hfile_len = os_strlen(home) + 1 + os_strlen(fname) + 1;
1551 hfile = os_malloc(hfile_len);
1554 res = os_snprintf(hfile, hfile_len, "%s/%s", home,
1556 if (res >= 0 && res < hfile_len) {
1557 hfile[hfile_len - 1] = '\0';
1558 read_history(hfile);
1559 stifle_history(100);
1563 #endif /* CONFIG_READLINE */
1566 wpa_cli_recv_pending(ctrl_conn, 0, 0);
1567 #ifndef CONFIG_NATIVE_WINDOWS
1568 alarm(ping_interval);
1569 #endif /* CONFIG_NATIVE_WINDOWS */
1570 #ifdef CONFIG_READLINE
1571 cmd = readline("> ");
1574 while (next_history())
1576 h = previous_history();
1577 if (h == NULL || os_strcmp(cmd, h->line) != 0)
1581 #else /* CONFIG_READLINE */
1583 cmd = fgets(cmdbuf, sizeof(cmdbuf), stdin);
1584 #endif /* CONFIG_READLINE */
1585 #ifndef CONFIG_NATIVE_WINDOWS
1587 #endif /* CONFIG_NATIVE_WINDOWS */
1590 wpa_cli_recv_pending(ctrl_conn, 0, 0);
1592 while (*pos != '\0') {
1608 if (argc == max_args)
1611 char *pos2 = os_strrchr(pos, '"');
1615 while (*pos != '\0' && *pos != ' ')
1621 wpa_request(ctrl_conn, argc, argv);
1625 } while (!wpa_cli_quit);
1627 #ifdef CONFIG_READLINE
1629 /* Save command history, excluding lines that may contain
1633 while ((h = current_history())) {
1635 while (*p == ' ' || *p == '\t')
1637 if (cmd_has_sensitive_data(p)) {
1638 h = remove_history(where_history());
1648 write_history(hfile);
1651 #endif /* CONFIG_READLINE */
1655 static void wpa_cli_action(struct wpa_ctrl *ctrl)
1657 #ifdef CONFIG_ANSI_C_EXTRA
1658 /* TODO: ANSI C version(?) */
1659 printf("Action processing not supported in ANSI C build.\n");
1660 #else /* CONFIG_ANSI_C_EXTRA */
1664 char buf[256]; /* note: large enough to fit in unsolicited messages */
1667 fd = wpa_ctrl_get_fd(ctrl);
1669 while (!wpa_cli_quit) {
1672 tv.tv_sec = ping_interval;
1674 res = select(fd + 1, &rfds, NULL, NULL, &tv);
1675 if (res < 0 && errno != EINTR) {
1680 if (FD_ISSET(fd, &rfds))
1681 wpa_cli_recv_pending(ctrl, 0, 1);
1683 /* verify that connection is still working */
1684 len = sizeof(buf) - 1;
1685 if (wpa_ctrl_request(ctrl, "PING", 4, buf, &len,
1686 wpa_cli_action_cb) < 0 ||
1687 len < 4 || os_memcmp(buf, "PONG", 4) != 0) {
1688 printf("wpa_supplicant did not reply to PING "
1689 "command - exiting\n");
1694 #endif /* CONFIG_ANSI_C_EXTRA */
1698 static void wpa_cli_cleanup(void)
1700 wpa_cli_close_connection();
1702 os_daemonize_terminate(pid_file);
1704 os_program_deinit();
1707 static void wpa_cli_terminate(int sig)
1714 #ifndef CONFIG_NATIVE_WINDOWS
1715 static void wpa_cli_alarm(int sig)
1717 if (ctrl_conn && _wpa_ctrl_command(ctrl_conn, "PING", 0)) {
1718 printf("Connection to wpa_supplicant lost - trying to "
1720 wpa_cli_close_connection();
1723 wpa_cli_reconnect();
1725 wpa_cli_recv_pending(ctrl_conn, 1, 0);
1726 alarm(ping_interval);
1728 #endif /* CONFIG_NATIVE_WINDOWS */
1731 static char * wpa_cli_get_default_ifname(void)
1733 char *ifname = NULL;
1735 #ifdef CONFIG_CTRL_IFACE_UNIX
1736 struct dirent *dent;
1737 DIR *dir = opendir(ctrl_iface_dir);
1740 while ((dent = readdir(dir))) {
1741 #ifdef _DIRENT_HAVE_D_TYPE
1743 * Skip the file if it is not a socket. Also accept
1744 * DT_UNKNOWN (0) in case the C library or underlying
1745 * file system does not support d_type.
1747 if (dent->d_type != DT_SOCK && dent->d_type != DT_UNKNOWN)
1749 #endif /* _DIRENT_HAVE_D_TYPE */
1750 if (os_strcmp(dent->d_name, ".") == 0 ||
1751 os_strcmp(dent->d_name, "..") == 0)
1753 printf("Selected interface '%s'\n", dent->d_name);
1754 ifname = os_strdup(dent->d_name);
1758 #endif /* CONFIG_CTRL_IFACE_UNIX */
1760 #ifdef CONFIG_CTRL_IFACE_NAMED_PIPE
1761 char buf[2048], *pos;
1763 struct wpa_ctrl *ctrl;
1766 ctrl = wpa_ctrl_open(NULL);
1770 len = sizeof(buf) - 1;
1771 ret = wpa_ctrl_request(ctrl, "INTERFACES", 10, buf, &len, NULL);
1774 pos = os_strchr(buf, '\n');
1777 ifname = os_strdup(buf);
1779 wpa_ctrl_close(ctrl);
1780 #endif /* CONFIG_CTRL_IFACE_NAMED_PIPE */
1786 int main(int argc, char *argv[])
1789 int warning_displayed = 0;
1793 const char *global = NULL;
1795 if (os_program_init())
1799 c = getopt(argc, argv, "a:Bg:G:hi:p:P:v");
1804 action_file = optarg;
1813 ping_interval = atoi(optarg);
1819 printf("%s\n", wpa_cli_version);
1822 os_free(ctrl_ifname);
1823 ctrl_ifname = os_strdup(optarg);
1826 ctrl_iface_dir = optarg;
1837 interactive = (argc == optind) && (action_file == NULL);
1840 printf("%s\n\n%s\n\n", wpa_cli_version, wpa_cli_license);
1843 #ifdef CONFIG_CTRL_IFACE_NAMED_PIPE
1844 ctrl_conn = wpa_ctrl_open(NULL);
1845 #else /* CONFIG_CTRL_IFACE_NAMED_PIPE */
1846 ctrl_conn = wpa_ctrl_open(global);
1847 #endif /* CONFIG_CTRL_IFACE_NAMED_PIPE */
1848 if (ctrl_conn == NULL) {
1849 perror("Failed to connect to wpa_supplicant - "
1856 if (ctrl_ifname == NULL)
1857 ctrl_ifname = wpa_cli_get_default_ifname();
1858 ctrl_conn = wpa_cli_open_connection(ctrl_ifname);
1860 if (warning_displayed)
1861 printf("Connection established.\n");
1866 perror("Failed to connect to wpa_supplicant - "
1871 if (!warning_displayed) {
1872 printf("Could not connect to wpa_supplicant - "
1874 warning_displayed = 1;
1881 signal(SIGINT, wpa_cli_terminate);
1882 signal(SIGTERM, wpa_cli_terminate);
1883 #endif /* _WIN32_WCE */
1884 #ifndef CONFIG_NATIVE_WINDOWS
1885 signal(SIGALRM, wpa_cli_alarm);
1886 #endif /* CONFIG_NATIVE_WINDOWS */
1888 if (interactive || action_file) {
1889 if (wpa_ctrl_attach(ctrl_conn) == 0) {
1890 wpa_cli_attached = 1;
1892 printf("Warning: Failed to attach to "
1893 "wpa_supplicant.\n");
1899 if (daemonize && os_daemonize(pid_file))
1903 wpa_cli_interactive();
1904 else if (action_file)
1905 wpa_cli_action(ctrl_conn);
1907 ret = wpa_request(ctrl_conn, argc - optind, &argv[optind]);
1909 os_free(ctrl_ifname);
1915 #else /* CONFIG_CTRL_IFACE */
1916 int main(int argc, char *argv[])
1918 printf("CONFIG_CTRL_IFACE not defined - wpa_cli disabled\n");
1921 #endif /* CONFIG_CTRL_IFACE */