1 /* 2 * Control interface for shared AP commands 3 * Copyright (c) 2004-2019, 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 #include "utils/common.h" 12 #include "common/ieee802_11_defs.h" 13 #include "common/sae.h" 14 #include "eapol_auth/eapol_auth_sm.h" 15 #include "fst/fst_ctrl_iface.h" 16 #include "hostapd.h" 17 #include "ieee802_1x.h" 18 #include "wpa_auth.h" 19 #include "ieee802_11.h" 20 #include "sta_info.h" 21 #include "wps_hostapd.h" 22 #include "p2p_hostapd.h" 23 #include "ctrl_iface_ap.h" 24 #include "ap_drv_ops.h" 25 #include "mbo_ap.h" 26 #include "taxonomy.h" 27 28 29 static size_t hostapd_write_ht_mcs_bitmask(char *buf, size_t buflen, 30 size_t curr_len, const u8 *mcs_set) 31 { 32 int ret; 33 size_t len = curr_len; 34 35 ret = os_snprintf(buf + len, buflen - len, 36 "ht_mcs_bitmask="); 37 if (os_snprintf_error(buflen - len, ret)) 38 return len; 39 len += ret; 40 41 /* 77 first bits (+ 3 reserved bits) */ 42 len += wpa_snprintf_hex(buf + len, buflen - len, mcs_set, 10); 43 44 ret = os_snprintf(buf + len, buflen - len, "\n"); 45 if (os_snprintf_error(buflen - len, ret)) 46 return curr_len; 47 len += ret; 48 49 return len; 50 } 51 52 53 static int hostapd_get_sta_tx_rx(struct hostapd_data *hapd, 54 struct sta_info *sta, 55 char *buf, size_t buflen) 56 { 57 struct hostap_sta_driver_data data; 58 int ret; 59 int len = 0; 60 61 if (hostapd_drv_read_sta_data(hapd, &data, sta->addr) < 0) 62 return 0; 63 64 ret = os_snprintf(buf, buflen, "rx_packets=%lu\ntx_packets=%lu\n" 65 "rx_bytes=%llu\ntx_bytes=%llu\ninactive_msec=%lu\n" 66 "signal=%d\n", 67 data.rx_packets, data.tx_packets, 68 data.rx_bytes, data.tx_bytes, data.inactive_msec, 69 data.signal); 70 if (os_snprintf_error(buflen, ret)) 71 return 0; 72 len += ret; 73 74 ret = os_snprintf(buf + len, buflen - len, "rx_rate_info=%lu", 75 data.current_rx_rate); 76 if (os_snprintf_error(buflen - len, ret)) 77 return len; 78 len += ret; 79 if (data.flags & STA_DRV_DATA_RX_MCS) { 80 ret = os_snprintf(buf + len, buflen - len, " mcs %u", 81 data.rx_mcs); 82 if (!os_snprintf_error(buflen - len, ret)) 83 len += ret; 84 } 85 if (data.flags & STA_DRV_DATA_RX_VHT_MCS) { 86 ret = os_snprintf(buf + len, buflen - len, " vhtmcs %u", 87 data.rx_vhtmcs); 88 if (!os_snprintf_error(buflen - len, ret)) 89 len += ret; 90 } 91 if (data.flags & STA_DRV_DATA_RX_VHT_NSS) { 92 ret = os_snprintf(buf + len, buflen - len, " vhtnss %u", 93 data.rx_vht_nss); 94 if (!os_snprintf_error(buflen - len, ret)) 95 len += ret; 96 } 97 if (data.flags & STA_DRV_DATA_RX_SHORT_GI) { 98 ret = os_snprintf(buf + len, buflen - len, " shortGI"); 99 if (!os_snprintf_error(buflen - len, ret)) 100 len += ret; 101 } 102 ret = os_snprintf(buf + len, buflen - len, "\n"); 103 if (!os_snprintf_error(buflen - len, ret)) 104 len += ret; 105 106 ret = os_snprintf(buf + len, buflen - len, "tx_rate_info=%lu", 107 data.current_tx_rate); 108 if (os_snprintf_error(buflen - len, ret)) 109 return len; 110 len += ret; 111 if (data.flags & STA_DRV_DATA_TX_MCS) { 112 ret = os_snprintf(buf + len, buflen - len, " mcs %u", 113 data.tx_mcs); 114 if (!os_snprintf_error(buflen - len, ret)) 115 len += ret; 116 } 117 if (data.flags & STA_DRV_DATA_TX_VHT_MCS) { 118 ret = os_snprintf(buf + len, buflen - len, " vhtmcs %u", 119 data.tx_vhtmcs); 120 if (!os_snprintf_error(buflen - len, ret)) 121 len += ret; 122 } 123 if (data.flags & STA_DRV_DATA_TX_VHT_NSS) { 124 ret = os_snprintf(buf + len, buflen - len, " vhtnss %u", 125 data.tx_vht_nss); 126 if (!os_snprintf_error(buflen - len, ret)) 127 len += ret; 128 } 129 if (data.flags & STA_DRV_DATA_TX_SHORT_GI) { 130 ret = os_snprintf(buf + len, buflen - len, " shortGI"); 131 if (!os_snprintf_error(buflen - len, ret)) 132 len += ret; 133 } 134 ret = os_snprintf(buf + len, buflen - len, "\n"); 135 if (!os_snprintf_error(buflen - len, ret)) 136 len += ret; 137 138 if ((sta->flags & WLAN_STA_VHT) && sta->vht_capabilities) { 139 ret = os_snprintf(buf + len, buflen - len, 140 "rx_vht_mcs_map=%04x\n" 141 "tx_vht_mcs_map=%04x\n", 142 le_to_host16(sta->vht_capabilities-> 143 vht_supported_mcs_set.rx_map), 144 le_to_host16(sta->vht_capabilities-> 145 vht_supported_mcs_set.tx_map)); 146 if (!os_snprintf_error(buflen - len, ret)) 147 len += ret; 148 } 149 150 if ((sta->flags & WLAN_STA_HT) && sta->ht_capabilities) { 151 len = hostapd_write_ht_mcs_bitmask(buf, buflen, len, 152 sta->ht_capabilities-> 153 supported_mcs_set); 154 } 155 156 if (data.flags & STA_DRV_DATA_LAST_ACK_RSSI) { 157 ret = os_snprintf(buf + len, buflen - len, 158 "last_ack_signal=%d\n", data.last_ack_rssi); 159 if (!os_snprintf_error(buflen - len, ret)) 160 len += ret; 161 } 162 163 return len; 164 } 165 166 167 static int hostapd_get_sta_conn_time(struct sta_info *sta, 168 char *buf, size_t buflen) 169 { 170 struct os_reltime age; 171 int ret; 172 173 if (!sta->connected_time.sec) 174 return 0; 175 176 os_reltime_age(&sta->connected_time, &age); 177 178 ret = os_snprintf(buf, buflen, "connected_time=%u\n", 179 (unsigned int) age.sec); 180 if (os_snprintf_error(buflen, ret)) 181 return 0; 182 return ret; 183 } 184 185 186 static const char * timeout_next_str(int val) 187 { 188 switch (val) { 189 case STA_NULLFUNC: 190 return "NULLFUNC POLL"; 191 case STA_DISASSOC: 192 return "DISASSOC"; 193 case STA_DEAUTH: 194 return "DEAUTH"; 195 case STA_REMOVE: 196 return "REMOVE"; 197 case STA_DISASSOC_FROM_CLI: 198 return "DISASSOC_FROM_CLI"; 199 } 200 201 return "?"; 202 } 203 204 205 static int hostapd_ctrl_iface_sta_mib(struct hostapd_data *hapd, 206 struct sta_info *sta, 207 char *buf, size_t buflen) 208 { 209 int len, res, ret, i; 210 const char *keyid; 211 212 if (!sta) 213 return 0; 214 215 len = 0; 216 ret = os_snprintf(buf + len, buflen - len, MACSTR "\nflags=", 217 MAC2STR(sta->addr)); 218 if (os_snprintf_error(buflen - len, ret)) 219 return len; 220 len += ret; 221 222 ret = ap_sta_flags_txt(sta->flags, buf + len, buflen - len); 223 if (ret < 0) 224 return len; 225 len += ret; 226 227 ret = os_snprintf(buf + len, buflen - len, "\naid=%d\ncapability=0x%x\n" 228 "listen_interval=%d\nsupported_rates=", 229 sta->aid, sta->capability, sta->listen_interval); 230 if (os_snprintf_error(buflen - len, ret)) 231 return len; 232 len += ret; 233 234 for (i = 0; i < sta->supported_rates_len; i++) { 235 ret = os_snprintf(buf + len, buflen - len, "%02x%s", 236 sta->supported_rates[i], 237 i + 1 < sta->supported_rates_len ? " " : ""); 238 if (os_snprintf_error(buflen - len, ret)) 239 return len; 240 len += ret; 241 } 242 243 ret = os_snprintf(buf + len, buflen - len, "\ntimeout_next=%s\n", 244 timeout_next_str(sta->timeout_next)); 245 if (os_snprintf_error(buflen - len, ret)) 246 return len; 247 len += ret; 248 249 res = ieee802_11_get_mib_sta(hapd, sta, buf + len, buflen - len); 250 if (res >= 0) 251 len += res; 252 res = wpa_get_mib_sta(sta->wpa_sm, buf + len, buflen - len); 253 if (res >= 0) 254 len += res; 255 res = ieee802_1x_get_mib_sta(hapd, sta, buf + len, buflen - len); 256 if (res >= 0) 257 len += res; 258 res = hostapd_wps_get_mib_sta(hapd, sta->addr, buf + len, 259 buflen - len); 260 if (res >= 0) 261 len += res; 262 res = hostapd_p2p_get_mib_sta(hapd, sta, buf + len, buflen - len); 263 if (res >= 0) 264 len += res; 265 266 len += hostapd_get_sta_tx_rx(hapd, sta, buf + len, buflen - len); 267 len += hostapd_get_sta_conn_time(sta, buf + len, buflen - len); 268 269 #ifdef CONFIG_SAE 270 if (sta->sae && sta->sae->state == SAE_ACCEPTED) { 271 res = os_snprintf(buf + len, buflen - len, "sae_group=%d\n", 272 sta->sae->group); 273 if (!os_snprintf_error(buflen - len, res)) 274 len += res; 275 } 276 #endif /* CONFIG_SAE */ 277 278 if (sta->vlan_id > 0) { 279 res = os_snprintf(buf + len, buflen - len, "vlan_id=%d\n", 280 sta->vlan_id); 281 if (!os_snprintf_error(buflen - len, res)) 282 len += res; 283 } 284 285 res = mbo_ap_get_info(sta, buf + len, buflen - len); 286 if (res >= 0) 287 len += res; 288 289 if (sta->supp_op_classes && 290 buflen - len > (unsigned) (17 + 2 * sta->supp_op_classes[0])) { 291 len += os_snprintf(buf + len, buflen - len, "supp_op_classes="); 292 len += wpa_snprintf_hex(buf + len, buflen - len, 293 sta->supp_op_classes + 1, 294 sta->supp_op_classes[0]); 295 len += os_snprintf(buf + len, buflen - len, "\n"); 296 } 297 298 if (sta->power_capab) { 299 ret = os_snprintf(buf + len, buflen - len, 300 "min_txpower=%d\n" 301 "max_txpower=%d\n", 302 sta->min_tx_power, sta->max_tx_power); 303 if (!os_snprintf_error(buflen - len, ret)) 304 len += ret; 305 } 306 307 #ifdef CONFIG_IEEE80211AC 308 if ((sta->flags & WLAN_STA_VHT) && sta->vht_capabilities) { 309 res = os_snprintf(buf + len, buflen - len, 310 "vht_caps_info=0x%08x\n", 311 le_to_host32(sta->vht_capabilities-> 312 vht_capabilities_info)); 313 if (!os_snprintf_error(buflen - len, res)) 314 len += res; 315 } 316 #endif /* CONFIG_IEEE80211AC */ 317 318 #ifdef CONFIG_IEEE80211N 319 if ((sta->flags & WLAN_STA_HT) && sta->ht_capabilities) { 320 res = os_snprintf(buf + len, buflen - len, 321 "ht_caps_info=0x%04x\n", 322 le_to_host16(sta->ht_capabilities-> 323 ht_capabilities_info)); 324 if (!os_snprintf_error(buflen - len, res)) 325 len += res; 326 } 327 #endif /* CONFIG_IEEE80211N */ 328 329 if (sta->ext_capability && 330 buflen - len > (unsigned) (11 + 2 * sta->ext_capability[0])) { 331 len += os_snprintf(buf + len, buflen - len, "ext_capab="); 332 len += wpa_snprintf_hex(buf + len, buflen - len, 333 sta->ext_capability + 1, 334 sta->ext_capability[0]); 335 len += os_snprintf(buf + len, buflen - len, "\n"); 336 } 337 338 if (sta->flags & WLAN_STA_WDS && sta->ifname_wds) { 339 ret = os_snprintf(buf + len, buflen - len, 340 "wds_sta_ifname=%s\n", sta->ifname_wds); 341 if (!os_snprintf_error(buflen - len, ret)) 342 len += ret; 343 } 344 345 keyid = ap_sta_wpa_get_keyid(hapd, sta); 346 if (keyid) { 347 ret = os_snprintf(buf + len, buflen - len, "keyid=%s\n", keyid); 348 if (!os_snprintf_error(buflen - len, ret)) 349 len += ret; 350 } 351 352 return len; 353 } 354 355 356 int hostapd_ctrl_iface_sta_first(struct hostapd_data *hapd, 357 char *buf, size_t buflen) 358 { 359 return hostapd_ctrl_iface_sta_mib(hapd, hapd->sta_list, buf, buflen); 360 } 361 362 363 int hostapd_ctrl_iface_sta(struct hostapd_data *hapd, const char *txtaddr, 364 char *buf, size_t buflen) 365 { 366 u8 addr[ETH_ALEN]; 367 int ret; 368 const char *pos; 369 struct sta_info *sta; 370 371 if (hwaddr_aton(txtaddr, addr)) { 372 ret = os_snprintf(buf, buflen, "FAIL\n"); 373 if (os_snprintf_error(buflen, ret)) 374 return 0; 375 return ret; 376 } 377 378 sta = ap_get_sta(hapd, addr); 379 if (sta == NULL) 380 return -1; 381 382 pos = os_strchr(txtaddr, ' '); 383 if (pos) { 384 pos++; 385 386 #ifdef HOSTAPD_DUMP_STATE 387 if (os_strcmp(pos, "eapol") == 0) { 388 if (sta->eapol_sm == NULL) 389 return -1; 390 return eapol_auth_dump_state(sta->eapol_sm, buf, 391 buflen); 392 } 393 #endif /* HOSTAPD_DUMP_STATE */ 394 395 return -1; 396 } 397 398 ret = hostapd_ctrl_iface_sta_mib(hapd, sta, buf, buflen); 399 ret += fst_ctrl_iface_mb_info(addr, buf + ret, buflen - ret); 400 401 return ret; 402 } 403 404 405 int hostapd_ctrl_iface_sta_next(struct hostapd_data *hapd, const char *txtaddr, 406 char *buf, size_t buflen) 407 { 408 u8 addr[ETH_ALEN]; 409 struct sta_info *sta; 410 int ret; 411 412 if (hwaddr_aton(txtaddr, addr) || 413 (sta = ap_get_sta(hapd, addr)) == NULL) { 414 ret = os_snprintf(buf, buflen, "FAIL\n"); 415 if (os_snprintf_error(buflen, ret)) 416 return 0; 417 return ret; 418 } 419 420 if (!sta->next) 421 return 0; 422 423 return hostapd_ctrl_iface_sta_mib(hapd, sta->next, buf, buflen); 424 } 425 426 427 #ifdef CONFIG_P2P_MANAGER 428 static int p2p_manager_disconnect(struct hostapd_data *hapd, u16 stype, 429 u8 minor_reason_code, const u8 *addr) 430 { 431 struct ieee80211_mgmt *mgmt; 432 int ret; 433 u8 *pos; 434 435 if (!hapd->drv_priv || !hapd->driver->send_frame) 436 return -1; 437 438 mgmt = os_zalloc(sizeof(*mgmt) + 100); 439 if (mgmt == NULL) 440 return -1; 441 442 mgmt->frame_control = IEEE80211_FC(WLAN_FC_TYPE_MGMT, stype); 443 wpa_dbg(hapd->msg_ctx, MSG_DEBUG, "P2P: Disconnect STA " MACSTR 444 " with minor reason code %u (stype=%u (%s))", 445 MAC2STR(addr), minor_reason_code, stype, 446 fc2str(le_to_host16(mgmt->frame_control))); 447 448 os_memcpy(mgmt->da, addr, ETH_ALEN); 449 os_memcpy(mgmt->sa, hapd->own_addr, ETH_ALEN); 450 os_memcpy(mgmt->bssid, hapd->own_addr, ETH_ALEN); 451 if (stype == WLAN_FC_STYPE_DEAUTH) { 452 mgmt->u.deauth.reason_code = 453 host_to_le16(WLAN_REASON_PREV_AUTH_NOT_VALID); 454 pos = mgmt->u.deauth.variable; 455 } else { 456 mgmt->u.disassoc.reason_code = 457 host_to_le16(WLAN_REASON_PREV_AUTH_NOT_VALID); 458 pos = mgmt->u.disassoc.variable; 459 } 460 461 *pos++ = WLAN_EID_VENDOR_SPECIFIC; 462 *pos++ = 4 + 3 + 1; 463 WPA_PUT_BE32(pos, P2P_IE_VENDOR_TYPE); 464 pos += 4; 465 466 *pos++ = P2P_ATTR_MINOR_REASON_CODE; 467 WPA_PUT_LE16(pos, 1); 468 pos += 2; 469 *pos++ = minor_reason_code; 470 471 ret = hapd->driver->send_frame(hapd->drv_priv, (u8 *) mgmt, 472 pos - (u8 *) mgmt, 1); 473 os_free(mgmt); 474 475 return ret < 0 ? -1 : 0; 476 } 477 #endif /* CONFIG_P2P_MANAGER */ 478 479 480 int hostapd_ctrl_iface_deauthenticate(struct hostapd_data *hapd, 481 const char *txtaddr) 482 { 483 u8 addr[ETH_ALEN]; 484 struct sta_info *sta; 485 const char *pos; 486 u16 reason = WLAN_REASON_PREV_AUTH_NOT_VALID; 487 488 wpa_dbg(hapd->msg_ctx, MSG_DEBUG, "CTRL_IFACE DEAUTHENTICATE %s", 489 txtaddr); 490 491 if (hwaddr_aton(txtaddr, addr)) 492 return -1; 493 494 pos = os_strstr(txtaddr, " reason="); 495 if (pos) 496 reason = atoi(pos + 8); 497 498 pos = os_strstr(txtaddr, " test="); 499 if (pos) { 500 struct ieee80211_mgmt mgmt; 501 int encrypt; 502 if (!hapd->drv_priv || !hapd->driver->send_frame) 503 return -1; 504 pos += 6; 505 encrypt = atoi(pos); 506 os_memset(&mgmt, 0, sizeof(mgmt)); 507 mgmt.frame_control = IEEE80211_FC(WLAN_FC_TYPE_MGMT, 508 WLAN_FC_STYPE_DEAUTH); 509 os_memcpy(mgmt.da, addr, ETH_ALEN); 510 os_memcpy(mgmt.sa, hapd->own_addr, ETH_ALEN); 511 os_memcpy(mgmt.bssid, hapd->own_addr, ETH_ALEN); 512 mgmt.u.deauth.reason_code = host_to_le16(reason); 513 if (hapd->driver->send_frame(hapd->drv_priv, (u8 *) &mgmt, 514 IEEE80211_HDRLEN + 515 sizeof(mgmt.u.deauth), 516 encrypt) < 0) 517 return -1; 518 return 0; 519 } 520 521 #ifdef CONFIG_P2P_MANAGER 522 pos = os_strstr(txtaddr, " p2p="); 523 if (pos) { 524 return p2p_manager_disconnect(hapd, WLAN_FC_STYPE_DEAUTH, 525 atoi(pos + 5), addr); 526 } 527 #endif /* CONFIG_P2P_MANAGER */ 528 529 if (os_strstr(txtaddr, " tx=0")) 530 hostapd_drv_sta_remove(hapd, addr); 531 else 532 hostapd_drv_sta_deauth(hapd, addr, reason); 533 sta = ap_get_sta(hapd, addr); 534 if (sta) 535 ap_sta_deauthenticate(hapd, sta, reason); 536 else if (addr[0] == 0xff) 537 hostapd_free_stas(hapd); 538 539 return 0; 540 } 541 542 543 int hostapd_ctrl_iface_disassociate(struct hostapd_data *hapd, 544 const char *txtaddr) 545 { 546 u8 addr[ETH_ALEN]; 547 struct sta_info *sta; 548 const char *pos; 549 u16 reason = WLAN_REASON_PREV_AUTH_NOT_VALID; 550 551 wpa_dbg(hapd->msg_ctx, MSG_DEBUG, "CTRL_IFACE DISASSOCIATE %s", 552 txtaddr); 553 554 if (hwaddr_aton(txtaddr, addr)) 555 return -1; 556 557 pos = os_strstr(txtaddr, " reason="); 558 if (pos) 559 reason = atoi(pos + 8); 560 561 pos = os_strstr(txtaddr, " test="); 562 if (pos) { 563 struct ieee80211_mgmt mgmt; 564 int encrypt; 565 if (!hapd->drv_priv || !hapd->driver->send_frame) 566 return -1; 567 pos += 6; 568 encrypt = atoi(pos); 569 os_memset(&mgmt, 0, sizeof(mgmt)); 570 mgmt.frame_control = IEEE80211_FC(WLAN_FC_TYPE_MGMT, 571 WLAN_FC_STYPE_DISASSOC); 572 os_memcpy(mgmt.da, addr, ETH_ALEN); 573 os_memcpy(mgmt.sa, hapd->own_addr, ETH_ALEN); 574 os_memcpy(mgmt.bssid, hapd->own_addr, ETH_ALEN); 575 mgmt.u.disassoc.reason_code = host_to_le16(reason); 576 if (hapd->driver->send_frame(hapd->drv_priv, (u8 *) &mgmt, 577 IEEE80211_HDRLEN + 578 sizeof(mgmt.u.deauth), 579 encrypt) < 0) 580 return -1; 581 return 0; 582 } 583 584 #ifdef CONFIG_P2P_MANAGER 585 pos = os_strstr(txtaddr, " p2p="); 586 if (pos) { 587 return p2p_manager_disconnect(hapd, WLAN_FC_STYPE_DISASSOC, 588 atoi(pos + 5), addr); 589 } 590 #endif /* CONFIG_P2P_MANAGER */ 591 592 if (os_strstr(txtaddr, " tx=0")) 593 hostapd_drv_sta_remove(hapd, addr); 594 else 595 hostapd_drv_sta_disassoc(hapd, addr, reason); 596 sta = ap_get_sta(hapd, addr); 597 if (sta) 598 ap_sta_disassociate(hapd, sta, reason); 599 else if (addr[0] == 0xff) 600 hostapd_free_stas(hapd); 601 602 return 0; 603 } 604 605 606 #ifdef CONFIG_TAXONOMY 607 int hostapd_ctrl_iface_signature(struct hostapd_data *hapd, 608 const char *txtaddr, 609 char *buf, size_t buflen) 610 { 611 u8 addr[ETH_ALEN]; 612 struct sta_info *sta; 613 614 wpa_dbg(hapd->msg_ctx, MSG_DEBUG, "CTRL_IFACE SIGNATURE %s", txtaddr); 615 616 if (hwaddr_aton(txtaddr, addr)) 617 return -1; 618 619 sta = ap_get_sta(hapd, addr); 620 if (!sta) 621 return -1; 622 623 return retrieve_sta_taxonomy(hapd, sta, buf, buflen); 624 } 625 #endif /* CONFIG_TAXONOMY */ 626 627 628 int hostapd_ctrl_iface_poll_sta(struct hostapd_data *hapd, 629 const char *txtaddr) 630 { 631 u8 addr[ETH_ALEN]; 632 struct sta_info *sta; 633 634 wpa_dbg(hapd->msg_ctx, MSG_DEBUG, "CTRL_IFACE POLL_STA %s", txtaddr); 635 636 if (hwaddr_aton(txtaddr, addr)) 637 return -1; 638 639 sta = ap_get_sta(hapd, addr); 640 if (!sta) 641 return -1; 642 643 hostapd_drv_poll_client(hapd, hapd->own_addr, addr, 644 sta->flags & WLAN_STA_WMM); 645 return 0; 646 } 647 648 649 int hostapd_ctrl_iface_status(struct hostapd_data *hapd, char *buf, 650 size_t buflen) 651 { 652 struct hostapd_iface *iface = hapd->iface; 653 struct hostapd_hw_modes *mode = iface->current_mode; 654 int len = 0, ret, j; 655 size_t i; 656 657 ret = os_snprintf(buf + len, buflen - len, 658 "state=%s\n" 659 "phy=%s\n" 660 "freq=%d\n" 661 "num_sta_non_erp=%d\n" 662 "num_sta_no_short_slot_time=%d\n" 663 "num_sta_no_short_preamble=%d\n" 664 "olbc=%d\n" 665 "num_sta_ht_no_gf=%d\n" 666 "num_sta_no_ht=%d\n" 667 "num_sta_ht_20_mhz=%d\n" 668 "num_sta_ht40_intolerant=%d\n" 669 "olbc_ht=%d\n" 670 "ht_op_mode=0x%x\n", 671 hostapd_state_text(iface->state), 672 iface->phy, 673 iface->freq, 674 iface->num_sta_non_erp, 675 iface->num_sta_no_short_slot_time, 676 iface->num_sta_no_short_preamble, 677 iface->olbc, 678 iface->num_sta_ht_no_gf, 679 iface->num_sta_no_ht, 680 iface->num_sta_ht_20mhz, 681 iface->num_sta_ht40_intolerant, 682 iface->olbc_ht, 683 iface->ht_op_mode); 684 if (os_snprintf_error(buflen - len, ret)) 685 return len; 686 len += ret; 687 688 if (!iface->cac_started || !iface->dfs_cac_ms) { 689 ret = os_snprintf(buf + len, buflen - len, 690 "cac_time_seconds=%d\n" 691 "cac_time_left_seconds=N/A\n", 692 iface->dfs_cac_ms / 1000); 693 } else { 694 /* CAC started and CAC time set - calculate remaining time */ 695 struct os_reltime now; 696 unsigned int left_time; 697 698 os_reltime_age(&iface->dfs_cac_start, &now); 699 left_time = iface->dfs_cac_ms / 1000 - now.sec; 700 ret = os_snprintf(buf + len, buflen - len, 701 "cac_time_seconds=%u\n" 702 "cac_time_left_seconds=%u\n", 703 iface->dfs_cac_ms / 1000, 704 left_time); 705 } 706 if (os_snprintf_error(buflen - len, ret)) 707 return len; 708 len += ret; 709 710 ret = os_snprintf(buf + len, buflen - len, 711 "channel=%u\n" 712 "secondary_channel=%d\n" 713 "ieee80211n=%d\n" 714 "ieee80211ac=%d\n" 715 "beacon_int=%u\n" 716 "dtim_period=%d\n", 717 iface->conf->channel, 718 iface->conf->ieee80211n && !hapd->conf->disable_11n ? 719 iface->conf->secondary_channel : 0, 720 iface->conf->ieee80211n && !hapd->conf->disable_11n, 721 iface->conf->ieee80211ac && 722 !hapd->conf->disable_11ac, 723 iface->conf->beacon_int, 724 hapd->conf->dtim_period); 725 if (os_snprintf_error(buflen - len, ret)) 726 return len; 727 len += ret; 728 if (iface->conf->ieee80211ac && !hapd->conf->disable_11ac) { 729 ret = os_snprintf(buf + len, buflen - len, 730 "vht_oper_chwidth=%d\n" 731 "vht_oper_centr_freq_seg0_idx=%d\n" 732 "vht_oper_centr_freq_seg1_idx=%d\n" 733 "vht_caps_info=%08x\n", 734 iface->conf->vht_oper_chwidth, 735 iface->conf->vht_oper_centr_freq_seg0_idx, 736 iface->conf->vht_oper_centr_freq_seg1_idx, 737 iface->conf->vht_capab); 738 if (os_snprintf_error(buflen - len, ret)) 739 return len; 740 len += ret; 741 } 742 743 if (iface->conf->ieee80211ac && !hapd->conf->disable_11ac && mode) { 744 u16 rxmap = WPA_GET_LE16(&mode->vht_mcs_set[0]); 745 u16 txmap = WPA_GET_LE16(&mode->vht_mcs_set[4]); 746 747 ret = os_snprintf(buf + len, buflen - len, 748 "rx_vht_mcs_map=%04x\n" 749 "tx_vht_mcs_map=%04x\n", 750 rxmap, txmap); 751 if (os_snprintf_error(buflen - len, ret)) 752 return len; 753 len += ret; 754 } 755 756 if (iface->conf->ieee80211n && !hapd->conf->disable_11n) { 757 ret = os_snprintf(buf + len, buflen - len, 758 "ht_caps_info=%04x\n", 759 hapd->iconf->ht_capab); 760 if (os_snprintf_error(buflen - len, ret)) 761 return len; 762 len += ret; 763 } 764 765 if (iface->conf->ieee80211n && !hapd->conf->disable_11n && mode) { 766 len = hostapd_write_ht_mcs_bitmask(buf, buflen, len, 767 mode->mcs_set); 768 } 769 770 if (iface->current_rates && iface->num_rates) { 771 ret = os_snprintf(buf + len, buflen - len, "supported_rates="); 772 if (os_snprintf_error(buflen - len, ret)) 773 return len; 774 len += ret; 775 776 for (j = 0; j < iface->num_rates; j++) { 777 ret = os_snprintf(buf + len, buflen - len, "%s%02x", 778 j > 0 ? " " : "", 779 iface->current_rates[j].rate / 5); 780 if (os_snprintf_error(buflen - len, ret)) 781 return len; 782 len += ret; 783 } 784 ret = os_snprintf(buf + len, buflen - len, "\n"); 785 if (os_snprintf_error(buflen - len, ret)) 786 return len; 787 len += ret; 788 } 789 790 for (j = 0; mode && j < mode->num_channels; j++) { 791 if (mode->channels[j].freq == iface->freq) { 792 ret = os_snprintf(buf + len, buflen - len, 793 "max_txpower=%u\n", 794 mode->channels[j].max_tx_power); 795 if (os_snprintf_error(buflen - len, ret)) 796 return len; 797 len += ret; 798 break; 799 } 800 } 801 802 for (i = 0; i < iface->num_bss; i++) { 803 struct hostapd_data *bss = iface->bss[i]; 804 ret = os_snprintf(buf + len, buflen - len, 805 "bss[%d]=%s\n" 806 "bssid[%d]=" MACSTR "\n" 807 "ssid[%d]=%s\n" 808 "num_sta[%d]=%d\n", 809 (int) i, bss->conf->iface, 810 (int) i, MAC2STR(bss->own_addr), 811 (int) i, 812 wpa_ssid_txt(bss->conf->ssid.ssid, 813 bss->conf->ssid.ssid_len), 814 (int) i, bss->num_sta); 815 if (os_snprintf_error(buflen - len, ret)) 816 return len; 817 len += ret; 818 } 819 820 if (hapd->conf->chan_util_avg_period) { 821 ret = os_snprintf(buf + len, buflen - len, 822 "chan_util_avg=%u\n", 823 iface->chan_util_average); 824 if (os_snprintf_error(buflen - len, ret)) 825 return len; 826 len += ret; 827 } 828 829 return len; 830 } 831 832 833 int hostapd_parse_csa_settings(const char *pos, 834 struct csa_settings *settings) 835 { 836 char *end; 837 838 os_memset(settings, 0, sizeof(*settings)); 839 settings->cs_count = strtol(pos, &end, 10); 840 if (pos == end) { 841 wpa_printf(MSG_ERROR, "chanswitch: invalid cs_count provided"); 842 return -1; 843 } 844 845 settings->freq_params.freq = atoi(end); 846 if (settings->freq_params.freq == 0) { 847 wpa_printf(MSG_ERROR, "chanswitch: invalid freq provided"); 848 return -1; 849 } 850 851 #define SET_CSA_SETTING(str) \ 852 do { \ 853 const char *pos2 = os_strstr(pos, " " #str "="); \ 854 if (pos2) { \ 855 pos2 += sizeof(" " #str "=") - 1; \ 856 settings->freq_params.str = atoi(pos2); \ 857 } \ 858 } while (0) 859 860 SET_CSA_SETTING(center_freq1); 861 SET_CSA_SETTING(center_freq2); 862 SET_CSA_SETTING(bandwidth); 863 SET_CSA_SETTING(sec_channel_offset); 864 settings->freq_params.ht_enabled = !!os_strstr(pos, " ht"); 865 settings->freq_params.vht_enabled = !!os_strstr(pos, " vht"); 866 settings->block_tx = !!os_strstr(pos, " blocktx"); 867 #undef SET_CSA_SETTING 868 869 return 0; 870 } 871 872 873 int hostapd_ctrl_iface_stop_ap(struct hostapd_data *hapd) 874 { 875 return hostapd_drv_stop_ap(hapd); 876 } 877 878 879 int hostapd_ctrl_iface_pmksa_list(struct hostapd_data *hapd, char *buf, 880 size_t len) 881 { 882 return wpa_auth_pmksa_list(hapd->wpa_auth, buf, len); 883 } 884 885 886 void hostapd_ctrl_iface_pmksa_flush(struct hostapd_data *hapd) 887 { 888 wpa_auth_pmksa_flush(hapd->wpa_auth); 889 } 890 891 892 int hostapd_ctrl_iface_pmksa_add(struct hostapd_data *hapd, char *cmd) 893 { 894 u8 spa[ETH_ALEN]; 895 u8 pmkid[PMKID_LEN]; 896 u8 pmk[PMK_LEN_MAX]; 897 size_t pmk_len; 898 char *pos, *pos2; 899 int akmp = 0, expiration = 0; 900 901 /* 902 * Entry format: 903 * <STA addr> <PMKID> <PMK> <expiration in seconds> <akmp> 904 */ 905 906 if (hwaddr_aton(cmd, spa)) 907 return -1; 908 909 pos = os_strchr(cmd, ' '); 910 if (!pos) 911 return -1; 912 pos++; 913 914 if (hexstr2bin(pos, pmkid, PMKID_LEN) < 0) 915 return -1; 916 917 pos = os_strchr(pos, ' '); 918 if (!pos) 919 return -1; 920 pos++; 921 922 pos2 = os_strchr(pos, ' '); 923 if (!pos2) 924 return -1; 925 pmk_len = (pos2 - pos) / 2; 926 if (pmk_len < PMK_LEN || pmk_len > PMK_LEN_MAX || 927 hexstr2bin(pos, pmk, pmk_len) < 0) 928 return -1; 929 930 pos = pos2 + 1; 931 932 if (sscanf(pos, "%d %d", &expiration, &akmp) != 2) 933 return -1; 934 935 return wpa_auth_pmksa_add2(hapd->wpa_auth, spa, pmk, pmk_len, 936 pmkid, expiration, akmp); 937 } 938 939 940 #ifdef CONFIG_PMKSA_CACHE_EXTERNAL 941 #ifdef CONFIG_MESH 942 943 int hostapd_ctrl_iface_pmksa_list_mesh(struct hostapd_data *hapd, 944 const u8 *addr, char *buf, size_t len) 945 { 946 return wpa_auth_pmksa_list_mesh(hapd->wpa_auth, addr, buf, len); 947 } 948 949 950 void * hostapd_ctrl_iface_pmksa_create_entry(const u8 *aa, char *cmd) 951 { 952 u8 spa[ETH_ALEN]; 953 u8 pmkid[PMKID_LEN]; 954 u8 pmk[PMK_LEN_MAX]; 955 char *pos; 956 int expiration; 957 958 /* 959 * Entry format: 960 * <BSSID> <PMKID> <PMK> <expiration in seconds> 961 */ 962 963 if (hwaddr_aton(cmd, spa)) 964 return NULL; 965 966 pos = os_strchr(cmd, ' '); 967 if (!pos) 968 return NULL; 969 pos++; 970 971 if (hexstr2bin(pos, pmkid, PMKID_LEN) < 0) 972 return NULL; 973 974 pos = os_strchr(pos, ' '); 975 if (!pos) 976 return NULL; 977 pos++; 978 979 if (hexstr2bin(pos, pmk, PMK_LEN) < 0) 980 return NULL; 981 982 pos = os_strchr(pos, ' '); 983 if (!pos) 984 return NULL; 985 pos++; 986 987 if (sscanf(pos, "%d", &expiration) != 1) 988 return NULL; 989 990 return wpa_auth_pmksa_create_entry(aa, spa, pmk, pmkid, expiration); 991 } 992 993 #endif /* CONFIG_MESH */ 994 #endif /* CONFIG_PMKSA_CACHE_EXTERNAL */ 995
