1 /* 2 * hostapd - command line interface for hostapd daemon 3 * Copyright (c) 2004-2019, Jouni Malinen <j@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 "common/ieee802_11_defs.h" 14 #include "utils/common.h" 15 #include "utils/eloop.h" 16 #include "utils/edit.h" 17 #include "common/version.h" 18 #include "common/cli.h" 19 20 #ifndef CONFIG_NO_CTRL_IFACE 21 22 static const char *const hostapd_cli_version = 23 "hostapd_cli v" VERSION_STR "\n" 24 "Copyright (c) 2004-2019, Jouni Malinen <j@w1.fi> and contributors"; 25 26 static struct wpa_ctrl *ctrl_conn; 27 static int hostapd_cli_quit = 0; 28 static int hostapd_cli_attached = 0; 29 30 #ifndef CONFIG_CTRL_IFACE_DIR 31 #define CONFIG_CTRL_IFACE_DIR "/var/run/hostapd" 32 #endif /* CONFIG_CTRL_IFACE_DIR */ 33 static const char *ctrl_iface_dir = CONFIG_CTRL_IFACE_DIR; 34 static const char *client_socket_dir = NULL; 35 36 static char *ctrl_ifname = NULL; 37 static const char *pid_file = NULL; 38 static const char *action_file = NULL; 39 static int ping_interval = 5; 40 static int interactive = 0; 41 static int event_handler_registered = 0; 42 43 static DEFINE_DL_LIST(stations); /* struct cli_txt_entry */ 44 45 static void print_help(FILE *stream, const char *cmd); 46 static char ** list_cmd_list(void); 47 static void hostapd_cli_receive(int sock, void *eloop_ctx, void *sock_ctx); 48 static void update_stations(struct wpa_ctrl *ctrl); 49 static void cli_event(const char *str); 50 51 52 static void usage(void) 53 { 54 fprintf(stderr, "%s\n", hostapd_cli_version); 55 fprintf(stderr, 56 "\n" 57 "usage: hostapd_cli [-p<path>] [-i<ifname>] [-hvBr] " 58 "[-a<path>] \\\n" 59 " [-P<pid file>] [-G<ping interval>] [command..]\n" 60 "\n" 61 "Options:\n" 62 " -h help (show this usage text)\n" 63 " -v shown version information\n" 64 " -p<path> path to find control sockets (default: " 65 "/var/run/hostapd)\n" 66 " -s<dir_path> dir path to open client sockets (default: " 67 CONFIG_CTRL_IFACE_DIR ")\n" 68 " -a<file> run in daemon mode executing the action file " 69 "based on events\n" 70 " from hostapd\n" 71 " -r try to reconnect when client socket is " 72 "disconnected.\n" 73 " This is useful only when used with -a.\n" 74 " -B run a daemon in the background\n" 75 " -i<ifname> Interface to listen on (default: first " 76 "interface found in the\n" 77 " socket path)\n\n"); 78 print_help(stderr, NULL); 79 } 80 81 82 static void register_event_handler(struct wpa_ctrl *ctrl) 83 { 84 if (!ctrl_conn) 85 return; 86 if (interactive) { 87 event_handler_registered = 88 !eloop_register_read_sock(wpa_ctrl_get_fd(ctrl), 89 hostapd_cli_receive, 90 NULL, NULL); 91 } 92 } 93 94 95 static void unregister_event_handler(struct wpa_ctrl *ctrl) 96 { 97 if (!ctrl_conn) 98 return; 99 if (interactive && event_handler_registered) { 100 eloop_unregister_read_sock(wpa_ctrl_get_fd(ctrl)); 101 event_handler_registered = 0; 102 } 103 } 104 105 106 static struct wpa_ctrl * hostapd_cli_open_connection(const char *ifname) 107 { 108 #ifndef CONFIG_CTRL_IFACE_UDP 109 char *cfile; 110 int flen; 111 #endif /* !CONFIG_CTRL_IFACE_UDP */ 112 113 if (ifname == NULL) 114 return NULL; 115 116 #ifdef CONFIG_CTRL_IFACE_UDP 117 ctrl_conn = wpa_ctrl_open(ifname); 118 return ctrl_conn; 119 #else /* CONFIG_CTRL_IFACE_UDP */ 120 flen = strlen(ctrl_iface_dir) + strlen(ifname) + 2; 121 cfile = malloc(flen); 122 if (cfile == NULL) 123 return NULL; 124 snprintf(cfile, flen, "%s/%s", ctrl_iface_dir, ifname); 125 126 if (client_socket_dir && client_socket_dir[0] && 127 access(client_socket_dir, F_OK) < 0) { 128 perror(client_socket_dir); 129 free(cfile); 130 return NULL; 131 } 132 133 ctrl_conn = wpa_ctrl_open2(cfile, client_socket_dir); 134 free(cfile); 135 return ctrl_conn; 136 #endif /* CONFIG_CTRL_IFACE_UDP */ 137 } 138 139 140 static void hostapd_cli_close_connection(void) 141 { 142 if (ctrl_conn == NULL) 143 return; 144 145 unregister_event_handler(ctrl_conn); 146 if (hostapd_cli_attached) { 147 wpa_ctrl_detach(ctrl_conn); 148 hostapd_cli_attached = 0; 149 } 150 wpa_ctrl_close(ctrl_conn); 151 ctrl_conn = NULL; 152 } 153 154 155 static int hostapd_cli_reconnect(const char *ifname) 156 { 157 char *next_ctrl_ifname; 158 159 hostapd_cli_close_connection(); 160 161 if (!ifname) 162 return -1; 163 164 next_ctrl_ifname = os_strdup(ifname); 165 os_free(ctrl_ifname); 166 ctrl_ifname = next_ctrl_ifname; 167 if (!ctrl_ifname) 168 return -1; 169 170 ctrl_conn = hostapd_cli_open_connection(ctrl_ifname); 171 if (!ctrl_conn) 172 return -1; 173 if (!interactive && !action_file) 174 return 0; 175 if (wpa_ctrl_attach(ctrl_conn) == 0) { 176 hostapd_cli_attached = 1; 177 register_event_handler(ctrl_conn); 178 update_stations(ctrl_conn); 179 } else { 180 printf("Warning: Failed to attach to hostapd.\n"); 181 } 182 return 0; 183 } 184 185 186 static void hostapd_cli_msg_cb(char *msg, size_t len) 187 { 188 cli_event(msg); 189 printf("%s\n", msg); 190 } 191 192 193 static int _wpa_ctrl_command(struct wpa_ctrl *ctrl, const char *cmd, int print) 194 { 195 char buf[4096]; 196 size_t len; 197 int ret; 198 199 if (ctrl_conn == NULL) { 200 printf("Not connected to hostapd - command dropped.\n"); 201 return -1; 202 } 203 len = sizeof(buf) - 1; 204 ret = wpa_ctrl_request(ctrl, cmd, strlen(cmd), buf, &len, 205 hostapd_cli_msg_cb); 206 if (ret == -2) { 207 printf("'%s' command timed out.\n", cmd); 208 return -2; 209 } else if (ret < 0) { 210 printf("'%s' command failed.\n", cmd); 211 return -1; 212 } 213 if (print) { 214 buf[len] = '\0'; 215 printf("%s", buf); 216 } 217 return 0; 218 } 219 220 221 static inline int wpa_ctrl_command(struct wpa_ctrl *ctrl, const char *cmd) 222 { 223 return _wpa_ctrl_command(ctrl, cmd, 1); 224 } 225 226 227 static int hostapd_cli_cmd(struct wpa_ctrl *ctrl, const char *cmd, 228 int min_args, int argc, char *argv[]) 229 { 230 char buf[4096]; 231 232 if (argc < min_args) { 233 printf("Invalid %s command - at least %d argument%s required.\n", 234 cmd, min_args, min_args > 1 ? "s are" : " is"); 235 return -1; 236 } 237 if (write_cmd(buf, sizeof(buf), cmd, argc, argv) < 0) 238 return -1; 239 return wpa_ctrl_command(ctrl, buf); 240 } 241 242 243 static int hostapd_cli_cmd_ping(struct wpa_ctrl *ctrl, int argc, char *argv[]) 244 { 245 return wpa_ctrl_command(ctrl, "PING"); 246 } 247 248 249 static int hostapd_cli_cmd_relog(struct wpa_ctrl *ctrl, int argc, char *argv[]) 250 { 251 return wpa_ctrl_command(ctrl, "RELOG"); 252 } 253 254 255 static int hostapd_cli_cmd_status(struct wpa_ctrl *ctrl, int argc, char *argv[]) 256 { 257 if (argc > 0 && os_strcmp(argv[0], "driver") == 0) 258 return wpa_ctrl_command(ctrl, "STATUS-DRIVER"); 259 return wpa_ctrl_command(ctrl, "STATUS"); 260 } 261 262 263 static int hostapd_cli_cmd_mib(struct wpa_ctrl *ctrl, int argc, char *argv[]) 264 { 265 if (argc > 0) { 266 char buf[100]; 267 os_snprintf(buf, sizeof(buf), "MIB %s", argv[0]); 268 return wpa_ctrl_command(ctrl, buf); 269 } 270 return wpa_ctrl_command(ctrl, "MIB"); 271 } 272 273 274 static int hostapd_cli_exec(const char *program, const char *arg1, 275 const char *arg2) 276 { 277 char *arg; 278 size_t len; 279 int res; 280 281 len = os_strlen(arg1) + os_strlen(arg2) + 2; 282 arg = os_malloc(len); 283 if (arg == NULL) 284 return -1; 285 os_snprintf(arg, len, "%s %s", arg1, arg2); 286 res = os_exec(program, arg, 1); 287 os_free(arg); 288 289 return res; 290 } 291 292 293 static void hostapd_cli_action_process(char *msg, size_t len) 294 { 295 const char *pos; 296 297 pos = msg; 298 if (*pos == '<') { 299 pos = os_strchr(pos, '>'); 300 if (pos) 301 pos++; 302 else 303 pos = msg; 304 } 305 306 hostapd_cli_exec(action_file, ctrl_ifname, pos); 307 } 308 309 310 static int hostapd_cli_cmd_sta(struct wpa_ctrl *ctrl, int argc, char *argv[]) 311 { 312 char buf[64]; 313 if (argc < 1) { 314 printf("Invalid 'sta' command - at least one argument, STA " 315 "address, is required.\n"); 316 return -1; 317 } 318 if (argc > 1) 319 snprintf(buf, sizeof(buf), "STA %s %s", argv[0], argv[1]); 320 else 321 snprintf(buf, sizeof(buf), "STA %s", argv[0]); 322 return wpa_ctrl_command(ctrl, buf); 323 } 324 325 326 static char ** hostapd_complete_stations(const char *str, int pos) 327 { 328 int arg = get_cmd_arg_num(str, pos); 329 char **res = NULL; 330 331 switch (arg) { 332 case 1: 333 res = cli_txt_list_array(&stations); 334 break; 335 } 336 337 return res; 338 } 339 340 341 static int hostapd_cli_cmd_new_sta(struct wpa_ctrl *ctrl, int argc, 342 char *argv[]) 343 { 344 char buf[64]; 345 if (argc != 1) { 346 printf("Invalid 'new_sta' command - exactly one argument, STA " 347 "address, is required.\n"); 348 return -1; 349 } 350 snprintf(buf, sizeof(buf), "NEW_STA %s", argv[0]); 351 return wpa_ctrl_command(ctrl, buf); 352 } 353 354 355 static int hostapd_cli_cmd_deauthenticate(struct wpa_ctrl *ctrl, int argc, 356 char *argv[]) 357 { 358 char buf[64]; 359 if (argc < 1) { 360 printf("Invalid 'deauthenticate' command - exactly one " 361 "argument, STA address, is required.\n"); 362 return -1; 363 } 364 if (argc > 1) 365 os_snprintf(buf, sizeof(buf), "DEAUTHENTICATE %s %s", 366 argv[0], argv[1]); 367 else 368 os_snprintf(buf, sizeof(buf), "DEAUTHENTICATE %s", argv[0]); 369 return wpa_ctrl_command(ctrl, buf); 370 } 371 372 373 static int hostapd_cli_cmd_disassociate(struct wpa_ctrl *ctrl, int argc, 374 char *argv[]) 375 { 376 char buf[64]; 377 if (argc < 1) { 378 printf("Invalid 'disassociate' command - exactly one " 379 "argument, STA address, is required.\n"); 380 return -1; 381 } 382 if (argc > 1) 383 os_snprintf(buf, sizeof(buf), "DISASSOCIATE %s %s", 384 argv[0], argv[1]); 385 else 386 os_snprintf(buf, sizeof(buf), "DISASSOCIATE %s", argv[0]); 387 return wpa_ctrl_command(ctrl, buf); 388 } 389 390 391 #ifdef CONFIG_TAXONOMY 392 static int hostapd_cli_cmd_signature(struct wpa_ctrl *ctrl, int argc, 393 char *argv[]) 394 { 395 char buf[64]; 396 397 if (argc != 1) { 398 printf("Invalid 'signature' command - exactly one argument, STA address, is required.\n"); 399 return -1; 400 } 401 os_snprintf(buf, sizeof(buf), "SIGNATURE %s", argv[0]); 402 return wpa_ctrl_command(ctrl, buf); 403 } 404 #endif /* CONFIG_TAXONOMY */ 405 406 407 static int hostapd_cli_cmd_sa_query(struct wpa_ctrl *ctrl, int argc, 408 char *argv[]) 409 { 410 char buf[64]; 411 if (argc != 1) { 412 printf("Invalid 'sa_query' command - exactly one argument, " 413 "STA address, is required.\n"); 414 return -1; 415 } 416 snprintf(buf, sizeof(buf), "SA_QUERY %s", argv[0]); 417 return wpa_ctrl_command(ctrl, buf); 418 } 419 420 421 #ifdef CONFIG_WPS 422 static int hostapd_cli_cmd_wps_pin(struct wpa_ctrl *ctrl, int argc, 423 char *argv[]) 424 { 425 char buf[256]; 426 if (argc < 2) { 427 printf("Invalid 'wps_pin' command - at least two arguments, " 428 "UUID and PIN, are required.\n"); 429 return -1; 430 } 431 if (argc > 3) 432 snprintf(buf, sizeof(buf), "WPS_PIN %s %s %s %s", 433 argv[0], argv[1], argv[2], argv[3]); 434 else if (argc > 2) 435 snprintf(buf, sizeof(buf), "WPS_PIN %s %s %s", 436 argv[0], argv[1], argv[2]); 437 else 438 snprintf(buf, sizeof(buf), "WPS_PIN %s %s", argv[0], argv[1]); 439 return wpa_ctrl_command(ctrl, buf); 440 } 441 442 443 static int hostapd_cli_cmd_wps_check_pin(struct wpa_ctrl *ctrl, int argc, 444 char *argv[]) 445 { 446 char cmd[256]; 447 int res; 448 449 if (argc != 1 && argc != 2) { 450 printf("Invalid WPS_CHECK_PIN command: needs one argument:\n" 451 "- PIN to be verified\n"); 452 return -1; 453 } 454 455 if (argc == 2) 456 res = os_snprintf(cmd, sizeof(cmd), "WPS_CHECK_PIN %s %s", 457 argv[0], argv[1]); 458 else 459 res = os_snprintf(cmd, sizeof(cmd), "WPS_CHECK_PIN %s", 460 argv[0]); 461 if (os_snprintf_error(sizeof(cmd), res)) { 462 printf("Too long WPS_CHECK_PIN command.\n"); 463 return -1; 464 } 465 return wpa_ctrl_command(ctrl, cmd); 466 } 467 468 469 static int hostapd_cli_cmd_wps_pbc(struct wpa_ctrl *ctrl, int argc, 470 char *argv[]) 471 { 472 return wpa_ctrl_command(ctrl, "WPS_PBC"); 473 } 474 475 476 static int hostapd_cli_cmd_wps_cancel(struct wpa_ctrl *ctrl, int argc, 477 char *argv[]) 478 { 479 return wpa_ctrl_command(ctrl, "WPS_CANCEL"); 480 } 481 482 483 #ifdef CONFIG_WPS_NFC 484 static int hostapd_cli_cmd_wps_nfc_tag_read(struct wpa_ctrl *ctrl, int argc, 485 char *argv[]) 486 { 487 int ret; 488 char *buf; 489 size_t buflen; 490 491 if (argc != 1) { 492 printf("Invalid 'wps_nfc_tag_read' command - one argument " 493 "is required.\n"); 494 return -1; 495 } 496 497 buflen = 18 + os_strlen(argv[0]); 498 buf = os_malloc(buflen); 499 if (buf == NULL) 500 return -1; 501 os_snprintf(buf, buflen, "WPS_NFC_TAG_READ %s", argv[0]); 502 503 ret = wpa_ctrl_command(ctrl, buf); 504 os_free(buf); 505 506 return ret; 507 } 508 509 510 static int hostapd_cli_cmd_wps_nfc_config_token(struct wpa_ctrl *ctrl, 511 int argc, char *argv[]) 512 { 513 char cmd[64]; 514 int res; 515 516 if (argc != 1) { 517 printf("Invalid 'wps_nfc_config_token' command - one argument " 518 "is required.\n"); 519 return -1; 520 } 521 522 res = os_snprintf(cmd, sizeof(cmd), "WPS_NFC_CONFIG_TOKEN %s", 523 argv[0]); 524 if (os_snprintf_error(sizeof(cmd), res)) { 525 printf("Too long WPS_NFC_CONFIG_TOKEN command.\n"); 526 return -1; 527 } 528 return wpa_ctrl_command(ctrl, cmd); 529 } 530 531 532 static int hostapd_cli_cmd_wps_nfc_token(struct wpa_ctrl *ctrl, 533 int argc, char *argv[]) 534 { 535 char cmd[64]; 536 int res; 537 538 if (argc != 1) { 539 printf("Invalid 'wps_nfc_token' command - one argument is " 540 "required.\n"); 541 return -1; 542 } 543 544 res = os_snprintf(cmd, sizeof(cmd), "WPS_NFC_TOKEN %s", argv[0]); 545 if (os_snprintf_error(sizeof(cmd), res)) { 546 printf("Too long WPS_NFC_TOKEN command.\n"); 547 return -1; 548 } 549 return wpa_ctrl_command(ctrl, cmd); 550 } 551 552 553 static int hostapd_cli_cmd_nfc_get_handover_sel(struct wpa_ctrl *ctrl, 554 int argc, char *argv[]) 555 { 556 char cmd[64]; 557 int res; 558 559 if (argc != 2) { 560 printf("Invalid 'nfc_get_handover_sel' command - two arguments " 561 "are required.\n"); 562 return -1; 563 } 564 565 res = os_snprintf(cmd, sizeof(cmd), "NFC_GET_HANDOVER_SEL %s %s", 566 argv[0], argv[1]); 567 if (os_snprintf_error(sizeof(cmd), res)) { 568 printf("Too long NFC_GET_HANDOVER_SEL command.\n"); 569 return -1; 570 } 571 return wpa_ctrl_command(ctrl, cmd); 572 } 573 574 #endif /* CONFIG_WPS_NFC */ 575 576 577 static int hostapd_cli_cmd_wps_ap_pin(struct wpa_ctrl *ctrl, int argc, 578 char *argv[]) 579 { 580 char buf[64]; 581 if (argc < 1) { 582 printf("Invalid 'wps_ap_pin' command - at least one argument " 583 "is required.\n"); 584 return -1; 585 } 586 if (argc > 2) 587 snprintf(buf, sizeof(buf), "WPS_AP_PIN %s %s %s", 588 argv[0], argv[1], argv[2]); 589 else if (argc > 1) 590 snprintf(buf, sizeof(buf), "WPS_AP_PIN %s %s", 591 argv[0], argv[1]); 592 else 593 snprintf(buf, sizeof(buf), "WPS_AP_PIN %s", argv[0]); 594 return wpa_ctrl_command(ctrl, buf); 595 } 596 597 598 static int hostapd_cli_cmd_wps_get_status(struct wpa_ctrl *ctrl, int argc, 599 char *argv[]) 600 { 601 return wpa_ctrl_command(ctrl, "WPS_GET_STATUS"); 602 } 603 604 605 static int hostapd_cli_cmd_wps_config(struct wpa_ctrl *ctrl, int argc, 606 char *argv[]) 607 { 608 char buf[256]; 609 char ssid_hex[2 * SSID_MAX_LEN + 1]; 610 char key_hex[2 * 64 + 1]; 611 int i; 612 613 if (argc < 1) { 614 printf("Invalid 'wps_config' command - at least two arguments " 615 "are required.\n"); 616 return -1; 617 } 618 619 ssid_hex[0] = '\0'; 620 for (i = 0; i < SSID_MAX_LEN; i++) { 621 if (argv[0][i] == '\0') 622 break; 623 os_snprintf(&ssid_hex[i * 2], 3, "%02x", argv[0][i]); 624 } 625 626 key_hex[0] = '\0'; 627 if (argc > 3) { 628 for (i = 0; i < 64; i++) { 629 if (argv[3][i] == '\0') 630 break; 631 os_snprintf(&key_hex[i * 2], 3, "%02x", 632 argv[3][i]); 633 } 634 } 635 636 if (argc > 3) 637 snprintf(buf, sizeof(buf), "WPS_CONFIG %s %s %s %s", 638 ssid_hex, argv[1], argv[2], key_hex); 639 else if (argc > 2) 640 snprintf(buf, sizeof(buf), "WPS_CONFIG %s %s %s", 641 ssid_hex, argv[1], argv[2]); 642 else 643 snprintf(buf, sizeof(buf), "WPS_CONFIG %s %s", 644 ssid_hex, argv[1]); 645 return wpa_ctrl_command(ctrl, buf); 646 } 647 #endif /* CONFIG_WPS */ 648 649 650 static int hostapd_cli_cmd_disassoc_imminent(struct wpa_ctrl *ctrl, int argc, 651 char *argv[]) 652 { 653 char buf[300]; 654 int res; 655 656 if (argc < 2) { 657 printf("Invalid 'disassoc_imminent' command - two arguments " 658 "(STA addr and Disassociation Timer) are needed\n"); 659 return -1; 660 } 661 662 res = os_snprintf(buf, sizeof(buf), "DISASSOC_IMMINENT %s %s", 663 argv[0], argv[1]); 664 if (os_snprintf_error(sizeof(buf), res)) 665 return -1; 666 return wpa_ctrl_command(ctrl, buf); 667 } 668 669 670 static int hostapd_cli_cmd_ess_disassoc(struct wpa_ctrl *ctrl, int argc, 671 char *argv[]) 672 { 673 char buf[300]; 674 int res; 675 676 if (argc < 3) { 677 printf("Invalid 'ess_disassoc' command - three arguments (STA " 678 "addr, disassoc timer, and URL) are needed\n"); 679 return -1; 680 } 681 682 res = os_snprintf(buf, sizeof(buf), "ESS_DISASSOC %s %s %s", 683 argv[0], argv[1], argv[2]); 684 if (os_snprintf_error(sizeof(buf), res)) 685 return -1; 686 return wpa_ctrl_command(ctrl, buf); 687 } 688 689 690 static int hostapd_cli_cmd_bss_tm_req(struct wpa_ctrl *ctrl, int argc, 691 char *argv[]) 692 { 693 char buf[2000], *tmp; 694 int res, i, total; 695 696 if (argc < 1) { 697 printf("Invalid 'bss_tm_req' command - at least one argument (STA addr) is needed\n"); 698 return -1; 699 } 700 701 res = os_snprintf(buf, sizeof(buf), "BSS_TM_REQ %s", argv[0]); 702 if (os_snprintf_error(sizeof(buf), res)) 703 return -1; 704 705 total = res; 706 for (i = 1; i < argc; i++) { 707 tmp = &buf[total]; 708 res = os_snprintf(tmp, sizeof(buf) - total, " %s", argv[i]); 709 if (os_snprintf_error(sizeof(buf) - total, res)) 710 return -1; 711 total += res; 712 } 713 return wpa_ctrl_command(ctrl, buf); 714 } 715 716 717 static int hostapd_cli_cmd_get_config(struct wpa_ctrl *ctrl, int argc, 718 char *argv[]) 719 { 720 return wpa_ctrl_command(ctrl, "GET_CONFIG"); 721 } 722 723 724 static int wpa_ctrl_command_sta(struct wpa_ctrl *ctrl, const char *cmd, 725 char *addr, size_t addr_len, int print) 726 { 727 char buf[4096], *pos; 728 size_t len; 729 int ret; 730 731 if (ctrl_conn == NULL) { 732 printf("Not connected to hostapd - command dropped.\n"); 733 return -1; 734 } 735 len = sizeof(buf) - 1; 736 ret = wpa_ctrl_request(ctrl, cmd, strlen(cmd), buf, &len, 737 hostapd_cli_msg_cb); 738 if (ret == -2) { 739 printf("'%s' command timed out.\n", cmd); 740 return -2; 741 } else if (ret < 0) { 742 printf("'%s' command failed.\n", cmd); 743 return -1; 744 } 745 746 buf[len] = '\0'; 747 if (memcmp(buf, "FAIL", 4) == 0) 748 return -1; 749 if (print) 750 printf("%s", buf); 751 752 pos = buf; 753 while (*pos != '\0' && *pos != '\n') 754 pos++; 755 *pos = '\0'; 756 os_strlcpy(addr, buf, addr_len); 757 return 0; 758 } 759 760 761 static int hostapd_cli_cmd_all_sta(struct wpa_ctrl *ctrl, int argc, 762 char *argv[]) 763 { 764 char addr[32], cmd[64]; 765 766 if (wpa_ctrl_command_sta(ctrl, "STA-FIRST", addr, sizeof(addr), 1)) 767 return 0; 768 do { 769 snprintf(cmd, sizeof(cmd), "STA-NEXT %s", addr); 770 } while (wpa_ctrl_command_sta(ctrl, cmd, addr, sizeof(addr), 1) == 0); 771 772 return -1; 773 } 774 775 776 static int hostapd_cli_cmd_list_sta(struct wpa_ctrl *ctrl, int argc, 777 char *argv[]) 778 { 779 char addr[32], cmd[64]; 780 781 if (wpa_ctrl_command_sta(ctrl, "STA-FIRST", addr, sizeof(addr), 0)) 782 return 0; 783 do { 784 if (os_strcmp(addr, "") != 0) 785 printf("%s\n", addr); 786 os_snprintf(cmd, sizeof(cmd), "STA-NEXT %s", addr); 787 } while (wpa_ctrl_command_sta(ctrl, cmd, addr, sizeof(addr), 0) == 0); 788 789 return 0; 790 } 791 792 793 static int hostapd_cli_cmd_help(struct wpa_ctrl *ctrl, int argc, char *argv[]) 794 { 795 print_help(stdout, argc > 0 ? argv[0] : NULL); 796 return 0; 797 } 798 799 800 static char ** hostapd_cli_complete_help(const char *str, int pos) 801 { 802 int arg = get_cmd_arg_num(str, pos); 803 char **res = NULL; 804 805 switch (arg) { 806 case 1: 807 res = list_cmd_list(); 808 break; 809 } 810 811 return res; 812 } 813 814 815 static int hostapd_cli_cmd_license(struct wpa_ctrl *ctrl, int argc, 816 char *argv[]) 817 { 818 printf("%s\n\n%s\n", hostapd_cli_version, cli_full_license); 819 return 0; 820 } 821 822 823 static int hostapd_cli_cmd_set_qos_map_set(struct wpa_ctrl *ctrl, 824 int argc, char *argv[]) 825 { 826 char buf[200]; 827 int res; 828 829 if (argc != 1) { 830 printf("Invalid 'set_qos_map_set' command - " 831 "one argument (comma delimited QoS map set) " 832 "is needed\n"); 833 return -1; 834 } 835 836 res = os_snprintf(buf, sizeof(buf), "SET_QOS_MAP_SET %s", argv[0]); 837 if (os_snprintf_error(sizeof(buf), res)) 838 return -1; 839 return wpa_ctrl_command(ctrl, buf); 840 } 841 842 843 static int hostapd_cli_cmd_send_qos_map_conf(struct wpa_ctrl *ctrl, 844 int argc, char *argv[]) 845 { 846 char buf[50]; 847 int res; 848 849 if (argc != 1) { 850 printf("Invalid 'send_qos_map_conf' command - " 851 "one argument (STA addr) is needed\n"); 852 return -1; 853 } 854 855 res = os_snprintf(buf, sizeof(buf), "SEND_QOS_MAP_CONF %s", argv[0]); 856 if (os_snprintf_error(sizeof(buf), res)) 857 return -1; 858 return wpa_ctrl_command(ctrl, buf); 859 } 860 861 862 static int hostapd_cli_cmd_hs20_wnm_notif(struct wpa_ctrl *ctrl, int argc, 863 char *argv[]) 864 { 865 char buf[300]; 866 int res; 867 868 if (argc < 2) { 869 printf("Invalid 'hs20_wnm_notif' command - two arguments (STA " 870 "addr and URL) are needed\n"); 871 return -1; 872 } 873 874 res = os_snprintf(buf, sizeof(buf), "HS20_WNM_NOTIF %s %s", 875 argv[0], argv[1]); 876 if (os_snprintf_error(sizeof(buf), res)) 877 return -1; 878 return wpa_ctrl_command(ctrl, buf); 879 } 880 881 882 static int hostapd_cli_cmd_hs20_deauth_req(struct wpa_ctrl *ctrl, int argc, 883 char *argv[]) 884 { 885 char buf[300]; 886 int res; 887 888 if (argc < 3) { 889 printf("Invalid 'hs20_deauth_req' command - at least three arguments (STA addr, Code, Re-auth Delay) are needed\n"); 890 return -1; 891 } 892 893 if (argc > 3) 894 res = os_snprintf(buf, sizeof(buf), 895 "HS20_DEAUTH_REQ %s %s %s %s", 896 argv[0], argv[1], argv[2], argv[3]); 897 else 898 res = os_snprintf(buf, sizeof(buf), 899 "HS20_DEAUTH_REQ %s %s %s", 900 argv[0], argv[1], argv[2]); 901 if (os_snprintf_error(sizeof(buf), res)) 902 return -1; 903 return wpa_ctrl_command(ctrl, buf); 904 } 905 906 907 static int hostapd_cli_cmd_quit(struct wpa_ctrl *ctrl, int argc, char *argv[]) 908 { 909 hostapd_cli_quit = 1; 910 if (interactive) 911 eloop_terminate(); 912 return 0; 913 } 914 915 916 static int hostapd_cli_cmd_level(struct wpa_ctrl *ctrl, int argc, char *argv[]) 917 { 918 char cmd[256]; 919 if (argc != 1) { 920 printf("Invalid LEVEL command: needs one argument (debug " 921 "level)\n"); 922 return 0; 923 } 924 snprintf(cmd, sizeof(cmd), "LEVEL %s", argv[0]); 925 return wpa_ctrl_command(ctrl, cmd); 926 } 927 928 929 static void update_stations(struct wpa_ctrl *ctrl) 930 { 931 char addr[32], cmd[64]; 932 933 if (!ctrl || !interactive) 934 return; 935 936 cli_txt_list_flush(&stations); 937 938 if (wpa_ctrl_command_sta(ctrl, "STA-FIRST", addr, sizeof(addr), 0)) 939 return; 940 do { 941 if (os_strcmp(addr, "") != 0) 942 cli_txt_list_add(&stations, addr); 943 os_snprintf(cmd, sizeof(cmd), "STA-NEXT %s", addr); 944 } while (wpa_ctrl_command_sta(ctrl, cmd, addr, sizeof(addr), 0) == 0); 945 } 946 947 948 static void hostapd_cli_get_interfaces(struct wpa_ctrl *ctrl, 949 struct dl_list *interfaces) 950 { 951 struct dirent *dent; 952 DIR *dir; 953 954 if (!ctrl || !interfaces) 955 return; 956 dir = opendir(ctrl_iface_dir); 957 if (dir == NULL) 958 return; 959 960 while ((dent = readdir(dir))) { 961 if (strcmp(dent->d_name, ".") == 0 || 962 strcmp(dent->d_name, "..") == 0) 963 continue; 964 cli_txt_list_add(interfaces, dent->d_name); 965 } 966 closedir(dir); 967 } 968 969 970 static void hostapd_cli_list_interfaces(struct wpa_ctrl *ctrl) 971 { 972 struct dirent *dent; 973 DIR *dir; 974 975 dir = opendir(ctrl_iface_dir); 976 if (dir == NULL) { 977 printf("Control interface directory '%s' could not be " 978 "opened.\n", ctrl_iface_dir); 979 return; 980 } 981 982 printf("Available interfaces:\n"); 983 while ((dent = readdir(dir))) { 984 if (strcmp(dent->d_name, ".") == 0 || 985 strcmp(dent->d_name, "..") == 0) 986 continue; 987 printf("%s\n", dent->d_name); 988 } 989 closedir(dir); 990 } 991 992 993 static int hostapd_cli_cmd_interface(struct wpa_ctrl *ctrl, int argc, 994 char *argv[]) 995 { 996 if (argc < 1) { 997 hostapd_cli_list_interfaces(ctrl); 998 return 0; 999 } 1000 if (hostapd_cli_reconnect(argv[0]) != 0) { 1001 printf("Could not connect to interface '%s' - re-trying\n", 1002 ctrl_ifname); 1003 } 1004 return 0; 1005 } 1006 1007 1008 static char ** hostapd_complete_interface(const char *str, int pos) 1009 { 1010 int arg = get_cmd_arg_num(str, pos); 1011 char **res = NULL; 1012 DEFINE_DL_LIST(interfaces); 1013 1014 switch (arg) { 1015 case 1: 1016 hostapd_cli_get_interfaces(ctrl_conn, &interfaces); 1017 res = cli_txt_list_array(&interfaces); 1018 cli_txt_list_flush(&interfaces); 1019 break; 1020 } 1021 1022 return res; 1023 } 1024 1025 1026 static int hostapd_cli_cmd_set(struct wpa_ctrl *ctrl, int argc, char *argv[]) 1027 { 1028 char cmd[2048]; 1029 int res; 1030 1031 if (argc != 2) { 1032 printf("Invalid SET command: needs two arguments (variable " 1033 "name and value)\n"); 1034 return -1; 1035 } 1036 1037 res = os_snprintf(cmd, sizeof(cmd), "SET %s %s", argv[0], argv[1]); 1038 if (os_snprintf_error(sizeof(cmd), res)) { 1039 printf("Too long SET command.\n"); 1040 return -1; 1041 } 1042 return wpa_ctrl_command(ctrl, cmd); 1043 } 1044 1045 1046 static char ** hostapd_complete_set(const char *str, int pos) 1047 { 1048 int arg = get_cmd_arg_num(str, pos); 1049 const char *fields[] = { 1050 #ifdef CONFIG_WPS_TESTING 1051 "wps_version_number", "wps_testing_dummy_cred", 1052 "wps_corrupt_pkhash", 1053 #endif /* CONFIG_WPS_TESTING */ 1054 #ifdef CONFIG_INTERWORKING 1055 "gas_frag_limit", 1056 #endif /* CONFIG_INTERWORKING */ 1057 #ifdef CONFIG_TESTING_OPTIONS 1058 "ext_mgmt_frame_handling", "ext_eapol_frame_io", 1059 #endif /* CONFIG_TESTING_OPTIONS */ 1060 #ifdef CONFIG_MBO 1061 "mbo_assoc_disallow", 1062 #endif /* CONFIG_MBO */ 1063 "deny_mac_file", "accept_mac_file", 1064 }; 1065 int i, num_fields = ARRAY_SIZE(fields); 1066 1067 if (arg == 1) { 1068 char **res; 1069 1070 res = os_calloc(num_fields + 1, sizeof(char *)); 1071 if (!res) 1072 return NULL; 1073 for (i = 0; i < num_fields; i++) { 1074 res[i] = os_strdup(fields[i]); 1075 if (!res[i]) 1076 return res; 1077 } 1078 return res; 1079 } 1080 return NULL; 1081 } 1082 1083 1084 static int hostapd_cli_cmd_get(struct wpa_ctrl *ctrl, int argc, char *argv[]) 1085 { 1086 char cmd[256]; 1087 int res; 1088 1089 if (argc != 1) { 1090 printf("Invalid GET command: needs one argument (variable " 1091 "name)\n"); 1092 return -1; 1093 } 1094 1095 res = os_snprintf(cmd, sizeof(cmd), "GET %s", argv[0]); 1096 if (os_snprintf_error(sizeof(cmd), res)) { 1097 printf("Too long GET command.\n"); 1098 return -1; 1099 } 1100 return wpa_ctrl_command(ctrl, cmd); 1101 } 1102 1103 1104 static char ** hostapd_complete_get(const char *str, int pos) 1105 { 1106 int arg = get_cmd_arg_num(str, pos); 1107 const char *fields[] = { 1108 "version", "tls_library", 1109 }; 1110 int i, num_fields = ARRAY_SIZE(fields); 1111 1112 if (arg == 1) { 1113 char **res; 1114 1115 res = os_calloc(num_fields + 1, sizeof(char *)); 1116 if (!res) 1117 return NULL; 1118 for (i = 0; i < num_fields; i++) { 1119 res[i] = os_strdup(fields[i]); 1120 if (!res[i]) 1121 return res; 1122 } 1123 return res; 1124 } 1125 return NULL; 1126 } 1127 1128 1129 #ifdef CONFIG_FST 1130 static int hostapd_cli_cmd_fst(struct wpa_ctrl *ctrl, int argc, char *argv[]) 1131 { 1132 char cmd[256]; 1133 int res; 1134 int i; 1135 int total; 1136 1137 if (argc <= 0) { 1138 printf("FST command: parameters are required.\n"); 1139 return -1; 1140 } 1141 1142 total = os_snprintf(cmd, sizeof(cmd), "FST-MANAGER"); 1143 1144 for (i = 0; i < argc; i++) { 1145 res = os_snprintf(cmd + total, sizeof(cmd) - total, " %s", 1146 argv[i]); 1147 if (os_snprintf_error(sizeof(cmd) - total, res)) { 1148 printf("Too long fst command.\n"); 1149 return -1; 1150 } 1151 total += res; 1152 } 1153 return wpa_ctrl_command(ctrl, cmd); 1154 } 1155 #endif /* CONFIG_FST */ 1156 1157 1158 static int hostapd_cli_cmd_chan_switch(struct wpa_ctrl *ctrl, 1159 int argc, char *argv[]) 1160 { 1161 char cmd[256]; 1162 int res; 1163 int i; 1164 char *tmp; 1165 int total; 1166 1167 if (argc < 2) { 1168 printf("Invalid chan_switch command: needs at least two " 1169 "arguments (count and freq)\n" 1170 "usage: <cs_count> <freq> [sec_channel_offset=] " 1171 "[center_freq1=] [center_freq2=] [bandwidth=] " 1172 "[blocktx] [ht|vht]\n"); 1173 return -1; 1174 } 1175 1176 res = os_snprintf(cmd, sizeof(cmd), "CHAN_SWITCH %s %s", 1177 argv[0], argv[1]); 1178 if (os_snprintf_error(sizeof(cmd), res)) { 1179 printf("Too long CHAN_SWITCH command.\n"); 1180 return -1; 1181 } 1182 1183 total = res; 1184 for (i = 2; i < argc; i++) { 1185 tmp = cmd + total; 1186 res = os_snprintf(tmp, sizeof(cmd) - total, " %s", argv[i]); 1187 if (os_snprintf_error(sizeof(cmd) - total, res)) { 1188 printf("Too long CHAN_SWITCH command.\n"); 1189 return -1; 1190 } 1191 total += res; 1192 } 1193 return wpa_ctrl_command(ctrl, cmd); 1194 } 1195 1196 1197 static int hostapd_cli_cmd_enable(struct wpa_ctrl *ctrl, int argc, 1198 char *argv[]) 1199 { 1200 return wpa_ctrl_command(ctrl, "ENABLE"); 1201 } 1202 1203 1204 static int hostapd_cli_cmd_reload(struct wpa_ctrl *ctrl, int argc, 1205 char *argv[]) 1206 { 1207 return wpa_ctrl_command(ctrl, "RELOAD"); 1208 } 1209 1210 1211 static int hostapd_cli_cmd_disable(struct wpa_ctrl *ctrl, int argc, 1212 char *argv[]) 1213 { 1214 return wpa_ctrl_command(ctrl, "DISABLE"); 1215 } 1216 1217 1218 static int hostapd_cli_cmd_update_beacon(struct wpa_ctrl *ctrl, int argc, 1219 char *argv[]) 1220 { 1221 return wpa_ctrl_command(ctrl, "UPDATE_BEACON"); 1222 } 1223 1224 1225 static int hostapd_cli_cmd_vendor(struct wpa_ctrl *ctrl, int argc, char *argv[]) 1226 { 1227 char cmd[256]; 1228 int res; 1229 1230 if (argc < 2 || argc > 4) { 1231 printf("Invalid vendor command\n" 1232 "usage: <vendor id> <command id> [<hex formatted command argument>] [nested=<0|1>]\n"); 1233 return -1; 1234 } 1235 1236 res = os_snprintf(cmd, sizeof(cmd), "VENDOR %s %s %s%s%s", argv[0], 1237 argv[1], argc >= 3 ? argv[2] : "", 1238 argc == 4 ? " " : "", argc == 4 ? argv[3] : ""); 1239 if (os_snprintf_error(sizeof(cmd), res)) { 1240 printf("Too long VENDOR command.\n"); 1241 return -1; 1242 } 1243 return wpa_ctrl_command(ctrl, cmd); 1244 } 1245 1246 1247 static int hostapd_cli_cmd_erp_flush(struct wpa_ctrl *ctrl, int argc, 1248 char *argv[]) 1249 { 1250 return wpa_ctrl_command(ctrl, "ERP_FLUSH"); 1251 } 1252 1253 1254 static int hostapd_cli_cmd_log_level(struct wpa_ctrl *ctrl, int argc, 1255 char *argv[]) 1256 { 1257 char cmd[256]; 1258 int res; 1259 1260 res = os_snprintf(cmd, sizeof(cmd), "LOG_LEVEL%s%s%s%s", 1261 argc >= 1 ? " " : "", 1262 argc >= 1 ? argv[0] : "", 1263 argc == 2 ? " " : "", 1264 argc == 2 ? argv[1] : ""); 1265 if (os_snprintf_error(sizeof(cmd), res)) { 1266 printf("Too long option\n"); 1267 return -1; 1268 } 1269 return wpa_ctrl_command(ctrl, cmd); 1270 } 1271 1272 1273 static int hostapd_cli_cmd_raw(struct wpa_ctrl *ctrl, int argc, char *argv[]) 1274 { 1275 if (argc == 0) 1276 return -1; 1277 return hostapd_cli_cmd(ctrl, argv[0], 0, argc - 1, &argv[1]); 1278 } 1279 1280 1281 static int hostapd_cli_cmd_pmksa(struct wpa_ctrl *ctrl, int argc, char *argv[]) 1282 { 1283 return wpa_ctrl_command(ctrl, "PMKSA"); 1284 } 1285 1286 1287 static int hostapd_cli_cmd_pmksa_flush(struct wpa_ctrl *ctrl, int argc, 1288 char *argv[]) 1289 { 1290 return wpa_ctrl_command(ctrl, "PMKSA_FLUSH"); 1291 } 1292 1293 1294 static int hostapd_cli_cmd_set_neighbor(struct wpa_ctrl *ctrl, int argc, 1295 char *argv[]) 1296 { 1297 char cmd[2048]; 1298 int res; 1299 1300 if (argc < 3 || argc > 6) { 1301 printf("Invalid set_neighbor command: needs 3-6 arguments\n"); 1302 return -1; 1303 } 1304 1305 res = os_snprintf(cmd, sizeof(cmd), "SET_NEIGHBOR %s %s %s %s %s %s", 1306 argv[0], argv[1], argv[2], argc >= 4 ? argv[3] : "", 1307 argc >= 5 ? argv[4] : "", argc == 6 ? argv[5] : ""); 1308 if (os_snprintf_error(sizeof(cmd), res)) { 1309 printf("Too long SET_NEIGHBOR command.\n"); 1310 return -1; 1311 } 1312 return wpa_ctrl_command(ctrl, cmd); 1313 } 1314 1315 1316 static int hostapd_cli_cmd_show_neighbor(struct wpa_ctrl *ctrl, int argc, 1317 char *argv[]) 1318 { 1319 return wpa_ctrl_command(ctrl, "SHOW_NEIGHBOR"); 1320 } 1321 1322 1323 static int hostapd_cli_cmd_remove_neighbor(struct wpa_ctrl *ctrl, int argc, 1324 char *argv[]) 1325 { 1326 return hostapd_cli_cmd(ctrl, "REMOVE_NEIGHBOR", 1, argc, argv); 1327 } 1328 1329 1330 static int hostapd_cli_cmd_req_lci(struct wpa_ctrl *ctrl, int argc, 1331 char *argv[]) 1332 { 1333 char cmd[256]; 1334 int res; 1335 1336 if (argc != 1) { 1337 printf("Invalid req_lci command - requires destination address\n"); 1338 return -1; 1339 } 1340 1341 res = os_snprintf(cmd, sizeof(cmd), "REQ_LCI %s", argv[0]); 1342 if (os_snprintf_error(sizeof(cmd), res)) { 1343 printf("Too long REQ_LCI command.\n"); 1344 return -1; 1345 } 1346 return wpa_ctrl_command(ctrl, cmd); 1347 } 1348 1349 1350 static int hostapd_cli_cmd_req_range(struct wpa_ctrl *ctrl, int argc, 1351 char *argv[]) 1352 { 1353 if (argc < 4) { 1354 printf("Invalid req_range command: needs at least 4 arguments - dest address, randomization interval, min AP count, and 1 to 16 AP addresses\n"); 1355 return -1; 1356 } 1357 1358 return hostapd_cli_cmd(ctrl, "REQ_RANGE", 4, argc, argv); 1359 } 1360 1361 1362 static int hostapd_cli_cmd_driver_flags(struct wpa_ctrl *ctrl, int argc, 1363 char *argv[]) 1364 { 1365 return wpa_ctrl_command(ctrl, "DRIVER_FLAGS"); 1366 } 1367 1368 1369 #ifdef CONFIG_DPP 1370 1371 static int hostapd_cli_cmd_dpp_qr_code(struct wpa_ctrl *ctrl, int argc, 1372 char *argv[]) 1373 { 1374 return hostapd_cli_cmd(ctrl, "DPP_QR_CODE", 1, argc, argv); 1375 } 1376 1377 1378 static int hostapd_cli_cmd_dpp_bootstrap_gen(struct wpa_ctrl *ctrl, int argc, 1379 char *argv[]) 1380 { 1381 return hostapd_cli_cmd(ctrl, "DPP_BOOTSTRAP_GEN", 1, argc, argv); 1382 } 1383 1384 1385 static int hostapd_cli_cmd_dpp_bootstrap_remove(struct wpa_ctrl *ctrl, int argc, 1386 char *argv[]) 1387 { 1388 return hostapd_cli_cmd(ctrl, "DPP_BOOTSTRAP_REMOVE", 1, argc, argv); 1389 } 1390 1391 1392 static int hostapd_cli_cmd_dpp_bootstrap_get_uri(struct wpa_ctrl *ctrl, 1393 int argc, char *argv[]) 1394 { 1395 return hostapd_cli_cmd(ctrl, "DPP_BOOTSTRAP_GET_URI", 1, argc, argv); 1396 } 1397 1398 1399 static int hostapd_cli_cmd_dpp_bootstrap_info(struct wpa_ctrl *ctrl, int argc, 1400 char *argv[]) 1401 { 1402 return hostapd_cli_cmd(ctrl, "DPP_BOOTSTRAP_INFO", 1, argc, argv); 1403 } 1404 1405 1406 static int hostapd_cli_cmd_dpp_bootstrap_set(struct wpa_ctrl *ctrl, int argc, 1407 char *argv[]) 1408 { 1409 return hostapd_cli_cmd(ctrl, "DPP_BOOTSTRAP_SET", 1, argc, argv); 1410 } 1411 1412 1413 static int hostapd_cli_cmd_dpp_auth_init(struct wpa_ctrl *ctrl, int argc, 1414 char *argv[]) 1415 { 1416 return hostapd_cli_cmd(ctrl, "DPP_AUTH_INIT", 1, argc, argv); 1417 } 1418 1419 1420 static int hostapd_cli_cmd_dpp_listen(struct wpa_ctrl *ctrl, int argc, 1421 char *argv[]) 1422 { 1423 return hostapd_cli_cmd(ctrl, "DPP_LISTEN", 1, argc, argv); 1424 } 1425 1426 1427 static int hostapd_cli_cmd_dpp_stop_listen(struct wpa_ctrl *ctrl, int argc, 1428 char *argv[]) 1429 { 1430 return wpa_ctrl_command(ctrl, "DPP_STOP_LISTEN"); 1431 } 1432 1433 1434 static int hostapd_cli_cmd_dpp_configurator_add(struct wpa_ctrl *ctrl, int argc, 1435 char *argv[]) 1436 { 1437 return hostapd_cli_cmd(ctrl, "DPP_CONFIGURATOR_ADD", 0, argc, argv); 1438 } 1439 1440 1441 static int hostapd_cli_cmd_dpp_configurator_remove(struct wpa_ctrl *ctrl, 1442 int argc, char *argv[]) 1443 { 1444 return hostapd_cli_cmd(ctrl, "DPP_CONFIGURATOR_REMOVE", 1, argc, argv); 1445 } 1446 1447 1448 static int hostapd_cli_cmd_dpp_configurator_get_key(struct wpa_ctrl *ctrl, 1449 int argc, char *argv[]) 1450 { 1451 return hostapd_cli_cmd(ctrl, "DPP_CONFIGURATOR_GET_KEY", 1, argc, argv); 1452 } 1453 1454 1455 static int hostapd_cli_cmd_dpp_configurator_sign(struct wpa_ctrl *ctrl, 1456 int argc, char *argv[]) 1457 { 1458 return hostapd_cli_cmd(ctrl, "DPP_CONFIGURATOR_SIGN", 1, argc, argv); 1459 } 1460 1461 1462 static int hostapd_cli_cmd_dpp_pkex_add(struct wpa_ctrl *ctrl, int argc, 1463 char *argv[]) 1464 { 1465 return hostapd_cli_cmd(ctrl, "DPP_PKEX_ADD", 1, argc, argv); 1466 } 1467 1468 1469 static int hostapd_cli_cmd_dpp_pkex_remove(struct wpa_ctrl *ctrl, int argc, 1470 char *argv[]) 1471 { 1472 return hostapd_cli_cmd(ctrl, "DPP_PKEX_REMOVE", 1, argc, argv); 1473 } 1474 1475 1476 #ifdef CONFIG_DPP2 1477 1478 static int hostapd_cli_cmd_dpp_controller_start(struct wpa_ctrl *ctrl, int argc, 1479 char *argv[]) 1480 { 1481 return hostapd_cli_cmd(ctrl, "DPP_CONTROLLER_START", 1, argc, argv); 1482 } 1483 1484 1485 static int hostapd_cli_cmd_dpp_controller_stop(struct wpa_ctrl *ctrl, int argc, 1486 char *argv[]) 1487 { 1488 return wpa_ctrl_command(ctrl, "DPP_CONTROLLER_STOP"); 1489 } 1490 1491 1492 static int hostapd_cli_cmd_dpp_chirp(struct wpa_ctrl *ctrl, int argc, 1493 char *argv[]) 1494 { 1495 return hostapd_cli_cmd(ctrl, "DPP_CHIRP", 1, argc, argv); 1496 } 1497 1498 1499 static int hostapd_cli_cmd_dpp_stop_chirp(struct wpa_ctrl *ctrl, int argc, 1500 char *argv[]) 1501 { 1502 return wpa_ctrl_command(ctrl, "DPP_STOP_CHIRP"); 1503 } 1504 1505 #endif /* CONFIG_DPP2 */ 1506 #endif /* CONFIG_DPP */ 1507 1508 1509 static int hostapd_cli_cmd_accept_macacl(struct wpa_ctrl *ctrl, int argc, 1510 char *argv[]) 1511 { 1512 return hostapd_cli_cmd(ctrl, "ACCEPT_ACL", 1, argc, argv); 1513 } 1514 1515 1516 static int hostapd_cli_cmd_deny_macacl(struct wpa_ctrl *ctrl, int argc, 1517 char *argv[]) 1518 { 1519 return hostapd_cli_cmd(ctrl, "DENY_ACL", 1, argc, argv); 1520 } 1521 1522 1523 static int hostapd_cli_cmd_poll_sta(struct wpa_ctrl *ctrl, int argc, 1524 char *argv[]) 1525 { 1526 return hostapd_cli_cmd(ctrl, "POLL_STA", 1, argc, argv); 1527 } 1528 1529 1530 static int hostapd_cli_cmd_req_beacon(struct wpa_ctrl *ctrl, int argc, 1531 char *argv[]) 1532 { 1533 return hostapd_cli_cmd(ctrl, "REQ_BEACON", 2, argc, argv); 1534 } 1535 1536 1537 static int hostapd_cli_cmd_reload_wpa_psk(struct wpa_ctrl *ctrl, int argc, 1538 char *argv[]) 1539 { 1540 return wpa_ctrl_command(ctrl, "RELOAD_WPA_PSK"); 1541 } 1542 1543 1544 #ifdef ANDROID 1545 static int hostapd_cli_cmd_driver(struct wpa_ctrl *ctrl, int argc, char *argv[]) 1546 { 1547 return hostapd_cli_cmd(ctrl, "DRIVER", 1, argc, argv); 1548 } 1549 #endif /* ANDROID */ 1550 1551 1552 struct hostapd_cli_cmd { 1553 const char *cmd; 1554 int (*handler)(struct wpa_ctrl *ctrl, int argc, char *argv[]); 1555 char ** (*completion)(const char *str, int pos); 1556 const char *usage; 1557 }; 1558 1559 static const struct hostapd_cli_cmd hostapd_cli_commands[] = { 1560 { "ping", hostapd_cli_cmd_ping, NULL, 1561 "= pings hostapd" }, 1562 { "mib", hostapd_cli_cmd_mib, NULL, 1563 "= get MIB variables (dot1x, dot11, radius)" }, 1564 { "relog", hostapd_cli_cmd_relog, NULL, 1565 "= reload/truncate debug log output file" }, 1566 { "status", hostapd_cli_cmd_status, NULL, 1567 "= show interface status info" }, 1568 { "sta", hostapd_cli_cmd_sta, hostapd_complete_stations, 1569 "<addr> = get MIB variables for one station" }, 1570 { "all_sta", hostapd_cli_cmd_all_sta, NULL, 1571 "= get MIB variables for all stations" }, 1572 { "list_sta", hostapd_cli_cmd_list_sta, NULL, 1573 "= list all stations" }, 1574 { "new_sta", hostapd_cli_cmd_new_sta, NULL, 1575 "<addr> = add a new station" }, 1576 { "deauthenticate", hostapd_cli_cmd_deauthenticate, 1577 hostapd_complete_stations, 1578 "<addr> = deauthenticate a station" }, 1579 { "disassociate", hostapd_cli_cmd_disassociate, 1580 hostapd_complete_stations, 1581 "<addr> = disassociate a station" }, 1582 #ifdef CONFIG_TAXONOMY 1583 { "signature", hostapd_cli_cmd_signature, hostapd_complete_stations, 1584 "<addr> = get taxonomy signature for a station" }, 1585 #endif /* CONFIG_TAXONOMY */ 1586 { "sa_query", hostapd_cli_cmd_sa_query, hostapd_complete_stations, 1587 "<addr> = send SA Query to a station" }, 1588 #ifdef CONFIG_WPS 1589 { "wps_pin", hostapd_cli_cmd_wps_pin, NULL, 1590 "<uuid> <pin> [timeout] [addr] = add WPS Enrollee PIN" }, 1591 { "wps_check_pin", hostapd_cli_cmd_wps_check_pin, NULL, 1592 "<PIN> = verify PIN checksum" }, 1593 { "wps_pbc", hostapd_cli_cmd_wps_pbc, NULL, 1594 "= indicate button pushed to initiate PBC" }, 1595 { "wps_cancel", hostapd_cli_cmd_wps_cancel, NULL, 1596 "= cancel the pending WPS operation" }, 1597 #ifdef CONFIG_WPS_NFC 1598 { "wps_nfc_tag_read", hostapd_cli_cmd_wps_nfc_tag_read, NULL, 1599 "<hexdump> = report read NFC tag with WPS data" }, 1600 { "wps_nfc_config_token", hostapd_cli_cmd_wps_nfc_config_token, NULL, 1601 "<WPS/NDEF> = build NFC configuration token" }, 1602 { "wps_nfc_token", hostapd_cli_cmd_wps_nfc_token, NULL, 1603 "<WPS/NDEF/enable/disable> = manager NFC password token" }, 1604 { "nfc_get_handover_sel", hostapd_cli_cmd_nfc_get_handover_sel, NULL, 1605 NULL }, 1606 #endif /* CONFIG_WPS_NFC */ 1607 { "wps_ap_pin", hostapd_cli_cmd_wps_ap_pin, NULL, 1608 "<cmd> [params..] = enable/disable AP PIN" }, 1609 { "wps_config", hostapd_cli_cmd_wps_config, NULL, 1610 "<SSID> <auth> <encr> <key> = configure AP" }, 1611 { "wps_get_status", hostapd_cli_cmd_wps_get_status, NULL, 1612 "= show current WPS status" }, 1613 #endif /* CONFIG_WPS */ 1614 { "disassoc_imminent", hostapd_cli_cmd_disassoc_imminent, NULL, 1615 "= send Disassociation Imminent notification" }, 1616 { "ess_disassoc", hostapd_cli_cmd_ess_disassoc, NULL, 1617 "= send ESS Dissassociation Imminent notification" }, 1618 { "bss_tm_req", hostapd_cli_cmd_bss_tm_req, NULL, 1619 "= send BSS Transition Management Request" }, 1620 { "get_config", hostapd_cli_cmd_get_config, NULL, 1621 "= show current configuration" }, 1622 { "help", hostapd_cli_cmd_help, hostapd_cli_complete_help, 1623 "= show this usage help" }, 1624 { "interface", hostapd_cli_cmd_interface, hostapd_complete_interface, 1625 "[ifname] = show interfaces/select interface" }, 1626 #ifdef CONFIG_FST 1627 { "fst", hostapd_cli_cmd_fst, NULL, 1628 "<params...> = send FST-MANAGER control interface command" }, 1629 #endif /* CONFIG_FST */ 1630 { "raw", hostapd_cli_cmd_raw, NULL, 1631 "<params..> = send unprocessed command" }, 1632 { "level", hostapd_cli_cmd_level, NULL, 1633 "<debug level> = change debug level" }, 1634 { "license", hostapd_cli_cmd_license, NULL, 1635 "= show full hostapd_cli license" }, 1636 { "quit", hostapd_cli_cmd_quit, NULL, 1637 "= exit hostapd_cli" }, 1638 { "set", hostapd_cli_cmd_set, hostapd_complete_set, 1639 "<name> <value> = set runtime variables" }, 1640 { "get", hostapd_cli_cmd_get, hostapd_complete_get, 1641 "<name> = get runtime info" }, 1642 { "set_qos_map_set", hostapd_cli_cmd_set_qos_map_set, NULL, 1643 "<arg,arg,...> = set QoS Map set element" }, 1644 { "send_qos_map_conf", hostapd_cli_cmd_send_qos_map_conf, 1645 hostapd_complete_stations, 1646 "<addr> = send QoS Map Configure frame" }, 1647 { "chan_switch", hostapd_cli_cmd_chan_switch, NULL, 1648 "<cs_count> <freq> [sec_channel_offset=] [center_freq1=]\n" 1649 " [center_freq2=] [bandwidth=] [blocktx] [ht|vht]\n" 1650 " = initiate channel switch announcement" }, 1651 { "hs20_wnm_notif", hostapd_cli_cmd_hs20_wnm_notif, NULL, 1652 "<addr> <url>\n" 1653 " = send WNM-Notification Subscription Remediation Request" }, 1654 { "hs20_deauth_req", hostapd_cli_cmd_hs20_deauth_req, NULL, 1655 "<addr> <code (0/1)> <Re-auth-Delay(sec)> [url]\n" 1656 " = send WNM-Notification imminent deauthentication indication" }, 1657 { "vendor", hostapd_cli_cmd_vendor, NULL, 1658 "<vendor id> <sub command id> [<hex formatted data>]\n" 1659 " = send vendor driver command" }, 1660 { "enable", hostapd_cli_cmd_enable, NULL, 1661 "= enable hostapd on current interface" }, 1662 { "reload", hostapd_cli_cmd_reload, NULL, 1663 "= reload configuration for current interface" }, 1664 { "disable", hostapd_cli_cmd_disable, NULL, 1665 "= disable hostapd on current interface" }, 1666 { "update_beacon", hostapd_cli_cmd_update_beacon, NULL, 1667 "= update Beacon frame contents\n"}, 1668 { "erp_flush", hostapd_cli_cmd_erp_flush, NULL, 1669 "= drop all ERP keys"}, 1670 { "log_level", hostapd_cli_cmd_log_level, NULL, 1671 "[level] = show/change log verbosity level" }, 1672 { "pmksa", hostapd_cli_cmd_pmksa, NULL, 1673 " = show PMKSA cache entries" }, 1674 { "pmksa_flush", hostapd_cli_cmd_pmksa_flush, NULL, 1675 " = flush PMKSA cache" }, 1676 { "set_neighbor", hostapd_cli_cmd_set_neighbor, NULL, 1677 "<addr> <ssid=> <nr=> [lci=] [civic=] [stat]\n" 1678 " = add AP to neighbor database" }, 1679 { "show_neighbor", hostapd_cli_cmd_show_neighbor, NULL, 1680 " = show neighbor database entries" }, 1681 { "remove_neighbor", hostapd_cli_cmd_remove_neighbor, NULL, 1682 "<addr> [ssid=<hex>] = remove AP from neighbor database" }, 1683 { "req_lci", hostapd_cli_cmd_req_lci, hostapd_complete_stations, 1684 "<addr> = send LCI request to a station"}, 1685 { "req_range", hostapd_cli_cmd_req_range, NULL, 1686 " = send FTM range request"}, 1687 { "driver_flags", hostapd_cli_cmd_driver_flags, NULL, 1688 " = show supported driver flags"}, 1689 #ifdef CONFIG_DPP 1690 { "dpp_qr_code", hostapd_cli_cmd_dpp_qr_code, NULL, 1691 "report a scanned DPP URI from a QR Code" }, 1692 { "dpp_bootstrap_gen", hostapd_cli_cmd_dpp_bootstrap_gen, NULL, 1693 "type=<qrcode> [chan=..] [mac=..] [info=..] [curve=..] [key=..] = generate DPP bootstrap information" }, 1694 { "dpp_bootstrap_remove", hostapd_cli_cmd_dpp_bootstrap_remove, NULL, 1695 "*|<id> = remove DPP bootstrap information" }, 1696 { "dpp_bootstrap_get_uri", hostapd_cli_cmd_dpp_bootstrap_get_uri, NULL, 1697 "<id> = get DPP bootstrap URI" }, 1698 { "dpp_bootstrap_info", hostapd_cli_cmd_dpp_bootstrap_info, NULL, 1699 "<id> = show DPP bootstrap information" }, 1700 { "dpp_bootstrap_set", hostapd_cli_cmd_dpp_bootstrap_set, NULL, 1701 "<id> [conf=..] [ssid=<SSID>] [ssid_charset=#] [psk=<PSK>] [pass=<passphrase>] [configurator=<id>] [conn_status=#] [akm_use_selector=<0|1>] [group_id=..] [expiry=#] [csrattrs=..] = set DPP configurator parameters" }, 1702 { "dpp_auth_init", hostapd_cli_cmd_dpp_auth_init, NULL, 1703 "peer=<id> [own=<id>] = initiate DPP bootstrapping" }, 1704 { "dpp_listen", hostapd_cli_cmd_dpp_listen, NULL, 1705 "<freq in MHz> = start DPP listen" }, 1706 { "dpp_stop_listen", hostapd_cli_cmd_dpp_stop_listen, NULL, 1707 "= stop DPP listen" }, 1708 { "dpp_configurator_add", hostapd_cli_cmd_dpp_configurator_add, NULL, 1709 "[curve=..] [key=..] = add DPP configurator" }, 1710 { "dpp_configurator_remove", hostapd_cli_cmd_dpp_configurator_remove, 1711 NULL, 1712 "*|<id> = remove DPP configurator" }, 1713 { "dpp_configurator_get_key", hostapd_cli_cmd_dpp_configurator_get_key, 1714 NULL, 1715 "<id> = Get DPP configurator's private key" }, 1716 { "dpp_configurator_sign", hostapd_cli_cmd_dpp_configurator_sign, NULL, 1717 "conf=<role> configurator=<id> = generate self DPP configuration" }, 1718 { "dpp_pkex_add", hostapd_cli_cmd_dpp_pkex_add, NULL, 1719 "add PKEX code" }, 1720 { "dpp_pkex_remove", hostapd_cli_cmd_dpp_pkex_remove, NULL, 1721 "*|<id> = remove DPP pkex information" }, 1722 #ifdef CONFIG_DPP2 1723 { "dpp_controller_start", hostapd_cli_cmd_dpp_controller_start, NULL, 1724 "[tcp_port=<port>] [role=..] = start DPP controller" }, 1725 { "dpp_controller_stop", hostapd_cli_cmd_dpp_controller_stop, NULL, 1726 "= stop DPP controller" }, 1727 { "dpp_chirp", hostapd_cli_cmd_dpp_chirp, NULL, 1728 "own=<BI ID> iter=<count> = start DPP chirp" }, 1729 { "dpp_stop_chirp", hostapd_cli_cmd_dpp_stop_chirp, NULL, 1730 "= stop DPP chirp" }, 1731 #endif /* CONFIG_DPP2 */ 1732 #endif /* CONFIG_DPP */ 1733 { "accept_acl", hostapd_cli_cmd_accept_macacl, NULL, 1734 "=Add/Delete/Show/Clear accept MAC ACL" }, 1735 { "deny_acl", hostapd_cli_cmd_deny_macacl, NULL, 1736 "=Add/Delete/Show/Clear deny MAC ACL" }, 1737 { "poll_sta", hostapd_cli_cmd_poll_sta, hostapd_complete_stations, 1738 "<addr> = poll a STA to check connectivity with a QoS null frame" }, 1739 { "req_beacon", hostapd_cli_cmd_req_beacon, NULL, 1740 "<addr> [req_mode=] <measurement request hexdump> = send a Beacon report request to a station" }, 1741 { "reload_wpa_psk", hostapd_cli_cmd_reload_wpa_psk, NULL, 1742 "= reload wpa_psk_file only" }, 1743 #ifdef ANDROID 1744 { "driver", hostapd_cli_cmd_driver, NULL, 1745 "<driver sub command> [<hex formatted data>] = send driver command data" }, 1746 #endif /* ANDROID */ 1747 { NULL, NULL, NULL, NULL } 1748 }; 1749 1750 1751 /* 1752 * Prints command usage, lines are padded with the specified string. 1753 */ 1754 static void print_cmd_help(FILE *stream, const struct hostapd_cli_cmd *cmd, 1755 const char *pad) 1756 { 1757 char c; 1758 size_t n; 1759 1760 if (cmd->usage == NULL) 1761 return; 1762 fprintf(stream, "%s%s ", pad, cmd->cmd); 1763 for (n = 0; (c = cmd->usage[n]); n++) { 1764 fprintf(stream, "%c", c); 1765 if (c == '\n') 1766 fprintf(stream, "%s", pad); 1767 } 1768 fprintf(stream, "\n"); 1769 } 1770 1771 1772 static void print_help(FILE *stream, const char *cmd) 1773 { 1774 int n; 1775 1776 fprintf(stream, "commands:\n"); 1777 for (n = 0; hostapd_cli_commands[n].cmd; n++) { 1778 if (cmd == NULL || str_starts(hostapd_cli_commands[n].cmd, cmd)) 1779 print_cmd_help(stream, &hostapd_cli_commands[n], " "); 1780 } 1781 } 1782 1783 1784 static void wpa_request(struct wpa_ctrl *ctrl, int argc, char *argv[]) 1785 { 1786 const struct hostapd_cli_cmd *cmd, *match = NULL; 1787 int count; 1788 1789 count = 0; 1790 cmd = hostapd_cli_commands; 1791 while (cmd->cmd) { 1792 if (strncasecmp(cmd->cmd, argv[0], strlen(argv[0])) == 0) { 1793 match = cmd; 1794 if (os_strcasecmp(cmd->cmd, argv[0]) == 0) { 1795 /* we have an exact match */ 1796 count = 1; 1797 break; 1798 } 1799 count++; 1800 } 1801 cmd++; 1802 } 1803 1804 if (count > 1) { 1805 printf("Ambiguous command '%s'; possible commands:", argv[0]); 1806 cmd = hostapd_cli_commands; 1807 while (cmd->cmd) { 1808 if (strncasecmp(cmd->cmd, argv[0], strlen(argv[0])) == 1809 0) { 1810 printf(" %s", cmd->cmd); 1811 } 1812 cmd++; 1813 } 1814 printf("\n"); 1815 } else if (count == 0) { 1816 printf("Unknown command '%s'\n", argv[0]); 1817 } else { 1818 match->handler(ctrl, argc - 1, &argv[1]); 1819 } 1820 } 1821 1822 1823 static void cli_event(const char *str) 1824 { 1825 const char *start, *s; 1826 1827 start = os_strchr(str, '>'); 1828 if (start == NULL) 1829 return; 1830 1831 start++; 1832 1833 if (str_starts(start, AP_STA_CONNECTED)) { 1834 s = os_strchr(start, ' '); 1835 if (s == NULL) 1836 return; 1837 cli_txt_list_add(&stations, s + 1); 1838 return; 1839 } 1840 1841 if (str_starts(start, AP_STA_DISCONNECTED)) { 1842 s = os_strchr(start, ' '); 1843 if (s == NULL) 1844 return; 1845 cli_txt_list_del_addr(&stations, s + 1); 1846 return; 1847 } 1848 } 1849 1850 1851 static void hostapd_cli_recv_pending(struct wpa_ctrl *ctrl, int in_read, 1852 int action_monitor) 1853 { 1854 int first = 1; 1855 if (ctrl_conn == NULL) 1856 return; 1857 while (wpa_ctrl_pending(ctrl)) { 1858 char buf[4096]; 1859 size_t len = sizeof(buf) - 1; 1860 if (wpa_ctrl_recv(ctrl, buf, &len) == 0) { 1861 buf[len] = '\0'; 1862 if (action_monitor) 1863 hostapd_cli_action_process(buf, len); 1864 else { 1865 cli_event(buf); 1866 if (in_read && first) 1867 printf("\n"); 1868 first = 0; 1869 printf("%s\n", buf); 1870 } 1871 } else { 1872 printf("Could not read pending message.\n"); 1873 break; 1874 } 1875 } 1876 } 1877 1878 1879 static void hostapd_cli_receive(int sock, void *eloop_ctx, void *sock_ctx) 1880 { 1881 hostapd_cli_recv_pending(ctrl_conn, 0, 0); 1882 } 1883 1884 1885 static void hostapd_cli_ping(void *eloop_ctx, void *timeout_ctx) 1886 { 1887 if (ctrl_conn && _wpa_ctrl_command(ctrl_conn, "PING", 0)) { 1888 printf("Connection to hostapd lost - trying to reconnect\n"); 1889 hostapd_cli_close_connection(); 1890 } 1891 if (!ctrl_conn && hostapd_cli_reconnect(ctrl_ifname) == 0) 1892 printf("Connection to hostapd re-established\n"); 1893 if (ctrl_conn) 1894 hostapd_cli_recv_pending(ctrl_conn, 1, 0); 1895 eloop_register_timeout(ping_interval, 0, hostapd_cli_ping, NULL, NULL); 1896 } 1897 1898 1899 static void hostapd_cli_eloop_terminate(int sig, void *signal_ctx) 1900 { 1901 eloop_terminate(); 1902 } 1903 1904 1905 static void hostapd_cli_edit_cmd_cb(void *ctx, char *cmd) 1906 { 1907 char *argv[max_args]; 1908 int argc; 1909 argc = tokenize_cmd(cmd, argv); 1910 if (argc) 1911 wpa_request(ctrl_conn, argc, argv); 1912 } 1913 1914 1915 static void hostapd_cli_edit_eof_cb(void *ctx) 1916 { 1917 eloop_terminate(); 1918 } 1919 1920 1921 static char ** list_cmd_list(void) 1922 { 1923 char **res; 1924 int i, count; 1925 1926 count = ARRAY_SIZE(hostapd_cli_commands); 1927 res = os_calloc(count + 1, sizeof(char *)); 1928 if (res == NULL) 1929 return NULL; 1930 1931 for (i = 0; hostapd_cli_commands[i].cmd; i++) { 1932 res[i] = os_strdup(hostapd_cli_commands[i].cmd); 1933 if (res[i] == NULL) 1934 break; 1935 } 1936 1937 return res; 1938 } 1939 1940 1941 static char ** hostapd_cli_cmd_completion(const char *cmd, const char *str, 1942 int pos) 1943 { 1944 int i; 1945 1946 for (i = 0; hostapd_cli_commands[i].cmd; i++) { 1947 if (os_strcasecmp(hostapd_cli_commands[i].cmd, cmd) != 0) 1948 continue; 1949 if (hostapd_cli_commands[i].completion) 1950 return hostapd_cli_commands[i].completion(str, pos); 1951 if (!hostapd_cli_commands[i].usage) 1952 return NULL; 1953 edit_clear_line(); 1954 printf("\r%s\n", hostapd_cli_commands[i].usage); 1955 edit_redraw(); 1956 break; 1957 } 1958 1959 return NULL; 1960 } 1961 1962 1963 static char ** hostapd_cli_edit_completion_cb(void *ctx, const char *str, 1964 int pos) 1965 { 1966 char **res; 1967 const char *end; 1968 char *cmd; 1969 1970 end = os_strchr(str, ' '); 1971 if (end == NULL || str + pos < end) 1972 return list_cmd_list(); 1973 1974 cmd = os_malloc(pos + 1); 1975 if (cmd == NULL) 1976 return NULL; 1977 os_memcpy(cmd, str, pos); 1978 cmd[end - str] = '\0'; 1979 res = hostapd_cli_cmd_completion(cmd, str, pos); 1980 os_free(cmd); 1981 return res; 1982 } 1983 1984 1985 static void hostapd_cli_interactive(void) 1986 { 1987 char *hfile = NULL; 1988 char *home; 1989 1990 printf("\nInteractive mode\n\n"); 1991 1992 #ifdef CONFIG_HOSTAPD_CLI_HISTORY_DIR 1993 home = CONFIG_HOSTAPD_CLI_HISTORY_DIR; 1994 #else /* CONFIG_HOSTAPD_CLI_HISTORY_DIR */ 1995 home = getenv("HOME"); 1996 #endif /* CONFIG_HOSTAPD_CLI_HISTORY_DIR */ 1997 if (home) { 1998 const char *fname = ".hostapd_cli_history"; 1999 int hfile_len = os_strlen(home) + 1 + os_strlen(fname) + 1; 2000 hfile = os_malloc(hfile_len); 2001 if (hfile) 2002 os_snprintf(hfile, hfile_len, "%s/%s", home, fname); 2003 } 2004 2005 eloop_register_signal_terminate(hostapd_cli_eloop_terminate, NULL); 2006 edit_init(hostapd_cli_edit_cmd_cb, hostapd_cli_edit_eof_cb, 2007 hostapd_cli_edit_completion_cb, NULL, hfile, NULL); 2008 eloop_register_timeout(ping_interval, 0, hostapd_cli_ping, NULL, NULL); 2009 2010 eloop_run(); 2011 2012 cli_txt_list_flush(&stations); 2013 edit_deinit(hfile, NULL); 2014 os_free(hfile); 2015 eloop_cancel_timeout(hostapd_cli_ping, NULL, NULL); 2016 } 2017 2018 2019 static void hostapd_cli_cleanup(void) 2020 { 2021 hostapd_cli_close_connection(); 2022 if (pid_file) 2023 os_daemonize_terminate(pid_file); 2024 2025 os_program_deinit(); 2026 } 2027 2028 2029 static void hostapd_cli_action(struct wpa_ctrl *ctrl) 2030 { 2031 fd_set rfds; 2032 int fd, res; 2033 struct timeval tv; 2034 char buf[256]; 2035 size_t len; 2036 2037 fd = wpa_ctrl_get_fd(ctrl); 2038 2039 while (!hostapd_cli_quit) { 2040 FD_ZERO(&rfds); 2041 FD_SET(fd, &rfds); 2042 tv.tv_sec = ping_interval; 2043 tv.tv_usec = 0; 2044 res = select(fd + 1, &rfds, NULL, NULL, &tv); 2045 if (res < 0 && errno != EINTR) { 2046 perror("select"); 2047 break; 2048 } 2049 2050 if (FD_ISSET(fd, &rfds)) 2051 hostapd_cli_recv_pending(ctrl, 0, 1); 2052 else { 2053 len = sizeof(buf) - 1; 2054 if (wpa_ctrl_request(ctrl, "PING", 4, buf, &len, 2055 hostapd_cli_action_process) < 0 || 2056 len < 4 || os_memcmp(buf, "PONG", 4) != 0) { 2057 printf("hostapd did not reply to PING " 2058 "command - exiting\n"); 2059 break; 2060 } 2061 } 2062 } 2063 } 2064 2065 2066 int main(int argc, char *argv[]) 2067 { 2068 int warning_displayed = 0; 2069 int c; 2070 int daemonize = 0; 2071 int reconnect = 0; 2072 2073 if (os_program_init()) 2074 return -1; 2075 2076 for (;;) { 2077 c = getopt(argc, argv, "a:BhG:i:p:P:rs:v"); 2078 if (c < 0) 2079 break; 2080 switch (c) { 2081 case 'a': 2082 action_file = optarg; 2083 break; 2084 case 'B': 2085 daemonize = 1; 2086 break; 2087 case 'G': 2088 ping_interval = atoi(optarg); 2089 break; 2090 case 'h': 2091 usage(); 2092 return 0; 2093 case 'v': 2094 printf("%s\n", hostapd_cli_version); 2095 return 0; 2096 case 'i': 2097 os_free(ctrl_ifname); 2098 ctrl_ifname = os_strdup(optarg); 2099 break; 2100 case 'p': 2101 ctrl_iface_dir = optarg; 2102 break; 2103 case 'P': 2104 pid_file = optarg; 2105 break; 2106 case 'r': 2107 reconnect = 1; 2108 break; 2109 case 's': 2110 client_socket_dir = optarg; 2111 break; 2112 default: 2113 usage(); 2114 return -1; 2115 } 2116 } 2117 2118 interactive = (argc == optind) && (action_file == NULL); 2119 2120 if (interactive) { 2121 printf("%s\n\n%s\n\n", hostapd_cli_version, cli_license); 2122 } 2123 2124 if (eloop_init()) 2125 return -1; 2126 2127 for (;;) { 2128 if (ctrl_ifname == NULL) { 2129 struct dirent *dent; 2130 DIR *dir = opendir(ctrl_iface_dir); 2131 if (dir) { 2132 while ((dent = readdir(dir))) { 2133 if (os_strcmp(dent->d_name, ".") == 0 2134 || 2135 os_strcmp(dent->d_name, "..") == 0) 2136 continue; 2137 printf("Selected interface '%s'\n", 2138 dent->d_name); 2139 ctrl_ifname = os_strdup(dent->d_name); 2140 break; 2141 } 2142 closedir(dir); 2143 } 2144 } 2145 hostapd_cli_reconnect(ctrl_ifname); 2146 if (ctrl_conn) { 2147 if (warning_displayed) 2148 printf("Connection established.\n"); 2149 break; 2150 } 2151 if (!interactive && !reconnect) { 2152 perror("Failed to connect to hostapd - " 2153 "wpa_ctrl_open"); 2154 return -1; 2155 } 2156 2157 if (!warning_displayed) { 2158 printf("Could not connect to hostapd - re-trying\n"); 2159 warning_displayed = 1; 2160 } 2161 os_sleep(1, 0); 2162 continue; 2163 } 2164 2165 if (action_file && !hostapd_cli_attached) 2166 return -1; 2167 if (daemonize && os_daemonize(pid_file) && eloop_sock_requeue()) 2168 return -1; 2169 if (reconnect && action_file && ctrl_ifname) { 2170 while (!hostapd_cli_quit) { 2171 if (ctrl_conn) 2172 hostapd_cli_action(ctrl_conn); 2173 os_sleep(1, 0); 2174 hostapd_cli_reconnect(ctrl_ifname); 2175 } 2176 } else if (interactive) 2177 hostapd_cli_interactive(); 2178 else if (action_file) 2179 hostapd_cli_action(ctrl_conn); 2180 else 2181 wpa_request(ctrl_conn, argc - optind, &argv[optind]); 2182 2183 unregister_event_handler(ctrl_conn); 2184 os_free(ctrl_ifname); 2185 eloop_destroy(); 2186 hostapd_cli_cleanup(); 2187 return 0; 2188 } 2189 2190 #else /* CONFIG_NO_CTRL_IFACE */ 2191 2192 int main(int argc, char *argv[]) 2193 { 2194 return -1; 2195 } 2196 2197 #endif /* CONFIG_NO_CTRL_IFACE */ 2198