]> git.ipfire.org Git - thirdparty/hostap.git/blob - wpa_supplicant/wpa_cli.c
projects / thirdparty / hostap.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
wpa_gui: Use separate ctrl_iface connection for event messages
[thirdparty/hostap.git] / wpa_supplicant / wpa_cli.c
1 /*
2 * WPA Supplicant - command line interface for wpa_supplicant daemon
3 * Copyright (c) 2004-2010, Jouni Malinen <j@w1.fi>
4 *
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.
8 *
9 * Alternatively, this software may be distributed under the terms of BSD
10 * license.
11 *
12 * See README and COPYING for more details.
13 */
14
15 #include "includes.h"
16
17 #ifdef CONFIG_CTRL_IFACE
18
19 #ifdef CONFIG_CTRL_IFACE_UNIX
20 #include <dirent.h>
21 #endif /* CONFIG_CTRL_IFACE_UNIX */
22 #ifdef CONFIG_READLINE
23 #include <readline/readline.h>
24 #include <readline/history.h>
25 #endif /* CONFIG_READLINE */
26
27 #include "common/wpa_ctrl.h"
28 #include "common.h"
29 #include "common/version.h"
30
31
32 static const char *wpa_cli_version =
33 "wpa_cli v" VERSION_STR "\n"
34 "Copyright (c) 2004-2010, Jouni Malinen <j@w1.fi> and contributors";
35
36
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"
40 "\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";
43
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"
48 "\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"
53 "\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"
57 "\n"
58 "Alternatively, this software may be distributed under the terms of the\n"
59 "BSD license.\n"
60 "\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"
63 "met:\n"
64 "\n"
65 "1. Redistributions of source code must retain the above copyright\n"
66 " notice, this list of conditions and the following disclaimer.\n"
67 "\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"
71 "\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"
75 "\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"
87 "\n";
88
89 static struct wpa_ctrl *ctrl_conn;
90 static struct wpa_ctrl *mon_conn;
91 static int wpa_cli_quit = 0;
92 static int wpa_cli_attached = 0;
93 static int wpa_cli_connected = 0;
94 static int wpa_cli_last_id = 0;
95 static const char *ctrl_iface_dir = "/var/run/wpa_supplicant";
96 static char *ctrl_ifname = NULL;
97 static const char *pid_file = NULL;
98 static const char *action_file = NULL;
99 static int ping_interval = 5;
100 static int interactive = 0;
101
102
103 static void print_help();
104
105
106 static void usage(void)
107 {
108 printf("wpa_cli [-p<path to ctrl sockets>] [-i<ifname>] [-hvB] "
109 "[-a<action file>] \\\n"
110 " [-P<pid file>] [-g<global ctrl>] [-G<ping interval>] "
111 "[command..]\n"
112 " -h = help (show this usage text)\n"
113 " -v = shown version information\n"
114 " -a = run in daemon mode executing the action file based on "
115 "events from\n"
116 " wpa_supplicant\n"
117 " -B = run a daemon in the background\n"
118 " default path: /var/run/wpa_supplicant\n"
119 " default interface: first interface found in socket path\n");
120 print_help();
121 }
122
123
124 static int wpa_cli_open_connection(const char *ifname, int attach)
125 {
126 #if defined(CONFIG_CTRL_IFACE_UDP) || defined(CONFIG_CTRL_IFACE_NAMED_PIPE)
127 ctrl_conn = wpa_ctrl_open(ifname);
128 if (ctrl_conn == NULL)
129 return -1;
130
131 if (attach && interactive)
132 mon_conn = wpa_ctrl_open(ifname);
133 else
134 mon_conn = NULL;
135 #else /* CONFIG_CTRL_IFACE_UDP || CONFIG_CTRL_IFACE_NAMED_PIPE */
136 char *cfile;
137 int flen, res;
138
139 if (ifname == NULL)
140 return -1;
141
142 flen = os_strlen(ctrl_iface_dir) + os_strlen(ifname) + 2;
143 cfile = os_malloc(flen);
144 if (cfile == NULL)
145 return -1L;
146 res = os_snprintf(cfile, flen, "%s/%s", ctrl_iface_dir, ifname);
147 if (res < 0 || res >= flen) {
148 os_free(cfile);
149 return -1;
150 }
151
152 ctrl_conn = wpa_ctrl_open(cfile);
153 if (ctrl_conn == NULL) {
154 os_free(cfile);
155 return -1;
156 }
157
158 if (attach && interactive)
159 mon_conn = wpa_ctrl_open(cfile);
160 else
161 mon_conn = NULL;
162 os_free(cfile);
163 #endif /* CONFIG_CTRL_IFACE_UDP || CONFIG_CTRL_IFACE_NAMED_PIPE */
164
165 if (mon_conn) {
166 if (wpa_ctrl_attach(mon_conn) == 0) {
167 wpa_cli_attached = 1;
168 } else {
169 printf("Warning: Failed to attach to "
170 "wpa_supplicant.\n");
171 return -1;
172 }
173 }
174
175 return 0;
176 }
177
178
179 static void wpa_cli_close_connection(void)
180 {
181 if (ctrl_conn == NULL)
182 return;
183
184 if (wpa_cli_attached) {
185 wpa_ctrl_detach(interactive ? mon_conn : ctrl_conn);
186 wpa_cli_attached = 0;
187 }
188 wpa_ctrl_close(ctrl_conn);
189 ctrl_conn = NULL;
190 if (mon_conn) {
191 wpa_ctrl_close(mon_conn);
192 mon_conn = NULL;
193 }
194 }
195
196
197 static void wpa_cli_msg_cb(char *msg, size_t len)
198 {
199 printf("%s\n", msg);
200 }
201
202
203 static int _wpa_ctrl_command(struct wpa_ctrl *ctrl, char *cmd, int print)
204 {
205 char buf[2048];
206 size_t len;
207 int ret;
208
209 if (ctrl_conn == NULL) {
210 printf("Not connected to wpa_supplicant - command dropped.\n");
211 return -1;
212 }
213 len = sizeof(buf) - 1;
214 ret = wpa_ctrl_request(ctrl, cmd, os_strlen(cmd), buf, &len,
215 wpa_cli_msg_cb);
216 if (ret == -2) {
217 printf("'%s' command timed out.\n", cmd);
218 return -2;
219 } else if (ret < 0) {
220 printf("'%s' command failed.\n", cmd);
221 return -1;
222 }
223 if (print) {
224 buf[len] = '\0';
225 printf("%s", buf);
226 }
227 return 0;
228 }
229
230
231 static int wpa_ctrl_command(struct wpa_ctrl *ctrl, char *cmd)
232 {
233 return _wpa_ctrl_command(ctrl, cmd, 1);
234 }
235
236
237 static int wpa_cli_cmd_status(struct wpa_ctrl *ctrl, int argc, char *argv[])
238 {
239 int verbose = argc > 0 && os_strcmp(argv[0], "verbose") == 0;
240 return wpa_ctrl_command(ctrl, verbose ? "STATUS-VERBOSE" : "STATUS");
241 }
242
243
244 static int wpa_cli_cmd_ping(struct wpa_ctrl *ctrl, int argc, char *argv[])
245 {
246 return wpa_ctrl_command(ctrl, "PING");
247 }
248
249
250 static int wpa_cli_cmd_mib(struct wpa_ctrl *ctrl, int argc, char *argv[])
251 {
252 return wpa_ctrl_command(ctrl, "MIB");
253 }
254
255
256 static int wpa_cli_cmd_pmksa(struct wpa_ctrl *ctrl, int argc, char *argv[])
257 {
258 return wpa_ctrl_command(ctrl, "PMKSA");
259 }
260
261
262 static int wpa_cli_cmd_help(struct wpa_ctrl *ctrl, int argc, char *argv[])
263 {
264 print_help();
265 return 0;
266 }
267
268
269 static int wpa_cli_cmd_license(struct wpa_ctrl *ctrl, int argc, char *argv[])
270 {
271 printf("%s\n\n%s\n", wpa_cli_version, wpa_cli_full_license);
272 return 0;
273 }
274
275
276 static int wpa_cli_cmd_quit(struct wpa_ctrl *ctrl, int argc, char *argv[])
277 {
278 wpa_cli_quit = 1;
279 return 0;
280 }
281
282
283 static void wpa_cli_show_variables(void)
284 {
285 printf("set variables:\n"
286 " EAPOL::heldPeriod (EAPOL state machine held period, "
287 "in seconds)\n"
288 " EAPOL::authPeriod (EAPOL state machine authentication "
289 "period, in seconds)\n"
290 " EAPOL::startPeriod (EAPOL state machine start period, in "
291 "seconds)\n"
292 " EAPOL::maxStart (EAPOL state machine maximum start "
293 "attempts)\n");
294 printf(" dot11RSNAConfigPMKLifetime (WPA/WPA2 PMK lifetime in "
295 "seconds)\n"
296 " dot11RSNAConfigPMKReauthThreshold (WPA/WPA2 reauthentication"
297 " threshold\n\tpercentage)\n"
298 " dot11RSNAConfigSATimeout (WPA/WPA2 timeout for completing "
299 "security\n\tassociation in seconds)\n");
300 }
301
302
303 static int wpa_cli_cmd_set(struct wpa_ctrl *ctrl, int argc, char *argv[])
304 {
305 char cmd[256];
306 int res;
307
308 if (argc == 0) {
309 wpa_cli_show_variables();
310 return 0;
311 }
312
313 if (argc != 2) {
314 printf("Invalid SET command: needs two arguments (variable "
315 "name and value)\n");
316 return -1;
317 }
318
319 res = os_snprintf(cmd, sizeof(cmd), "SET %s %s", argv[0], argv[1]);
320 if (res < 0 || (size_t) res >= sizeof(cmd) - 1) {
321 printf("Too long SET command.\n");
322 return -1;
323 }
324 return wpa_ctrl_command(ctrl, cmd);
325 }
326
327
328 static int wpa_cli_cmd_logoff(struct wpa_ctrl *ctrl, int argc, char *argv[])
329 {
330 return wpa_ctrl_command(ctrl, "LOGOFF");
331 }
332
333
334 static int wpa_cli_cmd_logon(struct wpa_ctrl *ctrl, int argc, char *argv[])
335 {
336 return wpa_ctrl_command(ctrl, "LOGON");
337 }
338
339
340 static int wpa_cli_cmd_reassociate(struct wpa_ctrl *ctrl, int argc,
341 char *argv[])
342 {
343 return wpa_ctrl_command(ctrl, "REASSOCIATE");
344 }
345
346
347 static int wpa_cli_cmd_preauthenticate(struct wpa_ctrl *ctrl, int argc,
348 char *argv[])
349 {
350 char cmd[256];
351 int res;
352
353 if (argc != 1) {
354 printf("Invalid PREAUTH command: needs one argument "
355 "(BSSID)\n");
356 return -1;
357 }
358
359 res = os_snprintf(cmd, sizeof(cmd), "PREAUTH %s", argv[0]);
360 if (res < 0 || (size_t) res >= sizeof(cmd) - 1) {
361 printf("Too long PREAUTH command.\n");
362 return -1;
363 }
364 return wpa_ctrl_command(ctrl, cmd);
365 }
366
367
368 static int wpa_cli_cmd_ap_scan(struct wpa_ctrl *ctrl, int argc, char *argv[])
369 {
370 char cmd[256];
371 int res;
372
373 if (argc != 1) {
374 printf("Invalid AP_SCAN command: needs one argument (ap_scan "
375 "value)\n");
376 return -1;
377 }
378 res = os_snprintf(cmd, sizeof(cmd), "AP_SCAN %s", argv[0]);
379 if (res < 0 || (size_t) res >= sizeof(cmd) - 1) {
380 printf("Too long AP_SCAN command.\n");
381 return -1;
382 }
383 return wpa_ctrl_command(ctrl, cmd);
384 }
385
386
387 static int wpa_cli_cmd_stkstart(struct wpa_ctrl *ctrl, int argc,
388 char *argv[])
389 {
390 char cmd[256];
391 int res;
392
393 if (argc != 1) {
394 printf("Invalid STKSTART command: needs one argument "
395 "(Peer STA MAC address)\n");
396 return -1;
397 }
398
399 res = os_snprintf(cmd, sizeof(cmd), "STKSTART %s", argv[0]);
400 if (res < 0 || (size_t) res >= sizeof(cmd) - 1) {
401 printf("Too long STKSTART command.\n");
402 return -1;
403 }
404 return wpa_ctrl_command(ctrl, cmd);
405 }
406
407
408 static int wpa_cli_cmd_ft_ds(struct wpa_ctrl *ctrl, int argc, char *argv[])
409 {
410 char cmd[256];
411 int res;
412
413 if (argc != 1) {
414 printf("Invalid FT_DS command: needs one argument "
415 "(Target AP MAC address)\n");
416 return -1;
417 }
418
419 res = os_snprintf(cmd, sizeof(cmd), "FT_DS %s", argv[0]);
420 if (res < 0 || (size_t) res >= sizeof(cmd) - 1) {
421 printf("Too long FT_DS command.\n");
422 return -1;
423 }
424 return wpa_ctrl_command(ctrl, cmd);
425 }
426
427
428 static int wpa_cli_cmd_wps_pbc(struct wpa_ctrl *ctrl, int argc, char *argv[])
429 {
430 char cmd[256];
431 int res;
432
433 if (argc == 0) {
434 /* Any BSSID */
435 return wpa_ctrl_command(ctrl, "WPS_PBC");
436 }
437
438 /* Specific BSSID */
439 res = os_snprintf(cmd, sizeof(cmd), "WPS_PBC %s", argv[0]);
440 if (res < 0 || (size_t) res >= sizeof(cmd) - 1) {
441 printf("Too long WPS_PBC command.\n");
442 return -1;
443 }
444 return wpa_ctrl_command(ctrl, cmd);
445 }
446
447
448 static int wpa_cli_cmd_wps_pin(struct wpa_ctrl *ctrl, int argc, char *argv[])
449 {
450 char cmd[256];
451 int res;
452
453 if (argc == 0) {
454 printf("Invalid WPS_PIN command: need one or two arguments:\n"
455 "- BSSID: use 'any' to select any\n"
456 "- PIN: optional, used only with devices that have no "
457 "display\n");
458 return -1;
459 }
460
461 if (argc == 1) {
462 /* Use dynamically generated PIN (returned as reply) */
463 res = os_snprintf(cmd, sizeof(cmd), "WPS_PIN %s", argv[0]);
464 if (res < 0 || (size_t) res >= sizeof(cmd) - 1) {
465 printf("Too long WPS_PIN command.\n");
466 return -1;
467 }
468 return wpa_ctrl_command(ctrl, cmd);
469 }
470
471 /* Use hardcoded PIN from a label */
472 res = os_snprintf(cmd, sizeof(cmd), "WPS_PIN %s %s", argv[0], argv[1]);
473 if (res < 0 || (size_t) res >= sizeof(cmd) - 1) {
474 printf("Too long WPS_PIN command.\n");
475 return -1;
476 }
477 return wpa_ctrl_command(ctrl, cmd);
478 }
479
480
481 #ifdef CONFIG_WPS_OOB
482 static int wpa_cli_cmd_wps_oob(struct wpa_ctrl *ctrl, int argc, char *argv[])
483 {
484 char cmd[256];
485 int res;
486
487 if (argc != 3 && argc != 4) {
488 printf("Invalid WPS_OOB command: need three or four "
489 "arguments:\n"
490 "- DEV_TYPE: use 'ufd' or 'nfc'\n"
491 "- PATH: path of OOB device like '/mnt'\n"
492 "- METHOD: OOB method 'pin-e' or 'pin-r', "
493 "'cred'\n"
494 "- DEV_NAME: (only for NFC) device name like "
495 "'pn531'\n");
496 return -1;
497 }
498
499 if (argc == 3)
500 res = os_snprintf(cmd, sizeof(cmd), "WPS_OOB %s %s %s",
501 argv[0], argv[1], argv[2]);
502 else
503 res = os_snprintf(cmd, sizeof(cmd), "WPS_OOB %s %s %s %s",
504 argv[0], argv[1], argv[2], argv[3]);
505 if (res < 0 || (size_t) res >= sizeof(cmd) - 1) {
506 printf("Too long WPS_OOB command.\n");
507 return -1;
508 }
509 return wpa_ctrl_command(ctrl, cmd);
510 }
511 #endif /* CONFIG_WPS_OOB */
512
513
514 static int wpa_cli_cmd_wps_reg(struct wpa_ctrl *ctrl, int argc, char *argv[])
515 {
516 char cmd[256];
517 int res;
518
519 if (argc == 2)
520 res = os_snprintf(cmd, sizeof(cmd), "WPS_REG %s %s",
521 argv[0], argv[1]);
522 else if (argc == 6) {
523 char ssid_hex[2 * 32 + 1];
524 char key_hex[2 * 64 + 1];
525 int i;
526
527 ssid_hex[0] = '\0';
528 for (i = 0; i < 32; i++) {
529 if (argv[2][i] == '\0')
530 break;
531 os_snprintf(&ssid_hex[i * 2], 3, "%02x", argv[2][i]);
532 }
533
534 key_hex[0] = '\0';
535 for (i = 0; i < 64; i++) {
536 if (argv[5][i] == '\0')
537 break;
538 os_snprintf(&key_hex[i * 2], 3, "%02x", argv[5][i]);
539 }
540
541 res = os_snprintf(cmd, sizeof(cmd),
542 "WPS_REG %s %s %s %s %s %s",
543 argv[0], argv[1], ssid_hex, argv[3], argv[4],
544 key_hex);
545 } else {
546 printf("Invalid WPS_REG command: need two arguments:\n"
547 "- BSSID: use 'any' to select any\n"
548 "- AP PIN\n");
549 printf("Alternatively, six arguments can be used to "
550 "reconfigure the AP:\n"
551 "- BSSID: use 'any' to select any\n"
552 "- AP PIN\n"
553 "- new SSID\n"
554 "- new auth (OPEN, WPAPSK, WPA2PSK)\n"
555 "- new encr (NONE, WEP, TKIP, CCMP)\n"
556 "- new key\n");
557 return -1;
558 }
559
560 if (res < 0 || (size_t) res >= sizeof(cmd) - 1) {
561 printf("Too long WPS_REG command.\n");
562 return -1;
563 }
564 return wpa_ctrl_command(ctrl, cmd);
565 }
566
567
568 static int wpa_cli_cmd_wps_er_start(struct wpa_ctrl *ctrl, int argc,
569 char *argv[])
570 {
571 return wpa_ctrl_command(ctrl, "WPS_ER_START");
572
573 }
574
575
576 static int wpa_cli_cmd_wps_er_stop(struct wpa_ctrl *ctrl, int argc,
577 char *argv[])
578 {
579 return wpa_ctrl_command(ctrl, "WPS_ER_STOP");
580
581 }
582
583
584 static int wpa_cli_cmd_wps_er_pin(struct wpa_ctrl *ctrl, int argc,
585 char *argv[])
586 {
587 char cmd[256];
588 int res;
589
590 if (argc != 2) {
591 printf("Invalid WPS_ER_PIN command: need two arguments:\n"
592 "- UUID: use 'any' to select any\n"
593 "- PIN: Enrollee PIN\n");
594 return -1;
595 }
596
597 res = os_snprintf(cmd, sizeof(cmd), "WPS_ER_PIN %s %s",
598 argv[0], argv[1]);
599 if (res < 0 || (size_t) res >= sizeof(cmd) - 1) {
600 printf("Too long WPS_ER_PIN command.\n");
601 return -1;
602 }
603 return wpa_ctrl_command(ctrl, cmd);
604 }
605
606
607 static int wpa_cli_cmd_wps_er_pbc(struct wpa_ctrl *ctrl, int argc,
608 char *argv[])
609 {
610 char cmd[256];
611 int res;
612
613 if (argc != 1) {
614 printf("Invalid WPS_ER_PBC command: need one argument:\n"
615 "- UUID: Specify the Enrollee\n");
616 return -1;
617 }
618
619 res = os_snprintf(cmd, sizeof(cmd), "WPS_ER_PBC %s",
620 argv[0]);
621 if (res < 0 || (size_t) res >= sizeof(cmd) - 1) {
622 printf("Too long WPS_ER_PBC command.\n");
623 return -1;
624 }
625 return wpa_ctrl_command(ctrl, cmd);
626 }
627
628
629 static int wpa_cli_cmd_wps_er_learn(struct wpa_ctrl *ctrl, int argc,
630 char *argv[])
631 {
632 char cmd[256];
633 int res;
634
635 if (argc != 2) {
636 printf("Invalid WPS_ER_LEARN command: need two arguments:\n"
637 "- UUID: specify which AP to use\n"
638 "- PIN: AP PIN\n");
639 return -1;
640 }
641
642 res = os_snprintf(cmd, sizeof(cmd), "WPS_ER_LEARN %s %s",
643 argv[0], argv[1]);
644 if (res < 0 || (size_t) res >= sizeof(cmd) - 1) {
645 printf("Too long WPS_ER_LEARN command.\n");
646 return -1;
647 }
648 return wpa_ctrl_command(ctrl, cmd);
649 }
650
651
652 static int wpa_cli_cmd_ibss_rsn(struct wpa_ctrl *ctrl, int argc, char *argv[])
653 {
654 char cmd[256];
655 int res;
656
657 if (argc != 1) {
658 printf("Invalid IBSS_RSN command: needs one argument "
659 "(Peer STA MAC address)\n");
660 return -1;
661 }
662
663 res = os_snprintf(cmd, sizeof(cmd), "IBSS_RSN %s", argv[0]);
664 if (res < 0 || (size_t) res >= sizeof(cmd) - 1) {
665 printf("Too long IBSS_RSN command.\n");
666 return -1;
667 }
668 return wpa_ctrl_command(ctrl, cmd);
669 }
670
671
672 static int wpa_cli_cmd_level(struct wpa_ctrl *ctrl, int argc, char *argv[])
673 {
674 char cmd[256];
675 int res;
676
677 if (argc != 1) {
678 printf("Invalid LEVEL command: needs one argument (debug "
679 "level)\n");
680 return -1;
681 }
682 res = os_snprintf(cmd, sizeof(cmd), "LEVEL %s", argv[0]);
683 if (res < 0 || (size_t) res >= sizeof(cmd) - 1) {
684 printf("Too long LEVEL command.\n");
685 return -1;
686 }
687 return wpa_ctrl_command(ctrl, cmd);
688 }
689
690
691 static int wpa_cli_cmd_identity(struct wpa_ctrl *ctrl, int argc, char *argv[])
692 {
693 char cmd[256], *pos, *end;
694 int i, ret;
695
696 if (argc < 2) {
697 printf("Invalid IDENTITY command: needs two arguments "
698 "(network id and identity)\n");
699 return -1;
700 }
701
702 end = cmd + sizeof(cmd);
703 pos = cmd;
704 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "IDENTITY-%s:%s",
705 argv[0], argv[1]);
706 if (ret < 0 || ret >= end - pos) {
707 printf("Too long IDENTITY command.\n");
708 return -1;
709 }
710 pos += ret;
711 for (i = 2; i < argc; i++) {
712 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
713 if (ret < 0 || ret >= end - pos) {
714 printf("Too long IDENTITY command.\n");
715 return -1;
716 }
717 pos += ret;
718 }
719
720 return wpa_ctrl_command(ctrl, cmd);
721 }
722
723
724 static int wpa_cli_cmd_password(struct wpa_ctrl *ctrl, int argc, char *argv[])
725 {
726 char cmd[256], *pos, *end;
727 int i, ret;
728
729 if (argc < 2) {
730 printf("Invalid PASSWORD command: needs two arguments "
731 "(network id and password)\n");
732 return -1;
733 }
734
735 end = cmd + sizeof(cmd);
736 pos = cmd;
737 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "PASSWORD-%s:%s",
738 argv[0], argv[1]);
739 if (ret < 0 || ret >= end - pos) {
740 printf("Too long PASSWORD command.\n");
741 return -1;
742 }
743 pos += ret;
744 for (i = 2; i < argc; i++) {
745 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
746 if (ret < 0 || ret >= end - pos) {
747 printf("Too long PASSWORD command.\n");
748 return -1;
749 }
750 pos += ret;
751 }
752
753 return wpa_ctrl_command(ctrl, cmd);
754 }
755
756
757 static int wpa_cli_cmd_new_password(struct wpa_ctrl *ctrl, int argc,
758 char *argv[])
759 {
760 char cmd[256], *pos, *end;
761 int i, ret;
762
763 if (argc < 2) {
764 printf("Invalid NEW_PASSWORD command: needs two arguments "
765 "(network id and password)\n");
766 return -1;
767 }
768
769 end = cmd + sizeof(cmd);
770 pos = cmd;
771 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "NEW_PASSWORD-%s:%s",
772 argv[0], argv[1]);
773 if (ret < 0 || ret >= end - pos) {
774 printf("Too long NEW_PASSWORD command.\n");
775 return -1;
776 }
777 pos += ret;
778 for (i = 2; i < argc; i++) {
779 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
780 if (ret < 0 || ret >= end - pos) {
781 printf("Too long NEW_PASSWORD command.\n");
782 return -1;
783 }
784 pos += ret;
785 }
786
787 return wpa_ctrl_command(ctrl, cmd);
788 }
789
790
791 static int wpa_cli_cmd_pin(struct wpa_ctrl *ctrl, int argc, char *argv[])
792 {
793 char cmd[256], *pos, *end;
794 int i, ret;
795
796 if (argc < 2) {
797 printf("Invalid PIN command: needs two arguments "
798 "(network id and pin)\n");
799 return -1;
800 }
801
802 end = cmd + sizeof(cmd);
803 pos = cmd;
804 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "PIN-%s:%s",
805 argv[0], argv[1]);
806 if (ret < 0 || ret >= end - pos) {
807 printf("Too long PIN command.\n");
808 return -1;
809 }
810 pos += ret;
811 for (i = 2; i < argc; i++) {
812 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
813 if (ret < 0 || ret >= end - pos) {
814 printf("Too long PIN command.\n");
815 return -1;
816 }
817 pos += ret;
818 }
819 return wpa_ctrl_command(ctrl, cmd);
820 }
821
822
823 static int wpa_cli_cmd_otp(struct wpa_ctrl *ctrl, int argc, char *argv[])
824 {
825 char cmd[256], *pos, *end;
826 int i, ret;
827
828 if (argc < 2) {
829 printf("Invalid OTP command: needs two arguments (network "
830 "id and password)\n");
831 return -1;
832 }
833
834 end = cmd + sizeof(cmd);
835 pos = cmd;
836 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "OTP-%s:%s",
837 argv[0], argv[1]);
838 if (ret < 0 || ret >= end - pos) {
839 printf("Too long OTP command.\n");
840 return -1;
841 }
842 pos += ret;
843 for (i = 2; i < argc; i++) {
844 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
845 if (ret < 0 || ret >= end - pos) {
846 printf("Too long OTP command.\n");
847 return -1;
848 }
849 pos += ret;
850 }
851
852 return wpa_ctrl_command(ctrl, cmd);
853 }
854
855
856 static int wpa_cli_cmd_passphrase(struct wpa_ctrl *ctrl, int argc,
857 char *argv[])
858 {
859 char cmd[256], *pos, *end;
860 int i, ret;
861
862 if (argc < 2) {
863 printf("Invalid PASSPHRASE command: needs two arguments "
864 "(network id and passphrase)\n");
865 return -1;
866 }
867
868 end = cmd + sizeof(cmd);
869 pos = cmd;
870 ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "PASSPHRASE-%s:%s",
871 argv[0], argv[1]);
872 if (ret < 0 || ret >= end - pos) {
873 printf("Too long PASSPHRASE command.\n");
874 return -1;
875 }
876 pos += ret;
877 for (i = 2; i < argc; i++) {
878 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
879 if (ret < 0 || ret >= end - pos) {
880 printf("Too long PASSPHRASE command.\n");
881 return -1;
882 }
883 pos += ret;
884 }
885
886 return wpa_ctrl_command(ctrl, cmd);
887 }
888
889
890 static int wpa_cli_cmd_bssid(struct wpa_ctrl *ctrl, int argc, char *argv[])
891 {
892 char cmd[256], *pos, *end;
893 int i, ret;
894
895 if (argc < 2) {
896 printf("Invalid BSSID command: needs two arguments (network "
897 "id and BSSID)\n");
898 return -1;
899 }
900
901 end = cmd + sizeof(cmd);
902 pos = cmd;
903 ret = os_snprintf(pos, end - pos, "BSSID");
904 if (ret < 0 || ret >= end - pos) {
905 printf("Too long BSSID command.\n");
906 return -1;
907 }
908 pos += ret;
909 for (i = 0; i < argc; i++) {
910 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
911 if (ret < 0 || ret >= end - pos) {
912 printf("Too long BSSID command.\n");
913 return -1;
914 }
915 pos += ret;
916 }
917
918 return wpa_ctrl_command(ctrl, cmd);
919 }
920
921
922 static int wpa_cli_cmd_list_networks(struct wpa_ctrl *ctrl, int argc,
923 char *argv[])
924 {
925 return wpa_ctrl_command(ctrl, "LIST_NETWORKS");
926 }
927
928
929 static int wpa_cli_cmd_select_network(struct wpa_ctrl *ctrl, int argc,
930 char *argv[])
931 {
932 char cmd[32];
933 int res;
934
935 if (argc < 1) {
936 printf("Invalid SELECT_NETWORK command: needs one argument "
937 "(network id)\n");
938 return -1;
939 }
940
941 res = os_snprintf(cmd, sizeof(cmd), "SELECT_NETWORK %s", argv[0]);
942 if (res < 0 || (size_t) res >= sizeof(cmd))
943 return -1;
944 cmd[sizeof(cmd) - 1] = '\0';
945
946 return wpa_ctrl_command(ctrl, cmd);
947 }
948
949
950 static int wpa_cli_cmd_enable_network(struct wpa_ctrl *ctrl, int argc,
951 char *argv[])
952 {
953 char cmd[32];
954 int res;
955
956 if (argc < 1) {
957 printf("Invalid ENABLE_NETWORK command: needs one argument "
958 "(network id)\n");
959 return -1;
960 }
961
962 res = os_snprintf(cmd, sizeof(cmd), "ENABLE_NETWORK %s", argv[0]);
963 if (res < 0 || (size_t) res >= sizeof(cmd))
964 return -1;
965 cmd[sizeof(cmd) - 1] = '\0';
966
967 return wpa_ctrl_command(ctrl, cmd);
968 }
969
970
971 static int wpa_cli_cmd_disable_network(struct wpa_ctrl *ctrl, int argc,
972 char *argv[])
973 {
974 char cmd[32];
975 int res;
976
977 if (argc < 1) {
978 printf("Invalid DISABLE_NETWORK command: needs one argument "
979 "(network id)\n");
980 return -1;
981 }
982
983 res = os_snprintf(cmd, sizeof(cmd), "DISABLE_NETWORK %s", argv[0]);
984 if (res < 0 || (size_t) res >= sizeof(cmd))
985 return -1;
986 cmd[sizeof(cmd) - 1] = '\0';
987
988 return wpa_ctrl_command(ctrl, cmd);
989 }
990
991
992 static int wpa_cli_cmd_add_network(struct wpa_ctrl *ctrl, int argc,
993 char *argv[])
994 {
995 return wpa_ctrl_command(ctrl, "ADD_NETWORK");
996 }
997
998
999 static int wpa_cli_cmd_remove_network(struct wpa_ctrl *ctrl, int argc,
1000 char *argv[])
1001 {
1002 char cmd[32];
1003 int res;
1004
1005 if (argc < 1) {
1006 printf("Invalid REMOVE_NETWORK command: needs one argument "
1007 "(network id)\n");
1008 return -1;
1009 }
1010
1011 res = os_snprintf(cmd, sizeof(cmd), "REMOVE_NETWORK %s", argv[0]);
1012 if (res < 0 || (size_t) res >= sizeof(cmd))
1013 return -1;
1014 cmd[sizeof(cmd) - 1] = '\0';
1015
1016 return wpa_ctrl_command(ctrl, cmd);
1017 }
1018
1019
1020 static void wpa_cli_show_network_variables(void)
1021 {
1022 printf("set_network variables:\n"
1023 " ssid (network name, SSID)\n"
1024 " psk (WPA passphrase or pre-shared key)\n"
1025 " key_mgmt (key management protocol)\n"
1026 " identity (EAP identity)\n"
1027 " password (EAP password)\n"
1028 " ...\n"
1029 "\n"
1030 "Note: Values are entered in the same format as the "
1031 "configuration file is using,\n"
1032 "i.e., strings values need to be inside double quotation "
1033 "marks.\n"
1034 "For example: set_network 1 ssid \"network name\"\n"
1035 "\n"
1036 "Please see wpa_supplicant.conf documentation for full list "
1037 "of\navailable variables.\n");
1038 }
1039
1040
1041 static int wpa_cli_cmd_set_network(struct wpa_ctrl *ctrl, int argc,
1042 char *argv[])
1043 {
1044 char cmd[256];
1045 int res;
1046
1047 if (argc == 0) {
1048 wpa_cli_show_network_variables();
1049 return 0;
1050 }
1051
1052 if (argc != 3) {
1053 printf("Invalid SET_NETWORK command: needs three arguments\n"
1054 "(network id, variable name, and value)\n");
1055 return -1;
1056 }
1057
1058 res = os_snprintf(cmd, sizeof(cmd), "SET_NETWORK %s %s %s",
1059 argv[0], argv[1], argv[2]);
1060 if (res < 0 || (size_t) res >= sizeof(cmd) - 1) {
1061 printf("Too long SET_NETWORK command.\n");
1062 return -1;
1063 }
1064 return wpa_ctrl_command(ctrl, cmd);
1065 }
1066
1067
1068 static int wpa_cli_cmd_get_network(struct wpa_ctrl *ctrl, int argc,
1069 char *argv[])
1070 {
1071 char cmd[256];
1072 int res;
1073
1074 if (argc == 0) {
1075 wpa_cli_show_network_variables();
1076 return 0;
1077 }
1078
1079 if (argc != 2) {
1080 printf("Invalid GET_NETWORK command: needs two arguments\n"
1081 "(network id and variable name)\n");
1082 return -1;
1083 }
1084
1085 res = os_snprintf(cmd, sizeof(cmd), "GET_NETWORK %s %s",
1086 argv[0], argv[1]);
1087 if (res < 0 || (size_t) res >= sizeof(cmd) - 1) {
1088 printf("Too long GET_NETWORK command.\n");
1089 return -1;
1090 }
1091 return wpa_ctrl_command(ctrl, cmd);
1092 }
1093
1094
1095 static int wpa_cli_cmd_disconnect(struct wpa_ctrl *ctrl, int argc,
1096 char *argv[])
1097 {
1098 return wpa_ctrl_command(ctrl, "DISCONNECT");
1099 }
1100
1101
1102 static int wpa_cli_cmd_reconnect(struct wpa_ctrl *ctrl, int argc,
1103 char *argv[])
1104 {
1105 return wpa_ctrl_command(ctrl, "RECONNECT");
1106 }
1107
1108
1109 static int wpa_cli_cmd_save_config(struct wpa_ctrl *ctrl, int argc,
1110 char *argv[])
1111 {
1112 return wpa_ctrl_command(ctrl, "SAVE_CONFIG");
1113 }
1114
1115
1116 static int wpa_cli_cmd_scan(struct wpa_ctrl *ctrl, int argc, char *argv[])
1117 {
1118 return wpa_ctrl_command(ctrl, "SCAN");
1119 }
1120
1121
1122 static int wpa_cli_cmd_scan_results(struct wpa_ctrl *ctrl, int argc,
1123 char *argv[])
1124 {
1125 return wpa_ctrl_command(ctrl, "SCAN_RESULTS");
1126 }
1127
1128
1129 static int wpa_cli_cmd_bss(struct wpa_ctrl *ctrl, int argc, char *argv[])
1130 {
1131 char cmd[64];
1132 int res;
1133
1134 if (argc != 1) {
1135 printf("Invalid BSS command: need one argument (index or "
1136 "BSSID)\n");
1137 return -1;
1138 }
1139
1140 res = os_snprintf(cmd, sizeof(cmd), "BSS %s", argv[0]);
1141 if (res < 0 || (size_t) res >= sizeof(cmd))
1142 return -1;
1143 cmd[sizeof(cmd) - 1] = '\0';
1144
1145 return wpa_ctrl_command(ctrl, cmd);
1146 }
1147
1148
1149 static int wpa_cli_cmd_get_capability(struct wpa_ctrl *ctrl, int argc,
1150 char *argv[])
1151 {
1152 char cmd[64];
1153 int res;
1154
1155 if (argc < 1 || argc > 2) {
1156 printf("Invalid GET_CAPABILITY command: need either one or "
1157 "two arguments\n");
1158 return -1;
1159 }
1160
1161 if ((argc == 2) && os_strcmp(argv[1], "strict") != 0) {
1162 printf("Invalid GET_CAPABILITY command: second argument, "
1163 "if any, must be 'strict'\n");
1164 return -1;
1165 }
1166
1167 res = os_snprintf(cmd, sizeof(cmd), "GET_CAPABILITY %s%s", argv[0],
1168 (argc == 2) ? " strict" : "");
1169 if (res < 0 || (size_t) res >= sizeof(cmd))
1170 return -1;
1171 cmd[sizeof(cmd) - 1] = '\0';
1172
1173 return wpa_ctrl_command(ctrl, cmd);
1174 }
1175
1176
1177 static int wpa_cli_list_interfaces(struct wpa_ctrl *ctrl)
1178 {
1179 printf("Available interfaces:\n");
1180 return wpa_ctrl_command(ctrl, "INTERFACES");
1181 }
1182
1183
1184 static int wpa_cli_cmd_interface(struct wpa_ctrl *ctrl, int argc, char *argv[])
1185 {
1186 if (argc < 1) {
1187 wpa_cli_list_interfaces(ctrl);
1188 return 0;
1189 }
1190
1191 wpa_cli_close_connection();
1192 os_free(ctrl_ifname);
1193 ctrl_ifname = os_strdup(argv[0]);
1194
1195 if (wpa_cli_open_connection(ctrl_ifname, 1)) {
1196 printf("Connected to interface '%s.\n", ctrl_ifname);
1197 } else {
1198 printf("Could not connect to interface '%s' - re-trying\n",
1199 ctrl_ifname);
1200 }
1201 return 0;
1202 }
1203
1204
1205 static int wpa_cli_cmd_reconfigure(struct wpa_ctrl *ctrl, int argc,
1206 char *argv[])
1207 {
1208 return wpa_ctrl_command(ctrl, "RECONFIGURE");
1209 }
1210
1211
1212 static int wpa_cli_cmd_terminate(struct wpa_ctrl *ctrl, int argc,
1213 char *argv[])
1214 {
1215 return wpa_ctrl_command(ctrl, "TERMINATE");
1216 }
1217
1218
1219 static int wpa_cli_cmd_interface_add(struct wpa_ctrl *ctrl, int argc,
1220 char *argv[])
1221 {
1222 char cmd[256];
1223 int res;
1224
1225 if (argc < 1) {
1226 printf("Invalid INTERFACE_ADD command: needs at least one "
1227 "argument (interface name)\n"
1228 "All arguments: ifname confname driver ctrl_interface "
1229 "driver_param bridge_name\n");
1230 return -1;
1231 }
1232
1233 /*
1234 * INTERFACE_ADD <ifname>TAB<confname>TAB<driver>TAB<ctrl_interface>TAB
1235 * <driver_param>TAB<bridge_name>
1236 */
1237 res = os_snprintf(cmd, sizeof(cmd),
1238 "INTERFACE_ADD %s\t%s\t%s\t%s\t%s\t%s",
1239 argv[0],
1240 argc > 1 ? argv[1] : "", argc > 2 ? argv[2] : "",
1241 argc > 3 ? argv[3] : "", argc > 4 ? argv[4] : "",
1242 argc > 5 ? argv[5] : "");
1243 if (res < 0 || (size_t) res >= sizeof(cmd))
1244 return -1;
1245 cmd[sizeof(cmd) - 1] = '\0';
1246 return wpa_ctrl_command(ctrl, cmd);
1247 }
1248
1249
1250 static int wpa_cli_cmd_interface_remove(struct wpa_ctrl *ctrl, int argc,
1251 char *argv[])
1252 {
1253 char cmd[128];
1254 int res;
1255
1256 if (argc != 1) {
1257 printf("Invalid INTERFACE_REMOVE command: needs one argument "
1258 "(interface name)\n");
1259 return -1;
1260 }
1261
1262 res = os_snprintf(cmd, sizeof(cmd), "INTERFACE_REMOVE %s", argv[0]);
1263 if (res < 0 || (size_t) res >= sizeof(cmd))
1264 return -1;
1265 cmd[sizeof(cmd) - 1] = '\0';
1266 return wpa_ctrl_command(ctrl, cmd);
1267 }
1268
1269
1270 static int wpa_cli_cmd_interface_list(struct wpa_ctrl *ctrl, int argc,
1271 char *argv[])
1272 {
1273 return wpa_ctrl_command(ctrl, "INTERFACE_LIST");
1274 }
1275
1276
1277 #ifdef CONFIG_AP
1278 static int wpa_cli_cmd_sta(struct wpa_ctrl *ctrl, int argc, char *argv[])
1279 {
1280 char buf[64];
1281 if (argc != 1) {
1282 printf("Invalid 'sta' command - exactly one argument, STA "
1283 "address, is required.\n");
1284 return -1;
1285 }
1286 snprintf(buf, sizeof(buf), "STA %s", argv[0]);
1287 return wpa_ctrl_command(ctrl, buf);
1288 }
1289
1290
1291 static int wpa_ctrl_command_sta(struct wpa_ctrl *ctrl, char *cmd,
1292 char *addr, size_t addr_len)
1293 {
1294 char buf[4096], *pos;
1295 size_t len;
1296 int ret;
1297
1298 if (ctrl_conn == NULL) {
1299 printf("Not connected to hostapd - command dropped.\n");
1300 return -1;
1301 }
1302 len = sizeof(buf) - 1;
1303 ret = wpa_ctrl_request(ctrl, cmd, strlen(cmd), buf, &len,
1304 wpa_cli_msg_cb);
1305 if (ret == -2) {
1306 printf("'%s' command timed out.\n", cmd);
1307 return -2;
1308 } else if (ret < 0) {
1309 printf("'%s' command failed.\n", cmd);
1310 return -1;
1311 }
1312
1313 buf[len] = '\0';
1314 if (memcmp(buf, "FAIL", 4) == 0)
1315 return -1;
1316 printf("%s", buf);
1317
1318 pos = buf;
1319 while (*pos != '\0' && *pos != '\n')
1320 pos++;
1321 *pos = '\0';
1322 os_strlcpy(addr, buf, addr_len);
1323 return 0;
1324 }
1325
1326
1327 static int wpa_cli_cmd_all_sta(struct wpa_ctrl *ctrl, int argc, char *argv[])
1328 {
1329 char addr[32], cmd[64];
1330
1331 if (wpa_ctrl_command_sta(ctrl, "STA-FIRST", addr, sizeof(addr)))
1332 return 0;
1333 do {
1334 snprintf(cmd, sizeof(cmd), "STA-NEXT %s", addr);
1335 } while (wpa_ctrl_command_sta(ctrl, cmd, addr, sizeof(addr)) == 0);
1336
1337 return -1;
1338 }
1339 #endif /* CONFIG_AP */
1340
1341
1342 enum wpa_cli_cmd_flags {
1343 cli_cmd_flag_none = 0x00,
1344 cli_cmd_flag_sensitive = 0x01
1345 };
1346
1347 struct wpa_cli_cmd {
1348 const char *cmd;
1349 int (*handler)(struct wpa_ctrl *ctrl, int argc, char *argv[]);
1350 enum wpa_cli_cmd_flags flags;
1351 const char *usage;
1352 };
1353
1354 static struct wpa_cli_cmd wpa_cli_commands[] = {
1355 { "status", wpa_cli_cmd_status,
1356 cli_cmd_flag_none,
1357 "[verbose] = get current WPA/EAPOL/EAP status" },
1358 { "ping", wpa_cli_cmd_ping,
1359 cli_cmd_flag_none,
1360 "= pings wpa_supplicant" },
1361 { "mib", wpa_cli_cmd_mib,
1362 cli_cmd_flag_none,
1363 "= get MIB variables (dot1x, dot11)" },
1364 { "help", wpa_cli_cmd_help,
1365 cli_cmd_flag_none,
1366 "= show this usage help" },
1367 { "interface", wpa_cli_cmd_interface,
1368 cli_cmd_flag_none,
1369 "[ifname] = show interfaces/select interface" },
1370 { "level", wpa_cli_cmd_level,
1371 cli_cmd_flag_none,
1372 "<debug level> = change debug level" },
1373 { "license", wpa_cli_cmd_license,
1374 cli_cmd_flag_none,
1375 "= show full wpa_cli license" },
1376 { "quit", wpa_cli_cmd_quit,
1377 cli_cmd_flag_none,
1378 "= exit wpa_cli" },
1379 { "set", wpa_cli_cmd_set,
1380 cli_cmd_flag_none,
1381 "= set variables (shows list of variables when run without "
1382 "arguments)" },
1383 { "logon", wpa_cli_cmd_logon,
1384 cli_cmd_flag_none,
1385 "= IEEE 802.1X EAPOL state machine logon" },
1386 { "logoff", wpa_cli_cmd_logoff,
1387 cli_cmd_flag_none,
1388 "= IEEE 802.1X EAPOL state machine logoff" },
1389 { "pmksa", wpa_cli_cmd_pmksa,
1390 cli_cmd_flag_none,
1391 "= show PMKSA cache" },
1392 { "reassociate", wpa_cli_cmd_reassociate,
1393 cli_cmd_flag_none,
1394 "= force reassociation" },
1395 { "preauthenticate", wpa_cli_cmd_preauthenticate,
1396 cli_cmd_flag_none,
1397 "<BSSID> = force preauthentication" },
1398 { "identity", wpa_cli_cmd_identity,
1399 cli_cmd_flag_none,
1400 "<network id> <identity> = configure identity for an SSID" },
1401 { "password", wpa_cli_cmd_password,
1402 cli_cmd_flag_sensitive,
1403 "<network id> <password> = configure password for an SSID" },
1404 { "new_password", wpa_cli_cmd_new_password,
1405 cli_cmd_flag_sensitive,
1406 "<network id> <password> = change password for an SSID" },
1407 { "pin", wpa_cli_cmd_pin,
1408 cli_cmd_flag_sensitive,
1409 "<network id> <pin> = configure pin for an SSID" },
1410 { "otp", wpa_cli_cmd_otp,
1411 cli_cmd_flag_sensitive,
1412 "<network id> <password> = configure one-time-password for an SSID"
1413 },
1414 { "passphrase", wpa_cli_cmd_passphrase,
1415 cli_cmd_flag_sensitive,
1416 "<network id> <passphrase> = configure private key passphrase\n"
1417 " for an SSID" },
1418 { "bssid", wpa_cli_cmd_bssid,
1419 cli_cmd_flag_none,
1420 "<network id> <BSSID> = set preferred BSSID for an SSID" },
1421 { "list_networks", wpa_cli_cmd_list_networks,
1422 cli_cmd_flag_none,
1423 "= list configured networks" },
1424 { "select_network", wpa_cli_cmd_select_network,
1425 cli_cmd_flag_none,
1426 "<network id> = select a network (disable others)" },
1427 { "enable_network", wpa_cli_cmd_enable_network,
1428 cli_cmd_flag_none,
1429 "<network id> = enable a network" },
1430 { "disable_network", wpa_cli_cmd_disable_network,
1431 cli_cmd_flag_none,
1432 "<network id> = disable a network" },
1433 { "add_network", wpa_cli_cmd_add_network,
1434 cli_cmd_flag_none,
1435 "= add a network" },
1436 { "remove_network", wpa_cli_cmd_remove_network,
1437 cli_cmd_flag_none,
1438 "<network id> = remove a network" },
1439 { "set_network", wpa_cli_cmd_set_network,
1440 cli_cmd_flag_sensitive,
1441 "<network id> <variable> <value> = set network variables (shows\n"
1442 " list of variables when run without arguments)" },
1443 { "get_network", wpa_cli_cmd_get_network,
1444 cli_cmd_flag_none,
1445 "<network id> <variable> = get network variables" },
1446 { "save_config", wpa_cli_cmd_save_config,
1447 cli_cmd_flag_none,
1448 "= save the current configuration" },
1449 { "disconnect", wpa_cli_cmd_disconnect,
1450 cli_cmd_flag_none,
1451 "= disconnect and wait for reassociate/reconnect command before\n"
1452 " connecting" },
1453 { "reconnect", wpa_cli_cmd_reconnect,
1454 cli_cmd_flag_none,
1455 "= like reassociate, but only takes effect if already disconnected"
1456 },
1457 { "scan", wpa_cli_cmd_scan,
1458 cli_cmd_flag_none,
1459 "= request new BSS scan" },
1460 { "scan_results", wpa_cli_cmd_scan_results,
1461 cli_cmd_flag_none,
1462 "= get latest scan results" },
1463 { "bss", wpa_cli_cmd_bss,
1464 cli_cmd_flag_none,
1465 "<<idx> | <bssid>> = get detailed scan result info" },
1466 { "get_capability", wpa_cli_cmd_get_capability,
1467 cli_cmd_flag_none,
1468 "<eap/pairwise/group/key_mgmt/proto/auth_alg> = get capabilies" },
1469 { "reconfigure", wpa_cli_cmd_reconfigure,
1470 cli_cmd_flag_none,
1471 "= force wpa_supplicant to re-read its configuration file" },
1472 { "terminate", wpa_cli_cmd_terminate,
1473 cli_cmd_flag_none,
1474 "= terminate wpa_supplicant" },
1475 { "interface_add", wpa_cli_cmd_interface_add,
1476 cli_cmd_flag_none,
1477 "<ifname> <confname> <driver> <ctrl_interface> <driver_param>\n"
1478 " <bridge_name> = adds new interface, all parameters but <ifname>\n"
1479 " are optional" },
1480 { "interface_remove", wpa_cli_cmd_interface_remove,
1481 cli_cmd_flag_none,
1482 "<ifname> = removes the interface" },
1483 { "interface_list", wpa_cli_cmd_interface_list,
1484 cli_cmd_flag_none,
1485 "= list available interfaces" },
1486 { "ap_scan", wpa_cli_cmd_ap_scan,
1487 cli_cmd_flag_none,
1488 "<value> = set ap_scan parameter" },
1489 { "stkstart", wpa_cli_cmd_stkstart,
1490 cli_cmd_flag_none,
1491 "<addr> = request STK negotiation with <addr>" },
1492 { "ft_ds", wpa_cli_cmd_ft_ds,
1493 cli_cmd_flag_none,
1494 "<addr> = request over-the-DS FT with <addr>" },
1495 { "wps_pbc", wpa_cli_cmd_wps_pbc,
1496 cli_cmd_flag_none,
1497 "[BSSID] = start Wi-Fi Protected Setup: Push Button Configuration" },
1498 { "wps_pin", wpa_cli_cmd_wps_pin,
1499 cli_cmd_flag_sensitive,
1500 "<BSSID> [PIN] = start WPS PIN method (returns PIN, if not "
1501 "hardcoded)" },
1502 #ifdef CONFIG_WPS_OOB
1503 { "wps_oob", wpa_cli_cmd_wps_oob,
1504 cli_cmd_flag_sensitive,
1505 "<DEV_TYPE> <PATH> <METHOD> [DEV_NAME] = start WPS OOB" },
1506 #endif /* CONFIG_WPS_OOB */
1507 { "wps_reg", wpa_cli_cmd_wps_reg,
1508 cli_cmd_flag_sensitive,
1509 "<BSSID> <AP PIN> = start WPS Registrar to configure an AP" },
1510 { "wps_er_start", wpa_cli_cmd_wps_er_start,
1511 cli_cmd_flag_none,
1512 "= start Wi-Fi Protected Setup External Registrar" },
1513 { "wps_er_stop", wpa_cli_cmd_wps_er_stop,
1514 cli_cmd_flag_none,
1515 "= stop Wi-Fi Protected Setup External Registrar" },
1516 { "wps_er_pin", wpa_cli_cmd_wps_er_pin,
1517 cli_cmd_flag_sensitive,
1518 "<UUID> <PIN> = add an Enrollee PIN to External Registrar" },
1519 { "wps_er_pbc", wpa_cli_cmd_wps_er_pbc,
1520 cli_cmd_flag_none,
1521 "<UUID> = accept an Enrollee PBC using External Registrar" },
1522 { "wps_er_learn", wpa_cli_cmd_wps_er_learn,
1523 cli_cmd_flag_sensitive,
1524 "<UUID> <PIN> = learn AP configuration" },
1525 { "ibss_rsn", wpa_cli_cmd_ibss_rsn,
1526 cli_cmd_flag_none,
1527 "<addr> = request RSN authentication with <addr> in IBSS" },
1528 #ifdef CONFIG_AP
1529 { "sta", wpa_cli_cmd_sta,
1530 cli_cmd_flag_none,
1531 "<addr> = get information about an associated station (AP)" },
1532 { "all_sta", wpa_cli_cmd_all_sta,
1533 cli_cmd_flag_none,
1534 "= get information about all associated stations (AP)" },
1535 #endif /* CONFIG_AP */
1536 { NULL, NULL, cli_cmd_flag_none, NULL }
1537 };
1538
1539
1540 /*
1541 * Prints command usage, lines are padded with the specified string.
1542 */
1543 static void print_cmd_help(struct wpa_cli_cmd *cmd, const char *pad)
1544 {
1545 char c;
1546 size_t n;
1547
1548 printf("%s%s ", pad, cmd->cmd);
1549 for (n = 0; (c = cmd->usage[n]); n++) {
1550 printf("%c", c);
1551 if (c == '\n')
1552 printf("%s", pad);
1553 }
1554 printf("\n");
1555 }
1556
1557
1558 static void print_help(void)
1559 {
1560 int n;
1561 printf("commands:\n");
1562 for (n = 0; wpa_cli_commands[n].cmd; n++)
1563 print_cmd_help(&wpa_cli_commands[n], " ");
1564 }
1565
1566
1567 #ifdef CONFIG_READLINE
1568 static int cmd_has_sensitive_data(const char *cmd)
1569 {
1570 const char *c, *delim;
1571 int n;
1572 size_t len;
1573
1574 delim = os_strchr(cmd, ' ');
1575 if (delim)
1576 len = delim - cmd;
1577 else
1578 len = os_strlen(cmd);
1579
1580 for (n = 0; (c = wpa_cli_commands[n].cmd); n++) {
1581 if (os_strncasecmp(cmd, c, len) == 0 && len == os_strlen(c))
1582 return (wpa_cli_commands[n].flags &
1583 cli_cmd_flag_sensitive);
1584 }
1585 return 0;
1586 }
1587 #endif /* CONFIG_READLINE */
1588
1589
1590 static int wpa_request(struct wpa_ctrl *ctrl, int argc, char *argv[])
1591 {
1592 struct wpa_cli_cmd *cmd, *match = NULL;
1593 int count;
1594 int ret = 0;
1595
1596 count = 0;
1597 cmd = wpa_cli_commands;
1598 while (cmd->cmd) {
1599 if (os_strncasecmp(cmd->cmd, argv[0], os_strlen(argv[0])) == 0)
1600 {
1601 match = cmd;
1602 if (os_strcasecmp(cmd->cmd, argv[0]) == 0) {
1603 /* we have an exact match */
1604 count = 1;
1605 break;
1606 }
1607 count++;
1608 }
1609 cmd++;
1610 }
1611
1612 if (count > 1) {
1613 printf("Ambiguous command '%s'; possible commands:", argv[0]);
1614 cmd = wpa_cli_commands;
1615 while (cmd->cmd) {
1616 if (os_strncasecmp(cmd->cmd, argv[0],
1617 os_strlen(argv[0])) == 0) {
1618 printf(" %s", cmd->cmd);
1619 }
1620 cmd++;
1621 }
1622 printf("\n");
1623 ret = 1;
1624 } else if (count == 0) {
1625 printf("Unknown command '%s'\n", argv[0]);
1626 ret = 1;
1627 } else {
1628 ret = match->handler(ctrl, argc - 1, &argv[1]);
1629 }
1630
1631 return ret;
1632 }
1633
1634
1635 static int str_match(const char *a, const char *b)
1636 {
1637 return os_strncmp(a, b, os_strlen(b)) == 0;
1638 }
1639
1640
1641 static int wpa_cli_exec(const char *program, const char *arg1,
1642 const char *arg2)
1643 {
1644 char *cmd;
1645 size_t len;
1646 int res;
1647 int ret = 0;
1648
1649 len = os_strlen(program) + os_strlen(arg1) + os_strlen(arg2) + 3;
1650 cmd = os_malloc(len);
1651 if (cmd == NULL)
1652 return -1;
1653 res = os_snprintf(cmd, len, "%s %s %s", program, arg1, arg2);
1654 if (res < 0 || (size_t) res >= len) {
1655 os_free(cmd);
1656 return -1;
1657 }
1658 cmd[len - 1] = '\0';
1659 #ifndef _WIN32_WCE
1660 if (system(cmd) < 0)
1661 ret = -1;
1662 #endif /* _WIN32_WCE */
1663 os_free(cmd);
1664
1665 return ret;
1666 }
1667
1668
1669 static void wpa_cli_action_process(const char *msg)
1670 {
1671 const char *pos;
1672 char *copy = NULL, *id, *pos2;
1673
1674 pos = msg;
1675 if (*pos == '<') {
1676 /* skip priority */
1677 pos = os_strchr(pos, '>');
1678 if (pos)
1679 pos++;
1680 else
1681 pos = msg;
1682 }
1683
1684 if (str_match(pos, WPA_EVENT_CONNECTED)) {
1685 int new_id = -1;
1686 os_unsetenv("WPA_ID");
1687 os_unsetenv("WPA_ID_STR");
1688 os_unsetenv("WPA_CTRL_DIR");
1689
1690 pos = os_strstr(pos, "[id=");
1691 if (pos)
1692 copy = os_strdup(pos + 4);
1693
1694 if (copy) {
1695 pos2 = id = copy;
1696 while (*pos2 && *pos2 != ' ')
1697 pos2++;
1698 *pos2++ = '\0';
1699 new_id = atoi(id);
1700 os_setenv("WPA_ID", id, 1);
1701 while (*pos2 && *pos2 != '=')
1702 pos2++;
1703 if (*pos2 == '=')
1704 pos2++;
1705 id = pos2;
1706 while (*pos2 && *pos2 != ']')
1707 pos2++;
1708 *pos2 = '\0';
1709 os_setenv("WPA_ID_STR", id, 1);
1710 os_free(copy);
1711 }
1712
1713 os_setenv("WPA_CTRL_DIR", ctrl_iface_dir, 1);
1714
1715 if (!wpa_cli_connected || new_id != wpa_cli_last_id) {
1716 wpa_cli_connected = 1;
1717 wpa_cli_last_id = new_id;
1718 wpa_cli_exec(action_file, ctrl_ifname, "CONNECTED");
1719 }
1720 } else if (str_match(pos, WPA_EVENT_DISCONNECTED)) {
1721 if (wpa_cli_connected) {
1722 wpa_cli_connected = 0;
1723 wpa_cli_exec(action_file, ctrl_ifname, "DISCONNECTED");
1724 }
1725 } else if (str_match(pos, WPA_EVENT_TERMINATING)) {
1726 printf("wpa_supplicant is terminating - stop monitoring\n");
1727 wpa_cli_quit = 1;
1728 }
1729 }
1730
1731
1732 #ifndef CONFIG_ANSI_C_EXTRA
1733 static void wpa_cli_action_cb(char *msg, size_t len)
1734 {
1735 wpa_cli_action_process(msg);
1736 }
1737 #endif /* CONFIG_ANSI_C_EXTRA */
1738
1739
1740 static void wpa_cli_reconnect(void)
1741 {
1742 wpa_cli_close_connection();
1743 wpa_cli_open_connection(ctrl_ifname, 1);
1744 }
1745
1746
1747 static void wpa_cli_recv_pending(struct wpa_ctrl *ctrl, int in_read,
1748 int action_monitor)
1749 {
1750 int first = 1;
1751 if (ctrl_conn == NULL) {
1752 wpa_cli_reconnect();
1753 return;
1754 }
1755 while (wpa_ctrl_pending(ctrl) > 0) {
1756 char buf[256];
1757 size_t len = sizeof(buf) - 1;
1758 if (wpa_ctrl_recv(ctrl, buf, &len) == 0) {
1759 buf[len] = '\0';
1760 if (action_monitor)
1761 wpa_cli_action_process(buf);
1762 else {
1763 if (in_read && first)
1764 printf("\n");
1765 first = 0;
1766 printf("%s\n", buf);
1767 }
1768 } else {
1769 printf("Could not read pending message.\n");
1770 break;
1771 }
1772 }
1773
1774 if (wpa_ctrl_pending(ctrl) < 0) {
1775 printf("Connection to wpa_supplicant lost - trying to "
1776 "reconnect\n");
1777 wpa_cli_reconnect();
1778 }
1779 }
1780
1781
1782 #ifdef CONFIG_READLINE
1783 static char * wpa_cli_cmd_gen(const char *text, int state)
1784 {
1785 static int i, len;
1786 const char *cmd;
1787
1788 if (state == 0) {
1789 i = 0;
1790 len = os_strlen(text);
1791 }
1792
1793 while ((cmd = wpa_cli_commands[i].cmd)) {
1794 i++;
1795 if (os_strncasecmp(cmd, text, len) == 0)
1796 return strdup(cmd);
1797 }
1798
1799 return NULL;
1800 }
1801
1802
1803 static char * wpa_cli_dummy_gen(const char *text, int state)
1804 {
1805 return NULL;
1806 }
1807
1808
1809 static char ** wpa_cli_completion(const char *text, int start, int end)
1810 {
1811 return rl_completion_matches(text, start == 0 ?
1812 wpa_cli_cmd_gen : wpa_cli_dummy_gen);
1813 }
1814 #endif /* CONFIG_READLINE */
1815
1816
1817 static void wpa_cli_interactive(void)
1818 {
1819 #define max_args 10
1820 char cmdbuf[256], *cmd, *argv[max_args], *pos;
1821 int argc;
1822 #ifdef CONFIG_READLINE
1823 char *home, *hfile = NULL;
1824 #endif /* CONFIG_READLINE */
1825
1826 printf("\nInteractive mode\n\n");
1827
1828 #ifdef CONFIG_READLINE
1829 rl_attempted_completion_function = wpa_cli_completion;
1830 home = getenv("HOME");
1831 if (home) {
1832 const char *fname = ".wpa_cli_history";
1833 int hfile_len = os_strlen(home) + 1 + os_strlen(fname) + 1;
1834 hfile = os_malloc(hfile_len);
1835 if (hfile) {
1836 int res;
1837 res = os_snprintf(hfile, hfile_len, "%s/%s", home,
1838 fname);
1839 if (res >= 0 && res < hfile_len) {
1840 hfile[hfile_len - 1] = '\0';
1841 read_history(hfile);
1842 stifle_history(100);
1843 }
1844 }
1845 }
1846 #endif /* CONFIG_READLINE */
1847
1848 do {
1849 wpa_cli_recv_pending(mon_conn, 0, 0);
1850 #ifndef CONFIG_NATIVE_WINDOWS
1851 alarm(ping_interval);
1852 #endif /* CONFIG_NATIVE_WINDOWS */
1853 #ifdef CONFIG_READLINE
1854 cmd = readline("> ");
1855 if (cmd && *cmd) {
1856 HIST_ENTRY *h;
1857 while (next_history())
1858 ;
1859 h = previous_history();
1860 if (h == NULL || os_strcmp(cmd, h->line) != 0)
1861 add_history(cmd);
1862 next_history();
1863 }
1864 #else /* CONFIG_READLINE */
1865 printf("> ");
1866 cmd = fgets(cmdbuf, sizeof(cmdbuf), stdin);
1867 #endif /* CONFIG_READLINE */
1868 #ifndef CONFIG_NATIVE_WINDOWS
1869 alarm(0);
1870 #endif /* CONFIG_NATIVE_WINDOWS */
1871 if (cmd == NULL)
1872 break;
1873 wpa_cli_recv_pending(mon_conn, 0, 0);
1874 pos = cmd;
1875 while (*pos != '\0') {
1876 if (*pos == '\n') {
1877 *pos = '\0';
1878 break;
1879 }
1880 pos++;
1881 }
1882 argc = 0;
1883 pos = cmd;
1884 for (;;) {
1885 while (*pos == ' ')
1886 pos++;
1887 if (*pos == '\0')
1888 break;
1889 argv[argc] = pos;
1890 argc++;
1891 if (argc == max_args)
1892 break;
1893 if (*pos == '"') {
1894 char *pos2 = os_strrchr(pos, '"');
1895 if (pos2)
1896 pos = pos2 + 1;
1897 }
1898 while (*pos != '\0' && *pos != ' ')
1899 pos++;
1900 if (*pos == ' ')
1901 *pos++ = '\0';
1902 }
1903 if (argc)
1904 wpa_request(ctrl_conn, argc, argv);
1905
1906 if (cmd != cmdbuf)
1907 free(cmd);
1908 } while (!wpa_cli_quit);
1909
1910 #ifdef CONFIG_READLINE
1911 if (hfile) {
1912 /* Save command history, excluding lines that may contain
1913 * passwords. */
1914 HIST_ENTRY *h;
1915 history_set_pos(0);
1916 while ((h = current_history())) {
1917 char *p = h->line;
1918 while (*p == ' ' || *p == '\t')
1919 p++;
1920 if (cmd_has_sensitive_data(p)) {
1921 h = remove_history(where_history());
1922 if (h) {
1923 os_free(h->line);
1924 os_free(h->data);
1925 os_free(h);
1926 } else
1927 next_history();
1928 } else
1929 next_history();
1930 }
1931 write_history(hfile);
1932 os_free(hfile);
1933 }
1934 #endif /* CONFIG_READLINE */
1935 }
1936
1937
1938 static void wpa_cli_action(struct wpa_ctrl *ctrl)
1939 {
1940 #ifdef CONFIG_ANSI_C_EXTRA
1941 /* TODO: ANSI C version(?) */
1942 printf("Action processing not supported in ANSI C build.\n");
1943 #else /* CONFIG_ANSI_C_EXTRA */
1944 fd_set rfds;
1945 int fd, res;
1946 struct timeval tv;
1947 char buf[256]; /* note: large enough to fit in unsolicited messages */
1948 size_t len;
1949
1950 fd = wpa_ctrl_get_fd(ctrl);
1951
1952 while (!wpa_cli_quit) {
1953 FD_ZERO(&rfds);
1954 FD_SET(fd, &rfds);
1955 tv.tv_sec = ping_interval;
1956 tv.tv_usec = 0;
1957 res = select(fd + 1, &rfds, NULL, NULL, &tv);
1958 if (res < 0 && errno != EINTR) {
1959 perror("select");
1960 break;
1961 }
1962
1963 if (FD_ISSET(fd, &rfds))
1964 wpa_cli_recv_pending(ctrl, 0, 1);
1965 else {
1966 /* verify that connection is still working */
1967 len = sizeof(buf) - 1;
1968 if (wpa_ctrl_request(ctrl, "PING", 4, buf, &len,
1969 wpa_cli_action_cb) < 0 ||
1970 len < 4 || os_memcmp(buf, "PONG", 4) != 0) {
1971 printf("wpa_supplicant did not reply to PING "
1972 "command - exiting\n");
1973 break;
1974 }
1975 }
1976 }
1977 #endif /* CONFIG_ANSI_C_EXTRA */
1978 }
1979
1980
1981 static void wpa_cli_cleanup(void)
1982 {
1983 wpa_cli_close_connection();
1984 if (pid_file)
1985 os_daemonize_terminate(pid_file);
1986
1987 os_program_deinit();
1988 }
1989
1990 static void wpa_cli_terminate(int sig)
1991 {
1992 wpa_cli_cleanup();
1993 exit(0);
1994 }
1995
1996
1997 #ifndef CONFIG_NATIVE_WINDOWS
1998 static void wpa_cli_alarm(int sig)
1999 {
2000 if (ctrl_conn && _wpa_ctrl_command(ctrl_conn, "PING", 0)) {
2001 printf("Connection to wpa_supplicant lost - trying to "
2002 "reconnect\n");
2003 wpa_cli_close_connection();
2004 }
2005 if (!ctrl_conn)
2006 wpa_cli_reconnect();
2007 if (mon_conn)
2008 wpa_cli_recv_pending(mon_conn, 1, 0);
2009 alarm(ping_interval);
2010 }
2011 #endif /* CONFIG_NATIVE_WINDOWS */
2012
2013
2014 static char * wpa_cli_get_default_ifname(void)
2015 {
2016 char *ifname = NULL;
2017
2018 #ifdef CONFIG_CTRL_IFACE_UNIX
2019 struct dirent *dent;
2020 DIR *dir = opendir(ctrl_iface_dir);
2021 if (!dir)
2022 return NULL;
2023 while ((dent = readdir(dir))) {
2024 #ifdef _DIRENT_HAVE_D_TYPE
2025 /*
2026 * Skip the file if it is not a socket. Also accept
2027 * DT_UNKNOWN (0) in case the C library or underlying
2028 * file system does not support d_type.
2029 */
2030 if (dent->d_type != DT_SOCK && dent->d_type != DT_UNKNOWN)
2031 continue;
2032 #endif /* _DIRENT_HAVE_D_TYPE */
2033 if (os_strcmp(dent->d_name, ".") == 0 ||
2034 os_strcmp(dent->d_name, "..") == 0)
2035 continue;
2036 printf("Selected interface '%s'\n", dent->d_name);
2037 ifname = os_strdup(dent->d_name);
2038 break;
2039 }
2040 closedir(dir);
2041 #endif /* CONFIG_CTRL_IFACE_UNIX */
2042
2043 #ifdef CONFIG_CTRL_IFACE_NAMED_PIPE
2044 char buf[2048], *pos;
2045 size_t len;
2046 struct wpa_ctrl *ctrl;
2047 int ret;
2048
2049 ctrl = wpa_ctrl_open(NULL);
2050 if (ctrl == NULL)
2051 return NULL;
2052
2053 len = sizeof(buf) - 1;
2054 ret = wpa_ctrl_request(ctrl, "INTERFACES", 10, buf, &len, NULL);
2055 if (ret >= 0) {
2056 buf[len] = '\0';
2057 pos = os_strchr(buf, '\n');
2058 if (pos)
2059 *pos = '\0';
2060 ifname = os_strdup(buf);
2061 }
2062 wpa_ctrl_close(ctrl);
2063 #endif /* CONFIG_CTRL_IFACE_NAMED_PIPE */
2064
2065 return ifname;
2066 }
2067
2068
2069 int main(int argc, char *argv[])
2070 {
2071 int warning_displayed = 0;
2072 int c;
2073 int daemonize = 0;
2074 int ret = 0;
2075 const char *global = NULL;
2076
2077 if (os_program_init())
2078 return -1;
2079
2080 for (;;) {
2081 c = getopt(argc, argv, "a:Bg:G:hi:p:P:v");
2082 if (c < 0)
2083 break;
2084 switch (c) {
2085 case 'a':
2086 action_file = optarg;
2087 break;
2088 case 'B':
2089 daemonize = 1;
2090 break;
2091 case 'g':
2092 global = optarg;
2093 break;
2094 case 'G':
2095 ping_interval = atoi(optarg);
2096 break;
2097 case 'h':
2098 usage();
2099 return 0;
2100 case 'v':
2101 printf("%s\n", wpa_cli_version);
2102 return 0;
2103 case 'i':
2104 os_free(ctrl_ifname);
2105 ctrl_ifname = os_strdup(optarg);
2106 break;
2107 case 'p':
2108 ctrl_iface_dir = optarg;
2109 break;
2110 case 'P':
2111 pid_file = optarg;
2112 break;
2113 default:
2114 usage();
2115 return -1;
2116 }
2117 }
2118
2119 interactive = (argc == optind) && (action_file == NULL);
2120
2121 if (interactive)
2122 printf("%s\n\n%s\n\n", wpa_cli_version, wpa_cli_license);
2123
2124 if (global) {
2125 #ifdef CONFIG_CTRL_IFACE_NAMED_PIPE
2126 ctrl_conn = wpa_ctrl_open(NULL);
2127 #else /* CONFIG_CTRL_IFACE_NAMED_PIPE */
2128 ctrl_conn = wpa_ctrl_open(global);
2129 #endif /* CONFIG_CTRL_IFACE_NAMED_PIPE */
2130 if (ctrl_conn == NULL) {
2131 perror("Failed to connect to wpa_supplicant - "
2132 "wpa_ctrl_open");
2133 return -1;
2134 }
2135 }
2136
2137 #ifndef _WIN32_WCE
2138 signal(SIGINT, wpa_cli_terminate);
2139 signal(SIGTERM, wpa_cli_terminate);
2140 #endif /* _WIN32_WCE */
2141 #ifndef CONFIG_NATIVE_WINDOWS
2142 signal(SIGALRM, wpa_cli_alarm);
2143 #endif /* CONFIG_NATIVE_WINDOWS */
2144
2145 if (ctrl_ifname == NULL)
2146 ctrl_ifname = wpa_cli_get_default_ifname();
2147
2148 if (interactive) {
2149 for (; !global;) {
2150 if (wpa_cli_open_connection(ctrl_ifname, 1) == 0) {
2151 if (warning_displayed)
2152 printf("Connection established.\n");
2153 break;
2154 }
2155
2156 if (!warning_displayed) {
2157 printf("Could not connect to wpa_supplicant - "
2158 "re-trying\n");
2159 warning_displayed = 1;
2160 }
2161 os_sleep(1, 0);
2162 continue;
2163 }
2164 } else {
2165 if (!global &&
2166 wpa_cli_open_connection(ctrl_ifname, 0) < 0) {
2167 perror("Failed to connect to wpa_supplicant - "
2168 "wpa_ctrl_open");
2169 return -1;
2170 }
2171
2172 if (action_file) {
2173 if (wpa_ctrl_attach(ctrl_conn) == 0) {
2174 wpa_cli_attached = 1;
2175 } else {
2176 printf("Warning: Failed to attach to "
2177 "wpa_supplicant.\n");
2178 return -1;
2179 }
2180 }
2181 }
2182
2183 if (daemonize && os_daemonize(pid_file))
2184 return -1;
2185
2186 if (interactive)
2187 wpa_cli_interactive();
2188 else if (action_file)
2189 wpa_cli_action(ctrl_conn);
2190 else
2191 ret = wpa_request(ctrl_conn, argc - optind, &argv[optind]);
2192
2193 os_free(ctrl_ifname);
2194 wpa_cli_cleanup();
2195
2196 return ret;
2197 }
2198
2199 #else /* CONFIG_CTRL_IFACE */
2200 int main(int argc, char *argv[])
2201 {
2202 printf("CONFIG_CTRL_IFACE not defined - wpa_cli disabled\n");
2203 return -1;
2204 }
2205 #endif /* CONFIG_CTRL_IFACE */
Unnamed repository; edit this file 'description' to name the repository.