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