source: src/linux/universal/linux-4.9/net/mac80211/rx.c @ 31662

Last change on this file since 31662 was 31662, checked in by brainslayer, 5 months ago

use new squashfs in all kernels

File size: 119.2 KB
Line 
1/*
2 * Copyright 2002-2005, Instant802 Networks, Inc.
3 * Copyright 2005-2006, Devicescape Software, Inc.
4 * Copyright 2006-2007  Jiri Benc <jbenc@suse.cz>
5 * Copyright 2007-2010  Johannes Berg <johannes@sipsolutions.net>
6 * Copyright 2013-2014  Intel Mobile Communications GmbH
7 * Copyright(c) 2015 - 2017 Intel Deutschland GmbH
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation.
12 */
13
14#include <linux/jiffies.h>
15#include <linux/slab.h>
16#include <linux/kernel.h>
17#include <linux/skbuff.h>
18#include <linux/netdevice.h>
19#include <linux/etherdevice.h>
20#include <linux/rcupdate.h>
21#include <linux/export.h>
22#include <linux/bitops.h>
23#include <net/mac80211.h>
24#include <net/ieee80211_radiotap.h>
25#include <asm/unaligned.h>
26
27#include "ieee80211_i.h"
28#include "driver-ops.h"
29#include "led.h"
30#include "mesh.h"
31#include "wep.h"
32#include "wpa.h"
33#include "tkip.h"
34#include "wme.h"
35#include "rate.h"
36
37static inline void ieee80211_rx_stats(struct net_device *dev, u32 len)
38{
39        struct pcpu_sw_netstats *tstats = this_cpu_ptr(dev->tstats);
40
41        u64_stats_update_begin(&tstats->syncp);
42        tstats->rx_packets++;
43        tstats->rx_bytes += len;
44        u64_stats_update_end(&tstats->syncp);
45}
46
47static u8 *ieee80211_get_bssid(struct ieee80211_hdr *hdr, size_t len,
48                               enum nl80211_iftype type)
49{
50        __le16 fc = hdr->frame_control;
51
52        if (ieee80211_is_data(fc)) {
53                if (len < 24) /* drop incorrect hdr len (data) */
54                        return NULL;
55
56                if (ieee80211_has_a4(fc))
57                        return NULL;
58                if (ieee80211_has_tods(fc))
59                        return hdr->addr1;
60                if (ieee80211_has_fromds(fc))
61                        return hdr->addr2;
62
63                return hdr->addr3;
64        }
65
66        if (ieee80211_is_mgmt(fc)) {
67                if (len < 24) /* drop incorrect hdr len (mgmt) */
68                        return NULL;
69                return hdr->addr3;
70        }
71
72        if (ieee80211_is_ctl(fc)) {
73                if (ieee80211_is_pspoll(fc))
74                        return hdr->addr1;
75
76                if (ieee80211_is_back_req(fc)) {
77                        switch (type) {
78                        case NL80211_IFTYPE_STATION:
79                                return hdr->addr2;
80                        case NL80211_IFTYPE_AP:
81                        case NL80211_IFTYPE_AP_VLAN:
82                                return hdr->addr1;
83                        default:
84                                break; /* fall through to the return */
85                        }
86                }
87        }
88
89        return NULL;
90}
91
92/*
93 * monitor mode reception
94 *
95 * This function cleans up the SKB, i.e. it removes all the stuff
96 * only useful for monitoring.
97 */
98static struct sk_buff *remove_monitor_info(struct ieee80211_local *local,
99                                           struct sk_buff *skb,
100                                           unsigned int rtap_vendor_space)
101{
102        if (ieee80211_hw_check(&local->hw, RX_INCLUDES_FCS)) {
103                if (likely(skb->len > FCS_LEN))
104                        __pskb_trim(skb, skb->len - FCS_LEN);
105                else {
106                        /* driver bug */
107                        WARN_ON(1);
108                        dev_kfree_skb(skb);
109                        return NULL;
110                }
111        }
112
113        __pskb_pull(skb, rtap_vendor_space);
114
115        return skb;
116}
117
118static inline bool should_drop_frame(struct sk_buff *skb, int present_fcs_len,
119                                     unsigned int rtap_vendor_space)
120{
121        struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
122        struct ieee80211_hdr *hdr;
123
124        hdr = (void *)(skb->data + rtap_vendor_space);
125
126        if (status->flag & (RX_FLAG_FAILED_FCS_CRC |
127                            RX_FLAG_FAILED_PLCP_CRC |
128                            RX_FLAG_ONLY_MONITOR))
129                return true;
130
131        if (unlikely(skb->len < 16 + present_fcs_len + rtap_vendor_space))
132                return true;
133
134        if (ieee80211_is_ctl(hdr->frame_control) &&
135            !ieee80211_is_pspoll(hdr->frame_control) &&
136            !ieee80211_is_back_req(hdr->frame_control))
137                return true;
138
139        return false;
140}
141
142static int
143ieee80211_rx_radiotap_hdrlen(struct ieee80211_local *local,
144                             struct ieee80211_rx_status *status,
145                             struct sk_buff *skb)
146{
147        int len;
148
149        /* always present fields */
150        len = sizeof(struct ieee80211_radiotap_header) + 8;
151
152        /* allocate extra bitmaps */
153        if (status->chains)
154                len += 4 * hweight8(status->chains);
155
156        if (ieee80211_have_rx_timestamp(status)) {
157                len = ALIGN(len, 8);
158                len += 8;
159        }
160        if (ieee80211_hw_check(&local->hw, SIGNAL_DBM))
161                len += 1;
162
163        /* antenna field, if we don't have per-chain info */
164        if (!status->chains)
165                len += 1;
166
167        /* padding for RX_FLAGS if necessary */
168        len = ALIGN(len, 2);
169
170        if (status->flag & RX_FLAG_HT) /* HT info */
171                len += 3;
172
173        if (status->flag & RX_FLAG_AMPDU_DETAILS) {
174                len = ALIGN(len, 4);
175                len += 8;
176        }
177
178        if (status->flag & RX_FLAG_VHT) {
179                len = ALIGN(len, 2);
180                len += 12;
181        }
182
183        if (local->hw.radiotap_timestamp.units_pos >= 0) {
184                len = ALIGN(len, 8);
185                len += 12;
186        }
187
188        if (status->chains) {
189                /* antenna and antenna signal fields */
190                len += 2 * hweight8(status->chains);
191        }
192
193        if (status->flag & RX_FLAG_RADIOTAP_VENDOR_DATA) {
194                struct ieee80211_vendor_radiotap *rtap = (void *)skb->data;
195
196                /* vendor presence bitmap */
197                len += 4;
198                /* alignment for fixed 6-byte vendor data header */
199                len = ALIGN(len, 2);
200                /* vendor data header */
201                len += 6;
202                if (WARN_ON(rtap->align == 0))
203                        rtap->align = 1;
204                len = ALIGN(len, rtap->align);
205                len += rtap->len + rtap->pad;
206        }
207
208        return len;
209}
210
211/*
212 * ieee80211_add_rx_radiotap_header - add radiotap header
213 *
214 * add a radiotap header containing all the fields which the hardware provided.
215 */
216static void
217ieee80211_add_rx_radiotap_header(struct ieee80211_local *local,
218                                 struct sk_buff *skb,
219                                 struct ieee80211_rate *rate,
220                                 int rtap_len, bool has_fcs)
221{
222        struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
223        struct ieee80211_radiotap_header *rthdr;
224        unsigned char *pos;
225        __le32 *it_present;
226        u32 it_present_val;
227        u16 rx_flags = 0;
228        u16 channel_flags = 0;
229        int mpdulen, chain;
230        unsigned long chains = status->chains;
231        struct ieee80211_vendor_radiotap rtap = {};
232
233        if (status->flag & RX_FLAG_RADIOTAP_VENDOR_DATA) {
234                rtap = *(struct ieee80211_vendor_radiotap *)skb->data;
235                /* rtap.len and rtap.pad are undone immediately */
236                skb_pull(skb, sizeof(rtap) + rtap.len + rtap.pad);
237        }
238
239        mpdulen = skb->len;
240        if (!(has_fcs && ieee80211_hw_check(&local->hw, RX_INCLUDES_FCS)))
241                mpdulen += FCS_LEN;
242
243        rthdr = (struct ieee80211_radiotap_header *)skb_push(skb, rtap_len);
244        memset(rthdr, 0, rtap_len - rtap.len - rtap.pad);
245        it_present = &rthdr->it_present;
246
247        /* radiotap header, set always present flags */
248        rthdr->it_len = cpu_to_le16(rtap_len);
249        it_present_val = BIT(IEEE80211_RADIOTAP_FLAGS) |
250                         BIT(IEEE80211_RADIOTAP_CHANNEL) |
251                         BIT(IEEE80211_RADIOTAP_RX_FLAGS);
252
253        if (!status->chains)
254                it_present_val |= BIT(IEEE80211_RADIOTAP_ANTENNA);
255
256        for_each_set_bit(chain, &chains, IEEE80211_MAX_CHAINS) {
257                it_present_val |=
258                        BIT(IEEE80211_RADIOTAP_EXT) |
259                        BIT(IEEE80211_RADIOTAP_RADIOTAP_NAMESPACE);
260                put_unaligned_le32(it_present_val, it_present);
261                it_present++;
262                it_present_val = BIT(IEEE80211_RADIOTAP_ANTENNA) |
263                                 BIT(IEEE80211_RADIOTAP_DBM_ANTSIGNAL);
264        }
265
266        if (status->flag & RX_FLAG_RADIOTAP_VENDOR_DATA) {
267                it_present_val |= BIT(IEEE80211_RADIOTAP_VENDOR_NAMESPACE) |
268                                  BIT(IEEE80211_RADIOTAP_EXT);
269                put_unaligned_le32(it_present_val, it_present);
270                it_present++;
271                it_present_val = rtap.present;
272        }
273
274        put_unaligned_le32(it_present_val, it_present);
275
276        pos = (void *)(it_present + 1);
277
278        /* the order of the following fields is important */
279
280        /* IEEE80211_RADIOTAP_TSFT */
281        if (ieee80211_have_rx_timestamp(status)) {
282                /* padding */
283                while ((pos - (u8 *)rthdr) & 7)
284                        *pos++ = 0;
285                put_unaligned_le64(
286                        ieee80211_calculate_rx_timestamp(local, status,
287                                                         mpdulen, 0),
288                        pos);
289                rthdr->it_present |= cpu_to_le32(1 << IEEE80211_RADIOTAP_TSFT);
290                pos += 8;
291        }
292
293        /* IEEE80211_RADIOTAP_FLAGS */
294        if (has_fcs && ieee80211_hw_check(&local->hw, RX_INCLUDES_FCS))
295                *pos |= IEEE80211_RADIOTAP_F_FCS;
296        if (status->flag & (RX_FLAG_FAILED_FCS_CRC | RX_FLAG_FAILED_PLCP_CRC))
297                *pos |= IEEE80211_RADIOTAP_F_BADFCS;
298        if (status->flag & RX_FLAG_SHORTPRE)
299                *pos |= IEEE80211_RADIOTAP_F_SHORTPRE;
300        pos++;
301
302        /* IEEE80211_RADIOTAP_RATE */
303        if (!rate || status->flag & (RX_FLAG_HT | RX_FLAG_VHT)) {
304                /*
305                 * Without rate information don't add it. If we have,
306                 * MCS information is a separate field in radiotap,
307                 * added below. The byte here is needed as padding
308                 * for the channel though, so initialise it to 0.
309                 */
310                *pos = 0;
311        } else {
312                int shift = 0;
313                rthdr->it_present |= cpu_to_le32(1 << IEEE80211_RADIOTAP_RATE);
314                if (status->flag & RX_FLAG_10MHZ)
315                        shift = 1;
316                else if (status->flag & RX_FLAG_5MHZ)
317                        shift = 2;
318                *pos = DIV_ROUND_UP(rate->bitrate, 5 * (1 << shift));
319        }
320        pos++;
321
322        /* IEEE80211_RADIOTAP_CHANNEL */
323        put_unaligned_le16(status->freq, pos);
324        pos += 2;
325        if (status->flag & RX_FLAG_10MHZ)
326                channel_flags |= IEEE80211_CHAN_HALF;
327        else if (status->flag & RX_FLAG_5MHZ)
328                channel_flags |= IEEE80211_CHAN_QUARTER;
329
330        if (status->band == NL80211_BAND_5GHZ)
331                channel_flags |= IEEE80211_CHAN_OFDM | IEEE80211_CHAN_5GHZ;
332        else if (status->flag & (RX_FLAG_HT | RX_FLAG_VHT))
333                channel_flags |= IEEE80211_CHAN_DYN | IEEE80211_CHAN_2GHZ;
334        else if (rate && rate->flags & IEEE80211_RATE_ERP_G)
335                channel_flags |= IEEE80211_CHAN_OFDM | IEEE80211_CHAN_2GHZ;
336        else if (rate)
337                channel_flags |= IEEE80211_CHAN_CCK | IEEE80211_CHAN_2GHZ;
338        else
339                channel_flags |= IEEE80211_CHAN_2GHZ;
340        put_unaligned_le16(channel_flags, pos);
341        pos += 2;
342
343        /* IEEE80211_RADIOTAP_DBM_ANTSIGNAL */
344        if (ieee80211_hw_check(&local->hw, SIGNAL_DBM) &&
345            !(status->flag & RX_FLAG_NO_SIGNAL_VAL)) {
346                *pos = status->signal;
347                rthdr->it_present |=
348                        cpu_to_le32(1 << IEEE80211_RADIOTAP_DBM_ANTSIGNAL);
349                pos++;
350        }
351
352        /* IEEE80211_RADIOTAP_LOCK_QUALITY is missing */
353
354        if (!status->chains) {
355                /* IEEE80211_RADIOTAP_ANTENNA */
356                *pos = status->antenna;
357                pos++;
358        }
359
360        /* IEEE80211_RADIOTAP_DB_ANTNOISE is not used */
361
362        /* IEEE80211_RADIOTAP_RX_FLAGS */
363        /* ensure 2 byte alignment for the 2 byte field as required */
364        if ((pos - (u8 *)rthdr) & 1)
365                *pos++ = 0;
366        if (status->flag & RX_FLAG_FAILED_PLCP_CRC)
367                rx_flags |= IEEE80211_RADIOTAP_F_RX_BADPLCP;
368        put_unaligned_le16(rx_flags, pos);
369        pos += 2;
370
371        if (status->flag & RX_FLAG_HT) {
372                unsigned int stbc;
373
374                rthdr->it_present |= cpu_to_le32(1 << IEEE80211_RADIOTAP_MCS);
375                *pos++ = local->hw.radiotap_mcs_details;
376                *pos = 0;
377                if (status->flag & RX_FLAG_SHORT_GI)
378                        *pos |= IEEE80211_RADIOTAP_MCS_SGI;
379                if (status->flag & RX_FLAG_40MHZ)
380                        *pos |= IEEE80211_RADIOTAP_MCS_BW_40;
381                if (status->flag & RX_FLAG_HT_GF)
382                        *pos |= IEEE80211_RADIOTAP_MCS_FMT_GF;
383                if (status->flag & RX_FLAG_LDPC)
384                        *pos |= IEEE80211_RADIOTAP_MCS_FEC_LDPC;
385                stbc = (status->flag & RX_FLAG_STBC_MASK) >> RX_FLAG_STBC_SHIFT;
386                *pos |= stbc << IEEE80211_RADIOTAP_MCS_STBC_SHIFT;
387                pos++;
388                *pos++ = status->rate_idx;
389        }
390
391        if (status->flag & RX_FLAG_AMPDU_DETAILS) {
392                u16 flags = 0;
393
394                /* ensure 4 byte alignment */
395                while ((pos - (u8 *)rthdr) & 3)
396                        pos++;
397                rthdr->it_present |=
398                        cpu_to_le32(1 << IEEE80211_RADIOTAP_AMPDU_STATUS);
399                put_unaligned_le32(status->ampdu_reference, pos);
400                pos += 4;
401                if (status->flag & RX_FLAG_AMPDU_LAST_KNOWN)
402                        flags |= IEEE80211_RADIOTAP_AMPDU_LAST_KNOWN;
403                if (status->flag & RX_FLAG_AMPDU_IS_LAST)
404                        flags |= IEEE80211_RADIOTAP_AMPDU_IS_LAST;
405                if (status->flag & RX_FLAG_AMPDU_DELIM_CRC_ERROR)
406                        flags |= IEEE80211_RADIOTAP_AMPDU_DELIM_CRC_ERR;
407                if (status->flag & RX_FLAG_AMPDU_DELIM_CRC_KNOWN)
408                        flags |= IEEE80211_RADIOTAP_AMPDU_DELIM_CRC_KNOWN;
409                put_unaligned_le16(flags, pos);
410                pos += 2;
411                if (status->flag & RX_FLAG_AMPDU_DELIM_CRC_KNOWN)
412                        *pos++ = status->ampdu_delimiter_crc;
413                else
414                        *pos++ = 0;
415                *pos++ = 0;
416        }
417
418        if (status->flag & RX_FLAG_VHT) {
419                u16 known = local->hw.radiotap_vht_details;
420
421                rthdr->it_present |= cpu_to_le32(1 << IEEE80211_RADIOTAP_VHT);
422                put_unaligned_le16(known, pos);
423                pos += 2;
424                /* flags */
425                if (status->flag & RX_FLAG_SHORT_GI)
426                        *pos |= IEEE80211_RADIOTAP_VHT_FLAG_SGI;
427                /* in VHT, STBC is binary */
428                if (status->flag & RX_FLAG_STBC_MASK)
429                        *pos |= IEEE80211_RADIOTAP_VHT_FLAG_STBC;
430                if (status->vht_flag & RX_VHT_FLAG_BF)
431                        *pos |= IEEE80211_RADIOTAP_VHT_FLAG_BEAMFORMED;
432                pos++;
433                /* bandwidth */
434                if (status->vht_flag & RX_VHT_FLAG_80MHZ)
435                        *pos++ = 4;
436                else if (status->vht_flag & RX_VHT_FLAG_160MHZ)
437                        *pos++ = 11;
438                else if (status->flag & RX_FLAG_40MHZ)
439                        *pos++ = 1;
440                else /* 20 MHz */
441                        *pos++ = 0;
442                /* MCS/NSS */
443                *pos = (status->rate_idx << 4) | status->vht_nss;
444                pos += 4;
445                /* coding field */
446                if (status->flag & RX_FLAG_LDPC)
447                        *pos |= IEEE80211_RADIOTAP_CODING_LDPC_USER0;
448                pos++;
449                /* group ID */
450                pos++;
451                /* partial_aid */
452                pos += 2;
453        }
454
455        if (local->hw.radiotap_timestamp.units_pos >= 0) {
456                u16 accuracy = 0;
457                u8 flags = IEEE80211_RADIOTAP_TIMESTAMP_FLAG_32BIT;
458
459                rthdr->it_present |=
460                        cpu_to_le32(1 << IEEE80211_RADIOTAP_TIMESTAMP);
461
462                /* ensure 8 byte alignment */
463                while ((pos - (u8 *)rthdr) & 7)
464                        pos++;
465
466                put_unaligned_le64(status->device_timestamp, pos);
467                pos += sizeof(u64);
468
469                if (local->hw.radiotap_timestamp.accuracy >= 0) {
470                        accuracy = local->hw.radiotap_timestamp.accuracy;
471                        flags |= IEEE80211_RADIOTAP_TIMESTAMP_FLAG_ACCURACY;
472                }
473                put_unaligned_le16(accuracy, pos);
474                pos += sizeof(u16);
475
476                *pos++ = local->hw.radiotap_timestamp.units_pos;
477                *pos++ = flags;
478        }
479
480        for_each_set_bit(chain, &chains, IEEE80211_MAX_CHAINS) {
481                *pos++ = status->chain_signal[chain];
482                *pos++ = chain;
483        }
484
485        if (status->flag & RX_FLAG_RADIOTAP_VENDOR_DATA) {
486                /* ensure 2 byte alignment for the vendor field as required */
487                if ((pos - (u8 *)rthdr) & 1)
488                        *pos++ = 0;
489                *pos++ = rtap.oui[0];
490                *pos++ = rtap.oui[1];
491                *pos++ = rtap.oui[2];
492                *pos++ = rtap.subns;
493                put_unaligned_le16(rtap.len, pos);
494                pos += 2;
495                /* align the actual payload as requested */
496                while ((pos - (u8 *)rthdr) & (rtap.align - 1))
497                        *pos++ = 0;
498                /* data (and possible padding) already follows */
499        }
500}
501
502/*
503 * This function copies a received frame to all monitor interfaces and
504 * returns a cleaned-up SKB that no longer includes the FCS nor the
505 * radiotap header the driver might have added.
506 */
507static struct sk_buff *
508ieee80211_rx_monitor(struct ieee80211_local *local, struct sk_buff *origskb,
509                     struct ieee80211_rate *rate)
510{
511        struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(origskb);
512        struct ieee80211_sub_if_data *sdata;
513        int rt_hdrlen, needed_headroom;
514        struct sk_buff *skb, *skb2;
515        struct net_device *prev_dev = NULL;
516        int present_fcs_len = 0;
517        unsigned int rtap_vendor_space = 0;
518        struct ieee80211_mgmt *mgmt;
519        struct ieee80211_sub_if_data *monitor_sdata =
520                rcu_dereference(local->monitor_sdata);
521
522        if (unlikely(status->flag & RX_FLAG_RADIOTAP_VENDOR_DATA)) {
523                struct ieee80211_vendor_radiotap *rtap = (void *)origskb->data;
524
525                rtap_vendor_space = sizeof(*rtap) + rtap->len + rtap->pad;
526        }
527
528        /*
529         * First, we may need to make a copy of the skb because
530         *  (1) we need to modify it for radiotap (if not present), and
531         *  (2) the other RX handlers will modify the skb we got.
532         *
533         * We don't need to, of course, if we aren't going to return
534         * the SKB because it has a bad FCS/PLCP checksum.
535         */
536
537        if (ieee80211_hw_check(&local->hw, RX_INCLUDES_FCS))
538                present_fcs_len = FCS_LEN;
539
540        /* ensure hdr->frame_control and vendor radiotap data are in skb head */
541        if (!pskb_may_pull(origskb, 2 + rtap_vendor_space)) {
542                dev_kfree_skb(origskb);
543                return NULL;
544        }
545
546        if (!local->monitors || (status->flag & RX_FLAG_SKIP_MONITOR)) {
547                if (should_drop_frame(origskb, present_fcs_len,
548                                      rtap_vendor_space)) {
549                        dev_kfree_skb(origskb);
550                        return NULL;
551                }
552
553                return remove_monitor_info(local, origskb, rtap_vendor_space);
554        }
555
556        /* room for the radiotap header based on driver features */
557        rt_hdrlen = ieee80211_rx_radiotap_hdrlen(local, status, origskb);
558        needed_headroom = rt_hdrlen - rtap_vendor_space;
559
560        if (should_drop_frame(origskb, present_fcs_len, rtap_vendor_space)) {
561                /* only need to expand headroom if necessary */
562                skb = origskb;
563                origskb = NULL;
564
565                /*
566                 * This shouldn't trigger often because most devices have an
567                 * RX header they pull before we get here, and that should
568                 * be big enough for our radiotap information. We should
569                 * probably export the length to drivers so that we can have
570                 * them allocate enough headroom to start with.
571                 */
572                if (skb_headroom(skb) < needed_headroom &&
573                    pskb_expand_head(skb, needed_headroom, 0, GFP_ATOMIC)) {
574                        dev_kfree_skb(skb);
575                        return NULL;
576                }
577        } else {
578                /*
579                 * Need to make a copy and possibly remove radiotap header
580                 * and FCS from the original.
581                 */
582                skb = skb_copy_expand(origskb, needed_headroom, 0, GFP_ATOMIC);
583
584                origskb = remove_monitor_info(local, origskb,
585                                              rtap_vendor_space);
586
587                if (!skb)
588                        return origskb;
589        }
590
591        /* prepend radiotap information */
592        ieee80211_add_rx_radiotap_header(local, skb, rate, rt_hdrlen, true);
593
594        skb_reset_mac_header(skb);
595        skb->ip_summed = CHECKSUM_UNNECESSARY;
596        skb->pkt_type = PACKET_OTHERHOST;
597        skb->protocol = htons(ETH_P_802_2);
598
599        list_for_each_entry_rcu(sdata, &local->interfaces, list) {
600                if (sdata->vif.type != NL80211_IFTYPE_MONITOR)
601                        continue;
602
603                if (sdata->u.mntr.flags & MONITOR_FLAG_COOK_FRAMES)
604                        continue;
605
606                if (!ieee80211_sdata_running(sdata))
607                        continue;
608
609                if (prev_dev) {
610                        skb2 = skb_clone(skb, GFP_ATOMIC);
611                        if (skb2) {
612                                skb2->dev = prev_dev;
613                                netif_receive_skb(skb2);
614                        }
615                }
616
617                prev_dev = sdata->dev;
618                ieee80211_rx_stats(sdata->dev, skb->len);
619        }
620
621        mgmt = (void *)skb->data;
622        if (monitor_sdata &&
623            skb->len >= IEEE80211_MIN_ACTION_SIZE + 1 + VHT_MUMIMO_GROUPS_DATA_LEN &&
624            ieee80211_is_action(mgmt->frame_control) &&
625            mgmt->u.action.category == WLAN_CATEGORY_VHT &&
626            mgmt->u.action.u.vht_group_notif.action_code == WLAN_VHT_ACTION_GROUPID_MGMT &&
627            is_valid_ether_addr(monitor_sdata->u.mntr.mu_follow_addr) &&
628            ether_addr_equal(mgmt->da, monitor_sdata->u.mntr.mu_follow_addr)) {
629                struct sk_buff *mu_skb = skb_copy(skb, GFP_ATOMIC);
630
631                if (mu_skb) {
632                        mu_skb->pkt_type = IEEE80211_SDATA_QUEUE_TYPE_FRAME;
633                        skb_queue_tail(&monitor_sdata->skb_queue, mu_skb);
634                        ieee80211_queue_work(&local->hw, &monitor_sdata->work);
635                }
636        }
637
638        if (prev_dev) {
639                skb->dev = prev_dev;
640                netif_receive_skb(skb);
641        } else
642                dev_kfree_skb(skb);
643
644        return origskb;
645}
646
647static void ieee80211_parse_qos(struct ieee80211_rx_data *rx)
648{
649        struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
650        struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb);
651        int tid, seqno_idx, security_idx;
652
653        /* does the frame have a qos control field? */
654        if (ieee80211_is_data_qos(hdr->frame_control)) {
655                u8 *qc = ieee80211_get_qos_ctl(hdr);
656                /* frame has qos control */
657                tid = *qc & IEEE80211_QOS_CTL_TID_MASK;
658                if (*qc & IEEE80211_QOS_CTL_A_MSDU_PRESENT)
659                        status->rx_flags |= IEEE80211_RX_AMSDU;
660
661                seqno_idx = tid;
662                security_idx = tid;
663        } else {
664                /*
665                 * IEEE 802.11-2007, 7.1.3.4.1 ("Sequence Number field"):
666                 *
667                 *      Sequence numbers for management frames, QoS data
668                 *      frames with a broadcast/multicast address in the
669                 *      Address 1 field, and all non-QoS data frames sent
670                 *      by QoS STAs are assigned using an additional single
671                 *      modulo-4096 counter, [...]
672                 *
673                 * We also use that counter for non-QoS STAs.
674                 */
675                seqno_idx = IEEE80211_NUM_TIDS;
676                security_idx = 0;
677                if (ieee80211_is_mgmt(hdr->frame_control))
678                        security_idx = IEEE80211_NUM_TIDS;
679                tid = 0;
680        }
681
682        rx->seqno_idx = seqno_idx;
683        rx->security_idx = security_idx;
684        /* Set skb->priority to 1d tag if highest order bit of TID is not set.
685         * For now, set skb->priority to 0 for other cases. */
686        rx->skb->priority = (tid > 7) ? 0 : tid;
687}
688
689/**
690 * DOC: Packet alignment
691 *
692 * Drivers always need to pass packets that are aligned to two-byte boundaries
693 * to the stack.
694 *
695 * Additionally, should, if possible, align the payload data in a way that
696 * guarantees that the contained IP header is aligned to a four-byte
697 * boundary. In the case of regular frames, this simply means aligning the
698 * payload to a four-byte boundary (because either the IP header is directly
699 * contained, or IV/RFC1042 headers that have a length divisible by four are
700 * in front of it).  If the payload data is not properly aligned and the
701 * architecture doesn't support efficient unaligned operations, mac80211
702 * will align the data.
703 *
704 * With A-MSDU frames, however, the payload data address must yield two modulo
705 * four because there are 14-byte 802.3 headers within the A-MSDU frames that
706 * push the IP header further back to a multiple of four again. Thankfully, the
707 * specs were sane enough this time around to require padding each A-MSDU
708 * subframe to a length that is a multiple of four.
709 *
710 * Padding like Atheros hardware adds which is between the 802.11 header and
711 * the payload is not supported, the driver is required to move the 802.11
712 * header to be directly in front of the payload in that case.
713 */
714static void ieee80211_verify_alignment(struct ieee80211_rx_data *rx)
715{
716#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
717        WARN_ON_ONCE((unsigned long)rx->skb->data & 1);
718#endif
719}
720
721
722/* rx handlers */
723
724static int ieee80211_is_unicast_robust_mgmt_frame(struct sk_buff *skb)
725{
726        struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
727
728        if (is_multicast_ether_addr(hdr->addr1))
729                return 0;
730
731        return ieee80211_is_robust_mgmt_frame(skb);
732}
733
734
735static int ieee80211_is_multicast_robust_mgmt_frame(struct sk_buff *skb)
736{
737        struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
738
739        if (!is_multicast_ether_addr(hdr->addr1))
740                return 0;
741
742        return ieee80211_is_robust_mgmt_frame(skb);
743}
744
745
746/* Get the BIP key index from MMIE; return -1 if this is not a BIP frame */
747static int ieee80211_get_mmie_keyidx(struct sk_buff *skb)
748{
749        struct ieee80211_mgmt *hdr = (struct ieee80211_mgmt *) skb->data;
750        struct ieee80211_mmie *mmie;
751        struct ieee80211_mmie_16 *mmie16;
752
753        if (skb->len < 24 + sizeof(*mmie) || !is_multicast_ether_addr(hdr->da))
754                return -1;
755
756        if (!ieee80211_is_robust_mgmt_frame(skb))
757                return -1; /* not a robust management frame */
758
759        mmie = (struct ieee80211_mmie *)
760                (skb->data + skb->len - sizeof(*mmie));
761        if (mmie->element_id == WLAN_EID_MMIE &&
762            mmie->length == sizeof(*mmie) - 2)
763                return le16_to_cpu(mmie->key_id);
764
765        mmie16 = (struct ieee80211_mmie_16 *)
766                (skb->data + skb->len - sizeof(*mmie16));
767        if (skb->len >= 24 + sizeof(*mmie16) &&
768            mmie16->element_id == WLAN_EID_MMIE &&
769            mmie16->length == sizeof(*mmie16) - 2)
770                return le16_to_cpu(mmie16->key_id);
771
772        return -1;
773}
774
775static int ieee80211_get_cs_keyid(const struct ieee80211_cipher_scheme *cs,
776                                  struct sk_buff *skb)
777{
778        struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
779        __le16 fc;
780        int hdrlen;
781        u8 keyid;
782
783        fc = hdr->frame_control;
784        hdrlen = ieee80211_hdrlen(fc);
785
786        if (skb->len < hdrlen + cs->hdr_len)
787                return -EINVAL;
788
789        skb_copy_bits(skb, hdrlen + cs->key_idx_off, &keyid, 1);
790        keyid &= cs->key_idx_mask;
791        keyid >>= cs->key_idx_shift;
792
793        return keyid;
794}
795
796static ieee80211_rx_result ieee80211_rx_mesh_check(struct ieee80211_rx_data *rx)
797{
798        struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
799        char *dev_addr = rx->sdata->vif.addr;
800
801        if (ieee80211_is_data(hdr->frame_control)) {
802                if (is_multicast_ether_addr(hdr->addr1)) {
803                        if (ieee80211_has_tods(hdr->frame_control) ||
804                            !ieee80211_has_fromds(hdr->frame_control))
805                                return RX_DROP_MONITOR;
806                        if (ether_addr_equal(hdr->addr3, dev_addr))
807                                return RX_DROP_MONITOR;
808                } else {
809                        if (!ieee80211_has_a4(hdr->frame_control))
810                                return RX_DROP_MONITOR;
811                        if (ether_addr_equal(hdr->addr4, dev_addr))
812                                return RX_DROP_MONITOR;
813                }
814        }
815
816        /* If there is not an established peer link and this is not a peer link
817         * establisment frame, beacon or probe, drop the frame.
818         */
819
820        if (!rx->sta || sta_plink_state(rx->sta) != NL80211_PLINK_ESTAB) {
821                struct ieee80211_mgmt *mgmt;
822
823                if (!ieee80211_is_mgmt(hdr->frame_control))
824                        return RX_DROP_MONITOR;
825
826                if (ieee80211_is_action(hdr->frame_control)) {
827                        u8 category;
828
829                        /* make sure category field is present */
830                        if (rx->skb->len < IEEE80211_MIN_ACTION_SIZE)
831                                return RX_DROP_MONITOR;
832
833                        mgmt = (struct ieee80211_mgmt *)hdr;
834                        category = mgmt->u.action.category;
835                        if (category != WLAN_CATEGORY_MESH_ACTION &&
836                            category != WLAN_CATEGORY_SELF_PROTECTED)
837                                return RX_DROP_MONITOR;
838                        return RX_CONTINUE;
839                }
840
841                if (ieee80211_is_probe_req(hdr->frame_control) ||
842                    ieee80211_is_probe_resp(hdr->frame_control) ||
843                    ieee80211_is_beacon(hdr->frame_control) ||
844                    ieee80211_is_auth(hdr->frame_control))
845                        return RX_CONTINUE;
846
847                return RX_DROP_MONITOR;
848        }
849
850        return RX_CONTINUE;
851}
852
853static inline bool ieee80211_rx_reorder_ready(struct tid_ampdu_rx *tid_agg_rx,
854                                              int index)
855{
856        struct sk_buff_head *frames = &tid_agg_rx->reorder_buf[index];
857        struct sk_buff *tail = skb_peek_tail(frames);
858        struct ieee80211_rx_status *status;
859
860        if (tid_agg_rx->reorder_buf_filtered & BIT_ULL(index))
861                return true;
862
863        if (!tail)
864                return false;
865
866        status = IEEE80211_SKB_RXCB(tail);
867        if (status->flag & RX_FLAG_AMSDU_MORE)
868                return false;
869
870        return true;
871}
872
873static void ieee80211_release_reorder_frame(struct ieee80211_sub_if_data *sdata,
874                                            struct tid_ampdu_rx *tid_agg_rx,
875                                            int index,
876                                            struct sk_buff_head *frames)
877{
878        struct sk_buff_head *skb_list = &tid_agg_rx->reorder_buf[index];
879        struct sk_buff *skb;
880        struct ieee80211_rx_status *status;
881
882        lockdep_assert_held(&tid_agg_rx->reorder_lock);
883
884        if (skb_queue_empty(skb_list))
885                goto no_frame;
886
887        if (!ieee80211_rx_reorder_ready(tid_agg_rx, index)) {
888                __skb_queue_purge(skb_list);
889                goto no_frame;
890        }
891
892        /* release frames from the reorder ring buffer */
893        tid_agg_rx->stored_mpdu_num--;
894        while ((skb = __skb_dequeue(skb_list))) {
895                status = IEEE80211_SKB_RXCB(skb);
896                status->rx_flags |= IEEE80211_RX_DEFERRED_RELEASE;
897                __skb_queue_tail(frames, skb);
898        }
899
900no_frame:
901        tid_agg_rx->reorder_buf_filtered &= ~BIT_ULL(index);
902        tid_agg_rx->head_seq_num = ieee80211_sn_inc(tid_agg_rx->head_seq_num);
903}
904
905static void ieee80211_release_reorder_frames(struct ieee80211_sub_if_data *sdata,
906                                             struct tid_ampdu_rx *tid_agg_rx,
907                                             u16 head_seq_num,
908                                             struct sk_buff_head *frames)
909{
910        int index;
911
912        lockdep_assert_held(&tid_agg_rx->reorder_lock);
913
914        while (ieee80211_sn_less(tid_agg_rx->head_seq_num, head_seq_num)) {
915                index = tid_agg_rx->head_seq_num % tid_agg_rx->buf_size;
916                ieee80211_release_reorder_frame(sdata, tid_agg_rx, index,
917                                                frames);
918        }
919}
920
921/*
922 * Timeout (in jiffies) for skb's that are waiting in the RX reorder buffer. If
923 * the skb was added to the buffer longer than this time ago, the earlier
924 * frames that have not yet been received are assumed to be lost and the skb
925 * can be released for processing. This may also release other skb's from the
926 * reorder buffer if there are no additional gaps between the frames.
927 *
928 * Callers must hold tid_agg_rx->reorder_lock.
929 */
930#define HT_RX_REORDER_BUF_TIMEOUT (HZ / 10)
931
932static void ieee80211_sta_reorder_release(struct ieee80211_sub_if_data *sdata,
933                                          struct tid_ampdu_rx *tid_agg_rx,
934                                          struct sk_buff_head *frames)
935{
936        int index, i, j;
937
938        lockdep_assert_held(&tid_agg_rx->reorder_lock);
939
940        /* release the buffer until next missing frame */
941        index = tid_agg_rx->head_seq_num % tid_agg_rx->buf_size;
942        if (!ieee80211_rx_reorder_ready(tid_agg_rx, index) &&
943            tid_agg_rx->stored_mpdu_num) {
944                /*
945                 * No buffers ready to be released, but check whether any
946                 * frames in the reorder buffer have timed out.
947                 */
948                int skipped = 1;
949                for (j = (index + 1) % tid_agg_rx->buf_size; j != index;
950                     j = (j + 1) % tid_agg_rx->buf_size) {
951                        if (!ieee80211_rx_reorder_ready(tid_agg_rx, j)) {
952                                skipped++;
953                                continue;
954                        }
955                        if (skipped &&
956                            !time_after(jiffies, tid_agg_rx->reorder_time[j] +
957                                        HT_RX_REORDER_BUF_TIMEOUT))
958                                goto set_release_timer;
959
960                        /* don't leave incomplete A-MSDUs around */
961                        for (i = (index + 1) % tid_agg_rx->buf_size; i != j;
962                             i = (i + 1) % tid_agg_rx->buf_size)
963                                __skb_queue_purge(&tid_agg_rx->reorder_buf[i]);
964
965                        ht_dbg_ratelimited(sdata,
966                                           "release an RX reorder frame due to timeout on earlier frames\n");
967                        ieee80211_release_reorder_frame(sdata, tid_agg_rx, j,
968                                                        frames);
969
970                        /*
971                         * Increment the head seq# also for the skipped slots.
972                         */
973                        tid_agg_rx->head_seq_num =
974                                (tid_agg_rx->head_seq_num +
975                                 skipped) & IEEE80211_SN_MASK;
976                        skipped = 0;
977                }
978        } else while (ieee80211_rx_reorder_ready(tid_agg_rx, index)) {
979                ieee80211_release_reorder_frame(sdata, tid_agg_rx, index,
980                                                frames);
981                index = tid_agg_rx->head_seq_num % tid_agg_rx->buf_size;
982        }
983
984        if (tid_agg_rx->stored_mpdu_num) {
985                j = index = tid_agg_rx->head_seq_num % tid_agg_rx->buf_size;
986
987                for (; j != (index - 1) % tid_agg_rx->buf_size;
988                     j = (j + 1) % tid_agg_rx->buf_size) {
989                        if (ieee80211_rx_reorder_ready(tid_agg_rx, j))
990                                break;
991                }
992
993 set_release_timer:
994
995                if (!tid_agg_rx->removed)
996                        mod_timer(&tid_agg_rx->reorder_timer,
997                                  tid_agg_rx->reorder_time[j] + 1 +
998                                  HT_RX_REORDER_BUF_TIMEOUT);
999        } else {
1000                del_timer(&tid_agg_rx->reorder_timer);
1001        }
1002}
1003
1004/*
1005 * As this function belongs to the RX path it must be under
1006 * rcu_read_lock protection. It returns false if the frame
1007 * can be processed immediately, true if it was consumed.
1008 */
1009static bool ieee80211_sta_manage_reorder_buf(struct ieee80211_sub_if_data *sdata,
1010                                             struct tid_ampdu_rx *tid_agg_rx,
1011                                             struct sk_buff *skb,
1012                                             struct sk_buff_head *frames)
1013{
1014        struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
1015        struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
1016        u16 sc = le16_to_cpu(hdr->seq_ctrl);
1017        u16 mpdu_seq_num = (sc & IEEE80211_SCTL_SEQ) >> 4;
1018        u16 head_seq_num, buf_size;
1019        int index;
1020        bool ret = true;
1021
1022        spin_lock(&tid_agg_rx->reorder_lock);
1023
1024        /*
1025         * Offloaded BA sessions have no known starting sequence number so pick
1026         * one from first Rxed frame for this tid after BA was started.
1027         */
1028        if (unlikely(tid_agg_rx->auto_seq)) {
1029                tid_agg_rx->auto_seq = false;
1030                tid_agg_rx->ssn = mpdu_seq_num;
1031                tid_agg_rx->head_seq_num = mpdu_seq_num;
1032        }
1033
1034        buf_size = tid_agg_rx->buf_size;
1035        head_seq_num = tid_agg_rx->head_seq_num;
1036
1037        /*
1038         * If the current MPDU's SN is smaller than the SSN, it shouldn't
1039         * be reordered.
1040         */
1041        if (unlikely(!tid_agg_rx->started)) {
1042                if (ieee80211_sn_less(mpdu_seq_num, head_seq_num)) {
1043                        ret = false;
1044                        goto out;
1045                }
1046                tid_agg_rx->started = true;
1047        }
1048
1049        /* frame with out of date sequence number */
1050        if (ieee80211_sn_less(mpdu_seq_num, head_seq_num)) {
1051                dev_kfree_skb(skb);
1052                goto out;
1053        }
1054
1055        /*
1056         * If frame the sequence number exceeds our buffering window
1057         * size release some previous frames to make room for this one.
1058         */
1059        if (!ieee80211_sn_less(mpdu_seq_num, head_seq_num + buf_size)) {
1060                head_seq_num = ieee80211_sn_inc(
1061                                ieee80211_sn_sub(mpdu_seq_num, buf_size));
1062                /* release stored frames up to new head to stack */
1063                ieee80211_release_reorder_frames(sdata, tid_agg_rx,
1064                                                 head_seq_num, frames);
1065        }
1066
1067        /* Now the new frame is always in the range of the reordering buffer */
1068
1069        index = mpdu_seq_num % tid_agg_rx->buf_size;
1070
1071        /* check if we already stored this frame */
1072        if (ieee80211_rx_reorder_ready(tid_agg_rx, index)) {
1073                dev_kfree_skb(skb);
1074                goto out;
1075        }
1076
1077        /*
1078         * If the current MPDU is in the right order and nothing else
1079         * is stored we can process it directly, no need to buffer it.
1080         * If it is first but there's something stored, we may be able
1081         * to release frames after this one.
1082         */
1083        if (mpdu_seq_num == tid_agg_rx->head_seq_num &&
1084            tid_agg_rx->stored_mpdu_num == 0) {
1085                if (!(status->flag & RX_FLAG_AMSDU_MORE))
1086                        tid_agg_rx->head_seq_num =
1087                                ieee80211_sn_inc(tid_agg_rx->head_seq_num);
1088                ret = false;
1089                goto out;
1090        }
1091
1092        /* put the frame in the reordering buffer */
1093        __skb_queue_tail(&tid_agg_rx->reorder_buf[index], skb);
1094        if (!(status->flag & RX_FLAG_AMSDU_MORE)) {
1095                tid_agg_rx->reorder_time[index] = jiffies;
1096                tid_agg_rx->stored_mpdu_num++;
1097                ieee80211_sta_reorder_release(sdata, tid_agg_rx, frames);
1098        }
1099
1100 out:
1101        spin_unlock(&tid_agg_rx->reorder_lock);
1102        return ret;
1103}
1104
1105/*
1106 * Reorder MPDUs from A-MPDUs, keeping them on a buffer. Returns
1107 * true if the MPDU was buffered, false if it should be processed.
1108 */
1109static void ieee80211_rx_reorder_ampdu(struct ieee80211_rx_data *rx,
1110                                       struct sk_buff_head *frames)
1111{
1112        struct sk_buff *skb = rx->skb;
1113        struct ieee80211_local *local = rx->local;
1114        struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
1115        struct sta_info *sta = rx->sta;
1116        struct tid_ampdu_rx *tid_agg_rx;
1117        u16 sc;
1118        u8 tid, ack_policy;
1119
1120        if (!ieee80211_is_data_qos(hdr->frame_control) ||
1121            is_multicast_ether_addr(hdr->addr1))
1122                goto dont_reorder;
1123
1124        /*
1125         * filter the QoS data rx stream according to
1126         * STA/TID and check if this STA/TID is on aggregation
1127         */
1128
1129        if (!sta)
1130                goto dont_reorder;
1131
1132        ack_policy = *ieee80211_get_qos_ctl(hdr) &
1133                     IEEE80211_QOS_CTL_ACK_POLICY_MASK;
1134        tid = *ieee80211_get_qos_ctl(hdr) & IEEE80211_QOS_CTL_TID_MASK;
1135
1136        tid_agg_rx = rcu_dereference(sta->ampdu_mlme.tid_rx[tid]);
1137        if (!tid_agg_rx) {
1138                if (ack_policy == IEEE80211_QOS_CTL_ACK_POLICY_BLOCKACK &&
1139                    !test_bit(tid, rx->sta->ampdu_mlme.agg_session_valid) &&
1140                    !test_and_set_bit(tid, rx->sta->ampdu_mlme.unexpected_agg))
1141                        ieee80211_send_delba(rx->sdata, rx->sta->sta.addr, tid,
1142                                             WLAN_BACK_RECIPIENT,
1143                                             WLAN_REASON_QSTA_REQUIRE_SETUP);
1144                goto dont_reorder;
1145        }
1146
1147        /* qos null data frames are excluded */
1148        if (unlikely(hdr->frame_control & cpu_to_le16(IEEE80211_STYPE_NULLFUNC)))
1149                goto dont_reorder;
1150
1151        /* not part of a BA session */
1152        if (ack_policy != IEEE80211_QOS_CTL_ACK_POLICY_BLOCKACK &&
1153            ack_policy != IEEE80211_QOS_CTL_ACK_POLICY_NORMAL)
1154                goto dont_reorder;
1155
1156        /* new, potentially un-ordered, ampdu frame - process it */
1157
1158        /* reset session timer */
1159        if (tid_agg_rx->timeout)
1160                tid_agg_rx->last_rx = jiffies;
1161
1162        /* if this mpdu is fragmented - terminate rx aggregation session */
1163        sc = le16_to_cpu(hdr->seq_ctrl);
1164        if (sc & IEEE80211_SCTL_FRAG) {
1165                skb->pkt_type = IEEE80211_SDATA_QUEUE_TYPE_FRAME;
1166                skb_queue_tail(&rx->sdata->skb_queue, skb);
1167                ieee80211_queue_work(&local->hw, &rx->sdata->work);
1168                return;
1169        }
1170
1171        /*
1172         * No locking needed -- we will only ever process one
1173         * RX packet at a time, and thus own tid_agg_rx. All
1174         * other code manipulating it needs to (and does) make
1175         * sure that we cannot get to it any more before doing
1176         * anything with it.
1177         */
1178        if (ieee80211_sta_manage_reorder_buf(rx->sdata, tid_agg_rx, skb,
1179                                             frames))
1180                return;
1181
1182 dont_reorder:
1183        __skb_queue_tail(frames, skb);
1184}
1185
1186static ieee80211_rx_result debug_noinline
1187ieee80211_rx_h_check_dup(struct ieee80211_rx_data *rx)
1188{
1189        struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
1190        struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb);
1191
1192        if (status->flag & RX_FLAG_DUP_VALIDATED)
1193                return RX_CONTINUE;
1194
1195        /*
1196         * Drop duplicate 802.11 retransmissions
1197         * (IEEE 802.11-2012: 9.3.2.10 "Duplicate detection and recovery")
1198         */
1199
1200        if (rx->skb->len < 24)
1201                return RX_CONTINUE;
1202
1203        if (ieee80211_is_ctl(hdr->frame_control) ||
1204            ieee80211_is_qos_nullfunc(hdr->frame_control) ||
1205            is_multicast_ether_addr(hdr->addr1))
1206                return RX_CONTINUE;
1207
1208        if (!rx->sta)
1209                return RX_CONTINUE;
1210
1211        if (unlikely(ieee80211_has_retry(hdr->frame_control) &&
1212                     rx->sta->last_seq_ctrl[rx->seqno_idx] == hdr->seq_ctrl)) {
1213                I802_DEBUG_INC(rx->local->dot11FrameDuplicateCount);
1214                rx->sta->rx_stats.num_duplicates++;
1215                return RX_DROP_UNUSABLE;
1216        } else if (!(status->flag & RX_FLAG_AMSDU_MORE)) {
1217                rx->sta->last_seq_ctrl[rx->seqno_idx] = hdr->seq_ctrl;
1218        }
1219
1220        return RX_CONTINUE;
1221}
1222
1223static ieee80211_rx_result debug_noinline
1224ieee80211_rx_h_check(struct ieee80211_rx_data *rx)
1225{
1226        struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
1227
1228        /* Drop disallowed frame classes based on STA auth/assoc state;
1229         * IEEE 802.11, Chap 5.5.
1230         *
1231         * mac80211 filters only based on association state, i.e. it drops
1232         * Class 3 frames from not associated stations. hostapd sends
1233         * deauth/disassoc frames when needed. In addition, hostapd is
1234         * responsible for filtering on both auth and assoc states.
1235         */
1236
1237        if (ieee80211_vif_is_mesh(&rx->sdata->vif))
1238                return ieee80211_rx_mesh_check(rx);
1239
1240        if (unlikely((ieee80211_is_data(hdr->frame_control) ||
1241                      ieee80211_is_pspoll(hdr->frame_control)) &&
1242                     rx->sdata->vif.type != NL80211_IFTYPE_ADHOC &&
1243                     rx->sdata->vif.type != NL80211_IFTYPE_WDS &&
1244                     rx->sdata->vif.type != NL80211_IFTYPE_OCB &&
1245                     (!rx->sta || !test_sta_flag(rx->sta, WLAN_STA_ASSOC)))) {
1246                /*
1247                 * accept port control frames from the AP even when it's not
1248                 * yet marked ASSOC to prevent a race where we don't set the
1249                 * assoc bit quickly enough before it sends the first frame
1250                 */
1251                if (rx->sta && rx->sdata->vif.type == NL80211_IFTYPE_STATION &&
1252                    ieee80211_is_data_present(hdr->frame_control)) {
1253                        unsigned int hdrlen;
1254                        __be16 ethertype;
1255
1256                        hdrlen = ieee80211_hdrlen(hdr->frame_control);
1257
1258                        if (rx->skb->len < hdrlen + 8)
1259                                return RX_DROP_MONITOR;
1260
1261                        skb_copy_bits(rx->skb, hdrlen + 6, &ethertype, 2);
1262                        if (ethertype == rx->sdata->control_port_protocol)
1263                                return RX_CONTINUE;
1264                }
1265
1266                if (rx->sdata->vif.type == NL80211_IFTYPE_AP &&
1267                    cfg80211_rx_spurious_frame(rx->sdata->dev,
1268                                               hdr->addr2,
1269                                               GFP_ATOMIC))
1270                        return RX_DROP_UNUSABLE;
1271
1272                return RX_DROP_MONITOR;
1273        }
1274
1275        return RX_CONTINUE;
1276}
1277
1278
1279static ieee80211_rx_result debug_noinline
1280ieee80211_rx_h_check_more_data(struct ieee80211_rx_data *rx)
1281{
1282        struct ieee80211_local *local;
1283        struct ieee80211_hdr *hdr;
1284        struct sk_buff *skb;
1285
1286        local = rx->local;
1287        skb = rx->skb;
1288        hdr = (struct ieee80211_hdr *) skb->data;
1289
1290        if (!local->pspolling)
1291                return RX_CONTINUE;
1292
1293        if (!ieee80211_has_fromds(hdr->frame_control))
1294                /* this is not from AP */
1295                return RX_CONTINUE;
1296
1297        if (!ieee80211_is_data(hdr->frame_control))
1298                return RX_CONTINUE;
1299
1300        if (!ieee80211_has_moredata(hdr->frame_control)) {
1301                /* AP has no more frames buffered for us */
1302                local->pspolling = false;
1303                return RX_CONTINUE;
1304        }
1305
1306        /* more data bit is set, let's request a new frame from the AP */
1307        ieee80211_send_pspoll(local, rx->sdata);
1308
1309        return RX_CONTINUE;
1310}
1311
1312static void sta_ps_start(struct sta_info *sta)
1313{
1314        struct ieee80211_sub_if_data *sdata = sta->sdata;
1315        struct ieee80211_local *local = sdata->local;
1316        struct ps_data *ps;
1317        int tid;
1318
1319        if (sta->sdata->vif.type == NL80211_IFTYPE_AP ||
1320            sta->sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
1321                ps = &sdata->bss->ps;
1322        else
1323                return;
1324
1325        atomic_inc(&ps->num_sta_ps);
1326        set_sta_flag(sta, WLAN_STA_PS_STA);
1327        if (!ieee80211_hw_check(&local->hw, AP_LINK_PS))
1328                drv_sta_notify(local, sdata, STA_NOTIFY_SLEEP, &sta->sta);
1329        ps_dbg(sdata, "STA %pM aid %d enters power save mode\n",
1330               sta->sta.addr, sta->sta.aid);
1331
1332        ieee80211_clear_fast_xmit(sta);
1333
1334        if (!sta->sta.txq[0])
1335                return;
1336
1337        for (tid = 0; tid < ARRAY_SIZE(sta->sta.txq); tid++) {
1338                if (txq_has_queue(sta->sta.txq[tid]))
1339                        set_bit(tid, &sta->txq_buffered_tids);
1340                else
1341                        clear_bit(tid, &sta->txq_buffered_tids);
1342        }
1343}
1344
1345static void sta_ps_end(struct sta_info *sta)
1346{
1347        ps_dbg(sta->sdata, "STA %pM aid %d exits power save mode\n",
1348               sta->sta.addr, sta->sta.aid);
1349
1350        if (test_sta_flag(sta, WLAN_STA_PS_DRIVER)) {
1351                /*
1352                 * Clear the flag only if the other one is still set
1353                 * so that the TX path won't start TX'ing new frames
1354                 * directly ... In the case that the driver flag isn't
1355                 * set ieee80211_sta_ps_deliver_wakeup() will clear it.
1356                 */
1357                clear_sta_flag(sta, WLAN_STA_PS_STA);
1358                ps_dbg(sta->sdata, "STA %pM aid %d driver-ps-blocked\n",
1359                       sta->sta.addr, sta->sta.aid);
1360                return;
1361        }
1362
1363        set_sta_flag(sta, WLAN_STA_PS_DELIVER);
1364        clear_sta_flag(sta, WLAN_STA_PS_STA);
1365        ieee80211_sta_ps_deliver_wakeup(sta);
1366}
1367
1368int ieee80211_sta_ps_transition(struct ieee80211_sta *pubsta, bool start)
1369{
1370        struct sta_info *sta = container_of(pubsta, struct sta_info, sta);
1371        bool in_ps;
1372
1373        WARN_ON(!ieee80211_hw_check(&sta->local->hw, AP_LINK_PS));
1374
1375        /* Don't let the same PS state be set twice */
1376        in_ps = test_sta_flag(sta, WLAN_STA_PS_STA);
1377        if ((start && in_ps) || (!start && !in_ps))
1378                return -EINVAL;
1379
1380        if (start)
1381                sta_ps_start(sta);
1382        else
1383                sta_ps_end(sta);
1384
1385        return 0;
1386}
1387EXPORT_SYMBOL(ieee80211_sta_ps_transition);
1388
1389void ieee80211_sta_pspoll(struct ieee80211_sta *pubsta)
1390{
1391        struct sta_info *sta = container_of(pubsta, struct sta_info, sta);
1392
1393        if (test_sta_flag(sta, WLAN_STA_SP))
1394                return;
1395
1396        if (!test_sta_flag(sta, WLAN_STA_PS_DRIVER))
1397                ieee80211_sta_ps_deliver_poll_response(sta);
1398        else
1399                set_sta_flag(sta, WLAN_STA_PSPOLL);
1400}
1401EXPORT_SYMBOL(ieee80211_sta_pspoll);
1402
1403void ieee80211_sta_uapsd_trigger(struct ieee80211_sta *pubsta, u8 tid)
1404{
1405        struct sta_info *sta = container_of(pubsta, struct sta_info, sta);
1406        u8 ac = ieee802_1d_to_ac[tid & 7];
1407
1408        /*
1409         * If this AC is not trigger-enabled do nothing.
1410         *
1411         * NB: This could/should check a separate bitmap of trigger-
1412         * enabled queues, but for now we only implement uAPSD w/o
1413         * TSPEC changes to the ACs, so they're always the same.
1414         */
1415        if (!(sta->sta.uapsd_queues & BIT(ac)))
1416                return;
1417
1418        /* if we are in a service period, do nothing */
1419        if (test_sta_flag(sta, WLAN_STA_SP))
1420                return;
1421
1422        if (!test_sta_flag(sta, WLAN_STA_PS_DRIVER))
1423                ieee80211_sta_ps_deliver_uapsd(sta);
1424        else
1425                set_sta_flag(sta, WLAN_STA_UAPSD);
1426}
1427EXPORT_SYMBOL(ieee80211_sta_uapsd_trigger);
1428
1429static ieee80211_rx_result debug_noinline
1430ieee80211_rx_h_uapsd_and_pspoll(struct ieee80211_rx_data *rx)
1431{
1432        struct ieee80211_sub_if_data *sdata = rx->sdata;
1433        struct ieee80211_hdr *hdr = (void *)rx->skb->data;
1434        struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb);
1435
1436        if (!rx->sta)
1437                return RX_CONTINUE;
1438
1439        if (sdata->vif.type != NL80211_IFTYPE_AP &&
1440            sdata->vif.type != NL80211_IFTYPE_AP_VLAN)
1441                return RX_CONTINUE;
1442
1443        /*
1444         * The device handles station powersave, so don't do anything about
1445         * uAPSD and PS-Poll frames (the latter shouldn't even come up from
1446         * it to mac80211 since they're handled.)
1447         */
1448        if (ieee80211_hw_check(&sdata->local->hw, AP_LINK_PS))
1449                return RX_CONTINUE;
1450
1451        /*
1452         * Don't do anything if the station isn't already asleep. In
1453         * the uAPSD case, the station will probably be marked asleep,
1454         * in the PS-Poll case the station must be confused ...
1455         */
1456        if (!test_sta_flag(rx->sta, WLAN_STA_PS_STA))
1457                return RX_CONTINUE;
1458
1459        if (unlikely(ieee80211_is_pspoll(hdr->frame_control))) {
1460                ieee80211_sta_pspoll(&rx->sta->sta);
1461
1462                /* Free PS Poll skb here instead of returning RX_DROP that would
1463                 * count as an dropped frame. */
1464                dev_kfree_skb(rx->skb);
1465
1466                return RX_QUEUED;
1467        } else if (!ieee80211_has_morefrags(hdr->frame_control) &&
1468                   !(status->rx_flags & IEEE80211_RX_DEFERRED_RELEASE) &&
1469                   ieee80211_has_pm(hdr->frame_control) &&
1470                   (ieee80211_is_data_qos(hdr->frame_control) ||
1471                    ieee80211_is_qos_nullfunc(hdr->frame_control))) {
1472                u8 tid;
1473
1474                tid = *ieee80211_get_qos_ctl(hdr) & IEEE80211_QOS_CTL_TID_MASK;
1475
1476                ieee80211_sta_uapsd_trigger(&rx->sta->sta, tid);
1477        }
1478
1479        return RX_CONTINUE;
1480}
1481
1482static ieee80211_rx_result debug_noinline
1483ieee80211_rx_h_sta_process(struct ieee80211_rx_data *rx)
1484{
1485        struct sta_info *sta = rx->sta;
1486        struct sk_buff *skb = rx->skb;
1487        struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
1488        struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1489        int i;
1490
1491        if (!sta)
1492                return RX_CONTINUE;
1493
1494        /*
1495         * Update last_rx only for IBSS packets which are for the current
1496         * BSSID and for station already AUTHORIZED to avoid keeping the
1497         * current IBSS network alive in cases where other STAs start
1498         * using different BSSID. This will also give the station another
1499         * chance to restart the authentication/authorization in case
1500         * something went wrong the first time.
1501         */
1502        if (rx->sdata->vif.type == NL80211_IFTYPE_ADHOC) {
1503                u8 *bssid = ieee80211_get_bssid(hdr, rx->skb->len,
1504                                                NL80211_IFTYPE_ADHOC);
1505                if (ether_addr_equal(bssid, rx->sdata->u.ibss.bssid) &&
1506                    test_sta_flag(sta, WLAN_STA_AUTHORIZED)) {
1507                        sta->rx_stats.last_rx = jiffies;
1508                        if (ieee80211_is_data(hdr->frame_control) &&
1509                            !is_multicast_ether_addr(hdr->addr1))
1510                                sta->rx_stats.last_rate =
1511                                        sta_stats_encode_rate(status);
1512                }
1513        } else if (rx->sdata->vif.type == NL80211_IFTYPE_OCB) {
1514                sta->rx_stats.last_rx = jiffies;
1515        } else if (!is_multicast_ether_addr(hdr->addr1)) {
1516                /*
1517                 * Mesh beacons will update last_rx when if they are found to
1518                 * match the current local configuration when processed.
1519                 */
1520                sta->rx_stats.last_rx = jiffies;
1521                if (ieee80211_is_data(hdr->frame_control))
1522                        sta->rx_stats.last_rate = sta_stats_encode_rate(status);
1523        }
1524
1525        if (rx->sdata->vif.type == NL80211_IFTYPE_STATION)
1526                ieee80211_sta_rx_notify(rx->sdata, hdr);
1527
1528        sta->rx_stats.fragments++;
1529
1530        u64_stats_update_begin(&rx->sta->rx_stats.syncp);
1531        sta->rx_stats.bytes += rx->skb->len;
1532        u64_stats_update_end(&rx->sta->rx_stats.syncp);
1533
1534        if (!(status->flag & RX_FLAG_NO_SIGNAL_VAL)) {
1535                sta->rx_stats.last_signal = status->signal;
1536                ewma_signal_add(&sta->rx_stats_avg.signal, -status->signal);
1537        }
1538
1539        if (status->chains) {
1540                sta->rx_stats.chains = status->chains;
1541                for (i = 0; i < ARRAY_SIZE(status->chain_signal); i++) {
1542                        int signal = status->chain_signal[i];
1543
1544                        if (!(status->chains & BIT(i)))
1545                                continue;
1546
1547                        sta->rx_stats.chain_signal_last[i] = signal;
1548                        ewma_signal_add(&sta->rx_stats_avg.chain_signal[i],
1549                                        -signal);
1550                }
1551        }
1552
1553        /*
1554         * Change STA power saving mode only at the end of a frame
1555         * exchange sequence.
1556         */
1557        if (!ieee80211_hw_check(&sta->local->hw, AP_LINK_PS) &&
1558            !ieee80211_has_morefrags(hdr->frame_control) &&
1559            !(status->rx_flags & IEEE80211_RX_DEFERRED_RELEASE) &&
1560            (rx->sdata->vif.type == NL80211_IFTYPE_AP ||
1561             rx->sdata->vif.type == NL80211_IFTYPE_AP_VLAN) &&
1562            /* PM bit is only checked in frames where it isn't reserved,
1563             * in AP mode it's reserved in non-bufferable management frames
1564             * (cf. IEEE 802.11-2012 8.2.4.1.7 Power Management field)
1565             */
1566            (!ieee80211_is_mgmt(hdr->frame_control) ||
1567             ieee80211_is_bufferable_mmpdu(hdr->frame_control))) {
1568                if (test_sta_flag(sta, WLAN_STA_PS_STA)) {
1569                        if (!ieee80211_has_pm(hdr->frame_control))
1570                                sta_ps_end(sta);
1571                } else {
1572                        if (ieee80211_has_pm(hdr->frame_control))
1573                                sta_ps_start(sta);
1574                }
1575        }
1576
1577        /* mesh power save support */
1578        if (ieee80211_vif_is_mesh(&rx->sdata->vif))
1579                ieee80211_mps_rx_h_sta_process(sta, hdr);
1580
1581        /*
1582         * Drop (qos-)data::nullfunc frames silently, since they
1583         * are used only to control station power saving mode.
1584         */
1585        if (ieee80211_is_nullfunc(hdr->frame_control) ||
1586            ieee80211_is_qos_nullfunc(hdr->frame_control)) {
1587                I802_DEBUG_INC(rx->local->rx_handlers_drop_nullfunc);
1588
1589                /*
1590                 * If we receive a 4-addr nullfunc frame from a STA
1591                 * that was not moved to a 4-addr STA vlan yet send
1592                 * the event to userspace and for older hostapd drop
1593                 * the frame to the monitor interface.
1594                 */
1595                if (ieee80211_has_a4(hdr->frame_control) &&
1596                    (rx->sdata->vif.type == NL80211_IFTYPE_AP ||
1597                     (rx->sdata->vif.type == NL80211_IFTYPE_AP_VLAN &&
1598                      !rx->sdata->u.vlan.sta))) {
1599                        if (!test_and_set_sta_flag(sta, WLAN_STA_4ADDR_EVENT))
1600                                cfg80211_rx_unexpected_4addr_frame(
1601                                        rx->sdata->dev, sta->sta.addr,
1602                                        GFP_ATOMIC);
1603                        return RX_DROP_MONITOR;
1604                }
1605                /*
1606                 * Update counter and free packet here to avoid
1607                 * counting this as a dropped packed.
1608                 */
1609                sta->rx_stats.packets++;
1610                dev_kfree_skb(rx->skb);
1611                return RX_QUEUED;
1612        }
1613
1614        return RX_CONTINUE;
1615} /* ieee80211_rx_h_sta_process */
1616
1617static ieee80211_rx_result debug_noinline
1618ieee80211_rx_h_decrypt(struct ieee80211_rx_data *rx)
1619{
1620        struct sk_buff *skb = rx->skb;
1621        struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
1622        struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1623        int keyidx;
1624        int hdrlen;
1625        ieee80211_rx_result result = RX_DROP_UNUSABLE;
1626        struct ieee80211_key *sta_ptk = NULL;
1627        int mmie_keyidx = -1;
1628        __le16 fc;
1629        const struct ieee80211_cipher_scheme *cs = NULL;
1630
1631        /*
1632         * Key selection 101
1633         *
1634         * There are four types of keys:
1635         *  - GTK (group keys)
1636         *  - IGTK (group keys for management frames)
1637         *  - PTK (pairwise keys)
1638         *  - STK (station-to-station pairwise keys)
1639         *
1640         * When selecting a key, we have to distinguish between multicast
1641         * (including broadcast) and unicast frames, the latter can only
1642         * use PTKs and STKs while the former always use GTKs and IGTKs.
1643         * Unless, of course, actual WEP keys ("pre-RSNA") are used, then
1644         * unicast frames can also use key indices like GTKs. Hence, if we
1645         * don't have a PTK/STK we check the key index for a WEP key.
1646         *
1647         * Note that in a regular BSS, multicast frames are sent by the
1648         * AP only, associated stations unicast the frame to the AP first
1649         * which then multicasts it on their behalf.
1650         *
1651         * There is also a slight problem in IBSS mode: GTKs are negotiated
1652         * with each station, that is something we don't currently handle.
1653         * The spec seems to expect that one negotiates the same key with
1654         * every station but there's no such requirement; VLANs could be
1655         * possible.
1656         */
1657
1658        /* start without a key */
1659        rx->key = NULL;
1660        fc = hdr->frame_control;
1661
1662        if (rx->sta) {
1663                int keyid = rx->sta->ptk_idx;
1664
1665                if (ieee80211_has_protected(fc) && rx->sta->cipher_scheme) {
1666                        cs = rx->sta->cipher_scheme;
1667                        keyid = ieee80211_get_cs_keyid(cs, rx->skb);
1668                        if (unlikely(keyid < 0))
1669                                return RX_DROP_UNUSABLE;
1670                }
1671                sta_ptk = rcu_dereference(rx->sta->ptk[keyid]);
1672        }
1673
1674        if (!ieee80211_has_protected(fc))
1675                mmie_keyidx = ieee80211_get_mmie_keyidx(rx->skb);
1676
1677        if (!is_multicast_ether_addr(hdr->addr1) && sta_ptk) {
1678                rx->key = sta_ptk;
1679                if ((status->flag & RX_FLAG_DECRYPTED) &&
1680                    (status->flag & RX_FLAG_IV_STRIPPED))
1681                        return RX_CONTINUE;
1682                /* Skip decryption if the frame is not protected. */
1683                if (!ieee80211_has_protected(fc))
1684                        return RX_CONTINUE;
1685        } else if (mmie_keyidx >= 0) {
1686                /* Broadcast/multicast robust management frame / BIP */
1687                if ((status->flag & RX_FLAG_DECRYPTED) &&
1688                    (status->flag & RX_FLAG_IV_STRIPPED))
1689                        return RX_CONTINUE;
1690
1691                if (mmie_keyidx < NUM_DEFAULT_KEYS ||
1692                    mmie_keyidx >= NUM_DEFAULT_KEYS + NUM_DEFAULT_MGMT_KEYS)
1693                        return RX_DROP_MONITOR; /* unexpected BIP keyidx */
1694                if (rx->sta) {
1695                        if (ieee80211_is_group_privacy_action(skb) &&
1696                            test_sta_flag(rx->sta, WLAN_STA_MFP))
1697                                return RX_DROP_MONITOR;
1698
1699                        rx->key = rcu_dereference(rx->sta->gtk[mmie_keyidx]);
1700                }
1701                if (!rx->key)
1702                        rx->key = rcu_dereference(rx->sdata->keys[mmie_keyidx]);
1703        } else if (!ieee80211_has_protected(fc)) {
1704                /*
1705                 * The frame was not protected, so skip decryption. However, we
1706                 * need to set rx->key if there is a key that could have been
1707                 * used so that the frame may be dropped if encryption would
1708                 * have been expected.
1709                 */
1710                struct ieee80211_key *key = NULL;
1711                struct ieee80211_sub_if_data *sdata = rx->sdata;
1712                int i;
1713
1714                if (ieee80211_is_mgmt(fc) &&
1715                    is_multicast_ether_addr(hdr->addr1) &&
1716                    (key = rcu_dereference(rx->sdata->default_mgmt_key)))
1717                        rx->key = key;
1718                else {
1719                        if (rx->sta) {
1720                                for (i = 0; i < NUM_DEFAULT_KEYS; i++) {
1721                                        key = rcu_dereference(rx->sta->gtk[i]);
1722                                        if (key)
1723                                                break;
1724                                }
1725                        }
1726                        if (!key) {
1727                                for (i = 0; i < NUM_DEFAULT_KEYS; i++) {
1728                                        key = rcu_dereference(sdata->keys[i]);
1729                                        if (key)
1730                                                break;
1731                                }
1732                        }
1733                        if (key)
1734                                rx->key = key;
1735                }
1736                return RX_CONTINUE;
1737        } else {
1738                u8 keyid;
1739
1740                /*
1741                 * The device doesn't give us the IV so we won't be
1742                 * able to look up the key. That's ok though, we
1743                 * don't need to decrypt the frame, we just won't
1744                 * be able to keep statistics accurate.
1745                 * Except for key threshold notifications, should
1746                 * we somehow allow the driver to tell us which key
1747                 * the hardware used if this flag is set?
1748                 */
1749                if ((status->flag & RX_FLAG_DECRYPTED) &&
1750                    (status->flag & RX_FLAG_IV_STRIPPED))
1751                        return RX_CONTINUE;
1752
1753                hdrlen = ieee80211_hdrlen(fc);
1754
1755                if (cs) {
1756                        keyidx = ieee80211_get_cs_keyid(cs, rx->skb);
1757
1758                        if (unlikely(keyidx < 0))
1759                                return RX_DROP_UNUSABLE;
1760                } else {
1761                        if (rx->skb->len < 8 + hdrlen)
1762                                return RX_DROP_UNUSABLE; /* TODO: count this? */
1763                        /*
1764                         * no need to call ieee80211_wep_get_keyidx,
1765                         * it verifies a bunch of things we've done already
1766                         */
1767                        skb_copy_bits(rx->skb, hdrlen + 3, &keyid, 1);
1768                        keyidx = keyid >> 6;
1769                }
1770
1771                /* check per-station GTK first, if multicast packet */
1772                if (is_multicast_ether_addr(hdr->addr1) && rx->sta)
1773                        rx->key = rcu_dereference(rx->sta->gtk[keyidx]);
1774
1775                /* if not found, try default key */
1776                if (!rx->key) {
1777                        rx->key = rcu_dereference(rx->sdata->keys[keyidx]);
1778
1779                        /*
1780                         * RSNA-protected unicast frames should always be
1781                         * sent with pairwise or station-to-station keys,
1782                         * but for WEP we allow using a key index as well.
1783                         */
1784                        if (rx->key &&
1785                            rx->key->conf.cipher != WLAN_CIPHER_SUITE_WEP40 &&
1786                            rx->key->conf.cipher != WLAN_CIPHER_SUITE_WEP104 &&
1787                            !is_multicast_ether_addr(hdr->addr1))
1788                                rx->key = NULL;
1789                }
1790        }
1791
1792        if (rx->key) {
1793                if (unlikely(rx->key->flags & KEY_FLAG_TAINTED))
1794                        return RX_DROP_MONITOR;
1795
1796                /* TODO: add threshold stuff again */
1797        } else {
1798                return RX_DROP_MONITOR;
1799        }
1800
1801        switch (rx->key->conf.cipher) {
1802        case WLAN_CIPHER_SUITE_WEP40:
1803        case WLAN_CIPHER_SUITE_WEP104:
1804                result = ieee80211_crypto_wep_decrypt(rx);
1805                break;
1806        case WLAN_CIPHER_SUITE_TKIP:
1807                result = ieee80211_crypto_tkip_decrypt(rx);
1808                break;
1809        case WLAN_CIPHER_SUITE_CCMP:
1810                result = ieee80211_crypto_ccmp_decrypt(
1811                        rx, IEEE80211_CCMP_MIC_LEN);
1812                break;
1813        case WLAN_CIPHER_SUITE_CCMP_256:
1814                result = ieee80211_crypto_ccmp_decrypt(
1815                        rx, IEEE80211_CCMP_256_MIC_LEN);
1816                break;
1817        case WLAN_CIPHER_SUITE_AES_CMAC:
1818                result = ieee80211_crypto_aes_cmac_decrypt(rx);
1819                break;
1820        case WLAN_CIPHER_SUITE_BIP_CMAC_256:
1821                result = ieee80211_crypto_aes_cmac_256_decrypt(rx);
1822                break;
1823        case WLAN_CIPHER_SUITE_BIP_GMAC_128:
1824        case WLAN_CIPHER_SUITE_BIP_GMAC_256:
1825                result = ieee80211_crypto_aes_gmac_decrypt(rx);
1826                break;
1827        case WLAN_CIPHER_SUITE_GCMP:
1828        case WLAN_CIPHER_SUITE_GCMP_256:
1829                result = ieee80211_crypto_gcmp_decrypt(rx);
1830                break;
1831        default:
1832                result = ieee80211_crypto_hw_decrypt(rx);
1833        }
1834
1835        /* the hdr variable is invalid after the decrypt handlers */
1836
1837        /* either the frame has been decrypted or will be dropped */
1838        status->flag |= RX_FLAG_DECRYPTED;
1839
1840        return result;
1841}
1842
1843static inline struct ieee80211_fragment_entry *
1844ieee80211_reassemble_add(struct ieee80211_sub_if_data *sdata,
1845                         unsigned int frag, unsigned int seq, int rx_queue,
1846                         struct sk_buff **skb)
1847{
1848        struct ieee80211_fragment_entry *entry;
1849
1850        entry = &sdata->fragments[sdata->fragment_next++];
1851        if (sdata->fragment_next >= IEEE80211_FRAGMENT_MAX)
1852                sdata->fragment_next = 0;
1853
1854        if (!skb_queue_empty(&entry->skb_list))
1855                __skb_queue_purge(&entry->skb_list);
1856
1857        __skb_queue_tail(&entry->skb_list, *skb); /* no need for locking */
1858        *skb = NULL;
1859        entry->first_frag_time = jiffies;
1860        entry->seq = seq;
1861        entry->rx_queue = rx_queue;
1862        entry->last_frag = frag;
1863        entry->check_sequential_pn = false;
1864        entry->extra_len = 0;
1865
1866        return entry;
1867}
1868
1869static inline struct ieee80211_fragment_entry *
1870ieee80211_reassemble_find(struct ieee80211_sub_if_data *sdata,
1871                          unsigned int frag, unsigned int seq,
1872                          int rx_queue, struct ieee80211_hdr *hdr)
1873{
1874        struct ieee80211_fragment_entry *entry;
1875        int i, idx;
1876
1877        idx = sdata->fragment_next;
1878        for (i = 0; i < IEEE80211_FRAGMENT_MAX; i++) {
1879                struct ieee80211_hdr *f_hdr;
1880
1881                idx--;
1882                if (idx < 0)
1883                        idx = IEEE80211_FRAGMENT_MAX - 1;
1884
1885                entry = &sdata->fragments[idx];
1886                if (skb_queue_empty(&entry->skb_list) || entry->seq != seq ||
1887                    entry->rx_queue != rx_queue ||
1888                    entry->last_frag + 1 != frag)
1889                        continue;
1890
1891                f_hdr = (struct ieee80211_hdr *)entry->skb_list.next->data;
1892
1893                /*
1894                 * Check ftype and addresses are equal, else check next fragment
1895                 */
1896                if (((hdr->frame_control ^ f_hdr->frame_control) &
1897                     cpu_to_le16(IEEE80211_FCTL_FTYPE)) ||
1898                    !ether_addr_equal(hdr->addr1, f_hdr->addr1) ||
1899                    !ether_addr_equal(hdr->addr2, f_hdr->addr2))
1900                        continue;
1901
1902                if (time_after(jiffies, entry->first_frag_time + 2 * HZ)) {
1903                        __skb_queue_purge(&entry->skb_list);
1904                        continue;
1905                }
1906                return entry;
1907        }
1908
1909        return NULL;
1910}
1911
1912static ieee80211_rx_result debug_noinline
1913ieee80211_rx_h_defragment(struct ieee80211_rx_data *rx)
1914{
1915        struct ieee80211_hdr *hdr;
1916        u16 sc;
1917        __le16 fc;
1918        unsigned int frag, seq;
1919        struct ieee80211_fragment_entry *entry;
1920        struct sk_buff *skb;
1921        struct ieee80211_rx_status *status;
1922
1923        hdr = (struct ieee80211_hdr *)rx->skb->data;
1924        fc = hdr->frame_control;
1925
1926        if (ieee80211_is_ctl(fc))
1927                return RX_CONTINUE;
1928
1929        sc = le16_to_cpu(hdr->seq_ctrl);
1930        frag = sc & IEEE80211_SCTL_FRAG;
1931
1932        if (is_multicast_ether_addr(hdr->addr1)) {
1933                I802_DEBUG_INC(rx->local->dot11MulticastReceivedFrameCount);
1934                goto out_no_led;
1935        }
1936
1937        if (likely(!ieee80211_has_morefrags(fc) && frag == 0))
1938                goto out;
1939
1940        I802_DEBUG_INC(rx->local->rx_handlers_fragments);
1941
1942        if (skb_linearize(rx->skb))
1943                return RX_DROP_UNUSABLE;
1944
1945        /*
1946         *  skb_linearize() might change the skb->data and
1947         *  previously cached variables (in this case, hdr) need to
1948         *  be refreshed with the new data.
1949         */
1950        hdr = (struct ieee80211_hdr *)rx->skb->data;
1951        seq = (sc & IEEE80211_SCTL_SEQ) >> 4;
1952
1953        if (frag == 0) {
1954                /* This is the first fragment of a new frame. */
1955                entry = ieee80211_reassemble_add(rx->sdata, frag, seq,
1956                                                 rx->seqno_idx, &(rx->skb));
1957                if (rx->key &&
1958                    (rx->key->conf.cipher == WLAN_CIPHER_SUITE_CCMP ||
1959                     rx->key->conf.cipher == WLAN_CIPHER_SUITE_CCMP_256 ||
1960                     rx->key->conf.cipher == WLAN_CIPHER_SUITE_GCMP ||
1961                     rx->key->conf.cipher == WLAN_CIPHER_SUITE_GCMP_256) &&
1962                    ieee80211_has_protected(fc)) {
1963                        int queue = rx->security_idx;
1964
1965                        /* Store CCMP/GCMP PN so that we can verify that the
1966                         * next fragment has a sequential PN value.
1967                         */
1968                        entry->check_sequential_pn = true;
1969                        memcpy(entry->last_pn,
1970                               rx->key->u.ccmp.rx_pn[queue],
1971                               IEEE80211_CCMP_PN_LEN);
1972                        BUILD_BUG_ON(offsetof(struct ieee80211_key,
1973                                              u.ccmp.rx_pn) !=
1974                                     offsetof(struct ieee80211_key,
1975                                              u.gcmp.rx_pn));
1976                        BUILD_BUG_ON(sizeof(rx->key->u.ccmp.rx_pn[queue]) !=
1977                                     sizeof(rx->key->u.gcmp.rx_pn[queue]));
1978                        BUILD_BUG_ON(IEEE80211_CCMP_PN_LEN !=
1979                                     IEEE80211_GCMP_PN_LEN);
1980                }
1981                return RX_QUEUED;
1982        }
1983
1984        /* This is a fragment for a frame that should already be pending in
1985         * fragment cache. Add this fragment to the end of the pending entry.
1986         */
1987        entry = ieee80211_reassemble_find(rx->sdata, frag, seq,
1988                                          rx->seqno_idx, hdr);
1989        if (!entry) {
1990                I802_DEBUG_INC(rx->local->rx_handlers_drop_defrag);
1991                return RX_DROP_MONITOR;
1992        }
1993
1994        /* "The receiver shall discard MSDUs and MMPDUs whose constituent
1995         *  MPDU PN values are not incrementing in steps of 1."
1996         * see IEEE P802.11-REVmc/D5.0, 12.5.3.4.4, item d (for CCMP)
1997         * and IEEE P802.11-REVmc/D5.0, 12.5.5.4.4, item d (for GCMP)
1998         */
1999        if (entry->check_sequential_pn) {
2000                int i;
2001                u8 pn[IEEE80211_CCMP_PN_LEN], *rpn;
2002                int queue;
2003
2004                if (!rx->key ||
2005                    (rx->key->conf.cipher != WLAN_CIPHER_SUITE_CCMP &&
2006                     rx->key->conf.cipher != WLAN_CIPHER_SUITE_CCMP_256 &&
2007                     rx->key->conf.cipher != WLAN_CIPHER_SUITE_GCMP &&
2008                     rx->key->conf.cipher != WLAN_CIPHER_SUITE_GCMP_256))
2009                        return RX_DROP_UNUSABLE;
2010                memcpy(pn, entry->last_pn, IEEE80211_CCMP_PN_LEN);
2011                for (i = IEEE80211_CCMP_PN_LEN - 1; i >= 0; i--) {
2012                        pn[i]++;
2013                        if (pn[i])
2014                                break;
2015                }
2016                queue = rx->security_idx;
2017                rpn = rx->key->u.ccmp.rx_pn[queue];
2018                if (memcmp(pn, rpn, IEEE80211_CCMP_PN_LEN))
2019                        return RX_DROP_UNUSABLE;
2020                memcpy(entry->last_pn, pn, IEEE80211_CCMP_PN_LEN);
2021        }
2022
2023        skb_pull(rx->skb, ieee80211_hdrlen(fc));
2024        __skb_queue_tail(&entry->skb_list, rx->skb);
2025        entry->last_frag = frag;
2026        entry->extra_len += rx->skb->len;
2027        if (ieee80211_has_morefrags(fc)) {
2028                rx->skb = NULL;
2029                return RX_QUEUED;
2030        }
2031
2032        rx->skb = __skb_dequeue(&entry->skb_list);
2033        if (skb_tailroom(rx->skb) < entry->extra_len) {
2034                I802_DEBUG_INC(rx->local->rx_expand_skb_head_defrag);
2035                if (unlikely(pskb_expand_head(rx->skb, 0, entry->extra_len,
2036                                              GFP_ATOMIC))) {
2037                        I802_DEBUG_INC(rx->local->rx_handlers_drop_defrag);
2038                        __skb_queue_purge(&entry->skb_list);
2039                        return RX_DROP_UNUSABLE;
2040                }
2041        }
2042        while ((skb = __skb_dequeue(&entry->skb_list))) {
2043                memcpy(skb_put(rx->skb, skb->len), skb->data, skb->len);
2044                dev_kfree_skb(skb);
2045        }
2046
2047        /* Complete frame has been reassembled - process it now */
2048        status = IEEE80211_SKB_RXCB(rx->skb);
2049
2050 out:
2051        ieee80211_led_rx(rx->local);
2052 out_no_led:
2053        if (rx->sta)
2054                rx->sta->rx_stats.packets++;
2055        return RX_CONTINUE;
2056}
2057
2058static int ieee80211_802_1x_port_control(struct ieee80211_rx_data *rx)
2059{
2060        if (unlikely(!rx->sta || !test_sta_flag(rx->sta, WLAN_STA_AUTHORIZED)))
2061                return -EACCES;
2062
2063        return 0;
2064}
2065
2066static int ieee80211_drop_unencrypted(struct ieee80211_rx_data *rx, __le16 fc)
2067{
2068        struct sk_buff *skb = rx->skb;
2069        struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
2070
2071        /*
2072         * Pass through unencrypted frames if the hardware has
2073         * decrypted them already.
2074         */
2075        if (status->flag & RX_FLAG_DECRYPTED)
2076                return 0;
2077
2078        /* Drop unencrypted frames if key is set. */
2079        if (unlikely(!ieee80211_has_protected(fc) &&
2080                     !ieee80211_is_nullfunc(fc) &&
2081                     ieee80211_is_data(fc) && rx->key))
2082                return -EACCES;
2083
2084        return 0;
2085}
2086
2087static int ieee80211_drop_unencrypted_mgmt(struct ieee80211_rx_data *rx)
2088{
2089        struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
2090        struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb);
2091        __le16 fc = hdr->frame_control;
2092
2093        /*
2094         * Pass through unencrypted frames if the hardware has
2095         * decrypted them already.
2096         */
2097        if (status->flag & RX_FLAG_DECRYPTED)
2098                return 0;
2099
2100        if (rx->sta && test_sta_flag(rx->sta, WLAN_STA_MFP)) {
2101                if (unlikely(!ieee80211_has_protected(fc) &&
2102                             ieee80211_is_unicast_robust_mgmt_frame(rx->skb) &&
2103                             rx->key)) {
2104                        if (ieee80211_is_deauth(fc) ||
2105                            ieee80211_is_disassoc(fc))
2106                                cfg80211_rx_unprot_mlme_mgmt(rx->sdata->dev,
2107                                                             rx->skb->data,
2108                                                             rx->skb->len);
2109                        return -EACCES;
2110                }
2111                /* BIP does not use Protected field, so need to check MMIE */
2112                if (unlikely(ieee80211_is_multicast_robust_mgmt_frame(rx->skb) &&
2113                             ieee80211_get_mmie_keyidx(rx->skb) < 0)) {
2114                        if (ieee80211_is_deauth(fc) ||
2115                            ieee80211_is_disassoc(fc))
2116                                cfg80211_rx_unprot_mlme_mgmt(rx->sdata->dev,
2117                                                             rx->skb->data,
2118                                                             rx->skb->len);
2119                        return -EACCES;
2120                }
2121                /*
2122                 * When using MFP, Action frames are not allowed prior to
2123                 * having configured keys.
2124                 */
2125                if (unlikely(ieee80211_is_action(fc) && !rx->key &&
2126                             ieee80211_is_robust_mgmt_frame(rx->skb)))
2127                        return -EACCES;
2128        }
2129
2130        return 0;
2131}
2132
2133static int
2134__ieee80211_data_to_8023(struct ieee80211_rx_data *rx, bool *port_control)
2135{
2136        struct ieee80211_sub_if_data *sdata = rx->sdata;
2137        struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
2138        bool check_port_control = false;
2139        struct ethhdr *ehdr;
2140        int ret;
2141
2142        *port_control = false;
2143        if (ieee80211_has_a4(hdr->frame_control) &&
2144            sdata->vif.type == NL80211_IFTYPE_AP_VLAN && !sdata->u.vlan.sta)
2145                return -1;
2146
2147        if (sdata->vif.type == NL80211_IFTYPE_STATION &&
2148            !!sdata->u.mgd.use_4addr != !!ieee80211_has_a4(hdr->frame_control)) {
2149
2150                if (!sdata->u.mgd.use_4addr)
2151                        return -1;
2152                else
2153                        check_port_control = true;
2154        }
2155
2156        if (is_multicast_ether_addr(hdr->addr1) &&
2157            sdata->vif.type == NL80211_IFTYPE_AP_VLAN && sdata->u.vlan.sta)
2158                return -1;
2159
2160        ret = ieee80211_data_to_8023(rx->skb, sdata->vif.addr, sdata->vif.type);
2161        if (ret < 0)
2162                return ret;
2163
2164        ehdr = (struct ethhdr *) rx->skb->data;
2165        if (ehdr->h_proto == rx->sdata->control_port_protocol)
2166                *port_control = true;
2167        else if (check_port_control)
2168                return -1;
2169
2170        return 0;
2171}
2172
2173/*
2174 * requires that rx->skb is a frame with ethernet header
2175 */
2176static bool ieee80211_frame_allowed(struct ieee80211_rx_data *rx, __le16 fc)
2177{
2178        static const u8 pae_group_addr[ETH_ALEN] __aligned(2)
2179                = { 0x01, 0x80, 0xC2, 0x00, 0x00, 0x03 };
2180        struct ethhdr *ehdr = (struct ethhdr *) rx->skb->data;
2181
2182        /*
2183         * Allow EAPOL frames to us/the PAE group address regardless
2184         * of whether the frame was encrypted or not.
2185         */
2186        if (ehdr->h_proto == rx->sdata->control_port_protocol &&
2187            (ether_addr_equal(ehdr->h_dest, rx->sdata->vif.addr) ||
2188             ether_addr_equal(ehdr->h_dest, pae_group_addr)))
2189                return true;
2190
2191        if (ieee80211_802_1x_port_control(rx) ||
2192            ieee80211_drop_unencrypted(rx, fc))
2193                return false;
2194
2195        return true;
2196}
2197
2198/*
2199 * requires that rx->skb is a frame with ethernet header
2200 */
2201static void
2202ieee80211_deliver_skb(struct ieee80211_rx_data *rx)
2203{
2204        struct ieee80211_sub_if_data *sdata = rx->sdata;
2205        struct net_device *dev = sdata->dev;
2206        struct sk_buff *skb, *xmit_skb;
2207        struct ethhdr *ehdr = (struct ethhdr *) rx->skb->data;
2208        struct sta_info *dsta;
2209
2210        skb = rx->skb;
2211        xmit_skb = NULL;
2212
2213        ieee80211_rx_stats(dev, skb->len);
2214
2215        if (rx->sta) {
2216                /* The seqno index has the same property as needed
2217                 * for the rx_msdu field, i.e. it is IEEE80211_NUM_TIDS
2218                 * for non-QoS-data frames. Here we know it's a data
2219                 * frame, so count MSDUs.
2220                 */
2221                u64_stats_update_begin(&rx->sta->rx_stats.syncp);
2222                rx->sta->rx_stats.msdu[rx->seqno_idx]++;
2223                u64_stats_update_end(&rx->sta->rx_stats.syncp);
2224        }
2225
2226        if ((sdata->vif.type == NL80211_IFTYPE_AP ||
2227             sdata->vif.type == NL80211_IFTYPE_AP_VLAN) &&
2228            !(sdata->flags & IEEE80211_SDATA_DONT_BRIDGE_PACKETS) &&
2229            (sdata->vif.type != NL80211_IFTYPE_AP_VLAN || !sdata->u.vlan.sta)) {
2230                if (is_multicast_ether_addr(ehdr->h_dest)) {
2231                        /*
2232                         * send multicast frames both to higher layers in
2233                         * local net stack and back to the wireless medium
2234                         */
2235                        xmit_skb = skb_copy(skb, GFP_ATOMIC);
2236                        if (!xmit_skb)
2237                                net_info_ratelimited("%s: failed to clone multicast frame\n",
2238                                                    dev->name);
2239                } else {
2240                        dsta = sta_info_get(sdata, skb->data);
2241                        if (dsta) {
2242                                /*
2243                                 * The destination station is associated to
2244                                 * this AP (in this VLAN), so send the frame
2245                                 * directly to it and do not pass it to local
2246                                 * net stack.
2247                                 */
2248                                xmit_skb = skb;
2249                                skb = NULL;
2250                        }
2251                }
2252        }
2253
2254#ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
2255        if (skb) {
2256                /* 'align' will only take the values 0 or 2 here since all
2257                 * frames are required to be aligned to 2-byte boundaries
2258                 * when being passed to mac80211; the code here works just
2259                 * as well if that isn't true, but mac80211 assumes it can
2260                 * access fields as 2-byte aligned (e.g. for ether_addr_equal)
2261                 */
2262                int align;
2263
2264                align = (unsigned long)(skb->data + sizeof(struct ethhdr)) & 3;
2265                if (align) {
2266                        if (WARN_ON(skb_headroom(skb) < 3)) {
2267                                dev_kfree_skb(skb);
2268                                skb = NULL;
2269                        } else {
2270                                u8 *data = skb->data;
2271                                size_t len = skb_headlen(skb);
2272                                skb->data -= align;
2273                                memmove(skb->data, data, len);
2274                                skb_set_tail_pointer(skb, len);
2275                        }
2276                }
2277        }
2278#endif
2279
2280        if (skb) {
2281                /* deliver to local stack */
2282                skb->protocol = eth_type_trans(skb, dev);
2283                memset(skb->cb, 0, sizeof(skb->cb));
2284                if (rx->napi)
2285                        napi_gro_receive(rx->napi, skb);
2286                else
2287                        netif_receive_skb(skb);
2288        }
2289
2290        if (xmit_skb) {
2291                /*
2292                 * Send to wireless media and increase priority by 256 to
2293                 * keep the received priority instead of reclassifying
2294                 * the frame (see cfg80211_classify8021d).
2295                 */
2296                xmit_skb->priority += 256;
2297                xmit_skb->protocol = htons(ETH_P_802_3);
2298                skb_reset_network_header(xmit_skb);
2299                skb_reset_mac_header(xmit_skb);
2300                dev_queue_xmit(xmit_skb);
2301        }
2302}
2303
2304static ieee80211_rx_result debug_noinline
2305ieee80211_rx_h_amsdu(struct ieee80211_rx_data *rx)
2306{
2307        struct net_device *dev = rx->sdata->dev;
2308        struct sk_buff *skb = rx->skb;
2309        struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
2310        __le16 fc = hdr->frame_control;
2311        struct sk_buff_head frame_list;
2312        struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb);
2313        struct ethhdr ethhdr;
2314        const u8 *check_da = ethhdr.h_dest, *check_sa = ethhdr.h_source;
2315
2316        if (unlikely(!ieee80211_is_data(fc)))
2317                return RX_CONTINUE;
2318
2319        if (unlikely(!ieee80211_is_data_present(fc)))
2320                return RX_DROP_MONITOR;
2321
2322        if (!(status->rx_flags & IEEE80211_RX_AMSDU))
2323                return RX_CONTINUE;
2324
2325        if (unlikely(ieee80211_has_a4(hdr->frame_control))) {
2326                switch (rx->sdata->vif.type) {
2327                case NL80211_IFTYPE_AP_VLAN:
2328                        if (!rx->sdata->u.vlan.sta)
2329                                return RX_DROP_UNUSABLE;
2330                        break;
2331                case NL80211_IFTYPE_STATION:
2332                        if (!rx->sdata->u.mgd.use_4addr)
2333                                return RX_DROP_UNUSABLE;
2334                        break;
2335                default:
2336                        return RX_DROP_UNUSABLE;
2337                }
2338                check_da = NULL;
2339                check_sa = NULL;
2340        } else switch (rx->sdata->vif.type) {
2341                case NL80211_IFTYPE_AP:
2342                case NL80211_IFTYPE_AP_VLAN:
2343                        check_da = NULL;
2344                        break;
2345                case NL80211_IFTYPE_STATION:
2346                        if (!rx->sta ||
2347                            !test_sta_flag(rx->sta, WLAN_STA_TDLS_PEER))
2348                                check_sa = NULL;
2349                        break;
2350                case NL80211_IFTYPE_MESH_POINT:
2351                        check_sa = NULL;
2352                        break;
2353                default:
2354                        break;
2355        }
2356
2357        if (is_multicast_ether_addr(hdr->addr1))
2358                return RX_DROP_UNUSABLE;
2359
2360        skb->dev = dev;
2361        __skb_queue_head_init(&frame_list);
2362
2363        if (ieee80211_data_to_8023_exthdr(skb, &ethhdr,
2364                                          rx->sdata->vif.addr,
2365                                          rx->sdata->vif.type))
2366                return RX_DROP_UNUSABLE;
2367
2368        ieee80211_amsdu_to_8023s(skb, &frame_list, dev->dev_addr,
2369                                 rx->sdata->vif.type,
2370                                 rx->local->hw.extra_tx_headroom,
2371                                 check_da, check_sa);
2372
2373        while (!skb_queue_empty(&frame_list)) {
2374                rx->skb = __skb_dequeue(&frame_list);
2375
2376                if (!ieee80211_frame_allowed(rx, fc)) {
2377                        dev_kfree_skb(rx->skb);
2378                        continue;
2379                }
2380
2381                ieee80211_deliver_skb(rx);
2382        }
2383
2384        return RX_QUEUED;
2385}
2386
2387#ifdef CONFIG_MAC80211_MESH
2388static ieee80211_rx_result
2389ieee80211_rx_h_mesh_fwding(struct ieee80211_rx_data *rx)
2390{
2391        struct ieee80211_hdr *fwd_hdr, *hdr;
2392        struct ieee80211_tx_info *info;
2393        struct ieee80211s_hdr *mesh_hdr;
2394        struct sk_buff *skb = rx->skb, *fwd_skb;
2395        struct ieee80211_local *local = rx->local;
2396        struct ieee80211_sub_if_data *sdata = rx->sdata;
2397        struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
2398        u16 ac, q, hdrlen;
2399
2400        hdr = (struct ieee80211_hdr *) skb->data;
2401        hdrlen = ieee80211_hdrlen(hdr->frame_control);
2402
2403        /* make sure fixed part of mesh header is there, also checks skb len */
2404        if (!pskb_may_pull(rx->skb, hdrlen + 6))
2405                return RX_DROP_MONITOR;
2406
2407        mesh_hdr = (struct ieee80211s_hdr *) (skb->data + hdrlen);
2408
2409        /* make sure full mesh header is there, also checks skb len */
2410        if (!pskb_may_pull(rx->skb,
2411                           hdrlen + ieee80211_get_mesh_hdrlen(mesh_hdr)))
2412                return RX_DROP_MONITOR;
2413
2414        /* reload pointers */
2415        hdr = (struct ieee80211_hdr *) skb->data;
2416        mesh_hdr = (struct ieee80211s_hdr *) (skb->data + hdrlen);
2417
2418        if (ieee80211_drop_unencrypted(rx, hdr->frame_control))
2419                return RX_DROP_MONITOR;
2420
2421        /* frame is in RMC, don't forward */
2422        if (ieee80211_is_data(hdr->frame_control) &&
2423            is_multicast_ether_addr(hdr->addr1) &&
2424            mesh_rmc_check(rx->sdata, hdr->addr3, mesh_hdr))
2425                return RX_DROP_MONITOR;
2426
2427        if (!ieee80211_is_data(hdr->frame_control))
2428                return RX_CONTINUE;
2429
2430        if (!mesh_hdr->ttl)
2431                return RX_DROP_MONITOR;
2432
2433        if (mesh_hdr->flags & MESH_FLAGS_AE) {
2434                struct mesh_path *mppath;
2435                char *proxied_addr;
2436                char *mpp_addr;
2437
2438                if (is_multicast_ether_addr(hdr->addr1)) {
2439                        mpp_addr = hdr->addr3;
2440                        proxied_addr = mesh_hdr->eaddr1;
2441                } else if (mesh_hdr->flags & MESH_FLAGS_AE_A5_A6) {
2442                        /* has_a4 already checked in ieee80211_rx_mesh_check */
2443                        mpp_addr = hdr->addr4;
2444                        proxied_addr = mesh_hdr->eaddr2;
2445                } else {
2446                        return RX_DROP_MONITOR;
2447                }
2448
2449                rcu_read_lock();
2450                mppath = mpp_path_lookup(sdata, proxied_addr);
2451                if (!mppath) {
2452                        mpp_path_add(sdata, proxied_addr, mpp_addr);
2453                } else {
2454                        spin_lock_bh(&mppath->state_lock);
2455                        if (!ether_addr_equal(mppath->mpp, mpp_addr))
2456                                memcpy(mppath->mpp, mpp_addr, ETH_ALEN);
2457                        mppath->exp_time = jiffies;
2458                        spin_unlock_bh(&mppath->state_lock);
2459                }
2460                rcu_read_unlock();
2461        }
2462
2463        /* Frame has reached destination.  Don't forward */
2464        if (!is_multicast_ether_addr(hdr->addr1) &&
2465            ether_addr_equal(sdata->vif.addr, hdr->addr3))
2466                return RX_CONTINUE;
2467
2468        ac = ieee80211_select_queue_80211(sdata, skb, hdr);
2469        q = sdata->vif.hw_queue[ac];
2470        if (ieee80211_queue_stopped(&local->hw, q)) {
2471                IEEE80211_IFSTA_MESH_CTR_INC(ifmsh, dropped_frames_congestion);
2472                return RX_DROP_MONITOR;
2473        }
2474        skb_set_queue_mapping(skb, q);
2475
2476        if (!--mesh_hdr->ttl) {
2477                IEEE80211_IFSTA_MESH_CTR_INC(ifmsh, dropped_frames_ttl);
2478                goto out;
2479        }
2480
2481        if (!ifmsh->mshcfg.dot11MeshForwarding)
2482                goto out;
2483
2484        fwd_skb = skb_copy(skb, GFP_ATOMIC);
2485        if (!fwd_skb) {
2486                net_info_ratelimited("%s: failed to clone mesh frame\n",
2487                                    sdata->name);
2488                goto out;
2489        }
2490
2491        fwd_hdr =  (struct ieee80211_hdr *) fwd_skb->data;
2492        fwd_hdr->frame_control &= ~cpu_to_le16(IEEE80211_FCTL_RETRY);
2493        info = IEEE80211_SKB_CB(fwd_skb);
2494        memset(info, 0, sizeof(*info));
2495        info->flags |= IEEE80211_TX_INTFL_NEED_TXPROCESSING;
2496        info->control.vif = &rx->sdata->vif;
2497        info->control.jiffies = jiffies;
2498        if (is_multicast_ether_addr(fwd_hdr->addr1)) {
2499                IEEE80211_IFSTA_MESH_CTR_INC(ifmsh, fwded_mcast);
2500                memcpy(fwd_hdr->addr2, sdata->vif.addr, ETH_ALEN);
2501                /* update power mode indication when forwarding */
2502                ieee80211_mps_set_frame_flags(sdata, NULL, fwd_hdr);
2503        } else if (!mesh_nexthop_lookup(sdata, fwd_skb)) {
2504                /* mesh power mode flags updated in mesh_nexthop_lookup */
2505                IEEE80211_IFSTA_MESH_CTR_INC(ifmsh, fwded_unicast);
2506        } else {
2507                /* unable to resolve next hop */
2508                mesh_path_error_tx(sdata, ifmsh->mshcfg.element_ttl,
2509                                   fwd_hdr->addr3, 0,
2510                                   WLAN_REASON_MESH_PATH_NOFORWARD,
2511                                   fwd_hdr->addr2);
2512                IEEE80211_IFSTA_MESH_CTR_INC(ifmsh, dropped_frames_no_route);
2513                kfree_skb(fwd_skb);
2514                return RX_DROP_MONITOR;
2515        }
2516
2517        IEEE80211_IFSTA_MESH_CTR_INC(ifmsh, fwded_frames);
2518        ieee80211_add_pending_skb(local, fwd_skb);
2519 out:
2520        if (is_multicast_ether_addr(hdr->addr1))
2521                return RX_CONTINUE;
2522        return RX_DROP_MONITOR;
2523}
2524#endif
2525
2526static ieee80211_rx_result debug_noinline
2527ieee80211_rx_h_data(struct ieee80211_rx_data *rx)
2528{
2529        struct ieee80211_sub_if_data *sdata = rx->sdata;
2530        struct ieee80211_local *local = rx->local;
2531        struct net_device *dev = sdata->dev;
2532        struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
2533        __le16 fc = hdr->frame_control;
2534        bool port_control;
2535        int err;
2536
2537        if (unlikely(!ieee80211_is_data(hdr->frame_control)))
2538                return RX_CONTINUE;
2539
2540        if (unlikely(!ieee80211_is_data_present(hdr->frame_control)))
2541                return RX_DROP_MONITOR;
2542
2543        /*
2544         * Send unexpected-4addr-frame event to hostapd. For older versions,
2545         * also drop the frame to cooked monitor interfaces.
2546         */
2547        if (ieee80211_has_a4(hdr->frame_control) &&
2548            sdata->vif.type == NL80211_IFTYPE_AP) {
2549                if (rx->sta &&
2550                    !test_and_set_sta_flag(rx->sta, WLAN_STA_4ADDR_EVENT))
2551                        cfg80211_rx_unexpected_4addr_frame(
2552                                rx->sdata->dev, rx->sta->sta.addr, GFP_ATOMIC);
2553                return RX_DROP_MONITOR;
2554        }
2555
2556        err = __ieee80211_data_to_8023(rx, &port_control);
2557        if (unlikely(err))
2558                return RX_DROP_UNUSABLE;
2559
2560        if (!ieee80211_frame_allowed(rx, fc))
2561                return RX_DROP_MONITOR;
2562
2563        /* directly handle TDLS channel switch requests/responses */
2564        if (unlikely(((struct ethhdr *)rx->skb->data)->h_proto ==
2565                                                cpu_to_be16(ETH_P_TDLS))) {
2566                struct ieee80211_tdls_data *tf = (void *)rx->skb->data;
2567
2568                if (pskb_may_pull(rx->skb,
2569                                  offsetof(struct ieee80211_tdls_data, u)) &&
2570                    tf->payload_type == WLAN_TDLS_SNAP_RFTYPE &&
2571                    tf->category == WLAN_CATEGORY_TDLS &&
2572                    (tf->action_code == WLAN_TDLS_CHANNEL_SWITCH_REQUEST ||
2573                     tf->action_code == WLAN_TDLS_CHANNEL_SWITCH_RESPONSE)) {
2574                        skb_queue_tail(&local->skb_queue_tdls_chsw, rx->skb);
2575                        schedule_work(&local->tdls_chsw_work);
2576                        if (rx->sta)
2577                                rx->sta->rx_stats.packets++;
2578
2579                        return RX_QUEUED;
2580                }
2581        }
2582
2583        if (rx->sdata->vif.type == NL80211_IFTYPE_AP_VLAN &&
2584            unlikely(port_control) && sdata->bss) {
2585                sdata = container_of(sdata->bss, struct ieee80211_sub_if_data,
2586                                     u.ap);
2587                dev = sdata->dev;
2588                rx->sdata = sdata;
2589        }
2590
2591        rx->skb->dev = dev;
2592
2593        if (!ieee80211_hw_check(&local->hw, SUPPORTS_DYNAMIC_PS) &&
2594            local->ps_sdata && local->hw.conf.dynamic_ps_timeout > 0 &&
2595            !is_multicast_ether_addr(
2596                    ((struct ethhdr *)rx->skb->data)->h_dest) &&
2597            (!local->scanning &&
2598             !test_bit(SDATA_STATE_OFFCHANNEL, &sdata->state)))
2599                mod_timer(&local->dynamic_ps_timer, jiffies +
2600                          msecs_to_jiffies(local->hw.conf.dynamic_ps_timeout));
2601
2602        ieee80211_deliver_skb(rx);
2603
2604        return RX_QUEUED;
2605}
2606
2607static ieee80211_rx_result debug_noinline
2608ieee80211_rx_h_ctrl(struct ieee80211_rx_data *rx, struct sk_buff_head *frames)
2609{
2610        struct sk_buff *skb = rx->skb;
2611        struct ieee80211_bar *bar = (struct ieee80211_bar *)skb->data;
2612        struct tid_ampdu_rx *tid_agg_rx;
2613        u16 start_seq_num;
2614        u16 tid;
2615
2616        if (likely(!ieee80211_is_ctl(bar->frame_control)))
2617                return RX_CONTINUE;
2618
2619        if (ieee80211_is_back_req(bar->frame_control)) {
2620                struct {
2621                        __le16 control, start_seq_num;
2622                } __packed bar_data;
2623                struct ieee80211_event event = {
2624                        .type = BAR_RX_EVENT,
2625                };
2626
2627                if (!rx->sta)
2628                        return RX_DROP_MONITOR;
2629
2630                if (skb_copy_bits(skb, offsetof(struct ieee80211_bar, control),
2631                                  &bar_data, sizeof(bar_data)))
2632                        return RX_DROP_MONITOR;
2633
2634                tid = le16_to_cpu(bar_data.control) >> 12;
2635
2636                if (!test_bit(tid, rx->sta->ampdu_mlme.agg_session_valid) &&
2637                    !test_and_set_bit(tid, rx->sta->ampdu_mlme.unexpected_agg))
2638                        ieee80211_send_delba(rx->sdata, rx->sta->sta.addr, tid,
2639                                             WLAN_BACK_RECIPIENT,
2640                                             WLAN_REASON_QSTA_REQUIRE_SETUP);
2641
2642                tid_agg_rx = rcu_dereference(rx->sta->ampdu_mlme.tid_rx[tid]);
2643                if (!tid_agg_rx)
2644                        return RX_DROP_MONITOR;
2645
2646                start_seq_num = le16_to_cpu(bar_data.start_seq_num) >> 4;
2647                event.u.ba.tid = tid;
2648                event.u.ba.ssn = start_seq_num;
2649                event.u.ba.sta = &rx->sta->sta;
2650
2651                /* reset session timer */
2652                if (tid_agg_rx->timeout)
2653                        mod_timer(&tid_agg_rx->session_timer,
2654                                  TU_TO_EXP_TIME(tid_agg_rx->timeout));
2655
2656                spin_lock(&tid_agg_rx->reorder_lock);
2657                /* release stored frames up to start of BAR */
2658                ieee80211_release_reorder_frames(rx->sdata, tid_agg_rx,
2659                                                 start_seq_num, frames);
2660                spin_unlock(&tid_agg_rx->reorder_lock);
2661
2662                drv_event_callback(rx->local, rx->sdata, &event);
2663
2664                kfree_skb(skb);
2665                return RX_QUEUED;
2666        }
2667
2668        /*
2669         * After this point, we only want management frames,
2670         * so we can drop all remaining control frames to
2671         * cooked monitor interfaces.
2672         */
2673        return RX_DROP_MONITOR;
2674}
2675
2676static void ieee80211_process_sa_query_req(struct ieee80211_sub_if_data *sdata,
2677                                           struct ieee80211_mgmt *mgmt,
2678                                           size_t len)
2679{
2680        struct ieee80211_local *local = sdata->local;
2681        struct sk_buff *skb;
2682        struct ieee80211_mgmt *resp;
2683
2684        if (!ether_addr_equal(mgmt->da, sdata->vif.addr)) {
2685                /* Not to own unicast address */
2686                return;
2687        }
2688
2689        if (!ether_addr_equal(mgmt->sa, sdata->u.mgd.bssid) ||
2690            !ether_addr_equal(mgmt->bssid, sdata->u.mgd.bssid)) {
2691                /* Not from the current AP or not associated yet. */
2692                return;
2693        }
2694
2695        if (len < 24 + 1 + sizeof(resp->u.action.u.sa_query)) {
2696                /* Too short SA Query request frame */
2697                return;
2698        }
2699
2700        skb = dev_alloc_skb(sizeof(*resp) + local->hw.extra_tx_headroom);
2701        if (skb == NULL)
2702                return;
2703
2704        skb_reserve(skb, local->hw.extra_tx_headroom);
2705        resp = (struct ieee80211_mgmt *) skb_put(skb, 24);
2706        memset(resp, 0, 24);
2707        memcpy(resp->da, mgmt->sa, ETH_ALEN);
2708        memcpy(resp->sa, sdata->vif.addr, ETH_ALEN);
2709        memcpy(resp->bssid, sdata->u.mgd.bssid, ETH_ALEN);
2710        resp->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
2711                                          IEEE80211_STYPE_ACTION);
2712        skb_put(skb, 1 + sizeof(resp->u.action.u.sa_query));
2713        resp->u.action.category = WLAN_CATEGORY_SA_QUERY;
2714        resp->u.action.u.sa_query.action = WLAN_ACTION_SA_QUERY_RESPONSE;
2715        memcpy(resp->u.action.u.sa_query.trans_id,
2716               mgmt->u.action.u.sa_query.trans_id,
2717               WLAN_SA_QUERY_TR_ID_LEN);
2718
2719        ieee80211_tx_skb(sdata, skb);
2720}
2721
2722static ieee80211_rx_result debug_noinline
2723ieee80211_rx_h_mgmt_check(struct ieee80211_rx_data *rx)
2724{
2725        struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *) rx->skb->data;
2726        struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb);
2727
2728        /*
2729         * From here on, look only at management frames.
2730         * Data and control frames are already handled,
2731         * and unknown (reserved) frames are useless.
2732         */
2733        if (rx->skb->len < 24)
2734                return RX_DROP_MONITOR;
2735
2736        if (!ieee80211_is_mgmt(mgmt->frame_control))
2737                return RX_DROP_MONITOR;
2738
2739        if (rx->sdata->vif.type == NL80211_IFTYPE_AP &&
2740            ieee80211_is_beacon(mgmt->frame_control) &&
2741            !(rx->flags & IEEE80211_RX_BEACON_REPORTED)) {
2742                int sig = 0;
2743
2744                if (ieee80211_hw_check(&rx->local->hw, SIGNAL_DBM))
2745                        sig = status->signal;
2746
2747                cfg80211_report_obss_beacon(rx->local->hw.wiphy,
2748                                            rx->skb->data, rx->skb->len,
2749                                            status->freq, sig);
2750                rx->flags |= IEEE80211_RX_BEACON_REPORTED;
2751        }
2752
2753        if (ieee80211_drop_unencrypted_mgmt(rx))
2754                return RX_DROP_UNUSABLE;
2755
2756        return RX_CONTINUE;
2757}
2758
2759static ieee80211_rx_result debug_noinline
2760ieee80211_rx_h_action(struct ieee80211_rx_data *rx)
2761{
2762        struct ieee80211_local *local = rx->local;
2763        struct ieee80211_sub_if_data *sdata = rx->sdata;
2764        struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *) rx->skb->data;
2765        struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb);
2766        int len = rx->skb->len;
2767
2768        if (!ieee80211_is_action(mgmt->frame_control))
2769                return RX_CONTINUE;
2770
2771        /* drop too small frames */
2772        if (len < IEEE80211_MIN_ACTION_SIZE)
2773                return RX_DROP_UNUSABLE;
2774
2775        if (!rx->sta && mgmt->u.action.category != WLAN_CATEGORY_PUBLIC &&
2776            mgmt->u.action.category != WLAN_CATEGORY_SELF_PROTECTED &&
2777            mgmt->u.action.category != WLAN_CATEGORY_SPECTRUM_MGMT)
2778                return RX_DROP_UNUSABLE;
2779
2780        switch (mgmt->u.action.category) {
2781        case WLAN_CATEGORY_HT:
2782                /* reject HT action frames from stations not supporting HT */
2783                if (!rx->sta->sta.ht_cap.ht_supported)
2784                        goto invalid;
2785
2786                if (sdata->vif.type != NL80211_IFTYPE_STATION &&
2787                    sdata->vif.type != NL80211_IFTYPE_MESH_POINT &&
2788                    sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
2789                    sdata->vif.type != NL80211_IFTYPE_AP &&
2790                    sdata->vif.type != NL80211_IFTYPE_ADHOC)
2791                        break;
2792
2793                /* verify action & smps_control/chanwidth are present */
2794                if (len < IEEE80211_MIN_ACTION_SIZE + 2)
2795                        goto invalid;
2796
2797                switch (mgmt->u.action.u.ht_smps.action) {
2798                case WLAN_HT_ACTION_SMPS: {
2799                        struct ieee80211_supported_band *sband;
2800                        enum ieee80211_smps_mode smps_mode;
2801
2802                        /* convert to HT capability */
2803                        switch (mgmt->u.action.u.ht_smps.smps_control) {
2804                        case WLAN_HT_SMPS_CONTROL_DISABLED:
2805                                smps_mode = IEEE80211_SMPS_OFF;
2806                                break;
2807                        case WLAN_HT_SMPS_CONTROL_STATIC:
2808                                smps_mode = IEEE80211_SMPS_STATIC;
2809                                break;
2810                        case WLAN_HT_SMPS_CONTROL_DYNAMIC:
2811                                smps_mode = IEEE80211_SMPS_DYNAMIC;
2812                                break;
2813                        default:
2814                                goto invalid;
2815                        }
2816
2817                        /* if no change do nothing */
2818                        if (rx->sta->sta.smps_mode == smps_mode)
2819                                goto handled;
2820                        rx->sta->sta.smps_mode = smps_mode;
2821
2822                        sband = rx->local->hw.wiphy->bands[status->band];
2823
2824                        rate_control_rate_update(local, sband, rx->sta,
2825                                                 IEEE80211_RC_SMPS_CHANGED);
2826                        goto handled;
2827                }
2828                case WLAN_HT_ACTION_NOTIFY_CHANWIDTH: {
2829                        struct ieee80211_supported_band *sband;
2830                        u8 chanwidth = mgmt->u.action.u.ht_notify_cw.chanwidth;
2831                        enum ieee80211_sta_rx_bandwidth max_bw, new_bw;
2832
2833                        /* If it doesn't support 40 MHz it can't change ... */
2834                        if (!(rx->sta->sta.ht_cap.cap &
2835                                        IEEE80211_HT_CAP_SUP_WIDTH_20_40))
2836                                goto handled;
2837
2838                        if (chanwidth == IEEE80211_HT_CHANWIDTH_20MHZ)
2839                                max_bw = IEEE80211_STA_RX_BW_20;
2840                        else
2841                                max_bw = ieee80211_sta_cap_rx_bw(rx->sta);
2842
2843                        /* set cur_max_bandwidth and recalc sta bw */
2844                        rx->sta->cur_max_bandwidth = max_bw;
2845                        new_bw = ieee80211_sta_cur_vht_bw(rx->sta);
2846
2847                        if (rx->sta->sta.bandwidth == new_bw)
2848                                goto handled;
2849
2850                        rx->sta->sta.bandwidth = new_bw;
2851                        sband = rx->local->hw.wiphy->bands[status->band];
2852
2853                        rate_control_rate_update(local, sband, rx->sta,
2854                                                 IEEE80211_RC_BW_CHANGED);
2855                        goto handled;
2856                }
2857                default:
2858                        goto invalid;
2859                }
2860
2861                break;
2862        case WLAN_CATEGORY_PUBLIC:
2863                if (len < IEEE80211_MIN_ACTION_SIZE + 1)
2864                        goto invalid;
2865                if (sdata->vif.type != NL80211_IFTYPE_STATION)
2866                        break;
2867                if (!rx->sta)
2868                        break;
2869                if (!ether_addr_equal(mgmt->bssid, sdata->u.mgd.bssid))
2870                        break;
2871                if (mgmt->u.action.u.ext_chan_switch.action_code !=
2872                                WLAN_PUB_ACTION_EXT_CHANSW_ANN)
2873                        break;
2874                if (len < offsetof(struct ieee80211_mgmt,
2875                                   u.action.u.ext_chan_switch.variable))
2876                        goto invalid;
2877                goto queue;
2878        case WLAN_CATEGORY_VHT:
2879                if (sdata->vif.type != NL80211_IFTYPE_STATION &&
2880                    sdata->vif.type != NL80211_IFTYPE_MESH_POINT &&
2881                    sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
2882                    sdata->vif.type != NL80211_IFTYPE_AP &&
2883                    sdata->vif.type != NL80211_IFTYPE_ADHOC)
2884                        break;
2885
2886                /* verify action code is present */
2887                if (len < IEEE80211_MIN_ACTION_SIZE + 1)
2888                        goto invalid;
2889
2890                switch (mgmt->u.action.u.vht_opmode_notif.action_code) {
2891                case WLAN_VHT_ACTION_OPMODE_NOTIF: {
2892                        u8 opmode;
2893
2894                        /* verify opmode is present */
2895                        if (len < IEEE80211_MIN_ACTION_SIZE + 2)
2896                                goto invalid;
2897
2898                        opmode = mgmt->u.action.u.vht_opmode_notif.operating_mode;
2899
2900                        ieee80211_vht_handle_opmode(rx->sdata, rx->sta,
2901                                                    opmode, status->band);
2902                        goto handled;
2903                }
2904                case WLAN_VHT_ACTION_GROUPID_MGMT: {
2905                        if (len < IEEE80211_MIN_ACTION_SIZE + 25)
2906                                goto invalid;
2907                        goto queue;
2908                }
2909                default:
2910                        break;
2911                }
2912                break;
2913        case WLAN_CATEGORY_BACK:
2914                if (sdata->vif.type != NL80211_IFTYPE_STATION &&
2915                    sdata->vif.type != NL80211_IFTYPE_MESH_POINT &&
2916                    sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
2917                    sdata->vif.type != NL80211_IFTYPE_AP &&
2918                    sdata->vif.type != NL80211_IFTYPE_ADHOC)
2919                        break;
2920
2921                /* verify action_code is present */
2922                if (len < IEEE80211_MIN_ACTION_SIZE + 1)
2923                        break;
2924
2925                switch (mgmt->u.action.u.addba_req.action_code) {
2926                case WLAN_ACTION_ADDBA_REQ:
2927                        if (len < (IEEE80211_MIN_ACTION_SIZE +
2928                                   sizeof(mgmt->u.action.u.addba_req)))
2929                                goto invalid;
2930                        break;
2931                case WLAN_ACTION_ADDBA_RESP:
2932                        if (len < (IEEE80211_MIN_ACTION_SIZE +
2933                                   sizeof(mgmt->u.action.u.addba_resp)))
2934                                goto invalid;
2935                        break;
2936                case WLAN_ACTION_DELBA:
2937                        if (len < (IEEE80211_MIN_ACTION_SIZE +
2938                                   sizeof(mgmt->u.action.u.delba)))
2939                                goto invalid;
2940                        break;
2941                default:
2942                        goto invalid;
2943                }
2944
2945                goto queue;
2946        case WLAN_CATEGORY_SPECTRUM_MGMT:
2947                /* verify action_code is present */
2948                if (len < IEEE80211_MIN_ACTION_SIZE + 1)
2949                        break;
2950
2951                switch (mgmt->u.action.u.measurement.action_code) {
2952                case WLAN_ACTION_SPCT_MSR_REQ:
2953                        if (status->band != NL80211_BAND_5GHZ)
2954                                break;
2955
2956                        if (len < (IEEE80211_MIN_ACTION_SIZE +
2957                                   sizeof(mgmt->u.action.u.measurement)))
2958                                break;
2959
2960                        if (sdata->vif.type != NL80211_IFTYPE_STATION)
2961                                break;
2962
2963                        ieee80211_process_measurement_req(sdata, mgmt, len);
2964                        goto handled;
2965                case WLAN_ACTION_SPCT_CHL_SWITCH: {
2966                        u8 *bssid;
2967                        if (len < (IEEE80211_MIN_ACTION_SIZE +
2968                                   sizeof(mgmt->u.action.u.chan_switch)))
2969                                break;
2970
2971                        if (sdata->vif.type != NL80211_IFTYPE_STATION &&
2972                            sdata->vif.type != NL80211_IFTYPE_ADHOC &&
2973                            sdata->vif.type != NL80211_IFTYPE_MESH_POINT)
2974                                break;
2975
2976                        if (sdata->vif.type == NL80211_IFTYPE_STATION)
2977                                bssid = sdata->u.mgd.bssid;
2978                        else if (sdata->vif.type == NL80211_IFTYPE_ADHOC)
2979                                bssid = sdata->u.ibss.bssid;
2980                        else if (sdata->vif.type == NL80211_IFTYPE_MESH_POINT)
2981                                bssid = mgmt->sa;
2982                        else
2983                                break;
2984
2985                        if (!ether_addr_equal(mgmt->bssid, bssid))
2986                                break;
2987
2988                        goto queue;
2989                        }
2990                }
2991                break;
2992        case WLAN_CATEGORY_SA_QUERY:
2993                if (len < (IEEE80211_MIN_ACTION_SIZE +
2994                           sizeof(mgmt->u.action.u.sa_query)))
2995                        break;
2996
2997                switch (mgmt->u.action.u.sa_query.action) {
2998                case WLAN_ACTION_SA_QUERY_REQUEST:
2999                        if (sdata->vif.type != NL80211_IFTYPE_STATION)
3000                                break;
3001                        ieee80211_process_sa_query_req(sdata, mgmt, len);
3002                        goto handled;
3003                }
3004                break;
3005        case WLAN_CATEGORY_SELF_PROTECTED:
3006                if (len < (IEEE80211_MIN_ACTION_SIZE +
3007                           sizeof(mgmt->u.action.u.self_prot.action_code)))
3008                        break;
3009
3010                switch (mgmt->u.action.u.self_prot.action_code) {
3011                case WLAN_SP_MESH_PEERING_OPEN:
3012                case WLAN_SP_MESH_PEERING_CLOSE:
3013                case WLAN_SP_MESH_PEERING_CONFIRM:
3014                        if (!ieee80211_vif_is_mesh(&sdata->vif))
3015                                goto invalid;
3016                        if (sdata->u.mesh.user_mpm)
3017                                /* userspace handles this frame */
3018                                break;
3019                        goto queue;
3020                case WLAN_SP_MGK_INFORM:
3021                case WLAN_SP_MGK_ACK:
3022                        if (!ieee80211_vif_is_mesh(&sdata->vif))
3023                                goto invalid;
3024                        break;
3025                }
3026                break;
3027        case WLAN_CATEGORY_MESH_ACTION:
3028                if (len < (IEEE80211_MIN_ACTION_SIZE +
3029                           sizeof(mgmt->u.action.u.mesh_action.action_code)))
3030                        break;
3031
3032                if (!ieee80211_vif_is_mesh(&sdata->vif))
3033                        break;
3034                if (mesh_action_is_path_sel(mgmt) &&
3035                    !mesh_path_sel_is_hwmp(sdata))
3036                        break;
3037                goto queue;
3038        }
3039
3040        return RX_CONTINUE;
3041
3042 invalid:
3043        status->rx_flags |= IEEE80211_RX_MALFORMED_ACTION_FRM;
3044        /* will return in the next handlers */
3045        return RX_CONTINUE;
3046
3047 handled:
3048        if (rx->sta)
3049                rx->sta->rx_stats.packets++;
3050        dev_kfree_skb(rx->skb);
3051        return RX_QUEUED;
3052
3053 queue:
3054        rx->skb->pkt_type = IEEE80211_SDATA_QUEUE_TYPE_FRAME;
3055        skb_queue_tail(&sdata->skb_queue, rx->skb);
3056        ieee80211_queue_work(&local->hw, &sdata->work);
3057        if (rx->sta)
3058                rx->sta->rx_stats.packets++;
3059        return RX_QUEUED;
3060}
3061
3062static ieee80211_rx_result debug_noinline
3063ieee80211_rx_h_userspace_mgmt(struct ieee80211_rx_data *rx)
3064{
3065        struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb);
3066        int sig = 0;
3067
3068        /* skip known-bad action frames and return them in the next handler */
3069        if (status->rx_flags & IEEE80211_RX_MALFORMED_ACTION_FRM)
3070                return RX_CONTINUE;
3071
3072        /*
3073         * Getting here means the kernel doesn't know how to handle
3074         * it, but maybe userspace does ... include returned frames
3075         * so userspace can register for those to know whether ones
3076         * it transmitted were processed or returned.
3077         */
3078
3079        if (ieee80211_hw_check(&rx->local->hw, SIGNAL_DBM))
3080                sig = status->signal;
3081
3082        if (cfg80211_rx_mgmt(&rx->sdata->wdev, status->freq, sig,
3083                             rx->skb->data, rx->skb->len, 0)) {
3084                if (rx->sta)
3085                        rx->sta->rx_stats.packets++;
3086                dev_kfree_skb(rx->skb);
3087                return RX_QUEUED;
3088        }
3089
3090        return RX_CONTINUE;
3091}
3092
3093static ieee80211_rx_result debug_noinline
3094ieee80211_rx_h_action_return(struct ieee80211_rx_data *rx)
3095{
3096        struct ieee80211_local *local = rx->local;
3097        struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *) rx->skb->data;
3098        struct sk_buff *nskb;
3099        struct ieee80211_sub_if_data *sdata = rx->sdata;
3100        struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb);
3101
3102        if (!ieee80211_is_action(mgmt->frame_control))
3103                return RX_CONTINUE;
3104
3105        /*
3106         * For AP mode, hostapd is responsible for handling any action
3107         * frames that we didn't handle, including returning unknown
3108         * ones. For all other modes we will return them to the sender,
3109         * setting the 0x80 bit in the action category, as required by
3110         * 802.11-2012 9.24.4.
3111         * Newer versions of hostapd shall also use the management frame
3112         * registration mechanisms, but older ones still use cooked
3113         * monitor interfaces so push all frames there.
3114         */
3115        if (!(status->rx_flags & IEEE80211_RX_MALFORMED_ACTION_FRM) &&
3116            (sdata->vif.type == NL80211_IFTYPE_AP ||
3117             sdata->vif.type == NL80211_IFTYPE_AP_VLAN))
3118                return RX_DROP_MONITOR;
3119
3120        if (is_multicast_ether_addr(mgmt->da))
3121                return RX_DROP_MONITOR;
3122
3123        /* do not return rejected action frames */
3124        if (mgmt->u.action.category & 0x80)
3125                return RX_DROP_UNUSABLE;
3126
3127        nskb = skb_copy_expand(rx->skb, local->hw.extra_tx_headroom, 0,
3128                               GFP_ATOMIC);
3129        if (nskb) {
3130                struct ieee80211_mgmt *nmgmt = (void *)nskb->data;
3131
3132                nmgmt->u.action.category |= 0x80;
3133                memcpy(nmgmt->da, nmgmt->sa, ETH_ALEN);
3134                memcpy(nmgmt->sa, rx->sdata->vif.addr, ETH_ALEN);
3135
3136                memset(nskb->cb, 0, sizeof(nskb->cb));
3137
3138                if (rx->sdata->vif.type == NL80211_IFTYPE_P2P_DEVICE) {
3139                        struct ieee80211_tx_info *info = IEEE80211_SKB_CB(nskb);
3140
3141                        info->flags = IEEE80211_TX_CTL_TX_OFFCHAN |
3142                                      IEEE80211_TX_INTFL_OFFCHAN_TX_OK |
3143                                      IEEE80211_TX_CTL_NO_CCK_RATE;
3144                        if (ieee80211_hw_check(&local->hw, QUEUE_CONTROL))
3145                                info->hw_queue =
3146                                        local->hw.offchannel_tx_hw_queue;
3147                }
3148
3149                __ieee80211_tx_skb_tid_band(rx->sdata, nskb, 7,
3150                                            status->band);
3151        }
3152        dev_kfree_skb(rx->skb);
3153        return RX_QUEUED;
3154}
3155
3156static ieee80211_rx_result debug_noinline
3157ieee80211_rx_h_mgmt(struct ieee80211_rx_data *rx)
3158{
3159        struct ieee80211_sub_if_data *sdata = rx->sdata;
3160        struct ieee80211_mgmt *mgmt = (void *)rx->skb->data;
3161        __le16 stype;
3162
3163        stype = mgmt->frame_control & cpu_to_le16(IEEE80211_FCTL_STYPE);
3164
3165        if (!ieee80211_vif_is_mesh(&sdata->vif) &&
3166            sdata->vif.type != NL80211_IFTYPE_ADHOC &&
3167            sdata->vif.type != NL80211_IFTYPE_OCB &&
3168            sdata->vif.type != NL80211_IFTYPE_STATION)
3169                return RX_DROP_MONITOR;
3170
3171        switch (stype) {
3172        case cpu_to_le16(IEEE80211_STYPE_AUTH):
3173        case cpu_to_le16(IEEE80211_STYPE_BEACON):
3174        case cpu_to_le16(IEEE80211_STYPE_PROBE_RESP):
3175                /* process for all: mesh, mlme, ibss */
3176                break;
3177        case cpu_to_le16(IEEE80211_STYPE_ASSOC_RESP):
3178        case cpu_to_le16(IEEE80211_STYPE_REASSOC_RESP):
3179        case cpu_to_le16(IEEE80211_STYPE_DEAUTH):
3180        case cpu_to_le16(IEEE80211_STYPE_DISASSOC):
3181                if (is_multicast_ether_addr(mgmt->da) &&
3182                    !is_broadcast_ether_addr(mgmt->da))
3183                        return RX_DROP_MONITOR;
3184
3185                /* process only for station */
3186                if (sdata->vif.type != NL80211_IFTYPE_STATION)
3187                        return RX_DROP_MONITOR;
3188                break;
3189        case cpu_to_le16(IEEE80211_STYPE_PROBE_REQ):
3190                /* process only for ibss and mesh */
3191                if (sdata->vif.type != NL80211_IFTYPE_ADHOC &&
3192                    sdata->vif.type != NL80211_IFTYPE_MESH_POINT)
3193                        return RX_DROP_MONITOR;
3194                break;
3195        default:
3196                return RX_DROP_MONITOR;
3197        }
3198
3199        /* queue up frame and kick off work to process it */
3200        rx->skb->pkt_type = IEEE80211_SDATA_QUEUE_TYPE_FRAME;
3201        skb_queue_tail(&sdata->skb_queue, rx->skb);
3202        ieee80211_queue_work(&rx->local->hw, &sdata->work);
3203        if (rx->sta)
3204                rx->sta->rx_stats.packets++;
3205
3206        return RX_QUEUED;
3207}
3208
3209static void ieee80211_rx_cooked_monitor(struct ieee80211_rx_data *rx,
3210                                        struct ieee80211_rate *rate)
3211{
3212        struct ieee80211_sub_if_data *sdata;
3213        struct ieee80211_local *local = rx->local;
3214        struct sk_buff *skb = rx->skb, *skb2;
3215        struct net_device *prev_dev = NULL;
3216        struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
3217        int needed_headroom;
3218
3219        /*
3220         * If cooked monitor has been processed already, then
3221         * don't do it again. If not, set the flag.
3222         */
3223        if (rx->flags & IEEE80211_RX_CMNTR)
3224                goto out_free_skb;
3225        rx->flags |= IEEE80211_RX_CMNTR;
3226
3227        /* If there are no cooked monitor interfaces, just free the SKB */
3228        if (!local->cooked_mntrs)
3229                goto out_free_skb;
3230
3231        /* vendor data is long removed here */
3232        status->flag &= ~RX_FLAG_RADIOTAP_VENDOR_DATA;
3233        /* room for the radiotap header based on driver features */
3234        needed_headroom = ieee80211_rx_radiotap_hdrlen(local, status, skb);
3235
3236        if (skb_headroom(skb) < needed_headroom &&
3237            pskb_expand_head(skb, needed_headroom, 0, GFP_ATOMIC))
3238                goto out_free_skb;
3239
3240        /* prepend radiotap information */
3241        ieee80211_add_rx_radiotap_header(local, skb, rate, needed_headroom,
3242                                         false);
3243
3244        skb_reset_mac_header(skb);
3245        skb->ip_summed = CHECKSUM_UNNECESSARY;
3246        skb->pkt_type = PACKET_OTHERHOST;
3247        skb->protocol = htons(ETH_P_802_2);
3248
3249        list_for_each_entry_rcu(sdata, &local->interfaces, list) {
3250                if (!ieee80211_sdata_running(sdata))
3251                        continue;
3252
3253                if (sdata->vif.type != NL80211_IFTYPE_MONITOR ||
3254                    !(sdata->u.mntr.flags & MONITOR_FLAG_COOK_FRAMES))
3255                        continue;
3256
3257                if (prev_dev) {
3258                        skb2 = skb_clone(skb, GFP_ATOMIC);
3259                        if (skb2) {
3260                                skb2->dev = prev_dev;
3261                                netif_receive_skb(skb2);
3262                        }
3263                }
3264
3265                prev_dev = sdata->dev;
3266                ieee80211_rx_stats(sdata->dev, skb->len);
3267        }
3268
3269        if (prev_dev) {
3270                skb->dev = prev_dev;
3271                netif_receive_skb(skb);
3272                return;
3273        }
3274
3275 out_free_skb:
3276        dev_kfree_skb(skb);
3277}
3278
3279static void ieee80211_rx_handlers_result(struct ieee80211_rx_data *rx,
3280                                         ieee80211_rx_result res)
3281{
3282        switch (res) {
3283        case RX_DROP_MONITOR:
3284                I802_DEBUG_INC(rx->sdata->local->rx_handlers_drop);
3285                if (rx->sta)
3286                        rx->sta->rx_stats.dropped++;
3287                /* fall through */
3288        case RX_CONTINUE: {
3289                struct ieee80211_rate *rate = NULL;
3290                struct ieee80211_supported_band *sband;
3291                struct ieee80211_rx_status *status;
3292
3293                status = IEEE80211_SKB_RXCB((rx->skb));
3294
3295                sband = rx->local->hw.wiphy->bands[status->band];
3296                if (!(status->flag & RX_FLAG_HT) &&
3297                    !(status->flag & RX_FLAG_VHT))
3298                        rate = &sband->bitrates[status->rate_idx];
3299
3300                ieee80211_rx_cooked_monitor(rx, rate);
3301                break;
3302                }
3303        case RX_DROP_UNUSABLE:
3304                I802_DEBUG_INC(rx->sdata->local->rx_handlers_drop);
3305                if (rx->sta)
3306                        rx->sta->rx_stats.dropped++;
3307                dev_kfree_skb(rx->skb);
3308                break;
3309        case RX_QUEUED:
3310                I802_DEBUG_INC(rx->sdata->local->rx_handlers_queued);
3311                break;
3312        }
3313}
3314
3315static void ieee80211_rx_handlers(struct ieee80211_rx_data *rx,
3316                                  struct sk_buff_head *frames)
3317{
3318        ieee80211_rx_result res = RX_DROP_MONITOR;
3319        struct sk_buff *skb;
3320
3321#define CALL_RXH(rxh)                   \
3322        do {                            \
3323                res = rxh(rx);          \
3324                if (res != RX_CONTINUE) \
3325                        goto rxh_next;  \
3326        } while (0)
3327
3328        /* Lock here to avoid hitting all of the data used in the RX
3329         * path (e.g. key data, station data, ...) concurrently when
3330         * a frame is released from the reorder buffer due to timeout
3331         * from the timer, potentially concurrently with RX from the
3332         * driver.
3333         */
3334        spin_lock_bh(&rx->local->rx_path_lock);
3335
3336        while ((skb = __skb_dequeue(frames))) {
3337                /*
3338                 * all the other fields are valid across frames
3339                 * that belong to an aMPDU since they are on the
3340                 * same TID from the same station
3341                 */
3342                rx->skb = skb;
3343
3344                CALL_RXH(ieee80211_rx_h_check_more_data);
3345                CALL_RXH(ieee80211_rx_h_uapsd_and_pspoll);
3346                CALL_RXH(ieee80211_rx_h_sta_process);
3347                CALL_RXH(ieee80211_rx_h_decrypt);
3348                CALL_RXH(ieee80211_rx_h_defragment);
3349                CALL_RXH(ieee80211_rx_h_michael_mic_verify);
3350                /* must be after MMIC verify so header is counted in MPDU mic */
3351#ifdef CONFIG_MAC80211_MESH
3352                if (ieee80211_vif_is_mesh(&rx->sdata->vif))
3353                        CALL_RXH(ieee80211_rx_h_mesh_fwding);
3354#endif
3355                CALL_RXH(ieee80211_rx_h_amsdu);
3356                CALL_RXH(ieee80211_rx_h_data);
3357
3358                /* special treatment -- needs the queue */
3359                res = ieee80211_rx_h_ctrl(rx, frames);
3360                if (res != RX_CONTINUE)
3361                        goto rxh_next;
3362
3363                CALL_RXH(ieee80211_rx_h_mgmt_check);
3364                CALL_RXH(ieee80211_rx_h_action);
3365                CALL_RXH(ieee80211_rx_h_userspace_mgmt);
3366                CALL_RXH(ieee80211_rx_h_action_return);
3367                CALL_RXH(ieee80211_rx_h_mgmt);
3368
3369 rxh_next:
3370                ieee80211_rx_handlers_result(rx, res);
3371
3372#undef CALL_RXH
3373        }
3374
3375        spin_unlock_bh(&rx->local->rx_path_lock);
3376}
3377
3378static void ieee80211_invoke_rx_handlers(struct ieee80211_rx_data *rx)
3379{
3380        struct sk_buff_head reorder_release;
3381        ieee80211_rx_result res = RX_DROP_MONITOR;
3382
3383        __skb_queue_head_init(&reorder_release);
3384
3385#define CALL_RXH(rxh)                   \
3386        do {                            \
3387                res = rxh(rx);          \
3388                if (res != RX_CONTINUE) \
3389                        goto rxh_next;  \
3390        } while (0)
3391
3392        CALL_RXH(ieee80211_rx_h_check_dup);
3393        CALL_RXH(ieee80211_rx_h_check);
3394
3395        ieee80211_rx_reorder_ampdu(rx, &reorder_release);
3396
3397        ieee80211_rx_handlers(rx, &reorder_release);
3398        return;
3399
3400 rxh_next:
3401        ieee80211_rx_handlers_result(rx, res);
3402
3403#undef CALL_RXH
3404}
3405
3406/*
3407 * This function makes calls into the RX path, therefore
3408 * it has to be invoked under RCU read lock.
3409 */
3410void ieee80211_release_reorder_timeout(struct sta_info *sta, int tid)
3411{
3412        struct sk_buff_head frames;
3413        struct ieee80211_rx_data rx = {
3414                .sta = sta,
3415                .sdata = sta->sdata,
3416                .local = sta->local,
3417                /* This is OK -- must be QoS data frame */
3418                .security_idx = tid,
3419                .seqno_idx = tid,
3420                .napi = NULL, /* must be NULL to not have races */
3421        };
3422        struct tid_ampdu_rx *tid_agg_rx;
3423
3424        tid_agg_rx = rcu_dereference(sta->ampdu_mlme.tid_rx[tid]);
3425        if (!tid_agg_rx)
3426                return;
3427
3428        __skb_queue_head_init(&frames);
3429
3430        spin_lock(&tid_agg_rx->reorder_lock);
3431        ieee80211_sta_reorder_release(sta->sdata, tid_agg_rx, &frames);
3432        spin_unlock(&tid_agg_rx->reorder_lock);
3433
3434        if (!skb_queue_empty(&frames)) {
3435                struct ieee80211_event event = {
3436                        .type = BA_FRAME_TIMEOUT,
3437                        .u.ba.tid = tid,
3438                        .u.ba.sta = &sta->sta,
3439                };
3440                drv_event_callback(rx.local, rx.sdata, &event);
3441        }
3442
3443        ieee80211_rx_handlers(&rx, &frames);
3444}
3445
3446void ieee80211_mark_rx_ba_filtered_frames(struct ieee80211_sta *pubsta, u8 tid,
3447                                          u16 ssn, u64 filtered,
3448                                          u16 received_mpdus)
3449{
3450        struct sta_info *sta;
3451        struct tid_ampdu_rx *tid_agg_rx;
3452        struct sk_buff_head frames;
3453        struct ieee80211_rx_data rx = {
3454                /* This is OK -- must be QoS data frame */
3455                .security_idx = tid,
3456                .seqno_idx = tid,
3457        };
3458        int i, diff;
3459
3460        if (WARN_ON(!pubsta || tid >= IEEE80211_NUM_TIDS))
3461                return;
3462
3463        __skb_queue_head_init(&frames);
3464
3465        sta = container_of(pubsta, struct sta_info, sta);
3466
3467        rx.sta = sta;
3468        rx.sdata = sta->sdata;
3469        rx.local = sta->local;
3470
3471        rcu_read_lock();
3472        tid_agg_rx = rcu_dereference(sta->ampdu_mlme.tid_rx[tid]);
3473        if (!tid_agg_rx)
3474                goto out;
3475
3476        spin_lock_bh(&tid_agg_rx->reorder_lock);
3477
3478        if (received_mpdus >= IEEE80211_SN_MODULO >> 1) {
3479                int release;
3480
3481                /* release all frames in the reorder buffer */
3482                release = (tid_agg_rx->head_seq_num + tid_agg_rx->buf_size) %
3483                           IEEE80211_SN_MODULO;
3484                ieee80211_release_reorder_frames(sta->sdata, tid_agg_rx,
3485                                                 release, &frames);
3486                /* update ssn to match received ssn */
3487                tid_agg_rx->head_seq_num = ssn;
3488        } else {
3489                ieee80211_release_reorder_frames(sta->sdata, tid_agg_rx, ssn,
3490                                                 &frames);
3491        }
3492
3493        /* handle the case that received ssn is behind the mac ssn.
3494         * it can be tid_agg_rx->buf_size behind and still be valid */
3495        diff = (tid_agg_rx->head_seq_num - ssn) & IEEE80211_SN_MASK;
3496        if (diff >= tid_agg_rx->buf_size) {
3497                tid_agg_rx->reorder_buf_filtered = 0;
3498                goto release;
3499        }
3500        filtered = filtered >> diff;
3501        ssn += diff;
3502
3503        /* update bitmap */
3504        for (i = 0; i < tid_agg_rx->buf_size; i++) {
3505                int index = (ssn + i) % tid_agg_rx->buf_size;
3506
3507                tid_agg_rx->reorder_buf_filtered &= ~BIT_ULL(index);
3508                if (filtered & BIT_ULL(i))
3509                        tid_agg_rx->reorder_buf_filtered |= BIT_ULL(index);
3510        }
3511
3512        /* now process also frames that the filter marking released */
3513        ieee80211_sta_reorder_release(sta->sdata, tid_agg_rx, &frames);
3514
3515release:
3516        spin_unlock_bh(&tid_agg_rx->reorder_lock);
3517
3518        ieee80211_rx_handlers(&rx, &frames);
3519
3520 out:
3521        rcu_read_unlock();
3522}
3523EXPORT_SYMBOL(ieee80211_mark_rx_ba_filtered_frames);
3524
3525/* main receive path */
3526
3527static bool ieee80211_accept_frame(struct ieee80211_rx_data *rx)
3528{
3529        struct ieee80211_sub_if_data *sdata = rx->sdata;
3530        struct sk_buff *skb = rx->skb;
3531        struct ieee80211_hdr *hdr = (void *)skb->data;
3532        struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
3533        u8 *bssid = ieee80211_get_bssid(hdr, skb->len, sdata->vif.type);
3534        int multicast = is_multicast_ether_addr(hdr->addr1);
3535
3536        switch (sdata->vif.type) {
3537        case NL80211_IFTYPE_STATION:
3538                if (!bssid && !sdata->u.mgd.use_4addr)
3539                        return false;
3540                if (multicast)
3541                        return true;
3542                return ether_addr_equal(sdata->vif.addr, hdr->addr1);
3543        case NL80211_IFTYPE_ADHOC:
3544                if (!bssid)
3545                        return false;
3546                if (ether_addr_equal(sdata->vif.addr, hdr->addr2) ||
3547                    ether_addr_equal(sdata->u.ibss.bssid, hdr->addr2))
3548                        return false;
3549                if (ieee80211_is_beacon(hdr->frame_control))
3550                        return true;
3551                if (!ieee80211_bssid_match(bssid, sdata->u.ibss.bssid))
3552                        return false;
3553                if (!multicast &&
3554                    !ether_addr_equal(sdata->vif.addr, hdr->addr1))
3555                        return false;
3556                if (!rx->sta) {
3557                        int rate_idx;
3558                        if (status->flag & (RX_FLAG_HT | RX_FLAG_VHT))
3559                                rate_idx = 0; /* TODO: HT/VHT rates */
3560                        else
3561                                rate_idx = status->rate_idx;
3562                        ieee80211_ibss_rx_no_sta(sdata, bssid, hdr->addr2,
3563                                                 BIT(rate_idx));
3564                }
3565                return true;
3566        case NL80211_IFTYPE_OCB:
3567                if (!bssid)
3568                        return false;
3569                if (!ieee80211_is_data_present(hdr->frame_control))
3570                        return false;
3571                if (!is_broadcast_ether_addr(bssid))
3572                        return false;
3573                if (!multicast &&
3574                    !ether_addr_equal(sdata->dev->dev_addr, hdr->addr1))
3575                        return false;
3576                if (!rx->sta) {
3577                        int rate_idx;
3578                        if (status->flag & RX_FLAG_HT)
3579                                rate_idx = 0; /* TODO: HT rates */
3580                        else
3581                                rate_idx = status->rate_idx;
3582                        ieee80211_ocb_rx_no_sta(sdata, bssid, hdr->addr2,
3583                                                BIT(rate_idx));
3584                }
3585                return true;
3586        case NL80211_IFTYPE_MESH_POINT:
3587                if (multicast)
3588                        return true;
3589                return ether_addr_equal(sdata->vif.addr, hdr->addr1);
3590        case NL80211_IFTYPE_AP_VLAN:
3591        case NL80211_IFTYPE_AP:
3592                if (!bssid)
3593                        return ether_addr_equal(sdata->vif.addr, hdr->addr1);
3594
3595                if (!ieee80211_bssid_match(bssid, sdata->vif.addr)) {
3596                        /*
3597                         * Accept public action frames even when the
3598                         * BSSID doesn't match, this is used for P2P
3599                         * and location updates. Note that mac80211
3600                         * itself never looks at these frames.
3601                         */
3602                        if (!multicast &&
3603                            !ether_addr_equal(sdata->vif.addr, hdr->addr1))
3604                                return false;
3605                        if (ieee80211_is_public_action(hdr, skb->len))
3606                                return true;
3607                        return ieee80211_is_beacon(hdr->frame_control);
3608                }
3609
3610                if (!ieee80211_has_tods(hdr->frame_control)) {
3611                        /* ignore data frames to TDLS-peers */
3612                        if (ieee80211_is_data(hdr->frame_control))
3613                                return false;
3614                        /* ignore action frames to TDLS-peers */
3615                        if (ieee80211_is_action(hdr->frame_control) &&
3616                            !is_broadcast_ether_addr(bssid) &&
3617                            !ether_addr_equal(bssid, hdr->addr1))
3618                                return false;
3619                }
3620                return true;
3621        case NL80211_IFTYPE_WDS:
3622                if (bssid || !ieee80211_is_data(hdr->frame_control))
3623                        return false;
3624                return ether_addr_equal(sdata->u.wds.remote_addr, hdr->addr2);
3625        case NL80211_IFTYPE_P2P_DEVICE:
3626                return ieee80211_is_public_action(hdr, skb->len) ||
3627                       ieee80211_is_probe_req(hdr->frame_control) ||
3628                       ieee80211_is_probe_resp(hdr->frame_control) ||
3629                       ieee80211_is_beacon(hdr->frame_control);
3630        case NL80211_IFTYPE_NAN:
3631                /* Currently no frames on NAN interface are allowed */
3632                return false;
3633        default:
3634                break;
3635        }
3636
3637        WARN_ON_ONCE(1);
3638        return false;
3639}
3640
3641void ieee80211_check_fast_rx(struct sta_info *sta)
3642{
3643        struct ieee80211_sub_if_data *sdata = sta->sdata;
3644        struct ieee80211_local *local = sdata->local;
3645        struct ieee80211_key *key;
3646        struct ieee80211_fast_rx fastrx = {
3647                .dev = sdata->dev,
3648                .vif_type = sdata->vif.type,
3649                .control_port_protocol = sdata->control_port_protocol,
3650        }, *old, *new = NULL;
3651        bool assign = false;
3652
3653        /* use sparse to check that we don't return without updating */
3654        __acquire(check_fast_rx);
3655
3656        BUILD_BUG_ON(sizeof(fastrx.rfc1042_hdr) != sizeof(rfc1042_header));
3657        BUILD_BUG_ON(sizeof(fastrx.rfc1042_hdr) != ETH_ALEN);
3658        ether_addr_copy(fastrx.rfc1042_hdr, rfc1042_header);
3659        ether_addr_copy(fastrx.vif_addr, sdata->vif.addr);
3660
3661        fastrx.uses_rss = ieee80211_hw_check(&local->hw, USES_RSS);
3662
3663        /* fast-rx doesn't do reordering */
3664        if (ieee80211_hw_check(&local->hw, AMPDU_AGGREGATION) &&
3665            !ieee80211_hw_check(&local->hw, SUPPORTS_REORDERING_BUFFER))
3666                goto clear;
3667
3668        switch (sdata->vif.type) {
3669        case NL80211_IFTYPE_STATION:
3670                /* 4-addr is harder to deal with, later maybe */
3671                if (sdata->u.mgd.use_4addr)
3672                        goto clear;
3673                /* software powersave is a huge mess, avoid all of it */
3674                if (ieee80211_hw_check(&local->hw, PS_NULLFUNC_STACK))
3675                        goto clear;
3676                if (ieee80211_hw_check(&local->hw, SUPPORTS_PS) &&
3677                    !ieee80211_hw_check(&local->hw, SUPPORTS_DYNAMIC_PS))
3678                        goto clear;
3679                if (sta->sta.tdls) {
3680                        fastrx.da_offs = offsetof(struct ieee80211_hdr, addr1);
3681                        fastrx.sa_offs = offsetof(struct ieee80211_hdr, addr2);
3682                        fastrx.expected_ds_bits = 0;
3683                } else {
3684                        fastrx.sta_notify = sdata->u.mgd.probe_send_count > 0;
3685                        fastrx.da_offs = offsetof(struct ieee80211_hdr, addr1);
3686                        fastrx.sa_offs = offsetof(struct ieee80211_hdr, addr3);
3687                        fastrx.expected_ds_bits =
3688                                cpu_to_le16(IEEE80211_FCTL_FROMDS);
3689                }
3690                break;
3691        case NL80211_IFTYPE_AP_VLAN:
3692        case NL80211_IFTYPE_AP:
3693                /* parallel-rx requires this, at least with calls to
3694                 * ieee80211_sta_ps_transition()
3695                 */
3696                if (!ieee80211_hw_check(&local->hw, AP_LINK_PS))
3697                        goto clear;
3698                fastrx.da_offs = offsetof(struct ieee80211_hdr, addr3);
3699                fastrx.sa_offs = offsetof(struct ieee80211_hdr, addr2);
3700                fastrx.expected_ds_bits = cpu_to_le16(IEEE80211_FCTL_TODS);
3701
3702                fastrx.internal_forward =
3703                        !(sdata->flags & IEEE80211_SDATA_DONT_BRIDGE_PACKETS) &&
3704                        (sdata->vif.type != NL80211_IFTYPE_AP_VLAN ||
3705                         !sdata->u.vlan.sta);
3706                break;
3707        default:
3708                goto clear;
3709        }
3710
3711        if (!test_sta_flag(sta, WLAN_STA_AUTHORIZED))
3712                goto clear;
3713
3714        rcu_read_lock();
3715        key = rcu_dereference(sta->ptk[sta->ptk_idx]);
3716        if (key) {
3717                switch (key->conf.cipher) {
3718                case WLAN_CIPHER_SUITE_TKIP:
3719                        /* we don't want to deal with MMIC in fast-rx */
3720                        goto clear_rcu;
3721                case WLAN_CIPHER_SUITE_CCMP:
3722                case WLAN_CIPHER_SUITE_CCMP_256:
3723                case WLAN_CIPHER_SUITE_GCMP:
3724                case WLAN_CIPHER_SUITE_GCMP_256:
3725                        break;
3726                default:
3727                        /* we also don't want to deal with WEP or cipher scheme
3728                         * since those require looking up the key idx in the
3729                         * frame, rather than assuming the PTK is used
3730                         * (we need to revisit this once we implement the real
3731                         * PTK index, which is now valid in the spec, but we
3732                         * haven't implemented that part yet)
3733                         */
3734                        goto clear_rcu;
3735                }
3736
3737                fastrx.key = true;
3738                fastrx.icv_len = key->conf.icv_len;
3739        }
3740
3741        assign = true;
3742 clear_rcu:
3743        rcu_read_unlock();
3744 clear:
3745        __release(check_fast_rx);
3746
3747        if (assign)
3748                new = kmemdup(&fastrx, sizeof(fastrx), GFP_KERNEL);
3749
3750        spin_lock_bh(&sta->lock);
3751        old = rcu_dereference_protected(sta->fast_rx, true);
3752        rcu_assign_pointer(sta->fast_rx, new);
3753        spin_unlock_bh(&sta->lock);
3754
3755        if (old)
3756                kfree_rcu(old, rcu_head);
3757}
3758
3759void ieee80211_clear_fast_rx(struct sta_info *sta)
3760{
3761        struct ieee80211_fast_rx *old;
3762
3763        spin_lock_bh(&sta->lock);
3764        old = rcu_dereference_protected(sta->fast_rx, true);
3765        RCU_INIT_POINTER(sta->fast_rx, NULL);
3766        spin_unlock_bh(&sta->lock);
3767
3768        if (old)
3769                kfree_rcu(old, rcu_head);
3770}
3771
3772void __ieee80211_check_fast_rx_iface(struct ieee80211_sub_if_data *sdata)
3773{
3774        struct ieee80211_local *local = sdata->local;
3775        struct sta_info *sta;
3776
3777        lockdep_assert_held(&local->sta_mtx);
3778
3779        list_for_each_entry_rcu(sta, &local->sta_list, list) {
3780                if (sdata != sta->sdata &&
3781                    (!sta->sdata->bss || sta->sdata->bss != sdata->bss))
3782                        continue;
3783                ieee80211_check_fast_rx(sta);
3784        }
3785}
3786
3787void ieee80211_check_fast_rx_iface(struct ieee80211_sub_if_data *sdata)
3788{
3789        struct ieee80211_local *local = sdata->local;
3790
3791        mutex_lock(&local->sta_mtx);
3792        __ieee80211_check_fast_rx_iface(sdata);
3793        mutex_unlock(&local->sta_mtx);
3794}
3795
3796static bool ieee80211_invoke_fast_rx(struct ieee80211_rx_data *rx,
3797                                     struct ieee80211_fast_rx *fast_rx)
3798{
3799        struct sk_buff *skb = rx->skb;
3800        struct ieee80211_hdr *hdr = (void *)skb->data;
3801        struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
3802        struct sta_info *sta = rx->sta;
3803        int orig_len = skb->len;
3804        int snap_offs = ieee80211_hdrlen(hdr->frame_control);
3805        struct {
3806                u8 snap[sizeof(rfc1042_header)];
3807                __be16 proto;
3808        } *payload __aligned(2);
3809        struct {
3810                u8 da[ETH_ALEN];
3811                u8 sa[ETH_ALEN];
3812        } addrs __aligned(2);
3813        struct ieee80211_sta_rx_stats *stats = &sta->rx_stats;
3814
3815        if (fast_rx->uses_rss)
3816                stats = this_cpu_ptr(sta->pcpu_rx_stats);
3817
3818        /* for parallel-rx, we need to have DUP_VALIDATED, otherwise we write
3819         * to a common data structure; drivers can implement that per queue
3820         * but we don't have that information in mac80211
3821         */
3822        if (!(status->flag & RX_FLAG_DUP_VALIDATED))
3823                return false;
3824
3825#define FAST_RX_CRYPT_FLAGS     (RX_FLAG_PN_VALIDATED | RX_FLAG_DECRYPTED)
3826
3827        /* If using encryption, we also need to have:
3828         *  - PN_VALIDATED: similar, but the implementation is tricky
3829         *  - DECRYPTED: necessary for PN_VALIDATED
3830         */
3831        if (fast_rx->key &&
3832            (status->flag & FAST_RX_CRYPT_FLAGS) != FAST_RX_CRYPT_FLAGS)
3833                return false;
3834
3835        /* we don't deal with A-MSDU deaggregation here */
3836        if (status->rx_flags & IEEE80211_RX_AMSDU)
3837                return false;
3838
3839        if (unlikely(!ieee80211_is_data_present(hdr->frame_control)))
3840                return false;
3841
3842        if (unlikely(ieee80211_is_frag(hdr)))
3843                return false;
3844
3845        /* Since our interface address cannot be multicast, this
3846         * implicitly also rejects multicast frames without the
3847         * explicit check.
3848         *
3849         * We shouldn't get any *data* frames not addressed to us
3850         * (AP mode will accept multicast *management* frames), but
3851         * punting here will make it go through the full checks in
3852         * ieee80211_accept_frame().
3853         */
3854        if (!ether_addr_equal(fast_rx->vif_addr, hdr->addr1))
3855                return false;
3856
3857        if ((hdr->frame_control & cpu_to_le16(IEEE80211_FCTL_FROMDS |
3858                                              IEEE80211_FCTL_TODS)) !=
3859            fast_rx->expected_ds_bits)
3860                goto drop;
3861
3862        /* assign the key to drop unencrypted frames (later)
3863         * and strip the IV/MIC if necessary
3864         */
3865        if (fast_rx->key && !(status->flag & RX_FLAG_IV_STRIPPED)) {
3866                /* GCMP header length is the same */
3867                snap_offs += IEEE80211_CCMP_HDR_LEN;
3868        }
3869
3870        if (!pskb_may_pull(skb, snap_offs + sizeof(*payload)))
3871                goto drop;
3872        payload = (void *)(skb->data + snap_offs);
3873
3874        if (!ether_addr_equal(payload->snap, fast_rx->rfc1042_hdr))
3875                return false;
3876
3877        /* Don't handle these here since they require special code.
3878         * Accept AARP and IPX even though they should come with a
3879         * bridge-tunnel header - but if we get them this way then
3880         * there's little point in discarding them.
3881         */
3882        if (unlikely(payload->proto == cpu_to_be16(ETH_P_TDLS) ||
3883                     payload->proto == fast_rx->control_port_protocol))
3884                return false;
3885
3886        /* after this point, don't punt to the slowpath! */
3887
3888        if (rx->key && !(status->flag & RX_FLAG_MIC_STRIPPED) &&
3889            pskb_trim(skb, skb->len - fast_rx->icv_len))
3890                goto drop;
3891
3892        if (unlikely(fast_rx->sta_notify)) {
3893                ieee80211_sta_rx_notify(rx->sdata, hdr);
3894                fast_rx->sta_notify = false;
3895        }
3896
3897        /* statistics part of ieee80211_rx_h_sta_process() */
3898        stats->last_rx = jiffies;
3899        stats->last_rate = sta_stats_encode_rate(status);
3900
3901        stats->fragments++;
3902
3903        if (!(status->flag & RX_FLAG_NO_SIGNAL_VAL)) {
3904                stats->last_signal = status->signal;
3905                if (!fast_rx->uses_rss)
3906                        ewma_signal_add(&sta->rx_stats_avg.signal,
3907                                        -status->signal);
3908        }
3909
3910        if (status->chains) {
3911                int i;
3912
3913                stats->chains = status->chains;
3914                for (i = 0; i < ARRAY_SIZE(status->chain_signal); i++) {
3915                        int signal = status->chain_signal[i];
3916
3917                        if (!(status->chains & BIT(i)))
3918                                continue;
3919
3920                        stats->chain_signal_last[i] = signal;
3921                        if (!fast_rx->uses_rss)
3922                                ewma_signal_add(&sta->rx_stats_avg.chain_signal[i],
3923                                                -signal);
3924                }
3925        }
3926        /* end of statistics */
3927
3928        if (rx->key && !ieee80211_has_protected(hdr->frame_control))
3929                goto drop;
3930
3931        /* do the header conversion - first grab the addresses */
3932        ether_addr_copy(addrs.da, skb->data + fast_rx->da_offs);
3933        ether_addr_copy(addrs.sa, skb->data + fast_rx->sa_offs);
3934        /* remove the SNAP but leave the ethertype */
3935        skb_pull(skb, snap_offs + sizeof(rfc1042_header));
3936        /* push the addresses in front */
3937        memcpy(skb_push(skb, sizeof(addrs)), &addrs, sizeof(addrs));
3938
3939        skb->dev = fast_rx->dev;
3940
3941        ieee80211_rx_stats(fast_rx->dev, skb->len);
3942
3943        /* The seqno index has the same property as needed
3944         * for the rx_msdu field, i.e. it is IEEE80211_NUM_TIDS
3945         * for non-QoS-data frames. Here we know it's a data
3946         * frame, so count MSDUs.
3947         */
3948        u64_stats_update_begin(&stats->syncp);
3949        stats->msdu[rx->seqno_idx]++;
3950        stats->bytes += orig_len;
3951        u64_stats_update_end(&stats->syncp);
3952
3953        if (fast_rx->internal_forward) {
3954                struct sk_buff *xmit_skb = NULL;
3955                bool multicast = is_multicast_ether_addr(skb->data);
3956
3957                if (multicast) {
3958                        xmit_skb = skb_copy(skb, GFP_ATOMIC);
3959                } else if (sta_info_get(rx->sdata, skb->data)) {
3960                        xmit_skb = skb;
3961                        skb = NULL;
3962                }
3963
3964                if (xmit_skb) {
3965                        /*
3966                         * Send to wireless media and increase priority by 256
3967                         * to keep the received priority instead of
3968                         * reclassifying the frame (see cfg80211_classify8021d).
3969                         */
3970                        xmit_skb->priority += 256;
3971                        xmit_skb->protocol = htons(ETH_P_802_3);
3972                        skb_reset_network_header(xmit_skb);
3973                        skb_reset_mac_header(xmit_skb);
3974                        dev_queue_xmit(xmit_skb);
3975                }
3976
3977                if (!skb)
3978                        return true;
3979        }
3980
3981        /* deliver to local stack */
3982        skb->protocol = eth_type_trans(skb, fast_rx->dev);
3983        memset(skb->cb, 0, sizeof(skb->cb));
3984        if (rx->napi)
3985                napi_gro_receive(rx->napi, skb);
3986        else
3987                netif_receive_skb(skb);
3988
3989        return true;
3990 drop:
3991        dev_kfree_skb(skb);
3992        stats->dropped++;
3993        return true;
3994}
3995
3996/*
3997 * This function returns whether or not the SKB
3998 * was destined for RX processing or not, which,
3999 * if consume is true, is equivalent to whether
4000 * or not the skb was consumed.
4001 */
4002static bool ieee80211_prepare_and_rx_handle(struct ieee80211_rx_data *rx,
4003                                            struct sk_buff *skb, bool consume)
4004{
4005        struct ieee80211_local *local = rx->local;
4006        struct ieee80211_sub_if_data *sdata = rx->sdata;
4007
4008        rx->skb = skb;
4009
4010        /* See if we can do fast-rx; if we have to copy we already lost,
4011         * so punt in that case. We should never have to deliver a data
4012         * frame to multiple interfaces anyway.
4013         *
4014         * We skip the ieee80211_accept_frame() call and do the necessary
4015         * checking inside ieee80211_invoke_fast_rx().
4016         */
4017        if (consume && rx->sta) {
4018                struct ieee80211_fast_rx *fast_rx;
4019
4020                fast_rx = rcu_dereference(rx->sta->fast_rx);
4021                if (fast_rx && ieee80211_invoke_fast_rx(rx, fast_rx))
4022                        return true;
4023        }
4024
4025        if (!ieee80211_accept_frame(rx))
4026                return false;
4027
4028        if (!consume) {
4029                skb = skb_copy(skb, GFP_ATOMIC);
4030                if (!skb) {
4031                        if (net_ratelimit())
4032                                wiphy_debug(local->hw.wiphy,
4033                                        "failed to copy skb for %s\n",
4034                                        sdata->name);
4035                        return true;
4036                }
4037
4038                rx->skb = skb;
4039        }
4040
4041        ieee80211_invoke_rx_handlers(rx);
4042        return true;
4043}
4044
4045/*
4046 * This is the actual Rx frames handler. as it belongs to Rx path it must
4047 * be called with rcu_read_lock protection.
4048 */
4049static void __ieee80211_rx_handle_packet(struct ieee80211_hw *hw,
4050                                         struct ieee80211_sta *pubsta,
4051                                         struct sk_buff *skb,
4052                                         struct napi_struct *napi)
4053{
4054        struct ieee80211_local *local = hw_to_local(hw);
4055        struct ieee80211_sub_if_data *sdata;
4056        struct ieee80211_hdr *hdr;
4057        __le16 fc;
4058        struct ieee80211_rx_data rx;
4059        struct ieee80211_sub_if_data *prev;
4060        struct rhlist_head *tmp;
4061        int err = 0;
4062
4063        fc = ((struct ieee80211_hdr *)skb->data)->frame_control;
4064        memset(&rx, 0, sizeof(rx));
4065        rx.skb = skb;
4066        rx.local = local;
4067        rx.napi = napi;
4068
4069        if (ieee80211_is_data(fc) || ieee80211_is_mgmt(fc))
4070                I802_DEBUG_INC(local->dot11ReceivedFragmentCount);
4071
4072        if (ieee80211_is_mgmt(fc)) {
4073                /* drop frame if too short for header */
4074                if (skb->len < ieee80211_hdrlen(fc))
4075                        err = -ENOBUFS;
4076                else
4077                        err = skb_linearize(skb);
4078        } else {
4079                err = !pskb_may_pull(skb, ieee80211_hdrlen(fc));
4080        }
4081
4082        if (err) {
4083                dev_kfree_skb(skb);
4084                return;
4085        }
4086
4087        hdr = (struct ieee80211_hdr *)skb->data;
4088        ieee80211_parse_qos(&rx);
4089        ieee80211_verify_alignment(&rx);
4090
4091        if (unlikely(ieee80211_is_probe_resp(hdr->frame_control) ||
4092                     ieee80211_is_beacon(hdr->frame_control)))
4093                ieee80211_scan_rx(local, skb);
4094
4095        if (ieee80211_is_data(fc)) {
4096                struct sta_info *sta, *prev_sta;
4097
4098                if (pubsta) {
4099                        rx.sta = container_of(pubsta, struct sta_info, sta);
4100                        rx.sdata = rx.sta->sdata;
4101                        if (ieee80211_prepare_and_rx_handle(&rx, skb, true))
4102                                return;
4103                        goto out;
4104                }
4105
4106                prev_sta = NULL;
4107
4108                for_each_sta_info(local, hdr->addr2, sta, tmp) {
4109                        if (!prev_sta) {
4110                                prev_sta = sta;
4111                                continue;
4112                        }
4113
4114                        rx.sta = prev_sta;
4115                        rx.sdata = prev_sta->sdata;
4116                        ieee80211_prepare_and_rx_handle(&rx, skb, false);
4117
4118                        prev_sta = sta;
4119                }
4120
4121                if (prev_sta) {
4122                        rx.sta = prev_sta;
4123                        rx.sdata = prev_sta->sdata;
4124
4125                        if (ieee80211_prepare_and_rx_handle(&rx, skb, true))
4126                                return;
4127                        goto out;
4128                }
4129        }
4130
4131        prev = NULL;
4132
4133        list_for_each_entry_rcu(sdata, &local->interfaces, list) {
4134                if (!ieee80211_sdata_running(sdata))
4135                        continue;
4136
4137                if (sdata->vif.type == NL80211_IFTYPE_MONITOR ||
4138                    sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
4139                        continue;
4140
4141                /*
4142                 * frame is destined for this interface, but if it's
4143                 * not also for the previous one we handle that after
4144                 * the loop to avoid copying the SKB once too much
4145                 */
4146
4147                if (!prev) {
4148                        prev = sdata;
4149                        continue;
4150                }
4151
4152                rx.sta = sta_info_get_bss(prev, hdr->addr2);
4153                rx.sdata = prev;
4154                ieee80211_prepare_and_rx_handle(&rx, skb, false);
4155
4156                prev = sdata;
4157        }
4158
4159        if (prev) {
4160                rx.sta = sta_info_get_bss(prev, hdr->addr2);
4161                rx.sdata = prev;
4162
4163                if (ieee80211_prepare_and_rx_handle(&rx, skb, true))
4164                        return;
4165        }
4166
4167 out:
4168        dev_kfree_skb(skb);
4169}
4170
4171/*
4172 * This is the receive path handler. It is called by a low level driver when an
4173 * 802.11 MPDU is received from the hardware.
4174 */
4175void ieee80211_rx_napi(struct ieee80211_hw *hw, struct ieee80211_sta *pubsta,
4176                       struct sk_buff *skb, struct napi_struct *napi)
4177{
4178        struct ieee80211_local *local = hw_to_local(hw);
4179        struct ieee80211_rate *rate = NULL;
4180        struct ieee80211_supported_band *sband;
4181        struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
4182
4183        WARN_ON_ONCE(softirq_count() == 0);
4184
4185        if (WARN_ON(status->band >= NUM_NL80211_BANDS))
4186                goto drop;
4187
4188        sband = local->hw.wiphy->bands[status->band];
4189        if (WARN_ON(!sband))
4190                goto drop;
4191
4192        /*
4193         * If we're suspending, it is possible although not too likely
4194         * that we'd be receiving frames after having already partially
4195         * quiesced the stack. We can't process such frames then since
4196         * that might, for example, cause stations to be added or other
4197         * driver callbacks be invoked.
4198         */
4199        if (unlikely(local->quiescing || local->suspended))
4200                goto drop;
4201
4202        /* We might be during a HW reconfig, prevent Rx for the same reason */
4203        if (unlikely(local->in_reconfig))
4204                goto drop;
4205
4206        /*
4207         * The same happens when we're not even started,
4208         * but that's worth a warning.
4209         */
4210        if (WARN_ON(!local->started))
4211                goto drop;
4212
4213        if (likely(!(status->flag & RX_FLAG_FAILED_PLCP_CRC))) {
4214                /*
4215                 * Validate the rate, unless a PLCP error means that
4216                 * we probably can't have a valid rate here anyway.
4217                 */
4218
4219                if (status->flag & RX_FLAG_HT) {
4220                        /*
4221                         * rate_idx is MCS index, which can be [0-76]
4222                         * as documented on:
4223                         *
4224                         * http://wireless.kernel.org/en/developers/Documentation/ieee80211/802.11n
4225                         *
4226                         * Anything else would be some sort of driver or
4227                         * hardware error. The driver should catch hardware
4228                         * errors.
4229                         */
4230                        if (WARN(status->rate_idx > 76,
4231                                 "Rate marked as an HT rate but passed "
4232                                 "status->rate_idx is not "
4233                                 "an MCS index [0-76]: %d (0x%02x)\n",
4234                                 status->rate_idx,
4235                                 status->rate_idx))
4236                                goto drop;
4237                } else if (status->flag & RX_FLAG_VHT) {
4238                        if (WARN_ONCE(status->rate_idx > 9 ||
4239                                      !status->vht_nss ||
4240                                      status->vht_nss > 8,
4241                                      "Rate marked as a VHT rate but data is invalid: MCS: %d, NSS: %d\n",
4242                                      status->rate_idx, status->vht_nss))
4243                                goto drop;
4244                } else {
4245                        if (WARN_ON(status->rate_idx >= sband->n_bitrates))
4246                                goto drop;
4247                        rate = &sband->bitrates[status->rate_idx];
4248                }
4249        }
4250
4251        status->rx_flags = 0;
4252
4253        /*
4254         * key references and virtual interfaces are protected using RCU
4255         * and this requires that we are in a read-side RCU section during
4256         * receive processing
4257         */
4258        rcu_read_lock();
4259
4260        /*
4261         * Frames with failed FCS/PLCP checksum are not returned,
4262         * all other frames are returned without radiotap header
4263         * if it was previously present.
4264         * Also, frames with less than 16 bytes are dropped.
4265         */
4266        skb = ieee80211_rx_monitor(local, skb, rate);
4267        if (!skb) {
4268                rcu_read_unlock();
4269                return;
4270        }
4271
4272        ieee80211_tpt_led_trig_rx(local,
4273                        ((struct ieee80211_hdr *)skb->data)->frame_control,
4274                        skb->len);
4275
4276        __ieee80211_rx_handle_packet(hw, pubsta, skb, napi);
4277
4278        rcu_read_unlock();
4279
4280        return;
4281 drop:
4282        kfree_skb(skb);
4283}
4284EXPORT_SYMBOL(ieee80211_rx_napi);
4285
4286/* This is a version of the rx handler that can be called from hard irq
4287 * context. Post the skb on the queue and schedule the tasklet */
4288void ieee80211_rx_irqsafe(struct ieee80211_hw *hw, struct sk_buff *skb)
4289{
4290        struct ieee80211_local *local = hw_to_local(hw);
4291
4292        BUILD_BUG_ON(sizeof(struct ieee80211_rx_status) > sizeof(skb->cb));
4293
4294        skb->pkt_type = IEEE80211_RX_MSG;
4295        skb_queue_tail(&local->skb_queue, skb);
4296        tasklet_schedule(&local->tasklet);
4297}
4298EXPORT_SYMBOL(ieee80211_rx_irqsafe);
Note: See TracBrowser for help on using the repository browser.