1 /* 2 * hostapd - command line interface for hostapd daemon 3 * Copyright (c) 2004-2011, Jouni Malinen <j (at) 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 #include <dirent.h> 17 18 #include "common/wpa_ctrl.h" 19 #include "common.h" 20 #include "common/version.h" 21 22 23 static const char *hostapd_cli_version = 24 "hostapd_cli v" VERSION_STR "\n" 25 "Copyright (c) 2004-2011, Jouni Malinen <j (at) w1.fi> and contributors"; 26 27 28 static const char *hostapd_cli_license = 29 "This program is free software. You can distribute it and/or modify it\n" 30 "under the terms of the GNU General Public License version 2.\n" 31 "\n" 32 "Alternatively, this software may be distributed under the terms of the\n" 33 "BSD license. See README and COPYING for more details.\n"; 34 35 static const char *hostapd_cli_full_license = 36 "This program is free software; you can redistribute it and/or modify\n" 37 "it under the terms of the GNU General Public License version 2 as\n" 38 "published by the Free Software Foundation.\n" 39 "\n" 40 "This program is distributed in the hope that it will be useful,\n" 41 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n" 42 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n" 43 "GNU General Public License for more details.\n" 44 "\n" 45 "You should have received a copy of the GNU General Public License\n" 46 "along with this program; if not, write to the Free Software\n" 47 "Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\n" 48 "\n" 49 "Alternatively, this software may be distributed under the terms of the\n" 50 "BSD license.\n" 51 "\n" 52 "Redistribution and use in source and binary forms, with or without\n" 53 "modification, are permitted provided that the following conditions are\n" 54 "met:\n" 55 "\n" 56 "1. Redistributions of source code must retain the above copyright\n" 57 " notice, this list of conditions and the following disclaimer.\n" 58 "\n" 59 "2. Redistributions in binary form must reproduce the above copyright\n" 60 " notice, this list of conditions and the following disclaimer in the\n" 61 " documentation and/or other materials provided with the distribution.\n" 62 "\n" 63 "3. Neither the name(s) of the above-listed copyright holder(s) nor the\n" 64 " names of its contributors may be used to endorse or promote products\n" 65 " derived from this software without specific prior written permission.\n" 66 "\n" 67 "THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n" 68 "\"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n" 69 "LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n" 70 "A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n" 71 "OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n" 72 "SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n" 73 "LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n" 74 "DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n" 75 "THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n" 76 "(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n" 77 "OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n" 78 "\n"; 79 80 static const char *commands_help = 81 "Commands:\n" 82 " mib get MIB variables (dot1x, dot11, radius)\n" 83 " sta <addr> get MIB variables for one station\n" 84 " all_sta get MIB variables for all stations\n" 85 " new_sta <addr> add a new station\n" 86 " deauthenticate <addr> deauthenticate a station\n" 87 " disassociate <addr> disassociate a station\n" 88 #ifdef CONFIG_IEEE80211W 89 " sa_query <addr> send SA Query to a station\n" 90 #endif /* CONFIG_IEEE80211W */ 91 #ifdef CONFIG_WPS 92 " wps_pin <uuid> <pin> [timeout] [addr] add WPS Enrollee PIN\n" 93 " wps_check_pin <PIN> verify PIN checksum\n" 94 " wps_pbc indicate button pushed to initiate PBC\n" 95 #ifdef CONFIG_WPS_OOB 96 " wps_oob <type> <path> <method> use WPS with out-of-band (UFD)\n" 97 #endif /* CONFIG_WPS_OOB */ 98 " wps_ap_pin <cmd> [params..] enable/disable AP PIN\n" 99 " wps_config <SSID> <auth> <encr> <key> configure AP\n" 100 #endif /* CONFIG_WPS */ 101 " get_config show current configuration\n" 102 " help show this usage help\n" 103 " interface [ifname] show interfaces/select interface\n" 104 " level <debug level> change debug level\n" 105 " license show full hostapd_cli license\n" 106 " quit exit hostapd_cli\n"; 107 108 static struct wpa_ctrl *ctrl_conn; 109 static int hostapd_cli_quit = 0; 110 static int hostapd_cli_attached = 0; 111 static const char *ctrl_iface_dir = "/var/run/hostapd"; 112 static char *ctrl_ifname = NULL; 113 static const char *pid_file = NULL; 114 static const char *action_file = NULL; 115 static int ping_interval = 5; 116 117 118 static void usage(void) 119 { 120 fprintf(stderr, "%s\n", hostapd_cli_version); 121 fprintf(stderr, 122 "\n" 123 "usage: hostapd_cli [-p<path>] [-i<ifname>] [-hvB] " 124 "[-a<path>] \\\n" 125 " [-G<ping interval>] [command..]\n" 126 "\n" 127 "Options:\n" 128 " -h help (show this usage text)\n" 129 " -v shown version information\n" 130 " -p<path> path to find control sockets (default: " 131 "/var/run/hostapd)\n" 132 " -a<file> run in daemon mode executing the action file " 133 "based on events\n" 134 " from hostapd\n" 135 " -B run a daemon in the background\n" 136 " -i<ifname> Interface to listen on (default: first " 137 "interface found in the\n" 138 " socket path)\n\n" 139 "%s", 140 commands_help); 141 } 142 143 144 static struct wpa_ctrl * hostapd_cli_open_connection(const char *ifname) 145 { 146 char *cfile; 147 int flen; 148 149 if (ifname == NULL) 150 return NULL; 151 152 flen = strlen(ctrl_iface_dir) + strlen(ifname) + 2; 153 cfile = malloc(flen); 154 if (cfile == NULL) 155 return NULL; 156 snprintf(cfile, flen, "%s/%s", ctrl_iface_dir, ifname); 157 158 ctrl_conn = wpa_ctrl_open(cfile); 159 free(cfile); 160 return ctrl_conn; 161 } 162 163 164 static void hostapd_cli_close_connection(void) 165 { 166 if (ctrl_conn == NULL) 167 return; 168 169 if (hostapd_cli_attached) { 170 wpa_ctrl_detach(ctrl_conn); 171 hostapd_cli_attached = 0; 172 } 173 wpa_ctrl_close(ctrl_conn); 174 ctrl_conn = NULL; 175 } 176 177 178 static void hostapd_cli_msg_cb(char *msg, size_t len) 179 { 180 printf("%s\n", msg); 181 } 182 183 184 static int _wpa_ctrl_command(struct wpa_ctrl *ctrl, char *cmd, int print) 185 { 186 char buf[4096]; 187 size_t len; 188 int ret; 189 190 if (ctrl_conn == NULL) { 191 printf("Not connected to hostapd - command dropped.\n"); 192 return -1; 193 } 194 len = sizeof(buf) - 1; 195 ret = wpa_ctrl_request(ctrl, cmd, strlen(cmd), buf, &len, 196 hostapd_cli_msg_cb); 197 if (ret == -2) { 198 printf("'%s' command timed out.\n", cmd); 199 return -2; 200 } else if (ret < 0) { 201 printf("'%s' command failed.\n", cmd); 202 return -1; 203 } 204 if (print) { 205 buf[len] = '\0'; 206 printf("%s", buf); 207 } 208 return 0; 209 } 210 211 212 static inline int wpa_ctrl_command(struct wpa_ctrl *ctrl, char *cmd) 213 { 214 return _wpa_ctrl_command(ctrl, cmd, 1); 215 } 216 217 218 static int hostapd_cli_cmd_ping(struct wpa_ctrl *ctrl, int argc, char *argv[]) 219 { 220 return wpa_ctrl_command(ctrl, "PING"); 221 } 222 223 224 static int hostapd_cli_cmd_relog(struct wpa_ctrl *ctrl, int argc, char *argv[]) 225 { 226 return wpa_ctrl_command(ctrl, "RELOG"); 227 } 228 229 230 static int hostapd_cli_cmd_mib(struct wpa_ctrl *ctrl, int argc, char *argv[]) 231 { 232 return wpa_ctrl_command(ctrl, "MIB"); 233 } 234 235 236 static int hostapd_cli_exec(const char *program, const char *arg1, 237 const char *arg2) 238 { 239 char *cmd; 240 size_t len; 241 int res; 242 int ret = 0; 243 244 len = os_strlen(program) + os_strlen(arg1) + os_strlen(arg2) + 3; 245 cmd = os_malloc(len); 246 if (cmd == NULL) 247 return -1; 248 res = os_snprintf(cmd, len, "%s %s %s", program, arg1, arg2); 249 if (res < 0 || (size_t) res >= len) { 250 os_free(cmd); 251 return -1; 252 } 253 cmd[len - 1] = '\0'; 254 #ifndef _WIN32_WCE 255 if (system(cmd) < 0) 256 ret = -1; 257 #endif /* _WIN32_WCE */ 258 os_free(cmd); 259 260 return ret; 261 } 262 263 264 static void hostapd_cli_action_process(char *msg, size_t len) 265 { 266 const char *pos; 267 268 pos = msg; 269 if (*pos == '<') { 270 pos = os_strchr(pos, '>'); 271 if (pos) 272 pos++; 273 else 274 pos = msg; 275 } 276 277 hostapd_cli_exec(action_file, ctrl_ifname, pos); 278 } 279 280 281 static int hostapd_cli_cmd_sta(struct wpa_ctrl *ctrl, int argc, char *argv[]) 282 { 283 char buf[64]; 284 if (argc != 1) { 285 printf("Invalid 'sta' command - exactly one argument, STA " 286 "address, is required.\n"); 287 return -1; 288 } 289 snprintf(buf, sizeof(buf), "STA %s", argv[0]); 290 return wpa_ctrl_command(ctrl, buf); 291 } 292 293 294 static int hostapd_cli_cmd_new_sta(struct wpa_ctrl *ctrl, int argc, 295 char *argv[]) 296 { 297 char buf[64]; 298 if (argc != 1) { 299 printf("Invalid 'new_sta' command - exactly one argument, STA " 300 "address, is required.\n"); 301 return -1; 302 } 303 snprintf(buf, sizeof(buf), "NEW_STA %s", argv[0]); 304 return wpa_ctrl_command(ctrl, buf); 305 } 306 307 308 static int hostapd_cli_cmd_deauthenticate(struct wpa_ctrl *ctrl, int argc, 309 char *argv[]) 310 { 311 char buf[64]; 312 if (argc < 1) { 313 printf("Invalid 'deauthenticate' command - exactly one " 314 "argument, STA address, is required.\n"); 315 return -1; 316 } 317 if (argc > 1) 318 os_snprintf(buf, sizeof(buf), "DEAUTHENTICATE %s %s", 319 argv[0], argv[1]); 320 else 321 os_snprintf(buf, sizeof(buf), "DEAUTHENTICATE %s", argv[0]); 322 return wpa_ctrl_command(ctrl, buf); 323 } 324 325 326 static int hostapd_cli_cmd_disassociate(struct wpa_ctrl *ctrl, int argc, 327 char *argv[]) 328 { 329 char buf[64]; 330 if (argc < 1) { 331 printf("Invalid 'disassociate' command - exactly one " 332 "argument, STA address, is required.\n"); 333 return -1; 334 } 335 if (argc > 1) 336 os_snprintf(buf, sizeof(buf), "DISASSOCIATE %s %s", 337 argv[0], argv[1]); 338 else 339 os_snprintf(buf, sizeof(buf), "DISASSOCIATE %s", argv[0]); 340 return wpa_ctrl_command(ctrl, buf); 341 } 342 343 344 #ifdef CONFIG_IEEE80211W 345 static int hostapd_cli_cmd_sa_query(struct wpa_ctrl *ctrl, int argc, 346 char *argv[]) 347 { 348 char buf[64]; 349 if (argc != 1) { 350 printf("Invalid 'sa_query' command - exactly one argument, " 351 "STA address, is required.\n"); 352 return -1; 353 } 354 snprintf(buf, sizeof(buf), "SA_QUERY %s", argv[0]); 355 return wpa_ctrl_command(ctrl, buf); 356 } 357 #endif /* CONFIG_IEEE80211W */ 358 359 360 #ifdef CONFIG_WPS 361 static int hostapd_cli_cmd_wps_pin(struct wpa_ctrl *ctrl, int argc, 362 char *argv[]) 363 { 364 char buf[256]; 365 if (argc < 2) { 366 printf("Invalid 'wps_pin' command - at least two arguments, " 367 "UUID and PIN, are required.\n"); 368 return -1; 369 } 370 if (argc > 3) 371 snprintf(buf, sizeof(buf), "WPS_PIN %s %s %s %s", 372 argv[0], argv[1], argv[2], argv[3]); 373 else if (argc > 2) 374 snprintf(buf, sizeof(buf), "WPS_PIN %s %s %s", 375 argv[0], argv[1], argv[2]); 376 else 377 snprintf(buf, sizeof(buf), "WPS_PIN %s %s", argv[0], argv[1]); 378 return wpa_ctrl_command(ctrl, buf); 379 } 380 381 382 static int hostapd_cli_cmd_wps_check_pin(struct wpa_ctrl *ctrl, int argc, 383 char *argv[]) 384 { 385 char cmd[256]; 386 int res; 387 388 if (argc != 1 && argc != 2) { 389 printf("Invalid WPS_CHECK_PIN command: needs one argument:\n" 390 "- PIN to be verified\n"); 391 return -1; 392 } 393 394 if (argc == 2) 395 res = os_snprintf(cmd, sizeof(cmd), "WPS_CHECK_PIN %s %s", 396 argv[0], argv[1]); 397 else 398 res = os_snprintf(cmd, sizeof(cmd), "WPS_CHECK_PIN %s", 399 argv[0]); 400 if (res < 0 || (size_t) res >= sizeof(cmd) - 1) { 401 printf("Too long WPS_CHECK_PIN command.\n"); 402 return -1; 403 } 404 return wpa_ctrl_command(ctrl, cmd); 405 } 406 407 408 static int hostapd_cli_cmd_wps_pbc(struct wpa_ctrl *ctrl, int argc, 409 char *argv[]) 410 { 411 return wpa_ctrl_command(ctrl, "WPS_PBC"); 412 } 413 414 415 #ifdef CONFIG_WPS_OOB 416 static int hostapd_cli_cmd_wps_oob(struct wpa_ctrl *ctrl, int argc, 417 char *argv[]) 418 { 419 char cmd[256]; 420 int res; 421 422 if (argc != 3 && argc != 4) { 423 printf("Invalid WPS_OOB command: need three or four " 424 "arguments:\n" 425 "- DEV_TYPE: use 'ufd' or 'nfc'\n" 426 "- PATH: path of OOB device like '/mnt'\n" 427 "- METHOD: OOB method 'pin-e' or 'pin-r', " 428 "'cred'\n" 429 "- DEV_NAME: (only for NFC) device name like " 430 "'pn531'\n"); 431 return -1; 432 } 433 434 if (argc == 3) 435 res = os_snprintf(cmd, sizeof(cmd), "WPS_OOB %s %s %s", 436 argv[0], argv[1], argv[2]); 437 else 438 res = os_snprintf(cmd, sizeof(cmd), "WPS_OOB %s %s %s %s", 439 argv[0], argv[1], argv[2], argv[3]); 440 if (res < 0 || (size_t) res >= sizeof(cmd) - 1) { 441 printf("Too long WPS_OOB command.\n"); 442 return -1; 443 } 444 return wpa_ctrl_command(ctrl, cmd); 445 } 446 #endif /* CONFIG_WPS_OOB */ 447 448 449 static int hostapd_cli_cmd_wps_ap_pin(struct wpa_ctrl *ctrl, int argc, 450 char *argv[]) 451 { 452 char buf[64]; 453 if (argc < 1) { 454 printf("Invalid 'wps_ap_pin' command - at least one argument " 455 "is required.\n"); 456 return -1; 457 } 458 if (argc > 2) 459 snprintf(buf, sizeof(buf), "WPS_AP_PIN %s %s %s", 460 argv[0], argv[1], argv[2]); 461 else if (argc > 1) 462 snprintf(buf, sizeof(buf), "WPS_AP_PIN %s %s", 463 argv[0], argv[1]); 464 else 465 snprintf(buf, sizeof(buf), "WPS_AP_PIN %s", argv[0]); 466 return wpa_ctrl_command(ctrl, buf); 467 } 468 469 470 static int hostapd_cli_cmd_wps_config(struct wpa_ctrl *ctrl, int argc, 471 char *argv[]) 472 { 473 char buf[256]; 474 char ssid_hex[2 * 32 + 1]; 475 char key_hex[2 * 64 + 1]; 476 int i; 477 478 if (argc < 1) { 479 printf("Invalid 'wps_config' command - at least two arguments " 480 "are required.\n"); 481 return -1; 482 } 483 484 ssid_hex[0] = '\0'; 485 for (i = 0; i < 32; i++) { 486 if (argv[0][i] == '\0') 487 break; 488 os_snprintf(&ssid_hex[i * 2], 3, "%02x", argv[0][i]); 489 } 490 491 key_hex[0] = '\0'; 492 if (argc > 3) { 493 for (i = 0; i < 64; i++) { 494 if (argv[3][i] == '\0') 495 break; 496 os_snprintf(&key_hex[i * 2], 3, "%02x", 497 argv[3][i]); 498 } 499 } 500 501 if (argc > 3) 502 snprintf(buf, sizeof(buf), "WPS_CONFIG %s %s %s %s", 503 ssid_hex, argv[1], argv[2], key_hex); 504 else if (argc > 2) 505 snprintf(buf, sizeof(buf), "WPS_CONFIG %s %s %s", 506 ssid_hex, argv[1], argv[2]); 507 else 508 snprintf(buf, sizeof(buf), "WPS_CONFIG %s %s", 509 ssid_hex, argv[1]); 510 return wpa_ctrl_command(ctrl, buf); 511 } 512 #endif /* CONFIG_WPS */ 513 514 515 static int hostapd_cli_cmd_get_config(struct wpa_ctrl *ctrl, int argc, 516 char *argv[]) 517 { 518 return wpa_ctrl_command(ctrl, "GET_CONFIG"); 519 } 520 521 522 static int wpa_ctrl_command_sta(struct wpa_ctrl *ctrl, char *cmd, 523 char *addr, size_t addr_len) 524 { 525 char buf[4096], *pos; 526 size_t len; 527 int ret; 528 529 if (ctrl_conn == NULL) { 530 printf("Not connected to hostapd - command dropped.\n"); 531 return -1; 532 } 533 len = sizeof(buf) - 1; 534 ret = wpa_ctrl_request(ctrl, cmd, strlen(cmd), buf, &len, 535 hostapd_cli_msg_cb); 536 if (ret == -2) { 537 printf("'%s' command timed out.\n", cmd); 538 return -2; 539 } else if (ret < 0) { 540 printf("'%s' command failed.\n", cmd); 541 return -1; 542 } 543 544 buf[len] = '\0'; 545 if (memcmp(buf, "FAIL", 4) == 0) 546 return -1; 547 printf("%s", buf); 548 549 pos = buf; 550 while (*pos != '\0' && *pos != '\n') 551 pos++; 552 *pos = '\0'; 553 os_strlcpy(addr, buf, addr_len); 554 return 0; 555 } 556 557 558 static int hostapd_cli_cmd_all_sta(struct wpa_ctrl *ctrl, int argc, 559 char *argv[]) 560 { 561 char addr[32], cmd[64]; 562 563 if (wpa_ctrl_command_sta(ctrl, "STA-FIRST", addr, sizeof(addr))) 564 return 0; 565 do { 566 snprintf(cmd, sizeof(cmd), "STA-NEXT %s", addr); 567 } while (wpa_ctrl_command_sta(ctrl, cmd, addr, sizeof(addr)) == 0); 568 569 return -1; 570 } 571 572 573 static int hostapd_cli_cmd_help(struct wpa_ctrl *ctrl, int argc, char *argv[]) 574 { 575 printf("%s", commands_help); 576 return 0; 577 } 578 579 580 static int hostapd_cli_cmd_license(struct wpa_ctrl *ctrl, int argc, 581 char *argv[]) 582 { 583 printf("%s\n\n%s\n", hostapd_cli_version, hostapd_cli_full_license); 584 return 0; 585 } 586 587 588 static int hostapd_cli_cmd_quit(struct wpa_ctrl *ctrl, int argc, char *argv[]) 589 { 590 hostapd_cli_quit = 1; 591 return 0; 592 } 593 594 595 static int hostapd_cli_cmd_level(struct wpa_ctrl *ctrl, int argc, char *argv[]) 596 { 597 char cmd[256]; 598 if (argc != 1) { 599 printf("Invalid LEVEL command: needs one argument (debug " 600 "level)\n"); 601 return 0; 602 } 603 snprintf(cmd, sizeof(cmd), "LEVEL %s", argv[0]); 604 return wpa_ctrl_command(ctrl, cmd); 605 } 606 607 608 static void hostapd_cli_list_interfaces(struct wpa_ctrl *ctrl) 609 { 610 struct dirent *dent; 611 DIR *dir; 612 613 dir = opendir(ctrl_iface_dir); 614 if (dir == NULL) { 615 printf("Control interface directory '%s' could not be " 616 "openned.\n", ctrl_iface_dir); 617 return; 618 } 619 620 printf("Available interfaces:\n"); 621 while ((dent = readdir(dir))) { 622 if (strcmp(dent->d_name, ".") == 0 || 623 strcmp(dent->d_name, "..") == 0) 624 continue; 625 printf("%s\n", dent->d_name); 626 } 627 closedir(dir); 628 } 629 630 631 static int hostapd_cli_cmd_interface(struct wpa_ctrl *ctrl, int argc, 632 char *argv[]) 633 { 634 if (argc < 1) { 635 hostapd_cli_list_interfaces(ctrl); 636 return 0; 637 } 638 639 hostapd_cli_close_connection(); 640 free(ctrl_ifname); 641 ctrl_ifname = strdup(argv[0]); 642 643 if (hostapd_cli_open_connection(ctrl_ifname)) { 644 printf("Connected to interface '%s.\n", ctrl_ifname); 645 if (wpa_ctrl_attach(ctrl_conn) == 0) { 646 hostapd_cli_attached = 1; 647 } else { 648 printf("Warning: Failed to attach to " 649 "hostapd.\n"); 650 } 651 } else { 652 printf("Could not connect to interface '%s' - re-trying\n", 653 ctrl_ifname); 654 } 655 return 0; 656 } 657 658 659 static int hostapd_cli_cmd_set(struct wpa_ctrl *ctrl, int argc, char *argv[]) 660 { 661 char cmd[256]; 662 int res; 663 664 if (argc != 2) { 665 printf("Invalid SET command: needs two arguments (variable " 666 "name and value)\n"); 667 return -1; 668 } 669 670 res = os_snprintf(cmd, sizeof(cmd), "SET %s %s", argv[0], argv[1]); 671 if (res < 0 || (size_t) res >= sizeof(cmd) - 1) { 672 printf("Too long SET command.\n"); 673 return -1; 674 } 675 return wpa_ctrl_command(ctrl, cmd); 676 } 677 678 679 static int hostapd_cli_cmd_get(struct wpa_ctrl *ctrl, int argc, char *argv[]) 680 { 681 char cmd[256]; 682 int res; 683 684 if (argc != 1) { 685 printf("Invalid GET command: needs one argument (variable " 686 "name)\n"); 687 return -1; 688 } 689 690 res = os_snprintf(cmd, sizeof(cmd), "GET %s", argv[0]); 691 if (res < 0 || (size_t) res >= sizeof(cmd) - 1) { 692 printf("Too long GET command.\n"); 693 return -1; 694 } 695 return wpa_ctrl_command(ctrl, cmd); 696 } 697 698 699 struct hostapd_cli_cmd { 700 const char *cmd; 701 int (*handler)(struct wpa_ctrl *ctrl, int argc, char *argv[]); 702 }; 703 704 static struct hostapd_cli_cmd hostapd_cli_commands[] = { 705 { "ping", hostapd_cli_cmd_ping }, 706 { "mib", hostapd_cli_cmd_mib }, 707 { "relog", hostapd_cli_cmd_relog }, 708 { "sta", hostapd_cli_cmd_sta }, 709 { "all_sta", hostapd_cli_cmd_all_sta }, 710 { "new_sta", hostapd_cli_cmd_new_sta }, 711 { "deauthenticate", hostapd_cli_cmd_deauthenticate }, 712 { "disassociate", hostapd_cli_cmd_disassociate }, 713 #ifdef CONFIG_IEEE80211W 714 { "sa_query", hostapd_cli_cmd_sa_query }, 715 #endif /* CONFIG_IEEE80211W */ 716 #ifdef CONFIG_WPS 717 { "wps_pin", hostapd_cli_cmd_wps_pin }, 718 { "wps_check_pin", hostapd_cli_cmd_wps_check_pin }, 719 { "wps_pbc", hostapd_cli_cmd_wps_pbc }, 720 #ifdef CONFIG_WPS_OOB 721 { "wps_oob", hostapd_cli_cmd_wps_oob }, 722 #endif /* CONFIG_WPS_OOB */ 723 { "wps_ap_pin", hostapd_cli_cmd_wps_ap_pin }, 724 { "wps_config", hostapd_cli_cmd_wps_config }, 725 #endif /* CONFIG_WPS */ 726 { "get_config", hostapd_cli_cmd_get_config }, 727 { "help", hostapd_cli_cmd_help }, 728 { "interface", hostapd_cli_cmd_interface }, 729 { "level", hostapd_cli_cmd_level }, 730 { "license", hostapd_cli_cmd_license }, 731 { "quit", hostapd_cli_cmd_quit }, 732 { "set", hostapd_cli_cmd_set }, 733 { "get", hostapd_cli_cmd_get }, 734 { NULL, NULL } 735 }; 736 737 738 static void wpa_request(struct wpa_ctrl *ctrl, int argc, char *argv[]) 739 { 740 struct hostapd_cli_cmd *cmd, *match = NULL; 741 int count; 742 743 count = 0; 744 cmd = hostapd_cli_commands; 745 while (cmd->cmd) { 746 if (strncasecmp(cmd->cmd, argv[0], strlen(argv[0])) == 0) { 747 match = cmd; 748 if (os_strcasecmp(cmd->cmd, argv[0]) == 0) { 749 /* we have an exact match */ 750 count = 1; 751 break; 752 } 753 count++; 754 } 755 cmd++; 756 } 757 758 if (count > 1) { 759 printf("Ambiguous command '%s'; possible commands:", argv[0]); 760 cmd = hostapd_cli_commands; 761 while (cmd->cmd) { 762 if (strncasecmp(cmd->cmd, argv[0], strlen(argv[0])) == 763 0) { 764 printf(" %s", cmd->cmd); 765 } 766 cmd++; 767 } 768 printf("\n"); 769 } else if (count == 0) { 770 printf("Unknown command '%s'\n", argv[0]); 771 } else { 772 match->handler(ctrl, argc - 1, &argv[1]); 773 } 774 } 775 776 777 static void hostapd_cli_recv_pending(struct wpa_ctrl *ctrl, int in_read, 778 int action_monitor) 779 { 780 int first = 1; 781 if (ctrl_conn == NULL) 782 return; 783 while (wpa_ctrl_pending(ctrl)) { 784 char buf[256]; 785 size_t len = sizeof(buf) - 1; 786 if (wpa_ctrl_recv(ctrl, buf, &len) == 0) { 787 buf[len] = '\0'; 788 if (action_monitor) 789 hostapd_cli_action_process(buf, len); 790 else { 791 if (in_read && first) 792 printf("\n"); 793 first = 0; 794 printf("%s\n", buf); 795 } 796 } else { 797 printf("Could not read pending message.\n"); 798 break; 799 } 800 } 801 } 802 803 804 static void hostapd_cli_interactive(void) 805 { 806 const int max_args = 10; 807 char cmd[256], *res, *argv[max_args], *pos; 808 int argc; 809 810 printf("\nInteractive mode\n\n"); 811 812 do { 813 hostapd_cli_recv_pending(ctrl_conn, 0, 0); 814 printf("> "); 815 alarm(ping_interval); 816 res = fgets(cmd, sizeof(cmd), stdin); 817 alarm(0); 818 if (res == NULL) 819 break; 820 pos = cmd; 821 while (*pos != '\0') { 822 if (*pos == '\n') { 823 *pos = '\0'; 824 break; 825 } 826 pos++; 827 } 828 argc = 0; 829 pos = cmd; 830 for (;;) { 831 while (*pos == ' ') 832 pos++; 833 if (*pos == '\0') 834 break; 835 argv[argc] = pos; 836 argc++; 837 if (argc == max_args) 838 break; 839 while (*pos != '\0' && *pos != ' ') 840 pos++; 841 if (*pos == ' ') 842 *pos++ = '\0'; 843 } 844 if (argc) 845 wpa_request(ctrl_conn, argc, argv); 846 } while (!hostapd_cli_quit); 847 } 848 849 850 static void hostapd_cli_cleanup(void) 851 { 852 hostapd_cli_close_connection(); 853 if (pid_file) 854 os_daemonize_terminate(pid_file); 855 856 os_program_deinit(); 857 } 858 859 860 static void hostapd_cli_terminate(int sig) 861 { 862 hostapd_cli_cleanup(); 863 exit(0); 864 } 865 866 867 static void hostapd_cli_alarm(int sig) 868 { 869 if (ctrl_conn && _wpa_ctrl_command(ctrl_conn, "PING", 0)) { 870 printf("Connection to hostapd lost - trying to reconnect\n"); 871 hostapd_cli_close_connection(); 872 } 873 if (!ctrl_conn) { 874 ctrl_conn = hostapd_cli_open_connection(ctrl_ifname); 875 if (ctrl_conn) { 876 printf("Connection to hostapd re-established\n"); 877 if (wpa_ctrl_attach(ctrl_conn) == 0) { 878 hostapd_cli_attached = 1; 879 } else { 880 printf("Warning: Failed to attach to " 881 "hostapd.\n"); 882 } 883 } 884 } 885 if (ctrl_conn) 886 hostapd_cli_recv_pending(ctrl_conn, 1, 0); 887 alarm(ping_interval); 888 } 889 890 891 static void hostapd_cli_action(struct wpa_ctrl *ctrl) 892 { 893 fd_set rfds; 894 int fd, res; 895 struct timeval tv; 896 char buf[256]; 897 size_t len; 898 899 fd = wpa_ctrl_get_fd(ctrl); 900 901 while (!hostapd_cli_quit) { 902 FD_ZERO(&rfds); 903 FD_SET(fd, &rfds); 904 tv.tv_sec = ping_interval; 905 tv.tv_usec = 0; 906 res = select(fd + 1, &rfds, NULL, NULL, &tv); 907 if (res < 0 && errno != EINTR) { 908 perror("select"); 909 break; 910 } 911 912 if (FD_ISSET(fd, &rfds)) 913 hostapd_cli_recv_pending(ctrl, 0, 1); 914 else { 915 len = sizeof(buf) - 1; 916 if (wpa_ctrl_request(ctrl, "PING", 4, buf, &len, 917 hostapd_cli_action_process) < 0 || 918 len < 4 || os_memcmp(buf, "PONG", 4) != 0) { 919 printf("hostapd did not reply to PING " 920 "command - exiting\n"); 921 break; 922 } 923 } 924 } 925 } 926 927 928 int main(int argc, char *argv[]) 929 { 930 int interactive; 931 int warning_displayed = 0; 932 int c; 933 int daemonize = 0; 934 935 if (os_program_init()) 936 return -1; 937 938 for (;;) { 939 c = getopt(argc, argv, "a:BhG:i:p:v"); 940 if (c < 0) 941 break; 942 switch (c) { 943 case 'a': 944 action_file = optarg; 945 break; 946 case 'B': 947 daemonize = 1; 948 break; 949 case 'G': 950 ping_interval = atoi(optarg); 951 break; 952 case 'h': 953 usage(); 954 return 0; 955 case 'v': 956 printf("%s\n", hostapd_cli_version); 957 return 0; 958 case 'i': 959 os_free(ctrl_ifname); 960 ctrl_ifname = os_strdup(optarg); 961 break; 962 case 'p': 963 ctrl_iface_dir = optarg; 964 break; 965 default: 966 usage(); 967 return -1; 968 } 969 } 970 971 interactive = (argc == optind) && (action_file == NULL); 972 973 if (interactive) { 974 printf("%s\n\n%s\n\n", hostapd_cli_version, 975 hostapd_cli_license); 976 } 977 978 for (;;) { 979 if (ctrl_ifname == NULL) { 980 struct dirent *dent; 981 DIR *dir = opendir(ctrl_iface_dir); 982 if (dir) { 983 while ((dent = readdir(dir))) { 984 if (os_strcmp(dent->d_name, ".") == 0 985 || 986 os_strcmp(dent->d_name, "..") == 0) 987 continue; 988 printf("Selected interface '%s'\n", 989 dent->d_name); 990 ctrl_ifname = os_strdup(dent->d_name); 991 break; 992 } 993 closedir(dir); 994 } 995 } 996 ctrl_conn = hostapd_cli_open_connection(ctrl_ifname); 997 if (ctrl_conn) { 998 if (warning_displayed) 999 printf("Connection established.\n"); 1000 break; 1001 } 1002 1003 if (!interactive) { 1004 perror("Failed to connect to hostapd - " 1005 "wpa_ctrl_open"); 1006 return -1; 1007 } 1008 1009 if (!warning_displayed) { 1010 printf("Could not connect to hostapd - re-trying\n"); 1011 warning_displayed = 1; 1012 } 1013 os_sleep(1, 0); 1014 continue; 1015 } 1016 1017 signal(SIGINT, hostapd_cli_terminate); 1018 signal(SIGTERM, hostapd_cli_terminate); 1019 signal(SIGALRM, hostapd_cli_alarm); 1020 1021 if (interactive || action_file) { 1022 if (wpa_ctrl_attach(ctrl_conn) == 0) { 1023 hostapd_cli_attached = 1; 1024 } else { 1025 printf("Warning: Failed to attach to hostapd.\n"); 1026 if (action_file) 1027 return -1; 1028 } 1029 } 1030 1031 if (daemonize && os_daemonize(pid_file)) 1032 return -1; 1033 1034 if (interactive) 1035 hostapd_cli_interactive(); 1036 else if (action_file) 1037 hostapd_cli_action(ctrl_conn); 1038 else 1039 wpa_request(ctrl_conn, argc - optind, &argv[optind]); 1040 1041 os_free(ctrl_ifname); 1042 hostapd_cli_cleanup(); 1043 return 0; 1044 } 1045
