2 * Wireless utility functions
4 * Copyright 2007-2009 Johannes Berg <johannes@sipsolutions.net>
5 * Copyright 2013-2014 Intel Mobile Communications GmbH
7 #include <linux/export.h>
8 #include <linux/bitops.h>
9 #include <linux/etherdevice.h>
10 #include <linux/slab.h>
11 #include <net/cfg80211.h>
13 #include <net/dsfield.h>
14 #include <linux/if_vlan.h>
15 #include <linux/mpls.h>
20 struct ieee80211_rate
*
21 ieee80211_get_response_rate(struct ieee80211_supported_band
*sband
,
22 u32 basic_rates
, int bitrate
)
24 struct ieee80211_rate
*result
= &sband
->bitrates
[0];
27 for (i
= 0; i
< sband
->n_bitrates
; i
++) {
28 if (!(basic_rates
& BIT(i
)))
30 if (sband
->bitrates
[i
].bitrate
> bitrate
)
32 result
= &sband
->bitrates
[i
];
37 EXPORT_SYMBOL(ieee80211_get_response_rate
);
39 u32
ieee80211_mandatory_rates(struct ieee80211_supported_band
*sband
,
40 enum nl80211_bss_scan_width scan_width
)
42 struct ieee80211_rate
*bitrates
;
43 u32 mandatory_rates
= 0;
44 enum ieee80211_rate_flags mandatory_flag
;
50 if (sband
->band
== IEEE80211_BAND_2GHZ
) {
51 if (scan_width
== NL80211_BSS_CHAN_WIDTH_5
||
52 scan_width
== NL80211_BSS_CHAN_WIDTH_10
)
53 mandatory_flag
= IEEE80211_RATE_MANDATORY_G
;
55 mandatory_flag
= IEEE80211_RATE_MANDATORY_B
;
57 mandatory_flag
= IEEE80211_RATE_MANDATORY_A
;
60 bitrates
= sband
->bitrates
;
61 for (i
= 0; i
< sband
->n_bitrates
; i
++)
62 if (bitrates
[i
].flags
& mandatory_flag
)
63 mandatory_rates
|= BIT(i
);
64 return mandatory_rates
;
66 EXPORT_SYMBOL(ieee80211_mandatory_rates
);
68 int ieee80211_channel_to_frequency(int chan
, enum ieee80211_band band
)
70 /* see 802.11 17.3.8.3.2 and Annex J
71 * there are overlapping channel numbers in 5GHz and 2GHz bands */
73 return 0; /* not supported */
75 case IEEE80211_BAND_2GHZ
:
79 return 2407 + chan
* 5;
81 case IEEE80211_BAND_5GHZ
:
82 if (chan
>= 182 && chan
<= 196)
83 return 4000 + chan
* 5;
85 return 5000 + chan
* 5;
87 case IEEE80211_BAND_60GHZ
:
89 return 56160 + chan
* 2160;
94 return 0; /* not supported */
96 EXPORT_SYMBOL(ieee80211_channel_to_frequency
);
98 int ieee80211_frequency_to_channel(int freq
)
100 /* see 802.11 17.3.8.3.2 and Annex J */
103 else if (freq
< 2484)
104 return (freq
- 2407) / 5;
105 else if (freq
>= 4910 && freq
<= 4980)
106 return (freq
- 4000) / 5;
107 else if (freq
<= 45000) /* DMG band lower limit */
108 return (freq
- 5000) / 5;
109 else if (freq
>= 58320 && freq
<= 64800)
110 return (freq
- 56160) / 2160;
114 EXPORT_SYMBOL(ieee80211_frequency_to_channel
);
116 struct ieee80211_channel
*__ieee80211_get_channel(struct wiphy
*wiphy
,
119 enum ieee80211_band band
;
120 struct ieee80211_supported_band
*sband
;
123 for (band
= 0; band
< IEEE80211_NUM_BANDS
; band
++) {
124 sband
= wiphy
->bands
[band
];
129 for (i
= 0; i
< sband
->n_channels
; i
++) {
130 if (sband
->channels
[i
].center_freq
== freq
)
131 return &sband
->channels
[i
];
137 EXPORT_SYMBOL(__ieee80211_get_channel
);
139 static void set_mandatory_flags_band(struct ieee80211_supported_band
*sband
,
140 enum ieee80211_band band
)
145 case IEEE80211_BAND_5GHZ
:
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
;
158 case IEEE80211_BAND_2GHZ
:
160 for (i
= 0; i
< sband
->n_bitrates
; i
++) {
161 if (sband
->bitrates
[i
].bitrate
== 10) {
162 sband
->bitrates
[i
].flags
|=
163 IEEE80211_RATE_MANDATORY_B
|
164 IEEE80211_RATE_MANDATORY_G
;
168 if (sband
->bitrates
[i
].bitrate
== 20 ||
169 sband
->bitrates
[i
].bitrate
== 55 ||
170 sband
->bitrates
[i
].bitrate
== 110 ||
171 sband
->bitrates
[i
].bitrate
== 60 ||
172 sband
->bitrates
[i
].bitrate
== 120 ||
173 sband
->bitrates
[i
].bitrate
== 240) {
174 sband
->bitrates
[i
].flags
|=
175 IEEE80211_RATE_MANDATORY_G
;
179 if (sband
->bitrates
[i
].bitrate
!= 10 &&
180 sband
->bitrates
[i
].bitrate
!= 20 &&
181 sband
->bitrates
[i
].bitrate
!= 55 &&
182 sband
->bitrates
[i
].bitrate
!= 110)
183 sband
->bitrates
[i
].flags
|=
184 IEEE80211_RATE_ERP_G
;
186 WARN_ON(want
!= 0 && want
!= 3 && want
!= 6);
188 case IEEE80211_BAND_60GHZ
:
189 /* check for mandatory HT MCS 1..4 */
190 WARN_ON(!sband
->ht_cap
.ht_supported
);
191 WARN_ON((sband
->ht_cap
.mcs
.rx_mask
[0] & 0x1e) != 0x1e);
193 case IEEE80211_NUM_BANDS
:
199 void ieee80211_set_bitrate_flags(struct wiphy
*wiphy
)
201 enum ieee80211_band band
;
203 for (band
= 0; band
< IEEE80211_NUM_BANDS
; band
++)
204 if (wiphy
->bands
[band
])
205 set_mandatory_flags_band(wiphy
->bands
[band
], band
);
208 bool cfg80211_supported_cipher_suite(struct wiphy
*wiphy
, u32 cipher
)
211 for (i
= 0; i
< wiphy
->n_cipher_suites
; i
++)
212 if (cipher
== wiphy
->cipher_suites
[i
])
217 int cfg80211_validate_key_settings(struct cfg80211_registered_device
*rdev
,
218 struct key_params
*params
, int key_idx
,
219 bool pairwise
, const u8
*mac_addr
)
224 if (!pairwise
&& mac_addr
&& !(rdev
->wiphy
.flags
& WIPHY_FLAG_IBSS_RSN
))
227 if (pairwise
&& !mac_addr
)
231 * Disallow pairwise keys with non-zero index unless it's WEP
232 * or a vendor specific cipher (because current deployments use
233 * pairwise WEP keys with non-zero indices and for vendor specific
234 * ciphers this should be validated in the driver or hardware level
235 * - but 802.11i clearly specifies to use zero)
237 if (pairwise
&& key_idx
&&
238 ((params
->cipher
== WLAN_CIPHER_SUITE_TKIP
) ||
239 (params
->cipher
== WLAN_CIPHER_SUITE_CCMP
) ||
240 (params
->cipher
== WLAN_CIPHER_SUITE_AES_CMAC
)))
243 switch (params
->cipher
) {
244 case WLAN_CIPHER_SUITE_WEP40
:
245 if (params
->key_len
!= WLAN_KEY_LEN_WEP40
)
248 case WLAN_CIPHER_SUITE_TKIP
:
249 if (params
->key_len
!= WLAN_KEY_LEN_TKIP
)
252 case WLAN_CIPHER_SUITE_CCMP
:
253 if (params
->key_len
!= WLAN_KEY_LEN_CCMP
)
256 case WLAN_CIPHER_SUITE_WEP104
:
257 if (params
->key_len
!= WLAN_KEY_LEN_WEP104
)
260 case WLAN_CIPHER_SUITE_AES_CMAC
:
261 if (params
->key_len
!= WLAN_KEY_LEN_AES_CMAC
)
266 * We don't know anything about this algorithm,
267 * allow using it -- but the driver must check
268 * all parameters! We still check below whether
269 * or not the driver supports this algorithm,
276 switch (params
->cipher
) {
277 case WLAN_CIPHER_SUITE_WEP40
:
278 case WLAN_CIPHER_SUITE_WEP104
:
279 /* These ciphers do not use key sequence */
281 case WLAN_CIPHER_SUITE_TKIP
:
282 case WLAN_CIPHER_SUITE_CCMP
:
283 case WLAN_CIPHER_SUITE_AES_CMAC
:
284 if (params
->seq_len
!= 6)
290 if (!cfg80211_supported_cipher_suite(&rdev
->wiphy
, params
->cipher
))
296 unsigned int __attribute_const__
ieee80211_hdrlen(__le16 fc
)
298 unsigned int hdrlen
= 24;
300 if (ieee80211_is_data(fc
)) {
301 if (ieee80211_has_a4(fc
))
303 if (ieee80211_is_data_qos(fc
)) {
304 hdrlen
+= IEEE80211_QOS_CTL_LEN
;
305 if (ieee80211_has_order(fc
))
306 hdrlen
+= IEEE80211_HT_CTL_LEN
;
311 if (ieee80211_is_mgmt(fc
)) {
312 if (ieee80211_has_order(fc
))
313 hdrlen
+= IEEE80211_HT_CTL_LEN
;
317 if (ieee80211_is_ctl(fc
)) {
319 * ACK and CTS are 10 bytes, all others 16. To see how
320 * to get this condition consider
321 * subtype mask: 0b0000000011110000 (0x00F0)
322 * ACK subtype: 0b0000000011010000 (0x00D0)
323 * CTS subtype: 0b0000000011000000 (0x00C0)
324 * bits that matter: ^^^ (0x00E0)
325 * value of those: 0b0000000011000000 (0x00C0)
327 if ((fc
& cpu_to_le16(0x00E0)) == cpu_to_le16(0x00C0))
335 EXPORT_SYMBOL(ieee80211_hdrlen
);
337 unsigned int ieee80211_get_hdrlen_from_skb(const struct sk_buff
*skb
)
339 const struct ieee80211_hdr
*hdr
=
340 (const struct ieee80211_hdr
*)skb
->data
;
343 if (unlikely(skb
->len
< 10))
345 hdrlen
= ieee80211_hdrlen(hdr
->frame_control
);
346 if (unlikely(hdrlen
> skb
->len
))
350 EXPORT_SYMBOL(ieee80211_get_hdrlen_from_skb
);
352 unsigned int ieee80211_get_mesh_hdrlen(struct ieee80211s_hdr
*meshhdr
)
354 int ae
= meshhdr
->flags
& MESH_FLAGS_AE
;
355 /* 802.11-2012, 8.2.4.7.3 */
360 case MESH_FLAGS_AE_A4
:
362 case MESH_FLAGS_AE_A5_A6
:
366 EXPORT_SYMBOL(ieee80211_get_mesh_hdrlen
);
368 int ieee80211_data_to_8023(struct sk_buff
*skb
, const u8
*addr
,
369 enum nl80211_iftype iftype
)
371 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*) skb
->data
;
372 u16 hdrlen
, ethertype
;
375 u8 src
[ETH_ALEN
] __aligned(2);
377 if (unlikely(!ieee80211_is_data_present(hdr
->frame_control
)))
380 hdrlen
= ieee80211_hdrlen(hdr
->frame_control
);
382 /* convert IEEE 802.11 header + possible LLC headers into Ethernet
384 * IEEE 802.11 address fields:
385 * ToDS FromDS Addr1 Addr2 Addr3 Addr4
386 * 0 0 DA SA BSSID n/a
387 * 0 1 DA BSSID SA n/a
388 * 1 0 BSSID SA DA n/a
391 memcpy(dst
, ieee80211_get_DA(hdr
), ETH_ALEN
);
392 memcpy(src
, ieee80211_get_SA(hdr
), ETH_ALEN
);
394 switch (hdr
->frame_control
&
395 cpu_to_le16(IEEE80211_FCTL_TODS
| IEEE80211_FCTL_FROMDS
)) {
396 case cpu_to_le16(IEEE80211_FCTL_TODS
):
397 if (unlikely(iftype
!= NL80211_IFTYPE_AP
&&
398 iftype
!= NL80211_IFTYPE_AP_VLAN
&&
399 iftype
!= NL80211_IFTYPE_P2P_GO
))
402 case cpu_to_le16(IEEE80211_FCTL_TODS
| IEEE80211_FCTL_FROMDS
):
403 if (unlikely(iftype
!= NL80211_IFTYPE_WDS
&&
404 iftype
!= NL80211_IFTYPE_MESH_POINT
&&
405 iftype
!= NL80211_IFTYPE_AP_VLAN
&&
406 iftype
!= NL80211_IFTYPE_STATION
))
408 if (iftype
== NL80211_IFTYPE_MESH_POINT
) {
409 struct ieee80211s_hdr
*meshdr
=
410 (struct ieee80211s_hdr
*) (skb
->data
+ hdrlen
);
411 /* make sure meshdr->flags is on the linear part */
412 if (!pskb_may_pull(skb
, hdrlen
+ 1))
414 if (meshdr
->flags
& MESH_FLAGS_AE_A4
)
416 if (meshdr
->flags
& MESH_FLAGS_AE_A5_A6
) {
417 skb_copy_bits(skb
, hdrlen
+
418 offsetof(struct ieee80211s_hdr
, eaddr1
),
420 skb_copy_bits(skb
, hdrlen
+
421 offsetof(struct ieee80211s_hdr
, eaddr2
),
424 hdrlen
+= ieee80211_get_mesh_hdrlen(meshdr
);
427 case cpu_to_le16(IEEE80211_FCTL_FROMDS
):
428 if ((iftype
!= NL80211_IFTYPE_STATION
&&
429 iftype
!= NL80211_IFTYPE_P2P_CLIENT
&&
430 iftype
!= NL80211_IFTYPE_MESH_POINT
) ||
431 (is_multicast_ether_addr(dst
) &&
432 ether_addr_equal(src
, addr
)))
434 if (iftype
== NL80211_IFTYPE_MESH_POINT
) {
435 struct ieee80211s_hdr
*meshdr
=
436 (struct ieee80211s_hdr
*) (skb
->data
+ hdrlen
);
437 /* make sure meshdr->flags is on the linear part */
438 if (!pskb_may_pull(skb
, hdrlen
+ 1))
440 if (meshdr
->flags
& MESH_FLAGS_AE_A5_A6
)
442 if (meshdr
->flags
& MESH_FLAGS_AE_A4
)
443 skb_copy_bits(skb
, hdrlen
+
444 offsetof(struct ieee80211s_hdr
, eaddr1
),
446 hdrlen
+= ieee80211_get_mesh_hdrlen(meshdr
);
450 if (iftype
!= NL80211_IFTYPE_ADHOC
&&
451 iftype
!= NL80211_IFTYPE_STATION
&&
452 iftype
!= NL80211_IFTYPE_OCB
)
457 if (!pskb_may_pull(skb
, hdrlen
+ 8))
460 payload
= skb
->data
+ hdrlen
;
461 ethertype
= (payload
[6] << 8) | payload
[7];
463 if (likely((ether_addr_equal(payload
, rfc1042_header
) &&
464 ethertype
!= ETH_P_AARP
&& ethertype
!= ETH_P_IPX
) ||
465 ether_addr_equal(payload
, bridge_tunnel_header
))) {
466 /* remove RFC1042 or Bridge-Tunnel encapsulation and
467 * replace EtherType */
468 skb_pull(skb
, hdrlen
+ 6);
469 memcpy(skb_push(skb
, ETH_ALEN
), src
, ETH_ALEN
);
470 memcpy(skb_push(skb
, ETH_ALEN
), dst
, ETH_ALEN
);
475 skb_pull(skb
, hdrlen
);
476 len
= htons(skb
->len
);
477 ehdr
= (struct ethhdr
*) skb_push(skb
, sizeof(struct ethhdr
));
478 memcpy(ehdr
->h_dest
, dst
, ETH_ALEN
);
479 memcpy(ehdr
->h_source
, src
, ETH_ALEN
);
484 EXPORT_SYMBOL(ieee80211_data_to_8023
);
486 int ieee80211_data_from_8023(struct sk_buff
*skb
, const u8
*addr
,
487 enum nl80211_iftype iftype
,
488 const u8
*bssid
, bool qos
)
490 struct ieee80211_hdr hdr
;
491 u16 hdrlen
, ethertype
;
493 const u8
*encaps_data
;
494 int encaps_len
, skip_header_bytes
;
498 if (unlikely(skb
->len
< ETH_HLEN
))
501 nh_pos
= skb_network_header(skb
) - skb
->data
;
502 h_pos
= skb_transport_header(skb
) - skb
->data
;
504 /* convert Ethernet header to proper 802.11 header (based on
506 ethertype
= (skb
->data
[12] << 8) | skb
->data
[13];
507 fc
= cpu_to_le16(IEEE80211_FTYPE_DATA
| IEEE80211_STYPE_DATA
);
510 case NL80211_IFTYPE_AP
:
511 case NL80211_IFTYPE_AP_VLAN
:
512 case NL80211_IFTYPE_P2P_GO
:
513 fc
|= cpu_to_le16(IEEE80211_FCTL_FROMDS
);
515 memcpy(hdr
.addr1
, skb
->data
, ETH_ALEN
);
516 memcpy(hdr
.addr2
, addr
, ETH_ALEN
);
517 memcpy(hdr
.addr3
, skb
->data
+ ETH_ALEN
, ETH_ALEN
);
520 case NL80211_IFTYPE_STATION
:
521 case NL80211_IFTYPE_P2P_CLIENT
:
522 fc
|= cpu_to_le16(IEEE80211_FCTL_TODS
);
524 memcpy(hdr
.addr1
, bssid
, ETH_ALEN
);
525 memcpy(hdr
.addr2
, skb
->data
+ ETH_ALEN
, ETH_ALEN
);
526 memcpy(hdr
.addr3
, skb
->data
, ETH_ALEN
);
529 case NL80211_IFTYPE_OCB
:
530 case NL80211_IFTYPE_ADHOC
:
532 memcpy(hdr
.addr1
, skb
->data
, ETH_ALEN
);
533 memcpy(hdr
.addr2
, skb
->data
+ ETH_ALEN
, ETH_ALEN
);
534 memcpy(hdr
.addr3
, bssid
, ETH_ALEN
);
542 fc
|= cpu_to_le16(IEEE80211_STYPE_QOS_DATA
);
546 hdr
.frame_control
= fc
;
550 skip_header_bytes
= ETH_HLEN
;
551 if (ethertype
== ETH_P_AARP
|| ethertype
== ETH_P_IPX
) {
552 encaps_data
= bridge_tunnel_header
;
553 encaps_len
= sizeof(bridge_tunnel_header
);
554 skip_header_bytes
-= 2;
555 } else if (ethertype
>= ETH_P_802_3_MIN
) {
556 encaps_data
= rfc1042_header
;
557 encaps_len
= sizeof(rfc1042_header
);
558 skip_header_bytes
-= 2;
564 skb_pull(skb
, skip_header_bytes
);
565 nh_pos
-= skip_header_bytes
;
566 h_pos
-= skip_header_bytes
;
568 head_need
= hdrlen
+ encaps_len
- skb_headroom(skb
);
570 if (head_need
> 0 || skb_cloned(skb
)) {
571 head_need
= max(head_need
, 0);
575 if (pskb_expand_head(skb
, head_need
, 0, GFP_ATOMIC
))
578 skb
->truesize
+= head_need
;
582 memcpy(skb_push(skb
, encaps_len
), encaps_data
, encaps_len
);
583 nh_pos
+= encaps_len
;
587 memcpy(skb_push(skb
, hdrlen
), &hdr
, hdrlen
);
592 /* Update skb pointers to various headers since this modified frame
593 * is going to go through Linux networking code that may potentially
594 * need things like pointer to IP header. */
595 skb_set_mac_header(skb
, 0);
596 skb_set_network_header(skb
, nh_pos
);
597 skb_set_transport_header(skb
, h_pos
);
601 EXPORT_SYMBOL(ieee80211_data_from_8023
);
604 void ieee80211_amsdu_to_8023s(struct sk_buff
*skb
, struct sk_buff_head
*list
,
605 const u8
*addr
, enum nl80211_iftype iftype
,
606 const unsigned int extra_headroom
,
607 bool has_80211_header
)
609 struct sk_buff
*frame
= NULL
;
612 const struct ethhdr
*eth
;
614 u8 dst
[ETH_ALEN
], src
[ETH_ALEN
];
616 if (has_80211_header
) {
617 err
= ieee80211_data_to_8023(skb
, addr
, iftype
);
621 /* skip the wrapping header */
622 eth
= (struct ethhdr
*) skb_pull(skb
, sizeof(struct ethhdr
));
626 eth
= (struct ethhdr
*) skb
->data
;
629 while (skb
!= frame
) {
631 __be16 len
= eth
->h_proto
;
632 unsigned int subframe_len
= sizeof(struct ethhdr
) + ntohs(len
);
634 remaining
= skb
->len
;
635 memcpy(dst
, eth
->h_dest
, ETH_ALEN
);
636 memcpy(src
, eth
->h_source
, ETH_ALEN
);
638 padding
= (4 - subframe_len
) & 0x3;
639 /* the last MSDU has no padding */
640 if (subframe_len
> remaining
)
643 skb_pull(skb
, sizeof(struct ethhdr
));
644 /* reuse skb for the last subframe */
645 if (remaining
<= subframe_len
+ padding
)
648 unsigned int hlen
= ALIGN(extra_headroom
, 4);
650 * Allocate and reserve two bytes more for payload
651 * alignment since sizeof(struct ethhdr) is 14.
653 frame
= dev_alloc_skb(hlen
+ subframe_len
+ 2);
657 skb_reserve(frame
, hlen
+ sizeof(struct ethhdr
) + 2);
658 memcpy(skb_put(frame
, ntohs(len
)), skb
->data
,
661 eth
= (struct ethhdr
*)skb_pull(skb
, ntohs(len
) +
664 dev_kfree_skb(frame
);
669 skb_reset_network_header(frame
);
670 frame
->dev
= skb
->dev
;
671 frame
->priority
= skb
->priority
;
673 payload
= frame
->data
;
674 ethertype
= (payload
[6] << 8) | payload
[7];
676 if (likely((ether_addr_equal(payload
, rfc1042_header
) &&
677 ethertype
!= ETH_P_AARP
&& ethertype
!= ETH_P_IPX
) ||
678 ether_addr_equal(payload
, bridge_tunnel_header
))) {
679 /* remove RFC1042 or Bridge-Tunnel
680 * encapsulation and replace EtherType */
682 memcpy(skb_push(frame
, ETH_ALEN
), src
, ETH_ALEN
);
683 memcpy(skb_push(frame
, ETH_ALEN
), dst
, ETH_ALEN
);
685 memcpy(skb_push(frame
, sizeof(__be16
)), &len
,
687 memcpy(skb_push(frame
, ETH_ALEN
), src
, ETH_ALEN
);
688 memcpy(skb_push(frame
, ETH_ALEN
), dst
, ETH_ALEN
);
690 __skb_queue_tail(list
, frame
);
696 __skb_queue_purge(list
);
700 EXPORT_SYMBOL(ieee80211_amsdu_to_8023s
);
702 /* Given a data frame determine the 802.1p/1d tag to use. */
703 unsigned int cfg80211_classify8021d(struct sk_buff
*skb
,
704 struct cfg80211_qos_map
*qos_map
)
707 unsigned char vlan_priority
;
709 /* skb->priority values from 256->263 are magic values to
710 * directly indicate a specific 802.1d priority. This is used
711 * to allow 802.1d priority to be passed directly in from VLAN
714 if (skb
->priority
>= 256 && skb
->priority
<= 263)
715 return skb
->priority
- 256;
717 if (vlan_tx_tag_present(skb
)) {
718 vlan_priority
= (vlan_tx_tag_get(skb
) & VLAN_PRIO_MASK
)
720 if (vlan_priority
> 0)
721 return vlan_priority
;
724 switch (skb
->protocol
) {
725 case htons(ETH_P_IP
):
726 dscp
= ipv4_get_dsfield(ip_hdr(skb
)) & 0xfc;
728 case htons(ETH_P_IPV6
):
729 dscp
= ipv6_get_dsfield(ipv6_hdr(skb
)) & 0xfc;
731 case htons(ETH_P_MPLS_UC
):
732 case htons(ETH_P_MPLS_MC
): {
733 struct mpls_label mpls_tmp
, *mpls
;
735 mpls
= skb_header_pointer(skb
, sizeof(struct ethhdr
),
736 sizeof(*mpls
), &mpls_tmp
);
740 return (ntohl(mpls
->entry
) & MPLS_LS_TC_MASK
)
743 case htons(ETH_P_80221
):
744 /* 802.21 is always network control traffic */
751 unsigned int i
, tmp_dscp
= dscp
>> 2;
753 for (i
= 0; i
< qos_map
->num_des
; i
++) {
754 if (tmp_dscp
== qos_map
->dscp_exception
[i
].dscp
)
755 return qos_map
->dscp_exception
[i
].up
;
758 for (i
= 0; i
< 8; i
++) {
759 if (tmp_dscp
>= qos_map
->up
[i
].low
&&
760 tmp_dscp
<= qos_map
->up
[i
].high
)
767 EXPORT_SYMBOL(cfg80211_classify8021d
);
769 const u8
*ieee80211_bss_get_ie(struct cfg80211_bss
*bss
, u8 ie
)
771 const struct cfg80211_bss_ies
*ies
;
773 ies
= rcu_dereference(bss
->ies
);
777 return cfg80211_find_ie(ie
, ies
->data
, ies
->len
);
779 EXPORT_SYMBOL(ieee80211_bss_get_ie
);
781 void cfg80211_upload_connect_keys(struct wireless_dev
*wdev
)
783 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wdev
->wiphy
);
784 struct net_device
*dev
= wdev
->netdev
;
787 if (!wdev
->connect_keys
)
790 for (i
= 0; i
< 6; i
++) {
791 if (!wdev
->connect_keys
->params
[i
].cipher
)
793 if (rdev_add_key(rdev
, dev
, i
, false, NULL
,
794 &wdev
->connect_keys
->params
[i
])) {
795 netdev_err(dev
, "failed to set key %d\n", i
);
798 if (wdev
->connect_keys
->def
== i
)
799 if (rdev_set_default_key(rdev
, dev
, i
, true, true)) {
800 netdev_err(dev
, "failed to set defkey %d\n", i
);
803 if (wdev
->connect_keys
->defmgmt
== i
)
804 if (rdev_set_default_mgmt_key(rdev
, dev
, i
))
805 netdev_err(dev
, "failed to set mgtdef %d\n", i
);
808 kzfree(wdev
->connect_keys
);
809 wdev
->connect_keys
= NULL
;
812 void cfg80211_process_wdev_events(struct wireless_dev
*wdev
)
814 struct cfg80211_event
*ev
;
816 const u8
*bssid
= NULL
;
818 spin_lock_irqsave(&wdev
->event_lock
, flags
);
819 while (!list_empty(&wdev
->event_list
)) {
820 ev
= list_first_entry(&wdev
->event_list
,
821 struct cfg80211_event
, list
);
823 spin_unlock_irqrestore(&wdev
->event_lock
, flags
);
827 case EVENT_CONNECT_RESULT
:
828 if (!is_zero_ether_addr(ev
->cr
.bssid
))
829 bssid
= ev
->cr
.bssid
;
830 __cfg80211_connect_result(
832 ev
->cr
.req_ie
, ev
->cr
.req_ie_len
,
833 ev
->cr
.resp_ie
, ev
->cr
.resp_ie_len
,
835 ev
->cr
.status
== WLAN_STATUS_SUCCESS
,
839 __cfg80211_roamed(wdev
, ev
->rm
.bss
, ev
->rm
.req_ie
,
840 ev
->rm
.req_ie_len
, ev
->rm
.resp_ie
,
843 case EVENT_DISCONNECTED
:
844 __cfg80211_disconnected(wdev
->netdev
,
845 ev
->dc
.ie
, ev
->dc
.ie_len
,
846 ev
->dc
.reason
, true);
848 case EVENT_IBSS_JOINED
:
849 __cfg80211_ibss_joined(wdev
->netdev
, ev
->ij
.bssid
,
853 __cfg80211_leave(wiphy_to_rdev(wdev
->wiphy
), wdev
);
860 spin_lock_irqsave(&wdev
->event_lock
, flags
);
862 spin_unlock_irqrestore(&wdev
->event_lock
, flags
);
865 void cfg80211_process_rdev_events(struct cfg80211_registered_device
*rdev
)
867 struct wireless_dev
*wdev
;
871 list_for_each_entry(wdev
, &rdev
->wdev_list
, list
)
872 cfg80211_process_wdev_events(wdev
);
875 int cfg80211_change_iface(struct cfg80211_registered_device
*rdev
,
876 struct net_device
*dev
, enum nl80211_iftype ntype
,
877 u32
*flags
, struct vif_params
*params
)
880 enum nl80211_iftype otype
= dev
->ieee80211_ptr
->iftype
;
884 /* don't support changing VLANs, you just re-create them */
885 if (otype
== NL80211_IFTYPE_AP_VLAN
)
888 /* cannot change into P2P device type */
889 if (ntype
== NL80211_IFTYPE_P2P_DEVICE
)
892 if (!rdev
->ops
->change_virtual_intf
||
893 !(rdev
->wiphy
.interface_modes
& (1 << ntype
)))
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
))
903 if (ntype
!= otype
&& netif_running(dev
)) {
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
);
911 case NL80211_IFTYPE_AP
:
912 cfg80211_stop_ap(rdev
, dev
, true);
914 case NL80211_IFTYPE_ADHOC
:
915 cfg80211_leave_ibss(rdev
, dev
, false);
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
);
924 case NL80211_IFTYPE_MESH_POINT
:
925 /* mesh should be handled? */
931 cfg80211_process_rdev_events(rdev
);
934 err
= rdev_change_virtual_intf(rdev
, dev
, ntype
, flags
, params
);
936 WARN_ON(!err
&& dev
->ieee80211_ptr
->iftype
!= ntype
);
938 if (!err
&& params
&& params
->use_4addr
!= -1)
939 dev
->ieee80211_ptr
->use_4addr
= params
->use_4addr
;
942 dev
->priv_flags
&= ~IFF_DONT_BRIDGE
;
944 case NL80211_IFTYPE_STATION
:
945 if (dev
->ieee80211_ptr
->use_4addr
)
948 case NL80211_IFTYPE_OCB
:
949 case NL80211_IFTYPE_P2P_CLIENT
:
950 case NL80211_IFTYPE_ADHOC
:
951 dev
->priv_flags
|= IFF_DONT_BRIDGE
;
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
:
960 case NL80211_IFTYPE_MONITOR
:
961 /* monitor can't bridge anyway */
963 case NL80211_IFTYPE_UNSPECIFIED
:
964 case NUM_NL80211_IFTYPES
:
967 case NL80211_IFTYPE_P2P_DEVICE
:
973 if (!err
&& ntype
!= otype
&& netif_running(dev
)) {
974 cfg80211_update_iface_num(rdev
, ntype
, 1);
975 cfg80211_update_iface_num(rdev
, otype
, -1);
981 static u32
cfg80211_calculate_bitrate_60g(struct rate_info
*rate
)
983 static const u32 __mcs2bitrate
[] = {
991 [5] = 12512, /* 1251.25 mbps */
1001 [14] = 8662, /* 866.25 mbps */
1011 [24] = 67568, /* 6756.75 mbps */
1022 if (WARN_ON_ONCE(rate
->mcs
>= ARRAY_SIZE(__mcs2bitrate
)))
1025 return __mcs2bitrate
[rate
->mcs
];
1028 static u32
cfg80211_calculate_bitrate_vht(struct rate_info
*rate
)
1030 static const u32 base
[4][10] = {
1079 if (WARN_ON_ONCE(rate
->mcs
> 9))
1082 idx
= rate
->flags
& (RATE_INFO_FLAGS_160_MHZ_WIDTH
|
1083 RATE_INFO_FLAGS_80P80_MHZ_WIDTH
) ? 3 :
1084 rate
->flags
& RATE_INFO_FLAGS_80_MHZ_WIDTH
? 2 :
1085 rate
->flags
& RATE_INFO_FLAGS_40_MHZ_WIDTH
? 1 : 0;
1087 bitrate
= base
[idx
][rate
->mcs
];
1088 bitrate
*= rate
->nss
;
1090 if (rate
->flags
& RATE_INFO_FLAGS_SHORT_GI
)
1091 bitrate
= (bitrate
/ 9) * 10;
1093 /* do NOT round down here */
1094 return (bitrate
+ 50000) / 100000;
1097 u32
cfg80211_calculate_bitrate(struct rate_info
*rate
)
1099 int modulation
, streams
, bitrate
;
1101 if (!(rate
->flags
& RATE_INFO_FLAGS_MCS
) &&
1102 !(rate
->flags
& RATE_INFO_FLAGS_VHT_MCS
))
1103 return rate
->legacy
;
1104 if (rate
->flags
& RATE_INFO_FLAGS_60G
)
1105 return cfg80211_calculate_bitrate_60g(rate
);
1106 if (rate
->flags
& RATE_INFO_FLAGS_VHT_MCS
)
1107 return cfg80211_calculate_bitrate_vht(rate
);
1109 /* the formula below does only work for MCS values smaller than 32 */
1110 if (WARN_ON_ONCE(rate
->mcs
>= 32))
1113 modulation
= rate
->mcs
& 7;
1114 streams
= (rate
->mcs
>> 3) + 1;
1116 bitrate
= (rate
->flags
& RATE_INFO_FLAGS_40_MHZ_WIDTH
) ?
1120 bitrate
*= (modulation
+ 1);
1121 else if (modulation
== 4)
1122 bitrate
*= (modulation
+ 2);
1124 bitrate
*= (modulation
+ 3);
1128 if (rate
->flags
& RATE_INFO_FLAGS_SHORT_GI
)
1129 bitrate
= (bitrate
/ 9) * 10;
1131 /* do NOT round down here */
1132 return (bitrate
+ 50000) / 100000;
1134 EXPORT_SYMBOL(cfg80211_calculate_bitrate
);
1136 int cfg80211_get_p2p_attr(const u8
*ies
, unsigned int len
,
1137 enum ieee80211_p2p_attr_id attr
,
1138 u8
*buf
, unsigned int bufsize
)
1141 u16 attr_remaining
= 0;
1142 bool desired_attr
= false;
1143 u16 desired_len
= 0;
1146 unsigned int iedatalen
;
1153 if (iedatalen
+ 2 > len
)
1156 if (ies
[0] != WLAN_EID_VENDOR_SPECIFIC
)
1164 /* check WFA OUI, P2P subtype */
1165 if (iedata
[0] != 0x50 || iedata
[1] != 0x6f ||
1166 iedata
[2] != 0x9a || iedata
[3] != 0x09)
1172 /* check attribute continuation into this IE */
1173 copy
= min_t(unsigned int, attr_remaining
, iedatalen
);
1174 if (copy
&& desired_attr
) {
1175 desired_len
+= copy
;
1177 memcpy(out
, iedata
, min(bufsize
, copy
));
1178 out
+= min(bufsize
, copy
);
1179 bufsize
-= min(bufsize
, copy
);
1183 if (copy
== attr_remaining
)
1187 attr_remaining
-= copy
;
1194 while (iedatalen
> 0) {
1197 /* P2P attribute ID & size must fit */
1200 desired_attr
= iedata
[0] == attr
;
1201 attr_len
= get_unaligned_le16(iedata
+ 1);
1205 copy
= min_t(unsigned int, attr_len
, iedatalen
);
1208 desired_len
+= copy
;
1210 memcpy(out
, iedata
, min(bufsize
, copy
));
1211 out
+= min(bufsize
, copy
);
1212 bufsize
-= min(bufsize
, copy
);
1215 if (copy
== attr_len
)
1221 attr_remaining
= attr_len
- copy
;
1229 if (attr_remaining
&& desired_attr
)
1234 EXPORT_SYMBOL(cfg80211_get_p2p_attr
);
1236 bool ieee80211_operating_class_to_band(u8 operating_class
,
1237 enum ieee80211_band
*band
)
1239 switch (operating_class
) {
1242 *band
= IEEE80211_BAND_5GHZ
;
1248 *band
= IEEE80211_BAND_2GHZ
;
1251 *band
= IEEE80211_BAND_60GHZ
;
1257 EXPORT_SYMBOL(ieee80211_operating_class_to_band
);
1259 int cfg80211_validate_beacon_int(struct cfg80211_registered_device
*rdev
,
1262 struct wireless_dev
*wdev
;
1268 list_for_each_entry(wdev
, &rdev
->wdev_list
, list
) {
1269 if (!wdev
->beacon_interval
)
1271 if (wdev
->beacon_interval
!= beacon_int
) {
1280 int cfg80211_iter_combinations(struct wiphy
*wiphy
,
1281 const int num_different_channels
,
1282 const u8 radar_detect
,
1283 const int iftype_num
[NUM_NL80211_IFTYPES
],
1284 void (*iter
)(const struct ieee80211_iface_combination
*c
,
1288 const struct ieee80211_regdomain
*regdom
;
1289 enum nl80211_dfs_regions region
= 0;
1291 int num_interfaces
= 0;
1292 u32 used_iftypes
= 0;
1296 regdom
= rcu_dereference(cfg80211_regdomain
);
1298 region
= regdom
->dfs_region
;
1302 for (iftype
= 0; iftype
< NUM_NL80211_IFTYPES
; iftype
++) {
1303 num_interfaces
+= iftype_num
[iftype
];
1304 if (iftype_num
[iftype
] > 0 &&
1305 !(wiphy
->software_iftypes
& BIT(iftype
)))
1306 used_iftypes
|= BIT(iftype
);
1309 for (i
= 0; i
< wiphy
->n_iface_combinations
; i
++) {
1310 const struct ieee80211_iface_combination
*c
;
1311 struct ieee80211_iface_limit
*limits
;
1312 u32 all_iftypes
= 0;
1314 c
= &wiphy
->iface_combinations
[i
];
1316 if (num_interfaces
> c
->max_interfaces
)
1318 if (num_different_channels
> c
->num_different_channels
)
1321 limits
= kmemdup(c
->limits
, sizeof(limits
[0]) * c
->n_limits
,
1326 for (iftype
= 0; iftype
< NUM_NL80211_IFTYPES
; iftype
++) {
1327 if (wiphy
->software_iftypes
& BIT(iftype
))
1329 for (j
= 0; j
< c
->n_limits
; j
++) {
1330 all_iftypes
|= limits
[j
].types
;
1331 if (!(limits
[j
].types
& BIT(iftype
)))
1333 if (limits
[j
].max
< iftype_num
[iftype
])
1335 limits
[j
].max
-= iftype_num
[iftype
];
1339 if (radar_detect
!= (c
->radar_detect_widths
& radar_detect
))
1342 if (radar_detect
&& c
->radar_detect_regions
&&
1343 !(c
->radar_detect_regions
& BIT(region
)))
1346 /* Finally check that all iftypes that we're currently
1347 * using are actually part of this combination. If they
1348 * aren't then we can't use this combination and have
1349 * to continue to the next.
1351 if ((all_iftypes
& used_iftypes
) != used_iftypes
)
1354 /* This combination covered all interface types and
1355 * supported the requested numbers, so we're good.
1365 EXPORT_SYMBOL(cfg80211_iter_combinations
);
1368 cfg80211_iter_sum_ifcombs(const struct ieee80211_iface_combination
*c
,
1375 int cfg80211_check_combinations(struct wiphy
*wiphy
,
1376 const int num_different_channels
,
1377 const u8 radar_detect
,
1378 const int iftype_num
[NUM_NL80211_IFTYPES
])
1382 err
= cfg80211_iter_combinations(wiphy
, num_different_channels
,
1383 radar_detect
, iftype_num
,
1384 cfg80211_iter_sum_ifcombs
, &num
);
1392 EXPORT_SYMBOL(cfg80211_check_combinations
);
1394 int cfg80211_can_use_iftype_chan(struct cfg80211_registered_device
*rdev
,
1395 struct wireless_dev
*wdev
,
1396 enum nl80211_iftype iftype
,
1397 struct ieee80211_channel
*chan
,
1398 enum cfg80211_chan_mode chanmode
,
1401 struct wireless_dev
*wdev_iter
;
1402 int num
[NUM_NL80211_IFTYPES
];
1403 struct ieee80211_channel
1404 *used_channels
[CFG80211_MAX_NUM_DIFFERENT_CHANNELS
];
1405 struct ieee80211_channel
*ch
;
1406 enum cfg80211_chan_mode chmode
;
1407 int num_different_channels
= 0;
1413 if (WARN_ON(hweight32(radar_detect
) > 1))
1416 if (WARN_ON(iftype
>= NUM_NL80211_IFTYPES
))
1419 /* Always allow software iftypes */
1420 if (rdev
->wiphy
.software_iftypes
& BIT(iftype
)) {
1426 memset(num
, 0, sizeof(num
));
1427 memset(used_channels
, 0, sizeof(used_channels
));
1431 /* TODO: We'll probably not need this anymore, since this
1432 * should only be called with CHAN_MODE_UNDEFINED. There are
1433 * still a couple of pending calls where other chanmodes are
1434 * used, but we should get rid of them.
1437 case CHAN_MODE_UNDEFINED
:
1439 case CHAN_MODE_SHARED
:
1441 used_channels
[0] = chan
;
1442 num_different_channels
++;
1444 case CHAN_MODE_EXCLUSIVE
:
1445 num_different_channels
++;
1449 list_for_each_entry(wdev_iter
, &rdev
->wdev_list
, list
) {
1450 if (wdev_iter
== wdev
)
1452 if (wdev_iter
->iftype
== NL80211_IFTYPE_P2P_DEVICE
) {
1453 if (!wdev_iter
->p2p_started
)
1455 } else if (wdev_iter
->netdev
) {
1456 if (!netif_running(wdev_iter
->netdev
))
1462 if (rdev
->wiphy
.software_iftypes
& BIT(wdev_iter
->iftype
))
1466 * We may be holding the "wdev" mutex, but now need to lock
1467 * wdev_iter. This is OK because once we get here wdev_iter
1468 * is not wdev (tested above), but we need to use the nested
1469 * locking for lockdep.
1471 mutex_lock_nested(&wdev_iter
->mtx
, 1);
1472 __acquire(wdev_iter
->mtx
);
1473 cfg80211_get_chan_state(wdev_iter
, &ch
, &chmode
, &radar_detect
);
1474 wdev_unlock(wdev_iter
);
1477 case CHAN_MODE_UNDEFINED
:
1479 case CHAN_MODE_SHARED
:
1480 for (i
= 0; i
< CFG80211_MAX_NUM_DIFFERENT_CHANNELS
; i
++)
1481 if (!used_channels
[i
] || used_channels
[i
] == ch
)
1484 if (i
== CFG80211_MAX_NUM_DIFFERENT_CHANNELS
)
1487 if (used_channels
[i
] == NULL
) {
1488 used_channels
[i
] = ch
;
1489 num_different_channels
++;
1492 case CHAN_MODE_EXCLUSIVE
:
1493 num_different_channels
++;
1497 num
[wdev_iter
->iftype
]++;
1501 if (total
== 1 && !radar_detect
)
1504 return cfg80211_check_combinations(&rdev
->wiphy
, num_different_channels
,
1508 int ieee80211_get_ratemask(struct ieee80211_supported_band
*sband
,
1509 const u8
*rates
, unsigned int n_rates
,
1517 if (n_rates
== 0 || n_rates
> NL80211_MAX_SUPP_RATES
)
1522 for (i
= 0; i
< n_rates
; i
++) {
1523 int rate
= (rates
[i
] & 0x7f) * 5;
1526 for (j
= 0; j
< sband
->n_bitrates
; j
++) {
1527 if (sband
->bitrates
[j
].bitrate
== rate
) {
1538 * mask must have at least one bit set here since we
1539 * didn't accept a 0-length rates array nor allowed
1540 * entries in the array that didn't exist
1546 unsigned int ieee80211_get_num_supported_channels(struct wiphy
*wiphy
)
1548 enum ieee80211_band band
;
1549 unsigned int n_channels
= 0;
1551 for (band
= 0; band
< IEEE80211_NUM_BANDS
; band
++)
1552 if (wiphy
->bands
[band
])
1553 n_channels
+= wiphy
->bands
[band
]->n_channels
;
1557 EXPORT_SYMBOL(ieee80211_get_num_supported_channels
);
1559 int cfg80211_get_station(struct net_device
*dev
, const u8
*mac_addr
,
1560 struct station_info
*sinfo
)
1562 struct cfg80211_registered_device
*rdev
;
1563 struct wireless_dev
*wdev
;
1565 wdev
= dev
->ieee80211_ptr
;
1569 rdev
= wiphy_to_rdev(wdev
->wiphy
);
1570 if (!rdev
->ops
->get_station
)
1573 return rdev_get_station(rdev
, dev
, mac_addr
, sinfo
);
1575 EXPORT_SYMBOL(cfg80211_get_station
);
1577 /* See IEEE 802.1H for LLC/SNAP encapsulation/decapsulation */
1578 /* Ethernet-II snap header (RFC1042 for most EtherTypes) */
1579 const unsigned char rfc1042_header
[] __aligned(2) =
1580 { 0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00 };
1581 EXPORT_SYMBOL(rfc1042_header
);
1583 /* Bridge-Tunnel header (for EtherTypes ETH_P_AARP and ETH_P_IPX) */
1584 const unsigned char bridge_tunnel_header
[] __aligned(2) =
1585 { 0xaa, 0xaa, 0x03, 0x00, 0x00, 0xf8 };
1586 EXPORT_SYMBOL(bridge_tunnel_header
);