1 /* 2 * Wireless utility functions 3 * 4 * Copyright 2007-2009 Johannes Berg <johannes@sipsolutions.net> 5 */ 6 #include <linux/bitops.h> 7 #include <linux/etherdevice.h> 8 #include <linux/slab.h> 9 #include <net/cfg80211.h> 10 #include <net/ip.h> 11 #include "core.h" 12 13 struct ieee80211_rate * 14 ieee80211_get_response_rate(struct ieee80211_supported_band *sband, 15 u32 basic_rates, int bitrate) 16 { 17 struct ieee80211_rate *result = &sband->bitrates[0]; 18 int i; 19 20 for (i = 0; i < sband->n_bitrates; i++) { 21 if (!(basic_rates & BIT(i))) 22 continue; 23 if (sband->bitrates[i].bitrate > bitrate) 24 continue; 25 result = &sband->bitrates[i]; 26 } 27 28 return result; 29 } 30 EXPORT_SYMBOL(ieee80211_get_response_rate); 31 32 int ieee80211_channel_to_frequency(int chan, enum ieee80211_band band) 33 { 34 /* see 802.11 17.3.8.3.2 and Annex J 35 * there are overlapping channel numbers in 5GHz and 2GHz bands */ 36 if (band == IEEE80211_BAND_5GHZ) { 37 if (chan >= 182 && chan <= 196) 38 return 4000 + chan * 5; 39 else 40 return 5000 + chan * 5; 41 } else { /* IEEE80211_BAND_2GHZ */ 42 if (chan == 14) 43 return 2484; 44 else if (chan < 14) 45 return 2407 + chan * 5; 46 else 47 return 0; /* not supported */ 48 } 49 } 50 EXPORT_SYMBOL(ieee80211_channel_to_frequency); 51 52 int ieee80211_frequency_to_channel(int freq) 53 { 54 /* see 802.11 17.3.8.3.2 and Annex J */ 55 if (freq == 2484) 56 return 14; 57 else if (freq < 2484) 58 return (freq - 2407) / 5; 59 else if (freq >= 4910 && freq <= 4980) 60 return (freq - 4000) / 5; 61 else 62 return (freq - 5000) / 5; 63 } 64 EXPORT_SYMBOL(ieee80211_frequency_to_channel); 65 66 struct ieee80211_channel *__ieee80211_get_channel(struct wiphy *wiphy, 67 int freq) 68 { 69 enum ieee80211_band band; 70 struct ieee80211_supported_band *sband; 71 int i; 72 73 for (band = 0; band < IEEE80211_NUM_BANDS; band++) { 74 sband = wiphy->bands[band]; 75 76 if (!sband) 77 continue; 78 79 for (i = 0; i < sband->n_channels; i++) { 80 if (sband->channels[i].center_freq == freq) 81 return &sband->channels[i]; 82 } 83 } 84 85 return NULL; 86 } 87 EXPORT_SYMBOL(__ieee80211_get_channel); 88 89 static void set_mandatory_flags_band(struct ieee80211_supported_band *sband, 90 enum ieee80211_band band) 91 { 92 int i, want; 93 94 switch (band) { 95 case IEEE80211_BAND_5GHZ: 96 want = 3; 97 for (i = 0; i < sband->n_bitrates; i++) { 98 if (sband->bitrates[i].bitrate == 60 || 99 sband->bitrates[i].bitrate == 120 || 100 sband->bitrates[i].bitrate == 240) { 101 sband->bitrates[i].flags |= 102 IEEE80211_RATE_MANDATORY_A; 103 want--; 104 } 105 } 106 WARN_ON(want); 107 break; 108 case IEEE80211_BAND_2GHZ: 109 want = 7; 110 for (i = 0; i < sband->n_bitrates; i++) { 111 if (sband->bitrates[i].bitrate == 10) { 112 sband->bitrates[i].flags |= 113 IEEE80211_RATE_MANDATORY_B | 114 IEEE80211_RATE_MANDATORY_G; 115 want--; 116 } 117 118 if (sband->bitrates[i].bitrate == 20 || 119 sband->bitrates[i].bitrate == 55 || 120 sband->bitrates[i].bitrate == 110 || 121 sband->bitrates[i].bitrate == 60 || 122 sband->bitrates[i].bitrate == 120 || 123 sband->bitrates[i].bitrate == 240) { 124 sband->bitrates[i].flags |= 125 IEEE80211_RATE_MANDATORY_G; 126 want--; 127 } 128 129 if (sband->bitrates[i].bitrate != 10 && 130 sband->bitrates[i].bitrate != 20 && 131 sband->bitrates[i].bitrate != 55 && 132 sband->bitrates[i].bitrate != 110) 133 sband->bitrates[i].flags |= 134 IEEE80211_RATE_ERP_G; 135 } 136 WARN_ON(want != 0 && want != 3 && want != 6); 137 break; 138 case IEEE80211_NUM_BANDS: 139 WARN_ON(1); 140 break; 141 } 142 } 143 144 void ieee80211_set_bitrate_flags(struct wiphy *wiphy) 145 { 146 enum ieee80211_band band; 147 148 for (band = 0; band < IEEE80211_NUM_BANDS; band++) 149 if (wiphy->bands[band]) 150 set_mandatory_flags_band(wiphy->bands[band], band); 151 } 152 153 int cfg80211_validate_key_settings(struct cfg80211_registered_device *rdev, 154 struct key_params *params, int key_idx, 155 bool pairwise, const u8 *mac_addr) 156 { 157 int i; 158 159 if (key_idx > 5) 160 return -EINVAL; 161 162 if (!pairwise && mac_addr && !(rdev->wiphy.flags & WIPHY_FLAG_IBSS_RSN)) 163 return -EINVAL; 164 165 if (pairwise && !mac_addr) 166 return -EINVAL; 167 168 /* 169 * Disallow pairwise keys with non-zero index unless it's WEP 170 * or a vendor specific cipher (because current deployments use 171 * pairwise WEP keys with non-zero indices and for vendor specific 172 * ciphers this should be validated in the driver or hardware level 173 * - but 802.11i clearly specifies to use zero) 174 */ 175 if (pairwise && key_idx && 176 ((params->cipher == WLAN_CIPHER_SUITE_TKIP) || 177 (params->cipher == WLAN_CIPHER_SUITE_CCMP) || 178 (params->cipher == WLAN_CIPHER_SUITE_AES_CMAC))) 179 return -EINVAL; 180 181 switch (params->cipher) { 182 case WLAN_CIPHER_SUITE_WEP40: 183 if (params->key_len != WLAN_KEY_LEN_WEP40) 184 return -EINVAL; 185 break; 186 case WLAN_CIPHER_SUITE_TKIP: 187 if (params->key_len != WLAN_KEY_LEN_TKIP) 188 return -EINVAL; 189 break; 190 case WLAN_CIPHER_SUITE_CCMP: 191 if (params->key_len != WLAN_KEY_LEN_CCMP) 192 return -EINVAL; 193 break; 194 case WLAN_CIPHER_SUITE_WEP104: 195 if (params->key_len != WLAN_KEY_LEN_WEP104) 196 return -EINVAL; 197 break; 198 case WLAN_CIPHER_SUITE_AES_CMAC: 199 if (params->key_len != WLAN_KEY_LEN_AES_CMAC) 200 return -EINVAL; 201 break; 202 default: 203 /* 204 * We don't know anything about this algorithm, 205 * allow using it -- but the driver must check 206 * all parameters! We still check below whether 207 * or not the driver supports this algorithm, 208 * of course. 209 */ 210 break; 211 } 212 213 if (params->seq) { 214 switch (params->cipher) { 215 case WLAN_CIPHER_SUITE_WEP40: 216 case WLAN_CIPHER_SUITE_WEP104: 217 /* These ciphers do not use key sequence */ 218 return -EINVAL; 219 case WLAN_CIPHER_SUITE_TKIP: 220 case WLAN_CIPHER_SUITE_CCMP: 221 case WLAN_CIPHER_SUITE_AES_CMAC: 222 if (params->seq_len != 6) 223 return -EINVAL; 224 break; 225 } 226 } 227 228 for (i = 0; i < rdev->wiphy.n_cipher_suites; i++) 229 if (params->cipher == rdev->wiphy.cipher_suites[i]) 230 break; 231 if (i == rdev->wiphy.n_cipher_suites) 232 return -EINVAL; 233 234 return 0; 235 } 236 237 /* See IEEE 802.1H for LLC/SNAP encapsulation/decapsulation */ 238 /* Ethernet-II snap header (RFC1042 for most EtherTypes) */ 239 const unsigned char rfc1042_header[] __aligned(2) = 240 { 0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00 }; 241 EXPORT_SYMBOL(rfc1042_header); 242 243 /* Bridge-Tunnel header (for EtherTypes ETH_P_AARP and ETH_P_IPX) */ 244 const unsigned char bridge_tunnel_header[] __aligned(2) = 245 { 0xaa, 0xaa, 0x03, 0x00, 0x00, 0xf8 }; 246 EXPORT_SYMBOL(bridge_tunnel_header); 247 248 unsigned int __attribute_const__ ieee80211_hdrlen(__le16 fc) 249 { 250 unsigned int hdrlen = 24; 251 252 if (ieee80211_is_data(fc)) { 253 if (ieee80211_has_a4(fc)) 254 hdrlen = 30; 255 if (ieee80211_is_data_qos(fc)) { 256 hdrlen += IEEE80211_QOS_CTL_LEN; 257 if (ieee80211_has_order(fc)) 258 hdrlen += IEEE80211_HT_CTL_LEN; 259 } 260 goto out; 261 } 262 263 if (ieee80211_is_ctl(fc)) { 264 /* 265 * ACK and CTS are 10 bytes, all others 16. To see how 266 * to get this condition consider 267 * subtype mask: 0b0000000011110000 (0x00F0) 268 * ACK subtype: 0b0000000011010000 (0x00D0) 269 * CTS subtype: 0b0000000011000000 (0x00C0) 270 * bits that matter: ^^^ (0x00E0) 271 * value of those: 0b0000000011000000 (0x00C0) 272 */ 273 if ((fc & cpu_to_le16(0x00E0)) == cpu_to_le16(0x00C0)) 274 hdrlen = 10; 275 else 276 hdrlen = 16; 277 } 278 out: 279 return hdrlen; 280 } 281 EXPORT_SYMBOL(ieee80211_hdrlen); 282 283 unsigned int ieee80211_get_hdrlen_from_skb(const struct sk_buff *skb) 284 { 285 const struct ieee80211_hdr *hdr = 286 (const struct ieee80211_hdr *)skb->data; 287 unsigned int hdrlen; 288 289 if (unlikely(skb->len < 10)) 290 return 0; 291 hdrlen = ieee80211_hdrlen(hdr->frame_control); 292 if (unlikely(hdrlen > skb->len)) 293 return 0; 294 return hdrlen; 295 } 296 EXPORT_SYMBOL(ieee80211_get_hdrlen_from_skb); 297 298 static int ieee80211_get_mesh_hdrlen(struct ieee80211s_hdr *meshhdr) 299 { 300 int ae = meshhdr->flags & MESH_FLAGS_AE; 301 /* 7.1.3.5a.2 */ 302 switch (ae) { 303 case 0: 304 return 6; 305 case MESH_FLAGS_AE_A4: 306 return 12; 307 case MESH_FLAGS_AE_A5_A6: 308 return 18; 309 case (MESH_FLAGS_AE_A4 | MESH_FLAGS_AE_A5_A6): 310 return 24; 311 default: 312 return 6; 313 } 314 } 315 316 int ieee80211_data_to_8023(struct sk_buff *skb, const u8 *addr, 317 enum nl80211_iftype iftype) 318 { 319 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data; 320 u16 hdrlen, ethertype; 321 u8 *payload; 322 u8 dst[ETH_ALEN]; 323 u8 src[ETH_ALEN] __aligned(2); 324 325 if (unlikely(!ieee80211_is_data_present(hdr->frame_control))) 326 return -1; 327 328 hdrlen = ieee80211_hdrlen(hdr->frame_control); 329 330 /* convert IEEE 802.11 header + possible LLC headers into Ethernet 331 * header 332 * IEEE 802.11 address fields: 333 * ToDS FromDS Addr1 Addr2 Addr3 Addr4 334 * 0 0 DA SA BSSID n/a 335 * 0 1 DA BSSID SA n/a 336 * 1 0 BSSID SA DA n/a 337 * 1 1 RA TA DA SA 338 */ 339 memcpy(dst, ieee80211_get_DA(hdr), ETH_ALEN); 340 memcpy(src, ieee80211_get_SA(hdr), ETH_ALEN); 341 342 switch (hdr->frame_control & 343 cpu_to_le16(IEEE80211_FCTL_TODS | IEEE80211_FCTL_FROMDS)) { 344 case cpu_to_le16(IEEE80211_FCTL_TODS): 345 if (unlikely(iftype != NL80211_IFTYPE_AP && 346 iftype != NL80211_IFTYPE_AP_VLAN && 347 iftype != NL80211_IFTYPE_P2P_GO)) 348 return -1; 349 break; 350 case cpu_to_le16(IEEE80211_FCTL_TODS | IEEE80211_FCTL_FROMDS): 351 if (unlikely(iftype != NL80211_IFTYPE_WDS && 352 iftype != NL80211_IFTYPE_MESH_POINT && 353 iftype != NL80211_IFTYPE_AP_VLAN && 354 iftype != NL80211_IFTYPE_STATION)) 355 return -1; 356 if (iftype == NL80211_IFTYPE_MESH_POINT) { 357 struct ieee80211s_hdr *meshdr = 358 (struct ieee80211s_hdr *) (skb->data + hdrlen); 359 /* make sure meshdr->flags is on the linear part */ 360 if (!pskb_may_pull(skb, hdrlen + 1)) 361 return -1; 362 if (meshdr->flags & MESH_FLAGS_AE_A5_A6) { 363 skb_copy_bits(skb, hdrlen + 364 offsetof(struct ieee80211s_hdr, eaddr1), 365 dst, ETH_ALEN); 366 skb_copy_bits(skb, hdrlen + 367 offsetof(struct ieee80211s_hdr, eaddr2), 368 src, ETH_ALEN); 369 } 370 hdrlen += ieee80211_get_mesh_hdrlen(meshdr); 371 } 372 break; 373 case cpu_to_le16(IEEE80211_FCTL_FROMDS): 374 if ((iftype != NL80211_IFTYPE_STATION && 375 iftype != NL80211_IFTYPE_P2P_CLIENT && 376 iftype != NL80211_IFTYPE_MESH_POINT) || 377 (is_multicast_ether_addr(dst) && 378 !compare_ether_addr(src, addr))) 379 return -1; 380 if (iftype == NL80211_IFTYPE_MESH_POINT) { 381 struct ieee80211s_hdr *meshdr = 382 (struct ieee80211s_hdr *) (skb->data + hdrlen); 383 /* make sure meshdr->flags is on the linear part */ 384 if (!pskb_may_pull(skb, hdrlen + 1)) 385 return -1; 386 if (meshdr->flags & MESH_FLAGS_AE_A4) 387 skb_copy_bits(skb, hdrlen + 388 offsetof(struct ieee80211s_hdr, eaddr1), 389 src, ETH_ALEN); 390 hdrlen += ieee80211_get_mesh_hdrlen(meshdr); 391 } 392 break; 393 case cpu_to_le16(0): 394 if (iftype != NL80211_IFTYPE_ADHOC) 395 return -1; 396 break; 397 } 398 399 if (!pskb_may_pull(skb, hdrlen + 8)) 400 return -1; 401 402 payload = skb->data + hdrlen; 403 ethertype = (payload[6] << 8) | payload[7]; 404 405 if (likely((compare_ether_addr(payload, rfc1042_header) == 0 && 406 ethertype != ETH_P_AARP && ethertype != ETH_P_IPX) || 407 compare_ether_addr(payload, bridge_tunnel_header) == 0)) { 408 /* remove RFC1042 or Bridge-Tunnel encapsulation and 409 * replace EtherType */ 410 skb_pull(skb, hdrlen + 6); 411 memcpy(skb_push(skb, ETH_ALEN), src, ETH_ALEN); 412 memcpy(skb_push(skb, ETH_ALEN), dst, ETH_ALEN); 413 } else { 414 struct ethhdr *ehdr; 415 __be16 len; 416 417 skb_pull(skb, hdrlen); 418 len = htons(skb->len); 419 ehdr = (struct ethhdr *) skb_push(skb, sizeof(struct ethhdr)); 420 memcpy(ehdr->h_dest, dst, ETH_ALEN); 421 memcpy(ehdr->h_source, src, ETH_ALEN); 422 ehdr->h_proto = len; 423 } 424 return 0; 425 } 426 EXPORT_SYMBOL(ieee80211_data_to_8023); 427 428 int ieee80211_data_from_8023(struct sk_buff *skb, const u8 *addr, 429 enum nl80211_iftype iftype, u8 *bssid, bool qos) 430 { 431 struct ieee80211_hdr hdr; 432 u16 hdrlen, ethertype; 433 __le16 fc; 434 const u8 *encaps_data; 435 int encaps_len, skip_header_bytes; 436 int nh_pos, h_pos; 437 int head_need; 438 439 if (unlikely(skb->len < ETH_HLEN)) 440 return -EINVAL; 441 442 nh_pos = skb_network_header(skb) - skb->data; 443 h_pos = skb_transport_header(skb) - skb->data; 444 445 /* convert Ethernet header to proper 802.11 header (based on 446 * operation mode) */ 447 ethertype = (skb->data[12] << 8) | skb->data[13]; 448 fc = cpu_to_le16(IEEE80211_FTYPE_DATA | IEEE80211_STYPE_DATA); 449 450 switch (iftype) { 451 case NL80211_IFTYPE_AP: 452 case NL80211_IFTYPE_AP_VLAN: 453 case NL80211_IFTYPE_P2P_GO: 454 fc |= cpu_to_le16(IEEE80211_FCTL_FROMDS); 455 /* DA BSSID SA */ 456 memcpy(hdr.addr1, skb->data, ETH_ALEN); 457 memcpy(hdr.addr2, addr, ETH_ALEN); 458 memcpy(hdr.addr3, skb->data + ETH_ALEN, ETH_ALEN); 459 hdrlen = 24; 460 break; 461 case NL80211_IFTYPE_STATION: 462 case NL80211_IFTYPE_P2P_CLIENT: 463 fc |= cpu_to_le16(IEEE80211_FCTL_TODS); 464 /* BSSID SA DA */ 465 memcpy(hdr.addr1, bssid, ETH_ALEN); 466 memcpy(hdr.addr2, skb->data + ETH_ALEN, ETH_ALEN); 467 memcpy(hdr.addr3, skb->data, ETH_ALEN); 468 hdrlen = 24; 469 break; 470 case NL80211_IFTYPE_ADHOC: 471 /* DA SA BSSID */ 472 memcpy(hdr.addr1, skb->data, ETH_ALEN); 473 memcpy(hdr.addr2, skb->data + ETH_ALEN, ETH_ALEN); 474 memcpy(hdr.addr3, bssid, ETH_ALEN); 475 hdrlen = 24; 476 break; 477 default: 478 return -EOPNOTSUPP; 479 } 480 481 if (qos) { 482 fc |= cpu_to_le16(IEEE80211_STYPE_QOS_DATA); 483 hdrlen += 2; 484 } 485 486 hdr.frame_control = fc; 487 hdr.duration_id = 0; 488 hdr.seq_ctrl = 0; 489 490 skip_header_bytes = ETH_HLEN; 491 if (ethertype == ETH_P_AARP || ethertype == ETH_P_IPX) { 492 encaps_data = bridge_tunnel_header; 493 encaps_len = sizeof(bridge_tunnel_header); 494 skip_header_bytes -= 2; 495 } else if (ethertype > 0x600) { 496 encaps_data = rfc1042_header; 497 encaps_len = sizeof(rfc1042_header); 498 skip_header_bytes -= 2; 499 } else { 500 encaps_data = NULL; 501 encaps_len = 0; 502 } 503 504 skb_pull(skb, skip_header_bytes); 505 nh_pos -= skip_header_bytes; 506 h_pos -= skip_header_bytes; 507 508 head_need = hdrlen + encaps_len - skb_headroom(skb); 509 510 if (head_need > 0 || skb_cloned(skb)) { 511 head_need = max(head_need, 0); 512 if (head_need) 513 skb_orphan(skb); 514 515 if (pskb_expand_head(skb, head_need, 0, GFP_ATOMIC)) { 516 pr_err("failed to reallocate Tx buffer\n"); 517 return -ENOMEM; 518 } 519 skb->truesize += head_need; 520 } 521 522 if (encaps_data) { 523 memcpy(skb_push(skb, encaps_len), encaps_data, encaps_len); 524 nh_pos += encaps_len; 525 h_pos += encaps_len; 526 } 527 528 memcpy(skb_push(skb, hdrlen), &hdr, hdrlen); 529 530 nh_pos += hdrlen; 531 h_pos += hdrlen; 532 533 /* Update skb pointers to various headers since this modified frame 534 * is going to go through Linux networking code that may potentially 535 * need things like pointer to IP header. */ 536 skb_set_mac_header(skb, 0); 537 skb_set_network_header(skb, nh_pos); 538 skb_set_transport_header(skb, h_pos); 539 540 return 0; 541 } 542 EXPORT_SYMBOL(ieee80211_data_from_8023); 543 544 545 void ieee80211_amsdu_to_8023s(struct sk_buff *skb, struct sk_buff_head *list, 546 const u8 *addr, enum nl80211_iftype iftype, 547 const unsigned int extra_headroom, 548 bool has_80211_header) 549 { 550 struct sk_buff *frame = NULL; 551 u16 ethertype; 552 u8 *payload; 553 const struct ethhdr *eth; 554 int remaining, err; 555 u8 dst[ETH_ALEN], src[ETH_ALEN]; 556 557 if (has_80211_header) { 558 err = ieee80211_data_to_8023(skb, addr, iftype); 559 if (err) 560 goto out; 561 562 /* skip the wrapping header */ 563 eth = (struct ethhdr *) skb_pull(skb, sizeof(struct ethhdr)); 564 if (!eth) 565 goto out; 566 } else { 567 eth = (struct ethhdr *) skb->data; 568 } 569 570 while (skb != frame) { 571 u8 padding; 572 __be16 len = eth->h_proto; 573 unsigned int subframe_len = sizeof(struct ethhdr) + ntohs(len); 574 575 remaining = skb->len; 576 memcpy(dst, eth->h_dest, ETH_ALEN); 577 memcpy(src, eth->h_source, ETH_ALEN); 578 579 padding = (4 - subframe_len) & 0x3; 580 /* the last MSDU has no padding */ 581 if (subframe_len > remaining) 582 goto purge; 583 584 skb_pull(skb, sizeof(struct ethhdr)); 585 /* reuse skb for the last subframe */ 586 if (remaining <= subframe_len + padding) 587 frame = skb; 588 else { 589 unsigned int hlen = ALIGN(extra_headroom, 4); 590 /* 591 * Allocate and reserve two bytes more for payload 592 * alignment since sizeof(struct ethhdr) is 14. 593 */ 594 frame = dev_alloc_skb(hlen + subframe_len + 2); 595 if (!frame) 596 goto purge; 597 598 skb_reserve(frame, hlen + sizeof(struct ethhdr) + 2); 599 memcpy(skb_put(frame, ntohs(len)), skb->data, 600 ntohs(len)); 601 602 eth = (struct ethhdr *)skb_pull(skb, ntohs(len) + 603 padding); 604 if (!eth) { 605 dev_kfree_skb(frame); 606 goto purge; 607 } 608 } 609 610 skb_reset_network_header(frame); 611 frame->dev = skb->dev; 612 frame->priority = skb->priority; 613 614 payload = frame->data; 615 ethertype = (payload[6] << 8) | payload[7]; 616 617 if (likely((compare_ether_addr(payload, rfc1042_header) == 0 && 618 ethertype != ETH_P_AARP && ethertype != ETH_P_IPX) || 619 compare_ether_addr(payload, 620 bridge_tunnel_header) == 0)) { 621 /* remove RFC1042 or Bridge-Tunnel 622 * encapsulation and replace EtherType */ 623 skb_pull(frame, 6); 624 memcpy(skb_push(frame, ETH_ALEN), src, ETH_ALEN); 625 memcpy(skb_push(frame, ETH_ALEN), dst, ETH_ALEN); 626 } else { 627 memcpy(skb_push(frame, sizeof(__be16)), &len, 628 sizeof(__be16)); 629 memcpy(skb_push(frame, ETH_ALEN), src, ETH_ALEN); 630 memcpy(skb_push(frame, ETH_ALEN), dst, ETH_ALEN); 631 } 632 __skb_queue_tail(list, frame); 633 } 634 635 return; 636 637 purge: 638 __skb_queue_purge(list); 639 out: 640 dev_kfree_skb(skb); 641 } 642 EXPORT_SYMBOL(ieee80211_amsdu_to_8023s); 643 644 /* Given a data frame determine the 802.1p/1d tag to use. */ 645 unsigned int cfg80211_classify8021d(struct sk_buff *skb) 646 { 647 unsigned int dscp; 648 649 /* skb->priority values from 256->263 are magic values to 650 * directly indicate a specific 802.1d priority. This is used 651 * to allow 802.1d priority to be passed directly in from VLAN 652 * tags, etc. 653 */ 654 if (skb->priority >= 256 && skb->priority <= 263) 655 return skb->priority - 256; 656 657 switch (skb->protocol) { 658 case htons(ETH_P_IP): 659 dscp = ip_hdr(skb)->tos & 0xfc; 660 break; 661 default: 662 return 0; 663 } 664 665 return dscp >> 5; 666 } 667 EXPORT_SYMBOL(cfg80211_classify8021d); 668 669 const u8 *ieee80211_bss_get_ie(struct cfg80211_bss *bss, u8 ie) 670 { 671 u8 *end, *pos; 672 673 pos = bss->information_elements; 674 if (pos == NULL) 675 return NULL; 676 end = pos + bss->len_information_elements; 677 678 while (pos + 1 < end) { 679 if (pos + 2 + pos[1] > end) 680 break; 681 if (pos[0] == ie) 682 return pos; 683 pos += 2 + pos[1]; 684 } 685 686 return NULL; 687 } 688 EXPORT_SYMBOL(ieee80211_bss_get_ie); 689 690 void cfg80211_upload_connect_keys(struct wireless_dev *wdev) 691 { 692 struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy); 693 struct net_device *dev = wdev->netdev; 694 int i; 695 696 if (!wdev->connect_keys) 697 return; 698 699 for (i = 0; i < 6; i++) { 700 if (!wdev->connect_keys->params[i].cipher) 701 continue; 702 if (rdev->ops->add_key(wdev->wiphy, dev, i, false, NULL, 703 &wdev->connect_keys->params[i])) { 704 netdev_err(dev, "failed to set key %d\n", i); 705 continue; 706 } 707 if (wdev->connect_keys->def == i) 708 if (rdev->ops->set_default_key(wdev->wiphy, dev, 709 i, true, true)) { 710 netdev_err(dev, "failed to set defkey %d\n", i); 711 continue; 712 } 713 if (wdev->connect_keys->defmgmt == i) 714 if (rdev->ops->set_default_mgmt_key(wdev->wiphy, dev, i)) 715 netdev_err(dev, "failed to set mgtdef %d\n", i); 716 } 717 718 kfree(wdev->connect_keys); 719 wdev->connect_keys = NULL; 720 } 721 722 static void cfg80211_process_wdev_events(struct wireless_dev *wdev) 723 { 724 struct cfg80211_event *ev; 725 unsigned long flags; 726 const u8 *bssid = NULL; 727 728 spin_lock_irqsave(&wdev->event_lock, flags); 729 while (!list_empty(&wdev->event_list)) { 730 ev = list_first_entry(&wdev->event_list, 731 struct cfg80211_event, list); 732 list_del(&ev->list); 733 spin_unlock_irqrestore(&wdev->event_lock, flags); 734 735 wdev_lock(wdev); 736 switch (ev->type) { 737 case EVENT_CONNECT_RESULT: 738 if (!is_zero_ether_addr(ev->cr.bssid)) 739 bssid = ev->cr.bssid; 740 __cfg80211_connect_result( 741 wdev->netdev, bssid, 742 ev->cr.req_ie, ev->cr.req_ie_len, 743 ev->cr.resp_ie, ev->cr.resp_ie_len, 744 ev->cr.status, 745 ev->cr.status == WLAN_STATUS_SUCCESS, 746 NULL); 747 break; 748 case EVENT_ROAMED: 749 __cfg80211_roamed(wdev, ev->rm.channel, ev->rm.bssid, 750 ev->rm.req_ie, ev->rm.req_ie_len, 751 ev->rm.resp_ie, ev->rm.resp_ie_len); 752 break; 753 case EVENT_DISCONNECTED: 754 __cfg80211_disconnected(wdev->netdev, 755 ev->dc.ie, ev->dc.ie_len, 756 ev->dc.reason, true); 757 break; 758 case EVENT_IBSS_JOINED: 759 __cfg80211_ibss_joined(wdev->netdev, ev->ij.bssid); 760 break; 761 } 762 wdev_unlock(wdev); 763 764 kfree(ev); 765 766 spin_lock_irqsave(&wdev->event_lock, flags); 767 } 768 spin_unlock_irqrestore(&wdev->event_lock, flags); 769 } 770 771 void cfg80211_process_rdev_events(struct cfg80211_registered_device *rdev) 772 { 773 struct wireless_dev *wdev; 774 775 ASSERT_RTNL(); 776 ASSERT_RDEV_LOCK(rdev); 777 778 mutex_lock(&rdev->devlist_mtx); 779 780 list_for_each_entry(wdev, &rdev->netdev_list, list) 781 cfg80211_process_wdev_events(wdev); 782 783 mutex_unlock(&rdev->devlist_mtx); 784 } 785 786 int cfg80211_change_iface(struct cfg80211_registered_device *rdev, 787 struct net_device *dev, enum nl80211_iftype ntype, 788 u32 *flags, struct vif_params *params) 789 { 790 int err; 791 enum nl80211_iftype otype = dev->ieee80211_ptr->iftype; 792 793 ASSERT_RDEV_LOCK(rdev); 794 795 /* don't support changing VLANs, you just re-create them */ 796 if (otype == NL80211_IFTYPE_AP_VLAN) 797 return -EOPNOTSUPP; 798 799 if (!rdev->ops->change_virtual_intf || 800 !(rdev->wiphy.interface_modes & (1 << ntype))) 801 return -EOPNOTSUPP; 802 803 /* if it's part of a bridge, reject changing type to station/ibss */ 804 if ((dev->priv_flags & IFF_BRIDGE_PORT) && 805 (ntype == NL80211_IFTYPE_ADHOC || 806 ntype == NL80211_IFTYPE_STATION || 807 ntype == NL80211_IFTYPE_P2P_CLIENT)) 808 return -EBUSY; 809 810 if (ntype != otype) { 811 err = cfg80211_can_change_interface(rdev, dev->ieee80211_ptr, 812 ntype); 813 if (err) 814 return err; 815 816 dev->ieee80211_ptr->use_4addr = false; 817 dev->ieee80211_ptr->mesh_id_up_len = 0; 818 819 switch (otype) { 820 case NL80211_IFTYPE_ADHOC: 821 cfg80211_leave_ibss(rdev, dev, false); 822 break; 823 case NL80211_IFTYPE_STATION: 824 case NL80211_IFTYPE_P2P_CLIENT: 825 cfg80211_disconnect(rdev, dev, 826 WLAN_REASON_DEAUTH_LEAVING, true); 827 break; 828 case NL80211_IFTYPE_MESH_POINT: 829 /* mesh should be handled? */ 830 break; 831 default: 832 break; 833 } 834 835 cfg80211_process_rdev_events(rdev); 836 } 837 838 err = rdev->ops->change_virtual_intf(&rdev->wiphy, dev, 839 ntype, flags, params); 840 841 WARN_ON(!err && dev->ieee80211_ptr->iftype != ntype); 842 843 if (!err && params && params->use_4addr != -1) 844 dev->ieee80211_ptr->use_4addr = params->use_4addr; 845 846 if (!err) { 847 dev->priv_flags &= ~IFF_DONT_BRIDGE; 848 switch (ntype) { 849 case NL80211_IFTYPE_STATION: 850 if (dev->ieee80211_ptr->use_4addr) 851 break; 852 /* fall through */ 853 case NL80211_IFTYPE_P2P_CLIENT: 854 case NL80211_IFTYPE_ADHOC: 855 dev->priv_flags |= IFF_DONT_BRIDGE; 856 break; 857 case NL80211_IFTYPE_P2P_GO: 858 case NL80211_IFTYPE_AP: 859 case NL80211_IFTYPE_AP_VLAN: 860 case NL80211_IFTYPE_WDS: 861 case NL80211_IFTYPE_MESH_POINT: 862 /* bridging OK */ 863 break; 864 case NL80211_IFTYPE_MONITOR: 865 /* monitor can't bridge anyway */ 866 break; 867 case NL80211_IFTYPE_UNSPECIFIED: 868 case NUM_NL80211_IFTYPES: 869 /* not happening */ 870 break; 871 } 872 } 873 874 return err; 875 } 876 877 u16 cfg80211_calculate_bitrate(struct rate_info *rate) 878 { 879 int modulation, streams, bitrate; 880 881 if (!(rate->flags & RATE_INFO_FLAGS_MCS)) 882 return rate->legacy; 883 884 /* the formula below does only work for MCS values smaller than 32 */ 885 if (rate->mcs >= 32) 886 return 0; 887 888 modulation = rate->mcs & 7; 889 streams = (rate->mcs >> 3) + 1; 890 891 bitrate = (rate->flags & RATE_INFO_FLAGS_40_MHZ_WIDTH) ? 892 13500000 : 6500000; 893 894 if (modulation < 4) 895 bitrate *= (modulation + 1); 896 else if (modulation == 4) 897 bitrate *= (modulation + 2); 898 else 899 bitrate *= (modulation + 3); 900 901 bitrate *= streams; 902 903 if (rate->flags & RATE_INFO_FLAGS_SHORT_GI) 904 bitrate = (bitrate / 9) * 10; 905 906 /* do NOT round down here */ 907 return (bitrate + 50000) / 100000; 908 } 909 910 int cfg80211_validate_beacon_int(struct cfg80211_registered_device *rdev, 911 u32 beacon_int) 912 { 913 struct wireless_dev *wdev; 914 int res = 0; 915 916 if (!beacon_int) 917 return -EINVAL; 918 919 mutex_lock(&rdev->devlist_mtx); 920 921 list_for_each_entry(wdev, &rdev->netdev_list, list) { 922 if (!wdev->beacon_interval) 923 continue; 924 if (wdev->beacon_interval != beacon_int) { 925 res = -EINVAL; 926 break; 927 } 928 } 929 930 mutex_unlock(&rdev->devlist_mtx); 931 932 return res; 933 } 934 935 int cfg80211_can_change_interface(struct cfg80211_registered_device *rdev, 936 struct wireless_dev *wdev, 937 enum nl80211_iftype iftype) 938 { 939 struct wireless_dev *wdev_iter; 940 int num[NUM_NL80211_IFTYPES]; 941 int total = 1; 942 int i, j; 943 944 ASSERT_RTNL(); 945 946 /* Always allow software iftypes */ 947 if (rdev->wiphy.software_iftypes & BIT(iftype)) 948 return 0; 949 950 /* 951 * Drivers will gradually all set this flag, until all 952 * have it we only enforce for those that set it. 953 */ 954 if (!(rdev->wiphy.flags & WIPHY_FLAG_ENFORCE_COMBINATIONS)) 955 return 0; 956 957 memset(num, 0, sizeof(num)); 958 959 num[iftype] = 1; 960 961 mutex_lock(&rdev->devlist_mtx); 962 list_for_each_entry(wdev_iter, &rdev->netdev_list, list) { 963 if (wdev_iter == wdev) 964 continue; 965 if (!netif_running(wdev_iter->netdev)) 966 continue; 967 968 if (rdev->wiphy.software_iftypes & BIT(wdev_iter->iftype)) 969 continue; 970 971 num[wdev_iter->iftype]++; 972 total++; 973 } 974 mutex_unlock(&rdev->devlist_mtx); 975 976 for (i = 0; i < rdev->wiphy.n_iface_combinations; i++) { 977 const struct ieee80211_iface_combination *c; 978 struct ieee80211_iface_limit *limits; 979 980 c = &rdev->wiphy.iface_combinations[i]; 981 982 limits = kmemdup(c->limits, sizeof(limits[0]) * c->n_limits, 983 GFP_KERNEL); 984 if (!limits) 985 return -ENOMEM; 986 if (total > c->max_interfaces) 987 goto cont; 988 989 for (iftype = 0; iftype < NUM_NL80211_IFTYPES; iftype++) { 990 if (rdev->wiphy.software_iftypes & BIT(iftype)) 991 continue; 992 for (j = 0; j < c->n_limits; j++) { 993 if (!(limits[j].types & iftype)) 994 continue; 995 if (limits[j].max < num[iftype]) 996 goto cont; 997 limits[j].max -= num[iftype]; 998 } 999 } 1000 /* yay, it fits */ 1001 kfree(limits); 1002 return 0; 1003 cont: 1004 kfree(limits); 1005 } 1006 1007 return -EBUSY; 1008 } 1009 1010 int ieee80211_get_ratemask(struct ieee80211_supported_band *sband, 1011 const u8 *rates, unsigned int n_rates, 1012 u32 *mask) 1013 { 1014 int i, j; 1015 1016 if (!sband) 1017 return -EINVAL; 1018 1019 if (n_rates == 0 || n_rates > NL80211_MAX_SUPP_RATES) 1020 return -EINVAL; 1021 1022 *mask = 0; 1023 1024 for (i = 0; i < n_rates; i++) { 1025 int rate = (rates[i] & 0x7f) * 5; 1026 bool found = false; 1027 1028 for (j = 0; j < sband->n_bitrates; j++) { 1029 if (sband->bitrates[j].bitrate == rate) { 1030 found = true; 1031 *mask |= BIT(j); 1032 break; 1033 } 1034 } 1035 if (!found) 1036 return -EINVAL; 1037 } 1038 1039 /* 1040 * mask must have at least one bit set here since we 1041 * didn't accept a 0-length rates array nor allowed 1042 * entries in the array that didn't exist 1043 */ 1044 1045 return 0; 1046 } 1047