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