1 /* 2 * hostapd / UNIX domain socket -based control interface 3 * Copyright (c) 2004-2014, 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 "utils/includes.h" 10 11 #ifndef CONFIG_NATIVE_WINDOWS 12 13 #include <sys/un.h> 14 #include <sys/stat.h> 15 #include <stddef.h> 16 17 #include "utils/common.h" 18 #include "utils/eloop.h" 19 #include "common/version.h" 20 #include "common/ieee802_11_defs.h" 21 #include "drivers/driver.h" 22 #include "radius/radius_client.h" 23 #include "radius/radius_server.h" 24 #include "ap/hostapd.h" 25 #include "ap/ap_config.h" 26 #include "ap/ieee802_1x.h" 27 #include "ap/wpa_auth.h" 28 #include "ap/ieee802_11.h" 29 #include "ap/sta_info.h" 30 #include "ap/wps_hostapd.h" 31 #include "ap/ctrl_iface_ap.h" 32 #include "ap/ap_drv_ops.h" 33 #include "ap/hs20.h" 34 #include "ap/wnm_ap.h" 35 #include "ap/wpa_auth.h" 36 #include "wps/wps_defs.h" 37 #include "wps/wps.h" 38 #include "config_file.h" 39 #include "ctrl_iface.h" 40 41 42 struct wpa_ctrl_dst { 43 struct wpa_ctrl_dst *next; 44 struct sockaddr_un addr; 45 socklen_t addrlen; 46 int debug_level; 47 int errors; 48 }; 49 50 51 static void hostapd_ctrl_iface_send(struct hostapd_data *hapd, int level, 52 const char *buf, size_t len); 53 54 55 static int hostapd_ctrl_iface_attach(struct hostapd_data *hapd, 56 struct sockaddr_un *from, 57 socklen_t fromlen) 58 { 59 struct wpa_ctrl_dst *dst; 60 61 dst = os_zalloc(sizeof(*dst)); 62 if (dst == NULL) 63 return -1; 64 os_memcpy(&dst->addr, from, sizeof(struct sockaddr_un)); 65 dst->addrlen = fromlen; 66 dst->debug_level = MSG_INFO; 67 dst->next = hapd->ctrl_dst; 68 hapd->ctrl_dst = dst; 69 wpa_hexdump(MSG_DEBUG, "CTRL_IFACE monitor attached", 70 (u8 *) from->sun_path, 71 fromlen - offsetof(struct sockaddr_un, sun_path)); 72 return 0; 73 } 74 75 76 static int hostapd_ctrl_iface_detach(struct hostapd_data *hapd, 77 struct sockaddr_un *from, 78 socklen_t fromlen) 79 { 80 struct wpa_ctrl_dst *dst, *prev = NULL; 81 82 dst = hapd->ctrl_dst; 83 while (dst) { 84 if (fromlen == dst->addrlen && 85 os_memcmp(from->sun_path, dst->addr.sun_path, 86 fromlen - offsetof(struct sockaddr_un, sun_path)) 87 == 0) { 88 wpa_hexdump(MSG_DEBUG, "CTRL_IFACE monitor detached", 89 (u8 *) from->sun_path, 90 fromlen - 91 offsetof(struct sockaddr_un, sun_path)); 92 if (prev == NULL) 93 hapd->ctrl_dst = dst->next; 94 else 95 prev->next = dst->next; 96 os_free(dst); 97 return 0; 98 } 99 prev = dst; 100 dst = dst->next; 101 } 102 return -1; 103 } 104 105 106 static int hostapd_ctrl_iface_level(struct hostapd_data *hapd, 107 struct sockaddr_un *from, 108 socklen_t fromlen, 109 char *level) 110 { 111 struct wpa_ctrl_dst *dst; 112 113 wpa_printf(MSG_DEBUG, "CTRL_IFACE LEVEL %s", level); 114 115 dst = hapd->ctrl_dst; 116 while (dst) { 117 if (fromlen == dst->addrlen && 118 os_memcmp(from->sun_path, dst->addr.sun_path, 119 fromlen - offsetof(struct sockaddr_un, sun_path)) 120 == 0) { 121 wpa_hexdump(MSG_DEBUG, "CTRL_IFACE changed monitor " 122 "level", (u8 *) from->sun_path, fromlen - 123 offsetof(struct sockaddr_un, sun_path)); 124 dst->debug_level = atoi(level); 125 return 0; 126 } 127 dst = dst->next; 128 } 129 130 return -1; 131 } 132 133 134 static int hostapd_ctrl_iface_new_sta(struct hostapd_data *hapd, 135 const char *txtaddr) 136 { 137 u8 addr[ETH_ALEN]; 138 struct sta_info *sta; 139 140 wpa_printf(MSG_DEBUG, "CTRL_IFACE NEW_STA %s", txtaddr); 141 142 if (hwaddr_aton(txtaddr, addr)) 143 return -1; 144 145 sta = ap_get_sta(hapd, addr); 146 if (sta) 147 return 0; 148 149 wpa_printf(MSG_DEBUG, "Add new STA " MACSTR " based on ctrl_iface " 150 "notification", MAC2STR(addr)); 151 sta = ap_sta_add(hapd, addr); 152 if (sta == NULL) 153 return -1; 154 155 hostapd_new_assoc_sta(hapd, sta, 0); 156 return 0; 157 } 158 159 160 #ifdef CONFIG_IEEE80211W 161 #ifdef NEED_AP_MLME 162 static int hostapd_ctrl_iface_sa_query(struct hostapd_data *hapd, 163 const char *txtaddr) 164 { 165 u8 addr[ETH_ALEN]; 166 u8 trans_id[WLAN_SA_QUERY_TR_ID_LEN]; 167 168 wpa_printf(MSG_DEBUG, "CTRL_IFACE SA_QUERY %s", txtaddr); 169 170 if (hwaddr_aton(txtaddr, addr) || 171 os_get_random(trans_id, WLAN_SA_QUERY_TR_ID_LEN) < 0) 172 return -1; 173 174 ieee802_11_send_sa_query_req(hapd, addr, trans_id); 175 176 return 0; 177 } 178 #endif /* NEED_AP_MLME */ 179 #endif /* CONFIG_IEEE80211W */ 180 181 182 #ifdef CONFIG_WPS 183 static int hostapd_ctrl_iface_wps_pin(struct hostapd_data *hapd, char *txt) 184 { 185 char *pin = os_strchr(txt, ' '); 186 char *timeout_txt; 187 int timeout; 188 u8 addr_buf[ETH_ALEN], *addr = NULL; 189 char *pos; 190 191 if (pin == NULL) 192 return -1; 193 *pin++ = '\0'; 194 195 timeout_txt = os_strchr(pin, ' '); 196 if (timeout_txt) { 197 *timeout_txt++ = '\0'; 198 timeout = atoi(timeout_txt); 199 pos = os_strchr(timeout_txt, ' '); 200 if (pos) { 201 *pos++ = '\0'; 202 if (hwaddr_aton(pos, addr_buf) == 0) 203 addr = addr_buf; 204 } 205 } else 206 timeout = 0; 207 208 return hostapd_wps_add_pin(hapd, addr, txt, pin, timeout); 209 } 210 211 212 static int hostapd_ctrl_iface_wps_check_pin( 213 struct hostapd_data *hapd, char *cmd, char *buf, size_t buflen) 214 { 215 char pin[9]; 216 size_t len; 217 char *pos; 218 int ret; 219 220 wpa_hexdump_ascii_key(MSG_DEBUG, "WPS_CHECK_PIN", 221 (u8 *) cmd, os_strlen(cmd)); 222 for (pos = cmd, len = 0; *pos != '\0'; pos++) { 223 if (*pos < '0' || *pos > '9') 224 continue; 225 pin[len++] = *pos; 226 if (len == 9) { 227 wpa_printf(MSG_DEBUG, "WPS: Too long PIN"); 228 return -1; 229 } 230 } 231 if (len != 4 && len != 8) { 232 wpa_printf(MSG_DEBUG, "WPS: Invalid PIN length %d", (int) len); 233 return -1; 234 } 235 pin[len] = '\0'; 236 237 if (len == 8) { 238 unsigned int pin_val; 239 pin_val = atoi(pin); 240 if (!wps_pin_valid(pin_val)) { 241 wpa_printf(MSG_DEBUG, "WPS: Invalid checksum digit"); 242 ret = os_snprintf(buf, buflen, "FAIL-CHECKSUM\n"); 243 if (ret < 0 || (size_t) ret >= buflen) 244 return -1; 245 return ret; 246 } 247 } 248 249 ret = os_snprintf(buf, buflen, "%s", pin); 250 if (ret < 0 || (size_t) ret >= buflen) 251 return -1; 252 253 return ret; 254 } 255 256 257 #ifdef CONFIG_WPS_NFC 258 static int hostapd_ctrl_iface_wps_nfc_tag_read(struct hostapd_data *hapd, 259 char *pos) 260 { 261 size_t len; 262 struct wpabuf *buf; 263 int ret; 264 265 len = os_strlen(pos); 266 if (len & 0x01) 267 return -1; 268 len /= 2; 269 270 buf = wpabuf_alloc(len); 271 if (buf == NULL) 272 return -1; 273 if (hexstr2bin(pos, wpabuf_put(buf, len), len) < 0) { 274 wpabuf_free(buf); 275 return -1; 276 } 277 278 ret = hostapd_wps_nfc_tag_read(hapd, buf); 279 wpabuf_free(buf); 280 281 return ret; 282 } 283 284 285 static int hostapd_ctrl_iface_wps_nfc_config_token(struct hostapd_data *hapd, 286 char *cmd, char *reply, 287 size_t max_len) 288 { 289 int ndef; 290 struct wpabuf *buf; 291 int res; 292 293 if (os_strcmp(cmd, "WPS") == 0) 294 ndef = 0; 295 else if (os_strcmp(cmd, "NDEF") == 0) 296 ndef = 1; 297 else 298 return -1; 299 300 buf = hostapd_wps_nfc_config_token(hapd, ndef); 301 if (buf == NULL) 302 return -1; 303 304 res = wpa_snprintf_hex_uppercase(reply, max_len, wpabuf_head(buf), 305 wpabuf_len(buf)); 306 reply[res++] = '\n'; 307 reply[res] = '\0'; 308 309 wpabuf_free(buf); 310 311 return res; 312 } 313 314 315 static int hostapd_ctrl_iface_wps_nfc_token_gen(struct hostapd_data *hapd, 316 char *reply, size_t max_len, 317 int ndef) 318 { 319 struct wpabuf *buf; 320 int res; 321 322 buf = hostapd_wps_nfc_token_gen(hapd, ndef); 323 if (buf == NULL) 324 return -1; 325 326 res = wpa_snprintf_hex_uppercase(reply, max_len, wpabuf_head(buf), 327 wpabuf_len(buf)); 328 reply[res++] = '\n'; 329 reply[res] = '\0'; 330 331 wpabuf_free(buf); 332 333 return res; 334 } 335 336 337 static int hostapd_ctrl_iface_wps_nfc_token(struct hostapd_data *hapd, 338 char *cmd, char *reply, 339 size_t max_len) 340 { 341 if (os_strcmp(cmd, "WPS") == 0) 342 return hostapd_ctrl_iface_wps_nfc_token_gen(hapd, reply, 343 max_len, 0); 344 345 if (os_strcmp(cmd, "NDEF") == 0) 346 return hostapd_ctrl_iface_wps_nfc_token_gen(hapd, reply, 347 max_len, 1); 348 349 if (os_strcmp(cmd, "enable") == 0) 350 return hostapd_wps_nfc_token_enable(hapd); 351 352 if (os_strcmp(cmd, "disable") == 0) { 353 hostapd_wps_nfc_token_disable(hapd); 354 return 0; 355 } 356 357 return -1; 358 } 359 360 361 static int hostapd_ctrl_iface_nfc_get_handover_sel(struct hostapd_data *hapd, 362 char *cmd, char *reply, 363 size_t max_len) 364 { 365 struct wpabuf *buf; 366 int res; 367 char *pos; 368 int ndef; 369 370 pos = os_strchr(cmd, ' '); 371 if (pos == NULL) 372 return -1; 373 *pos++ = '\0'; 374 375 if (os_strcmp(cmd, "WPS") == 0) 376 ndef = 0; 377 else if (os_strcmp(cmd, "NDEF") == 0) 378 ndef = 1; 379 else 380 return -1; 381 382 if (os_strcmp(pos, "WPS-CR") == 0) 383 buf = hostapd_wps_nfc_hs_cr(hapd, ndef); 384 else 385 buf = NULL; 386 if (buf == NULL) 387 return -1; 388 389 res = wpa_snprintf_hex_uppercase(reply, max_len, wpabuf_head(buf), 390 wpabuf_len(buf)); 391 reply[res++] = '\n'; 392 reply[res] = '\0'; 393 394 wpabuf_free(buf); 395 396 return res; 397 } 398 399 400 static int hostapd_ctrl_iface_nfc_report_handover(struct hostapd_data *hapd, 401 char *cmd) 402 { 403 size_t len; 404 struct wpabuf *req, *sel; 405 int ret; 406 char *pos, *role, *type, *pos2; 407 408 role = cmd; 409 pos = os_strchr(role, ' '); 410 if (pos == NULL) 411 return -1; 412 *pos++ = '\0'; 413 414 type = pos; 415 pos = os_strchr(type, ' '); 416 if (pos == NULL) 417 return -1; 418 *pos++ = '\0'; 419 420 pos2 = os_strchr(pos, ' '); 421 if (pos2 == NULL) 422 return -1; 423 *pos2++ = '\0'; 424 425 len = os_strlen(pos); 426 if (len & 0x01) 427 return -1; 428 len /= 2; 429 430 req = wpabuf_alloc(len); 431 if (req == NULL) 432 return -1; 433 if (hexstr2bin(pos, wpabuf_put(req, len), len) < 0) { 434 wpabuf_free(req); 435 return -1; 436 } 437 438 len = os_strlen(pos2); 439 if (len & 0x01) { 440 wpabuf_free(req); 441 return -1; 442 } 443 len /= 2; 444 445 sel = wpabuf_alloc(len); 446 if (sel == NULL) { 447 wpabuf_free(req); 448 return -1; 449 } 450 if (hexstr2bin(pos2, wpabuf_put(sel, len), len) < 0) { 451 wpabuf_free(req); 452 wpabuf_free(sel); 453 return -1; 454 } 455 456 if (os_strcmp(role, "RESP") == 0 && os_strcmp(type, "WPS") == 0) { 457 ret = hostapd_wps_nfc_report_handover(hapd, req, sel); 458 } else { 459 wpa_printf(MSG_DEBUG, "NFC: Unsupported connection handover " 460 "reported: role=%s type=%s", role, type); 461 ret = -1; 462 } 463 wpabuf_free(req); 464 wpabuf_free(sel); 465 466 return ret; 467 } 468 469 #endif /* CONFIG_WPS_NFC */ 470 471 472 static int hostapd_ctrl_iface_wps_ap_pin(struct hostapd_data *hapd, char *txt, 473 char *buf, size_t buflen) 474 { 475 int timeout = 300; 476 char *pos; 477 const char *pin_txt; 478 479 pos = os_strchr(txt, ' '); 480 if (pos) 481 *pos++ = '\0'; 482 483 if (os_strcmp(txt, "disable") == 0) { 484 hostapd_wps_ap_pin_disable(hapd); 485 return os_snprintf(buf, buflen, "OK\n"); 486 } 487 488 if (os_strcmp(txt, "random") == 0) { 489 if (pos) 490 timeout = atoi(pos); 491 pin_txt = hostapd_wps_ap_pin_random(hapd, timeout); 492 if (pin_txt == NULL) 493 return -1; 494 return os_snprintf(buf, buflen, "%s", pin_txt); 495 } 496 497 if (os_strcmp(txt, "get") == 0) { 498 pin_txt = hostapd_wps_ap_pin_get(hapd); 499 if (pin_txt == NULL) 500 return -1; 501 return os_snprintf(buf, buflen, "%s", pin_txt); 502 } 503 504 if (os_strcmp(txt, "set") == 0) { 505 char *pin; 506 if (pos == NULL) 507 return -1; 508 pin = pos; 509 pos = os_strchr(pos, ' '); 510 if (pos) { 511 *pos++ = '\0'; 512 timeout = atoi(pos); 513 } 514 if (os_strlen(pin) > buflen) 515 return -1; 516 if (hostapd_wps_ap_pin_set(hapd, pin, timeout) < 0) 517 return -1; 518 return os_snprintf(buf, buflen, "%s", pin); 519 } 520 521 return -1; 522 } 523 524 525 static int hostapd_ctrl_iface_wps_config(struct hostapd_data *hapd, char *txt) 526 { 527 char *pos; 528 char *ssid, *auth, *encr = NULL, *key = NULL; 529 530 ssid = txt; 531 pos = os_strchr(txt, ' '); 532 if (!pos) 533 return -1; 534 *pos++ = '\0'; 535 536 auth = pos; 537 pos = os_strchr(pos, ' '); 538 if (pos) { 539 *pos++ = '\0'; 540 encr = pos; 541 pos = os_strchr(pos, ' '); 542 if (pos) { 543 *pos++ = '\0'; 544 key = pos; 545 } 546 } 547 548 return hostapd_wps_config_ap(hapd, ssid, auth, encr, key); 549 } 550 551 552 static const char * pbc_status_str(enum pbc_status status) 553 { 554 switch (status) { 555 case WPS_PBC_STATUS_DISABLE: 556 return "Disabled"; 557 case WPS_PBC_STATUS_ACTIVE: 558 return "Active"; 559 case WPS_PBC_STATUS_TIMEOUT: 560 return "Timed-out"; 561 case WPS_PBC_STATUS_OVERLAP: 562 return "Overlap"; 563 default: 564 return "Unknown"; 565 } 566 } 567 568 569 static int hostapd_ctrl_iface_wps_get_status(struct hostapd_data *hapd, 570 char *buf, size_t buflen) 571 { 572 int ret; 573 char *pos, *end; 574 575 pos = buf; 576 end = buf + buflen; 577 578 ret = os_snprintf(pos, end - pos, "PBC Status: %s\n", 579 pbc_status_str(hapd->wps_stats.pbc_status)); 580 581 if (ret < 0 || ret >= end - pos) 582 return pos - buf; 583 pos += ret; 584 585 ret = os_snprintf(pos, end - pos, "Last WPS result: %s\n", 586 (hapd->wps_stats.status == WPS_STATUS_SUCCESS ? 587 "Success": 588 (hapd->wps_stats.status == WPS_STATUS_FAILURE ? 589 "Failed" : "None"))); 590 591 if (ret < 0 || ret >= end - pos) 592 return pos - buf; 593 pos += ret; 594 595 /* If status == Failure - Add possible Reasons */ 596 if(hapd->wps_stats.status == WPS_STATUS_FAILURE && 597 hapd->wps_stats.failure_reason > 0) { 598 ret = os_snprintf(pos, end - pos, 599 "Failure Reason: %s\n", 600 wps_ei_str(hapd->wps_stats.failure_reason)); 601 602 if (ret < 0 || ret >= end - pos) 603 return pos - buf; 604 pos += ret; 605 } 606 607 if (hapd->wps_stats.status) { 608 ret = os_snprintf(pos, end - pos, "Peer Address: " MACSTR "\n", 609 MAC2STR(hapd->wps_stats.peer_addr)); 610 611 if (ret < 0 || ret >= end - pos) 612 return pos - buf; 613 pos += ret; 614 } 615 616 return pos - buf; 617 } 618 619 #endif /* CONFIG_WPS */ 620 621 #ifdef CONFIG_HS20 622 623 static int hostapd_ctrl_iface_hs20_wnm_notif(struct hostapd_data *hapd, 624 const char *cmd) 625 { 626 u8 addr[ETH_ALEN]; 627 const char *url; 628 629 if (hwaddr_aton(cmd, addr)) 630 return -1; 631 url = cmd + 17; 632 if (*url == '\0') { 633 url = NULL; 634 } else { 635 if (*url != ' ') 636 return -1; 637 url++; 638 if (*url == '\0') 639 url = NULL; 640 } 641 642 return hs20_send_wnm_notification(hapd, addr, 1, url); 643 } 644 645 646 static int hostapd_ctrl_iface_hs20_deauth_req(struct hostapd_data *hapd, 647 const char *cmd) 648 { 649 u8 addr[ETH_ALEN]; 650 int code, reauth_delay, ret; 651 const char *pos; 652 size_t url_len; 653 struct wpabuf *req; 654 655 /* <STA MAC Addr> <Code(0/1)> <Re-auth-Delay(sec)> [URL] */ 656 if (hwaddr_aton(cmd, addr)) 657 return -1; 658 659 pos = os_strchr(cmd, ' '); 660 if (pos == NULL) 661 return -1; 662 pos++; 663 code = atoi(pos); 664 665 pos = os_strchr(pos, ' '); 666 if (pos == NULL) 667 return -1; 668 pos++; 669 reauth_delay = atoi(pos); 670 671 url_len = 0; 672 pos = os_strchr(pos, ' '); 673 if (pos) { 674 pos++; 675 url_len = os_strlen(pos); 676 } 677 678 req = wpabuf_alloc(4 + url_len); 679 if (req == NULL) 680 return -1; 681 wpabuf_put_u8(req, code); 682 wpabuf_put_le16(req, reauth_delay); 683 wpabuf_put_u8(req, url_len); 684 if (pos) 685 wpabuf_put_data(req, pos, url_len); 686 687 wpa_printf(MSG_DEBUG, "HS 2.0: Send WNM-Notification to " MACSTR 688 " to indicate imminent deauthentication (code=%d " 689 "reauth_delay=%d)", MAC2STR(addr), code, reauth_delay); 690 ret = hs20_send_wnm_notification_deauth_req(hapd, addr, req); 691 wpabuf_free(req); 692 return ret; 693 } 694 695 #endif /* CONFIG_HS20 */ 696 697 698 #ifdef CONFIG_INTERWORKING 699 700 static int hostapd_ctrl_iface_set_qos_map_set(struct hostapd_data *hapd, 701 const char *cmd) 702 { 703 u8 qos_map_set[16 + 2 * 21], count = 0; 704 const char *pos = cmd; 705 int val, ret; 706 707 for (;;) { 708 if (count == sizeof(qos_map_set)) { 709 wpa_printf(MSG_ERROR, "Too many qos_map_set parameters"); 710 return -1; 711 } 712 713 val = atoi(pos); 714 if (val < 0 || val > 255) { 715 wpa_printf(MSG_INFO, "Invalid QoS Map Set"); 716 return -1; 717 } 718 719 qos_map_set[count++] = val; 720 pos = os_strchr(pos, ','); 721 if (!pos) 722 break; 723 pos++; 724 } 725 726 if (count < 16 || count & 1) { 727 wpa_printf(MSG_INFO, "Invalid QoS Map Set"); 728 return -1; 729 } 730 731 ret = hostapd_drv_set_qos_map(hapd, qos_map_set, count); 732 if (ret) { 733 wpa_printf(MSG_INFO, "Failed to set QoS Map Set"); 734 return -1; 735 } 736 737 os_memcpy(hapd->conf->qos_map_set, qos_map_set, count); 738 hapd->conf->qos_map_set_len = count; 739 740 return 0; 741 } 742 743 744 static int hostapd_ctrl_iface_send_qos_map_conf(struct hostapd_data *hapd, 745 const char *cmd) 746 { 747 u8 addr[ETH_ALEN]; 748 struct sta_info *sta; 749 struct wpabuf *buf; 750 u8 *qos_map_set = hapd->conf->qos_map_set; 751 u8 qos_map_set_len = hapd->conf->qos_map_set_len; 752 int ret; 753 754 if (!qos_map_set_len) { 755 wpa_printf(MSG_INFO, "QoS Map Set is not set"); 756 return -1; 757 } 758 759 if (hwaddr_aton(cmd, addr)) 760 return -1; 761 762 sta = ap_get_sta(hapd, addr); 763 if (sta == NULL) { 764 wpa_printf(MSG_DEBUG, "Station " MACSTR " not found " 765 "for QoS Map Configuration message", 766 MAC2STR(addr)); 767 return -1; 768 } 769 770 if (!sta->qos_map_enabled) { 771 wpa_printf(MSG_DEBUG, "Station " MACSTR " did not indicate " 772 "support for QoS Map", MAC2STR(addr)); 773 return -1; 774 } 775 776 buf = wpabuf_alloc(2 + 2 + qos_map_set_len); 777 if (buf == NULL) 778 return -1; 779 780 wpabuf_put_u8(buf, WLAN_ACTION_QOS); 781 wpabuf_put_u8(buf, QOS_QOS_MAP_CONFIG); 782 783 /* QoS Map Set Element */ 784 wpabuf_put_u8(buf, WLAN_EID_QOS_MAP_SET); 785 wpabuf_put_u8(buf, qos_map_set_len); 786 wpabuf_put_data(buf, qos_map_set, qos_map_set_len); 787 788 ret = hostapd_drv_send_action(hapd, hapd->iface->freq, 0, addr, 789 wpabuf_head(buf), wpabuf_len(buf)); 790 wpabuf_free(buf); 791 792 return ret; 793 } 794 795 #endif /* CONFIG_INTERWORKING */ 796 797 798 #ifdef CONFIG_WNM 799 800 static int hostapd_ctrl_iface_disassoc_imminent(struct hostapd_data *hapd, 801 const char *cmd) 802 { 803 u8 addr[ETH_ALEN]; 804 int disassoc_timer; 805 struct sta_info *sta; 806 807 if (hwaddr_aton(cmd, addr)) 808 return -1; 809 if (cmd[17] != ' ') 810 return -1; 811 disassoc_timer = atoi(cmd + 17); 812 813 sta = ap_get_sta(hapd, addr); 814 if (sta == NULL) { 815 wpa_printf(MSG_DEBUG, "Station " MACSTR 816 " not found for disassociation imminent message", 817 MAC2STR(addr)); 818 return -1; 819 } 820 821 return wnm_send_disassoc_imminent(hapd, sta, disassoc_timer); 822 } 823 824 825 static int hostapd_ctrl_iface_ess_disassoc(struct hostapd_data *hapd, 826 const char *cmd) 827 { 828 u8 addr[ETH_ALEN]; 829 const char *url, *timerstr; 830 int disassoc_timer; 831 struct sta_info *sta; 832 833 if (hwaddr_aton(cmd, addr)) 834 return -1; 835 836 sta = ap_get_sta(hapd, addr); 837 if (sta == NULL) { 838 wpa_printf(MSG_DEBUG, "Station " MACSTR 839 " not found for ESS disassociation imminent message", 840 MAC2STR(addr)); 841 return -1; 842 } 843 844 timerstr = cmd + 17; 845 if (*timerstr != ' ') 846 return -1; 847 timerstr++; 848 disassoc_timer = atoi(timerstr); 849 if (disassoc_timer < 0 || disassoc_timer > 65535) 850 return -1; 851 852 url = os_strchr(timerstr, ' '); 853 if (url == NULL) 854 return -1; 855 url++; 856 857 return wnm_send_ess_disassoc_imminent(hapd, sta, url, disassoc_timer); 858 } 859 860 #endif /* CONFIG_WNM */ 861 862 863 static int hostapd_ctrl_iface_get_config(struct hostapd_data *hapd, 864 char *buf, size_t buflen) 865 { 866 int ret; 867 char *pos, *end; 868 869 pos = buf; 870 end = buf + buflen; 871 872 ret = os_snprintf(pos, end - pos, "bssid=" MACSTR "\n" 873 "ssid=%s\n", 874 MAC2STR(hapd->own_addr), 875 wpa_ssid_txt(hapd->conf->ssid.ssid, 876 hapd->conf->ssid.ssid_len)); 877 if (ret < 0 || ret >= end - pos) 878 return pos - buf; 879 pos += ret; 880 881 #ifdef CONFIG_WPS 882 ret = os_snprintf(pos, end - pos, "wps_state=%s\n", 883 hapd->conf->wps_state == 0 ? "disabled" : 884 (hapd->conf->wps_state == 1 ? "not configured" : 885 "configured")); 886 if (ret < 0 || ret >= end - pos) 887 return pos - buf; 888 pos += ret; 889 890 if (hapd->conf->wps_state && hapd->conf->wpa && 891 hapd->conf->ssid.wpa_passphrase) { 892 ret = os_snprintf(pos, end - pos, "passphrase=%s\n", 893 hapd->conf->ssid.wpa_passphrase); 894 if (ret < 0 || ret >= end - pos) 895 return pos - buf; 896 pos += ret; 897 } 898 899 if (hapd->conf->wps_state && hapd->conf->wpa && 900 hapd->conf->ssid.wpa_psk && 901 hapd->conf->ssid.wpa_psk->group) { 902 char hex[PMK_LEN * 2 + 1]; 903 wpa_snprintf_hex(hex, sizeof(hex), 904 hapd->conf->ssid.wpa_psk->psk, PMK_LEN); 905 ret = os_snprintf(pos, end - pos, "psk=%s\n", hex); 906 if (ret < 0 || ret >= end - pos) 907 return pos - buf; 908 pos += ret; 909 } 910 #endif /* CONFIG_WPS */ 911 912 if (hapd->conf->wpa && hapd->conf->wpa_key_mgmt) { 913 ret = os_snprintf(pos, end - pos, "key_mgmt="); 914 if (ret < 0 || ret >= end - pos) 915 return pos - buf; 916 pos += ret; 917 918 if (hapd->conf->wpa_key_mgmt & WPA_KEY_MGMT_PSK) { 919 ret = os_snprintf(pos, end - pos, "WPA-PSK "); 920 if (ret < 0 || ret >= end - pos) 921 return pos - buf; 922 pos += ret; 923 } 924 if (hapd->conf->wpa_key_mgmt & WPA_KEY_MGMT_IEEE8021X) { 925 ret = os_snprintf(pos, end - pos, "WPA-EAP "); 926 if (ret < 0 || ret >= end - pos) 927 return pos - buf; 928 pos += ret; 929 } 930 #ifdef CONFIG_IEEE80211R 931 if (hapd->conf->wpa_key_mgmt & WPA_KEY_MGMT_FT_PSK) { 932 ret = os_snprintf(pos, end - pos, "FT-PSK "); 933 if (ret < 0 || ret >= end - pos) 934 return pos - buf; 935 pos += ret; 936 } 937 if (hapd->conf->wpa_key_mgmt & WPA_KEY_MGMT_FT_IEEE8021X) { 938 ret = os_snprintf(pos, end - pos, "FT-EAP "); 939 if (ret < 0 || ret >= end - pos) 940 return pos - buf; 941 pos += ret; 942 } 943 #ifdef CONFIG_SAE 944 if (hapd->conf->wpa_key_mgmt & WPA_KEY_MGMT_FT_SAE) { 945 ret = os_snprintf(pos, end - pos, "FT-SAE "); 946 if (ret < 0 || ret >= end - pos) 947 return pos - buf; 948 pos += ret; 949 } 950 #endif /* CONFIG_SAE */ 951 #endif /* CONFIG_IEEE80211R */ 952 #ifdef CONFIG_IEEE80211W 953 if (hapd->conf->wpa_key_mgmt & WPA_KEY_MGMT_PSK_SHA256) { 954 ret = os_snprintf(pos, end - pos, "WPA-PSK-SHA256 "); 955 if (ret < 0 || ret >= end - pos) 956 return pos - buf; 957 pos += ret; 958 } 959 if (hapd->conf->wpa_key_mgmt & WPA_KEY_MGMT_IEEE8021X_SHA256) { 960 ret = os_snprintf(pos, end - pos, "WPA-EAP-SHA256 "); 961 if (ret < 0 || ret >= end - pos) 962 return pos - buf; 963 pos += ret; 964 } 965 #endif /* CONFIG_IEEE80211W */ 966 #ifdef CONFIG_SAE 967 if (hapd->conf->wpa_key_mgmt & WPA_KEY_MGMT_SAE) { 968 ret = os_snprintf(pos, end - pos, "SAE "); 969 if (ret < 0 || ret >= end - pos) 970 return pos - buf; 971 pos += ret; 972 } 973 #endif /* CONFIG_SAE */ 974 975 ret = os_snprintf(pos, end - pos, "\n"); 976 if (ret < 0 || ret >= end - pos) 977 return pos - buf; 978 pos += ret; 979 } 980 981 if (hapd->conf->wpa) { 982 ret = os_snprintf(pos, end - pos, "group_cipher=%s\n", 983 wpa_cipher_txt(hapd->conf->wpa_group)); 984 if (ret < 0 || ret >= end - pos) 985 return pos - buf; 986 pos += ret; 987 } 988 989 if ((hapd->conf->wpa & WPA_PROTO_RSN) && hapd->conf->rsn_pairwise) { 990 ret = os_snprintf(pos, end - pos, "rsn_pairwise_cipher="); 991 if (ret < 0 || ret >= end - pos) 992 return pos - buf; 993 pos += ret; 994 995 ret = wpa_write_ciphers(pos, end, hapd->conf->rsn_pairwise, 996 " "); 997 if (ret < 0) 998 return pos - buf; 999 pos += ret; 1000 1001 ret = os_snprintf(pos, end - pos, "\n"); 1002 if (ret < 0 || ret >= end - pos) 1003 return pos - buf; 1004 pos += ret; 1005 } 1006 1007 if ((hapd->conf->wpa & WPA_PROTO_WPA) && hapd->conf->wpa_pairwise) { 1008 ret = os_snprintf(pos, end - pos, "wpa_pairwise_cipher="); 1009 if (ret < 0 || ret >= end - pos) 1010 return pos - buf; 1011 pos += ret; 1012 1013 ret = wpa_write_ciphers(pos, end, hapd->conf->wpa_pairwise, 1014 " "); 1015 if (ret < 0) 1016 return pos - buf; 1017 pos += ret; 1018 1019 ret = os_snprintf(pos, end - pos, "\n"); 1020 if (ret < 0 || ret >= end - pos) 1021 return pos - buf; 1022 pos += ret; 1023 } 1024 1025 return pos - buf; 1026 } 1027 1028 1029 static int hostapd_ctrl_iface_set(struct hostapd_data *hapd, char *cmd) 1030 { 1031 char *value; 1032 int ret = 0; 1033 1034 value = os_strchr(cmd, ' '); 1035 if (value == NULL) 1036 return -1; 1037 *value++ = '\0'; 1038 1039 wpa_printf(MSG_DEBUG, "CTRL_IFACE SET '%s'='%s'", cmd, value); 1040 if (0) { 1041 #ifdef CONFIG_WPS_TESTING 1042 } else if (os_strcasecmp(cmd, "wps_version_number") == 0) { 1043 long int val; 1044 val = strtol(value, NULL, 0); 1045 if (val < 0 || val > 0xff) { 1046 ret = -1; 1047 wpa_printf(MSG_DEBUG, "WPS: Invalid " 1048 "wps_version_number %ld", val); 1049 } else { 1050 wps_version_number = val; 1051 wpa_printf(MSG_DEBUG, "WPS: Testing - force WPS " 1052 "version %u.%u", 1053 (wps_version_number & 0xf0) >> 4, 1054 wps_version_number & 0x0f); 1055 hostapd_wps_update_ie(hapd); 1056 } 1057 } else if (os_strcasecmp(cmd, "wps_testing_dummy_cred") == 0) { 1058 wps_testing_dummy_cred = atoi(value); 1059 wpa_printf(MSG_DEBUG, "WPS: Testing - dummy_cred=%d", 1060 wps_testing_dummy_cred); 1061 } else if (os_strcasecmp(cmd, "wps_corrupt_pkhash") == 0) { 1062 wps_corrupt_pkhash = atoi(value); 1063 wpa_printf(MSG_DEBUG, "WPS: Testing - wps_corrupt_pkhash=%d", 1064 wps_corrupt_pkhash); 1065 #endif /* CONFIG_WPS_TESTING */ 1066 #ifdef CONFIG_INTERWORKING 1067 } else if (os_strcasecmp(cmd, "gas_frag_limit") == 0) { 1068 int val = atoi(value); 1069 if (val <= 0) 1070 ret = -1; 1071 else 1072 hapd->gas_frag_limit = val; 1073 #endif /* CONFIG_INTERWORKING */ 1074 #ifdef CONFIG_TESTING_OPTIONS 1075 } else if (os_strcasecmp(cmd, "ext_mgmt_frame_handling") == 0) { 1076 hapd->ext_mgmt_frame_handling = atoi(value); 1077 #endif /* CONFIG_TESTING_OPTIONS */ 1078 } else { 1079 struct sta_info *sta; 1080 int vlan_id; 1081 1082 ret = hostapd_set_iface(hapd->iconf, hapd->conf, cmd, value); 1083 if (ret) 1084 return ret; 1085 1086 if (os_strcasecmp(cmd, "deny_mac_file") == 0) { 1087 for (sta = hapd->sta_list; sta; sta = sta->next) { 1088 if (hostapd_maclist_found( 1089 hapd->conf->deny_mac, 1090 hapd->conf->num_deny_mac, sta->addr, 1091 &vlan_id) && 1092 (!vlan_id || vlan_id == sta->vlan_id)) 1093 ap_sta_disconnect( 1094 hapd, sta, sta->addr, 1095 WLAN_REASON_UNSPECIFIED); 1096 } 1097 } else if (hapd->conf->macaddr_acl == DENY_UNLESS_ACCEPTED && 1098 os_strcasecmp(cmd, "accept_mac_file") == 0) { 1099 for (sta = hapd->sta_list; sta; sta = sta->next) { 1100 if (!hostapd_maclist_found( 1101 hapd->conf->accept_mac, 1102 hapd->conf->num_accept_mac, 1103 sta->addr, &vlan_id) || 1104 (vlan_id && vlan_id != sta->vlan_id)) 1105 ap_sta_disconnect( 1106 hapd, sta, sta->addr, 1107 WLAN_REASON_UNSPECIFIED); 1108 } 1109 } 1110 } 1111 1112 return ret; 1113 } 1114 1115 1116 static int hostapd_ctrl_iface_get(struct hostapd_data *hapd, char *cmd, 1117 char *buf, size_t buflen) 1118 { 1119 int res; 1120 1121 wpa_printf(MSG_DEBUG, "CTRL_IFACE GET '%s'", cmd); 1122 1123 if (os_strcmp(cmd, "version") == 0) { 1124 res = os_snprintf(buf, buflen, "%s", VERSION_STR); 1125 if (res < 0 || (unsigned int) res >= buflen) 1126 return -1; 1127 return res; 1128 } 1129 1130 return -1; 1131 } 1132 1133 1134 static int hostapd_ctrl_iface_enable(struct hostapd_iface *iface) 1135 { 1136 if (hostapd_enable_iface(iface) < 0) { 1137 wpa_printf(MSG_ERROR, "Enabling of interface failed"); 1138 return -1; 1139 } 1140 return 0; 1141 } 1142 1143 1144 static int hostapd_ctrl_iface_reload(struct hostapd_iface *iface) 1145 { 1146 if (hostapd_reload_iface(iface) < 0) { 1147 wpa_printf(MSG_ERROR, "Reloading of interface failed"); 1148 return -1; 1149 } 1150 return 0; 1151 } 1152 1153 1154 static int hostapd_ctrl_iface_disable(struct hostapd_iface *iface) 1155 { 1156 if (hostapd_disable_iface(iface) < 0) { 1157 wpa_printf(MSG_ERROR, "Disabling of interface failed"); 1158 return -1; 1159 } 1160 return 0; 1161 } 1162 1163 1164 #ifdef CONFIG_TESTING_OPTIONS 1165 1166 static int hostapd_ctrl_iface_radar(struct hostapd_data *hapd, char *cmd) 1167 { 1168 union wpa_event_data data; 1169 char *pos, *param; 1170 enum wpa_event_type event; 1171 1172 wpa_printf(MSG_DEBUG, "RADAR TEST: %s", cmd); 1173 1174 os_memset(&data, 0, sizeof(data)); 1175 1176 param = os_strchr(cmd, ' '); 1177 if (param == NULL) 1178 return -1; 1179 *param++ = '\0'; 1180 1181 if (os_strcmp(cmd, "DETECTED") == 0) 1182 event = EVENT_DFS_RADAR_DETECTED; 1183 else if (os_strcmp(cmd, "CAC-FINISHED") == 0) 1184 event = EVENT_DFS_CAC_FINISHED; 1185 else if (os_strcmp(cmd, "CAC-ABORTED") == 0) 1186 event = EVENT_DFS_CAC_ABORTED; 1187 else if (os_strcmp(cmd, "NOP-FINISHED") == 0) 1188 event = EVENT_DFS_NOP_FINISHED; 1189 else { 1190 wpa_printf(MSG_DEBUG, "Unsupported RADAR test command: %s", 1191 cmd); 1192 return -1; 1193 } 1194 1195 pos = os_strstr(param, "freq="); 1196 if (pos) 1197 data.dfs_event.freq = atoi(pos + 5); 1198 1199 pos = os_strstr(param, "ht_enabled=1"); 1200 if (pos) 1201 data.dfs_event.ht_enabled = 1; 1202 1203 pos = os_strstr(param, "chan_offset="); 1204 if (pos) 1205 data.dfs_event.chan_offset = atoi(pos + 12); 1206 1207 pos = os_strstr(param, "chan_width="); 1208 if (pos) 1209 data.dfs_event.chan_width = atoi(pos + 11); 1210 1211 pos = os_strstr(param, "cf1="); 1212 if (pos) 1213 data.dfs_event.cf1 = atoi(pos + 4); 1214 1215 pos = os_strstr(param, "cf2="); 1216 if (pos) 1217 data.dfs_event.cf2 = atoi(pos + 4); 1218 1219 wpa_supplicant_event(hapd, event, &data); 1220 1221 return 0; 1222 } 1223 1224 1225 static int hostapd_ctrl_iface_mgmt_tx(struct hostapd_data *hapd, char *cmd) 1226 { 1227 size_t len; 1228 u8 *buf; 1229 int res; 1230 1231 wpa_printf(MSG_DEBUG, "External MGMT TX: %s", cmd); 1232 1233 len = os_strlen(cmd); 1234 if (len & 1) 1235 return -1; 1236 len /= 2; 1237 1238 buf = os_malloc(len); 1239 if (buf == NULL) 1240 return -1; 1241 1242 if (hexstr2bin(cmd, buf, len) < 0) { 1243 os_free(buf); 1244 return -1; 1245 } 1246 1247 res = hostapd_drv_send_mlme(hapd, buf, len, 0); 1248 os_free(buf); 1249 return res; 1250 } 1251 1252 #endif /* CONFIG_TESTING_OPTIONS */ 1253 1254 1255 static int hostapd_ctrl_iface_chan_switch(struct hostapd_iface *iface, 1256 char *pos) 1257 { 1258 #ifdef NEED_AP_MLME 1259 struct csa_settings settings; 1260 int ret; 1261 unsigned int i; 1262 1263 ret = hostapd_parse_csa_settings(pos, &settings); 1264 if (ret) 1265 return ret; 1266 1267 for (i = 0; i < iface->num_bss; i++) { 1268 ret = hostapd_switch_channel(iface->bss[i], &settings); 1269 if (ret) { 1270 /* FIX: What do we do if CSA fails in the middle of 1271 * submitting multi-BSS CSA requests? */ 1272 return ret; 1273 } 1274 } 1275 1276 return 0; 1277 #else /* NEED_AP_MLME */ 1278 return -1; 1279 #endif /* NEED_AP_MLME */ 1280 } 1281 1282 1283 static int hostapd_ctrl_iface_mib(struct hostapd_data *hapd, char *reply, 1284 int reply_size, const char *param) 1285 { 1286 #ifdef RADIUS_SERVER 1287 if (os_strcmp(param, "radius_server") == 0) { 1288 return radius_server_get_mib(hapd->radius_srv, reply, 1289 reply_size); 1290 } 1291 #endif /* RADIUS_SERVER */ 1292 return -1; 1293 } 1294 1295 1296 static int hostapd_ctrl_iface_vendor(struct hostapd_data *hapd, char *cmd, 1297 char *buf, size_t buflen) 1298 { 1299 int ret; 1300 char *pos; 1301 u8 *data = NULL; 1302 unsigned int vendor_id, subcmd; 1303 struct wpabuf *reply; 1304 size_t data_len = 0; 1305 1306 /* cmd: <vendor id> <subcommand id> [<hex formatted data>] */ 1307 vendor_id = strtoul(cmd, &pos, 16); 1308 if (!isblank(*pos)) 1309 return -EINVAL; 1310 1311 subcmd = strtoul(pos, &pos, 10); 1312 1313 if (*pos != '\0') { 1314 if (!isblank(*pos++)) 1315 return -EINVAL; 1316 data_len = os_strlen(pos); 1317 } 1318 1319 if (data_len) { 1320 data_len /= 2; 1321 data = os_malloc(data_len); 1322 if (!data) 1323 return -ENOBUFS; 1324 1325 if (hexstr2bin(pos, data, data_len)) { 1326 wpa_printf(MSG_DEBUG, 1327 "Vendor command: wrong parameter format"); 1328 os_free(data); 1329 return -EINVAL; 1330 } 1331 } 1332 1333 reply = wpabuf_alloc((buflen - 1) / 2); 1334 if (!reply) { 1335 os_free(data); 1336 return -ENOBUFS; 1337 } 1338 1339 ret = hostapd_drv_vendor_cmd(hapd, vendor_id, subcmd, data, data_len, 1340 reply); 1341 1342 if (ret == 0) 1343 ret = wpa_snprintf_hex(buf, buflen, wpabuf_head_u8(reply), 1344 wpabuf_len(reply)); 1345 1346 wpabuf_free(reply); 1347 os_free(data); 1348 1349 return ret; 1350 } 1351 1352 1353 static void hostapd_ctrl_iface_receive(int sock, void *eloop_ctx, 1354 void *sock_ctx) 1355 { 1356 struct hostapd_data *hapd = eloop_ctx; 1357 char buf[4096]; 1358 int res; 1359 struct sockaddr_un from; 1360 socklen_t fromlen = sizeof(from); 1361 char *reply; 1362 const int reply_size = 4096; 1363 int reply_len; 1364 int level = MSG_DEBUG; 1365 1366 res = recvfrom(sock, buf, sizeof(buf) - 1, 0, 1367 (struct sockaddr *) &from, &fromlen); 1368 if (res < 0) { 1369 perror("recvfrom(ctrl_iface)"); 1370 return; 1371 } 1372 buf[res] = '\0'; 1373 if (os_strcmp(buf, "PING") == 0) 1374 level = MSG_EXCESSIVE; 1375 wpa_hexdump_ascii(level, "RX ctrl_iface", (u8 *) buf, res); 1376 1377 reply = os_malloc(reply_size); 1378 if (reply == NULL) { 1379 sendto(sock, "FAIL\n", 5, 0, (struct sockaddr *) &from, 1380 fromlen); 1381 return; 1382 } 1383 1384 os_memcpy(reply, "OK\n", 3); 1385 reply_len = 3; 1386 1387 if (os_strcmp(buf, "PING") == 0) { 1388 os_memcpy(reply, "PONG\n", 5); 1389 reply_len = 5; 1390 } else if (os_strncmp(buf, "RELOG", 5) == 0) { 1391 if (wpa_debug_reopen_file() < 0) 1392 reply_len = -1; 1393 } else if (os_strcmp(buf, "STATUS") == 0) { 1394 reply_len = hostapd_ctrl_iface_status(hapd, reply, 1395 reply_size); 1396 } else if (os_strcmp(buf, "STATUS-DRIVER") == 0) { 1397 reply_len = hostapd_drv_status(hapd, reply, reply_size); 1398 } else if (os_strcmp(buf, "MIB") == 0) { 1399 reply_len = ieee802_11_get_mib(hapd, reply, reply_size); 1400 if (reply_len >= 0) { 1401 res = wpa_get_mib(hapd->wpa_auth, reply + reply_len, 1402 reply_size - reply_len); 1403 if (res < 0) 1404 reply_len = -1; 1405 else 1406 reply_len += res; 1407 } 1408 if (reply_len >= 0) { 1409 res = ieee802_1x_get_mib(hapd, reply + reply_len, 1410 reply_size - reply_len); 1411 if (res < 0) 1412 reply_len = -1; 1413 else 1414 reply_len += res; 1415 } 1416 #ifndef CONFIG_NO_RADIUS 1417 if (reply_len >= 0) { 1418 res = radius_client_get_mib(hapd->radius, 1419 reply + reply_len, 1420 reply_size - reply_len); 1421 if (res < 0) 1422 reply_len = -1; 1423 else 1424 reply_len += res; 1425 } 1426 #endif /* CONFIG_NO_RADIUS */ 1427 } else if (os_strncmp(buf, "MIB ", 4) == 0) { 1428 reply_len = hostapd_ctrl_iface_mib(hapd, reply, reply_size, 1429 buf + 4); 1430 } else if (os_strcmp(buf, "STA-FIRST") == 0) { 1431 reply_len = hostapd_ctrl_iface_sta_first(hapd, reply, 1432 reply_size); 1433 } else if (os_strncmp(buf, "STA ", 4) == 0) { 1434 reply_len = hostapd_ctrl_iface_sta(hapd, buf + 4, reply, 1435 reply_size); 1436 } else if (os_strncmp(buf, "STA-NEXT ", 9) == 0) { 1437 reply_len = hostapd_ctrl_iface_sta_next(hapd, buf + 9, reply, 1438 reply_size); 1439 } else if (os_strcmp(buf, "ATTACH") == 0) { 1440 if (hostapd_ctrl_iface_attach(hapd, &from, fromlen)) 1441 reply_len = -1; 1442 } else if (os_strcmp(buf, "DETACH") == 0) { 1443 if (hostapd_ctrl_iface_detach(hapd, &from, fromlen)) 1444 reply_len = -1; 1445 } else if (os_strncmp(buf, "LEVEL ", 6) == 0) { 1446 if (hostapd_ctrl_iface_level(hapd, &from, fromlen, 1447 buf + 6)) 1448 reply_len = -1; 1449 } else if (os_strncmp(buf, "NEW_STA ", 8) == 0) { 1450 if (hostapd_ctrl_iface_new_sta(hapd, buf + 8)) 1451 reply_len = -1; 1452 } else if (os_strncmp(buf, "DEAUTHENTICATE ", 15) == 0) { 1453 if (hostapd_ctrl_iface_deauthenticate(hapd, buf + 15)) 1454 reply_len = -1; 1455 } else if (os_strncmp(buf, "DISASSOCIATE ", 13) == 0) { 1456 if (hostapd_ctrl_iface_disassociate(hapd, buf + 13)) 1457 reply_len = -1; 1458 #ifdef CONFIG_IEEE80211W 1459 #ifdef NEED_AP_MLME 1460 } else if (os_strncmp(buf, "SA_QUERY ", 9) == 0) { 1461 if (hostapd_ctrl_iface_sa_query(hapd, buf + 9)) 1462 reply_len = -1; 1463 #endif /* NEED_AP_MLME */ 1464 #endif /* CONFIG_IEEE80211W */ 1465 #ifdef CONFIG_WPS 1466 } else if (os_strncmp(buf, "WPS_PIN ", 8) == 0) { 1467 if (hostapd_ctrl_iface_wps_pin(hapd, buf + 8)) 1468 reply_len = -1; 1469 } else if (os_strncmp(buf, "WPS_CHECK_PIN ", 14) == 0) { 1470 reply_len = hostapd_ctrl_iface_wps_check_pin( 1471 hapd, buf + 14, reply, reply_size); 1472 } else if (os_strcmp(buf, "WPS_PBC") == 0) { 1473 if (hostapd_wps_button_pushed(hapd, NULL)) 1474 reply_len = -1; 1475 } else if (os_strcmp(buf, "WPS_CANCEL") == 0) { 1476 if (hostapd_wps_cancel(hapd)) 1477 reply_len = -1; 1478 } else if (os_strncmp(buf, "WPS_AP_PIN ", 11) == 0) { 1479 reply_len = hostapd_ctrl_iface_wps_ap_pin(hapd, buf + 11, 1480 reply, reply_size); 1481 } else if (os_strncmp(buf, "WPS_CONFIG ", 11) == 0) { 1482 if (hostapd_ctrl_iface_wps_config(hapd, buf + 11) < 0) 1483 reply_len = -1; 1484 } else if (os_strncmp(buf, "WPS_GET_STATUS", 13) == 0) { 1485 reply_len = hostapd_ctrl_iface_wps_get_status(hapd, reply, 1486 reply_size); 1487 #ifdef CONFIG_WPS_NFC 1488 } else if (os_strncmp(buf, "WPS_NFC_TAG_READ ", 17) == 0) { 1489 if (hostapd_ctrl_iface_wps_nfc_tag_read(hapd, buf + 17)) 1490 reply_len = -1; 1491 } else if (os_strncmp(buf, "WPS_NFC_CONFIG_TOKEN ", 21) == 0) { 1492 reply_len = hostapd_ctrl_iface_wps_nfc_config_token( 1493 hapd, buf + 21, reply, reply_size); 1494 } else if (os_strncmp(buf, "WPS_NFC_TOKEN ", 14) == 0) { 1495 reply_len = hostapd_ctrl_iface_wps_nfc_token( 1496 hapd, buf + 14, reply, reply_size); 1497 } else if (os_strncmp(buf, "NFC_GET_HANDOVER_SEL ", 21) == 0) { 1498 reply_len = hostapd_ctrl_iface_nfc_get_handover_sel( 1499 hapd, buf + 21, reply, reply_size); 1500 } else if (os_strncmp(buf, "NFC_REPORT_HANDOVER ", 20) == 0) { 1501 if (hostapd_ctrl_iface_nfc_report_handover(hapd, buf + 20)) 1502 reply_len = -1; 1503 #endif /* CONFIG_WPS_NFC */ 1504 #endif /* CONFIG_WPS */ 1505 #ifdef CONFIG_INTERWORKING 1506 } else if (os_strncmp(buf, "SET_QOS_MAP_SET ", 16) == 0) { 1507 if (hostapd_ctrl_iface_set_qos_map_set(hapd, buf + 16)) 1508 reply_len = -1; 1509 } else if (os_strncmp(buf, "SEND_QOS_MAP_CONF ", 18) == 0) { 1510 if (hostapd_ctrl_iface_send_qos_map_conf(hapd, buf + 18)) 1511 reply_len = -1; 1512 #endif /* CONFIG_INTERWORKING */ 1513 #ifdef CONFIG_HS20 1514 } else if (os_strncmp(buf, "HS20_WNM_NOTIF ", 15) == 0) { 1515 if (hostapd_ctrl_iface_hs20_wnm_notif(hapd, buf + 15)) 1516 reply_len = -1; 1517 } else if (os_strncmp(buf, "HS20_DEAUTH_REQ ", 16) == 0) { 1518 if (hostapd_ctrl_iface_hs20_deauth_req(hapd, buf + 16)) 1519 reply_len = -1; 1520 #endif /* CONFIG_HS20 */ 1521 #ifdef CONFIG_WNM 1522 } else if (os_strncmp(buf, "DISASSOC_IMMINENT ", 18) == 0) { 1523 if (hostapd_ctrl_iface_disassoc_imminent(hapd, buf + 18)) 1524 reply_len = -1; 1525 } else if (os_strncmp(buf, "ESS_DISASSOC ", 13) == 0) { 1526 if (hostapd_ctrl_iface_ess_disassoc(hapd, buf + 13)) 1527 reply_len = -1; 1528 #endif /* CONFIG_WNM */ 1529 } else if (os_strcmp(buf, "GET_CONFIG") == 0) { 1530 reply_len = hostapd_ctrl_iface_get_config(hapd, reply, 1531 reply_size); 1532 } else if (os_strncmp(buf, "SET ", 4) == 0) { 1533 if (hostapd_ctrl_iface_set(hapd, buf + 4)) 1534 reply_len = -1; 1535 } else if (os_strncmp(buf, "GET ", 4) == 0) { 1536 reply_len = hostapd_ctrl_iface_get(hapd, buf + 4, reply, 1537 reply_size); 1538 } else if (os_strncmp(buf, "ENABLE", 6) == 0) { 1539 if (hostapd_ctrl_iface_enable(hapd->iface)) 1540 reply_len = -1; 1541 } else if (os_strncmp(buf, "RELOAD", 6) == 0) { 1542 if (hostapd_ctrl_iface_reload(hapd->iface)) 1543 reply_len = -1; 1544 } else if (os_strncmp(buf, "DISABLE", 7) == 0) { 1545 if (hostapd_ctrl_iface_disable(hapd->iface)) 1546 reply_len = -1; 1547 #ifdef CONFIG_TESTING_OPTIONS 1548 } else if (os_strncmp(buf, "RADAR ", 6) == 0) { 1549 if (hostapd_ctrl_iface_radar(hapd, buf + 6)) 1550 reply_len = -1; 1551 } else if (os_strncmp(buf, "MGMT_TX ", 8) == 0) { 1552 if (hostapd_ctrl_iface_mgmt_tx(hapd, buf + 8)) 1553 reply_len = -1; 1554 #endif /* CONFIG_TESTING_OPTIONS */ 1555 } else if (os_strncmp(buf, "CHAN_SWITCH ", 12) == 0) { 1556 if (hostapd_ctrl_iface_chan_switch(hapd->iface, buf + 12)) 1557 reply_len = -1; 1558 } else if (os_strncmp(buf, "VENDOR ", 7) == 0) { 1559 reply_len = hostapd_ctrl_iface_vendor(hapd, buf + 7, reply, 1560 reply_size); 1561 1562 } else { 1563 os_memcpy(reply, "UNKNOWN COMMAND\n", 16); 1564 reply_len = 16; 1565 } 1566 1567 if (reply_len < 0) { 1568 os_memcpy(reply, "FAIL\n", 5); 1569 reply_len = 5; 1570 } 1571 sendto(sock, reply, reply_len, 0, (struct sockaddr *) &from, fromlen); 1572 os_free(reply); 1573 } 1574 1575 1576 static char * hostapd_ctrl_iface_path(struct hostapd_data *hapd) 1577 { 1578 char *buf; 1579 size_t len; 1580 1581 if (hapd->conf->ctrl_interface == NULL) 1582 return NULL; 1583 1584 len = os_strlen(hapd->conf->ctrl_interface) + 1585 os_strlen(hapd->conf->iface) + 2; 1586 buf = os_malloc(len); 1587 if (buf == NULL) 1588 return NULL; 1589 1590 os_snprintf(buf, len, "%s/%s", 1591 hapd->conf->ctrl_interface, hapd->conf->iface); 1592 buf[len - 1] = '\0'; 1593 return buf; 1594 } 1595 1596 1597 static void hostapd_ctrl_iface_msg_cb(void *ctx, int level, int global, 1598 const char *txt, size_t len) 1599 { 1600 struct hostapd_data *hapd = ctx; 1601 if (hapd == NULL) 1602 return; 1603 hostapd_ctrl_iface_send(hapd, level, txt, len); 1604 } 1605 1606 1607 int hostapd_ctrl_iface_init(struct hostapd_data *hapd) 1608 { 1609 struct sockaddr_un addr; 1610 int s = -1; 1611 char *fname = NULL; 1612 1613 if (hapd->ctrl_sock > -1) { 1614 wpa_printf(MSG_DEBUG, "ctrl_iface already exists!"); 1615 return 0; 1616 } 1617 1618 if (hapd->conf->ctrl_interface == NULL) 1619 return 0; 1620 1621 if (mkdir(hapd->conf->ctrl_interface, S_IRWXU | S_IRWXG) < 0) { 1622 if (errno == EEXIST) { 1623 wpa_printf(MSG_DEBUG, "Using existing control " 1624 "interface directory."); 1625 } else { 1626 perror("mkdir[ctrl_interface]"); 1627 goto fail; 1628 } 1629 } 1630 1631 if (hapd->conf->ctrl_interface_gid_set && 1632 chown(hapd->conf->ctrl_interface, -1, 1633 hapd->conf->ctrl_interface_gid) < 0) { 1634 perror("chown[ctrl_interface]"); 1635 return -1; 1636 } 1637 1638 if (!hapd->conf->ctrl_interface_gid_set && 1639 hapd->iface->interfaces->ctrl_iface_group && 1640 chown(hapd->conf->ctrl_interface, -1, 1641 hapd->iface->interfaces->ctrl_iface_group) < 0) { 1642 perror("chown[ctrl_interface]"); 1643 return -1; 1644 } 1645 1646 #ifdef ANDROID 1647 /* 1648 * Android is using umask 0077 which would leave the control interface 1649 * directory without group access. This breaks things since Wi-Fi 1650 * framework assumes that this directory can be accessed by other 1651 * applications in the wifi group. Fix this by adding group access even 1652 * if umask value would prevent this. 1653 */ 1654 if (chmod(hapd->conf->ctrl_interface, S_IRWXU | S_IRWXG) < 0) { 1655 wpa_printf(MSG_ERROR, "CTRL: Could not chmod directory: %s", 1656 strerror(errno)); 1657 /* Try to continue anyway */ 1658 } 1659 #endif /* ANDROID */ 1660 1661 if (os_strlen(hapd->conf->ctrl_interface) + 1 + 1662 os_strlen(hapd->conf->iface) >= sizeof(addr.sun_path)) 1663 goto fail; 1664 1665 s = socket(PF_UNIX, SOCK_DGRAM, 0); 1666 if (s < 0) { 1667 perror("socket(PF_UNIX)"); 1668 goto fail; 1669 } 1670 1671 os_memset(&addr, 0, sizeof(addr)); 1672 #ifdef __FreeBSD__ 1673 addr.sun_len = sizeof(addr); 1674 #endif /* __FreeBSD__ */ 1675 addr.sun_family = AF_UNIX; 1676 fname = hostapd_ctrl_iface_path(hapd); 1677 if (fname == NULL) 1678 goto fail; 1679 os_strlcpy(addr.sun_path, fname, sizeof(addr.sun_path)); 1680 if (bind(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) { 1681 wpa_printf(MSG_DEBUG, "ctrl_iface bind(PF_UNIX) failed: %s", 1682 strerror(errno)); 1683 if (connect(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) { 1684 wpa_printf(MSG_DEBUG, "ctrl_iface exists, but does not" 1685 " allow connections - assuming it was left" 1686 "over from forced program termination"); 1687 if (unlink(fname) < 0) { 1688 perror("unlink[ctrl_iface]"); 1689 wpa_printf(MSG_ERROR, "Could not unlink " 1690 "existing ctrl_iface socket '%s'", 1691 fname); 1692 goto fail; 1693 } 1694 if (bind(s, (struct sockaddr *) &addr, sizeof(addr)) < 1695 0) { 1696 perror("hostapd-ctrl-iface: bind(PF_UNIX)"); 1697 goto fail; 1698 } 1699 wpa_printf(MSG_DEBUG, "Successfully replaced leftover " 1700 "ctrl_iface socket '%s'", fname); 1701 } else { 1702 wpa_printf(MSG_INFO, "ctrl_iface exists and seems to " 1703 "be in use - cannot override it"); 1704 wpa_printf(MSG_INFO, "Delete '%s' manually if it is " 1705 "not used anymore", fname); 1706 os_free(fname); 1707 fname = NULL; 1708 goto fail; 1709 } 1710 } 1711 1712 if (hapd->conf->ctrl_interface_gid_set && 1713 chown(fname, -1, hapd->conf->ctrl_interface_gid) < 0) { 1714 perror("chown[ctrl_interface/ifname]"); 1715 goto fail; 1716 } 1717 1718 if (!hapd->conf->ctrl_interface_gid_set && 1719 hapd->iface->interfaces->ctrl_iface_group && 1720 chown(fname, -1, hapd->iface->interfaces->ctrl_iface_group) < 0) { 1721 perror("chown[ctrl_interface/ifname]"); 1722 goto fail; 1723 } 1724 1725 if (chmod(fname, S_IRWXU | S_IRWXG) < 0) { 1726 perror("chmod[ctrl_interface/ifname]"); 1727 goto fail; 1728 } 1729 os_free(fname); 1730 1731 hapd->ctrl_sock = s; 1732 eloop_register_read_sock(s, hostapd_ctrl_iface_receive, hapd, 1733 NULL); 1734 hapd->msg_ctx = hapd; 1735 wpa_msg_register_cb(hostapd_ctrl_iface_msg_cb); 1736 1737 return 0; 1738 1739 fail: 1740 if (s >= 0) 1741 close(s); 1742 if (fname) { 1743 unlink(fname); 1744 os_free(fname); 1745 } 1746 return -1; 1747 } 1748 1749 1750 void hostapd_ctrl_iface_deinit(struct hostapd_data *hapd) 1751 { 1752 struct wpa_ctrl_dst *dst, *prev; 1753 1754 if (hapd->ctrl_sock > -1) { 1755 char *fname; 1756 eloop_unregister_read_sock(hapd->ctrl_sock); 1757 close(hapd->ctrl_sock); 1758 hapd->ctrl_sock = -1; 1759 fname = hostapd_ctrl_iface_path(hapd); 1760 if (fname) 1761 unlink(fname); 1762 os_free(fname); 1763 1764 if (hapd->conf->ctrl_interface && 1765 rmdir(hapd->conf->ctrl_interface) < 0) { 1766 if (errno == ENOTEMPTY) { 1767 wpa_printf(MSG_DEBUG, "Control interface " 1768 "directory not empty - leaving it " 1769 "behind"); 1770 } else { 1771 wpa_printf(MSG_ERROR, 1772 "rmdir[ctrl_interface=%s]: %s", 1773 hapd->conf->ctrl_interface, 1774 strerror(errno)); 1775 } 1776 } 1777 } 1778 1779 dst = hapd->ctrl_dst; 1780 while (dst) { 1781 prev = dst; 1782 dst = dst->next; 1783 os_free(prev); 1784 } 1785 } 1786 1787 1788 static int hostapd_ctrl_iface_add(struct hapd_interfaces *interfaces, 1789 char *buf) 1790 { 1791 if (hostapd_add_iface(interfaces, buf) < 0) { 1792 wpa_printf(MSG_ERROR, "Adding interface %s failed", buf); 1793 return -1; 1794 } 1795 return 0; 1796 } 1797 1798 1799 static int hostapd_ctrl_iface_remove(struct hapd_interfaces *interfaces, 1800 char *buf) 1801 { 1802 if (hostapd_remove_iface(interfaces, buf) < 0) { 1803 wpa_printf(MSG_ERROR, "Removing interface %s failed", buf); 1804 return -1; 1805 } 1806 return 0; 1807 } 1808 1809 1810 static void hostapd_ctrl_iface_flush(struct hapd_interfaces *interfaces) 1811 { 1812 #ifdef CONFIG_WPS_TESTING 1813 wps_version_number = 0x20; 1814 wps_testing_dummy_cred = 0; 1815 wps_corrupt_pkhash = 0; 1816 #endif /* CONFIG_WPS_TESTING */ 1817 } 1818 1819 1820 static void hostapd_global_ctrl_iface_receive(int sock, void *eloop_ctx, 1821 void *sock_ctx) 1822 { 1823 void *interfaces = eloop_ctx; 1824 char buf[256]; 1825 int res; 1826 struct sockaddr_un from; 1827 socklen_t fromlen = sizeof(from); 1828 char reply[24]; 1829 int reply_len; 1830 1831 res = recvfrom(sock, buf, sizeof(buf) - 1, 0, 1832 (struct sockaddr *) &from, &fromlen); 1833 if (res < 0) { 1834 perror("recvfrom(ctrl_iface)"); 1835 return; 1836 } 1837 buf[res] = '\0'; 1838 wpa_printf(MSG_DEBUG, "Global ctrl_iface command: %s", buf); 1839 1840 os_memcpy(reply, "OK\n", 3); 1841 reply_len = 3; 1842 1843 if (os_strcmp(buf, "PING") == 0) { 1844 os_memcpy(reply, "PONG\n", 5); 1845 reply_len = 5; 1846 } else if (os_strncmp(buf, "RELOG", 5) == 0) { 1847 if (wpa_debug_reopen_file() < 0) 1848 reply_len = -1; 1849 } else if (os_strcmp(buf, "FLUSH") == 0) { 1850 hostapd_ctrl_iface_flush(interfaces); 1851 } else if (os_strncmp(buf, "ADD ", 4) == 0) { 1852 if (hostapd_ctrl_iface_add(interfaces, buf + 4) < 0) 1853 reply_len = -1; 1854 } else if (os_strncmp(buf, "REMOVE ", 7) == 0) { 1855 if (hostapd_ctrl_iface_remove(interfaces, buf + 7) < 0) 1856 reply_len = -1; 1857 #ifdef CONFIG_MODULE_TESTS 1858 } else if (os_strcmp(buf, "MODULE_TESTS") == 0) { 1859 int hapd_module_tests(void); 1860 if (hapd_module_tests() < 0) 1861 reply_len = -1; 1862 #endif /* CONFIG_MODULE_TESTS */ 1863 } else { 1864 wpa_printf(MSG_DEBUG, "Unrecognized global ctrl_iface command " 1865 "ignored"); 1866 reply_len = -1; 1867 } 1868 1869 if (reply_len < 0) { 1870 os_memcpy(reply, "FAIL\n", 5); 1871 reply_len = 5; 1872 } 1873 1874 sendto(sock, reply, reply_len, 0, (struct sockaddr *) &from, fromlen); 1875 } 1876 1877 1878 static char * hostapd_global_ctrl_iface_path(struct hapd_interfaces *interface) 1879 { 1880 char *buf; 1881 size_t len; 1882 1883 if (interface->global_iface_path == NULL) 1884 return NULL; 1885 1886 len = os_strlen(interface->global_iface_path) + 1887 os_strlen(interface->global_iface_name) + 2; 1888 buf = os_malloc(len); 1889 if (buf == NULL) 1890 return NULL; 1891 1892 os_snprintf(buf, len, "%s/%s", interface->global_iface_path, 1893 interface->global_iface_name); 1894 buf[len - 1] = '\0'; 1895 return buf; 1896 } 1897 1898 1899 int hostapd_global_ctrl_iface_init(struct hapd_interfaces *interface) 1900 { 1901 struct sockaddr_un addr; 1902 int s = -1; 1903 char *fname = NULL; 1904 1905 if (interface->global_iface_path == NULL) { 1906 wpa_printf(MSG_DEBUG, "ctrl_iface not configured!"); 1907 return 0; 1908 } 1909 1910 if (mkdir(interface->global_iface_path, S_IRWXU | S_IRWXG) < 0) { 1911 if (errno == EEXIST) { 1912 wpa_printf(MSG_DEBUG, "Using existing control " 1913 "interface directory."); 1914 } else { 1915 perror("mkdir[ctrl_interface]"); 1916 goto fail; 1917 } 1918 } else if (interface->ctrl_iface_group && 1919 chown(interface->global_iface_path, -1, 1920 interface->ctrl_iface_group) < 0) { 1921 perror("chown[ctrl_interface]"); 1922 goto fail; 1923 } 1924 1925 if (os_strlen(interface->global_iface_path) + 1 + 1926 os_strlen(interface->global_iface_name) >= sizeof(addr.sun_path)) 1927 goto fail; 1928 1929 s = socket(PF_UNIX, SOCK_DGRAM, 0); 1930 if (s < 0) { 1931 perror("socket(PF_UNIX)"); 1932 goto fail; 1933 } 1934 1935 os_memset(&addr, 0, sizeof(addr)); 1936 #ifdef __FreeBSD__ 1937 addr.sun_len = sizeof(addr); 1938 #endif /* __FreeBSD__ */ 1939 addr.sun_family = AF_UNIX; 1940 fname = hostapd_global_ctrl_iface_path(interface); 1941 if (fname == NULL) 1942 goto fail; 1943 os_strlcpy(addr.sun_path, fname, sizeof(addr.sun_path)); 1944 if (bind(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) { 1945 wpa_printf(MSG_DEBUG, "ctrl_iface bind(PF_UNIX) failed: %s", 1946 strerror(errno)); 1947 if (connect(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) { 1948 wpa_printf(MSG_DEBUG, "ctrl_iface exists, but does not" 1949 " allow connections - assuming it was left" 1950 "over from forced program termination"); 1951 if (unlink(fname) < 0) { 1952 perror("unlink[ctrl_iface]"); 1953 wpa_printf(MSG_ERROR, "Could not unlink " 1954 "existing ctrl_iface socket '%s'", 1955 fname); 1956 goto fail; 1957 } 1958 if (bind(s, (struct sockaddr *) &addr, sizeof(addr)) < 1959 0) { 1960 perror("bind(PF_UNIX)"); 1961 goto fail; 1962 } 1963 wpa_printf(MSG_DEBUG, "Successfully replaced leftover " 1964 "ctrl_iface socket '%s'", fname); 1965 } else { 1966 wpa_printf(MSG_INFO, "ctrl_iface exists and seems to " 1967 "be in use - cannot override it"); 1968 wpa_printf(MSG_INFO, "Delete '%s' manually if it is " 1969 "not used anymore", fname); 1970 os_free(fname); 1971 fname = NULL; 1972 goto fail; 1973 } 1974 } 1975 1976 if (interface->ctrl_iface_group && 1977 chown(fname, -1, interface->ctrl_iface_group) < 0) { 1978 perror("chown[ctrl_interface]"); 1979 goto fail; 1980 } 1981 1982 if (chmod(fname, S_IRWXU | S_IRWXG) < 0) { 1983 perror("chmod[ctrl_interface/ifname]"); 1984 goto fail; 1985 } 1986 os_free(fname); 1987 1988 interface->global_ctrl_sock = s; 1989 eloop_register_read_sock(s, hostapd_global_ctrl_iface_receive, 1990 interface, NULL); 1991 1992 return 0; 1993 1994 fail: 1995 if (s >= 0) 1996 close(s); 1997 if (fname) { 1998 unlink(fname); 1999 os_free(fname); 2000 } 2001 return -1; 2002 } 2003 2004 2005 void hostapd_global_ctrl_iface_deinit(struct hapd_interfaces *interfaces) 2006 { 2007 char *fname = NULL; 2008 2009 if (interfaces->global_ctrl_sock > -1) { 2010 eloop_unregister_read_sock(interfaces->global_ctrl_sock); 2011 close(interfaces->global_ctrl_sock); 2012 interfaces->global_ctrl_sock = -1; 2013 fname = hostapd_global_ctrl_iface_path(interfaces); 2014 if (fname) { 2015 unlink(fname); 2016 os_free(fname); 2017 } 2018 2019 if (interfaces->global_iface_path && 2020 rmdir(interfaces->global_iface_path) < 0) { 2021 if (errno == ENOTEMPTY) { 2022 wpa_printf(MSG_DEBUG, "Control interface " 2023 "directory not empty - leaving it " 2024 "behind"); 2025 } else { 2026 wpa_printf(MSG_ERROR, 2027 "rmdir[ctrl_interface=%s]: %s", 2028 interfaces->global_iface_path, 2029 strerror(errno)); 2030 } 2031 } 2032 os_free(interfaces->global_iface_path); 2033 interfaces->global_iface_path = NULL; 2034 } 2035 } 2036 2037 2038 static void hostapd_ctrl_iface_send(struct hostapd_data *hapd, int level, 2039 const char *buf, size_t len) 2040 { 2041 struct wpa_ctrl_dst *dst, *next; 2042 struct msghdr msg; 2043 int idx; 2044 struct iovec io[2]; 2045 char levelstr[10]; 2046 2047 dst = hapd->ctrl_dst; 2048 if (hapd->ctrl_sock < 0 || dst == NULL) 2049 return; 2050 2051 os_snprintf(levelstr, sizeof(levelstr), "<%d>", level); 2052 io[0].iov_base = levelstr; 2053 io[0].iov_len = os_strlen(levelstr); 2054 io[1].iov_base = (char *) buf; 2055 io[1].iov_len = len; 2056 os_memset(&msg, 0, sizeof(msg)); 2057 msg.msg_iov = io; 2058 msg.msg_iovlen = 2; 2059 2060 idx = 0; 2061 while (dst) { 2062 next = dst->next; 2063 if (level >= dst->debug_level) { 2064 wpa_hexdump(MSG_DEBUG, "CTRL_IFACE monitor send", 2065 (u8 *) dst->addr.sun_path, dst->addrlen - 2066 offsetof(struct sockaddr_un, sun_path)); 2067 msg.msg_name = &dst->addr; 2068 msg.msg_namelen = dst->addrlen; 2069 if (sendmsg(hapd->ctrl_sock, &msg, 0) < 0) { 2070 int _errno = errno; 2071 wpa_printf(MSG_INFO, "CTRL_IFACE monitor[%d]: " 2072 "%d - %s", 2073 idx, errno, strerror(errno)); 2074 dst->errors++; 2075 if (dst->errors > 10 || _errno == ENOENT) { 2076 hostapd_ctrl_iface_detach( 2077 hapd, &dst->addr, 2078 dst->addrlen); 2079 } 2080 } else 2081 dst->errors = 0; 2082 } 2083 idx++; 2084 dst = next; 2085 } 2086 } 2087 2088 #endif /* CONFIG_NATIVE_WINDOWS */ 2089
