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