1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Wireless utility functions 4 * 5 * Copyright 2007-2009 Johannes Berg <johannes@sipsolutions.net> 6 * Copyright 2013-2014 Intel Mobile Communications GmbH 7 */ 8 #include <linux/export.h> 9 #include <linux/bitops.h> 10 #include <linux/etherdevice.h> 11 #include <linux/slab.h> 12 #include <net/cfg80211.h> 13 #include <net/ip.h> 14 #include <net/dsfield.h> 15 #include <linux/if_vlan.h> 16 #include <linux/mpls.h> 17 #include <linux/gcd.h> 18 #include "core.h" 19 #include "rdev-ops.h" 20 21 22 struct ieee80211_rate * 23 ieee80211_get_response_rate(struct ieee80211_supported_band *sband, 24 u32 basic_rates, int bitrate) 25 { 26 struct ieee80211_rate *result = &sband->bitrates[0]; 27 int i; 28 29 for (i = 0; i < sband->n_bitrates; i++) { 30 if (!(basic_rates & BIT(i))) 31 continue; 32 if (sband->bitrates[i].bitrate > bitrate) 33 continue; 34 result = &sband->bitrates[i]; 35 } 36 37 return result; 38 } 39 EXPORT_SYMBOL(ieee80211_get_response_rate); 40 41 u32 ieee80211_mandatory_rates(struct ieee80211_supported_band *sband, 42 enum nl80211_bss_scan_width scan_width) 43 { 44 struct ieee80211_rate *bitrates; 45 u32 mandatory_rates = 0; 46 enum ieee80211_rate_flags mandatory_flag; 47 int i; 48 49 if (WARN_ON(!sband)) 50 return 1; 51 52 if (sband->band == NL80211_BAND_2GHZ) { 53 if (scan_width == NL80211_BSS_CHAN_WIDTH_5 || 54 scan_width == NL80211_BSS_CHAN_WIDTH_10) 55 mandatory_flag = IEEE80211_RATE_MANDATORY_G; 56 else 57 mandatory_flag = IEEE80211_RATE_MANDATORY_B; 58 } else { 59 mandatory_flag = IEEE80211_RATE_MANDATORY_A; 60 } 61 62 bitrates = sband->bitrates; 63 for (i = 0; i < sband->n_bitrates; i++) 64 if (bitrates[i].flags & mandatory_flag) 65 mandatory_rates |= BIT(i); 66 return mandatory_rates; 67 } 68 EXPORT_SYMBOL(ieee80211_mandatory_rates); 69 70 int ieee80211_channel_to_frequency(int chan, enum nl80211_band band) 71 { 72 /* see 802.11 17.3.8.3.2 and Annex J 73 * there are overlapping channel numbers in 5GHz and 2GHz bands */ 74 if (chan <= 0) 75 return 0; /* not supported */ 76 switch (band) { 77 case NL80211_BAND_2GHZ: 78 if (chan == 14) 79 return 2484; 80 else if (chan < 14) 81 return 2407 + chan * 5; 82 break; 83 case NL80211_BAND_5GHZ: 84 if (chan >= 182 && chan <= 196) 85 return 4000 + chan * 5; 86 else 87 return 5000 + chan * 5; 88 break; 89 case NL80211_BAND_60GHZ: 90 if (chan < 5) 91 return 56160 + chan * 2160; 92 break; 93 default: 94 ; 95 } 96 return 0; /* not supported */ 97 } 98 EXPORT_SYMBOL(ieee80211_channel_to_frequency); 99 100 int ieee80211_frequency_to_channel(int freq) 101 { 102 /* see 802.11 17.3.8.3.2 and Annex J */ 103 if (freq == 2484) 104 return 14; 105 else if (freq < 2484) 106 return (freq - 2407) / 5; 107 else if (freq >= 4910 && freq <= 4980) 108 return (freq - 4000) / 5; 109 else if (freq <= 45000) /* DMG band lower limit */ 110 return (freq - 5000) / 5; 111 else if (freq >= 58320 && freq <= 64800) 112 return (freq - 56160) / 2160; 113 else 114 return 0; 115 } 116 EXPORT_SYMBOL(ieee80211_frequency_to_channel); 117 118 struct ieee80211_channel *ieee80211_get_channel(struct wiphy *wiphy, int freq) 119 { 120 enum nl80211_band band; 121 struct ieee80211_supported_band *sband; 122 int i; 123 124 for (band = 0; band < NUM_NL80211_BANDS; band++) { 125 sband = wiphy->bands[band]; 126 127 if (!sband) 128 continue; 129 130 for (i = 0; i < sband->n_channels; i++) { 131 if (sband->channels[i].center_freq == freq) 132 return &sband->channels[i]; 133 } 134 } 135 136 return NULL; 137 } 138 EXPORT_SYMBOL(ieee80211_get_channel); 139 140 static void set_mandatory_flags_band(struct ieee80211_supported_band *sband) 141 { 142 int i, want; 143 144 switch (sband->band) { 145 case NL80211_BAND_5GHZ: 146 want = 3; 147 for (i = 0; i < sband->n_bitrates; i++) { 148 if (sband->bitrates[i].bitrate == 60 || 149 sband->bitrates[i].bitrate == 120 || 150 sband->bitrates[i].bitrate == 240) { 151 sband->bitrates[i].flags |= 152 IEEE80211_RATE_MANDATORY_A; 153 want--; 154 } 155 } 156 WARN_ON(want); 157 break; 158 case NL80211_BAND_2GHZ: 159 want = 7; 160 for (i = 0; i < sband->n_bitrates; i++) { 161 switch (sband->bitrates[i].bitrate) { 162 case 10: 163 case 20: 164 case 55: 165 case 110: 166 sband->bitrates[i].flags |= 167 IEEE80211_RATE_MANDATORY_B | 168 IEEE80211_RATE_MANDATORY_G; 169 want--; 170 break; 171 case 60: 172 case 120: 173 case 240: 174 sband->bitrates[i].flags |= 175 IEEE80211_RATE_MANDATORY_G; 176 want--; 177 /* fall through */ 178 default: 179 sband->bitrates[i].flags |= 180 IEEE80211_RATE_ERP_G; 181 break; 182 } 183 } 184 WARN_ON(want != 0 && want != 3); 185 break; 186 case NL80211_BAND_60GHZ: 187 /* check for mandatory HT MCS 1..4 */ 188 WARN_ON(!sband->ht_cap.ht_supported); 189 WARN_ON((sband->ht_cap.mcs.rx_mask[0] & 0x1e) != 0x1e); 190 break; 191 case NUM_NL80211_BANDS: 192 default: 193 WARN_ON(1); 194 break; 195 } 196 } 197 198 void ieee80211_set_bitrate_flags(struct wiphy *wiphy) 199 { 200 enum nl80211_band band; 201 202 for (band = 0; band < NUM_NL80211_BANDS; band++) 203 if (wiphy->bands[band]) 204 set_mandatory_flags_band(wiphy->bands[band]); 205 } 206 207 bool cfg80211_supported_cipher_suite(struct wiphy *wiphy, u32 cipher) 208 { 209 int i; 210 for (i = 0; i < wiphy->n_cipher_suites; i++) 211 if (cipher == wiphy->cipher_suites[i]) 212 return true; 213 return false; 214 } 215 216 int cfg80211_validate_key_settings(struct cfg80211_registered_device *rdev, 217 struct key_params *params, int key_idx, 218 bool pairwise, const u8 *mac_addr) 219 { 220 if (key_idx < 0 || key_idx > 5) 221 return -EINVAL; 222 223 if (!pairwise && mac_addr && !(rdev->wiphy.flags & WIPHY_FLAG_IBSS_RSN)) 224 return -EINVAL; 225 226 if (pairwise && !mac_addr) 227 return -EINVAL; 228 229 switch (params->cipher) { 230 case WLAN_CIPHER_SUITE_TKIP: 231 case WLAN_CIPHER_SUITE_CCMP: 232 case WLAN_CIPHER_SUITE_CCMP_256: 233 case WLAN_CIPHER_SUITE_GCMP: 234 case WLAN_CIPHER_SUITE_GCMP_256: 235 /* Disallow pairwise keys with non-zero index unless it's WEP 236 * or a vendor specific cipher (because current deployments use 237 * pairwise WEP keys with non-zero indices and for vendor 238 * specific ciphers this should be validated in the driver or 239 * hardware level - but 802.11i clearly specifies to use zero) 240 */ 241 if (pairwise && key_idx) 242 return -EINVAL; 243 break; 244 case WLAN_CIPHER_SUITE_AES_CMAC: 245 case WLAN_CIPHER_SUITE_BIP_CMAC_256: 246 case WLAN_CIPHER_SUITE_BIP_GMAC_128: 247 case WLAN_CIPHER_SUITE_BIP_GMAC_256: 248 /* Disallow BIP (group-only) cipher as pairwise cipher */ 249 if (pairwise) 250 return -EINVAL; 251 if (key_idx < 4) 252 return -EINVAL; 253 break; 254 case WLAN_CIPHER_SUITE_WEP40: 255 case WLAN_CIPHER_SUITE_WEP104: 256 if (key_idx > 3) 257 return -EINVAL; 258 default: 259 break; 260 } 261 262 switch (params->cipher) { 263 case WLAN_CIPHER_SUITE_WEP40: 264 if (params->key_len != WLAN_KEY_LEN_WEP40) 265 return -EINVAL; 266 break; 267 case WLAN_CIPHER_SUITE_TKIP: 268 if (params->key_len != WLAN_KEY_LEN_TKIP) 269 return -EINVAL; 270 break; 271 case WLAN_CIPHER_SUITE_CCMP: 272 if (params->key_len != WLAN_KEY_LEN_CCMP) 273 return -EINVAL; 274 break; 275 case WLAN_CIPHER_SUITE_CCMP_256: 276 if (params->key_len != WLAN_KEY_LEN_CCMP_256) 277 return -EINVAL; 278 break; 279 case WLAN_CIPHER_SUITE_GCMP: 280 if (params->key_len != WLAN_KEY_LEN_GCMP) 281 return -EINVAL; 282 break; 283 case WLAN_CIPHER_SUITE_GCMP_256: 284 if (params->key_len != WLAN_KEY_LEN_GCMP_256) 285 return -EINVAL; 286 break; 287 case WLAN_CIPHER_SUITE_WEP104: 288 if (params->key_len != WLAN_KEY_LEN_WEP104) 289 return -EINVAL; 290 break; 291 case WLAN_CIPHER_SUITE_AES_CMAC: 292 if (params->key_len != WLAN_KEY_LEN_AES_CMAC) 293 return -EINVAL; 294 break; 295 case WLAN_CIPHER_SUITE_BIP_CMAC_256: 296 if (params->key_len != WLAN_KEY_LEN_BIP_CMAC_256) 297 return -EINVAL; 298 break; 299 case WLAN_CIPHER_SUITE_BIP_GMAC_128: 300 if (params->key_len != WLAN_KEY_LEN_BIP_GMAC_128) 301 return -EINVAL; 302 break; 303 case WLAN_CIPHER_SUITE_BIP_GMAC_256: 304 if (params->key_len != WLAN_KEY_LEN_BIP_GMAC_256) 305 return -EINVAL; 306 break; 307 default: 308 /* 309 * We don't know anything about this algorithm, 310 * allow using it -- but the driver must check 311 * all parameters! We still check below whether 312 * or not the driver supports this algorithm, 313 * of course. 314 */ 315 break; 316 } 317 318 if (params->seq) { 319 switch (params->cipher) { 320 case WLAN_CIPHER_SUITE_WEP40: 321 case WLAN_CIPHER_SUITE_WEP104: 322 /* These ciphers do not use key sequence */ 323 return -EINVAL; 324 case WLAN_CIPHER_SUITE_TKIP: 325 case WLAN_CIPHER_SUITE_CCMP: 326 case WLAN_CIPHER_SUITE_CCMP_256: 327 case WLAN_CIPHER_SUITE_GCMP: 328 case WLAN_CIPHER_SUITE_GCMP_256: 329 case WLAN_CIPHER_SUITE_AES_CMAC: 330 case WLAN_CIPHER_SUITE_BIP_CMAC_256: 331 case WLAN_CIPHER_SUITE_BIP_GMAC_128: 332 case WLAN_CIPHER_SUITE_BIP_GMAC_256: 333 if (params->seq_len != 6) 334 return -EINVAL; 335 break; 336 } 337 } 338 339 if (!cfg80211_supported_cipher_suite(&rdev->wiphy, params->cipher)) 340 return -EINVAL; 341 342 return 0; 343 } 344 345 unsigned int __attribute_const__ ieee80211_hdrlen(__le16 fc) 346 { 347 unsigned int hdrlen = 24; 348 349 if (ieee80211_is_data(fc)) { 350 if (ieee80211_has_a4(fc)) 351 hdrlen = 30; 352 if (ieee80211_is_data_qos(fc)) { 353 hdrlen += IEEE80211_QOS_CTL_LEN; 354 if (ieee80211_has_order(fc)) 355 hdrlen += IEEE80211_HT_CTL_LEN; 356 } 357 goto out; 358 } 359 360 if (ieee80211_is_mgmt(fc)) { 361 if (ieee80211_has_order(fc)) 362 hdrlen += IEEE80211_HT_CTL_LEN; 363 goto out; 364 } 365 366 if (ieee80211_is_ctl(fc)) { 367 /* 368 * ACK and CTS are 10 bytes, all others 16. To see how 369 * to get this condition consider 370 * subtype mask: 0b0000000011110000 (0x00F0) 371 * ACK subtype: 0b0000000011010000 (0x00D0) 372 * CTS subtype: 0b0000000011000000 (0x00C0) 373 * bits that matter: ^^^ (0x00E0) 374 * value of those: 0b0000000011000000 (0x00C0) 375 */ 376 if ((fc & cpu_to_le16(0x00E0)) == cpu_to_le16(0x00C0)) 377 hdrlen = 10; 378 else 379 hdrlen = 16; 380 } 381 out: 382 return hdrlen; 383 } 384 EXPORT_SYMBOL(ieee80211_hdrlen); 385 386 unsigned int ieee80211_get_hdrlen_from_skb(const struct sk_buff *skb) 387 { 388 const struct ieee80211_hdr *hdr = 389 (const struct ieee80211_hdr *)skb->data; 390 unsigned int hdrlen; 391 392 if (unlikely(skb->len < 10)) 393 return 0; 394 hdrlen = ieee80211_hdrlen(hdr->frame_control); 395 if (unlikely(hdrlen > skb->len)) 396 return 0; 397 return hdrlen; 398 } 399 EXPORT_SYMBOL(ieee80211_get_hdrlen_from_skb); 400 401 static unsigned int __ieee80211_get_mesh_hdrlen(u8 flags) 402 { 403 int ae = flags & MESH_FLAGS_AE; 404 /* 802.11-2012, 8.2.4.7.3 */ 405 switch (ae) { 406 default: 407 case 0: 408 return 6; 409 case MESH_FLAGS_AE_A4: 410 return 12; 411 case MESH_FLAGS_AE_A5_A6: 412 return 18; 413 } 414 } 415 416 unsigned int ieee80211_get_mesh_hdrlen(struct ieee80211s_hdr *meshhdr) 417 { 418 return __ieee80211_get_mesh_hdrlen(meshhdr->flags); 419 } 420 EXPORT_SYMBOL(ieee80211_get_mesh_hdrlen); 421 422 int ieee80211_data_to_8023_exthdr(struct sk_buff *skb, struct ethhdr *ehdr, 423 const u8 *addr, enum nl80211_iftype iftype, 424 u8 data_offset) 425 { 426 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data; 427 struct { 428 u8 hdr[ETH_ALEN] __aligned(2); 429 __be16 proto; 430 } payload; 431 struct ethhdr tmp; 432 u16 hdrlen; 433 u8 mesh_flags = 0; 434 435 if (unlikely(!ieee80211_is_data_present(hdr->frame_control))) 436 return -1; 437 438 hdrlen = ieee80211_hdrlen(hdr->frame_control) + data_offset; 439 if (skb->len < hdrlen + 8) 440 return -1; 441 442 /* convert IEEE 802.11 header + possible LLC headers into Ethernet 443 * header 444 * IEEE 802.11 address fields: 445 * ToDS FromDS Addr1 Addr2 Addr3 Addr4 446 * 0 0 DA SA BSSID n/a 447 * 0 1 DA BSSID SA n/a 448 * 1 0 BSSID SA DA n/a 449 * 1 1 RA TA DA SA 450 */ 451 memcpy(tmp.h_dest, ieee80211_get_DA(hdr), ETH_ALEN); 452 memcpy(tmp.h_source, ieee80211_get_SA(hdr), ETH_ALEN); 453 454 if (iftype == NL80211_IFTYPE_MESH_POINT) 455 skb_copy_bits(skb, hdrlen, &mesh_flags, 1); 456 457 mesh_flags &= MESH_FLAGS_AE; 458 459 switch (hdr->frame_control & 460 cpu_to_le16(IEEE80211_FCTL_TODS | IEEE80211_FCTL_FROMDS)) { 461 case cpu_to_le16(IEEE80211_FCTL_TODS): 462 if (unlikely(iftype != NL80211_IFTYPE_AP && 463 iftype != NL80211_IFTYPE_AP_VLAN && 464 iftype != NL80211_IFTYPE_P2P_GO)) 465 return -1; 466 break; 467 case cpu_to_le16(IEEE80211_FCTL_TODS | IEEE80211_FCTL_FROMDS): 468 if (unlikely(iftype != NL80211_IFTYPE_WDS && 469 iftype != NL80211_IFTYPE_MESH_POINT && 470 iftype != NL80211_IFTYPE_AP_VLAN && 471 iftype != NL80211_IFTYPE_STATION)) 472 return -1; 473 if (iftype == NL80211_IFTYPE_MESH_POINT) { 474 if (mesh_flags == MESH_FLAGS_AE_A4) 475 return -1; 476 if (mesh_flags == MESH_FLAGS_AE_A5_A6) { 477 skb_copy_bits(skb, hdrlen + 478 offsetof(struct ieee80211s_hdr, eaddr1), 479 tmp.h_dest, 2 * ETH_ALEN); 480 } 481 hdrlen += __ieee80211_get_mesh_hdrlen(mesh_flags); 482 } 483 break; 484 case cpu_to_le16(IEEE80211_FCTL_FROMDS): 485 if ((iftype != NL80211_IFTYPE_STATION && 486 iftype != NL80211_IFTYPE_P2P_CLIENT && 487 iftype != NL80211_IFTYPE_MESH_POINT) || 488 (is_multicast_ether_addr(tmp.h_dest) && 489 ether_addr_equal(tmp.h_source, addr))) 490 return -1; 491 if (iftype == NL80211_IFTYPE_MESH_POINT) { 492 if (mesh_flags == MESH_FLAGS_AE_A5_A6) 493 return -1; 494 if (mesh_flags == MESH_FLAGS_AE_A4) 495 skb_copy_bits(skb, hdrlen + 496 offsetof(struct ieee80211s_hdr, eaddr1), 497 tmp.h_source, ETH_ALEN); 498 hdrlen += __ieee80211_get_mesh_hdrlen(mesh_flags); 499 } 500 break; 501 case cpu_to_le16(0): 502 if (iftype != NL80211_IFTYPE_ADHOC && 503 iftype != NL80211_IFTYPE_STATION && 504 iftype != NL80211_IFTYPE_OCB) 505 return -1; 506 break; 507 } 508 509 skb_copy_bits(skb, hdrlen, &payload, sizeof(payload)); 510 tmp.h_proto = payload.proto; 511 512 if (likely((ether_addr_equal(payload.hdr, rfc1042_header) && 513 tmp.h_proto != htons(ETH_P_AARP) && 514 tmp.h_proto != htons(ETH_P_IPX)) || 515 ether_addr_equal(payload.hdr, bridge_tunnel_header))) 516 /* remove RFC1042 or Bridge-Tunnel encapsulation and 517 * replace EtherType */ 518 hdrlen += ETH_ALEN + 2; 519 else 520 tmp.h_proto = htons(skb->len - hdrlen); 521 522 pskb_pull(skb, hdrlen); 523 524 if (!ehdr) 525 ehdr = skb_push(skb, sizeof(struct ethhdr)); 526 memcpy(ehdr, &tmp, sizeof(tmp)); 527 528 return 0; 529 } 530 EXPORT_SYMBOL(ieee80211_data_to_8023_exthdr); 531 532 static void 533 __frame_add_frag(struct sk_buff *skb, struct page *page, 534 void *ptr, int len, int size) 535 { 536 struct skb_shared_info *sh = skb_shinfo(skb); 537 int page_offset; 538 539 page_ref_inc(page); 540 page_offset = ptr - page_address(page); 541 skb_add_rx_frag(skb, sh->nr_frags, page, page_offset, len, size); 542 } 543 544 static void 545 __ieee80211_amsdu_copy_frag(struct sk_buff *skb, struct sk_buff *frame, 546 int offset, int len) 547 { 548 struct skb_shared_info *sh = skb_shinfo(skb); 549 const skb_frag_t *frag = &sh->frags[0]; 550 struct page *frag_page; 551 void *frag_ptr; 552 int frag_len, frag_size; 553 int head_size = skb->len - skb->data_len; 554 int cur_len; 555 556 frag_page = virt_to_head_page(skb->head); 557 frag_ptr = skb->data; 558 frag_size = head_size; 559 560 while (offset >= frag_size) { 561 offset -= frag_size; 562 frag_page = skb_frag_page(frag); 563 frag_ptr = skb_frag_address(frag); 564 frag_size = skb_frag_size(frag); 565 frag++; 566 } 567 568 frag_ptr += offset; 569 frag_len = frag_size - offset; 570 571 cur_len = min(len, frag_len); 572 573 __frame_add_frag(frame, frag_page, frag_ptr, cur_len, frag_size); 574 len -= cur_len; 575 576 while (len > 0) { 577 frag_len = skb_frag_size(frag); 578 cur_len = min(len, frag_len); 579 __frame_add_frag(frame, skb_frag_page(frag), 580 skb_frag_address(frag), cur_len, frag_len); 581 len -= cur_len; 582 frag++; 583 } 584 } 585 586 static struct sk_buff * 587 __ieee80211_amsdu_copy(struct sk_buff *skb, unsigned int hlen, 588 int offset, int len, bool reuse_frag) 589 { 590 struct sk_buff *frame; 591 int cur_len = len; 592 593 if (skb->len - offset < len) 594 return NULL; 595 596 /* 597 * When reusing framents, copy some data to the head to simplify 598 * ethernet header handling and speed up protocol header processing 599 * in the stack later. 600 */ 601 if (reuse_frag) 602 cur_len = min_t(int, len, 32); 603 604 /* 605 * Allocate and reserve two bytes more for payload 606 * alignment since sizeof(struct ethhdr) is 14. 607 */ 608 frame = dev_alloc_skb(hlen + sizeof(struct ethhdr) + 2 + cur_len); 609 if (!frame) 610 return NULL; 611 612 skb_reserve(frame, hlen + sizeof(struct ethhdr) + 2); 613 skb_copy_bits(skb, offset, skb_put(frame, cur_len), cur_len); 614 615 len -= cur_len; 616 if (!len) 617 return frame; 618 619 offset += cur_len; 620 __ieee80211_amsdu_copy_frag(skb, frame, offset, len); 621 622 return frame; 623 } 624 625 void ieee80211_amsdu_to_8023s(struct sk_buff *skb, struct sk_buff_head *list, 626 const u8 *addr, enum nl80211_iftype iftype, 627 const unsigned int extra_headroom, 628 const u8 *check_da, const u8 *check_sa) 629 { 630 unsigned int hlen = ALIGN(extra_headroom, 4); 631 struct sk_buff *frame = NULL; 632 u16 ethertype; 633 u8 *payload; 634 int offset = 0, remaining; 635 struct ethhdr eth; 636 bool reuse_frag = skb->head_frag && !skb_has_frag_list(skb); 637 bool reuse_skb = false; 638 bool last = false; 639 640 while (!last) { 641 unsigned int subframe_len; 642 int len; 643 u8 padding; 644 645 skb_copy_bits(skb, offset, ð, sizeof(eth)); 646 len = ntohs(eth.h_proto); 647 subframe_len = sizeof(struct ethhdr) + len; 648 padding = (4 - subframe_len) & 0x3; 649 650 /* the last MSDU has no padding */ 651 remaining = skb->len - offset; 652 if (subframe_len > remaining) 653 goto purge; 654 655 offset += sizeof(struct ethhdr); 656 last = remaining <= subframe_len + padding; 657 658 /* FIXME: should we really accept multicast DA? */ 659 if ((check_da && !is_multicast_ether_addr(eth.h_dest) && 660 !ether_addr_equal(check_da, eth.h_dest)) || 661 (check_sa && !ether_addr_equal(check_sa, eth.h_source))) { 662 offset += len + padding; 663 continue; 664 } 665 666 /* reuse skb for the last subframe */ 667 if (!skb_is_nonlinear(skb) && !reuse_frag && last) { 668 skb_pull(skb, offset); 669 frame = skb; 670 reuse_skb = true; 671 } else { 672 frame = __ieee80211_amsdu_copy(skb, hlen, offset, len, 673 reuse_frag); 674 if (!frame) 675 goto purge; 676 677 offset += len + padding; 678 } 679 680 skb_reset_network_header(frame); 681 frame->dev = skb->dev; 682 frame->priority = skb->priority; 683 684 payload = frame->data; 685 ethertype = (payload[6] << 8) | payload[7]; 686 if (likely((ether_addr_equal(payload, rfc1042_header) && 687 ethertype != ETH_P_AARP && ethertype != ETH_P_IPX) || 688 ether_addr_equal(payload, bridge_tunnel_header))) { 689 eth.h_proto = htons(ethertype); 690 skb_pull(frame, ETH_ALEN + 2); 691 } 692 693 memcpy(skb_push(frame, sizeof(eth)), ð, sizeof(eth)); 694 __skb_queue_tail(list, frame); 695 } 696 697 if (!reuse_skb) 698 dev_kfree_skb(skb); 699 700 return; 701 702 purge: 703 __skb_queue_purge(list); 704 dev_kfree_skb(skb); 705 } 706 EXPORT_SYMBOL(ieee80211_amsdu_to_8023s); 707 708 /* Given a data frame determine the 802.1p/1d tag to use. */ 709 unsigned int cfg80211_classify8021d(struct sk_buff *skb, 710 struct cfg80211_qos_map *qos_map) 711 { 712 unsigned int dscp; 713 unsigned char vlan_priority; 714 715 /* skb->priority values from 256->263 are magic values to 716 * directly indicate a specific 802.1d priority. This is used 717 * to allow 802.1d priority to be passed directly in from VLAN 718 * tags, etc. 719 */ 720 if (skb->priority >= 256 && skb->priority <= 263) 721 return skb->priority - 256; 722 723 if (skb_vlan_tag_present(skb)) { 724 vlan_priority = (skb_vlan_tag_get(skb) & VLAN_PRIO_MASK) 725 >> VLAN_PRIO_SHIFT; 726 if (vlan_priority > 0) 727 return vlan_priority; 728 } 729 730 switch (skb->protocol) { 731 case htons(ETH_P_IP): 732 dscp = ipv4_get_dsfield(ip_hdr(skb)) & 0xfc; 733 break; 734 case htons(ETH_P_IPV6): 735 dscp = ipv6_get_dsfield(ipv6_hdr(skb)) & 0xfc; 736 break; 737 case htons(ETH_P_MPLS_UC): 738 case htons(ETH_P_MPLS_MC): { 739 struct mpls_label mpls_tmp, *mpls; 740 741 mpls = skb_header_pointer(skb, sizeof(struct ethhdr), 742 sizeof(*mpls), &mpls_tmp); 743 if (!mpls) 744 return 0; 745 746 return (ntohl(mpls->entry) & MPLS_LS_TC_MASK) 747 >> MPLS_LS_TC_SHIFT; 748 } 749 case htons(ETH_P_80221): 750 /* 802.21 is always network control traffic */ 751 return 7; 752 default: 753 return 0; 754 } 755 756 if (qos_map) { 757 unsigned int i, tmp_dscp = dscp >> 2; 758 759 for (i = 0; i < qos_map->num_des; i++) { 760 if (tmp_dscp == qos_map->dscp_exception[i].dscp) 761 return qos_map->dscp_exception[i].up; 762 } 763 764 for (i = 0; i < 8; i++) { 765 if (tmp_dscp >= qos_map->up[i].low && 766 tmp_dscp <= qos_map->up[i].high) 767 return i; 768 } 769 } 770 771 return dscp >> 5; 772 } 773 EXPORT_SYMBOL(cfg80211_classify8021d); 774 775 const u8 *ieee80211_bss_get_ie(struct cfg80211_bss *bss, u8 ie) 776 { 777 const struct cfg80211_bss_ies *ies; 778 779 ies = rcu_dereference(bss->ies); 780 if (!ies) 781 return NULL; 782 783 return cfg80211_find_ie(ie, ies->data, ies->len); 784 } 785 EXPORT_SYMBOL(ieee80211_bss_get_ie); 786 787 void cfg80211_upload_connect_keys(struct wireless_dev *wdev) 788 { 789 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy); 790 struct net_device *dev = wdev->netdev; 791 int i; 792 793 if (!wdev->connect_keys) 794 return; 795 796 for (i = 0; i < CFG80211_MAX_WEP_KEYS; i++) { 797 if (!wdev->connect_keys->params[i].cipher) 798 continue; 799 if (rdev_add_key(rdev, dev, i, false, NULL, 800 &wdev->connect_keys->params[i])) { 801 netdev_err(dev, "failed to set key %d\n", i); 802 continue; 803 } 804 if (wdev->connect_keys->def == i && 805 rdev_set_default_key(rdev, dev, i, true, true)) { 806 netdev_err(dev, "failed to set defkey %d\n", i); 807 continue; 808 } 809 } 810 811 kzfree(wdev->connect_keys); 812 wdev->connect_keys = NULL; 813 } 814 815 void cfg80211_process_wdev_events(struct wireless_dev *wdev) 816 { 817 struct cfg80211_event *ev; 818 unsigned long flags; 819 820 spin_lock_irqsave(&wdev->event_lock, flags); 821 while (!list_empty(&wdev->event_list)) { 822 ev = list_first_entry(&wdev->event_list, 823 struct cfg80211_event, list); 824 list_del(&ev->list); 825 spin_unlock_irqrestore(&wdev->event_lock, flags); 826 827 wdev_lock(wdev); 828 switch (ev->type) { 829 case EVENT_CONNECT_RESULT: 830 __cfg80211_connect_result( 831 wdev->netdev, 832 &ev->cr, 833 ev->cr.status == WLAN_STATUS_SUCCESS); 834 break; 835 case EVENT_ROAMED: 836 __cfg80211_roamed(wdev, &ev->rm); 837 break; 838 case EVENT_DISCONNECTED: 839 __cfg80211_disconnected(wdev->netdev, 840 ev->dc.ie, ev->dc.ie_len, 841 ev->dc.reason, 842 !ev->dc.locally_generated); 843 break; 844 case EVENT_IBSS_JOINED: 845 __cfg80211_ibss_joined(wdev->netdev, ev->ij.bssid, 846 ev->ij.channel); 847 break; 848 case EVENT_STOPPED: 849 __cfg80211_leave(wiphy_to_rdev(wdev->wiphy), wdev); 850 break; 851 case EVENT_PORT_AUTHORIZED: 852 __cfg80211_port_authorized(wdev, ev->pa.bssid); 853 break; 854 } 855 wdev_unlock(wdev); 856 857 kfree(ev); 858 859 spin_lock_irqsave(&wdev->event_lock, flags); 860 } 861 spin_unlock_irqrestore(&wdev->event_lock, flags); 862 } 863 864 void cfg80211_process_rdev_events(struct cfg80211_registered_device *rdev) 865 { 866 struct wireless_dev *wdev; 867 868 ASSERT_RTNL(); 869 870 list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) 871 cfg80211_process_wdev_events(wdev); 872 } 873 874 int cfg80211_change_iface(struct cfg80211_registered_device *rdev, 875 struct net_device *dev, enum nl80211_iftype ntype, 876 struct vif_params *params) 877 { 878 int err; 879 enum nl80211_iftype otype = dev->ieee80211_ptr->iftype; 880 881 ASSERT_RTNL(); 882 883 /* don't support changing VLANs, you just re-create them */ 884 if (otype == NL80211_IFTYPE_AP_VLAN) 885 return -EOPNOTSUPP; 886 887 /* cannot change into P2P device or NAN */ 888 if (ntype == NL80211_IFTYPE_P2P_DEVICE || 889 ntype == NL80211_IFTYPE_NAN) 890 return -EOPNOTSUPP; 891 892 if (!rdev->ops->change_virtual_intf || 893 !(rdev->wiphy.interface_modes & (1 << ntype))) 894 return -EOPNOTSUPP; 895 896 /* if it's part of a bridge, reject changing type to station/ibss */ 897 if ((dev->priv_flags & IFF_BRIDGE_PORT) && 898 (ntype == NL80211_IFTYPE_ADHOC || 899 ntype == NL80211_IFTYPE_STATION || 900 ntype == NL80211_IFTYPE_P2P_CLIENT)) 901 return -EBUSY; 902 903 if (ntype != otype) { 904 dev->ieee80211_ptr->use_4addr = false; 905 dev->ieee80211_ptr->mesh_id_up_len = 0; 906 wdev_lock(dev->ieee80211_ptr); 907 rdev_set_qos_map(rdev, dev, NULL); 908 wdev_unlock(dev->ieee80211_ptr); 909 910 switch (otype) { 911 case NL80211_IFTYPE_AP: 912 cfg80211_stop_ap(rdev, dev, true); 913 break; 914 case NL80211_IFTYPE_ADHOC: 915 cfg80211_leave_ibss(rdev, dev, false); 916 break; 917 case NL80211_IFTYPE_STATION: 918 case NL80211_IFTYPE_P2P_CLIENT: 919 wdev_lock(dev->ieee80211_ptr); 920 cfg80211_disconnect(rdev, dev, 921 WLAN_REASON_DEAUTH_LEAVING, true); 922 wdev_unlock(dev->ieee80211_ptr); 923 break; 924 case NL80211_IFTYPE_MESH_POINT: 925 /* mesh should be handled? */ 926 break; 927 default: 928 break; 929 } 930 931 cfg80211_process_rdev_events(rdev); 932 } 933 934 err = rdev_change_virtual_intf(rdev, dev, ntype, params); 935 936 WARN_ON(!err && dev->ieee80211_ptr->iftype != ntype); 937 938 if (!err && params && params->use_4addr != -1) 939 dev->ieee80211_ptr->use_4addr = params->use_4addr; 940 941 if (!err) { 942 dev->priv_flags &= ~IFF_DONT_BRIDGE; 943 switch (ntype) { 944 case NL80211_IFTYPE_STATION: 945 if (dev->ieee80211_ptr->use_4addr) 946 break; 947 /* fall through */ 948 case NL80211_IFTYPE_OCB: 949 case NL80211_IFTYPE_P2P_CLIENT: 950 case NL80211_IFTYPE_ADHOC: 951 dev->priv_flags |= IFF_DONT_BRIDGE; 952 break; 953 case NL80211_IFTYPE_P2P_GO: 954 case NL80211_IFTYPE_AP: 955 case NL80211_IFTYPE_AP_VLAN: 956 case NL80211_IFTYPE_WDS: 957 case NL80211_IFTYPE_MESH_POINT: 958 /* bridging OK */ 959 break; 960 case NL80211_IFTYPE_MONITOR: 961 /* monitor can't bridge anyway */ 962 break; 963 case NL80211_IFTYPE_UNSPECIFIED: 964 case NUM_NL80211_IFTYPES: 965 /* not happening */ 966 break; 967 case NL80211_IFTYPE_P2P_DEVICE: 968 case NL80211_IFTYPE_NAN: 969 WARN_ON(1); 970 break; 971 } 972 } 973 974 if (!err && ntype != otype && netif_running(dev)) { 975 cfg80211_update_iface_num(rdev, ntype, 1); 976 cfg80211_update_iface_num(rdev, otype, -1); 977 } 978 979 return err; 980 } 981 982 static u32 cfg80211_calculate_bitrate_ht(struct rate_info *rate) 983 { 984 int modulation, streams, bitrate; 985 986 /* the formula below does only work for MCS values smaller than 32 */ 987 if (WARN_ON_ONCE(rate->mcs >= 32)) 988 return 0; 989 990 modulation = rate->mcs & 7; 991 streams = (rate->mcs >> 3) + 1; 992 993 bitrate = (rate->bw == RATE_INFO_BW_40) ? 13500000 : 6500000; 994 995 if (modulation < 4) 996 bitrate *= (modulation + 1); 997 else if (modulation == 4) 998 bitrate *= (modulation + 2); 999 else 1000 bitrate *= (modulation + 3); 1001 1002 bitrate *= streams; 1003 1004 if (rate->flags & RATE_INFO_FLAGS_SHORT_GI) 1005 bitrate = (bitrate / 9) * 10; 1006 1007 /* do NOT round down here */ 1008 return (bitrate + 50000) / 100000; 1009 } 1010 1011 static u32 cfg80211_calculate_bitrate_60g(struct rate_info *rate) 1012 { 1013 static const u32 __mcs2bitrate[] = { 1014 /* control PHY */ 1015 [0] = 275, 1016 /* SC PHY */ 1017 [1] = 3850, 1018 [2] = 7700, 1019 [3] = 9625, 1020 [4] = 11550, 1021 [5] = 12512, /* 1251.25 mbps */ 1022 [6] = 15400, 1023 [7] = 19250, 1024 [8] = 23100, 1025 [9] = 25025, 1026 [10] = 30800, 1027 [11] = 38500, 1028 [12] = 46200, 1029 /* OFDM PHY */ 1030 [13] = 6930, 1031 [14] = 8662, /* 866.25 mbps */ 1032 [15] = 13860, 1033 [16] = 17325, 1034 [17] = 20790, 1035 [18] = 27720, 1036 [19] = 34650, 1037 [20] = 41580, 1038 [21] = 45045, 1039 [22] = 51975, 1040 [23] = 62370, 1041 [24] = 67568, /* 6756.75 mbps */ 1042 /* LP-SC PHY */ 1043 [25] = 6260, 1044 [26] = 8340, 1045 [27] = 11120, 1046 [28] = 12510, 1047 [29] = 16680, 1048 [30] = 22240, 1049 [31] = 25030, 1050 }; 1051 1052 if (WARN_ON_ONCE(rate->mcs >= ARRAY_SIZE(__mcs2bitrate))) 1053 return 0; 1054 1055 return __mcs2bitrate[rate->mcs]; 1056 } 1057 1058 static u32 cfg80211_calculate_bitrate_vht(struct rate_info *rate) 1059 { 1060 static const u32 base[4][10] = { 1061 { 6500000, 1062 13000000, 1063 19500000, 1064 26000000, 1065 39000000, 1066 52000000, 1067 58500000, 1068 65000000, 1069 78000000, 1070 /* not in the spec, but some devices use this: */ 1071 86500000, 1072 }, 1073 { 13500000, 1074 27000000, 1075 40500000, 1076 54000000, 1077 81000000, 1078 108000000, 1079 121500000, 1080 135000000, 1081 162000000, 1082 180000000, 1083 }, 1084 { 29300000, 1085 58500000, 1086 87800000, 1087 117000000, 1088 175500000, 1089 234000000, 1090 263300000, 1091 292500000, 1092 351000000, 1093 390000000, 1094 }, 1095 { 58500000, 1096 117000000, 1097 175500000, 1098 234000000, 1099 351000000, 1100 468000000, 1101 526500000, 1102 585000000, 1103 702000000, 1104 780000000, 1105 }, 1106 }; 1107 u32 bitrate; 1108 int idx; 1109 1110 if (rate->mcs > 9) 1111 goto warn; 1112 1113 switch (rate->bw) { 1114 case RATE_INFO_BW_160: 1115 idx = 3; 1116 break; 1117 case RATE_INFO_BW_80: 1118 idx = 2; 1119 break; 1120 case RATE_INFO_BW_40: 1121 idx = 1; 1122 break; 1123 case RATE_INFO_BW_5: 1124 case RATE_INFO_BW_10: 1125 default: 1126 goto warn; 1127 case RATE_INFO_BW_20: 1128 idx = 0; 1129 } 1130 1131 bitrate = base[idx][rate->mcs]; 1132 bitrate *= rate->nss; 1133 1134 if (rate->flags & RATE_INFO_FLAGS_SHORT_GI) 1135 bitrate = (bitrate / 9) * 10; 1136 1137 /* do NOT round down here */ 1138 return (bitrate + 50000) / 100000; 1139 warn: 1140 WARN_ONCE(1, "invalid rate bw=%d, mcs=%d, nss=%d\n", 1141 rate->bw, rate->mcs, rate->nss); 1142 return 0; 1143 } 1144 1145 u32 cfg80211_calculate_bitrate(struct rate_info *rate) 1146 { 1147 if (rate->flags & RATE_INFO_FLAGS_MCS) 1148 return cfg80211_calculate_bitrate_ht(rate); 1149 if (rate->flags & RATE_INFO_FLAGS_60G) 1150 return cfg80211_calculate_bitrate_60g(rate); 1151 if (rate->flags & RATE_INFO_FLAGS_VHT_MCS) 1152 return cfg80211_calculate_bitrate_vht(rate); 1153 1154 return rate->legacy; 1155 } 1156 EXPORT_SYMBOL(cfg80211_calculate_bitrate); 1157 1158 int cfg80211_get_p2p_attr(const u8 *ies, unsigned int len, 1159 enum ieee80211_p2p_attr_id attr, 1160 u8 *buf, unsigned int bufsize) 1161 { 1162 u8 *out = buf; 1163 u16 attr_remaining = 0; 1164 bool desired_attr = false; 1165 u16 desired_len = 0; 1166 1167 while (len > 0) { 1168 unsigned int iedatalen; 1169 unsigned int copy; 1170 const u8 *iedata; 1171 1172 if (len < 2) 1173 return -EILSEQ; 1174 iedatalen = ies[1]; 1175 if (iedatalen + 2 > len) 1176 return -EILSEQ; 1177 1178 if (ies[0] != WLAN_EID_VENDOR_SPECIFIC) 1179 goto cont; 1180 1181 if (iedatalen < 4) 1182 goto cont; 1183 1184 iedata = ies + 2; 1185 1186 /* check WFA OUI, P2P subtype */ 1187 if (iedata[0] != 0x50 || iedata[1] != 0x6f || 1188 iedata[2] != 0x9a || iedata[3] != 0x09) 1189 goto cont; 1190 1191 iedatalen -= 4; 1192 iedata += 4; 1193 1194 /* check attribute continuation into this IE */ 1195 copy = min_t(unsigned int, attr_remaining, iedatalen); 1196 if (copy && desired_attr) { 1197 desired_len += copy; 1198 if (out) { 1199 memcpy(out, iedata, min(bufsize, copy)); 1200 out += min(bufsize, copy); 1201 bufsize -= min(bufsize, copy); 1202 } 1203 1204 1205 if (copy == attr_remaining) 1206 return desired_len; 1207 } 1208 1209 attr_remaining -= copy; 1210 if (attr_remaining) 1211 goto cont; 1212 1213 iedatalen -= copy; 1214 iedata += copy; 1215 1216 while (iedatalen > 0) { 1217 u16 attr_len; 1218 1219 /* P2P attribute ID & size must fit */ 1220 if (iedatalen < 3) 1221 return -EILSEQ; 1222 desired_attr = iedata[0] == attr; 1223 attr_len = get_unaligned_le16(iedata + 1); 1224 iedatalen -= 3; 1225 iedata += 3; 1226 1227 copy = min_t(unsigned int, attr_len, iedatalen); 1228 1229 if (desired_attr) { 1230 desired_len += copy; 1231 if (out) { 1232 memcpy(out, iedata, min(bufsize, copy)); 1233 out += min(bufsize, copy); 1234 bufsize -= min(bufsize, copy); 1235 } 1236 1237 if (copy == attr_len) 1238 return desired_len; 1239 } 1240 1241 iedata += copy; 1242 iedatalen -= copy; 1243 attr_remaining = attr_len - copy; 1244 } 1245 1246 cont: 1247 len -= ies[1] + 2; 1248 ies += ies[1] + 2; 1249 } 1250 1251 if (attr_remaining && desired_attr) 1252 return -EILSEQ; 1253 1254 return -ENOENT; 1255 } 1256 EXPORT_SYMBOL(cfg80211_get_p2p_attr); 1257 1258 static bool ieee80211_id_in_list(const u8 *ids, int n_ids, u8 id, bool id_ext) 1259 { 1260 int i; 1261 1262 /* Make sure array values are legal */ 1263 if (WARN_ON(ids[n_ids - 1] == WLAN_EID_EXTENSION)) 1264 return false; 1265 1266 i = 0; 1267 while (i < n_ids) { 1268 if (ids[i] == WLAN_EID_EXTENSION) { 1269 if (id_ext && (ids[i + 1] == id)) 1270 return true; 1271 1272 i += 2; 1273 continue; 1274 } 1275 1276 if (ids[i] == id && !id_ext) 1277 return true; 1278 1279 i++; 1280 } 1281 return false; 1282 } 1283 1284 static size_t skip_ie(const u8 *ies, size_t ielen, size_t pos) 1285 { 1286 /* we assume a validly formed IEs buffer */ 1287 u8 len = ies[pos + 1]; 1288 1289 pos += 2 + len; 1290 1291 /* the IE itself must have 255 bytes for fragments to follow */ 1292 if (len < 255) 1293 return pos; 1294 1295 while (pos < ielen && ies[pos] == WLAN_EID_FRAGMENT) { 1296 len = ies[pos + 1]; 1297 pos += 2 + len; 1298 } 1299 1300 return pos; 1301 } 1302 1303 size_t ieee80211_ie_split_ric(const u8 *ies, size_t ielen, 1304 const u8 *ids, int n_ids, 1305 const u8 *after_ric, int n_after_ric, 1306 size_t offset) 1307 { 1308 size_t pos = offset; 1309 1310 while (pos < ielen) { 1311 u8 ext = 0; 1312 1313 if (ies[pos] == WLAN_EID_EXTENSION) 1314 ext = 2; 1315 if ((pos + ext) >= ielen) 1316 break; 1317 1318 if (!ieee80211_id_in_list(ids, n_ids, ies[pos + ext], 1319 ies[pos] == WLAN_EID_EXTENSION)) 1320 break; 1321 1322 if (ies[pos] == WLAN_EID_RIC_DATA && n_after_ric) { 1323 pos = skip_ie(ies, ielen, pos); 1324 1325 while (pos < ielen) { 1326 if (ies[pos] == WLAN_EID_EXTENSION) 1327 ext = 2; 1328 else 1329 ext = 0; 1330 1331 if ((pos + ext) >= ielen) 1332 break; 1333 1334 if (!ieee80211_id_in_list(after_ric, 1335 n_after_ric, 1336 ies[pos + ext], 1337 ext == 2)) 1338 pos = skip_ie(ies, ielen, pos); 1339 } 1340 } else { 1341 pos = skip_ie(ies, ielen, pos); 1342 } 1343 } 1344 1345 return pos; 1346 } 1347 EXPORT_SYMBOL(ieee80211_ie_split_ric); 1348 1349 bool ieee80211_operating_class_to_band(u8 operating_class, 1350 enum nl80211_band *band) 1351 { 1352 switch (operating_class) { 1353 case 112: 1354 case 115 ... 127: 1355 case 128 ... 130: 1356 *band = NL80211_BAND_5GHZ; 1357 return true; 1358 case 81: 1359 case 82: 1360 case 83: 1361 case 84: 1362 *band = NL80211_BAND_2GHZ; 1363 return true; 1364 case 180: 1365 *band = NL80211_BAND_60GHZ; 1366 return true; 1367 } 1368 1369 return false; 1370 } 1371 EXPORT_SYMBOL(ieee80211_operating_class_to_band); 1372 1373 bool ieee80211_chandef_to_operating_class(struct cfg80211_chan_def *chandef, 1374 u8 *op_class) 1375 { 1376 u8 vht_opclass; 1377 u16 freq = chandef->center_freq1; 1378 1379 if (freq >= 2412 && freq <= 2472) { 1380 if (chandef->width > NL80211_CHAN_WIDTH_40) 1381 return false; 1382 1383 /* 2.407 GHz, channels 1..13 */ 1384 if (chandef->width == NL80211_CHAN_WIDTH_40) { 1385 if (freq > chandef->chan->center_freq) 1386 *op_class = 83; /* HT40+ */ 1387 else 1388 *op_class = 84; /* HT40- */ 1389 } else { 1390 *op_class = 81; 1391 } 1392 1393 return true; 1394 } 1395 1396 if (freq == 2484) { 1397 if (chandef->width > NL80211_CHAN_WIDTH_40) 1398 return false; 1399 1400 *op_class = 82; /* channel 14 */ 1401 return true; 1402 } 1403 1404 switch (chandef->width) { 1405 case NL80211_CHAN_WIDTH_80: 1406 vht_opclass = 128; 1407 break; 1408 case NL80211_CHAN_WIDTH_160: 1409 vht_opclass = 129; 1410 break; 1411 case NL80211_CHAN_WIDTH_80P80: 1412 vht_opclass = 130; 1413 break; 1414 case NL80211_CHAN_WIDTH_10: 1415 case NL80211_CHAN_WIDTH_5: 1416 return false; /* unsupported for now */ 1417 default: 1418 vht_opclass = 0; 1419 break; 1420 } 1421 1422 /* 5 GHz, channels 36..48 */ 1423 if (freq >= 5180 && freq <= 5240) { 1424 if (vht_opclass) { 1425 *op_class = vht_opclass; 1426 } else if (chandef->width == NL80211_CHAN_WIDTH_40) { 1427 if (freq > chandef->chan->center_freq) 1428 *op_class = 116; 1429 else 1430 *op_class = 117; 1431 } else { 1432 *op_class = 115; 1433 } 1434 1435 return true; 1436 } 1437 1438 /* 5 GHz, channels 52..64 */ 1439 if (freq >= 5260 && freq <= 5320) { 1440 if (vht_opclass) { 1441 *op_class = vht_opclass; 1442 } else if (chandef->width == NL80211_CHAN_WIDTH_40) { 1443 if (freq > chandef->chan->center_freq) 1444 *op_class = 119; 1445 else 1446 *op_class = 120; 1447 } else { 1448 *op_class = 118; 1449 } 1450 1451 return true; 1452 } 1453 1454 /* 5 GHz, channels 100..144 */ 1455 if (freq >= 5500 && freq <= 5720) { 1456 if (vht_opclass) { 1457 *op_class = vht_opclass; 1458 } else if (chandef->width == NL80211_CHAN_WIDTH_40) { 1459 if (freq > chandef->chan->center_freq) 1460 *op_class = 122; 1461 else 1462 *op_class = 123; 1463 } else { 1464 *op_class = 121; 1465 } 1466 1467 return true; 1468 } 1469 1470 /* 5 GHz, channels 149..169 */ 1471 if (freq >= 5745 && freq <= 5845) { 1472 if (vht_opclass) { 1473 *op_class = vht_opclass; 1474 } else if (chandef->width == NL80211_CHAN_WIDTH_40) { 1475 if (freq > chandef->chan->center_freq) 1476 *op_class = 126; 1477 else 1478 *op_class = 127; 1479 } else if (freq <= 5805) { 1480 *op_class = 124; 1481 } else { 1482 *op_class = 125; 1483 } 1484 1485 return true; 1486 } 1487 1488 /* 56.16 GHz, channel 1..4 */ 1489 if (freq >= 56160 + 2160 * 1 && freq <= 56160 + 2160 * 4) { 1490 if (chandef->width >= NL80211_CHAN_WIDTH_40) 1491 return false; 1492 1493 *op_class = 180; 1494 return true; 1495 } 1496 1497 /* not supported yet */ 1498 return false; 1499 } 1500 EXPORT_SYMBOL(ieee80211_chandef_to_operating_class); 1501 1502 static void cfg80211_calculate_bi_data(struct wiphy *wiphy, u32 new_beacon_int, 1503 u32 *beacon_int_gcd, 1504 bool *beacon_int_different) 1505 { 1506 struct wireless_dev *wdev; 1507 1508 *beacon_int_gcd = 0; 1509 *beacon_int_different = false; 1510 1511 list_for_each_entry(wdev, &wiphy->wdev_list, list) { 1512 if (!wdev->beacon_interval) 1513 continue; 1514 1515 if (!*beacon_int_gcd) { 1516 *beacon_int_gcd = wdev->beacon_interval; 1517 continue; 1518 } 1519 1520 if (wdev->beacon_interval == *beacon_int_gcd) 1521 continue; 1522 1523 *beacon_int_different = true; 1524 *beacon_int_gcd = gcd(*beacon_int_gcd, wdev->beacon_interval); 1525 } 1526 1527 if (new_beacon_int && *beacon_int_gcd != new_beacon_int) { 1528 if (*beacon_int_gcd) 1529 *beacon_int_different = true; 1530 *beacon_int_gcd = gcd(*beacon_int_gcd, new_beacon_int); 1531 } 1532 } 1533 1534 int cfg80211_validate_beacon_int(struct cfg80211_registered_device *rdev, 1535 enum nl80211_iftype iftype, u32 beacon_int) 1536 { 1537 /* 1538 * This is just a basic pre-condition check; if interface combinations 1539 * are possible the driver must already be checking those with a call 1540 * to cfg80211_check_combinations(), in which case we'll validate more 1541 * through the cfg80211_calculate_bi_data() call and code in 1542 * cfg80211_iter_combinations(). 1543 */ 1544 1545 if (beacon_int < 10 || beacon_int > 10000) 1546 return -EINVAL; 1547 1548 return 0; 1549 } 1550 1551 int cfg80211_iter_combinations(struct wiphy *wiphy, 1552 struct iface_combination_params *params, 1553 void (*iter)(const struct ieee80211_iface_combination *c, 1554 void *data), 1555 void *data) 1556 { 1557 const struct ieee80211_regdomain *regdom; 1558 enum nl80211_dfs_regions region = 0; 1559 int i, j, iftype; 1560 int num_interfaces = 0; 1561 u32 used_iftypes = 0; 1562 u32 beacon_int_gcd; 1563 bool beacon_int_different; 1564 1565 /* 1566 * This is a bit strange, since the iteration used to rely only on 1567 * the data given by the driver, but here it now relies on context, 1568 * in form of the currently operating interfaces. 1569 * This is OK for all current users, and saves us from having to 1570 * push the GCD calculations into all the drivers. 1571 * In the future, this should probably rely more on data that's in 1572 * cfg80211 already - the only thing not would appear to be any new 1573 * interfaces (while being brought up) and channel/radar data. 1574 */ 1575 cfg80211_calculate_bi_data(wiphy, params->new_beacon_int, 1576 &beacon_int_gcd, &beacon_int_different); 1577 1578 if (params->radar_detect) { 1579 rcu_read_lock(); 1580 regdom = rcu_dereference(cfg80211_regdomain); 1581 if (regdom) 1582 region = regdom->dfs_region; 1583 rcu_read_unlock(); 1584 } 1585 1586 for (iftype = 0; iftype < NUM_NL80211_IFTYPES; iftype++) { 1587 num_interfaces += params->iftype_num[iftype]; 1588 if (params->iftype_num[iftype] > 0 && 1589 !(wiphy->software_iftypes & BIT(iftype))) 1590 used_iftypes |= BIT(iftype); 1591 } 1592 1593 for (i = 0; i < wiphy->n_iface_combinations; i++) { 1594 const struct ieee80211_iface_combination *c; 1595 struct ieee80211_iface_limit *limits; 1596 u32 all_iftypes = 0; 1597 1598 c = &wiphy->iface_combinations[i]; 1599 1600 if (num_interfaces > c->max_interfaces) 1601 continue; 1602 if (params->num_different_channels > c->num_different_channels) 1603 continue; 1604 1605 limits = kmemdup(c->limits, sizeof(limits[0]) * c->n_limits, 1606 GFP_KERNEL); 1607 if (!limits) 1608 return -ENOMEM; 1609 1610 for (iftype = 0; iftype < NUM_NL80211_IFTYPES; iftype++) { 1611 if (wiphy->software_iftypes & BIT(iftype)) 1612 continue; 1613 for (j = 0; j < c->n_limits; j++) { 1614 all_iftypes |= limits[j].types; 1615 if (!(limits[j].types & BIT(iftype))) 1616 continue; 1617 if (limits[j].max < params->iftype_num[iftype]) 1618 goto cont; 1619 limits[j].max -= params->iftype_num[iftype]; 1620 } 1621 } 1622 1623 if (params->radar_detect != 1624 (c->radar_detect_widths & params->radar_detect)) 1625 goto cont; 1626 1627 if (params->radar_detect && c->radar_detect_regions && 1628 !(c->radar_detect_regions & BIT(region))) 1629 goto cont; 1630 1631 /* Finally check that all iftypes that we're currently 1632 * using are actually part of this combination. If they 1633 * aren't then we can't use this combination and have 1634 * to continue to the next. 1635 */ 1636 if ((all_iftypes & used_iftypes) != used_iftypes) 1637 goto cont; 1638 1639 if (beacon_int_gcd) { 1640 if (c->beacon_int_min_gcd && 1641 beacon_int_gcd < c->beacon_int_min_gcd) 1642 goto cont; 1643 if (!c->beacon_int_min_gcd && beacon_int_different) 1644 goto cont; 1645 } 1646 1647 /* This combination covered all interface types and 1648 * supported the requested numbers, so we're good. 1649 */ 1650 1651 (*iter)(c, data); 1652 cont: 1653 kfree(limits); 1654 } 1655 1656 return 0; 1657 } 1658 EXPORT_SYMBOL(cfg80211_iter_combinations); 1659 1660 static void 1661 cfg80211_iter_sum_ifcombs(const struct ieee80211_iface_combination *c, 1662 void *data) 1663 { 1664 int *num = data; 1665 (*num)++; 1666 } 1667 1668 int cfg80211_check_combinations(struct wiphy *wiphy, 1669 struct iface_combination_params *params) 1670 { 1671 int err, num = 0; 1672 1673 err = cfg80211_iter_combinations(wiphy, params, 1674 cfg80211_iter_sum_ifcombs, &num); 1675 if (err) 1676 return err; 1677 if (num == 0) 1678 return -EBUSY; 1679 1680 return 0; 1681 } 1682 EXPORT_SYMBOL(cfg80211_check_combinations); 1683 1684 int ieee80211_get_ratemask(struct ieee80211_supported_band *sband, 1685 const u8 *rates, unsigned int n_rates, 1686 u32 *mask) 1687 { 1688 int i, j; 1689 1690 if (!sband) 1691 return -EINVAL; 1692 1693 if (n_rates == 0 || n_rates > NL80211_MAX_SUPP_RATES) 1694 return -EINVAL; 1695 1696 *mask = 0; 1697 1698 for (i = 0; i < n_rates; i++) { 1699 int rate = (rates[i] & 0x7f) * 5; 1700 bool found = false; 1701 1702 for (j = 0; j < sband->n_bitrates; j++) { 1703 if (sband->bitrates[j].bitrate == rate) { 1704 found = true; 1705 *mask |= BIT(j); 1706 break; 1707 } 1708 } 1709 if (!found) 1710 return -EINVAL; 1711 } 1712 1713 /* 1714 * mask must have at least one bit set here since we 1715 * didn't accept a 0-length rates array nor allowed 1716 * entries in the array that didn't exist 1717 */ 1718 1719 return 0; 1720 } 1721 1722 unsigned int ieee80211_get_num_supported_channels(struct wiphy *wiphy) 1723 { 1724 enum nl80211_band band; 1725 unsigned int n_channels = 0; 1726 1727 for (band = 0; band < NUM_NL80211_BANDS; band++) 1728 if (wiphy->bands[band]) 1729 n_channels += wiphy->bands[band]->n_channels; 1730 1731 return n_channels; 1732 } 1733 EXPORT_SYMBOL(ieee80211_get_num_supported_channels); 1734 1735 int cfg80211_get_station(struct net_device *dev, const u8 *mac_addr, 1736 struct station_info *sinfo) 1737 { 1738 struct cfg80211_registered_device *rdev; 1739 struct wireless_dev *wdev; 1740 1741 wdev = dev->ieee80211_ptr; 1742 if (!wdev) 1743 return -EOPNOTSUPP; 1744 1745 rdev = wiphy_to_rdev(wdev->wiphy); 1746 if (!rdev->ops->get_station) 1747 return -EOPNOTSUPP; 1748 1749 memset(sinfo, 0, sizeof(*sinfo)); 1750 1751 return rdev_get_station(rdev, dev, mac_addr, sinfo); 1752 } 1753 EXPORT_SYMBOL(cfg80211_get_station); 1754 1755 void cfg80211_free_nan_func(struct cfg80211_nan_func *f) 1756 { 1757 int i; 1758 1759 if (!f) 1760 return; 1761 1762 kfree(f->serv_spec_info); 1763 kfree(f->srf_bf); 1764 kfree(f->srf_macs); 1765 for (i = 0; i < f->num_rx_filters; i++) 1766 kfree(f->rx_filters[i].filter); 1767 1768 for (i = 0; i < f->num_tx_filters; i++) 1769 kfree(f->tx_filters[i].filter); 1770 1771 kfree(f->rx_filters); 1772 kfree(f->tx_filters); 1773 kfree(f); 1774 } 1775 EXPORT_SYMBOL(cfg80211_free_nan_func); 1776 1777 bool cfg80211_does_bw_fit_range(const struct ieee80211_freq_range *freq_range, 1778 u32 center_freq_khz, u32 bw_khz) 1779 { 1780 u32 start_freq_khz, end_freq_khz; 1781 1782 start_freq_khz = center_freq_khz - (bw_khz / 2); 1783 end_freq_khz = center_freq_khz + (bw_khz / 2); 1784 1785 if (start_freq_khz >= freq_range->start_freq_khz && 1786 end_freq_khz <= freq_range->end_freq_khz) 1787 return true; 1788 1789 return false; 1790 } 1791 1792 int cfg80211_sinfo_alloc_tid_stats(struct station_info *sinfo, gfp_t gfp) 1793 { 1794 sinfo->pertid = kcalloc(sizeof(*(sinfo->pertid)), 1795 IEEE80211_NUM_TIDS + 1, gfp); 1796 if (!sinfo->pertid) 1797 return -ENOMEM; 1798 1799 return 0; 1800 } 1801 EXPORT_SYMBOL(cfg80211_sinfo_alloc_tid_stats); 1802 1803 /* See IEEE 802.1H for LLC/SNAP encapsulation/decapsulation */ 1804 /* Ethernet-II snap header (RFC1042 for most EtherTypes) */ 1805 const unsigned char rfc1042_header[] __aligned(2) = 1806 { 0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00 }; 1807 EXPORT_SYMBOL(rfc1042_header); 1808 1809 /* Bridge-Tunnel header (for EtherTypes ETH_P_AARP and ETH_P_IPX) */ 1810 const unsigned char bridge_tunnel_header[] __aligned(2) = 1811 { 0xaa, 0xaa, 0x03, 0x00, 0x00, 0xf8 }; 1812 EXPORT_SYMBOL(bridge_tunnel_header); 1813