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