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