1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20#include <linux/compiler.h>
21#include <linux/errno.h>
22#include <linux/if_arp.h>
23#include <linux/in6.h>
24#include <linux/in.h>
25#include <linux/ip.h>
26#include <linux/kernel.h>
27#include <linux/module.h>
28#include <linux/netdevice.h>
29#include <linux/pci.h>
30#include <linux/proc_fs.h>
31#include <linux/skbuff.h>
32#include <linux/slab.h>
33#include <linux/tcp.h>
34#include <linux/types.h>
35#include <linux/wireless.h>
36#include <linux/etherdevice.h>
37#include <linux/uaccess.h>
38#include <linux/ctype.h>
39
40#include "ieee80211.h"
41#include "dot11d.h"
42static inline void ieee80211_monitor_rx(struct ieee80211_device *ieee,
43 struct sk_buff *skb,
44 struct ieee80211_rx_stats *rx_stats)
45{
46 struct rtl_80211_hdr_4addr *hdr = (struct rtl_80211_hdr_4addr *)skb->data;
47 u16 fc = le16_to_cpu(hdr->frame_ctl);
48
49 skb->dev = ieee->dev;
50 skb_reset_mac_header(skb);
51
52 skb_pull(skb, ieee80211_get_hdrlen(fc));
53 skb->pkt_type = PACKET_OTHERHOST;
54 skb->protocol = htons(ETH_P_80211_RAW);
55 memset(skb->cb, 0, sizeof(skb->cb));
56 netif_rx(skb);
57}
58
59
60
61static struct ieee80211_frag_entry *
62ieee80211_frag_cache_find(struct ieee80211_device *ieee, unsigned int seq,
63 unsigned int frag, u8 tid, u8 *src, u8 *dst)
64{
65 struct ieee80211_frag_entry *entry;
66 int i;
67
68 for (i = 0; i < IEEE80211_FRAG_CACHE_LEN; i++) {
69 entry = &ieee->frag_cache[tid][i];
70 if (entry->skb &&
71 time_after(jiffies, entry->first_frag_time + 2 * HZ)) {
72 IEEE80211_DEBUG_FRAG(
73 "expiring fragment cache entry "
74 "seq=%u last_frag=%u\n",
75 entry->seq, entry->last_frag);
76 dev_kfree_skb_any(entry->skb);
77 entry->skb = NULL;
78 }
79
80 if (entry->skb && entry->seq == seq &&
81 (entry->last_frag + 1 == frag || frag == -1) &&
82 memcmp(entry->src_addr, src, ETH_ALEN) == 0 &&
83 memcmp(entry->dst_addr, dst, ETH_ALEN) == 0)
84 return entry;
85 }
86
87 return NULL;
88}
89
90
91static struct sk_buff *
92ieee80211_frag_cache_get(struct ieee80211_device *ieee,
93 struct rtl_80211_hdr_4addr *hdr)
94{
95 struct sk_buff *skb = NULL;
96 u16 fc = le16_to_cpu(hdr->frame_ctl);
97 u16 sc = le16_to_cpu(hdr->seq_ctl);
98 unsigned int frag = WLAN_GET_SEQ_FRAG(sc);
99 unsigned int seq = WLAN_GET_SEQ_SEQ(sc);
100 struct ieee80211_frag_entry *entry;
101 struct rtl_80211_hdr_3addrqos *hdr_3addrqos;
102 struct rtl_80211_hdr_4addrqos *hdr_4addrqos;
103 u8 tid;
104
105 if (((fc & IEEE80211_FCTL_DSTODS) == IEEE80211_FCTL_DSTODS) && IEEE80211_QOS_HAS_SEQ(fc)) {
106 hdr_4addrqos = (struct rtl_80211_hdr_4addrqos *)hdr;
107 tid = le16_to_cpu(hdr_4addrqos->qos_ctl) & IEEE80211_QCTL_TID;
108 tid = UP2AC(tid);
109 tid++;
110 } else if (IEEE80211_QOS_HAS_SEQ(fc)) {
111 hdr_3addrqos = (struct rtl_80211_hdr_3addrqos *)hdr;
112 tid = le16_to_cpu(hdr_3addrqos->qos_ctl) & IEEE80211_QCTL_TID;
113 tid = UP2AC(tid);
114 tid++;
115 } else {
116 tid = 0;
117 }
118
119 if (frag == 0) {
120
121 skb = dev_alloc_skb(ieee->dev->mtu +
122 sizeof(struct rtl_80211_hdr_4addr) +
123 8 +
124 2 +
125 8 +
126 ETH_ALEN +
127 (IEEE80211_QOS_HAS_SEQ(fc) ? 2 : 0) );
128 if (!skb)
129 return NULL;
130
131 entry = &ieee->frag_cache[tid][ieee->frag_next_idx[tid]];
132 ieee->frag_next_idx[tid]++;
133 if (ieee->frag_next_idx[tid] >= IEEE80211_FRAG_CACHE_LEN)
134 ieee->frag_next_idx[tid] = 0;
135
136 if (entry->skb)
137 dev_kfree_skb_any(entry->skb);
138
139 entry->first_frag_time = jiffies;
140 entry->seq = seq;
141 entry->last_frag = frag;
142 entry->skb = skb;
143 memcpy(entry->src_addr, hdr->addr2, ETH_ALEN);
144 memcpy(entry->dst_addr, hdr->addr1, ETH_ALEN);
145 } else {
146
147
148 entry = ieee80211_frag_cache_find(ieee, seq, frag, tid, hdr->addr2,
149 hdr->addr1);
150 if (entry) {
151 entry->last_frag = frag;
152 skb = entry->skb;
153 }
154 }
155
156 return skb;
157}
158
159
160
161static int ieee80211_frag_cache_invalidate(struct ieee80211_device *ieee,
162 struct rtl_80211_hdr_4addr *hdr)
163{
164 u16 fc = le16_to_cpu(hdr->frame_ctl);
165 u16 sc = le16_to_cpu(hdr->seq_ctl);
166 unsigned int seq = WLAN_GET_SEQ_SEQ(sc);
167 struct ieee80211_frag_entry *entry;
168 struct rtl_80211_hdr_3addrqos *hdr_3addrqos;
169 struct rtl_80211_hdr_4addrqos *hdr_4addrqos;
170 u8 tid;
171
172 if (((fc & IEEE80211_FCTL_DSTODS) == IEEE80211_FCTL_DSTODS) && IEEE80211_QOS_HAS_SEQ(fc)) {
173 hdr_4addrqos = (struct rtl_80211_hdr_4addrqos *)hdr;
174 tid = le16_to_cpu(hdr_4addrqos->qos_ctl) & IEEE80211_QCTL_TID;
175 tid = UP2AC(tid);
176 tid++;
177 } else if (IEEE80211_QOS_HAS_SEQ(fc)) {
178 hdr_3addrqos = (struct rtl_80211_hdr_3addrqos *)hdr;
179 tid = le16_to_cpu(hdr_3addrqos->qos_ctl) & IEEE80211_QCTL_TID;
180 tid = UP2AC(tid);
181 tid++;
182 } else {
183 tid = 0;
184 }
185
186 entry = ieee80211_frag_cache_find(ieee, seq, -1, tid, hdr->addr2,
187 hdr->addr1);
188
189 if (!entry) {
190 IEEE80211_DEBUG_FRAG(
191 "could not invalidate fragment cache "
192 "entry (seq=%u)\n", seq);
193 return -1;
194 }
195
196 entry->skb = NULL;
197 return 0;
198}
199
200
201
202
203
204
205
206
207static inline int
208ieee80211_rx_frame_mgmt(struct ieee80211_device *ieee, struct sk_buff *skb,
209 struct ieee80211_rx_stats *rx_stats, u16 type,
210 u16 stype)
211{
212
213
214
215
216 struct rtl_80211_hdr_3addr *hdr = (struct rtl_80211_hdr_3addr *)skb->data;
217
218 rx_stats->len = skb->len;
219 ieee80211_rx_mgt(ieee, (struct rtl_80211_hdr_4addr *)skb->data, rx_stats);
220
221 if ((memcmp(hdr->addr1, ieee->dev->dev_addr, ETH_ALEN))) {
222
223 dev_kfree_skb_any(skb);
224 return 0;
225 }
226
227 ieee80211_rx_frame_softmac(ieee, skb, rx_stats, type, stype);
228
229 dev_kfree_skb_any(skb);
230
231 return 0;
232
233 #ifdef NOT_YET
234 if (ieee->iw_mode == IW_MODE_MASTER) {
235 netdev_dbg(ieee->dev, "Master mode not yet supported.\n");
236 return 0;
237
238
239
240 }
241
242 if (ieee->hostapd && type == IEEE80211_TYPE_MGMT) {
243 if (stype == WLAN_FC_STYPE_BEACON &&
244 ieee->iw_mode == IW_MODE_MASTER) {
245 struct sk_buff *skb2;
246
247
248 skb2 = skb_clone(skb, GFP_ATOMIC);
249 if (skb2)
250 hostap_rx(skb2->dev, skb2, rx_stats);
251 }
252
253
254
255 ieee->apdevstats.rx_packets++;
256 ieee->apdevstats.rx_bytes += skb->len;
257 prism2_rx_80211(ieee->apdev, skb, rx_stats, PRISM2_RX_MGMT);
258 return 0;
259 }
260
261 if (ieee->iw_mode == IW_MODE_MASTER) {
262 if (type != WLAN_FC_TYPE_MGMT && type != WLAN_FC_TYPE_CTRL) {
263 netdev_dbg(skb->dev, "unknown management frame "
264 "(type=0x%02x, stype=0x%02x) dropped\n",
265 type, stype);
266 return -1;
267 }
268
269 hostap_rx(skb->dev, skb, rx_stats);
270 return 0;
271 }
272
273 netdev_dbg(skb->dev, "hostap_rx_frame_mgmt: management frame "
274 "received in non-Host AP mode\n");
275 return -1;
276 #endif
277}
278
279
280
281
282
283static unsigned char rfc1042_header[] = {
284 0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00 };
285
286static unsigned char bridge_tunnel_header[] = {
287 0xaa, 0xaa, 0x03, 0x00, 0x00, 0xf8 };
288
289
290
291static int ieee80211_is_eapol_frame(struct ieee80211_device *ieee,
292 struct sk_buff *skb, size_t hdrlen)
293{
294 struct net_device *dev = ieee->dev;
295 u16 fc, ethertype;
296 struct rtl_80211_hdr_4addr *hdr;
297 u8 *pos;
298
299 if (skb->len < 24)
300 return 0;
301
302 hdr = (struct rtl_80211_hdr_4addr *)skb->data;
303 fc = le16_to_cpu(hdr->frame_ctl);
304
305
306 if ((fc & (IEEE80211_FCTL_TODS | IEEE80211_FCTL_FROMDS)) ==
307 IEEE80211_FCTL_TODS &&
308 memcmp(hdr->addr1, dev->dev_addr, ETH_ALEN) == 0 &&
309 memcmp(hdr->addr3, dev->dev_addr, ETH_ALEN) == 0) {
310
311 } else if ((fc & (IEEE80211_FCTL_TODS | IEEE80211_FCTL_FROMDS)) ==
312 IEEE80211_FCTL_FROMDS &&
313 memcmp(hdr->addr1, dev->dev_addr, ETH_ALEN) == 0) {
314
315 } else
316 return 0;
317
318 if (skb->len < 24 + 8)
319 return 0;
320
321
322
323 pos = skb->data + hdrlen;
324 ethertype = (pos[6] << 8) | pos[7];
325 if (ethertype == ETH_P_PAE)
326 return 1;
327
328 return 0;
329}
330
331
332static inline int
333ieee80211_rx_frame_decrypt(struct ieee80211_device *ieee, struct sk_buff *skb,
334 struct ieee80211_crypt_data *crypt)
335{
336 struct rtl_80211_hdr_4addr *hdr;
337 int res, hdrlen;
338
339 if (!crypt || !crypt->ops->decrypt_mpdu)
340 return 0;
341 if (ieee->hwsec_active) {
342 struct cb_desc *tcb_desc = (struct cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
343 tcb_desc->bHwSec = 1;
344 }
345 hdr = (struct rtl_80211_hdr_4addr *)skb->data;
346 hdrlen = ieee80211_get_hdrlen(le16_to_cpu(hdr->frame_ctl));
347
348 if (ieee->tkip_countermeasures &&
349 strcmp(crypt->ops->name, "TKIP") == 0) {
350 if (net_ratelimit()) {
351 netdev_dbg(ieee->dev, "TKIP countermeasures: dropped "
352 "received packet from %pM\n",
353 hdr->addr2);
354 }
355 return -1;
356 }
357
358 atomic_inc(&crypt->refcnt);
359 res = crypt->ops->decrypt_mpdu(skb, hdrlen, crypt->priv);
360 atomic_dec(&crypt->refcnt);
361 if (res < 0) {
362 IEEE80211_DEBUG_DROP(
363 "decryption failed (SA=%pM"
364 ") res=%d\n", hdr->addr2, res);
365 if (res == -2)
366 IEEE80211_DEBUG_DROP("Decryption failed ICV "
367 "mismatch (key %d)\n",
368 skb->data[hdrlen + 3] >> 6);
369 ieee->ieee_stats.rx_discards_undecryptable++;
370 return -1;
371 }
372
373 return res;
374}
375
376
377
378static inline int
379ieee80211_rx_frame_decrypt_msdu(struct ieee80211_device *ieee, struct sk_buff *skb,
380 int keyidx, struct ieee80211_crypt_data *crypt)
381{
382 struct rtl_80211_hdr_4addr *hdr;
383 int res, hdrlen;
384
385 if (!crypt || !crypt->ops->decrypt_msdu)
386 return 0;
387 if (ieee->hwsec_active) {
388 struct cb_desc *tcb_desc = (struct cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
389 tcb_desc->bHwSec = 1;
390 }
391
392 hdr = (struct rtl_80211_hdr_4addr *)skb->data;
393 hdrlen = ieee80211_get_hdrlen(le16_to_cpu(hdr->frame_ctl));
394
395 atomic_inc(&crypt->refcnt);
396 res = crypt->ops->decrypt_msdu(skb, keyidx, hdrlen, crypt->priv);
397 atomic_dec(&crypt->refcnt);
398 if (res < 0) {
399 netdev_dbg(ieee->dev, "MSDU decryption/MIC verification failed"
400 " (SA=%pM keyidx=%d)\n",
401 hdr->addr2, keyidx);
402 return -1;
403 }
404
405 return 0;
406}
407
408
409
410#define IEEE_PACKET_RETRY_TIME (5 * HZ)
411static int is_duplicate_packet(struct ieee80211_device *ieee,
412 struct rtl_80211_hdr_4addr *header)
413{
414 u16 fc = le16_to_cpu(header->frame_ctl);
415 u16 sc = le16_to_cpu(header->seq_ctl);
416 u16 seq = WLAN_GET_SEQ_SEQ(sc);
417 u16 frag = WLAN_GET_SEQ_FRAG(sc);
418 u16 *last_seq, *last_frag;
419 unsigned long *last_time;
420 struct rtl_80211_hdr_3addrqos *hdr_3addrqos;
421 struct rtl_80211_hdr_4addrqos *hdr_4addrqos;
422 u8 tid;
423
424
425
426 if (((fc & IEEE80211_FCTL_DSTODS) == IEEE80211_FCTL_DSTODS) && IEEE80211_QOS_HAS_SEQ(fc)) {
427 hdr_4addrqos = (struct rtl_80211_hdr_4addrqos *)header;
428 tid = le16_to_cpu(hdr_4addrqos->qos_ctl) & IEEE80211_QCTL_TID;
429 tid = UP2AC(tid);
430 tid++;
431 } else if (IEEE80211_QOS_HAS_SEQ(fc)) {
432 hdr_3addrqos = (struct rtl_80211_hdr_3addrqos *)header;
433 tid = le16_to_cpu(hdr_3addrqos->qos_ctl) & IEEE80211_QCTL_TID;
434 tid = UP2AC(tid);
435 tid++;
436 } else {
437 tid = 0;
438 }
439
440 switch (ieee->iw_mode) {
441 case IW_MODE_ADHOC:
442 {
443 struct list_head *p;
444 struct ieee_ibss_seq *entry = NULL;
445 u8 *mac = header->addr2;
446 int index = mac[5] % IEEE_IBSS_MAC_HASH_SIZE;
447
448 list_for_each(p, &ieee->ibss_mac_hash[index]) {
449 entry = list_entry(p, struct ieee_ibss_seq, list);
450 if (!memcmp(entry->mac, mac, ETH_ALEN))
451 break;
452 }
453
454 if (p == &ieee->ibss_mac_hash[index]) {
455 entry = kmalloc(sizeof(struct ieee_ibss_seq), GFP_ATOMIC);
456 if (!entry)
457 return 0;
458 memcpy(entry->mac, mac, ETH_ALEN);
459 entry->seq_num[tid] = seq;
460 entry->frag_num[tid] = frag;
461 entry->packet_time[tid] = jiffies;
462 list_add(&entry->list, &ieee->ibss_mac_hash[index]);
463 return 0;
464 }
465 last_seq = &entry->seq_num[tid];
466 last_frag = &entry->frag_num[tid];
467 last_time = &entry->packet_time[tid];
468 break;
469 }
470
471 case IW_MODE_INFRA:
472 last_seq = &ieee->last_rxseq_num[tid];
473 last_frag = &ieee->last_rxfrag_num[tid];
474 last_time = &ieee->last_packet_time[tid];
475
476 break;
477 default:
478 return 0;
479 }
480
481
482
483
484 if ((*last_seq == seq) &&
485 time_after(*last_time + IEEE_PACKET_RETRY_TIME, jiffies)) {
486 if (*last_frag == frag)
487 goto drop;
488 if (*last_frag + 1 != frag)
489
490 goto drop;
491 } else
492 *last_seq = seq;
493
494 *last_frag = frag;
495 *last_time = jiffies;
496 return 0;
497
498drop:
499
500
501 return 1;
502}
503
504static bool AddReorderEntry(struct rx_ts_record *pTS, struct rx_reorder_entry *pReorderEntry)
505{
506 struct list_head *pList = &pTS->rx_pending_pkt_list;
507 while (pList->next != &pTS->rx_pending_pkt_list) {
508 if (SN_LESS(pReorderEntry->SeqNum, list_entry(pList->next, struct rx_reorder_entry, List)->SeqNum))
509 pList = pList->next;
510 else if (SN_EQUAL(pReorderEntry->SeqNum, list_entry(pList->next, struct rx_reorder_entry, List)->SeqNum))
511 return false;
512 else
513 break;
514 }
515 pReorderEntry->List.next = pList->next;
516 pReorderEntry->List.next->prev = &pReorderEntry->List;
517 pReorderEntry->List.prev = pList;
518 pList->next = &pReorderEntry->List;
519
520 return true;
521}
522
523static void indicate_packets(struct ieee80211_device *ieee,
524 struct ieee80211_rxb *rxb)
525{
526 struct net_device_stats *stats = &ieee->stats;
527 struct net_device *dev = ieee->dev;
528 u16 ethertype;
529 u8 i;
530
531 for (i = 0; i < rxb->nr_subframes; i++) {
532 struct sk_buff *sub_skb = rxb->subframes[i];
533
534 if (!sub_skb)
535 continue;
536
537
538 ethertype = (sub_skb->data[6] << 8) | sub_skb->data[7];
539 if (sub_skb->len >= 8 &&
540 ((!memcmp(sub_skb->data, rfc1042_header, SNAP_SIZE) &&
541 ethertype != ETH_P_AARP &&
542 ethertype != ETH_P_IPX) ||
543 !memcmp(sub_skb->data, bridge_tunnel_header, SNAP_SIZE))) {
544
545
546 skb_pull(sub_skb, SNAP_SIZE);
547 } else {
548
549 put_unaligned_be16(sub_skb->len, skb_push(sub_skb, 2));
550 }
551 memcpy(skb_push(sub_skb, ETH_ALEN), rxb->src, ETH_ALEN);
552 memcpy(skb_push(sub_skb, ETH_ALEN), rxb->dst, ETH_ALEN);
553
554 stats->rx_packets++;
555 stats->rx_bytes += sub_skb->len;
556 if (is_multicast_ether_addr(rxb->dst))
557 stats->multicast++;
558
559
560 sub_skb->protocol = eth_type_trans(sub_skb, dev);
561 memset(sub_skb->cb, 0, sizeof(sub_skb->cb));
562 sub_skb->dev = dev;
563
564 sub_skb->ip_summed = CHECKSUM_NONE;
565 ieee->last_rx_ps_time = jiffies;
566 netif_rx(sub_skb);
567 }
568}
569
570void ieee80211_indicate_packets(struct ieee80211_device *ieee,
571 struct ieee80211_rxb **prxbIndicateArray,
572 u8 index)
573{
574 u8 i;
575
576 for (i = 0; i < index; i++) {
577 struct ieee80211_rxb *prxb = prxbIndicateArray[i];
578
579 indicate_packets(ieee, prxb);
580 kfree(prxb);
581 prxb = NULL;
582 }
583}
584
585static void RxReorderIndicatePacket(struct ieee80211_device *ieee,
586 struct ieee80211_rxb *prxb,
587 struct rx_ts_record *pTS, u16 SeqNum)
588{
589 PRT_HIGH_THROUGHPUT pHTInfo = ieee->pHTInfo;
590 struct rx_reorder_entry *pReorderEntry = NULL;
591 struct ieee80211_rxb **prxbIndicateArray;
592 u8 WinSize = pHTInfo->RxReorderWinSize;
593 u16 WinEnd = (pTS->rx_indicate_seq + WinSize - 1) % 4096;
594 u8 index = 0;
595 bool bMatchWinStart = false, bPktInBuf = false;
596 IEEE80211_DEBUG(IEEE80211_DL_REORDER, "%s(): Seq is %d,pTS->rx_indicate_seq is %d, WinSize is %d\n", __func__, SeqNum, pTS->rx_indicate_seq, WinSize);
597
598 prxbIndicateArray = kmalloc_array(REORDER_WIN_SIZE,
599 sizeof(struct ieee80211_rxb *),
600 GFP_ATOMIC);
601 if (!prxbIndicateArray)
602 return;
603
604
605 if (pTS->rx_indicate_seq == 0xffff)
606 pTS->rx_indicate_seq = SeqNum;
607
608
609 if (SN_LESS(SeqNum, pTS->rx_indicate_seq)) {
610 IEEE80211_DEBUG(IEEE80211_DL_REORDER, "Packet Drop! IndicateSeq: %d, NewSeq: %d\n",
611 pTS->rx_indicate_seq, SeqNum);
612 pHTInfo->RxReorderDropCounter++;
613 {
614 int i;
615 for (i = 0; i < prxb->nr_subframes; i++)
616 dev_kfree_skb(prxb->subframes[i]);
617
618 kfree(prxb);
619 prxb = NULL;
620 }
621
622 kfree(prxbIndicateArray);
623 return;
624 }
625
626
627
628
629
630
631 if (SN_EQUAL(SeqNum, pTS->rx_indicate_seq)) {
632 pTS->rx_indicate_seq = (pTS->rx_indicate_seq + 1) % 4096;
633 bMatchWinStart = true;
634 } else if (SN_LESS(WinEnd, SeqNum)) {
635 if (SeqNum >= (WinSize - 1))
636 pTS->rx_indicate_seq = SeqNum + 1 - WinSize;
637 else
638 pTS->rx_indicate_seq = 4095 - (WinSize - (SeqNum + 1)) + 1;
639
640 IEEE80211_DEBUG(IEEE80211_DL_REORDER, "Window Shift! IndicateSeq: %d, NewSeq: %d\n", pTS->rx_indicate_seq, SeqNum);
641 }
642
643
644
645
646
647
648
649
650
651
652 if (bMatchWinStart) {
653
654 IEEE80211_DEBUG(IEEE80211_DL_REORDER, "Packets indication!! IndicateSeq: %d, NewSeq: %d\n",\
655 pTS->rx_indicate_seq, SeqNum);
656 prxbIndicateArray[0] = prxb;
657
658 index = 1;
659 } else {
660
661
662 if (!list_empty(&ieee->RxReorder_Unused_List)) {
663 pReorderEntry = list_entry(ieee->RxReorder_Unused_List.next, struct rx_reorder_entry, List);
664 list_del_init(&pReorderEntry->List);
665
666
667 pReorderEntry->SeqNum = SeqNum;
668 pReorderEntry->prxb = prxb;
669
670
671 if (!AddReorderEntry(pTS, pReorderEntry)) {
672 IEEE80211_DEBUG(IEEE80211_DL_REORDER, "%s(): Duplicate packet is dropped!! IndicateSeq: %d, NewSeq: %d\n",
673 __func__, pTS->rx_indicate_seq, SeqNum);
674 list_add_tail(&pReorderEntry->List, &ieee->RxReorder_Unused_List);
675 {
676 int i;
677 for (i = 0; i < prxb->nr_subframes; i++)
678 dev_kfree_skb(prxb->subframes[i]);
679
680 kfree(prxb);
681 prxb = NULL;
682 }
683 } else {
684 IEEE80211_DEBUG(IEEE80211_DL_REORDER,
685 "Pkt insert into buffer!! IndicateSeq: %d, NewSeq: %d\n", pTS->rx_indicate_seq, SeqNum);
686 }
687 } else {
688
689
690
691
692
693 IEEE80211_DEBUG(IEEE80211_DL_ERR, "RxReorderIndicatePacket(): There is no reorder entry!! Packet is dropped!!\n");
694 {
695 int i;
696 for (i = 0; i < prxb->nr_subframes; i++)
697 dev_kfree_skb(prxb->subframes[i]);
698
699 kfree(prxb);
700 prxb = NULL;
701 }
702 }
703 }
704
705
706 while (!list_empty(&pTS->rx_pending_pkt_list)) {
707 IEEE80211_DEBUG(IEEE80211_DL_REORDER, "%s(): start RREORDER indicate\n", __func__);
708 pReorderEntry = list_entry(pTS->rx_pending_pkt_list.prev, struct rx_reorder_entry, List);
709 if (SN_LESS(pReorderEntry->SeqNum, pTS->rx_indicate_seq) ||
710 SN_EQUAL(pReorderEntry->SeqNum, pTS->rx_indicate_seq)) {
711
712 if (index >= REORDER_WIN_SIZE) {
713 IEEE80211_DEBUG(IEEE80211_DL_ERR, "RxReorderIndicatePacket(): Buffer overflow!! \n");
714 bPktInBuf = true;
715 break;
716 }
717
718 list_del_init(&pReorderEntry->List);
719
720 if (SN_EQUAL(pReorderEntry->SeqNum, pTS->rx_indicate_seq))
721 pTS->rx_indicate_seq = (pTS->rx_indicate_seq + 1) % 4096;
722
723 IEEE80211_DEBUG(IEEE80211_DL_REORDER, "Packets indication!! IndicateSeq: %d, NewSeq: %d\n", pTS->rx_indicate_seq, SeqNum);
724 prxbIndicateArray[index] = pReorderEntry->prxb;
725
726 index++;
727
728 list_add_tail(&pReorderEntry->List, &ieee->RxReorder_Unused_List);
729 } else {
730 bPktInBuf = true;
731 break;
732 }
733 }
734
735
736 if (index > 0) {
737
738
739 pTS->rx_timeout_indicate_seq = 0xffff;
740
741
742 if (index > REORDER_WIN_SIZE) {
743 IEEE80211_DEBUG(IEEE80211_DL_ERR, "RxReorderIndicatePacket(): Rx Reorder buffer full!! \n");
744 kfree(prxbIndicateArray);
745 return;
746 }
747 ieee80211_indicate_packets(ieee, prxbIndicateArray, index);
748 }
749
750 if (bPktInBuf && pTS->rx_timeout_indicate_seq == 0xffff) {
751
752 IEEE80211_DEBUG(IEEE80211_DL_REORDER, "%s(): SET rx timeout timer\n", __func__);
753 pTS->rx_timeout_indicate_seq = pTS->rx_indicate_seq;
754 if (timer_pending(&pTS->rx_pkt_pending_timer))
755 del_timer_sync(&pTS->rx_pkt_pending_timer);
756 pTS->rx_pkt_pending_timer.expires = jiffies +
757 msecs_to_jiffies(pHTInfo->RxReorderPendingTime);
758 add_timer(&pTS->rx_pkt_pending_timer);
759 }
760
761 kfree(prxbIndicateArray);
762}
763
764static u8 parse_subframe(struct ieee80211_device *ieee,
765 struct sk_buff *skb,
766 struct ieee80211_rx_stats *rx_stats,
767 struct ieee80211_rxb *rxb, u8 *src, u8 *dst)
768{
769 struct rtl_80211_hdr_3addr *hdr = (struct rtl_80211_hdr_3addr *)skb->data;
770 u16 fc = le16_to_cpu(hdr->frame_ctl);
771
772 u16 LLCOffset = sizeof(struct rtl_80211_hdr_3addr);
773 u16 ChkLength;
774 bool bIsAggregateFrame = false;
775 u16 nSubframe_Length;
776 u8 nPadding_Length = 0;
777 u16 SeqNum = 0;
778
779 struct sk_buff *sub_skb;
780
781 SeqNum = WLAN_GET_SEQ_SEQ(le16_to_cpu(hdr->seq_ctl));
782
783 if ((IEEE80211_QOS_HAS_SEQ(fc)) && \
784 (((frameqos *)(skb->data + IEEE80211_3ADDR_LEN))->field.reserved)) {
785 bIsAggregateFrame = true;
786 }
787
788 if (IEEE80211_QOS_HAS_SEQ(fc))
789 LLCOffset += 2;
790
791 if (rx_stats->bContainHTC)
792 LLCOffset += HTCLNG;
793
794
795 ChkLength = LLCOffset;
796
797 if (skb->len <= ChkLength)
798 return 0;
799
800 skb_pull(skb, LLCOffset);
801
802 if (!bIsAggregateFrame) {
803 rxb->nr_subframes = 1;
804#ifdef JOHN_NOCPY
805 rxb->subframes[0] = skb;
806#else
807 rxb->subframes[0] = skb_copy(skb, GFP_ATOMIC);
808#endif
809
810 memcpy(rxb->src, src, ETH_ALEN);
811 memcpy(rxb->dst, dst, ETH_ALEN);
812
813 return 1;
814 } else {
815 rxb->nr_subframes = 0;
816 memcpy(rxb->src, src, ETH_ALEN);
817 memcpy(rxb->dst, dst, ETH_ALEN);
818 while (skb->len > ETHERNET_HEADER_SIZE) {
819
820 nSubframe_Length = *((u16 *)(skb->data + 12));
821
822 nSubframe_Length = (nSubframe_Length >> 8) + (nSubframe_Length << 8);
823
824 if (skb->len < (ETHERNET_HEADER_SIZE + nSubframe_Length)) {
825 netdev_dbg(ieee->dev, "A-MSDU parse error!! pRfd->nTotalSubframe : %d\n",
826 rxb->nr_subframes);
827 netdev_dbg(ieee->dev, "A-MSDU parse error!! Subframe Length: %d\n", nSubframe_Length);
828 netdev_dbg(ieee->dev, "nRemain_Length is %d and nSubframe_Length is : %d\n", skb->len, nSubframe_Length);
829 netdev_dbg(ieee->dev, "The Packet SeqNum is %d\n", SeqNum);
830 return 0;
831 }
832
833
834 skb_pull(skb, ETHERNET_HEADER_SIZE);
835
836#ifdef JOHN_NOCPY
837 sub_skb = skb_clone(skb, GFP_ATOMIC);
838 sub_skb->len = nSubframe_Length;
839 sub_skb->tail = sub_skb->data + nSubframe_Length;
840#else
841
842 sub_skb = dev_alloc_skb(nSubframe_Length + 12);
843 if (!sub_skb)
844 return 0;
845 skb_reserve(sub_skb, 12);
846 skb_put_data(sub_skb, skb->data, nSubframe_Length);
847#endif
848 rxb->subframes[rxb->nr_subframes++] = sub_skb;
849 if (rxb->nr_subframes >= MAX_SUBFRAME_COUNT) {
850 IEEE80211_DEBUG_RX("ParseSubframe(): Too many Subframes! Packets dropped!\n");
851 break;
852 }
853 skb_pull(skb, nSubframe_Length);
854
855 if (skb->len != 0) {
856 nPadding_Length = 4 - ((nSubframe_Length + ETHERNET_HEADER_SIZE) % 4);
857 if (nPadding_Length == 4)
858 nPadding_Length = 0;
859
860 if (skb->len < nPadding_Length)
861 return 0;
862
863 skb_pull(skb, nPadding_Length);
864 }
865 }
866#ifdef JOHN_NOCPY
867 dev_kfree_skb(skb);
868#endif
869
870
871
872 return rxb->nr_subframes;
873 }
874}
875
876
877
878
879int ieee80211_rx(struct ieee80211_device *ieee, struct sk_buff *skb,
880 struct ieee80211_rx_stats *rx_stats)
881{
882 struct net_device *dev = ieee->dev;
883 struct rtl_80211_hdr_4addr *hdr;
884
885
886 size_t hdrlen;
887 u16 fc, type, stype, sc;
888 struct net_device_stats *stats;
889 unsigned int frag;
890
891 u8 TID = 0;
892 u16 SeqNum = 0;
893 struct rx_ts_record *pTS = NULL;
894
895
896#ifdef NOT_YET
897 struct net_device *wds = NULL;
898 struct net_device *wds = NULL;
899 int from_assoc_ap = 0;
900 void *sta = NULL;
901#endif
902
903 u8 dst[ETH_ALEN];
904 u8 src[ETH_ALEN];
905 u8 bssid[ETH_ALEN];
906 struct ieee80211_crypt_data *crypt = NULL;
907 int keyidx = 0;
908
909 int i;
910 struct ieee80211_rxb *rxb = NULL;
911
912 hdr = (struct rtl_80211_hdr_4addr *)skb->data;
913 stats = &ieee->stats;
914
915 if (skb->len < 10) {
916 netdev_info(dev, "SKB length < 10\n");
917 goto rx_dropped;
918 }
919
920 fc = le16_to_cpu(hdr->frame_ctl);
921 type = WLAN_FC_GET_TYPE(fc);
922 stype = WLAN_FC_GET_STYPE(fc);
923 sc = le16_to_cpu(hdr->seq_ctl);
924
925 frag = WLAN_GET_SEQ_FRAG(sc);
926 hdrlen = ieee80211_get_hdrlen(fc);
927
928 if (HTCCheck(ieee, skb->data)) {
929 if (net_ratelimit())
930 netdev_warn(dev, "find HTCControl\n");
931 hdrlen += 4;
932 rx_stats->bContainHTC = true;
933 }
934
935
936#ifdef NOT_YET
937
938
939#ifdef IW_WIRELESS_SPY
940
941 if (iface->spy_data.spy_number > 0) {
942 struct iw_quality wstats;
943 wstats.level = rx_stats->rssi;
944 wstats.noise = rx_stats->noise;
945 wstats.updated = 6;
946
947 wireless_spy_update(dev, hdr->addr2, &wstats);
948 }
949#endif
950 hostap_update_rx_stats(local->ap, hdr, rx_stats);
951#endif
952
953 if (ieee->iw_mode == IW_MODE_MONITOR) {
954 ieee80211_monitor_rx(ieee, skb, rx_stats);
955 stats->rx_packets++;
956 stats->rx_bytes += skb->len;
957 return 1;
958 }
959
960 if (ieee->host_decrypt) {
961 int idx = 0;
962 if (skb->len >= hdrlen + 3)
963 idx = skb->data[hdrlen + 3] >> 6;
964 crypt = ieee->crypt[idx];
965#ifdef NOT_YET
966 sta = NULL;
967
968
969
970
971
972
973
974
975 if (!(hdr->addr1[0] & 0x01) || local->bcrx_sta_key)
976 (void)hostap_handle_sta_crypto(local, hdr, &crypt,
977 &sta);
978#endif
979
980
981
982 if (crypt && (!crypt->ops || !crypt->ops->decrypt_mpdu))
983 crypt = NULL;
984
985 if (!crypt && (fc & IEEE80211_FCTL_WEP)) {
986
987
988
989
990 IEEE80211_DEBUG_DROP("Decryption failed (not set)"
991 " (SA=%pM)\n",
992 hdr->addr2);
993 ieee->ieee_stats.rx_discards_undecryptable++;
994 goto rx_dropped;
995 }
996 }
997
998 if (skb->len < IEEE80211_DATA_HDR3_LEN)
999 goto rx_dropped;
1000
1001
1002 if ((!ieee->pHTInfo->bCurRxReorderEnable) || !ieee->current_network.qos_data.active || !IsDataFrame(skb->data) || IsLegacyDataFrame(skb->data)) {
1003 if (is_duplicate_packet(ieee, hdr))
1004 goto rx_dropped;
1005
1006 } else {
1007 struct rx_ts_record *pRxTS = NULL;
1008
1009 if (GetTs(
1010 ieee,
1011 (struct ts_common_info **)&pRxTS,
1012 hdr->addr2,
1013 Frame_QoSTID((u8 *)(skb->data)),
1014 RX_DIR,
1015 true)) {
1016
1017
1018 if ((fc & (1 << 11)) &&
1019 (frag == pRxTS->rx_last_frag_num) &&
1020 (WLAN_GET_SEQ_SEQ(sc) == pRxTS->rx_last_seq_num)) {
1021 goto rx_dropped;
1022 } else {
1023 pRxTS->rx_last_frag_num = frag;
1024 pRxTS->rx_last_seq_num = WLAN_GET_SEQ_SEQ(sc);
1025 }
1026 } else {
1027 IEEE80211_DEBUG(IEEE80211_DL_ERR, "%s(): No TS!! Skip the check!!\n", __func__);
1028 goto rx_dropped;
1029 }
1030 }
1031 if (type == IEEE80211_FTYPE_MGMT) {
1032
1033
1034
1035 if (ieee80211_rx_frame_mgmt(ieee, skb, rx_stats, type, stype))
1036 goto rx_dropped;
1037 else
1038 goto rx_exit;
1039 }
1040
1041
1042 switch (fc & (IEEE80211_FCTL_FROMDS | IEEE80211_FCTL_TODS)) {
1043 case IEEE80211_FCTL_FROMDS:
1044 memcpy(dst, hdr->addr1, ETH_ALEN);
1045 memcpy(src, hdr->addr3, ETH_ALEN);
1046 memcpy(bssid, hdr->addr2, ETH_ALEN);
1047 break;
1048 case IEEE80211_FCTL_TODS:
1049 memcpy(dst, hdr->addr3, ETH_ALEN);
1050 memcpy(src, hdr->addr2, ETH_ALEN);
1051 memcpy(bssid, hdr->addr1, ETH_ALEN);
1052 break;
1053 case IEEE80211_FCTL_FROMDS | IEEE80211_FCTL_TODS:
1054 if (skb->len < IEEE80211_DATA_HDR4_LEN)
1055 goto rx_dropped;
1056 memcpy(dst, hdr->addr3, ETH_ALEN);
1057 memcpy(src, hdr->addr4, ETH_ALEN);
1058 memcpy(bssid, ieee->current_network.bssid, ETH_ALEN);
1059 break;
1060 default:
1061 memcpy(dst, hdr->addr1, ETH_ALEN);
1062 memcpy(src, hdr->addr2, ETH_ALEN);
1063 memcpy(bssid, hdr->addr3, ETH_ALEN);
1064 break;
1065 }
1066
1067#ifdef NOT_YET
1068 if (hostap_rx_frame_wds(ieee, hdr, fc, &wds))
1069 goto rx_dropped;
1070 if (wds) {
1071 skb->dev = dev = wds;
1072 stats = hostap_get_stats(dev);
1073 }
1074
1075 if (ieee->iw_mode == IW_MODE_MASTER && !wds &&
1076 (fc & (IEEE80211_FCTL_TODS | IEEE80211_FCTL_FROMDS)) == IEEE80211_FCTL_FROMDS &&
1077 ieee->stadev &&
1078 memcmp(hdr->addr2, ieee->assoc_ap_addr, ETH_ALEN) == 0) {
1079
1080 skb->dev = dev = ieee->stadev;
1081 stats = hostap_get_stats(dev);
1082 from_assoc_ap = 1;
1083 }
1084
1085 if ((ieee->iw_mode == IW_MODE_MASTER ||
1086 ieee->iw_mode == IW_MODE_REPEAT) &&
1087 !from_assoc_ap) {
1088 switch (hostap_handle_sta_rx(ieee, dev, skb, rx_stats,
1089 wds)) {
1090 case AP_RX_CONTINUE_NOT_AUTHORIZED:
1091 case AP_RX_CONTINUE:
1092 break;
1093 case AP_RX_DROP:
1094 goto rx_dropped;
1095 case AP_RX_EXIT:
1096 goto rx_exit;
1097 }
1098 }
1099#endif
1100
1101
1102
1103 if (stype != IEEE80211_STYPE_DATA &&
1104 stype != IEEE80211_STYPE_DATA_CFACK &&
1105 stype != IEEE80211_STYPE_DATA_CFPOLL &&
1106 stype != IEEE80211_STYPE_DATA_CFACKPOLL &&
1107 stype != IEEE80211_STYPE_QOS_DATA
1108 ) {
1109 if (stype != IEEE80211_STYPE_NULLFUNC)
1110 IEEE80211_DEBUG_DROP(
1111 "RX: dropped data frame "
1112 "with no data (type=0x%02x, "
1113 "subtype=0x%02x, len=%d)\n",
1114 type, stype, skb->len);
1115 goto rx_dropped;
1116 }
1117 if (memcmp(bssid, ieee->current_network.bssid, ETH_ALEN))
1118 goto rx_dropped;
1119
1120
1121
1122 if (ieee->host_decrypt && (fc & IEEE80211_FCTL_WEP) &&
1123 (keyidx = ieee80211_rx_frame_decrypt(ieee, skb, crypt)) < 0) {
1124 netdev_dbg(ieee->dev, "decrypt frame error\n");
1125 goto rx_dropped;
1126 }
1127
1128
1129 hdr = (struct rtl_80211_hdr_4addr *)skb->data;
1130
1131
1132
1133
1134 if ((frag != 0 || (fc & IEEE80211_FCTL_MOREFRAGS))) {
1135 int flen;
1136 struct sk_buff *frag_skb = ieee80211_frag_cache_get(ieee, hdr);
1137 IEEE80211_DEBUG_FRAG("Rx Fragment received (%u)\n", frag);
1138
1139 if (!frag_skb) {
1140 IEEE80211_DEBUG(IEEE80211_DL_RX | IEEE80211_DL_FRAG,
1141 "Rx cannot get skb from fragment "
1142 "cache (morefrag=%d seq=%u frag=%u)\n",
1143 (fc & IEEE80211_FCTL_MOREFRAGS) != 0,
1144 WLAN_GET_SEQ_SEQ(sc), frag);
1145 goto rx_dropped;
1146 }
1147 flen = skb->len;
1148 if (frag != 0)
1149 flen -= hdrlen;
1150
1151 if (frag_skb->tail + flen > frag_skb->end) {
1152 netdev_warn(dev, "host decrypted and "
1153 "reassembled frame did not fit skb\n");
1154 ieee80211_frag_cache_invalidate(ieee, hdr);
1155 goto rx_dropped;
1156 }
1157
1158 if (frag == 0) {
1159
1160
1161 skb_put_data(frag_skb, skb->data, flen);
1162 } else {
1163
1164
1165 skb_put_data(frag_skb, skb->data + hdrlen, flen);
1166 }
1167 dev_kfree_skb_any(skb);
1168 skb = NULL;
1169
1170 if (fc & IEEE80211_FCTL_MOREFRAGS) {
1171
1172
1173
1174 goto rx_exit;
1175 }
1176
1177
1178
1179 skb = frag_skb;
1180 hdr = (struct rtl_80211_hdr_4addr *)skb->data;
1181 ieee80211_frag_cache_invalidate(ieee, hdr);
1182 }
1183
1184
1185
1186 if (ieee->host_decrypt && (fc & IEEE80211_FCTL_WEP) &&
1187 ieee80211_rx_frame_decrypt_msdu(ieee, skb, keyidx, crypt)) {
1188 netdev_dbg(ieee->dev, "==>decrypt msdu error\n");
1189 goto rx_dropped;
1190 }
1191
1192
1193 ieee->LinkDetectInfo.NumRecvDataInPeriod++;
1194 ieee->LinkDetectInfo.NumRxOkInPeriod++;
1195
1196 hdr = (struct rtl_80211_hdr_4addr *)skb->data;
1197 if (crypt && !(fc & IEEE80211_FCTL_WEP) && !ieee->open_wep) {
1198 if (
1199 ieee80211_is_eapol_frame(ieee, skb, hdrlen)) {
1200
1201#ifdef CONFIG_IEEE80211_DEBUG
1202
1203
1204 struct eapol *eap = (struct eapol *)(skb->data +
1205 24);
1206 IEEE80211_DEBUG_EAP("RX: IEEE 802.1X EAPOL frame: %s\n",
1207 eap_get_type(eap->type));
1208#endif
1209 } else {
1210 IEEE80211_DEBUG_DROP(
1211 "encryption configured, but RX "
1212 "frame not encrypted (SA=%pM)\n",
1213 hdr->addr2);
1214 goto rx_dropped;
1215 }
1216 }
1217
1218#ifdef CONFIG_IEEE80211_DEBUG
1219 if (crypt && !(fc & IEEE80211_FCTL_WEP) &&
1220 ieee80211_is_eapol_frame(ieee, skb, hdrlen)) {
1221 struct eapol *eap = (struct eapol *)(skb->data +
1222 24);
1223 IEEE80211_DEBUG_EAP("RX: IEEE 802.1X EAPOL frame: %s\n",
1224 eap_get_type(eap->type));
1225 }
1226#endif
1227
1228 if (crypt && !(fc & IEEE80211_FCTL_WEP) && !ieee->open_wep &&
1229 !ieee80211_is_eapol_frame(ieee, skb, hdrlen)) {
1230 IEEE80211_DEBUG_DROP(
1231 "dropped unencrypted RX data "
1232 "frame from %pM"
1233 " (drop_unencrypted=1)\n",
1234 hdr->addr2);
1235 goto rx_dropped;
1236 }
1237
1238
1239
1240
1241
1242
1243 if (ieee->current_network.qos_data.active && IsQoSDataFrame(skb->data)
1244 && !is_multicast_ether_addr(hdr->addr1)) {
1245 TID = Frame_QoSTID(skb->data);
1246 SeqNum = WLAN_GET_SEQ_SEQ(sc);
1247 GetTs(ieee, (struct ts_common_info **)&pTS, hdr->addr2, TID, RX_DIR, true);
1248 if (TID != 0 && TID != 3)
1249 ieee->bis_any_nonbepkts = true;
1250 }
1251
1252
1253
1254 rxb = kmalloc(sizeof(struct ieee80211_rxb), GFP_ATOMIC);
1255 if (!rxb)
1256 goto rx_dropped;
1257
1258
1259 if (parse_subframe(ieee, skb, rx_stats, rxb, src, dst) == 0) {
1260
1261 for (i = 0; i < rxb->nr_subframes; i++)
1262 dev_kfree_skb(rxb->subframes[i]);
1263
1264 kfree(rxb);
1265 rxb = NULL;
1266 goto rx_dropped;
1267 }
1268
1269
1270 if (!ieee->pHTInfo->bCurRxReorderEnable || !pTS) {
1271 indicate_packets(ieee, rxb);
1272 kfree(rxb);
1273 rxb = NULL;
1274
1275 } else {
1276 IEEE80211_DEBUG(IEEE80211_DL_REORDER, "%s(): REORDER ENABLE AND PTS not NULL, and we will enter RxReorderIndicatePacket()\n", __func__);
1277 RxReorderIndicatePacket(ieee, rxb, pTS, SeqNum);
1278 }
1279#ifndef JOHN_NOCPY
1280 dev_kfree_skb(skb);
1281#endif
1282
1283 rx_exit:
1284#ifdef NOT_YET
1285 if (sta)
1286 hostap_handle_sta_release(sta);
1287#endif
1288 return 1;
1289
1290 rx_dropped:
1291 kfree(rxb);
1292 rxb = NULL;
1293 stats->rx_dropped++;
1294
1295
1296
1297
1298 return 0;
1299}
1300EXPORT_SYMBOL(ieee80211_rx);
1301
1302#define MGMT_FRAME_FIXED_PART_LENGTH 0x24
1303
1304static u8 qos_oui[QOS_OUI_LEN] = { 0x00, 0x50, 0xF2 };
1305
1306
1307
1308
1309
1310static int ieee80211_verify_qos_info(struct ieee80211_qos_information_element
1311 *info_element, int sub_type)
1312{
1313 if (info_element->elementID != QOS_ELEMENT_ID)
1314 return -1;
1315 if (info_element->qui_subtype != sub_type)
1316 return -1;
1317 if (memcmp(info_element->qui, qos_oui, QOS_OUI_LEN))
1318 return -1;
1319 if (info_element->qui_type != QOS_OUI_TYPE)
1320 return -1;
1321 if (info_element->version != QOS_VERSION_1)
1322 return -1;
1323
1324 return 0;
1325}
1326
1327
1328
1329
1330
1331static int ieee80211_read_qos_param_element(
1332 struct ieee80211_qos_parameter_info *element_param,
1333 struct ieee80211_info_element *info_element)
1334{
1335 size_t size = sizeof(*element_param);
1336
1337 if (!element_param || !info_element || info_element->len != size - 2)
1338 return -1;
1339
1340 memcpy(element_param, info_element, size);
1341 return ieee80211_verify_qos_info(&element_param->info_element,
1342 QOS_OUI_PARAM_SUB_TYPE);
1343}
1344
1345
1346
1347
1348static int ieee80211_read_qos_info_element(
1349 struct ieee80211_qos_information_element *element_info,
1350 struct ieee80211_info_element *info_element)
1351{
1352 size_t size = sizeof(*element_info);
1353
1354 if (!element_info || !info_element || info_element->len != size - 2)
1355 return -1;
1356
1357 memcpy(element_info, info_element, size);
1358 return ieee80211_verify_qos_info(element_info, QOS_OUI_INFO_SUB_TYPE);
1359}
1360
1361
1362
1363
1364
1365static int ieee80211_qos_convert_ac_to_parameters(
1366 struct ieee80211_qos_parameter_info *param_elm,
1367 struct ieee80211_qos_parameters *qos_param)
1368{
1369 int i;
1370 struct ieee80211_qos_ac_parameter *ac_params;
1371 u8 aci;
1372
1373
1374
1375 for (i = 0; i < QOS_QUEUE_NUM; i++) {
1376 ac_params = &(param_elm->ac_params_record[i]);
1377
1378 aci = (ac_params->aci_aifsn & 0x60) >> 5;
1379
1380 if (aci >= QOS_QUEUE_NUM)
1381 continue;
1382 qos_param->aifs[aci] = (ac_params->aci_aifsn) & 0x0f;
1383
1384
1385 qos_param->aifs[aci] = (qos_param->aifs[aci] < 2) ? 2 : qos_param->aifs[aci];
1386
1387 qos_param->cw_min[aci] =
1388 cpu_to_le16(ac_params->ecw_min_max & 0x0F);
1389
1390 qos_param->cw_max[aci] =
1391 cpu_to_le16((ac_params->ecw_min_max & 0xF0) >> 4);
1392
1393 qos_param->flag[aci] =
1394 (ac_params->aci_aifsn & 0x10) ? 0x01 : 0x00;
1395 qos_param->tx_op_limit[aci] = ac_params->tx_op_limit;
1396 }
1397 return 0;
1398}
1399
1400
1401
1402
1403
1404
1405static int ieee80211_parse_qos_info_param_IE(struct ieee80211_info_element
1406 *info_element,
1407 struct ieee80211_network *network)
1408{
1409 int rc = 0;
1410 struct ieee80211_qos_parameters *qos_param = NULL;
1411 struct ieee80211_qos_information_element qos_info_element;
1412
1413 rc = ieee80211_read_qos_info_element(&qos_info_element, info_element);
1414
1415 if (rc == 0) {
1416 network->qos_data.param_count = qos_info_element.ac_info & 0x0F;
1417 network->flags |= NETWORK_HAS_QOS_INFORMATION;
1418 } else {
1419 struct ieee80211_qos_parameter_info param_element;
1420
1421 rc = ieee80211_read_qos_param_element(¶m_element,
1422 info_element);
1423 if (rc == 0) {
1424 qos_param = &(network->qos_data.parameters);
1425 ieee80211_qos_convert_ac_to_parameters(¶m_element,
1426 qos_param);
1427 network->flags |= NETWORK_HAS_QOS_PARAMETERS;
1428 network->qos_data.param_count =
1429 param_element.info_element.ac_info & 0x0F;
1430 }
1431 }
1432
1433 if (rc == 0) {
1434 IEEE80211_DEBUG_QOS("QoS is supported\n");
1435 network->qos_data.supported = 1;
1436 }
1437 return rc;
1438}
1439
1440#ifdef CONFIG_IEEE80211_DEBUG
1441#define MFIE_STRING(x) case MFIE_TYPE_ ##x: return #x
1442
1443static const char *get_info_element_string(u16 id)
1444{
1445 switch (id) {
1446 MFIE_STRING(SSID);
1447 MFIE_STRING(RATES);
1448 MFIE_STRING(FH_SET);
1449 MFIE_STRING(DS_SET);
1450 MFIE_STRING(CF_SET);
1451 MFIE_STRING(TIM);
1452 MFIE_STRING(IBSS_SET);
1453 MFIE_STRING(COUNTRY);
1454 MFIE_STRING(HOP_PARAMS);
1455 MFIE_STRING(HOP_TABLE);
1456 MFIE_STRING(REQUEST);
1457 MFIE_STRING(CHALLENGE);
1458 MFIE_STRING(POWER_CONSTRAINT);
1459 MFIE_STRING(POWER_CAPABILITY);
1460 MFIE_STRING(TPC_REQUEST);
1461 MFIE_STRING(TPC_REPORT);
1462 MFIE_STRING(SUPP_CHANNELS);
1463 MFIE_STRING(CSA);
1464 MFIE_STRING(MEASURE_REQUEST);
1465 MFIE_STRING(MEASURE_REPORT);
1466 MFIE_STRING(QUIET);
1467 MFIE_STRING(IBSS_DFS);
1468
1469 MFIE_STRING(RSN);
1470 MFIE_STRING(RATES_EX);
1471 MFIE_STRING(GENERIC);
1472 MFIE_STRING(QOS_PARAMETER);
1473 default:
1474 return "UNKNOWN";
1475 }
1476}
1477#endif
1478
1479static inline void ieee80211_extract_country_ie(
1480 struct ieee80211_device *ieee,
1481 struct ieee80211_info_element *info_element,
1482 struct ieee80211_network *network,
1483 u8 *addr2
1484)
1485{
1486 if (IS_DOT11D_ENABLE(ieee)) {
1487 if (info_element->len != 0) {
1488 memcpy(network->CountryIeBuf, info_element->data, info_element->len);
1489 network->CountryIeLen = info_element->len;
1490
1491 if (!IS_COUNTRY_IE_VALID(ieee)) {
1492 dot11d_update_country_ie(ieee, addr2, info_element->len, info_element->data);
1493 }
1494 }
1495
1496
1497
1498
1499
1500
1501 if (IS_EQUAL_CIE_SRC(ieee, addr2))
1502 UPDATE_CIE_WATCHDOG(ieee);
1503 }
1504}
1505
1506int ieee80211_parse_info_param(struct ieee80211_device *ieee,
1507 struct ieee80211_info_element *info_element,
1508 u16 length,
1509 struct ieee80211_network *network,
1510 struct ieee80211_rx_stats *stats)
1511{
1512 u8 i;
1513 short offset;
1514 u16 tmp_htcap_len = 0;
1515 u16 tmp_htinfo_len = 0;
1516 u16 ht_realtek_agg_len = 0;
1517 u8 ht_realtek_agg_buf[MAX_IE_LEN];
1518
1519#ifdef CONFIG_IEEE80211_DEBUG
1520 char rates_str[64];
1521 char *p;
1522#endif
1523
1524 while (length >= sizeof(*info_element)) {
1525 if (sizeof(*info_element) + info_element->len > length) {
1526 IEEE80211_DEBUG_MGMT("Info elem: parse failed: "
1527 "info_element->len + 2 > left : "
1528 "info_element->len+2=%zd left=%d, id=%d.\n",
1529 info_element->len +
1530 sizeof(*info_element),
1531 length, info_element->id);
1532
1533
1534
1535 break;
1536 }
1537
1538 switch (info_element->id) {
1539 case MFIE_TYPE_SSID:
1540 if (ieee80211_is_empty_essid(info_element->data,
1541 info_element->len)) {
1542 network->flags |= NETWORK_EMPTY_ESSID;
1543 break;
1544 }
1545
1546 network->ssid_len = min(info_element->len,
1547 (u8)IW_ESSID_MAX_SIZE);
1548 memcpy(network->ssid, info_element->data, network->ssid_len);
1549 if (network->ssid_len < IW_ESSID_MAX_SIZE)
1550 memset(network->ssid + network->ssid_len, 0,
1551 IW_ESSID_MAX_SIZE - network->ssid_len);
1552
1553 IEEE80211_DEBUG_MGMT("MFIE_TYPE_SSID: '%s' len=%d.\n",
1554 network->ssid, network->ssid_len);
1555 break;
1556
1557 case MFIE_TYPE_RATES:
1558#ifdef CONFIG_IEEE80211_DEBUG
1559 p = rates_str;
1560#endif
1561 network->rates_len = min(info_element->len,
1562 MAX_RATES_LENGTH);
1563 for (i = 0; i < network->rates_len; i++) {
1564 network->rates[i] = info_element->data[i];
1565#ifdef CONFIG_IEEE80211_DEBUG
1566 p += scnprintf(p, sizeof(rates_str) -
1567 (p - rates_str), "%02X ",
1568 network->rates[i]);
1569#endif
1570 if (ieee80211_is_ofdm_rate
1571 (info_element->data[i])) {
1572 network->flags |= NETWORK_HAS_OFDM;
1573 if (info_element->data[i] &
1574 IEEE80211_BASIC_RATE_MASK)
1575 network->flags &=
1576 ~NETWORK_HAS_CCK;
1577 }
1578 }
1579
1580 IEEE80211_DEBUG_MGMT("MFIE_TYPE_RATES: '%s' (%d)\n",
1581 rates_str, network->rates_len);
1582 break;
1583
1584 case MFIE_TYPE_RATES_EX:
1585#ifdef CONFIG_IEEE80211_DEBUG
1586 p = rates_str;
1587#endif
1588 network->rates_ex_len = min(info_element->len,
1589 MAX_RATES_EX_LENGTH);
1590 for (i = 0; i < network->rates_ex_len; i++) {
1591 network->rates_ex[i] = info_element->data[i];
1592#ifdef CONFIG_IEEE80211_DEBUG
1593 p += scnprintf(p, sizeof(rates_str) -
1594 (p - rates_str), "%02X ",
1595 network->rates_ex[i]);
1596#endif
1597 if (ieee80211_is_ofdm_rate
1598 (info_element->data[i])) {
1599 network->flags |= NETWORK_HAS_OFDM;
1600 if (info_element->data[i] &
1601 IEEE80211_BASIC_RATE_MASK)
1602 network->flags &=
1603 ~NETWORK_HAS_CCK;
1604 }
1605 }
1606
1607 IEEE80211_DEBUG_MGMT("MFIE_TYPE_RATES_EX: '%s' (%d)\n",
1608 rates_str, network->rates_ex_len);
1609 break;
1610
1611 case MFIE_TYPE_DS_SET:
1612 IEEE80211_DEBUG_MGMT("MFIE_TYPE_DS_SET: %d\n",
1613 info_element->data[0]);
1614 network->channel = info_element->data[0];
1615 break;
1616
1617 case MFIE_TYPE_FH_SET:
1618 IEEE80211_DEBUG_MGMT("MFIE_TYPE_FH_SET: ignored\n");
1619 break;
1620
1621 case MFIE_TYPE_CF_SET:
1622 IEEE80211_DEBUG_MGMT("MFIE_TYPE_CF_SET: ignored\n");
1623 break;
1624
1625 case MFIE_TYPE_TIM:
1626 if (info_element->len < 4)
1627 break;
1628
1629 network->tim.tim_count = info_element->data[0];
1630 network->tim.tim_period = info_element->data[1];
1631
1632 network->dtim_period = info_element->data[1];
1633 if (ieee->state != IEEE80211_LINKED)
1634 break;
1635
1636 network->last_dtim_sta_time[0] = stats->mac_time[0];
1637 network->last_dtim_sta_time[1] = stats->mac_time[1];
1638
1639 network->dtim_data = IEEE80211_DTIM_VALID;
1640
1641 if (info_element->data[0] != 0)
1642 break;
1643
1644 if (info_element->data[2] & 1)
1645 network->dtim_data |= IEEE80211_DTIM_MBCAST;
1646
1647 offset = (info_element->data[2] >> 1) * 2;
1648
1649 if (ieee->assoc_id < 8 * offset ||
1650 ieee->assoc_id > 8 * (offset + info_element->len - 3))
1651
1652 break;
1653
1654 offset = (ieee->assoc_id / 8) - offset;
1655
1656 if (info_element->data[3 + offset] & (1 << (ieee->assoc_id % 8)))
1657 network->dtim_data |= IEEE80211_DTIM_UCAST;
1658
1659
1660 break;
1661
1662 case MFIE_TYPE_ERP:
1663 network->erp_value = info_element->data[0];
1664 network->flags |= NETWORK_HAS_ERP_VALUE;
1665 IEEE80211_DEBUG_MGMT("MFIE_TYPE_ERP_SET: %d\n",
1666 network->erp_value);
1667 break;
1668 case MFIE_TYPE_IBSS_SET:
1669 network->atim_window = info_element->data[0];
1670 IEEE80211_DEBUG_MGMT("MFIE_TYPE_IBSS_SET: %d\n",
1671 network->atim_window);
1672 break;
1673
1674 case MFIE_TYPE_CHALLENGE:
1675 IEEE80211_DEBUG_MGMT("MFIE_TYPE_CHALLENGE: ignored\n");
1676 break;
1677
1678 case MFIE_TYPE_GENERIC:
1679 IEEE80211_DEBUG_MGMT("MFIE_TYPE_GENERIC: %d bytes\n",
1680 info_element->len);
1681 if (!ieee80211_parse_qos_info_param_IE(info_element,
1682 network))
1683 break;
1684
1685 if (info_element->len >= 4 &&
1686 info_element->data[0] == 0x00 &&
1687 info_element->data[1] == 0x50 &&
1688 info_element->data[2] == 0xf2 &&
1689 info_element->data[3] == 0x01) {
1690 network->wpa_ie_len = min(info_element->len + 2,
1691 MAX_WPA_IE_LEN);
1692 memcpy(network->wpa_ie, info_element,
1693 network->wpa_ie_len);
1694 break;
1695 }
1696
1697#ifdef THOMAS_TURBO
1698 if (info_element->len == 7 &&
1699 info_element->data[0] == 0x00 &&
1700 info_element->data[1] == 0xe0 &&
1701 info_element->data[2] == 0x4c &&
1702 info_element->data[3] == 0x01 &&
1703 info_element->data[4] == 0x02) {
1704 network->Turbo_Enable = 1;
1705 }
1706#endif
1707
1708
1709 if (tmp_htcap_len == 0) {
1710 if (info_element->len >= 4 &&
1711 info_element->data[0] == 0x00 &&
1712 info_element->data[1] == 0x90 &&
1713 info_element->data[2] == 0x4c &&
1714 info_element->data[3] == 0x033){
1715
1716 tmp_htcap_len = min(info_element->len, (u8)MAX_IE_LEN);
1717 if (tmp_htcap_len != 0) {
1718 network->bssht.bdHTSpecVer = HT_SPEC_VER_EWC;
1719 network->bssht.bdHTCapLen = tmp_htcap_len > sizeof(network->bssht.bdHTCapBuf) ? \
1720 sizeof(network->bssht.bdHTCapBuf) : tmp_htcap_len;
1721 memcpy(network->bssht.bdHTCapBuf, info_element->data, network->bssht.bdHTCapLen);
1722 }
1723 }
1724 if (tmp_htcap_len != 0)
1725 network->bssht.bdSupportHT = true;
1726 else
1727 network->bssht.bdSupportHT = false;
1728 }
1729
1730
1731 if (tmp_htinfo_len == 0) {
1732 if (info_element->len >= 4 &&
1733 info_element->data[0] == 0x00 &&
1734 info_element->data[1] == 0x90 &&
1735 info_element->data[2] == 0x4c &&
1736 info_element->data[3] == 0x034){
1737
1738 tmp_htinfo_len = min(info_element->len, (u8)MAX_IE_LEN);
1739 if (tmp_htinfo_len != 0) {
1740 network->bssht.bdHTSpecVer = HT_SPEC_VER_EWC;
1741 if (tmp_htinfo_len) {
1742 network->bssht.bdHTInfoLen = tmp_htinfo_len > sizeof(network->bssht.bdHTInfoBuf) ? \
1743 sizeof(network->bssht.bdHTInfoBuf) : tmp_htinfo_len;
1744 memcpy(network->bssht.bdHTInfoBuf, info_element->data, network->bssht.bdHTInfoLen);
1745 }
1746
1747 }
1748
1749 }
1750 }
1751
1752 if (ieee->aggregation) {
1753 if (network->bssht.bdSupportHT) {
1754 if (info_element->len >= 4 &&
1755 info_element->data[0] == 0x00 &&
1756 info_element->data[1] == 0xe0 &&
1757 info_element->data[2] == 0x4c &&
1758 info_element->data[3] == 0x02){
1759
1760 ht_realtek_agg_len = min(info_element->len, (u8)MAX_IE_LEN);
1761 memcpy(ht_realtek_agg_buf, info_element->data, info_element->len);
1762
1763 }
1764 if (ht_realtek_agg_len >= 5) {
1765 network->bssht.bdRT2RTAggregation = true;
1766
1767 if ((ht_realtek_agg_buf[4] == 1) && (ht_realtek_agg_buf[5] & 0x02))
1768 network->bssht.bdRT2RTLongSlotTime = true;
1769 }
1770 }
1771
1772 }
1773
1774
1775 {
1776 if ((info_element->len >= 3 &&
1777 info_element->data[0] == 0x00 &&
1778 info_element->data[1] == 0x05 &&
1779 info_element->data[2] == 0xb5) ||
1780 (info_element->len >= 3 &&
1781 info_element->data[0] == 0x00 &&
1782 info_element->data[1] == 0x0a &&
1783 info_element->data[2] == 0xf7) ||
1784 (info_element->len >= 3 &&
1785 info_element->data[0] == 0x00 &&
1786 info_element->data[1] == 0x10 &&
1787 info_element->data[2] == 0x18)){
1788
1789 network->broadcom_cap_exist = true;
1790
1791 }
1792 }
1793 if (info_element->len >= 3 &&
1794 info_element->data[0] == 0x00 &&
1795 info_element->data[1] == 0x0c &&
1796 info_element->data[2] == 0x43) {
1797 network->ralink_cap_exist = true;
1798 } else
1799 network->ralink_cap_exist = false;
1800
1801 if ((info_element->len >= 3 &&
1802 info_element->data[0] == 0x00 &&
1803 info_element->data[1] == 0x03 &&
1804 info_element->data[2] == 0x7f) ||
1805 (info_element->len >= 3 &&
1806 info_element->data[0] == 0x00 &&
1807 info_element->data[1] == 0x13 &&
1808 info_element->data[2] == 0x74)) {
1809 netdev_dbg(ieee->dev, "========> athros AP is exist\n");
1810 network->atheros_cap_exist = true;
1811 } else
1812 network->atheros_cap_exist = false;
1813
1814 if (info_element->len >= 3 &&
1815 info_element->data[0] == 0x00 &&
1816 info_element->data[1] == 0x40 &&
1817 info_element->data[2] == 0x96) {
1818 network->cisco_cap_exist = true;
1819 } else
1820 network->cisco_cap_exist = false;
1821
1822 if (info_element->len > 4 &&
1823 info_element->data[0] == 0x00 &&
1824 info_element->data[1] == 0x40 &&
1825 info_element->data[2] == 0x96 &&
1826 info_element->data[3] == 0x01) {
1827 if (info_element->len == 6) {
1828 memcpy(network->CcxRmState, &info_element[4], 2);
1829 if (network->CcxRmState[0] != 0)
1830 network->bCcxRmEnable = true;
1831 else
1832 network->bCcxRmEnable = false;
1833
1834
1835
1836 network->MBssidMask = network->CcxRmState[1] & 0x07;
1837 if (network->MBssidMask != 0) {
1838 network->bMBssidValid = true;
1839 network->MBssidMask = 0xff << (network->MBssidMask);
1840 ether_addr_copy(network->MBssid, network->bssid);
1841 network->MBssid[5] &= network->MBssidMask;
1842 } else {
1843 network->bMBssidValid = false;
1844 }
1845 } else {
1846 network->bCcxRmEnable = false;
1847 }
1848 }
1849 if (info_element->len > 4 &&
1850 info_element->data[0] == 0x00 &&
1851 info_element->data[1] == 0x40 &&
1852 info_element->data[2] == 0x96 &&
1853 info_element->data[3] == 0x03) {
1854 if (info_element->len == 5) {
1855 network->bWithCcxVerNum = true;
1856 network->BssCcxVerNumber = info_element->data[4];
1857 } else {
1858 network->bWithCcxVerNum = false;
1859 network->BssCcxVerNumber = 0;
1860 }
1861 }
1862 break;
1863
1864 case MFIE_TYPE_RSN:
1865 IEEE80211_DEBUG_MGMT("MFIE_TYPE_RSN: %d bytes\n",
1866 info_element->len);
1867 network->rsn_ie_len = min(info_element->len + 2,
1868 MAX_WPA_IE_LEN);
1869 memcpy(network->rsn_ie, info_element,
1870 network->rsn_ie_len);
1871 break;
1872
1873
1874 case MFIE_TYPE_HT_CAP:
1875 IEEE80211_DEBUG_SCAN("MFIE_TYPE_HT_CAP: %d bytes\n",
1876 info_element->len);
1877 tmp_htcap_len = min(info_element->len, (u8)MAX_IE_LEN);
1878 if (tmp_htcap_len != 0) {
1879 network->bssht.bdHTSpecVer = HT_SPEC_VER_EWC;
1880 network->bssht.bdHTCapLen = tmp_htcap_len > sizeof(network->bssht.bdHTCapBuf) ? \
1881 sizeof(network->bssht.bdHTCapBuf) : tmp_htcap_len;
1882 memcpy(network->bssht.bdHTCapBuf, info_element->data, network->bssht.bdHTCapLen);
1883
1884
1885
1886
1887 network->bssht.bdSupportHT = true;
1888 } else
1889 network->bssht.bdSupportHT = false;
1890 break;
1891
1892
1893 case MFIE_TYPE_HT_INFO:
1894 IEEE80211_DEBUG_SCAN("MFIE_TYPE_HT_INFO: %d bytes\n",
1895 info_element->len);
1896 tmp_htinfo_len = min(info_element->len, (u8)MAX_IE_LEN);
1897 if (tmp_htinfo_len) {
1898 network->bssht.bdHTSpecVer = HT_SPEC_VER_IEEE;
1899 network->bssht.bdHTInfoLen = tmp_htinfo_len > sizeof(network->bssht.bdHTInfoBuf) ? \
1900 sizeof(network->bssht.bdHTInfoBuf) : tmp_htinfo_len;
1901 memcpy(network->bssht.bdHTInfoBuf, info_element->data, network->bssht.bdHTInfoLen);
1902 }
1903 break;
1904
1905 case MFIE_TYPE_AIRONET:
1906 IEEE80211_DEBUG_SCAN("MFIE_TYPE_AIRONET: %d bytes\n",
1907 info_element->len);
1908 if (info_element->len > IE_CISCO_FLAG_POSITION) {
1909 network->bWithAironetIE = true;
1910
1911
1912
1913
1914 if ((info_element->data[IE_CISCO_FLAG_POSITION] & SUPPORT_CKIP_MIC) ||
1915 (info_element->data[IE_CISCO_FLAG_POSITION] & SUPPORT_CKIP_PK)) {
1916 network->bCkipSupported = true;
1917 } else {
1918 network->bCkipSupported = false;
1919 }
1920 } else {
1921 network->bWithAironetIE = false;
1922 network->bCkipSupported = false;
1923 }
1924 break;
1925 case MFIE_TYPE_QOS_PARAMETER:
1926 netdev_err(ieee->dev,
1927 "QoS Error need to parse QOS_PARAMETER IE\n");
1928 break;
1929
1930 case MFIE_TYPE_COUNTRY:
1931 IEEE80211_DEBUG_SCAN("MFIE_TYPE_COUNTRY: %d bytes\n",
1932 info_element->len);
1933 ieee80211_extract_country_ie(ieee, info_element, network, network->bssid);
1934 break;
1935
1936 default:
1937 IEEE80211_DEBUG_MGMT
1938 ("Unsupported info element: %s (%d)\n",
1939 get_info_element_string(info_element->id),
1940 info_element->id);
1941 break;
1942 }
1943
1944 length -= sizeof(*info_element) + info_element->len;
1945 info_element =
1946 (struct ieee80211_info_element *)&info_element->
1947 data[info_element->len];
1948 }
1949
1950 if (!network->atheros_cap_exist && !network->broadcom_cap_exist &&
1951 !network->cisco_cap_exist && !network->ralink_cap_exist && !network->bssht.bdRT2RTAggregation) {
1952 network->unknown_cap_exist = true;
1953 } else {
1954 network->unknown_cap_exist = false;
1955 }
1956 return 0;
1957}
1958
1959static inline u8 ieee80211_SignalStrengthTranslate(
1960 u8 CurrSS
1961 )
1962{
1963 u8 RetSS;
1964
1965
1966 if (CurrSS >= 71 && CurrSS <= 100) {
1967 RetSS = 90 + ((CurrSS - 70) / 3);
1968 } else if (CurrSS >= 41 && CurrSS <= 70) {
1969 RetSS = 78 + ((CurrSS - 40) / 3);
1970 } else if (CurrSS >= 31 && CurrSS <= 40) {
1971 RetSS = 66 + (CurrSS - 30);
1972 } else if (CurrSS >= 21 && CurrSS <= 30) {
1973 RetSS = 54 + (CurrSS - 20);
1974 } else if (CurrSS >= 5 && CurrSS <= 20) {
1975 RetSS = 42 + (((CurrSS - 5) * 2) / 3);
1976 } else if (CurrSS == 4) {
1977 RetSS = 36;
1978 } else if (CurrSS == 3) {
1979 RetSS = 27;
1980 } else if (CurrSS == 2) {
1981 RetSS = 18;
1982 } else if (CurrSS == 1) {
1983 RetSS = 9;
1984 } else {
1985 RetSS = CurrSS;
1986 }
1987
1988
1989
1990
1991
1992
1993 return RetSS;
1994}
1995
1996
1997static long ieee80211_translate_todbm(u8 signal_strength_index)
1998{
1999 long signal_power;
2000
2001
2002 signal_power = (long)((signal_strength_index + 1) >> 1);
2003 signal_power -= 95;
2004
2005 return signal_power;
2006}
2007
2008static inline int ieee80211_network_init(
2009 struct ieee80211_device *ieee,
2010 struct ieee80211_probe_response *beacon,
2011 struct ieee80211_network *network,
2012 struct ieee80211_rx_stats *stats)
2013{
2014#ifdef CONFIG_IEEE80211_DEBUG
2015
2016
2017#endif
2018
2019 network->qos_data.active = 0;
2020 network->qos_data.supported = 0;
2021 network->qos_data.param_count = 0;
2022 network->qos_data.old_param_count = 0;
2023
2024
2025 memcpy(network->bssid, beacon->header.addr3, ETH_ALEN);
2026 network->capability = le16_to_cpu(beacon->capability);
2027 network->last_scanned = jiffies;
2028 network->time_stamp[0] = le32_to_cpu(beacon->time_stamp[0]);
2029 network->time_stamp[1] = le32_to_cpu(beacon->time_stamp[1]);
2030 network->beacon_interval = le16_to_cpu(beacon->beacon_interval);
2031
2032 network->listen_interval = 0x0A;
2033 network->rates_len = network->rates_ex_len = 0;
2034 network->last_associate = 0;
2035 network->ssid_len = 0;
2036 network->flags = 0;
2037 network->atim_window = 0;
2038 network->erp_value = (network->capability & WLAN_CAPABILITY_IBSS) ?
2039 0x3 : 0x0;
2040 network->berp_info_valid = false;
2041 network->broadcom_cap_exist = false;
2042 network->ralink_cap_exist = false;
2043 network->atheros_cap_exist = false;
2044 network->cisco_cap_exist = false;
2045 network->unknown_cap_exist = false;
2046#ifdef THOMAS_TURBO
2047 network->Turbo_Enable = 0;
2048#endif
2049 network->CountryIeLen = 0;
2050 memset(network->CountryIeBuf, 0, MAX_IE_LEN);
2051
2052
2053 HTInitializeBssDesc(&network->bssht);
2054 if (stats->freq == IEEE80211_52GHZ_BAND) {
2055
2056 network->channel = stats->received_channel;
2057 } else
2058 network->flags |= NETWORK_HAS_CCK;
2059
2060 network->wpa_ie_len = 0;
2061 network->rsn_ie_len = 0;
2062
2063 if (ieee80211_parse_info_param
2064 (ieee, beacon->info_element, stats->len - sizeof(*beacon), network, stats))
2065 return 1;
2066
2067 network->mode = 0;
2068 if (stats->freq == IEEE80211_52GHZ_BAND)
2069 network->mode = IEEE_A;
2070 else {
2071 if (network->flags & NETWORK_HAS_OFDM)
2072 network->mode |= IEEE_G;
2073 if (network->flags & NETWORK_HAS_CCK)
2074 network->mode |= IEEE_B;
2075 }
2076
2077 if (network->mode == 0) {
2078 IEEE80211_DEBUG_SCAN("Filtered out '%s (%pM)' "
2079 "network.\n",
2080 escape_essid(network->ssid,
2081 network->ssid_len),
2082 network->bssid);
2083 return 1;
2084 }
2085
2086 if (network->bssht.bdSupportHT) {
2087 if (network->mode == IEEE_A)
2088 network->mode = IEEE_N_5G;
2089 else if (network->mode & (IEEE_G | IEEE_B))
2090 network->mode = IEEE_N_24G;
2091 }
2092 if (ieee80211_is_empty_essid(network->ssid, network->ssid_len))
2093 network->flags |= NETWORK_EMPTY_ESSID;
2094
2095 stats->signal = 30 + (stats->SignalStrength * 70) / 100;
2096
2097 stats->noise = ieee80211_translate_todbm((u8)(100 - stats->signal)) - 25;
2098
2099 memcpy(&network->stats, stats, sizeof(network->stats));
2100
2101 return 0;
2102}
2103
2104static inline int is_same_network(struct ieee80211_network *src,
2105 struct ieee80211_network *dst, struct ieee80211_device *ieee)
2106{
2107
2108
2109
2110
2111 return
2112 (((src->ssid_len == dst->ssid_len) || (ieee->iw_mode == IW_MODE_INFRA)) &&
2113 (src->channel == dst->channel) &&
2114 !memcmp(src->bssid, dst->bssid, ETH_ALEN) &&
2115
2116 (!memcmp(src->ssid, dst->ssid, src->ssid_len) || (ieee->iw_mode == IW_MODE_INFRA)) &&
2117 ((src->capability & WLAN_CAPABILITY_IBSS) ==
2118 (dst->capability & WLAN_CAPABILITY_IBSS)) &&
2119 ((src->capability & WLAN_CAPABILITY_BSS) ==
2120 (dst->capability & WLAN_CAPABILITY_BSS)));
2121}
2122
2123static inline void update_network(struct ieee80211_network *dst,
2124 struct ieee80211_network *src)
2125{
2126 int qos_active;
2127 u8 old_param;
2128
2129 memcpy(&dst->stats, &src->stats, sizeof(struct ieee80211_rx_stats));
2130 dst->capability = src->capability;
2131 memcpy(dst->rates, src->rates, src->rates_len);
2132 dst->rates_len = src->rates_len;
2133 memcpy(dst->rates_ex, src->rates_ex, src->rates_ex_len);
2134 dst->rates_ex_len = src->rates_ex_len;
2135 if (src->ssid_len > 0) {
2136 memset(dst->ssid, 0, dst->ssid_len);
2137 dst->ssid_len = src->ssid_len;
2138 memcpy(dst->ssid, src->ssid, src->ssid_len);
2139 }
2140 dst->mode = src->mode;
2141 dst->flags = src->flags;
2142 dst->time_stamp[0] = src->time_stamp[0];
2143 dst->time_stamp[1] = src->time_stamp[1];
2144 if (src->flags & NETWORK_HAS_ERP_VALUE) {
2145 dst->erp_value = src->erp_value;
2146 dst->berp_info_valid = src->berp_info_valid = true;
2147 }
2148 dst->beacon_interval = src->beacon_interval;
2149 dst->listen_interval = src->listen_interval;
2150 dst->atim_window = src->atim_window;
2151 dst->dtim_period = src->dtim_period;
2152 dst->dtim_data = src->dtim_data;
2153 dst->last_dtim_sta_time[0] = src->last_dtim_sta_time[0];
2154 dst->last_dtim_sta_time[1] = src->last_dtim_sta_time[1];
2155 memcpy(&dst->tim, &src->tim, sizeof(struct ieee80211_tim_parameters));
2156
2157 dst->bssht.bdSupportHT = src->bssht.bdSupportHT;
2158 dst->bssht.bdRT2RTAggregation = src->bssht.bdRT2RTAggregation;
2159 dst->bssht.bdHTCapLen = src->bssht.bdHTCapLen;
2160 memcpy(dst->bssht.bdHTCapBuf, src->bssht.bdHTCapBuf, src->bssht.bdHTCapLen);
2161 dst->bssht.bdHTInfoLen = src->bssht.bdHTInfoLen;
2162 memcpy(dst->bssht.bdHTInfoBuf, src->bssht.bdHTInfoBuf, src->bssht.bdHTInfoLen);
2163 dst->bssht.bdHTSpecVer = src->bssht.bdHTSpecVer;
2164 dst->bssht.bdRT2RTLongSlotTime = src->bssht.bdRT2RTLongSlotTime;
2165 dst->broadcom_cap_exist = src->broadcom_cap_exist;
2166 dst->ralink_cap_exist = src->ralink_cap_exist;
2167 dst->atheros_cap_exist = src->atheros_cap_exist;
2168 dst->cisco_cap_exist = src->cisco_cap_exist;
2169 dst->unknown_cap_exist = src->unknown_cap_exist;
2170 memcpy(dst->wpa_ie, src->wpa_ie, src->wpa_ie_len);
2171 dst->wpa_ie_len = src->wpa_ie_len;
2172 memcpy(dst->rsn_ie, src->rsn_ie, src->rsn_ie_len);
2173 dst->rsn_ie_len = src->rsn_ie_len;
2174
2175 dst->last_scanned = jiffies;
2176
2177
2178 qos_active = dst->qos_data.active;
2179
2180 old_param = dst->qos_data.param_count;
2181 if (dst->flags & NETWORK_HAS_QOS_MASK)
2182 memcpy(&dst->qos_data, &src->qos_data,
2183 sizeof(struct ieee80211_qos_data));
2184 else {
2185 dst->qos_data.supported = src->qos_data.supported;
2186 dst->qos_data.param_count = src->qos_data.param_count;
2187 }
2188
2189 if (dst->qos_data.supported == 1) {
2190 dst->QoS_Enable = 1;
2191 if (dst->ssid_len)
2192 IEEE80211_DEBUG_QOS
2193 ("QoS the network %s is QoS supported\n",
2194 dst->ssid);
2195 else
2196 IEEE80211_DEBUG_QOS
2197 ("QoS the network is QoS supported\n");
2198 }
2199 dst->qos_data.active = qos_active;
2200 dst->qos_data.old_param_count = old_param;
2201
2202
2203 dst->wmm_info = src->wmm_info;
2204 if (src->wmm_param[0].aci_aifsn || \
2205 src->wmm_param[1].aci_aifsn || \
2206 src->wmm_param[2].aci_aifsn || \
2207 src->wmm_param[3].aci_aifsn) {
2208 memcpy(dst->wmm_param, src->wmm_param, WME_AC_PRAM_LEN);
2209 }
2210
2211#ifdef THOMAS_TURBO
2212 dst->Turbo_Enable = src->Turbo_Enable;
2213#endif
2214
2215 dst->CountryIeLen = src->CountryIeLen;
2216 memcpy(dst->CountryIeBuf, src->CountryIeBuf, src->CountryIeLen);
2217
2218
2219 dst->bWithAironetIE = src->bWithAironetIE;
2220 dst->bCkipSupported = src->bCkipSupported;
2221 memcpy(dst->CcxRmState, src->CcxRmState, 2);
2222 dst->bCcxRmEnable = src->bCcxRmEnable;
2223 dst->MBssidMask = src->MBssidMask;
2224 dst->bMBssidValid = src->bMBssidValid;
2225 memcpy(dst->MBssid, src->MBssid, 6);
2226 dst->bWithCcxVerNum = src->bWithCcxVerNum;
2227 dst->BssCcxVerNumber = src->BssCcxVerNumber;
2228
2229}
2230
2231static inline int is_beacon(__le16 fc)
2232{
2233 return (WLAN_FC_GET_STYPE(le16_to_cpu(fc)) == IEEE80211_STYPE_BEACON);
2234}
2235
2236static inline void ieee80211_process_probe_response(
2237 struct ieee80211_device *ieee,
2238 struct ieee80211_probe_response *beacon,
2239 struct ieee80211_rx_stats *stats)
2240{
2241 struct ieee80211_network *network;
2242 struct ieee80211_network *target;
2243 struct ieee80211_network *oldest = NULL;
2244#ifdef CONFIG_IEEE80211_DEBUG
2245 struct ieee80211_info_element *info_element = &beacon->info_element[0];
2246#endif
2247 int fc = WLAN_FC_GET_STYPE(le16_to_cpu(beacon->header.frame_ctl));
2248 unsigned long flags;
2249 short renew;
2250 u16 capability;
2251
2252
2253 network = kzalloc(sizeof(*network), GFP_ATOMIC);
2254 if (!network)
2255 goto out;
2256
2257 capability = le16_to_cpu(beacon->capability);
2258 IEEE80211_DEBUG_SCAN(
2259 "'%s' (%pM): %c%c%c%c %c%c%c%c-%c%c%c%c %c%c%c%c\n",
2260 escape_essid(info_element->data, info_element->len),
2261 beacon->header.addr3,
2262 (capability & BIT(0xf)) ? '1' : '0',
2263 (capability & BIT(0xe)) ? '1' : '0',
2264 (capability & BIT(0xd)) ? '1' : '0',
2265 (capability & BIT(0xc)) ? '1' : '0',
2266 (capability & BIT(0xb)) ? '1' : '0',
2267 (capability & BIT(0xa)) ? '1' : '0',
2268 (capability & BIT(0x9)) ? '1' : '0',
2269 (capability & BIT(0x8)) ? '1' : '0',
2270 (capability & BIT(0x7)) ? '1' : '0',
2271 (capability & BIT(0x6)) ? '1' : '0',
2272 (capability & BIT(0x5)) ? '1' : '0',
2273 (capability & BIT(0x4)) ? '1' : '0',
2274 (capability & BIT(0x3)) ? '1' : '0',
2275 (capability & BIT(0x2)) ? '1' : '0',
2276 (capability & BIT(0x1)) ? '1' : '0',
2277 (capability & BIT(0x0)) ? '1' : '0');
2278
2279 if (ieee80211_network_init(ieee, beacon, network, stats)) {
2280 IEEE80211_DEBUG_SCAN("Dropped '%s' (%pM) via %s.\n",
2281 escape_essid(info_element->data,
2282 info_element->len),
2283 beacon->header.addr3,
2284 fc == IEEE80211_STYPE_PROBE_RESP ?
2285 "PROBE RESPONSE" : "BEACON");
2286 goto out;
2287 }
2288
2289
2290
2291
2292
2293
2294
2295
2296 if (!is_legal_channel(ieee, network->channel))
2297 goto out;
2298 if (ieee->bGlobalDomain) {
2299 if (fc == IEEE80211_STYPE_PROBE_RESP) {
2300 if (IS_COUNTRY_IE_VALID(ieee)) {
2301
2302 if (!is_legal_channel(ieee, network->channel)) {
2303 netdev_warn(ieee->dev, "GetScanInfo(): For Country code, filter probe response at channel(%d).\n", network->channel);
2304 goto out;
2305 }
2306 } else {
2307
2308
2309 if (network->channel > 11) {
2310 netdev_warn(ieee->dev, "GetScanInfo(): For Global Domain, filter probe response at channel(%d).\n", network->channel);
2311 goto out;
2312 }
2313 }
2314 } else {
2315 if (IS_COUNTRY_IE_VALID(ieee)) {
2316
2317 if (!is_legal_channel(ieee, network->channel)) {
2318 netdev_warn(ieee->dev, "GetScanInfo(): For Country code, filter beacon at channel(%d).\n", network->channel);
2319 goto out;
2320 }
2321 } else {
2322
2323
2324 if (network->channel > 14) {
2325 netdev_warn(ieee->dev, "GetScanInfo(): For Global Domain, filter beacon at channel(%d).\n", network->channel);
2326 goto out;
2327 }
2328 }
2329 }
2330 }
2331
2332
2333
2334
2335
2336
2337
2338
2339
2340
2341
2342 spin_lock_irqsave(&ieee->lock, flags);
2343
2344 if (is_same_network(&ieee->current_network, network, ieee)) {
2345 update_network(&ieee->current_network, network);
2346 if ((ieee->current_network.mode == IEEE_N_24G || ieee->current_network.mode == IEEE_G)
2347 && ieee->current_network.berp_info_valid){
2348 if (ieee->current_network.erp_value & ERP_UseProtection)
2349 ieee->current_network.buseprotection = true;
2350 else
2351 ieee->current_network.buseprotection = false;
2352 }
2353 if (is_beacon(beacon->header.frame_ctl)) {
2354 if (ieee->state == IEEE80211_LINKED)
2355 ieee->LinkDetectInfo.NumRecvBcnInPeriod++;
2356 } else
2357 network->flags = (~NETWORK_EMPTY_ESSID & network->flags) | (NETWORK_EMPTY_ESSID & ieee->current_network.flags);
2358 }
2359
2360 list_for_each_entry(target, &ieee->network_list, list) {
2361 if (is_same_network(target, network, ieee))
2362 break;
2363 if (!oldest ||
2364 (target->last_scanned < oldest->last_scanned))
2365 oldest = target;
2366 }
2367
2368
2369
2370 if (&target->list == &ieee->network_list) {
2371 if (list_empty(&ieee->network_free_list)) {
2372
2373 list_del(&oldest->list);
2374 target = oldest;
2375 IEEE80211_DEBUG_SCAN("Expired '%s' (%pM) from "
2376 "network list.\n",
2377 escape_essid(target->ssid,
2378 target->ssid_len),
2379 target->bssid);
2380 } else {
2381
2382 target = list_entry(ieee->network_free_list.next,
2383 struct ieee80211_network, list);
2384 list_del(ieee->network_free_list.next);
2385 }
2386
2387
2388#ifdef CONFIG_IEEE80211_DEBUG
2389 IEEE80211_DEBUG_SCAN("Adding '%s' (%pM) via %s.\n",
2390 escape_essid(network->ssid,
2391 network->ssid_len),
2392 network->bssid,
2393 fc == IEEE80211_STYPE_PROBE_RESP ?
2394 "PROBE RESPONSE" : "BEACON");
2395#endif
2396 memcpy(target, network, sizeof(*target));
2397 list_add_tail(&target->list, &ieee->network_list);
2398 if (ieee->softmac_features & IEEE_SOFTMAC_ASSOCIATE)
2399 ieee80211_softmac_new_net(ieee, network);
2400 } else {
2401 IEEE80211_DEBUG_SCAN("Updating '%s' (%pM) via %s.\n",
2402 escape_essid(target->ssid,
2403 target->ssid_len),
2404 target->bssid,
2405 fc == IEEE80211_STYPE_PROBE_RESP ?
2406 "PROBE RESPONSE" : "BEACON");
2407
2408
2409
2410
2411
2412 renew = !time_after(target->last_scanned + ieee->scan_age, jiffies);
2413
2414 if (is_beacon(beacon->header.frame_ctl) == 0)
2415 network->flags = (~NETWORK_EMPTY_ESSID & network->flags) | (NETWORK_EMPTY_ESSID & target->flags);
2416
2417
2418 if (((network->flags & NETWORK_EMPTY_ESSID) == NETWORK_EMPTY_ESSID) \
2419 && (((network->ssid_len > 0) && (strncmp(target->ssid, network->ssid, network->ssid_len)))\
2420 || ((ieee->current_network.ssid_len == network->ssid_len) && (strncmp(ieee->current_network.ssid, network->ssid, network->ssid_len) == 0) && (ieee->state == IEEE80211_NOLINK))))
2421 renew = 1;
2422
2423
2424 update_network(target, network);
2425 if (renew && (ieee->softmac_features & IEEE_SOFTMAC_ASSOCIATE))
2426 ieee80211_softmac_new_net(ieee, network);
2427 }
2428
2429 spin_unlock_irqrestore(&ieee->lock, flags);
2430 if (is_beacon(beacon->header.frame_ctl) && is_same_network(&ieee->current_network, network, ieee) && \
2431 (ieee->state == IEEE80211_LINKED)) {
2432 if (ieee->handle_beacon)
2433 ieee->handle_beacon(ieee->dev, beacon, &ieee->current_network);
2434 }
2435
2436out:
2437 kfree(network);
2438}
2439
2440void ieee80211_rx_mgt(struct ieee80211_device *ieee,
2441 struct rtl_80211_hdr_4addr *header,
2442 struct ieee80211_rx_stats *stats)
2443{
2444 switch (WLAN_FC_GET_STYPE(le16_to_cpu(header->frame_ctl))) {
2445
2446 case IEEE80211_STYPE_BEACON:
2447 IEEE80211_DEBUG_MGMT("received BEACON (%d)\n",
2448 WLAN_FC_GET_STYPE(le16_to_cpu(header->frame_ctl)));
2449 IEEE80211_DEBUG_SCAN("Beacon\n");
2450 ieee80211_process_probe_response(
2451 ieee, (struct ieee80211_probe_response *)header, stats);
2452 break;
2453
2454 case IEEE80211_STYPE_PROBE_RESP:
2455 IEEE80211_DEBUG_MGMT("received PROBE RESPONSE (%d)\n",
2456 WLAN_FC_GET_STYPE(le16_to_cpu(header->frame_ctl)));
2457 IEEE80211_DEBUG_SCAN("Probe response\n");
2458 ieee80211_process_probe_response(
2459 ieee, (struct ieee80211_probe_response *)header, stats);
2460 break;
2461
2462 }
2463}
2464EXPORT_SYMBOL(ieee80211_rx_mgt);
2465
