1 /* 2 * IEEE 802.11 Common routines 3 * Copyright (c) 2002-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 11 #include "common.h" 12 #include "defs.h" 13 #include "wpa_common.h" 14 #include "drivers/driver.h" 15 #include "qca-vendor.h" 16 #include "ieee802_11_defs.h" 17 #include "ieee802_11_common.h" 18 19 20 static int ieee802_11_parse_vendor_specific(const u8 *pos, size_t elen, 21 struct ieee802_11_elems *elems, 22 int show_errors) 23 { 24 unsigned int oui; 25 26 /* first 3 bytes in vendor specific information element are the IEEE 27 * OUI of the vendor. The following byte is used a vendor specific 28 * sub-type. */ 29 if (elen < 4) { 30 if (show_errors) { 31 wpa_printf(MSG_MSGDUMP, "short vendor specific " 32 "information element ignored (len=%lu)", 33 (unsigned long) elen); 34 } 35 return -1; 36 } 37 38 oui = WPA_GET_BE24(pos); 39 switch (oui) { 40 case OUI_MICROSOFT: 41 /* Microsoft/Wi-Fi information elements are further typed and 42 * subtyped */ 43 switch (pos[3]) { 44 case 1: 45 /* Microsoft OUI (00:50:F2) with OUI Type 1: 46 * real WPA information element */ 47 elems->wpa_ie = pos; 48 elems->wpa_ie_len = elen; 49 break; 50 case WMM_OUI_TYPE: 51 /* WMM information element */ 52 if (elen < 5) { 53 wpa_printf(MSG_MSGDUMP, "short WMM " 54 "information element ignored " 55 "(len=%lu)", 56 (unsigned long) elen); 57 return -1; 58 } 59 switch (pos[4]) { 60 case WMM_OUI_SUBTYPE_INFORMATION_ELEMENT: 61 case WMM_OUI_SUBTYPE_PARAMETER_ELEMENT: 62 /* 63 * Share same pointer since only one of these 64 * is used and they start with same data. 65 * Length field can be used to distinguish the 66 * IEs. 67 */ 68 elems->wmm = pos; 69 elems->wmm_len = elen; 70 break; 71 case WMM_OUI_SUBTYPE_TSPEC_ELEMENT: 72 elems->wmm_tspec = pos; 73 elems->wmm_tspec_len = elen; 74 break; 75 default: 76 wpa_printf(MSG_EXCESSIVE, "unknown WMM " 77 "information element ignored " 78 "(subtype=%d len=%lu)", 79 pos[4], (unsigned long) elen); 80 return -1; 81 } 82 break; 83 case 4: 84 /* Wi-Fi Protected Setup (WPS) IE */ 85 elems->wps_ie = pos; 86 elems->wps_ie_len = elen; 87 break; 88 default: 89 wpa_printf(MSG_EXCESSIVE, "Unknown Microsoft " 90 "information element ignored " 91 "(type=%d len=%lu)", 92 pos[3], (unsigned long) elen); 93 return -1; 94 } 95 break; 96 97 case OUI_WFA: 98 switch (pos[3]) { 99 case P2P_OUI_TYPE: 100 /* Wi-Fi Alliance - P2P IE */ 101 elems->p2p = pos; 102 elems->p2p_len = elen; 103 break; 104 case WFD_OUI_TYPE: 105 /* Wi-Fi Alliance - WFD IE */ 106 elems->wfd = pos; 107 elems->wfd_len = elen; 108 break; 109 case HS20_INDICATION_OUI_TYPE: 110 /* Hotspot 2.0 */ 111 elems->hs20 = pos; 112 elems->hs20_len = elen; 113 break; 114 case HS20_OSEN_OUI_TYPE: 115 /* Hotspot 2.0 OSEN */ 116 elems->osen = pos; 117 elems->osen_len = elen; 118 break; 119 case MBO_OUI_TYPE: 120 /* MBO-OCE */ 121 elems->mbo = pos; 122 elems->mbo_len = elen; 123 break; 124 case HS20_ROAMING_CONS_SEL_OUI_TYPE: 125 /* Hotspot 2.0 Roaming Consortium Selection */ 126 elems->roaming_cons_sel = pos; 127 elems->roaming_cons_sel_len = elen; 128 break; 129 case MULTI_AP_OUI_TYPE: 130 elems->multi_ap = pos; 131 elems->multi_ap_len = elen; 132 break; 133 case OWE_OUI_TYPE: 134 /* OWE Transition Mode element */ 135 break; 136 case DPP_CC_OUI_TYPE: 137 /* DPP Configurator Connectivity element */ 138 break; 139 case SAE_PK_OUI_TYPE: 140 elems->sae_pk = pos + 4; 141 elems->sae_pk_len = elen - 4; 142 break; 143 default: 144 wpa_printf(MSG_MSGDUMP, "Unknown WFA " 145 "information element ignored " 146 "(type=%d len=%lu)", 147 pos[3], (unsigned long) elen); 148 return -1; 149 } 150 break; 151 152 case OUI_BROADCOM: 153 switch (pos[3]) { 154 case VENDOR_HT_CAPAB_OUI_TYPE: 155 elems->vendor_ht_cap = pos; 156 elems->vendor_ht_cap_len = elen; 157 break; 158 case VENDOR_VHT_TYPE: 159 if (elen > 4 && 160 (pos[4] == VENDOR_VHT_SUBTYPE || 161 pos[4] == VENDOR_VHT_SUBTYPE2)) { 162 elems->vendor_vht = pos; 163 elems->vendor_vht_len = elen; 164 } else 165 return -1; 166 break; 167 default: 168 wpa_printf(MSG_EXCESSIVE, "Unknown Broadcom " 169 "information element ignored " 170 "(type=%d len=%lu)", 171 pos[3], (unsigned long) elen); 172 return -1; 173 } 174 break; 175 176 case OUI_QCA: 177 switch (pos[3]) { 178 case QCA_VENDOR_ELEM_P2P_PREF_CHAN_LIST: 179 elems->pref_freq_list = pos; 180 elems->pref_freq_list_len = elen; 181 break; 182 default: 183 wpa_printf(MSG_EXCESSIVE, 184 "Unknown QCA information element ignored (type=%d len=%lu)", 185 pos[3], (unsigned long) elen); 186 return -1; 187 } 188 break; 189 190 default: 191 wpa_printf(MSG_EXCESSIVE, "unknown vendor specific " 192 "information element ignored (vendor OUI " 193 "%02x:%02x:%02x len=%lu)", 194 pos[0], pos[1], pos[2], (unsigned long) elen); 195 return -1; 196 } 197 198 return 0; 199 } 200 201 202 static int ieee802_11_parse_extension(const u8 *pos, size_t elen, 203 struct ieee802_11_elems *elems, 204 int show_errors) 205 { 206 u8 ext_id; 207 208 if (elen < 1) { 209 if (show_errors) { 210 wpa_printf(MSG_MSGDUMP, 211 "short information element (Ext)"); 212 } 213 return -1; 214 } 215 216 ext_id = *pos++; 217 elen--; 218 219 elems->frag_ies.last_eid_ext = 0; 220 221 switch (ext_id) { 222 case WLAN_EID_EXT_ASSOC_DELAY_INFO: 223 if (elen != 1) 224 break; 225 elems->assoc_delay_info = pos; 226 break; 227 case WLAN_EID_EXT_FILS_REQ_PARAMS: 228 if (elen < 3) 229 break; 230 elems->fils_req_params = pos; 231 elems->fils_req_params_len = elen; 232 break; 233 case WLAN_EID_EXT_FILS_KEY_CONFIRM: 234 elems->fils_key_confirm = pos; 235 elems->fils_key_confirm_len = elen; 236 break; 237 case WLAN_EID_EXT_FILS_SESSION: 238 if (elen != FILS_SESSION_LEN) 239 break; 240 elems->fils_session = pos; 241 break; 242 case WLAN_EID_EXT_FILS_HLP_CONTAINER: 243 if (elen < 2 * ETH_ALEN) 244 break; 245 elems->fils_hlp = pos; 246 elems->fils_hlp_len = elen; 247 break; 248 case WLAN_EID_EXT_FILS_IP_ADDR_ASSIGN: 249 if (elen < 1) 250 break; 251 elems->fils_ip_addr_assign = pos; 252 elems->fils_ip_addr_assign_len = elen; 253 break; 254 case WLAN_EID_EXT_KEY_DELIVERY: 255 if (elen < WPA_KEY_RSC_LEN) 256 break; 257 elems->key_delivery = pos; 258 elems->key_delivery_len = elen; 259 break; 260 case WLAN_EID_EXT_WRAPPED_DATA: 261 elems->wrapped_data = pos; 262 elems->wrapped_data_len = elen; 263 break; 264 case WLAN_EID_EXT_FILS_PUBLIC_KEY: 265 if (elen < 1) 266 break; 267 elems->fils_pk = pos; 268 elems->fils_pk_len = elen; 269 break; 270 case WLAN_EID_EXT_FILS_NONCE: 271 if (elen != FILS_NONCE_LEN) 272 break; 273 elems->fils_nonce = pos; 274 break; 275 case WLAN_EID_EXT_OWE_DH_PARAM: 276 if (elen < 2) 277 break; 278 elems->owe_dh = pos; 279 elems->owe_dh_len = elen; 280 break; 281 case WLAN_EID_EXT_PASSWORD_IDENTIFIER: 282 elems->password_id = pos; 283 elems->password_id_len = elen; 284 break; 285 case WLAN_EID_EXT_HE_CAPABILITIES: 286 elems->he_capabilities = pos; 287 elems->he_capabilities_len = elen; 288 break; 289 case WLAN_EID_EXT_HE_OPERATION: 290 elems->he_operation = pos; 291 elems->he_operation_len = elen; 292 break; 293 case WLAN_EID_EXT_OCV_OCI: 294 elems->oci = pos; 295 elems->oci_len = elen; 296 break; 297 case WLAN_EID_EXT_SHORT_SSID_LIST: 298 elems->short_ssid_list = pos; 299 elems->short_ssid_list_len = elen; 300 break; 301 case WLAN_EID_EXT_HE_6GHZ_BAND_CAP: 302 if (elen < sizeof(struct ieee80211_he_6ghz_band_cap)) 303 break; 304 elems->he_6ghz_band_cap = pos; 305 break; 306 case WLAN_EID_EXT_PASN_PARAMS: 307 elems->pasn_params = pos; 308 elems->pasn_params_len = elen; 309 break; 310 default: 311 if (show_errors) { 312 wpa_printf(MSG_MSGDUMP, 313 "IEEE 802.11 element parsing ignored unknown element extension (ext_id=%u elen=%u)", 314 ext_id, (unsigned int) elen); 315 } 316 return -1; 317 } 318 319 if (elen == 254) 320 elems->frag_ies.last_eid_ext = ext_id; 321 322 return 0; 323 } 324 325 326 static void ieee802_11_parse_fragment(struct frag_ies_info *frag_ies, 327 const u8 *pos, u8 elen) 328 { 329 if (frag_ies->n_frags >= MAX_NUM_FRAG_IES_SUPPORTED) { 330 wpa_printf(MSG_MSGDUMP, "Too many element fragments - skip"); 331 return; 332 } 333 334 /* 335 * Note: while EID == 0 is a valid ID (SSID IE), it should not be 336 * fragmented. 337 */ 338 if (!frag_ies->last_eid) { 339 wpa_printf(MSG_MSGDUMP, 340 "Fragment without a valid last element - skip"); 341 return; 342 } 343 344 frag_ies->frags[frag_ies->n_frags].ie = pos; 345 frag_ies->frags[frag_ies->n_frags].ie_len = elen; 346 frag_ies->frags[frag_ies->n_frags].eid = frag_ies->last_eid; 347 frag_ies->frags[frag_ies->n_frags].eid_ext = frag_ies->last_eid_ext; 348 frag_ies->n_frags++; 349 } 350 351 352 /** 353 * ieee802_11_parse_elems - Parse information elements in management frames 354 * @start: Pointer to the start of IEs 355 * @len: Length of IE buffer in octets 356 * @elems: Data structure for parsed elements 357 * @show_errors: Whether to show parsing errors in debug log 358 * Returns: Parsing result 359 */ 360 ParseRes ieee802_11_parse_elems(const u8 *start, size_t len, 361 struct ieee802_11_elems *elems, 362 int show_errors) 363 { 364 const struct element *elem; 365 int unknown = 0; 366 367 os_memset(elems, 0, sizeof(*elems)); 368 369 if (!start) 370 return ParseOK; 371 372 for_each_element(elem, start, len) { 373 u8 id = elem->id, elen = elem->datalen; 374 const u8 *pos = elem->data; 375 376 switch (id) { 377 case WLAN_EID_SSID: 378 if (elen > SSID_MAX_LEN) { 379 wpa_printf(MSG_DEBUG, 380 "Ignored too long SSID element (elen=%u)", 381 elen); 382 break; 383 } 384 if (elems->ssid) { 385 wpa_printf(MSG_MSGDUMP, 386 "Ignored duplicated SSID element"); 387 break; 388 } 389 elems->ssid = pos; 390 elems->ssid_len = elen; 391 break; 392 case WLAN_EID_SUPP_RATES: 393 elems->supp_rates = pos; 394 elems->supp_rates_len = elen; 395 break; 396 case WLAN_EID_DS_PARAMS: 397 if (elen < 1) 398 break; 399 elems->ds_params = pos; 400 break; 401 case WLAN_EID_CF_PARAMS: 402 case WLAN_EID_TIM: 403 break; 404 case WLAN_EID_CHALLENGE: 405 elems->challenge = pos; 406 elems->challenge_len = elen; 407 break; 408 case WLAN_EID_ERP_INFO: 409 if (elen < 1) 410 break; 411 elems->erp_info = pos; 412 break; 413 case WLAN_EID_EXT_SUPP_RATES: 414 elems->ext_supp_rates = pos; 415 elems->ext_supp_rates_len = elen; 416 break; 417 case WLAN_EID_VENDOR_SPECIFIC: 418 if (ieee802_11_parse_vendor_specific(pos, elen, 419 elems, 420 show_errors)) 421 unknown++; 422 break; 423 case WLAN_EID_RSN: 424 elems->rsn_ie = pos; 425 elems->rsn_ie_len = elen; 426 break; 427 case WLAN_EID_RSNX: 428 elems->rsnxe = pos; 429 elems->rsnxe_len = elen; 430 break; 431 case WLAN_EID_PWR_CAPABILITY: 432 if (elen < 2) 433 break; 434 elems->power_capab = pos; 435 elems->power_capab_len = elen; 436 break; 437 case WLAN_EID_SUPPORTED_CHANNELS: 438 elems->supp_channels = pos; 439 elems->supp_channels_len = elen; 440 break; 441 case WLAN_EID_MOBILITY_DOMAIN: 442 if (elen < sizeof(struct rsn_mdie)) 443 break; 444 elems->mdie = pos; 445 elems->mdie_len = elen; 446 break; 447 case WLAN_EID_FAST_BSS_TRANSITION: 448 if (elen < sizeof(struct rsn_ftie)) 449 break; 450 elems->ftie = pos; 451 elems->ftie_len = elen; 452 break; 453 case WLAN_EID_TIMEOUT_INTERVAL: 454 if (elen != 5) 455 break; 456 elems->timeout_int = pos; 457 break; 458 case WLAN_EID_HT_CAP: 459 if (elen < sizeof(struct ieee80211_ht_capabilities)) 460 break; 461 elems->ht_capabilities = pos; 462 break; 463 case WLAN_EID_HT_OPERATION: 464 if (elen < sizeof(struct ieee80211_ht_operation)) 465 break; 466 elems->ht_operation = pos; 467 break; 468 case WLAN_EID_MESH_CONFIG: 469 elems->mesh_config = pos; 470 elems->mesh_config_len = elen; 471 break; 472 case WLAN_EID_MESH_ID: 473 elems->mesh_id = pos; 474 elems->mesh_id_len = elen; 475 break; 476 case WLAN_EID_PEER_MGMT: 477 elems->peer_mgmt = pos; 478 elems->peer_mgmt_len = elen; 479 break; 480 case WLAN_EID_VHT_CAP: 481 if (elen < sizeof(struct ieee80211_vht_capabilities)) 482 break; 483 elems->vht_capabilities = pos; 484 break; 485 case WLAN_EID_VHT_OPERATION: 486 if (elen < sizeof(struct ieee80211_vht_operation)) 487 break; 488 elems->vht_operation = pos; 489 break; 490 case WLAN_EID_VHT_OPERATING_MODE_NOTIFICATION: 491 if (elen != 1) 492 break; 493 elems->vht_opmode_notif = pos; 494 break; 495 case WLAN_EID_LINK_ID: 496 if (elen < 18) 497 break; 498 elems->link_id = pos; 499 break; 500 case WLAN_EID_INTERWORKING: 501 elems->interworking = pos; 502 elems->interworking_len = elen; 503 break; 504 case WLAN_EID_QOS_MAP_SET: 505 if (elen < 16) 506 break; 507 elems->qos_map_set = pos; 508 elems->qos_map_set_len = elen; 509 break; 510 case WLAN_EID_EXT_CAPAB: 511 elems->ext_capab = pos; 512 elems->ext_capab_len = elen; 513 break; 514 case WLAN_EID_BSS_MAX_IDLE_PERIOD: 515 if (elen < 3) 516 break; 517 elems->bss_max_idle_period = pos; 518 break; 519 case WLAN_EID_SSID_LIST: 520 elems->ssid_list = pos; 521 elems->ssid_list_len = elen; 522 break; 523 case WLAN_EID_AMPE: 524 elems->ampe = pos; 525 elems->ampe_len = elen; 526 break; 527 case WLAN_EID_MIC: 528 elems->mic = pos; 529 elems->mic_len = elen; 530 /* after mic everything is encrypted, so stop. */ 531 goto done; 532 case WLAN_EID_MULTI_BAND: 533 if (elems->mb_ies.nof_ies >= MAX_NOF_MB_IES_SUPPORTED) { 534 wpa_printf(MSG_MSGDUMP, 535 "IEEE 802.11 element parse ignored MB IE (id=%d elen=%d)", 536 id, elen); 537 break; 538 } 539 540 elems->mb_ies.ies[elems->mb_ies.nof_ies].ie = pos; 541 elems->mb_ies.ies[elems->mb_ies.nof_ies].ie_len = elen; 542 elems->mb_ies.nof_ies++; 543 break; 544 case WLAN_EID_SUPPORTED_OPERATING_CLASSES: 545 elems->supp_op_classes = pos; 546 elems->supp_op_classes_len = elen; 547 break; 548 case WLAN_EID_RRM_ENABLED_CAPABILITIES: 549 elems->rrm_enabled = pos; 550 elems->rrm_enabled_len = elen; 551 break; 552 case WLAN_EID_CAG_NUMBER: 553 elems->cag_number = pos; 554 elems->cag_number_len = elen; 555 break; 556 case WLAN_EID_AP_CSN: 557 if (elen < 1) 558 break; 559 elems->ap_csn = pos; 560 break; 561 case WLAN_EID_FILS_INDICATION: 562 if (elen < 2) 563 break; 564 elems->fils_indic = pos; 565 elems->fils_indic_len = elen; 566 break; 567 case WLAN_EID_DILS: 568 if (elen < 2) 569 break; 570 elems->dils = pos; 571 elems->dils_len = elen; 572 break; 573 case WLAN_EID_S1G_CAPABILITIES: 574 if (elen < 15) 575 break; 576 elems->s1g_capab = pos; 577 break; 578 case WLAN_EID_FRAGMENT: 579 ieee802_11_parse_fragment(&elems->frag_ies, pos, elen); 580 break; 581 case WLAN_EID_EXTENSION: 582 if (ieee802_11_parse_extension(pos, elen, elems, 583 show_errors)) 584 unknown++; 585 break; 586 default: 587 unknown++; 588 if (!show_errors) 589 break; 590 wpa_printf(MSG_MSGDUMP, "IEEE 802.11 element parse " 591 "ignored unknown element (id=%d elen=%d)", 592 id, elen); 593 break; 594 } 595 596 if (id != WLAN_EID_FRAGMENT && elen == 255) 597 elems->frag_ies.last_eid = id; 598 599 if (id == WLAN_EID_EXTENSION && !elems->frag_ies.last_eid_ext) 600 elems->frag_ies.last_eid = 0; 601 } 602 603 if (!for_each_element_completed(elem, start, len)) { 604 if (show_errors) { 605 wpa_printf(MSG_DEBUG, 606 "IEEE 802.11 element parse failed @%d", 607 (int) (start + len - (const u8 *) elem)); 608 wpa_hexdump(MSG_MSGDUMP, "IEs", start, len); 609 } 610 return ParseFailed; 611 } 612 613 done: 614 return unknown ? ParseUnknown : ParseOK; 615 } 616 617 618 int ieee802_11_ie_count(const u8 *ies, size_t ies_len) 619 { 620 const struct element *elem; 621 int count = 0; 622 623 if (ies == NULL) 624 return 0; 625 626 for_each_element(elem, ies, ies_len) 627 count++; 628 629 return count; 630 } 631 632 633 struct wpabuf * ieee802_11_vendor_ie_concat(const u8 *ies, size_t ies_len, 634 u32 oui_type) 635 { 636 struct wpabuf *buf; 637 const struct element *elem, *found = NULL; 638 639 for_each_element_id(elem, WLAN_EID_VENDOR_SPECIFIC, ies, ies_len) { 640 if (elem->datalen >= 4 && 641 WPA_GET_BE32(elem->data) == oui_type) { 642 found = elem; 643 break; 644 } 645 } 646 647 if (!found) 648 return NULL; /* No specified vendor IE found */ 649 650 buf = wpabuf_alloc(ies_len); 651 if (buf == NULL) 652 return NULL; 653 654 /* 655 * There may be multiple vendor IEs in the message, so need to 656 * concatenate their data fields. 657 */ 658 for_each_element_id(elem, WLAN_EID_VENDOR_SPECIFIC, ies, ies_len) { 659 if (elem->datalen >= 4 && WPA_GET_BE32(elem->data) == oui_type) 660 wpabuf_put_data(buf, elem->data + 4, elem->datalen - 4); 661 } 662 663 return buf; 664 } 665 666 667 const u8 * get_hdr_bssid(const struct ieee80211_hdr *hdr, size_t len) 668 { 669 u16 fc, type, stype; 670 671 /* 672 * PS-Poll frames are 16 bytes. All other frames are 673 * 24 bytes or longer. 674 */ 675 if (len < 16) 676 return NULL; 677 678 fc = le_to_host16(hdr->frame_control); 679 type = WLAN_FC_GET_TYPE(fc); 680 stype = WLAN_FC_GET_STYPE(fc); 681 682 switch (type) { 683 case WLAN_FC_TYPE_DATA: 684 if (len < 24) 685 return NULL; 686 switch (fc & (WLAN_FC_FROMDS | WLAN_FC_TODS)) { 687 case WLAN_FC_FROMDS | WLAN_FC_TODS: 688 case WLAN_FC_TODS: 689 return hdr->addr1; 690 case WLAN_FC_FROMDS: 691 return hdr->addr2; 692 default: 693 return NULL; 694 } 695 case WLAN_FC_TYPE_CTRL: 696 if (stype != WLAN_FC_STYPE_PSPOLL) 697 return NULL; 698 return hdr->addr1; 699 case WLAN_FC_TYPE_MGMT: 700 return hdr->addr3; 701 default: 702 return NULL; 703 } 704 } 705 706 707 int hostapd_config_wmm_ac(struct hostapd_wmm_ac_params wmm_ac_params[], 708 const char *name, const char *val) 709 { 710 int num, v; 711 const char *pos; 712 struct hostapd_wmm_ac_params *ac; 713 714 /* skip 'wme_ac_' or 'wmm_ac_' prefix */ 715 pos = name + 7; 716 if (os_strncmp(pos, "be_", 3) == 0) { 717 num = 0; 718 pos += 3; 719 } else if (os_strncmp(pos, "bk_", 3) == 0) { 720 num = 1; 721 pos += 3; 722 } else if (os_strncmp(pos, "vi_", 3) == 0) { 723 num = 2; 724 pos += 3; 725 } else if (os_strncmp(pos, "vo_", 3) == 0) { 726 num = 3; 727 pos += 3; 728 } else { 729 wpa_printf(MSG_ERROR, "Unknown WMM name '%s'", pos); 730 return -1; 731 } 732 733 ac = &wmm_ac_params[num]; 734 735 if (os_strcmp(pos, "aifs") == 0) { 736 v = atoi(val); 737 if (v < 1 || v > 255) { 738 wpa_printf(MSG_ERROR, "Invalid AIFS value %d", v); 739 return -1; 740 } 741 ac->aifs = v; 742 } else if (os_strcmp(pos, "cwmin") == 0) { 743 v = atoi(val); 744 if (v < 0 || v > 15) { 745 wpa_printf(MSG_ERROR, "Invalid cwMin value %d", v); 746 return -1; 747 } 748 ac->cwmin = v; 749 } else if (os_strcmp(pos, "cwmax") == 0) { 750 v = atoi(val); 751 if (v < 0 || v > 15) { 752 wpa_printf(MSG_ERROR, "Invalid cwMax value %d", v); 753 return -1; 754 } 755 ac->cwmax = v; 756 } else if (os_strcmp(pos, "txop_limit") == 0) { 757 v = atoi(val); 758 if (v < 0 || v > 0xffff) { 759 wpa_printf(MSG_ERROR, "Invalid txop value %d", v); 760 return -1; 761 } 762 ac->txop_limit = v; 763 } else if (os_strcmp(pos, "acm") == 0) { 764 v = atoi(val); 765 if (v < 0 || v > 1) { 766 wpa_printf(MSG_ERROR, "Invalid acm value %d", v); 767 return -1; 768 } 769 ac->admission_control_mandatory = v; 770 } else { 771 wpa_printf(MSG_ERROR, "Unknown wmm_ac_ field '%s'", pos); 772 return -1; 773 } 774 775 return 0; 776 } 777 778 779 /* convert floats with one decimal place to value*10 int, i.e., 780 * "1.5" will return 15 781 */ 782 static int hostapd_config_read_int10(const char *value) 783 { 784 int i, d; 785 char *pos; 786 787 i = atoi(value); 788 pos = os_strchr(value, '.'); 789 d = 0; 790 if (pos) { 791 pos++; 792 if (*pos >= '0' && *pos <= '9') 793 d = *pos - '0'; 794 } 795 796 return i * 10 + d; 797 } 798 799 800 static int valid_cw(int cw) 801 { 802 return (cw == 1 || cw == 3 || cw == 7 || cw == 15 || cw == 31 || 803 cw == 63 || cw == 127 || cw == 255 || cw == 511 || cw == 1023 || 804 cw == 2047 || cw == 4095 || cw == 8191 || cw == 16383 || 805 cw == 32767); 806 } 807 808 809 int hostapd_config_tx_queue(struct hostapd_tx_queue_params tx_queue[], 810 const char *name, const char *val) 811 { 812 int num; 813 const char *pos; 814 struct hostapd_tx_queue_params *queue; 815 816 /* skip 'tx_queue_' prefix */ 817 pos = name + 9; 818 if (os_strncmp(pos, "data", 4) == 0 && 819 pos[4] >= '0' && pos[4] <= '9' && pos[5] == '_') { 820 num = pos[4] - '0'; 821 pos += 6; 822 } else if (os_strncmp(pos, "after_beacon_", 13) == 0 || 823 os_strncmp(pos, "beacon_", 7) == 0) { 824 wpa_printf(MSG_INFO, "DEPRECATED: '%s' not used", name); 825 return 0; 826 } else { 827 wpa_printf(MSG_ERROR, "Unknown tx_queue name '%s'", pos); 828 return -1; 829 } 830 831 if (num >= NUM_TX_QUEUES) { 832 /* for backwards compatibility, do not trigger failure */ 833 wpa_printf(MSG_INFO, "DEPRECATED: '%s' not used", name); 834 return 0; 835 } 836 837 queue = &tx_queue[num]; 838 839 if (os_strcmp(pos, "aifs") == 0) { 840 queue->aifs = atoi(val); 841 if (queue->aifs < 0 || queue->aifs > 255) { 842 wpa_printf(MSG_ERROR, "Invalid AIFS value %d", 843 queue->aifs); 844 return -1; 845 } 846 } else if (os_strcmp(pos, "cwmin") == 0) { 847 queue->cwmin = atoi(val); 848 if (!valid_cw(queue->cwmin)) { 849 wpa_printf(MSG_ERROR, "Invalid cwMin value %d", 850 queue->cwmin); 851 return -1; 852 } 853 } else if (os_strcmp(pos, "cwmax") == 0) { 854 queue->cwmax = atoi(val); 855 if (!valid_cw(queue->cwmax)) { 856 wpa_printf(MSG_ERROR, "Invalid cwMax value %d", 857 queue->cwmax); 858 return -1; 859 } 860 } else if (os_strcmp(pos, "burst") == 0) { 861 queue->burst = hostapd_config_read_int10(val); 862 } else { 863 wpa_printf(MSG_ERROR, "Unknown queue field '%s'", pos); 864 return -1; 865 } 866 867 return 0; 868 } 869 870 871 enum hostapd_hw_mode ieee80211_freq_to_chan(int freq, u8 *channel) 872 { 873 u8 op_class; 874 875 return ieee80211_freq_to_channel_ext(freq, 0, CHANWIDTH_USE_HT, 876 &op_class, channel); 877 } 878 879 880 /** 881 * ieee80211_freq_to_channel_ext - Convert frequency into channel info 882 * for HT40, VHT, and HE. DFS channels are not covered. 883 * @freq: Frequency (MHz) to convert 884 * @sec_channel: 0 = non-HT40, 1 = sec. channel above, -1 = sec. channel below 885 * @chanwidth: VHT/EDMG channel width (CHANWIDTH_*) 886 * @op_class: Buffer for returning operating class 887 * @channel: Buffer for returning channel number 888 * Returns: hw_mode on success, NUM_HOSTAPD_MODES on failure 889 */ 890 enum hostapd_hw_mode ieee80211_freq_to_channel_ext(unsigned int freq, 891 int sec_channel, 892 int chanwidth, 893 u8 *op_class, u8 *channel) 894 { 895 u8 vht_opclass; 896 897 /* TODO: more operating classes */ 898 899 if (sec_channel > 1 || sec_channel < -1) 900 return NUM_HOSTAPD_MODES; 901 902 if (freq >= 2412 && freq <= 2472) { 903 if ((freq - 2407) % 5) 904 return NUM_HOSTAPD_MODES; 905 906 if (chanwidth) 907 return NUM_HOSTAPD_MODES; 908 909 /* 2.407 GHz, channels 1..13 */ 910 if (sec_channel == 1) 911 *op_class = 83; 912 else if (sec_channel == -1) 913 *op_class = 84; 914 else 915 *op_class = 81; 916 917 *channel = (freq - 2407) / 5; 918 919 return HOSTAPD_MODE_IEEE80211G; 920 } 921 922 if (freq == 2484) { 923 if (sec_channel || chanwidth) 924 return NUM_HOSTAPD_MODES; 925 926 *op_class = 82; /* channel 14 */ 927 *channel = 14; 928 929 return HOSTAPD_MODE_IEEE80211B; 930 } 931 932 if (freq >= 4900 && freq < 5000) { 933 if ((freq - 4000) % 5) 934 return NUM_HOSTAPD_MODES; 935 *channel = (freq - 4000) / 5; 936 *op_class = 0; /* TODO */ 937 return HOSTAPD_MODE_IEEE80211A; 938 } 939 940 switch (chanwidth) { 941 case CHANWIDTH_80MHZ: 942 vht_opclass = 128; 943 break; 944 case CHANWIDTH_160MHZ: 945 vht_opclass = 129; 946 break; 947 case CHANWIDTH_80P80MHZ: 948 vht_opclass = 130; 949 break; 950 default: 951 vht_opclass = 0; 952 break; 953 } 954 955 /* 5 GHz, channels 36..48 */ 956 if (freq >= 5180 && freq <= 5240) { 957 if ((freq - 5000) % 5) 958 return NUM_HOSTAPD_MODES; 959 960 if (vht_opclass) 961 *op_class = vht_opclass; 962 else if (sec_channel == 1) 963 *op_class = 116; 964 else if (sec_channel == -1) 965 *op_class = 117; 966 else 967 *op_class = 115; 968 969 *channel = (freq - 5000) / 5; 970 971 return HOSTAPD_MODE_IEEE80211A; 972 } 973 974 /* 5 GHz, channels 52..64 */ 975 if (freq >= 5260 && freq <= 5320) { 976 if ((freq - 5000) % 5) 977 return NUM_HOSTAPD_MODES; 978 979 if (vht_opclass) 980 *op_class = vht_opclass; 981 else if (sec_channel == 1) 982 *op_class = 119; 983 else if (sec_channel == -1) 984 *op_class = 120; 985 else 986 *op_class = 118; 987 988 *channel = (freq - 5000) / 5; 989 990 return HOSTAPD_MODE_IEEE80211A; 991 } 992 993 /* 5 GHz, channels 149..177 */ 994 if (freq >= 5745 && freq <= 5885) { 995 if ((freq - 5000) % 5) 996 return NUM_HOSTAPD_MODES; 997 998 if (vht_opclass) 999 *op_class = vht_opclass; 1000 else if (sec_channel == 1) 1001 *op_class = 126; 1002 else if (sec_channel == -1) 1003 *op_class = 127; 1004 else if (freq <= 5805) 1005 *op_class = 124; 1006 else 1007 *op_class = 125; 1008 1009 *channel = (freq - 5000) / 5; 1010 1011 return HOSTAPD_MODE_IEEE80211A; 1012 } 1013 1014 /* 5 GHz, channels 100..140 */ 1015 if (freq >= 5000 && freq <= 5700) { 1016 if ((freq - 5000) % 5) 1017 return NUM_HOSTAPD_MODES; 1018 1019 if (vht_opclass) 1020 *op_class = vht_opclass; 1021 else if (sec_channel == 1) 1022 *op_class = 122; 1023 else if (sec_channel == -1) 1024 *op_class = 123; 1025 else 1026 *op_class = 121; 1027 1028 *channel = (freq - 5000) / 5; 1029 1030 return HOSTAPD_MODE_IEEE80211A; 1031 } 1032 1033 if (freq >= 5000 && freq < 5900) { 1034 if ((freq - 5000) % 5) 1035 return NUM_HOSTAPD_MODES; 1036 *channel = (freq - 5000) / 5; 1037 *op_class = 0; /* TODO */ 1038 return HOSTAPD_MODE_IEEE80211A; 1039 } 1040 1041 if (freq > 5950 && freq <= 7115) { 1042 if ((freq - 5950) % 5) 1043 return NUM_HOSTAPD_MODES; 1044 1045 switch (chanwidth) { 1046 case CHANWIDTH_80MHZ: 1047 *op_class = 133; 1048 break; 1049 case CHANWIDTH_160MHZ: 1050 *op_class = 134; 1051 break; 1052 case CHANWIDTH_80P80MHZ: 1053 *op_class = 135; 1054 break; 1055 default: 1056 if (sec_channel) 1057 *op_class = 132; 1058 else 1059 *op_class = 131; 1060 break; 1061 } 1062 1063 *channel = (freq - 5950) / 5; 1064 return HOSTAPD_MODE_IEEE80211A; 1065 } 1066 1067 if (freq == 5935) { 1068 *op_class = 136; 1069 *channel = (freq - 5925) / 5; 1070 return HOSTAPD_MODE_IEEE80211A; 1071 } 1072 1073 /* 56.16 GHz, channel 1..6 */ 1074 if (freq >= 56160 + 2160 * 1 && freq <= 56160 + 2160 * 6) { 1075 if (sec_channel) 1076 return NUM_HOSTAPD_MODES; 1077 1078 switch (chanwidth) { 1079 case CHANWIDTH_USE_HT: 1080 case CHANWIDTH_2160MHZ: 1081 *channel = (freq - 56160) / 2160; 1082 *op_class = 180; 1083 break; 1084 case CHANWIDTH_4320MHZ: 1085 /* EDMG channels 9 - 13 */ 1086 if (freq > 56160 + 2160 * 5) 1087 return NUM_HOSTAPD_MODES; 1088 1089 *channel = (freq - 56160) / 2160 + 8; 1090 *op_class = 181; 1091 break; 1092 case CHANWIDTH_6480MHZ: 1093 /* EDMG channels 17 - 20 */ 1094 if (freq > 56160 + 2160 * 4) 1095 return NUM_HOSTAPD_MODES; 1096 1097 *channel = (freq - 56160) / 2160 + 16; 1098 *op_class = 182; 1099 break; 1100 case CHANWIDTH_8640MHZ: 1101 /* EDMG channels 25 - 27 */ 1102 if (freq > 56160 + 2160 * 3) 1103 return NUM_HOSTAPD_MODES; 1104 1105 *channel = (freq - 56160) / 2160 + 24; 1106 *op_class = 183; 1107 break; 1108 default: 1109 return NUM_HOSTAPD_MODES; 1110 } 1111 1112 return HOSTAPD_MODE_IEEE80211AD; 1113 } 1114 1115 return NUM_HOSTAPD_MODES; 1116 } 1117 1118 1119 int ieee80211_chaninfo_to_channel(unsigned int freq, enum chan_width chanwidth, 1120 int sec_channel, u8 *op_class, u8 *channel) 1121 { 1122 int cw = CHAN_WIDTH_UNKNOWN; 1123 1124 switch (chanwidth) { 1125 case CHAN_WIDTH_UNKNOWN: 1126 case CHAN_WIDTH_20_NOHT: 1127 case CHAN_WIDTH_20: 1128 case CHAN_WIDTH_40: 1129 cw = CHANWIDTH_USE_HT; 1130 break; 1131 case CHAN_WIDTH_80: 1132 cw = CHANWIDTH_80MHZ; 1133 break; 1134 case CHAN_WIDTH_80P80: 1135 cw = CHANWIDTH_80P80MHZ; 1136 break; 1137 case CHAN_WIDTH_160: 1138 cw = CHANWIDTH_160MHZ; 1139 break; 1140 case CHAN_WIDTH_2160: 1141 cw = CHANWIDTH_2160MHZ; 1142 break; 1143 case CHAN_WIDTH_4320: 1144 cw = CHANWIDTH_4320MHZ; 1145 break; 1146 case CHAN_WIDTH_6480: 1147 cw = CHANWIDTH_6480MHZ; 1148 break; 1149 case CHAN_WIDTH_8640: 1150 cw = CHANWIDTH_8640MHZ; 1151 break; 1152 } 1153 1154 if (ieee80211_freq_to_channel_ext(freq, sec_channel, cw, op_class, 1155 channel) == NUM_HOSTAPD_MODES) { 1156 wpa_printf(MSG_WARNING, 1157 "Cannot determine operating class and channel (freq=%u chanwidth=%d sec_channel=%d)", 1158 freq, chanwidth, sec_channel); 1159 return -1; 1160 } 1161 1162 return 0; 1163 } 1164 1165 1166 static const char *const us_op_class_cc[] = { 1167 "US", "CA", NULL 1168 }; 1169 1170 static const char *const eu_op_class_cc[] = { 1171 "AL", "AM", "AT", "AZ", "BA", "BE", "BG", "BY", "CH", "CY", "CZ", "DE", 1172 "DK", "EE", "EL", "ES", "FI", "FR", "GE", "HR", "HU", "IE", "IS", "IT", 1173 "LI", "LT", "LU", "LV", "MD", "ME", "MK", "MT", "NL", "NO", "PL", "PT", 1174 "RO", "RS", "RU", "SE", "SI", "SK", "TR", "UA", "UK", NULL 1175 }; 1176 1177 static const char *const jp_op_class_cc[] = { 1178 "JP", NULL 1179 }; 1180 1181 static const char *const cn_op_class_cc[] = { 1182 "CN", NULL 1183 }; 1184 1185 1186 static int country_match(const char *const cc[], const char *const country) 1187 { 1188 int i; 1189 1190 if (country == NULL) 1191 return 0; 1192 for (i = 0; cc[i]; i++) { 1193 if (cc[i][0] == country[0] && cc[i][1] == country[1]) 1194 return 1; 1195 } 1196 1197 return 0; 1198 } 1199 1200 1201 static int ieee80211_chan_to_freq_us(u8 op_class, u8 chan) 1202 { 1203 switch (op_class) { 1204 case 12: /* channels 1..11 */ 1205 case 32: /* channels 1..7; 40 MHz */ 1206 case 33: /* channels 5..11; 40 MHz */ 1207 if (chan < 1 || chan > 11) 1208 return -1; 1209 return 2407 + 5 * chan; 1210 case 1: /* channels 36,40,44,48 */ 1211 case 2: /* channels 52,56,60,64; dfs */ 1212 case 22: /* channels 36,44; 40 MHz */ 1213 case 23: /* channels 52,60; 40 MHz */ 1214 case 27: /* channels 40,48; 40 MHz */ 1215 case 28: /* channels 56,64; 40 MHz */ 1216 if (chan < 36 || chan > 64) 1217 return -1; 1218 return 5000 + 5 * chan; 1219 case 4: /* channels 100-144 */ 1220 case 24: /* channels 100-140; 40 MHz */ 1221 if (chan < 100 || chan > 144) 1222 return -1; 1223 return 5000 + 5 * chan; 1224 case 3: /* channels 149,153,157,161 */ 1225 case 25: /* channels 149,157; 40 MHz */ 1226 case 26: /* channels 149,157; 40 MHz */ 1227 case 30: /* channels 153,161; 40 MHz */ 1228 case 31: /* channels 153,161; 40 MHz */ 1229 if (chan < 149 || chan > 161) 1230 return -1; 1231 return 5000 + 5 * chan; 1232 case 5: /* channels 149,153,157,161,165 */ 1233 if (chan < 149 || chan > 165) 1234 return -1; 1235 return 5000 + 5 * chan; 1236 case 34: /* 60 GHz band, channels 1..8 */ 1237 if (chan < 1 || chan > 8) 1238 return -1; 1239 return 56160 + 2160 * chan; 1240 case 37: /* 60 GHz band, EDMG CB2, channels 9..15 */ 1241 if (chan < 9 || chan > 15) 1242 return -1; 1243 return 56160 + 2160 * (chan - 8); 1244 case 38: /* 60 GHz band, EDMG CB3, channels 17..22 */ 1245 if (chan < 17 || chan > 22) 1246 return -1; 1247 return 56160 + 2160 * (chan - 16); 1248 case 39: /* 60 GHz band, EDMG CB4, channels 25..29 */ 1249 if (chan < 25 || chan > 29) 1250 return -1; 1251 return 56160 + 2160 * (chan - 24); 1252 } 1253 return -1; 1254 } 1255 1256 1257 static int ieee80211_chan_to_freq_eu(u8 op_class, u8 chan) 1258 { 1259 switch (op_class) { 1260 case 4: /* channels 1..13 */ 1261 case 11: /* channels 1..9; 40 MHz */ 1262 case 12: /* channels 5..13; 40 MHz */ 1263 if (chan < 1 || chan > 13) 1264 return -1; 1265 return 2407 + 5 * chan; 1266 case 1: /* channels 36,40,44,48 */ 1267 case 2: /* channels 52,56,60,64; dfs */ 1268 case 5: /* channels 36,44; 40 MHz */ 1269 case 6: /* channels 52,60; 40 MHz */ 1270 case 8: /* channels 40,48; 40 MHz */ 1271 case 9: /* channels 56,64; 40 MHz */ 1272 if (chan < 36 || chan > 64) 1273 return -1; 1274 return 5000 + 5 * chan; 1275 case 3: /* channels 100-140 */ 1276 case 7: /* channels 100-132; 40 MHz */ 1277 case 10: /* channels 104-136; 40 MHz */ 1278 case 16: /* channels 100-140 */ 1279 if (chan < 100 || chan > 140) 1280 return -1; 1281 return 5000 + 5 * chan; 1282 case 17: /* channels 149,153,157,161,165,169 */ 1283 if (chan < 149 || chan > 169) 1284 return -1; 1285 return 5000 + 5 * chan; 1286 case 18: /* 60 GHz band, channels 1..6 */ 1287 if (chan < 1 || chan > 6) 1288 return -1; 1289 return 56160 + 2160 * chan; 1290 case 21: /* 60 GHz band, EDMG CB2, channels 9..11 */ 1291 if (chan < 9 || chan > 11) 1292 return -1; 1293 return 56160 + 2160 * (chan - 8); 1294 case 22: /* 60 GHz band, EDMG CB3, channels 17..18 */ 1295 if (chan < 17 || chan > 18) 1296 return -1; 1297 return 56160 + 2160 * (chan - 16); 1298 case 23: /* 60 GHz band, EDMG CB4, channels 25 */ 1299 if (chan != 25) 1300 return -1; 1301 return 56160 + 2160 * (chan - 24); 1302 } 1303 return -1; 1304 } 1305 1306 1307 static int ieee80211_chan_to_freq_jp(u8 op_class, u8 chan) 1308 { 1309 switch (op_class) { 1310 case 30: /* channels 1..13 */ 1311 case 56: /* channels 1..9; 40 MHz */ 1312 case 57: /* channels 5..13; 40 MHz */ 1313 if (chan < 1 || chan > 13) 1314 return -1; 1315 return 2407 + 5 * chan; 1316 case 31: /* channel 14 */ 1317 if (chan != 14) 1318 return -1; 1319 return 2414 + 5 * chan; 1320 case 1: /* channels 34,38,42,46(old) or 36,40,44,48 */ 1321 case 32: /* channels 52,56,60,64 */ 1322 case 33: /* channels 52,56,60,64 */ 1323 case 36: /* channels 36,44; 40 MHz */ 1324 case 37: /* channels 52,60; 40 MHz */ 1325 case 38: /* channels 52,60; 40 MHz */ 1326 case 41: /* channels 40,48; 40 MHz */ 1327 case 42: /* channels 56,64; 40 MHz */ 1328 case 43: /* channels 56,64; 40 MHz */ 1329 if (chan < 34 || chan > 64) 1330 return -1; 1331 return 5000 + 5 * chan; 1332 case 34: /* channels 100-140 */ 1333 case 35: /* channels 100-140 */ 1334 case 39: /* channels 100-132; 40 MHz */ 1335 case 40: /* channels 100-132; 40 MHz */ 1336 case 44: /* channels 104-136; 40 MHz */ 1337 case 45: /* channels 104-136; 40 MHz */ 1338 case 58: /* channels 100-140 */ 1339 if (chan < 100 || chan > 140) 1340 return -1; 1341 return 5000 + 5 * chan; 1342 case 59: /* 60 GHz band, channels 1..6 */ 1343 if (chan < 1 || chan > 6) 1344 return -1; 1345 return 56160 + 2160 * chan; 1346 case 62: /* 60 GHz band, EDMG CB2, channels 9..11 */ 1347 if (chan < 9 || chan > 11) 1348 return -1; 1349 return 56160 + 2160 * (chan - 8); 1350 case 63: /* 60 GHz band, EDMG CB3, channels 17..18 */ 1351 if (chan < 17 || chan > 18) 1352 return -1; 1353 return 56160 + 2160 * (chan - 16); 1354 case 64: /* 60 GHz band, EDMG CB4, channel 25 */ 1355 if (chan != 25) 1356 return -1; 1357 return 56160 + 2160 * (chan - 24); 1358 } 1359 return -1; 1360 } 1361 1362 1363 static int ieee80211_chan_to_freq_cn(u8 op_class, u8 chan) 1364 { 1365 switch (op_class) { 1366 case 7: /* channels 1..13 */ 1367 case 8: /* channels 1..9; 40 MHz */ 1368 case 9: /* channels 5..13; 40 MHz */ 1369 if (chan < 1 || chan > 13) 1370 return -1; 1371 return 2407 + 5 * chan; 1372 case 1: /* channels 36,40,44,48 */ 1373 case 2: /* channels 52,56,60,64; dfs */ 1374 case 4: /* channels 36,44; 40 MHz */ 1375 case 5: /* channels 52,60; 40 MHz */ 1376 if (chan < 36 || chan > 64) 1377 return -1; 1378 return 5000 + 5 * chan; 1379 case 3: /* channels 149,153,157,161,165 */ 1380 case 6: /* channels 149,157; 40 MHz */ 1381 if (chan < 149 || chan > 165) 1382 return -1; 1383 return 5000 + 5 * chan; 1384 } 1385 return -1; 1386 } 1387 1388 1389 static int ieee80211_chan_to_freq_global(u8 op_class, u8 chan) 1390 { 1391 /* Table E-4 in IEEE Std 802.11-2012 - Global operating classes */ 1392 switch (op_class) { 1393 case 81: 1394 /* channels 1..13 */ 1395 if (chan < 1 || chan > 13) 1396 return -1; 1397 return 2407 + 5 * chan; 1398 case 82: 1399 /* channel 14 */ 1400 if (chan != 14) 1401 return -1; 1402 return 2414 + 5 * chan; 1403 case 83: /* channels 1..9; 40 MHz */ 1404 case 84: /* channels 5..13; 40 MHz */ 1405 if (chan < 1 || chan > 13) 1406 return -1; 1407 return 2407 + 5 * chan; 1408 case 115: /* channels 36,40,44,48; indoor only */ 1409 case 116: /* channels 36,44; 40 MHz; indoor only */ 1410 case 117: /* channels 40,48; 40 MHz; indoor only */ 1411 case 118: /* channels 52,56,60,64; dfs */ 1412 case 119: /* channels 52,60; 40 MHz; dfs */ 1413 case 120: /* channels 56,64; 40 MHz; dfs */ 1414 if (chan < 36 || chan > 64) 1415 return -1; 1416 return 5000 + 5 * chan; 1417 case 121: /* channels 100-140 */ 1418 case 122: /* channels 100-142; 40 MHz */ 1419 case 123: /* channels 104-136; 40 MHz */ 1420 if (chan < 100 || chan > 140) 1421 return -1; 1422 return 5000 + 5 * chan; 1423 case 124: /* channels 149,153,157,161 */ 1424 if (chan < 149 || chan > 161) 1425 return -1; 1426 return 5000 + 5 * chan; 1427 case 125: /* channels 149,153,157,161,165,169,173,177 */ 1428 case 126: /* channels 149,157,165,173; 40 MHz */ 1429 case 127: /* channels 153,161,169,177; 40 MHz */ 1430 if (chan < 149 || chan > 177) 1431 return -1; 1432 return 5000 + 5 * chan; 1433 case 128: /* center freqs 42, 58, 106, 122, 138, 155, 171; 80 MHz */ 1434 case 130: /* center freqs 42, 58, 106, 122, 138, 155, 171; 80 MHz */ 1435 if (chan < 36 || chan > 177) 1436 return -1; 1437 return 5000 + 5 * chan; 1438 case 129: /* center freqs 50, 114, 163; 160 MHz */ 1439 if (chan < 36 || chan > 177) 1440 return -1; 1441 return 5000 + 5 * chan; 1442 case 131: /* UHB channels, 20 MHz: 1, 5, 9.. */ 1443 case 132: /* UHB channels, 40 MHz: 3, 11, 19.. */ 1444 case 133: /* UHB channels, 80 MHz: 7, 23, 39.. */ 1445 case 134: /* UHB channels, 160 MHz: 15, 47, 79.. */ 1446 case 135: /* UHB channels, 80+80 MHz: 7, 23, 39.. */ 1447 if (chan < 1 || chan > 233) 1448 return -1; 1449 return 5950 + chan * 5; 1450 case 136: /* UHB channels, 20 MHz: 2 */ 1451 if (chan == 2) 1452 return 5935; 1453 return -1; 1454 case 180: /* 60 GHz band, channels 1..8 */ 1455 if (chan < 1 || chan > 8) 1456 return -1; 1457 return 56160 + 2160 * chan; 1458 case 181: /* 60 GHz band, EDMG CB2, channels 9..15 */ 1459 if (chan < 9 || chan > 15) 1460 return -1; 1461 return 56160 + 2160 * (chan - 8); 1462 case 182: /* 60 GHz band, EDMG CB3, channels 17..22 */ 1463 if (chan < 17 || chan > 22) 1464 return -1; 1465 return 56160 + 2160 * (chan - 16); 1466 case 183: /* 60 GHz band, EDMG CB4, channel 25..29 */ 1467 if (chan < 25 || chan > 29) 1468 return -1; 1469 return 56160 + 2160 * (chan - 24); 1470 } 1471 return -1; 1472 } 1473 1474 /** 1475 * ieee80211_chan_to_freq - Convert channel info to frequency 1476 * @country: Country code, if known; otherwise, global operating class is used 1477 * @op_class: Operating class 1478 * @chan: Channel number 1479 * Returns: Frequency in MHz or -1 if the specified channel is unknown 1480 */ 1481 int ieee80211_chan_to_freq(const char *country, u8 op_class, u8 chan) 1482 { 1483 int freq; 1484 1485 if (country_match(us_op_class_cc, country)) { 1486 freq = ieee80211_chan_to_freq_us(op_class, chan); 1487 if (freq > 0) 1488 return freq; 1489 } 1490 1491 if (country_match(eu_op_class_cc, country)) { 1492 freq = ieee80211_chan_to_freq_eu(op_class, chan); 1493 if (freq > 0) 1494 return freq; 1495 } 1496 1497 if (country_match(jp_op_class_cc, country)) { 1498 freq = ieee80211_chan_to_freq_jp(op_class, chan); 1499 if (freq > 0) 1500 return freq; 1501 } 1502 1503 if (country_match(cn_op_class_cc, country)) { 1504 freq = ieee80211_chan_to_freq_cn(op_class, chan); 1505 if (freq > 0) 1506 return freq; 1507 } 1508 1509 return ieee80211_chan_to_freq_global(op_class, chan); 1510 } 1511 1512 1513 int ieee80211_is_dfs(int freq, const struct hostapd_hw_modes *modes, 1514 u16 num_modes) 1515 { 1516 int i, j; 1517 1518 if (!modes || !num_modes) 1519 return (freq >= 5260 && freq <= 5320) || 1520 (freq >= 5500 && freq <= 5700); 1521 1522 for (i = 0; i < num_modes; i++) { 1523 for (j = 0; j < modes[i].num_channels; j++) { 1524 if (modes[i].channels[j].freq == freq && 1525 (modes[i].channels[j].flag & HOSTAPD_CHAN_RADAR)) 1526 return 1; 1527 } 1528 } 1529 1530 return 0; 1531 } 1532 1533 1534 static int is_11b(u8 rate) 1535 { 1536 return rate == 0x02 || rate == 0x04 || rate == 0x0b || rate == 0x16; 1537 } 1538 1539 1540 int supp_rates_11b_only(struct ieee802_11_elems *elems) 1541 { 1542 int num_11b = 0, num_others = 0; 1543 int i; 1544 1545 if (elems->supp_rates == NULL && elems->ext_supp_rates == NULL) 1546 return 0; 1547 1548 for (i = 0; elems->supp_rates && i < elems->supp_rates_len; i++) { 1549 if (is_11b(elems->supp_rates[i])) 1550 num_11b++; 1551 else 1552 num_others++; 1553 } 1554 1555 for (i = 0; elems->ext_supp_rates && i < elems->ext_supp_rates_len; 1556 i++) { 1557 if (is_11b(elems->ext_supp_rates[i])) 1558 num_11b++; 1559 else 1560 num_others++; 1561 } 1562 1563 return num_11b > 0 && num_others == 0; 1564 } 1565 1566 1567 const char * fc2str(u16 fc) 1568 { 1569 u16 stype = WLAN_FC_GET_STYPE(fc); 1570 #define C2S(x) case x: return #x; 1571 1572 switch (WLAN_FC_GET_TYPE(fc)) { 1573 case WLAN_FC_TYPE_MGMT: 1574 switch (stype) { 1575 C2S(WLAN_FC_STYPE_ASSOC_REQ) 1576 C2S(WLAN_FC_STYPE_ASSOC_RESP) 1577 C2S(WLAN_FC_STYPE_REASSOC_REQ) 1578 C2S(WLAN_FC_STYPE_REASSOC_RESP) 1579 C2S(WLAN_FC_STYPE_PROBE_REQ) 1580 C2S(WLAN_FC_STYPE_PROBE_RESP) 1581 C2S(WLAN_FC_STYPE_BEACON) 1582 C2S(WLAN_FC_STYPE_ATIM) 1583 C2S(WLAN_FC_STYPE_DISASSOC) 1584 C2S(WLAN_FC_STYPE_AUTH) 1585 C2S(WLAN_FC_STYPE_DEAUTH) 1586 C2S(WLAN_FC_STYPE_ACTION) 1587 } 1588 break; 1589 case WLAN_FC_TYPE_CTRL: 1590 switch (stype) { 1591 C2S(WLAN_FC_STYPE_PSPOLL) 1592 C2S(WLAN_FC_STYPE_RTS) 1593 C2S(WLAN_FC_STYPE_CTS) 1594 C2S(WLAN_FC_STYPE_ACK) 1595 C2S(WLAN_FC_STYPE_CFEND) 1596 C2S(WLAN_FC_STYPE_CFENDACK) 1597 } 1598 break; 1599 case WLAN_FC_TYPE_DATA: 1600 switch (stype) { 1601 C2S(WLAN_FC_STYPE_DATA) 1602 C2S(WLAN_FC_STYPE_DATA_CFACK) 1603 C2S(WLAN_FC_STYPE_DATA_CFPOLL) 1604 C2S(WLAN_FC_STYPE_DATA_CFACKPOLL) 1605 C2S(WLAN_FC_STYPE_NULLFUNC) 1606 C2S(WLAN_FC_STYPE_CFACK) 1607 C2S(WLAN_FC_STYPE_CFPOLL) 1608 C2S(WLAN_FC_STYPE_CFACKPOLL) 1609 C2S(WLAN_FC_STYPE_QOS_DATA) 1610 C2S(WLAN_FC_STYPE_QOS_DATA_CFACK) 1611 C2S(WLAN_FC_STYPE_QOS_DATA_CFPOLL) 1612 C2S(WLAN_FC_STYPE_QOS_DATA_CFACKPOLL) 1613 C2S(WLAN_FC_STYPE_QOS_NULL) 1614 C2S(WLAN_FC_STYPE_QOS_CFPOLL) 1615 C2S(WLAN_FC_STYPE_QOS_CFACKPOLL) 1616 } 1617 break; 1618 } 1619 return "WLAN_FC_TYPE_UNKNOWN"; 1620 #undef C2S 1621 } 1622 1623 1624 const char * reason2str(u16 reason) 1625 { 1626 #define R2S(r) case WLAN_REASON_ ## r: return #r; 1627 switch (reason) { 1628 R2S(UNSPECIFIED) 1629 R2S(PREV_AUTH_NOT_VALID) 1630 R2S(DEAUTH_LEAVING) 1631 R2S(DISASSOC_DUE_TO_INACTIVITY) 1632 R2S(DISASSOC_AP_BUSY) 1633 R2S(CLASS2_FRAME_FROM_NONAUTH_STA) 1634 R2S(CLASS3_FRAME_FROM_NONASSOC_STA) 1635 R2S(DISASSOC_STA_HAS_LEFT) 1636 R2S(STA_REQ_ASSOC_WITHOUT_AUTH) 1637 R2S(PWR_CAPABILITY_NOT_VALID) 1638 R2S(SUPPORTED_CHANNEL_NOT_VALID) 1639 R2S(BSS_TRANSITION_DISASSOC) 1640 R2S(INVALID_IE) 1641 R2S(MICHAEL_MIC_FAILURE) 1642 R2S(4WAY_HANDSHAKE_TIMEOUT) 1643 R2S(GROUP_KEY_UPDATE_TIMEOUT) 1644 R2S(IE_IN_4WAY_DIFFERS) 1645 R2S(GROUP_CIPHER_NOT_VALID) 1646 R2S(PAIRWISE_CIPHER_NOT_VALID) 1647 R2S(AKMP_NOT_VALID) 1648 R2S(UNSUPPORTED_RSN_IE_VERSION) 1649 R2S(INVALID_RSN_IE_CAPAB) 1650 R2S(IEEE_802_1X_AUTH_FAILED) 1651 R2S(CIPHER_SUITE_REJECTED) 1652 R2S(TDLS_TEARDOWN_UNREACHABLE) 1653 R2S(TDLS_TEARDOWN_UNSPECIFIED) 1654 R2S(SSP_REQUESTED_DISASSOC) 1655 R2S(NO_SSP_ROAMING_AGREEMENT) 1656 R2S(BAD_CIPHER_OR_AKM) 1657 R2S(NOT_AUTHORIZED_THIS_LOCATION) 1658 R2S(SERVICE_CHANGE_PRECLUDES_TS) 1659 R2S(UNSPECIFIED_QOS_REASON) 1660 R2S(NOT_ENOUGH_BANDWIDTH) 1661 R2S(DISASSOC_LOW_ACK) 1662 R2S(EXCEEDED_TXOP) 1663 R2S(STA_LEAVING) 1664 R2S(END_TS_BA_DLS) 1665 R2S(UNKNOWN_TS_BA) 1666 R2S(TIMEOUT) 1667 R2S(PEERKEY_MISMATCH) 1668 R2S(AUTHORIZED_ACCESS_LIMIT_REACHED) 1669 R2S(EXTERNAL_SERVICE_REQUIREMENTS) 1670 R2S(INVALID_FT_ACTION_FRAME_COUNT) 1671 R2S(INVALID_PMKID) 1672 R2S(INVALID_MDE) 1673 R2S(INVALID_FTE) 1674 R2S(MESH_PEERING_CANCELLED) 1675 R2S(MESH_MAX_PEERS) 1676 R2S(MESH_CONFIG_POLICY_VIOLATION) 1677 R2S(MESH_CLOSE_RCVD) 1678 R2S(MESH_MAX_RETRIES) 1679 R2S(MESH_CONFIRM_TIMEOUT) 1680 R2S(MESH_INVALID_GTK) 1681 R2S(MESH_INCONSISTENT_PARAMS) 1682 R2S(MESH_INVALID_SECURITY_CAP) 1683 R2S(MESH_PATH_ERROR_NO_PROXY_INFO) 1684 R2S(MESH_PATH_ERROR_NO_FORWARDING_INFO) 1685 R2S(MESH_PATH_ERROR_DEST_UNREACHABLE) 1686 R2S(MAC_ADDRESS_ALREADY_EXISTS_IN_MBSS) 1687 R2S(MESH_CHANNEL_SWITCH_REGULATORY_REQ) 1688 R2S(MESH_CHANNEL_SWITCH_UNSPECIFIED) 1689 } 1690 return "UNKNOWN"; 1691 #undef R2S 1692 } 1693 1694 1695 const char * status2str(u16 status) 1696 { 1697 #define S2S(s) case WLAN_STATUS_ ## s: return #s; 1698 switch (status) { 1699 S2S(SUCCESS) 1700 S2S(UNSPECIFIED_FAILURE) 1701 S2S(TDLS_WAKEUP_ALTERNATE) 1702 S2S(TDLS_WAKEUP_REJECT) 1703 S2S(SECURITY_DISABLED) 1704 S2S(UNACCEPTABLE_LIFETIME) 1705 S2S(NOT_IN_SAME_BSS) 1706 S2S(CAPS_UNSUPPORTED) 1707 S2S(REASSOC_NO_ASSOC) 1708 S2S(ASSOC_DENIED_UNSPEC) 1709 S2S(NOT_SUPPORTED_AUTH_ALG) 1710 S2S(UNKNOWN_AUTH_TRANSACTION) 1711 S2S(CHALLENGE_FAIL) 1712 S2S(AUTH_TIMEOUT) 1713 S2S(AP_UNABLE_TO_HANDLE_NEW_STA) 1714 S2S(ASSOC_DENIED_RATES) 1715 S2S(ASSOC_DENIED_NOSHORT) 1716 S2S(SPEC_MGMT_REQUIRED) 1717 S2S(PWR_CAPABILITY_NOT_VALID) 1718 S2S(SUPPORTED_CHANNEL_NOT_VALID) 1719 S2S(ASSOC_DENIED_NO_SHORT_SLOT_TIME) 1720 S2S(ASSOC_DENIED_NO_HT) 1721 S2S(R0KH_UNREACHABLE) 1722 S2S(ASSOC_DENIED_NO_PCO) 1723 S2S(ASSOC_REJECTED_TEMPORARILY) 1724 S2S(ROBUST_MGMT_FRAME_POLICY_VIOLATION) 1725 S2S(UNSPECIFIED_QOS_FAILURE) 1726 S2S(DENIED_INSUFFICIENT_BANDWIDTH) 1727 S2S(DENIED_POOR_CHANNEL_CONDITIONS) 1728 S2S(DENIED_QOS_NOT_SUPPORTED) 1729 S2S(REQUEST_DECLINED) 1730 S2S(INVALID_PARAMETERS) 1731 S2S(REJECTED_WITH_SUGGESTED_CHANGES) 1732 S2S(INVALID_IE) 1733 S2S(GROUP_CIPHER_NOT_VALID) 1734 S2S(PAIRWISE_CIPHER_NOT_VALID) 1735 S2S(AKMP_NOT_VALID) 1736 S2S(UNSUPPORTED_RSN_IE_VERSION) 1737 S2S(INVALID_RSN_IE_CAPAB) 1738 S2S(CIPHER_REJECTED_PER_POLICY) 1739 S2S(TS_NOT_CREATED) 1740 S2S(DIRECT_LINK_NOT_ALLOWED) 1741 S2S(DEST_STA_NOT_PRESENT) 1742 S2S(DEST_STA_NOT_QOS_STA) 1743 S2S(ASSOC_DENIED_LISTEN_INT_TOO_LARGE) 1744 S2S(INVALID_FT_ACTION_FRAME_COUNT) 1745 S2S(INVALID_PMKID) 1746 S2S(INVALID_MDIE) 1747 S2S(INVALID_FTIE) 1748 S2S(REQUESTED_TCLAS_NOT_SUPPORTED) 1749 S2S(INSUFFICIENT_TCLAS_PROCESSING_RESOURCES) 1750 S2S(TRY_ANOTHER_BSS) 1751 S2S(GAS_ADV_PROTO_NOT_SUPPORTED) 1752 S2S(NO_OUTSTANDING_GAS_REQ) 1753 S2S(GAS_RESP_NOT_RECEIVED) 1754 S2S(STA_TIMED_OUT_WAITING_FOR_GAS_RESP) 1755 S2S(GAS_RESP_LARGER_THAN_LIMIT) 1756 S2S(REQ_REFUSED_HOME) 1757 S2S(ADV_SRV_UNREACHABLE) 1758 S2S(REQ_REFUSED_SSPN) 1759 S2S(REQ_REFUSED_UNAUTH_ACCESS) 1760 S2S(INVALID_RSNIE) 1761 S2S(U_APSD_COEX_NOT_SUPPORTED) 1762 S2S(U_APSD_COEX_MODE_NOT_SUPPORTED) 1763 S2S(BAD_INTERVAL_WITH_U_APSD_COEX) 1764 S2S(ANTI_CLOGGING_TOKEN_REQ) 1765 S2S(FINITE_CYCLIC_GROUP_NOT_SUPPORTED) 1766 S2S(CANNOT_FIND_ALT_TBTT) 1767 S2S(TRANSMISSION_FAILURE) 1768 S2S(REQ_TCLAS_NOT_SUPPORTED) 1769 S2S(TCLAS_RESOURCES_EXCHAUSTED) 1770 S2S(REJECTED_WITH_SUGGESTED_BSS_TRANSITION) 1771 S2S(REJECT_WITH_SCHEDULE) 1772 S2S(REJECT_NO_WAKEUP_SPECIFIED) 1773 S2S(SUCCESS_POWER_SAVE_MODE) 1774 S2S(PENDING_ADMITTING_FST_SESSION) 1775 S2S(PERFORMING_FST_NOW) 1776 S2S(PENDING_GAP_IN_BA_WINDOW) 1777 S2S(REJECT_U_PID_SETTING) 1778 S2S(REFUSED_EXTERNAL_REASON) 1779 S2S(REFUSED_AP_OUT_OF_MEMORY) 1780 S2S(REJECTED_EMERGENCY_SERVICE_NOT_SUPPORTED) 1781 S2S(QUERY_RESP_OUTSTANDING) 1782 S2S(REJECT_DSE_BAND) 1783 S2S(TCLAS_PROCESSING_TERMINATED) 1784 S2S(TS_SCHEDULE_CONFLICT) 1785 S2S(DENIED_WITH_SUGGESTED_BAND_AND_CHANNEL) 1786 S2S(MCCAOP_RESERVATION_CONFLICT) 1787 S2S(MAF_LIMIT_EXCEEDED) 1788 S2S(MCCA_TRACK_LIMIT_EXCEEDED) 1789 S2S(DENIED_DUE_TO_SPECTRUM_MANAGEMENT) 1790 S2S(ASSOC_DENIED_NO_VHT) 1791 S2S(ENABLEMENT_DENIED) 1792 S2S(RESTRICTION_FROM_AUTHORIZED_GDB) 1793 S2S(AUTHORIZATION_DEENABLED) 1794 S2S(FILS_AUTHENTICATION_FAILURE) 1795 S2S(UNKNOWN_AUTHENTICATION_SERVER) 1796 S2S(UNKNOWN_PASSWORD_IDENTIFIER) 1797 S2S(DENIED_HE_NOT_SUPPORTED) 1798 S2S(SAE_HASH_TO_ELEMENT) 1799 S2S(SAE_PK) 1800 } 1801 return "UNKNOWN"; 1802 #undef S2S 1803 } 1804 1805 1806 int mb_ies_info_by_ies(struct mb_ies_info *info, const u8 *ies_buf, 1807 size_t ies_len) 1808 { 1809 const struct element *elem; 1810 1811 os_memset(info, 0, sizeof(*info)); 1812 1813 if (!ies_buf) 1814 return 0; 1815 1816 for_each_element_id(elem, WLAN_EID_MULTI_BAND, ies_buf, ies_len) { 1817 if (info->nof_ies >= MAX_NOF_MB_IES_SUPPORTED) 1818 return 0; 1819 1820 wpa_printf(MSG_DEBUG, "MB IE of %u bytes found", 1821 elem->datalen + 2); 1822 info->ies[info->nof_ies].ie = elem->data; 1823 info->ies[info->nof_ies].ie_len = elem->datalen; 1824 info->nof_ies++; 1825 } 1826 1827 if (!for_each_element_completed(elem, ies_buf, ies_len)) { 1828 wpa_hexdump(MSG_DEBUG, "Truncated IEs", ies_buf, ies_len); 1829 return -1; 1830 } 1831 1832 return 0; 1833 } 1834 1835 1836 struct wpabuf * mb_ies_by_info(struct mb_ies_info *info) 1837 { 1838 struct wpabuf *mb_ies = NULL; 1839 1840 WPA_ASSERT(info != NULL); 1841 1842 if (info->nof_ies) { 1843 u8 i; 1844 size_t mb_ies_size = 0; 1845 1846 for (i = 0; i < info->nof_ies; i++) 1847 mb_ies_size += 2 + info->ies[i].ie_len; 1848 1849 mb_ies = wpabuf_alloc(mb_ies_size); 1850 if (mb_ies) { 1851 for (i = 0; i < info->nof_ies; i++) { 1852 wpabuf_put_u8(mb_ies, WLAN_EID_MULTI_BAND); 1853 wpabuf_put_u8(mb_ies, info->ies[i].ie_len); 1854 wpabuf_put_data(mb_ies, 1855 info->ies[i].ie, 1856 info->ies[i].ie_len); 1857 } 1858 } 1859 } 1860 1861 return mb_ies; 1862 } 1863 1864 1865 const struct oper_class_map global_op_class[] = { 1866 { HOSTAPD_MODE_IEEE80211G, 81, 1, 13, 1, BW20, P2P_SUPP }, 1867 { HOSTAPD_MODE_IEEE80211G, 82, 14, 14, 1, BW20, NO_P2P_SUPP }, 1868 1869 /* Do not enable HT40 on 2.4 GHz for P2P use for now */ 1870 { HOSTAPD_MODE_IEEE80211G, 83, 1, 9, 1, BW40PLUS, NO_P2P_SUPP }, 1871 { HOSTAPD_MODE_IEEE80211G, 84, 5, 13, 1, BW40MINUS, NO_P2P_SUPP }, 1872 1873 { HOSTAPD_MODE_IEEE80211A, 115, 36, 48, 4, BW20, P2P_SUPP }, 1874 { HOSTAPD_MODE_IEEE80211A, 116, 36, 44, 8, BW40PLUS, P2P_SUPP }, 1875 { HOSTAPD_MODE_IEEE80211A, 117, 40, 48, 8, BW40MINUS, P2P_SUPP }, 1876 { HOSTAPD_MODE_IEEE80211A, 118, 52, 64, 4, BW20, NO_P2P_SUPP }, 1877 { HOSTAPD_MODE_IEEE80211A, 119, 52, 60, 8, BW40PLUS, NO_P2P_SUPP }, 1878 { HOSTAPD_MODE_IEEE80211A, 120, 56, 64, 8, BW40MINUS, NO_P2P_SUPP }, 1879 { HOSTAPD_MODE_IEEE80211A, 121, 100, 140, 4, BW20, NO_P2P_SUPP }, 1880 { HOSTAPD_MODE_IEEE80211A, 122, 100, 132, 8, BW40PLUS, NO_P2P_SUPP }, 1881 { HOSTAPD_MODE_IEEE80211A, 123, 104, 136, 8, BW40MINUS, NO_P2P_SUPP }, 1882 { HOSTAPD_MODE_IEEE80211A, 124, 149, 161, 4, BW20, P2P_SUPP }, 1883 { HOSTAPD_MODE_IEEE80211A, 125, 149, 177, 4, BW20, P2P_SUPP }, 1884 { HOSTAPD_MODE_IEEE80211A, 126, 149, 173, 8, BW40PLUS, P2P_SUPP }, 1885 { HOSTAPD_MODE_IEEE80211A, 127, 153, 177, 8, BW40MINUS, P2P_SUPP }, 1886 1887 /* 1888 * IEEE P802.11ax/D8.0 Table E-4 actually talks about channel center 1889 * frequency index 42, 58, 106, 122, 138, 155, 171 with channel spacing 1890 * of 80 MHz, but currently use the following definition for simplicity 1891 * (these center frequencies are not actual channels, which makes 1892 * wpas_p2p_verify_channel() fail). wpas_p2p_verify_80mhz() should take 1893 * care of removing invalid channels. 1894 */ 1895 { HOSTAPD_MODE_IEEE80211A, 128, 36, 177, 4, BW80, P2P_SUPP }, 1896 { HOSTAPD_MODE_IEEE80211A, 129, 36, 177, 4, BW160, P2P_SUPP }, 1897 { HOSTAPD_MODE_IEEE80211A, 131, 1, 233, 4, BW20, P2P_SUPP }, 1898 { HOSTAPD_MODE_IEEE80211A, 132, 1, 233, 8, BW40, NO_P2P_SUPP }, 1899 { HOSTAPD_MODE_IEEE80211A, 133, 1, 233, 16, BW80, NO_P2P_SUPP }, 1900 { HOSTAPD_MODE_IEEE80211A, 134, 1, 233, 32, BW160, NO_P2P_SUPP }, 1901 { HOSTAPD_MODE_IEEE80211A, 135, 1, 233, 16, BW80P80, NO_P2P_SUPP }, 1902 { HOSTAPD_MODE_IEEE80211A, 136, 2, 2, 4, BW20, NO_P2P_SUPP }, 1903 1904 /* 1905 * IEEE Std 802.11ad-2012 and P802.ay/D5.0 60 GHz operating classes. 1906 * Class 180 has the legacy channels 1-6. Classes 181-183 include 1907 * channels which implement channel bonding features. 1908 */ 1909 { HOSTAPD_MODE_IEEE80211AD, 180, 1, 6, 1, BW2160, P2P_SUPP }, 1910 { HOSTAPD_MODE_IEEE80211AD, 181, 9, 13, 1, BW4320, P2P_SUPP }, 1911 { HOSTAPD_MODE_IEEE80211AD, 182, 17, 20, 1, BW6480, P2P_SUPP }, 1912 { HOSTAPD_MODE_IEEE80211AD, 183, 25, 27, 1, BW8640, P2P_SUPP }, 1913 1914 /* Keep the operating class 130 as the last entry as a workaround for 1915 * the OneHundredAndThirty Delimiter value used in the Supported 1916 * Operating Classes element to indicate the end of the Operating 1917 * Classes field. */ 1918 { HOSTAPD_MODE_IEEE80211A, 130, 36, 177, 4, BW80P80, P2P_SUPP }, 1919 { -1, 0, 0, 0, 0, BW20, NO_P2P_SUPP } 1920 }; 1921 1922 1923 static enum phy_type ieee80211_phy_type_by_freq(int freq) 1924 { 1925 enum hostapd_hw_mode hw_mode; 1926 u8 channel; 1927 1928 hw_mode = ieee80211_freq_to_chan(freq, &channel); 1929 1930 switch (hw_mode) { 1931 case HOSTAPD_MODE_IEEE80211A: 1932 return PHY_TYPE_OFDM; 1933 case HOSTAPD_MODE_IEEE80211B: 1934 return PHY_TYPE_HRDSSS; 1935 case HOSTAPD_MODE_IEEE80211G: 1936 return PHY_TYPE_ERP; 1937 case HOSTAPD_MODE_IEEE80211AD: 1938 return PHY_TYPE_DMG; 1939 default: 1940 return PHY_TYPE_UNSPECIFIED; 1941 }; 1942 } 1943 1944 1945 /* ieee80211_get_phy_type - Derive the phy type by freq and bandwidth */ 1946 enum phy_type ieee80211_get_phy_type(int freq, int ht, int vht) 1947 { 1948 if (vht) 1949 return PHY_TYPE_VHT; 1950 if (ht) 1951 return PHY_TYPE_HT; 1952 1953 return ieee80211_phy_type_by_freq(freq); 1954 } 1955 1956 1957 size_t global_op_class_size = ARRAY_SIZE(global_op_class); 1958 1959 1960 /** 1961 * get_ie - Fetch a specified information element from IEs buffer 1962 * @ies: Information elements buffer 1963 * @len: Information elements buffer length 1964 * @eid: Information element identifier (WLAN_EID_*) 1965 * Returns: Pointer to the information element (id field) or %NULL if not found 1966 * 1967 * This function returns the first matching information element in the IEs 1968 * buffer or %NULL in case the element is not found. 1969 */ 1970 const u8 * get_ie(const u8 *ies, size_t len, u8 eid) 1971 { 1972 const struct element *elem; 1973 1974 if (!ies) 1975 return NULL; 1976 1977 for_each_element_id(elem, eid, ies, len) 1978 return &elem->id; 1979 1980 return NULL; 1981 } 1982 1983 1984 /** 1985 * get_ie_ext - Fetch a specified extended information element from IEs buffer 1986 * @ies: Information elements buffer 1987 * @len: Information elements buffer length 1988 * @ext: Information element extension identifier (WLAN_EID_EXT_*) 1989 * Returns: Pointer to the information element (id field) or %NULL if not found 1990 * 1991 * This function returns the first matching information element in the IEs 1992 * buffer or %NULL in case the element is not found. 1993 */ 1994 const u8 * get_ie_ext(const u8 *ies, size_t len, u8 ext) 1995 { 1996 const struct element *elem; 1997 1998 if (!ies) 1999 return NULL; 2000 2001 for_each_element_extid(elem, ext, ies, len) 2002 return &elem->id; 2003 2004 return NULL; 2005 } 2006 2007 2008 const u8 * get_vendor_ie(const u8 *ies, size_t len, u32 vendor_type) 2009 { 2010 const struct element *elem; 2011 2012 for_each_element_id(elem, WLAN_EID_VENDOR_SPECIFIC, ies, len) { 2013 if (elem->datalen >= 4 && 2014 vendor_type == WPA_GET_BE32(elem->data)) 2015 return &elem->id; 2016 } 2017 2018 return NULL; 2019 } 2020 2021 2022 size_t mbo_add_ie(u8 *buf, size_t len, const u8 *attr, size_t attr_len) 2023 { 2024 /* 2025 * MBO IE requires 6 bytes without the attributes: EID (1), length (1), 2026 * OUI (3), OUI type (1). 2027 */ 2028 if (len < 6 + attr_len) { 2029 wpa_printf(MSG_DEBUG, 2030 "MBO: Not enough room in buffer for MBO IE: buf len = %zu, attr_len = %zu", 2031 len, attr_len); 2032 return 0; 2033 } 2034 2035 *buf++ = WLAN_EID_VENDOR_SPECIFIC; 2036 *buf++ = attr_len + 4; 2037 WPA_PUT_BE24(buf, OUI_WFA); 2038 buf += 3; 2039 *buf++ = MBO_OUI_TYPE; 2040 os_memcpy(buf, attr, attr_len); 2041 2042 return 6 + attr_len; 2043 } 2044 2045 2046 size_t add_multi_ap_ie(u8 *buf, size_t len, u8 value) 2047 { 2048 u8 *pos = buf; 2049 2050 if (len < 9) 2051 return 0; 2052 2053 *pos++ = WLAN_EID_VENDOR_SPECIFIC; 2054 *pos++ = 7; /* len */ 2055 WPA_PUT_BE24(pos, OUI_WFA); 2056 pos += 3; 2057 *pos++ = MULTI_AP_OUI_TYPE; 2058 *pos++ = MULTI_AP_SUB_ELEM_TYPE; 2059 *pos++ = 1; /* len */ 2060 *pos++ = value; 2061 2062 return pos - buf; 2063 } 2064 2065 2066 static const struct country_op_class us_op_class[] = { 2067 { 1, 115 }, 2068 { 2, 118 }, 2069 { 3, 124 }, 2070 { 4, 121 }, 2071 { 5, 125 }, 2072 { 12, 81 }, 2073 { 22, 116 }, 2074 { 23, 119 }, 2075 { 24, 122 }, 2076 { 25, 126 }, 2077 { 26, 126 }, 2078 { 27, 117 }, 2079 { 28, 120 }, 2080 { 29, 123 }, 2081 { 30, 127 }, 2082 { 31, 127 }, 2083 { 32, 83 }, 2084 { 33, 84 }, 2085 { 34, 180 }, 2086 }; 2087 2088 static const struct country_op_class eu_op_class[] = { 2089 { 1, 115 }, 2090 { 2, 118 }, 2091 { 3, 121 }, 2092 { 4, 81 }, 2093 { 5, 116 }, 2094 { 6, 119 }, 2095 { 7, 122 }, 2096 { 8, 117 }, 2097 { 9, 120 }, 2098 { 10, 123 }, 2099 { 11, 83 }, 2100 { 12, 84 }, 2101 { 17, 125 }, 2102 { 18, 180 }, 2103 }; 2104 2105 static const struct country_op_class jp_op_class[] = { 2106 { 1, 115 }, 2107 { 30, 81 }, 2108 { 31, 82 }, 2109 { 32, 118 }, 2110 { 33, 118 }, 2111 { 34, 121 }, 2112 { 35, 121 }, 2113 { 36, 116 }, 2114 { 37, 119 }, 2115 { 38, 119 }, 2116 { 39, 122 }, 2117 { 40, 122 }, 2118 { 41, 117 }, 2119 { 42, 120 }, 2120 { 43, 120 }, 2121 { 44, 123 }, 2122 { 45, 123 }, 2123 { 56, 83 }, 2124 { 57, 84 }, 2125 { 58, 121 }, 2126 { 59, 180 }, 2127 }; 2128 2129 static const struct country_op_class cn_op_class[] = { 2130 { 1, 115 }, 2131 { 2, 118 }, 2132 { 3, 125 }, 2133 { 4, 116 }, 2134 { 5, 119 }, 2135 { 6, 126 }, 2136 { 7, 81 }, 2137 { 8, 83 }, 2138 { 9, 84 }, 2139 }; 2140 2141 static u8 2142 global_op_class_from_country_array(u8 op_class, size_t array_size, 2143 const struct country_op_class *country_array) 2144 { 2145 size_t i; 2146 2147 for (i = 0; i < array_size; i++) { 2148 if (country_array[i].country_op_class == op_class) 2149 return country_array[i].global_op_class; 2150 } 2151 2152 return 0; 2153 } 2154 2155 2156 u8 country_to_global_op_class(const char *country, u8 op_class) 2157 { 2158 const struct country_op_class *country_array; 2159 size_t size; 2160 u8 g_op_class; 2161 2162 if (country_match(us_op_class_cc, country)) { 2163 country_array = us_op_class; 2164 size = ARRAY_SIZE(us_op_class); 2165 } else if (country_match(eu_op_class_cc, country)) { 2166 country_array = eu_op_class; 2167 size = ARRAY_SIZE(eu_op_class); 2168 } else if (country_match(jp_op_class_cc, country)) { 2169 country_array = jp_op_class; 2170 size = ARRAY_SIZE(jp_op_class); 2171 } else if (country_match(cn_op_class_cc, country)) { 2172 country_array = cn_op_class; 2173 size = ARRAY_SIZE(cn_op_class); 2174 } else { 2175 /* 2176 * Countries that do not match any of the above countries use 2177 * global operating classes 2178 */ 2179 return op_class; 2180 } 2181 2182 g_op_class = global_op_class_from_country_array(op_class, size, 2183 country_array); 2184 2185 /* 2186 * If the given operating class did not match any of the country's 2187 * operating classes, assume that global operating class is used. 2188 */ 2189 return g_op_class ? g_op_class : op_class; 2190 } 2191 2192 2193 const struct oper_class_map * get_oper_class(const char *country, u8 op_class) 2194 { 2195 const struct oper_class_map *op; 2196 2197 if (country) 2198 op_class = country_to_global_op_class(country, op_class); 2199 2200 op = &global_op_class[0]; 2201 while (op->op_class && op->op_class != op_class) 2202 op++; 2203 2204 if (!op->op_class) 2205 return NULL; 2206 2207 return op; 2208 } 2209 2210 2211 int oper_class_bw_to_int(const struct oper_class_map *map) 2212 { 2213 switch (map->bw) { 2214 case BW20: 2215 return 20; 2216 case BW40: 2217 case BW40PLUS: 2218 case BW40MINUS: 2219 return 40; 2220 case BW80: 2221 return 80; 2222 case BW80P80: 2223 case BW160: 2224 return 160; 2225 case BW2160: 2226 return 2160; 2227 default: 2228 return 0; 2229 } 2230 } 2231 2232 2233 int center_idx_to_bw_6ghz(u8 idx) 2234 { 2235 /* Channel: 2 */ 2236 if (idx == 2) 2237 return 0; /* 20 MHz */ 2238 /* channels: 1, 5, 9, 13... */ 2239 if ((idx & 0x3) == 0x1) 2240 return 0; /* 20 MHz */ 2241 /* channels 3, 11, 19... */ 2242 if ((idx & 0x7) == 0x3) 2243 return 1; /* 40 MHz */ 2244 /* channels 7, 23, 39.. */ 2245 if ((idx & 0xf) == 0x7) 2246 return 2; /* 80 MHz */ 2247 /* channels 15, 47, 79...*/ 2248 if ((idx & 0x1f) == 0xf) 2249 return 3; /* 160 MHz */ 2250 2251 return -1; 2252 } 2253 2254 2255 bool is_6ghz_freq(int freq) 2256 { 2257 if (freq < 5935 || freq > 7115) 2258 return false; 2259 2260 if (freq == 5935) 2261 return true; 2262 2263 if (center_idx_to_bw_6ghz((freq - 5950) / 5) < 0) 2264 return false; 2265 2266 return true; 2267 } 2268 2269 2270 bool is_6ghz_op_class(u8 op_class) 2271 { 2272 return op_class >= 131 && op_class <= 136; 2273 } 2274 2275 2276 bool is_6ghz_psc_frequency(int freq) 2277 { 2278 int i; 2279 2280 if (!is_6ghz_freq(freq) || freq == 5935) 2281 return false; 2282 if ((((freq - 5950) / 5) & 0x3) != 0x1) 2283 return false; 2284 2285 i = (freq - 5950 + 55) % 80; 2286 if (i == 0) 2287 i = (freq - 5950 + 55) / 80; 2288 2289 if (i >= 1 && i <= 15) 2290 return true; 2291 2292 return false; 2293 } 2294 2295 2296 int ieee802_11_parse_candidate_list(const char *pos, u8 *nei_rep, 2297 size_t nei_rep_len) 2298 { 2299 u8 *nei_pos = nei_rep; 2300 const char *end; 2301 2302 /* 2303 * BSS Transition Candidate List Entries - Neighbor Report elements 2304 * neighbor=<BSSID>,<BSSID Information>,<Operating Class>, 2305 * <Channel Number>,<PHY Type>[,<hexdump of Optional Subelements>] 2306 */ 2307 while (pos) { 2308 u8 *nei_start; 2309 long int val; 2310 char *endptr, *tmp; 2311 2312 pos = os_strstr(pos, " neighbor="); 2313 if (!pos) 2314 break; 2315 if (nei_pos + 15 > nei_rep + nei_rep_len) { 2316 wpa_printf(MSG_DEBUG, 2317 "Not enough room for additional neighbor"); 2318 return -1; 2319 } 2320 pos += 10; 2321 2322 nei_start = nei_pos; 2323 *nei_pos++ = WLAN_EID_NEIGHBOR_REPORT; 2324 nei_pos++; /* length to be filled in */ 2325 2326 if (hwaddr_aton(pos, nei_pos)) { 2327 wpa_printf(MSG_DEBUG, "Invalid BSSID"); 2328 return -1; 2329 } 2330 nei_pos += ETH_ALEN; 2331 pos += 17; 2332 if (*pos != ',') { 2333 wpa_printf(MSG_DEBUG, "Missing BSSID Information"); 2334 return -1; 2335 } 2336 pos++; 2337 2338 val = strtol(pos, &endptr, 0); 2339 WPA_PUT_LE32(nei_pos, val); 2340 nei_pos += 4; 2341 if (*endptr != ',') { 2342 wpa_printf(MSG_DEBUG, "Missing Operating Class"); 2343 return -1; 2344 } 2345 pos = endptr + 1; 2346 2347 *nei_pos++ = atoi(pos); /* Operating Class */ 2348 pos = os_strchr(pos, ','); 2349 if (pos == NULL) { 2350 wpa_printf(MSG_DEBUG, "Missing Channel Number"); 2351 return -1; 2352 } 2353 pos++; 2354 2355 *nei_pos++ = atoi(pos); /* Channel Number */ 2356 pos = os_strchr(pos, ','); 2357 if (pos == NULL) { 2358 wpa_printf(MSG_DEBUG, "Missing PHY Type"); 2359 return -1; 2360 } 2361 pos++; 2362 2363 *nei_pos++ = atoi(pos); /* PHY Type */ 2364 end = os_strchr(pos, ' '); 2365 tmp = os_strchr(pos, ','); 2366 if (tmp && (!end || tmp < end)) { 2367 /* Optional Subelements (hexdump) */ 2368 size_t len; 2369 2370 pos = tmp + 1; 2371 end = os_strchr(pos, ' '); 2372 if (end) 2373 len = end - pos; 2374 else 2375 len = os_strlen(pos); 2376 if (nei_pos + len / 2 > nei_rep + nei_rep_len) { 2377 wpa_printf(MSG_DEBUG, 2378 "Not enough room for neighbor subelements"); 2379 return -1; 2380 } 2381 if (len & 0x01 || 2382 hexstr2bin(pos, nei_pos, len / 2) < 0) { 2383 wpa_printf(MSG_DEBUG, 2384 "Invalid neighbor subelement info"); 2385 return -1; 2386 } 2387 nei_pos += len / 2; 2388 pos = end; 2389 } 2390 2391 nei_start[1] = nei_pos - nei_start - 2; 2392 } 2393 2394 return nei_pos - nei_rep; 2395 } 2396 2397 2398 int ieee802_11_ext_capab(const u8 *ie, unsigned int capab) 2399 { 2400 if (!ie || ie[1] <= capab / 8) 2401 return 0; 2402 return !!(ie[2 + capab / 8] & BIT(capab % 8)); 2403 } 2404 2405 2406 bool ieee802_11_rsnx_capab_len(const u8 *rsnxe, size_t rsnxe_len, 2407 unsigned int capab) 2408 { 2409 const u8 *end; 2410 size_t flen, i; 2411 u32 capabs = 0; 2412 2413 if (!rsnxe || rsnxe_len == 0) 2414 return false; 2415 end = rsnxe + rsnxe_len; 2416 flen = (rsnxe[0] & 0x0f) + 1; 2417 if (rsnxe + flen > end) 2418 return false; 2419 if (flen > 4) 2420 flen = 4; 2421 for (i = 0; i < flen; i++) 2422 capabs |= rsnxe[i] << (8 * i); 2423 2424 return capabs & BIT(capab); 2425 } 2426 2427 2428 bool ieee802_11_rsnx_capab(const u8 *rsnxe, unsigned int capab) 2429 { 2430 return ieee802_11_rsnx_capab_len(rsnxe ? rsnxe + 2 : NULL, 2431 rsnxe ? rsnxe[1] : 0, capab); 2432 } 2433 2434 2435 void hostapd_encode_edmg_chan(int edmg_enable, u8 edmg_channel, 2436 int primary_channel, 2437 struct ieee80211_edmg_config *edmg) 2438 { 2439 if (!edmg_enable) { 2440 edmg->channels = 0; 2441 edmg->bw_config = 0; 2442 return; 2443 } 2444 2445 /* Only EDMG CB1 and EDMG CB2 contiguous channels supported for now */ 2446 switch (edmg_channel) { 2447 case EDMG_CHANNEL_9: 2448 edmg->channels = EDMG_CHANNEL_9_SUBCHANNELS; 2449 edmg->bw_config = EDMG_BW_CONFIG_5; 2450 return; 2451 case EDMG_CHANNEL_10: 2452 edmg->channels = EDMG_CHANNEL_10_SUBCHANNELS; 2453 edmg->bw_config = EDMG_BW_CONFIG_5; 2454 return; 2455 case EDMG_CHANNEL_11: 2456 edmg->channels = EDMG_CHANNEL_11_SUBCHANNELS; 2457 edmg->bw_config = EDMG_BW_CONFIG_5; 2458 return; 2459 case EDMG_CHANNEL_12: 2460 edmg->channels = EDMG_CHANNEL_12_SUBCHANNELS; 2461 edmg->bw_config = EDMG_BW_CONFIG_5; 2462 return; 2463 case EDMG_CHANNEL_13: 2464 edmg->channels = EDMG_CHANNEL_13_SUBCHANNELS; 2465 edmg->bw_config = EDMG_BW_CONFIG_5; 2466 return; 2467 default: 2468 if (primary_channel > 0 && primary_channel < 7) { 2469 edmg->channels = BIT(primary_channel - 1); 2470 edmg->bw_config = EDMG_BW_CONFIG_4; 2471 } else { 2472 edmg->channels = 0; 2473 edmg->bw_config = 0; 2474 } 2475 break; 2476 } 2477 } 2478 2479 2480 /* Check if the requested EDMG configuration is a subset of the allowed 2481 * EDMG configuration. */ 2482 int ieee802_edmg_is_allowed(struct ieee80211_edmg_config allowed, 2483 struct ieee80211_edmg_config requested) 2484 { 2485 /* 2486 * The validation check if the requested EDMG configuration 2487 * is a subset of the allowed EDMG configuration: 2488 * 1. Check that the requested channels are part (set) of the allowed 2489 * channels. 2490 * 2. P802.11ay defines the values of bw_config between 4 and 15. 2491 * (bw config % 4) will give us 4 groups inside bw_config definition, 2492 * inside each group we can check the subset just by comparing the 2493 * bw_config value. 2494 * Between this 4 groups, there is no subset relation - as a result of 2495 * the P802.11ay definition. 2496 * bw_config defined by IEEE P802.11ay/D4.0, 9.4.2.251, Table 13. 2497 */ 2498 if (((requested.channels & allowed.channels) != requested.channels) || 2499 ((requested.bw_config % 4) > (allowed.bw_config % 4)) || 2500 requested.bw_config > allowed.bw_config) 2501 return 0; 2502 2503 return 1; 2504 } 2505 2506 2507 int op_class_to_bandwidth(u8 op_class) 2508 { 2509 switch (op_class) { 2510 case 81: 2511 case 82: 2512 return 20; 2513 case 83: /* channels 1..9; 40 MHz */ 2514 case 84: /* channels 5..13; 40 MHz */ 2515 return 40; 2516 case 115: /* channels 36,40,44,48; indoor only */ 2517 return 20; 2518 case 116: /* channels 36,44; 40 MHz; indoor only */ 2519 case 117: /* channels 40,48; 40 MHz; indoor only */ 2520 return 40; 2521 case 118: /* channels 52,56,60,64; dfs */ 2522 return 20; 2523 case 119: /* channels 52,60; 40 MHz; dfs */ 2524 case 120: /* channels 56,64; 40 MHz; dfs */ 2525 return 40; 2526 case 121: /* channels 100-140 */ 2527 return 20; 2528 case 122: /* channels 100-142; 40 MHz */ 2529 case 123: /* channels 104-136; 40 MHz */ 2530 return 40; 2531 case 124: /* channels 149,153,157,161 */ 2532 case 125: /* channels 149,153,157,161,165,169,173,177 */ 2533 return 20; 2534 case 126: /* channels 149,157,161,165,169,173; 40 MHz */ 2535 case 127: /* channels 153..177; 40 MHz */ 2536 return 40; 2537 case 128: /* center freqs 42, 58, 106, 122, 138, 155, 171; 80 MHz */ 2538 return 80; 2539 case 129: /* center freqs 50, 114, 163; 160 MHz */ 2540 return 160; 2541 case 130: /* center freqs 42, 58, 106, 122, 138, 155, 171; 80+80 MHz */ 2542 return 80; 2543 case 131: /* UHB channels, 20 MHz: 1, 5, 9.. */ 2544 return 20; 2545 case 132: /* UHB channels, 40 MHz: 3, 11, 19.. */ 2546 return 40; 2547 case 133: /* UHB channels, 80 MHz: 7, 23, 39.. */ 2548 return 80; 2549 case 134: /* UHB channels, 160 MHz: 15, 47, 79.. */ 2550 case 135: /* UHB channels, 80+80 MHz: 7, 23, 39.. */ 2551 return 160; 2552 case 136: /* UHB channels, 20 MHz: 2 */ 2553 return 20; 2554 case 180: /* 60 GHz band, channels 1..8 */ 2555 return 2160; 2556 case 181: /* 60 GHz band, EDMG CB2, channels 9..15 */ 2557 return 4320; 2558 case 182: /* 60 GHz band, EDMG CB3, channels 17..22 */ 2559 return 6480; 2560 case 183: /* 60 GHz band, EDMG CB4, channel 25..29 */ 2561 return 8640; 2562 } 2563 2564 return 20; 2565 } 2566 2567 2568 int op_class_to_ch_width(u8 op_class) 2569 { 2570 switch (op_class) { 2571 case 81: 2572 case 82: 2573 return CHANWIDTH_USE_HT; 2574 case 83: /* channels 1..9; 40 MHz */ 2575 case 84: /* channels 5..13; 40 MHz */ 2576 return CHANWIDTH_USE_HT; 2577 case 115: /* channels 36,40,44,48; indoor only */ 2578 return CHANWIDTH_USE_HT; 2579 case 116: /* channels 36,44; 40 MHz; indoor only */ 2580 case 117: /* channels 40,48; 40 MHz; indoor only */ 2581 return CHANWIDTH_USE_HT; 2582 case 118: /* channels 52,56,60,64; dfs */ 2583 return CHANWIDTH_USE_HT; 2584 case 119: /* channels 52,60; 40 MHz; dfs */ 2585 case 120: /* channels 56,64; 40 MHz; dfs */ 2586 return CHANWIDTH_USE_HT; 2587 case 121: /* channels 100-140 */ 2588 return CHANWIDTH_USE_HT; 2589 case 122: /* channels 100-142; 40 MHz */ 2590 case 123: /* channels 104-136; 40 MHz */ 2591 return CHANWIDTH_USE_HT; 2592 case 124: /* channels 149,153,157,161 */ 2593 case 125: /* channels 149,153,157,161,165,169,171 */ 2594 return CHANWIDTH_USE_HT; 2595 case 126: /* channels 149,157,165, 173; 40 MHz */ 2596 case 127: /* channels 153,161,169,177; 40 MHz */ 2597 return CHANWIDTH_USE_HT; 2598 case 128: /* center freqs 42, 58, 106, 122, 138, 155, 171; 80 MHz */ 2599 return CHANWIDTH_80MHZ; 2600 case 129: /* center freqs 50, 114, 163; 160 MHz */ 2601 return CHANWIDTH_160MHZ; 2602 case 130: /* center freqs 42, 58, 106, 122, 138, 155, 171; 80+80 MHz */ 2603 return CHANWIDTH_80P80MHZ; 2604 case 131: /* UHB channels, 20 MHz: 1, 5, 9.. */ 2605 return CHANWIDTH_USE_HT; 2606 case 132: /* UHB channels, 40 MHz: 3, 11, 19.. */ 2607 return CHANWIDTH_USE_HT; 2608 case 133: /* UHB channels, 80 MHz: 7, 23, 39.. */ 2609 return CHANWIDTH_80MHZ; 2610 case 134: /* UHB channels, 160 MHz: 15, 47, 79.. */ 2611 return CHANWIDTH_160MHZ; 2612 case 135: /* UHB channels, 80+80 MHz: 7, 23, 39.. */ 2613 return CHANWIDTH_80P80MHZ; 2614 case 136: /* UHB channels, 20 MHz: 2 */ 2615 return CHANWIDTH_USE_HT; 2616 case 180: /* 60 GHz band, channels 1..8 */ 2617 return CHANWIDTH_2160MHZ; 2618 case 181: /* 60 GHz band, EDMG CB2, channels 9..15 */ 2619 return CHANWIDTH_4320MHZ; 2620 case 182: /* 60 GHz band, EDMG CB3, channels 17..22 */ 2621 return CHANWIDTH_6480MHZ; 2622 case 183: /* 60 GHz band, EDMG CB4, channel 25..29 */ 2623 return CHANWIDTH_8640MHZ; 2624 } 2625 return CHANWIDTH_USE_HT; 2626 } 2627 2628 2629 struct wpabuf * ieee802_11_defrag_data(struct ieee802_11_elems *elems, 2630 u8 eid, u8 eid_ext, 2631 const u8 *data, u8 len) 2632 { 2633 struct frag_ies_info *frag_ies = &elems->frag_ies; 2634 struct wpabuf *buf; 2635 unsigned int i; 2636 2637 if (!elems || !data || !len) 2638 return NULL; 2639 2640 buf = wpabuf_alloc_copy(data, len); 2641 if (!buf) 2642 return NULL; 2643 2644 for (i = 0; i < frag_ies->n_frags; i++) { 2645 int ret; 2646 2647 if (frag_ies->frags[i].eid != eid || 2648 frag_ies->frags[i].eid_ext != eid_ext) 2649 continue; 2650 2651 ret = wpabuf_resize(&buf, frag_ies->frags[i].ie_len); 2652 if (ret < 0) { 2653 wpabuf_free(buf); 2654 return NULL; 2655 } 2656 2657 /* Copy only the fragment data (without the EID and length) */ 2658 wpabuf_put_data(buf, frag_ies->frags[i].ie, 2659 frag_ies->frags[i].ie_len); 2660 } 2661 2662 return buf; 2663 } 2664 2665 2666 struct wpabuf * ieee802_11_defrag(struct ieee802_11_elems *elems, 2667 u8 eid, u8 eid_ext) 2668 { 2669 const u8 *data; 2670 u8 len; 2671 2672 /* 2673 * TODO: Defragmentation mechanism can be supported for all IEs. For now 2674 * handle only those that are used (or use ieee802_11_defrag_data()). 2675 */ 2676 switch (eid) { 2677 case WLAN_EID_EXTENSION: 2678 switch (eid_ext) { 2679 case WLAN_EID_EXT_FILS_HLP_CONTAINER: 2680 data = elems->fils_hlp; 2681 len = elems->fils_hlp_len; 2682 break; 2683 case WLAN_EID_EXT_WRAPPED_DATA: 2684 data = elems->wrapped_data; 2685 len = elems->wrapped_data_len; 2686 break; 2687 default: 2688 wpa_printf(MSG_DEBUG, 2689 "Defragmentation not supported. eid_ext=%u", 2690 eid_ext); 2691 return NULL; 2692 } 2693 break; 2694 default: 2695 wpa_printf(MSG_DEBUG, 2696 "Defragmentation not supported. eid=%u", eid); 2697 return NULL; 2698 } 2699 2700 return ieee802_11_defrag_data(elems, eid, eid_ext, data, len); 2701 } 2702