blob: bb73ed2d20b90e8ece75bdd41a331fecb9c9d7ac [file] [log] [blame]
Johannes Berg571ecf62007-07-27 15:43:22 +02001/*
2 * Copyright 2002-2005, Instant802 Networks, Inc.
3 * Copyright 2005-2006, Devicescape Software, Inc.
4 * Copyright 2006-2007 Jiri Benc <jbenc@suse.cz>
Johannes Berg84040802010-02-15 12:46:39 +02005 * Copyright 2007-2010 Johannes Berg <johannes@sipsolutions.net>
Johannes Berg571ecf62007-07-27 15:43:22 +02006 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
10 */
11
S.Çağlar Onurab466232008-02-14 17:36:47 +020012#include <linux/jiffies.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090013#include <linux/slab.h>
Johannes Berg571ecf62007-07-27 15:43:22 +020014#include <linux/kernel.h>
15#include <linux/skbuff.h>
16#include <linux/netdevice.h>
17#include <linux/etherdevice.h>
Johannes Bergd4e46a32007-09-14 11:10:24 -040018#include <linux/rcupdate.h>
Paul Gortmakerbc3b2d72011-07-15 11:47:34 -040019#include <linux/export.h>
Johannes Berg571ecf62007-07-27 15:43:22 +020020#include <net/mac80211.h>
21#include <net/ieee80211_radiotap.h>
Johannes Bergd26ad372012-02-20 11:38:41 +010022#include <asm/unaligned.h>
Johannes Berg571ecf62007-07-27 15:43:22 +020023
24#include "ieee80211_i.h"
Johannes Berg24487982009-04-23 18:52:52 +020025#include "driver-ops.h"
Johannes Berg2c8dccc2008-04-08 15:14:40 -040026#include "led.h"
Luis Carlos Cobo33b64eb2008-02-23 15:17:10 +010027#include "mesh.h"
Johannes Berg571ecf62007-07-27 15:43:22 +020028#include "wep.h"
29#include "wpa.h"
30#include "tkip.h"
31#include "wme.h"
Johannes Berg1d8d3de2011-12-16 15:28:57 +010032#include "rate.h"
Johannes Berg571ecf62007-07-27 15:43:22 +020033
Johannes Bergb2e77712007-09-26 15:19:39 +020034/*
35 * monitor mode reception
36 *
37 * This function cleans up the SKB, i.e. it removes all the stuff
38 * only useful for monitoring.
39 */
40static struct sk_buff *remove_monitor_info(struct ieee80211_local *local,
Johannes Berg0869aea2009-10-28 10:03:35 +010041 struct sk_buff *skb)
Johannes Bergb2e77712007-09-26 15:19:39 +020042{
Johannes Berg90b9e4462012-11-16 10:09:08 +010043 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
44
Johannes Bergb2e77712007-09-26 15:19:39 +020045 if (local->hw.flags & IEEE80211_HW_RX_INCLUDES_FCS) {
46 if (likely(skb->len > FCS_LEN))
Zhu Yie3cf8b32010-03-29 17:35:07 +080047 __pskb_trim(skb, skb->len - FCS_LEN);
Johannes Bergb2e77712007-09-26 15:19:39 +020048 else {
49 /* driver bug */
50 WARN_ON(1);
51 dev_kfree_skb(skb);
Dan Carpenter06247602012-11-27 20:31:19 +030052 return NULL;
Johannes Bergb2e77712007-09-26 15:19:39 +020053 }
54 }
55
Johannes Berg90b9e4462012-11-16 10:09:08 +010056 if (status->vendor_radiotap_len)
57 __pskb_pull(skb, status->vendor_radiotap_len);
58
Johannes Bergb2e77712007-09-26 15:19:39 +020059 return skb;
60}
61
Johannes Berg1df332e2012-10-26 00:09:11 +020062static inline int should_drop_frame(struct sk_buff *skb, int present_fcs_len)
Johannes Bergb2e77712007-09-26 15:19:39 +020063{
Johannes Bergf1d58c22009-06-17 13:13:00 +020064 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
Johannes Berg605f1a52012-11-22 10:20:58 +010065 struct ieee80211_hdr *hdr;
66
67 hdr = (void *)(skb->data + status->vendor_radiotap_len);
Johannes Bergb2e77712007-09-26 15:19:39 +020068
Johannes Berg4c298672012-07-05 11:34:31 +020069 if (status->flag & (RX_FLAG_FAILED_FCS_CRC |
70 RX_FLAG_FAILED_PLCP_CRC |
71 RX_FLAG_AMPDU_IS_ZEROLEN))
Johannes Bergb2e77712007-09-26 15:19:39 +020072 return 1;
Johannes Berg605f1a52012-11-22 10:20:58 +010073 if (unlikely(skb->len < 16 + present_fcs_len +
74 status->vendor_radiotap_len))
Johannes Bergb2e77712007-09-26 15:19:39 +020075 return 1;
Harvey Harrison87228f52008-06-11 14:21:59 -070076 if (ieee80211_is_ctl(hdr->frame_control) &&
77 !ieee80211_is_pspoll(hdr->frame_control) &&
78 !ieee80211_is_back_req(hdr->frame_control))
Johannes Bergb2e77712007-09-26 15:19:39 +020079 return 1;
80 return 0;
81}
82
Bruno Randolf601ae7f2008-05-08 19:22:43 +020083static int
Johannes Berg90b9e4462012-11-16 10:09:08 +010084ieee80211_rx_radiotap_space(struct ieee80211_local *local,
85 struct ieee80211_rx_status *status)
Bruno Randolf601ae7f2008-05-08 19:22:43 +020086{
87 int len;
88
89 /* always present fields */
90 len = sizeof(struct ieee80211_radiotap_header) + 9;
91
Johannes Berg90b9e4462012-11-16 10:09:08 +010092 /* allocate extra bitmap */
93 if (status->vendor_radiotap_len)
94 len += 4;
95
96 if (ieee80211_have_rx_timestamp(status)) {
97 len = ALIGN(len, 8);
Bruno Randolf601ae7f2008-05-08 19:22:43 +020098 len += 8;
Johannes Berg90b9e4462012-11-16 10:09:08 +010099 }
Johannes Berg7fee5372009-01-30 11:13:06 +0100100 if (local->hw.flags & IEEE80211_HW_SIGNAL_DBM)
Bruno Randolf601ae7f2008-05-08 19:22:43 +0200101 len += 1;
Bruno Randolf601ae7f2008-05-08 19:22:43 +0200102
Johannes Berg90b9e4462012-11-16 10:09:08 +0100103 /* padding for RX_FLAGS if necessary */
104 len = ALIGN(len, 2);
Bruno Randolf601ae7f2008-05-08 19:22:43 +0200105
Johannes Berg6d744ba2011-01-27 14:13:17 +0100106 if (status->flag & RX_FLAG_HT) /* HT info */
107 len += 3;
108
Johannes Berg4c298672012-07-05 11:34:31 +0200109 if (status->flag & RX_FLAG_AMPDU_DETAILS) {
Johannes Berg90b9e4462012-11-16 10:09:08 +0100110 len = ALIGN(len, 4);
Johannes Berg4c298672012-07-05 11:34:31 +0200111 len += 8;
112 }
113
Johannes Berg51648922012-11-22 23:00:18 +0100114 if (status->flag & RX_FLAG_VHT) {
115 len = ALIGN(len, 2);
116 len += 12;
117 }
118
Johannes Berg90b9e4462012-11-16 10:09:08 +0100119 if (status->vendor_radiotap_len) {
120 if (WARN_ON_ONCE(status->vendor_radiotap_align == 0))
121 status->vendor_radiotap_align = 1;
122 /* align standard part of vendor namespace */
123 len = ALIGN(len, 2);
124 /* allocate standard part of vendor namespace */
125 len += 6;
126 /* align vendor-defined part */
127 len = ALIGN(len, status->vendor_radiotap_align);
128 /* vendor-defined part is already in skb */
129 }
130
Bruno Randolf601ae7f2008-05-08 19:22:43 +0200131 return len;
132}
133
Johannes Berg00ea6de2012-09-05 15:54:51 +0200134/*
Bruno Randolf601ae7f2008-05-08 19:22:43 +0200135 * ieee80211_add_rx_radiotap_header - add radiotap header
136 *
137 * add a radiotap header containing all the fields which the hardware provided.
138 */
139static void
140ieee80211_add_rx_radiotap_header(struct ieee80211_local *local,
141 struct sk_buff *skb,
Bruno Randolf601ae7f2008-05-08 19:22:43 +0200142 struct ieee80211_rate *rate,
Felix Fietkau973ef212012-04-16 14:56:48 +0200143 int rtap_len, bool has_fcs)
Bruno Randolf601ae7f2008-05-08 19:22:43 +0200144{
Johannes Bergf1d58c22009-06-17 13:13:00 +0200145 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
Bruno Randolf601ae7f2008-05-08 19:22:43 +0200146 struct ieee80211_radiotap_header *rthdr;
147 unsigned char *pos;
Johannes Berg6a86b9c2009-10-28 09:58:52 +0100148 u16 rx_flags = 0;
Thomas Pedersenf4bda332012-11-13 10:46:27 -0800149 int mpdulen;
150
151 mpdulen = skb->len;
152 if (!(has_fcs && (local->hw.flags & IEEE80211_HW_RX_INCLUDES_FCS)))
153 mpdulen += FCS_LEN;
Bruno Randolf601ae7f2008-05-08 19:22:43 +0200154
155 rthdr = (struct ieee80211_radiotap_header *)skb_push(skb, rtap_len);
156 memset(rthdr, 0, rtap_len);
157
158 /* radiotap header, set always present flags */
159 rthdr->it_present =
160 cpu_to_le32((1 << IEEE80211_RADIOTAP_FLAGS) |
Bruno Randolf601ae7f2008-05-08 19:22:43 +0200161 (1 << IEEE80211_RADIOTAP_CHANNEL) |
162 (1 << IEEE80211_RADIOTAP_ANTENNA) |
163 (1 << IEEE80211_RADIOTAP_RX_FLAGS));
Johannes Berg90b9e4462012-11-16 10:09:08 +0100164 rthdr->it_len = cpu_to_le16(rtap_len + status->vendor_radiotap_len);
Bruno Randolf601ae7f2008-05-08 19:22:43 +0200165
Johannes Berg1df332e2012-10-26 00:09:11 +0200166 pos = (unsigned char *)(rthdr + 1);
Bruno Randolf601ae7f2008-05-08 19:22:43 +0200167
Johannes Berg90b9e4462012-11-16 10:09:08 +0100168 if (status->vendor_radiotap_len) {
169 rthdr->it_present |=
170 cpu_to_le32(BIT(IEEE80211_RADIOTAP_VENDOR_NAMESPACE)) |
171 cpu_to_le32(BIT(IEEE80211_RADIOTAP_EXT));
172 put_unaligned_le32(status->vendor_radiotap_bitmap, pos);
173 pos += 4;
174 }
175
Bruno Randolf601ae7f2008-05-08 19:22:43 +0200176 /* the order of the following fields is important */
177
178 /* IEEE80211_RADIOTAP_TSFT */
Thomas Pedersenf4bda332012-11-13 10:46:27 -0800179 if (ieee80211_have_rx_timestamp(status)) {
Johannes Berg90b9e4462012-11-16 10:09:08 +0100180 /* padding */
181 while ((pos - (u8 *)rthdr) & 7)
182 *pos++ = 0;
Thomas Pedersenf4bda332012-11-13 10:46:27 -0800183 put_unaligned_le64(
184 ieee80211_calculate_rx_timestamp(local, status,
185 mpdulen, 0),
186 pos);
Johannes Berg1df332e2012-10-26 00:09:11 +0200187 rthdr->it_present |= cpu_to_le32(1 << IEEE80211_RADIOTAP_TSFT);
Bruno Randolf601ae7f2008-05-08 19:22:43 +0200188 pos += 8;
189 }
190
191 /* IEEE80211_RADIOTAP_FLAGS */
Felix Fietkau973ef212012-04-16 14:56:48 +0200192 if (has_fcs && (local->hw.flags & IEEE80211_HW_RX_INCLUDES_FCS))
Bruno Randolf601ae7f2008-05-08 19:22:43 +0200193 *pos |= IEEE80211_RADIOTAP_F_FCS;
Johannes Bergaae89832009-03-13 12:52:10 +0100194 if (status->flag & (RX_FLAG_FAILED_FCS_CRC | RX_FLAG_FAILED_PLCP_CRC))
195 *pos |= IEEE80211_RADIOTAP_F_BADFCS;
Bruno Randolfb4f28bb2008-07-30 17:19:55 +0200196 if (status->flag & RX_FLAG_SHORTPRE)
197 *pos |= IEEE80211_RADIOTAP_F_SHORTPRE;
Bruno Randolf601ae7f2008-05-08 19:22:43 +0200198 pos++;
199
200 /* IEEE80211_RADIOTAP_RATE */
Johannes Berg56146182012-11-09 15:07:02 +0100201 if (!rate || status->flag & (RX_FLAG_HT | RX_FLAG_VHT)) {
Jouni Malinen0fb8ca42008-12-12 14:38:33 +0200202 /*
Johannes Bergf8d1ccf2011-11-08 12:28:33 +0100203 * Without rate information don't add it. If we have,
Mohammed Shafi Shajakhan38f37be2011-02-07 10:10:04 +0530204 * MCS information is a separate field in radiotap,
Johannes Berg73b48092011-04-18 17:05:21 +0200205 * added below. The byte here is needed as padding
206 * for the channel though, so initialise it to 0.
Jouni Malinen0fb8ca42008-12-12 14:38:33 +0200207 */
208 *pos = 0;
Jouni Malinen8d6f6582008-12-15 10:37:50 +0200209 } else {
Jouni Malinenebe6c7b2009-01-10 11:47:33 +0200210 rthdr->it_present |= cpu_to_le32(1 << IEEE80211_RADIOTAP_RATE);
Jouni Malinen0fb8ca42008-12-12 14:38:33 +0200211 *pos = rate->bitrate / 5;
Jouni Malinen8d6f6582008-12-15 10:37:50 +0200212 }
Bruno Randolf601ae7f2008-05-08 19:22:43 +0200213 pos++;
214
215 /* IEEE80211_RADIOTAP_CHANNEL */
Johannes Berg6a86b9c2009-10-28 09:58:52 +0100216 put_unaligned_le16(status->freq, pos);
Bruno Randolf601ae7f2008-05-08 19:22:43 +0200217 pos += 2;
218 if (status->band == IEEE80211_BAND_5GHZ)
Johannes Berg6a86b9c2009-10-28 09:58:52 +0100219 put_unaligned_le16(IEEE80211_CHAN_OFDM | IEEE80211_CHAN_5GHZ,
220 pos);
Johannes Berg56146182012-11-09 15:07:02 +0100221 else if (status->flag & (RX_FLAG_HT | RX_FLAG_VHT))
Johannes Berg5f0b7de2009-11-16 13:58:21 +0100222 put_unaligned_le16(IEEE80211_CHAN_DYN | IEEE80211_CHAN_2GHZ,
223 pos);
Johannes Bergf8d1ccf2011-11-08 12:28:33 +0100224 else if (rate && rate->flags & IEEE80211_RATE_ERP_G)
Johannes Berg6a86b9c2009-10-28 09:58:52 +0100225 put_unaligned_le16(IEEE80211_CHAN_OFDM | IEEE80211_CHAN_2GHZ,
226 pos);
Johannes Bergf8d1ccf2011-11-08 12:28:33 +0100227 else if (rate)
Johannes Berg6a86b9c2009-10-28 09:58:52 +0100228 put_unaligned_le16(IEEE80211_CHAN_CCK | IEEE80211_CHAN_2GHZ,
229 pos);
Johannes Bergf8d1ccf2011-11-08 12:28:33 +0100230 else
231 put_unaligned_le16(IEEE80211_CHAN_2GHZ, pos);
Bruno Randolf601ae7f2008-05-08 19:22:43 +0200232 pos += 2;
233
234 /* IEEE80211_RADIOTAP_DBM_ANTSIGNAL */
Felix Fietkaufe8431f2012-03-01 18:00:07 +0100235 if (local->hw.flags & IEEE80211_HW_SIGNAL_DBM &&
236 !(status->flag & RX_FLAG_NO_SIGNAL_VAL)) {
Bruno Randolf601ae7f2008-05-08 19:22:43 +0200237 *pos = status->signal;
238 rthdr->it_present |=
239 cpu_to_le32(1 << IEEE80211_RADIOTAP_DBM_ANTSIGNAL);
240 pos++;
241 }
242
Bruno Randolf601ae7f2008-05-08 19:22:43 +0200243 /* IEEE80211_RADIOTAP_LOCK_QUALITY is missing */
244
245 /* IEEE80211_RADIOTAP_ANTENNA */
246 *pos = status->antenna;
247 pos++;
248
Bruno Randolf601ae7f2008-05-08 19:22:43 +0200249 /* IEEE80211_RADIOTAP_DB_ANTNOISE is not used */
250
251 /* IEEE80211_RADIOTAP_RX_FLAGS */
252 /* ensure 2 byte alignment for the 2 byte field as required */
Johannes Berg6a86b9c2009-10-28 09:58:52 +0100253 if ((pos - (u8 *)rthdr) & 1)
Johannes Berg90b9e4462012-11-16 10:09:08 +0100254 *pos++ = 0;
Johannes Bergaae89832009-03-13 12:52:10 +0100255 if (status->flag & RX_FLAG_FAILED_PLCP_CRC)
Johannes Berg6a86b9c2009-10-28 09:58:52 +0100256 rx_flags |= IEEE80211_RADIOTAP_F_RX_BADPLCP;
257 put_unaligned_le16(rx_flags, pos);
Bruno Randolf601ae7f2008-05-08 19:22:43 +0200258 pos += 2;
Johannes Berg6d744ba2011-01-27 14:13:17 +0100259
260 if (status->flag & RX_FLAG_HT) {
261 rthdr->it_present |= cpu_to_le32(1 << IEEE80211_RADIOTAP_MCS);
Johannes Bergac55d2f2012-05-10 09:09:10 +0200262 *pos++ = local->hw.radiotap_mcs_details;
Johannes Berg6d744ba2011-01-27 14:13:17 +0100263 *pos = 0;
264 if (status->flag & RX_FLAG_SHORT_GI)
265 *pos |= IEEE80211_RADIOTAP_MCS_SGI;
266 if (status->flag & RX_FLAG_40MHZ)
267 *pos |= IEEE80211_RADIOTAP_MCS_BW_40;
Johannes Bergac55d2f2012-05-10 09:09:10 +0200268 if (status->flag & RX_FLAG_HT_GF)
269 *pos |= IEEE80211_RADIOTAP_MCS_FMT_GF;
Johannes Berg6d744ba2011-01-27 14:13:17 +0100270 pos++;
271 *pos++ = status->rate_idx;
272 }
Johannes Berg4c298672012-07-05 11:34:31 +0200273
274 if (status->flag & RX_FLAG_AMPDU_DETAILS) {
275 u16 flags = 0;
276
277 /* ensure 4 byte alignment */
278 while ((pos - (u8 *)rthdr) & 3)
279 pos++;
280 rthdr->it_present |=
281 cpu_to_le32(1 << IEEE80211_RADIOTAP_AMPDU_STATUS);
282 put_unaligned_le32(status->ampdu_reference, pos);
283 pos += 4;
284 if (status->flag & RX_FLAG_AMPDU_REPORT_ZEROLEN)
285 flags |= IEEE80211_RADIOTAP_AMPDU_REPORT_ZEROLEN;
286 if (status->flag & RX_FLAG_AMPDU_IS_ZEROLEN)
287 flags |= IEEE80211_RADIOTAP_AMPDU_IS_ZEROLEN;
288 if (status->flag & RX_FLAG_AMPDU_LAST_KNOWN)
289 flags |= IEEE80211_RADIOTAP_AMPDU_LAST_KNOWN;
290 if (status->flag & RX_FLAG_AMPDU_IS_LAST)
291 flags |= IEEE80211_RADIOTAP_AMPDU_IS_LAST;
292 if (status->flag & RX_FLAG_AMPDU_DELIM_CRC_ERROR)
293 flags |= IEEE80211_RADIOTAP_AMPDU_DELIM_CRC_ERR;
294 if (status->flag & RX_FLAG_AMPDU_DELIM_CRC_KNOWN)
295 flags |= IEEE80211_RADIOTAP_AMPDU_DELIM_CRC_KNOWN;
296 put_unaligned_le16(flags, pos);
297 pos += 2;
298 if (status->flag & RX_FLAG_AMPDU_DELIM_CRC_KNOWN)
299 *pos++ = status->ampdu_delimiter_crc;
300 else
301 *pos++ = 0;
302 *pos++ = 0;
303 }
Johannes Berg90b9e4462012-11-16 10:09:08 +0100304
Johannes Berg51648922012-11-22 23:00:18 +0100305 if (status->flag & RX_FLAG_VHT) {
306 u16 known = local->hw.radiotap_vht_details;
307
308 rthdr->it_present |= cpu_to_le32(1 << IEEE80211_RADIOTAP_VHT);
309 /* known field - how to handle 80+80? */
310 if (status->flag & RX_FLAG_80P80MHZ)
311 known &= ~IEEE80211_RADIOTAP_VHT_KNOWN_BANDWIDTH;
312 put_unaligned_le16(known, pos);
313 pos += 2;
314 /* flags */
315 if (status->flag & RX_FLAG_SHORT_GI)
316 *pos |= IEEE80211_RADIOTAP_VHT_FLAG_SGI;
317 pos++;
318 /* bandwidth */
319 if (status->flag & RX_FLAG_80MHZ)
320 *pos++ = 4;
321 else if (status->flag & RX_FLAG_80P80MHZ)
322 *pos++ = 0; /* marked not known above */
323 else if (status->flag & RX_FLAG_160MHZ)
324 *pos++ = 11;
325 else if (status->flag & RX_FLAG_40MHZ)
326 *pos++ = 1;
327 else /* 20 MHz */
328 *pos++ = 0;
329 /* MCS/NSS */
330 *pos = (status->rate_idx << 4) | status->vht_nss;
331 pos += 4;
332 /* coding field */
333 pos++;
334 /* group ID */
335 pos++;
336 /* partial_aid */
337 pos += 2;
338 }
339
Johannes Berg90b9e4462012-11-16 10:09:08 +0100340 if (status->vendor_radiotap_len) {
341 /* ensure 2 byte alignment for the vendor field as required */
342 if ((pos - (u8 *)rthdr) & 1)
343 *pos++ = 0;
344 *pos++ = status->vendor_radiotap_oui[0];
345 *pos++ = status->vendor_radiotap_oui[1];
346 *pos++ = status->vendor_radiotap_oui[2];
347 *pos++ = status->vendor_radiotap_subns;
348 put_unaligned_le16(status->vendor_radiotap_len, pos);
349 pos += 2;
350 /* align the actual payload as requested */
351 while ((pos - (u8 *)rthdr) & (status->vendor_radiotap_align - 1))
352 *pos++ = 0;
353 }
Bruno Randolf601ae7f2008-05-08 19:22:43 +0200354}
355
Johannes Bergb2e77712007-09-26 15:19:39 +0200356/*
357 * This function copies a received frame to all monitor interfaces and
358 * returns a cleaned-up SKB that no longer includes the FCS nor the
359 * radiotap header the driver might have added.
360 */
361static struct sk_buff *
362ieee80211_rx_monitor(struct ieee80211_local *local, struct sk_buff *origskb,
Johannes Berg8318d782008-01-24 19:38:38 +0100363 struct ieee80211_rate *rate)
Johannes Bergb2e77712007-09-26 15:19:39 +0200364{
Johannes Bergf1d58c22009-06-17 13:13:00 +0200365 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(origskb);
Johannes Bergb2e77712007-09-26 15:19:39 +0200366 struct ieee80211_sub_if_data *sdata;
Johannes Berg293702a2012-03-02 13:18:19 +0100367 int needed_headroom;
Johannes Bergb2e77712007-09-26 15:19:39 +0200368 struct sk_buff *skb, *skb2;
369 struct net_device *prev_dev = NULL;
370 int present_fcs_len = 0;
Johannes Bergb2e77712007-09-26 15:19:39 +0200371
372 /*
373 * First, we may need to make a copy of the skb because
374 * (1) we need to modify it for radiotap (if not present), and
375 * (2) the other RX handlers will modify the skb we got.
376 *
377 * We don't need to, of course, if we aren't going to return
378 * the SKB because it has a bad FCS/PLCP checksum.
379 */
Johannes Berg0869aea2009-10-28 10:03:35 +0100380
Johannes Bergb2e77712007-09-26 15:19:39 +0200381 if (local->hw.flags & IEEE80211_HW_RX_INCLUDES_FCS)
382 present_fcs_len = FCS_LEN;
383
Johannes Berg605f1a52012-11-22 10:20:58 +0100384 /* ensure hdr->frame_control and vendor radiotap data are in skb head */
385 if (!pskb_may_pull(origskb, 2 + status->vendor_radiotap_len)) {
Zhu Yie3cf8b32010-03-29 17:35:07 +0800386 dev_kfree_skb(origskb);
387 return NULL;
388 }
389
Johannes Bergb2e77712007-09-26 15:19:39 +0200390 if (!local->monitors) {
Johannes Berg0869aea2009-10-28 10:03:35 +0100391 if (should_drop_frame(origskb, present_fcs_len)) {
Johannes Bergb2e77712007-09-26 15:19:39 +0200392 dev_kfree_skb(origskb);
393 return NULL;
394 }
395
Johannes Berg0869aea2009-10-28 10:03:35 +0100396 return remove_monitor_info(local, origskb);
Johannes Bergb2e77712007-09-26 15:19:39 +0200397 }
398
Helmut Schaa751413e2012-12-05 14:36:12 +0100399 /* room for the radiotap header based on driver features */
400 needed_headroom = ieee80211_rx_radiotap_space(local, status);
401
Johannes Berg0869aea2009-10-28 10:03:35 +0100402 if (should_drop_frame(origskb, present_fcs_len)) {
Johannes Bergb2e77712007-09-26 15:19:39 +0200403 /* only need to expand headroom if necessary */
404 skb = origskb;
405 origskb = NULL;
406
407 /*
408 * This shouldn't trigger often because most devices have an
409 * RX header they pull before we get here, and that should
410 * be big enough for our radiotap information. We should
411 * probably export the length to drivers so that we can have
412 * them allocate enough headroom to start with.
413 */
414 if (skb_headroom(skb) < needed_headroom &&
Johannes Bergc49e5ea2007-12-11 21:33:42 +0100415 pskb_expand_head(skb, needed_headroom, 0, GFP_ATOMIC)) {
Johannes Bergb2e77712007-09-26 15:19:39 +0200416 dev_kfree_skb(skb);
417 return NULL;
418 }
419 } else {
420 /*
421 * Need to make a copy and possibly remove radiotap header
422 * and FCS from the original.
423 */
424 skb = skb_copy_expand(origskb, needed_headroom, 0, GFP_ATOMIC);
425
Johannes Berg0869aea2009-10-28 10:03:35 +0100426 origskb = remove_monitor_info(local, origskb);
Johannes Bergb2e77712007-09-26 15:19:39 +0200427
428 if (!skb)
429 return origskb;
430 }
431
Johannes Berg0869aea2009-10-28 10:03:35 +0100432 /* prepend radiotap information */
Felix Fietkau973ef212012-04-16 14:56:48 +0200433 ieee80211_add_rx_radiotap_header(local, skb, rate, needed_headroom,
434 true);
Johannes Bergb2e77712007-09-26 15:19:39 +0200435
Johannes Bergce3edf6d02007-12-19 01:31:22 +0100436 skb_reset_mac_header(skb);
Johannes Bergb2e77712007-09-26 15:19:39 +0200437 skb->ip_summed = CHECKSUM_UNNECESSARY;
438 skb->pkt_type = PACKET_OTHERHOST;
439 skb->protocol = htons(ETH_P_802_2);
440
441 list_for_each_entry_rcu(sdata, &local->interfaces, list) {
Johannes Berg05c914f2008-09-11 00:01:58 +0200442 if (sdata->vif.type != NL80211_IFTYPE_MONITOR)
Johannes Bergb2e77712007-09-26 15:19:39 +0200443 continue;
444
Michael Wu3d30d942008-01-31 19:48:27 +0100445 if (sdata->u.mntr_flags & MONITOR_FLAG_COOK_FRAMES)
446 continue;
447
Johannes Berg9607e6b2009-12-23 13:15:31 +0100448 if (!ieee80211_sdata_running(sdata))
Johannes Berg47846c92009-11-25 17:46:19 +0100449 continue;
450
Johannes Bergb2e77712007-09-26 15:19:39 +0200451 if (prev_dev) {
452 skb2 = skb_clone(skb, GFP_ATOMIC);
453 if (skb2) {
454 skb2->dev = prev_dev;
John W. Linville5548a8a2010-06-24 14:25:56 -0400455 netif_receive_skb(skb2);
Johannes Bergb2e77712007-09-26 15:19:39 +0200456 }
457 }
458
459 prev_dev = sdata->dev;
460 sdata->dev->stats.rx_packets++;
461 sdata->dev->stats.rx_bytes += skb->len;
462 }
463
464 if (prev_dev) {
465 skb->dev = prev_dev;
John W. Linville5548a8a2010-06-24 14:25:56 -0400466 netif_receive_skb(skb);
Johannes Bergb2e77712007-09-26 15:19:39 +0200467 } else
468 dev_kfree_skb(skb);
469
470 return origskb;
471}
472
Johannes Berg5cf121c2008-02-25 16:27:43 +0100473static void ieee80211_parse_qos(struct ieee80211_rx_data *rx)
Johannes Berg6e0d1142007-07-27 15:43:22 +0200474{
Harvey Harrison238f74a2008-07-02 11:05:34 -0700475 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
Johannes Berg554891e2010-09-24 12:38:25 +0200476 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb);
Johannes Berg9e262972011-07-07 18:45:03 +0200477 int tid, seqno_idx, security_idx;
Johannes Berg6e0d1142007-07-27 15:43:22 +0200478
479 /* does the frame have a qos control field? */
Harvey Harrison238f74a2008-07-02 11:05:34 -0700480 if (ieee80211_is_data_qos(hdr->frame_control)) {
481 u8 *qc = ieee80211_get_qos_ctl(hdr);
Johannes Berg6e0d1142007-07-27 15:43:22 +0200482 /* frame has qos control */
Harvey Harrison238f74a2008-07-02 11:05:34 -0700483 tid = *qc & IEEE80211_QOS_CTL_TID_MASK;
Johannes Berg04b7dcf2011-06-22 10:06:59 +0200484 if (*qc & IEEE80211_QOS_CTL_A_MSDU_PRESENT)
Johannes Berg554891e2010-09-24 12:38:25 +0200485 status->rx_flags |= IEEE80211_RX_AMSDU;
Johannes Berg9e262972011-07-07 18:45:03 +0200486
487 seqno_idx = tid;
488 security_idx = tid;
Johannes Berg6e0d1142007-07-27 15:43:22 +0200489 } else {
Johannes Berg1411f9b2008-07-10 10:11:02 +0200490 /*
491 * IEEE 802.11-2007, 7.1.3.4.1 ("Sequence Number field"):
492 *
493 * Sequence numbers for management frames, QoS data
494 * frames with a broadcast/multicast address in the
495 * Address 1 field, and all non-QoS data frames sent
496 * by QoS STAs are assigned using an additional single
497 * modulo-4096 counter, [...]
498 *
499 * We also use that counter for non-QoS STAs.
500 */
Johannes Berg5a306f52012-11-14 23:22:21 +0100501 seqno_idx = IEEE80211_NUM_TIDS;
Johannes Berg9e262972011-07-07 18:45:03 +0200502 security_idx = 0;
503 if (ieee80211_is_mgmt(hdr->frame_control))
Johannes Berg5a306f52012-11-14 23:22:21 +0100504 security_idx = IEEE80211_NUM_TIDS;
Johannes Berg9e262972011-07-07 18:45:03 +0200505 tid = 0;
Johannes Berg6e0d1142007-07-27 15:43:22 +0200506 }
Johannes Berg52865dfd2007-07-27 15:43:22 +0200507
Johannes Berg9e262972011-07-07 18:45:03 +0200508 rx->seqno_idx = seqno_idx;
509 rx->security_idx = security_idx;
Johannes Berg6e0d1142007-07-27 15:43:22 +0200510 /* Set skb->priority to 1d tag if highest order bit of TID is not set.
511 * For now, set skb->priority to 0 for other cases. */
512 rx->skb->priority = (tid > 7) ? 0 : tid;
Johannes Berg38f37142008-01-29 17:07:43 +0100513}
Johannes Berg6e0d1142007-07-27 15:43:22 +0200514
Johannes Bergd1c3a372009-01-07 00:26:10 +0100515/**
516 * DOC: Packet alignment
517 *
518 * Drivers always need to pass packets that are aligned to two-byte boundaries
519 * to the stack.
520 *
521 * Additionally, should, if possible, align the payload data in a way that
522 * guarantees that the contained IP header is aligned to a four-byte
523 * boundary. In the case of regular frames, this simply means aligning the
524 * payload to a four-byte boundary (because either the IP header is directly
525 * contained, or IV/RFC1042 headers that have a length divisible by four are
Kalle Valo59d9cb02009-12-17 13:54:57 +0100526 * in front of it). If the payload data is not properly aligned and the
527 * architecture doesn't support efficient unaligned operations, mac80211
528 * will align the data.
Johannes Bergd1c3a372009-01-07 00:26:10 +0100529 *
530 * With A-MSDU frames, however, the payload data address must yield two modulo
531 * four because there are 14-byte 802.3 headers within the A-MSDU frames that
532 * push the IP header further back to a multiple of four again. Thankfully, the
533 * specs were sane enough this time around to require padding each A-MSDU
534 * subframe to a length that is a multiple of four.
535 *
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300536 * Padding like Atheros hardware adds which is between the 802.11 header and
Johannes Bergd1c3a372009-01-07 00:26:10 +0100537 * the payload is not supported, the driver is required to move the 802.11
538 * header to be directly in front of the payload in that case.
539 */
540static void ieee80211_verify_alignment(struct ieee80211_rx_data *rx)
Johannes Berg38f37142008-01-29 17:07:43 +0100541{
Kalle Valo59d9cb02009-12-17 13:54:57 +0100542#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
543 WARN_ONCE((unsigned long)rx->skb->data & 1,
544 "unaligned packet at 0x%p\n", rx->skb->data);
Johannes Bergd1c3a372009-01-07 00:26:10 +0100545#endif
Johannes Berg6e0d1142007-07-27 15:43:22 +0200546}
547
Ron Rindjunsky6368e4b2007-12-24 13:36:39 +0200548
Johannes Berg571ecf62007-07-27 15:43:22 +0200549/* rx handlers */
550
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +0200551static int ieee80211_is_unicast_robust_mgmt_frame(struct sk_buff *skb)
552{
553 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
554
555 if (skb->len < 24 || is_multicast_ether_addr(hdr->addr1))
556 return 0;
557
558 return ieee80211_is_robust_mgmt_frame(hdr);
559}
560
561
562static int ieee80211_is_multicast_robust_mgmt_frame(struct sk_buff *skb)
563{
564 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
565
566 if (skb->len < 24 || !is_multicast_ether_addr(hdr->addr1))
567 return 0;
568
569 return ieee80211_is_robust_mgmt_frame(hdr);
570}
571
572
573/* Get the BIP key index from MMIE; return -1 if this is not a BIP frame */
574static int ieee80211_get_mmie_keyidx(struct sk_buff *skb)
575{
576 struct ieee80211_mgmt *hdr = (struct ieee80211_mgmt *) skb->data;
577 struct ieee80211_mmie *mmie;
578
Johannes Berg1df332e2012-10-26 00:09:11 +0200579 if (skb->len < 24 + sizeof(*mmie) || !is_multicast_ether_addr(hdr->da))
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +0200580 return -1;
581
582 if (!ieee80211_is_robust_mgmt_frame((struct ieee80211_hdr *) hdr))
583 return -1; /* not a robust management frame */
584
585 mmie = (struct ieee80211_mmie *)
586 (skb->data + skb->len - sizeof(*mmie));
587 if (mmie->element_id != WLAN_EID_MMIE ||
588 mmie->length != sizeof(*mmie) - 2)
589 return -1;
590
591 return le16_to_cpu(mmie->key_id);
592}
593
Johannes Berg1df332e2012-10-26 00:09:11 +0200594static ieee80211_rx_result ieee80211_rx_mesh_check(struct ieee80211_rx_data *rx)
Luis Carlos Cobo33b64eb2008-02-23 15:17:10 +0100595{
Harvey Harrisona7767f92008-07-02 16:30:51 -0700596 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
Johannes Berg47846c92009-11-25 17:46:19 +0100597 char *dev_addr = rx->sdata->vif.addr;
Johannes Bergd6d1a5a2008-02-25 16:24:38 +0100598
Harvey Harrisona7767f92008-07-02 16:30:51 -0700599 if (ieee80211_is_data(hdr->frame_control)) {
Javier Cardona3c5772a2009-08-10 12:15:48 -0700600 if (is_multicast_ether_addr(hdr->addr1)) {
601 if (ieee80211_has_tods(hdr->frame_control) ||
Johannes Berg1df332e2012-10-26 00:09:11 +0200602 !ieee80211_has_fromds(hdr->frame_control))
Javier Cardona3c5772a2009-08-10 12:15:48 -0700603 return RX_DROP_MONITOR;
Joe Perchesb203ca32012-05-08 18:56:52 +0000604 if (ether_addr_equal(hdr->addr3, dev_addr))
Javier Cardona3c5772a2009-08-10 12:15:48 -0700605 return RX_DROP_MONITOR;
606 } else {
607 if (!ieee80211_has_a4(hdr->frame_control))
608 return RX_DROP_MONITOR;
Joe Perchesb203ca32012-05-08 18:56:52 +0000609 if (ether_addr_equal(hdr->addr4, dev_addr))
Javier Cardona3c5772a2009-08-10 12:15:48 -0700610 return RX_DROP_MONITOR;
611 }
Luis Carlos Cobo33b64eb2008-02-23 15:17:10 +0100612 }
613
614 /* If there is not an established peer link and this is not a peer link
615 * establisment frame, beacon or probe, drop the frame.
616 */
617
Javier Cardona57cf8042011-05-13 10:45:43 -0700618 if (!rx->sta || sta_plink_state(rx->sta) != NL80211_PLINK_ESTAB) {
Luis Carlos Cobo33b64eb2008-02-23 15:17:10 +0100619 struct ieee80211_mgmt *mgmt;
Johannes Bergd6d1a5a2008-02-25 16:24:38 +0100620
Harvey Harrisona7767f92008-07-02 16:30:51 -0700621 if (!ieee80211_is_mgmt(hdr->frame_control))
Luis Carlos Cobo33b64eb2008-02-23 15:17:10 +0100622 return RX_DROP_MONITOR;
623
Harvey Harrisona7767f92008-07-02 16:30:51 -0700624 if (ieee80211_is_action(hdr->frame_control)) {
Javier Cardonad3aaec8a2011-05-03 16:57:09 -0700625 u8 category;
Johannes Berg9b395bc2012-10-26 00:36:40 +0200626
627 /* make sure category field is present */
628 if (rx->skb->len < IEEE80211_MIN_ACTION_SIZE)
629 return RX_DROP_MONITOR;
630
Luis Carlos Cobo33b64eb2008-02-23 15:17:10 +0100631 mgmt = (struct ieee80211_mgmt *)hdr;
Javier Cardonad3aaec8a2011-05-03 16:57:09 -0700632 category = mgmt->u.action.category;
633 if (category != WLAN_CATEGORY_MESH_ACTION &&
Johannes Berg1df332e2012-10-26 00:09:11 +0200634 category != WLAN_CATEGORY_SELF_PROTECTED)
Luis Carlos Cobo33b64eb2008-02-23 15:17:10 +0100635 return RX_DROP_MONITOR;
Luis Carlos Cobo33b64eb2008-02-23 15:17:10 +0100636 return RX_CONTINUE;
Luis Carlos Cobo33b64eb2008-02-23 15:17:10 +0100637 }
638
Harvey Harrisona7767f92008-07-02 16:30:51 -0700639 if (ieee80211_is_probe_req(hdr->frame_control) ||
640 ieee80211_is_probe_resp(hdr->frame_control) ||
Javier Cardona71839122011-04-07 15:08:31 -0700641 ieee80211_is_beacon(hdr->frame_control) ||
642 ieee80211_is_auth(hdr->frame_control))
Harvey Harrisona7767f92008-07-02 16:30:51 -0700643 return RX_CONTINUE;
644
645 return RX_DROP_MONITOR;
Harvey Harrisona7767f92008-07-02 16:30:51 -0700646 }
647
Johannes Berg902acc72008-02-23 15:17:19 +0100648 return RX_CONTINUE;
649}
Luis Carlos Cobo33b64eb2008-02-23 15:17:10 +0100650
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100651#define SEQ_MODULO 0x1000
652#define SEQ_MASK 0xfff
653
654static inline int seq_less(u16 sq1, u16 sq2)
655{
656 return ((sq1 - sq2) & SEQ_MASK) > (SEQ_MODULO >> 1);
657}
658
659static inline u16 seq_inc(u16 sq)
660{
661 return (sq + 1) & SEQ_MASK;
662}
663
664static inline u16 seq_sub(u16 sq1, u16 sq2)
665{
666 return (sq1 - sq2) & SEQ_MASK;
667}
668
Johannes Bergd3b2fb52012-06-22 12:48:38 +0200669static void ieee80211_release_reorder_frame(struct ieee80211_sub_if_data *sdata,
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100670 struct tid_ampdu_rx *tid_agg_rx,
Christian Lamparterf9e124f2013-02-04 17:44:44 +0000671 int index,
672 struct sk_buff_head *frames)
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100673{
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100674 struct sk_buff *skb = tid_agg_rx->reorder_buf[index];
Christian Lamparter4cfda472010-12-27 23:21:26 +0100675 struct ieee80211_rx_status *status;
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100676
Johannes Bergdd318572010-11-29 11:09:16 +0100677 lockdep_assert_held(&tid_agg_rx->reorder_lock);
678
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100679 if (!skb)
680 goto no_frame;
681
Christian Lamparter071d9ac2010-08-05 01:36:36 +0200682 /* release the frame from the reorder ring buffer */
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100683 tid_agg_rx->stored_mpdu_num--;
684 tid_agg_rx->reorder_buf[index] = NULL;
Christian Lamparter4cfda472010-12-27 23:21:26 +0100685 status = IEEE80211_SKB_RXCB(skb);
686 status->rx_flags |= IEEE80211_RX_DEFERRED_RELEASE;
Christian Lamparterf9e124f2013-02-04 17:44:44 +0000687 __skb_queue_tail(frames, skb);
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100688
689no_frame:
690 tid_agg_rx->head_seq_num = seq_inc(tid_agg_rx->head_seq_num);
691}
692
Johannes Bergd3b2fb52012-06-22 12:48:38 +0200693static void ieee80211_release_reorder_frames(struct ieee80211_sub_if_data *sdata,
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100694 struct tid_ampdu_rx *tid_agg_rx,
Christian Lamparterf9e124f2013-02-04 17:44:44 +0000695 u16 head_seq_num,
696 struct sk_buff_head *frames)
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100697{
698 int index;
699
Johannes Bergdd318572010-11-29 11:09:16 +0100700 lockdep_assert_held(&tid_agg_rx->reorder_lock);
701
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100702 while (seq_less(tid_agg_rx->head_seq_num, head_seq_num)) {
703 index = seq_sub(tid_agg_rx->head_seq_num, tid_agg_rx->ssn) %
704 tid_agg_rx->buf_size;
Christian Lamparterf9e124f2013-02-04 17:44:44 +0000705 ieee80211_release_reorder_frame(sdata, tid_agg_rx, index,
706 frames);
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100707 }
708}
709
710/*
711 * Timeout (in jiffies) for skb's that are waiting in the RX reorder buffer. If
712 * the skb was added to the buffer longer than this time ago, the earlier
713 * frames that have not yet been received are assumed to be lost and the skb
714 * can be released for processing. This may also release other skb's from the
715 * reorder buffer if there are no additional gaps between the frames.
Christian Lamparter2bff8eb2010-08-05 01:36:41 +0200716 *
717 * Callers must hold tid_agg_rx->reorder_lock.
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100718 */
719#define HT_RX_REORDER_BUF_TIMEOUT (HZ / 10)
720
Johannes Bergd3b2fb52012-06-22 12:48:38 +0200721static void ieee80211_sta_reorder_release(struct ieee80211_sub_if_data *sdata,
Christian Lamparterf9e124f2013-02-04 17:44:44 +0000722 struct tid_ampdu_rx *tid_agg_rx,
723 struct sk_buff_head *frames)
Christian Lamparteraa0c8632010-08-05 01:36:04 +0200724{
Christian Lamparter2bff8eb2010-08-05 01:36:41 +0200725 int index, j;
Christian Lamparteraa0c8632010-08-05 01:36:04 +0200726
Johannes Bergdd318572010-11-29 11:09:16 +0100727 lockdep_assert_held(&tid_agg_rx->reorder_lock);
728
Christian Lamparteraa0c8632010-08-05 01:36:04 +0200729 /* release the buffer until next missing frame */
730 index = seq_sub(tid_agg_rx->head_seq_num, tid_agg_rx->ssn) %
731 tid_agg_rx->buf_size;
732 if (!tid_agg_rx->reorder_buf[index] &&
Eliad Peller07ae2df2012-02-01 18:48:09 +0200733 tid_agg_rx->stored_mpdu_num) {
Christian Lamparteraa0c8632010-08-05 01:36:04 +0200734 /*
735 * No buffers ready to be released, but check whether any
736 * frames in the reorder buffer have timed out.
737 */
Christian Lamparteraa0c8632010-08-05 01:36:04 +0200738 int skipped = 1;
739 for (j = (index + 1) % tid_agg_rx->buf_size; j != index;
740 j = (j + 1) % tid_agg_rx->buf_size) {
741 if (!tid_agg_rx->reorder_buf[j]) {
742 skipped++;
743 continue;
744 }
Daniel Halperin499fe9a2011-03-24 16:01:48 -0700745 if (skipped &&
746 !time_after(jiffies, tid_agg_rx->reorder_time[j] +
Christian Lamparteraa0c8632010-08-05 01:36:04 +0200747 HT_RX_REORDER_BUF_TIMEOUT))
Christian Lamparter2bff8eb2010-08-05 01:36:41 +0200748 goto set_release_timer;
Christian Lamparteraa0c8632010-08-05 01:36:04 +0200749
Johannes Bergbdcbd8e2012-06-22 11:29:50 +0200750 ht_dbg_ratelimited(sdata,
751 "release an RX reorder frame due to timeout on earlier frames\n");
Christian Lamparterf9e124f2013-02-04 17:44:44 +0000752 ieee80211_release_reorder_frame(sdata, tid_agg_rx, j,
753 frames);
Christian Lamparteraa0c8632010-08-05 01:36:04 +0200754
755 /*
756 * Increment the head seq# also for the skipped slots.
757 */
758 tid_agg_rx->head_seq_num =
759 (tid_agg_rx->head_seq_num + skipped) & SEQ_MASK;
760 skipped = 0;
761 }
762 } else while (tid_agg_rx->reorder_buf[index]) {
Christian Lamparterf9e124f2013-02-04 17:44:44 +0000763 ieee80211_release_reorder_frame(sdata, tid_agg_rx, index,
764 frames);
Christian Lamparteraa0c8632010-08-05 01:36:04 +0200765 index = seq_sub(tid_agg_rx->head_seq_num, tid_agg_rx->ssn) %
766 tid_agg_rx->buf_size;
767 }
Christian Lamparter2bff8eb2010-08-05 01:36:41 +0200768
769 if (tid_agg_rx->stored_mpdu_num) {
770 j = index = seq_sub(tid_agg_rx->head_seq_num,
771 tid_agg_rx->ssn) % tid_agg_rx->buf_size;
772
773 for (; j != (index - 1) % tid_agg_rx->buf_size;
774 j = (j + 1) % tid_agg_rx->buf_size) {
775 if (tid_agg_rx->reorder_buf[j])
776 break;
777 }
778
779 set_release_timer:
780
781 mod_timer(&tid_agg_rx->reorder_timer,
Christian Lamparter334df732011-04-24 20:41:16 +0200782 tid_agg_rx->reorder_time[j] + 1 +
Christian Lamparter2bff8eb2010-08-05 01:36:41 +0200783 HT_RX_REORDER_BUF_TIMEOUT);
784 } else {
785 del_timer(&tid_agg_rx->reorder_timer);
786 }
Christian Lamparteraa0c8632010-08-05 01:36:04 +0200787}
788
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100789/*
790 * As this function belongs to the RX path it must be under
791 * rcu_read_lock protection. It returns false if the frame
792 * can be processed immediately, true if it was consumed.
793 */
Johannes Bergd3b2fb52012-06-22 12:48:38 +0200794static bool ieee80211_sta_manage_reorder_buf(struct ieee80211_sub_if_data *sdata,
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100795 struct tid_ampdu_rx *tid_agg_rx,
Christian Lamparterf9e124f2013-02-04 17:44:44 +0000796 struct sk_buff *skb,
797 struct sk_buff_head *frames)
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100798{
799 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
800 u16 sc = le16_to_cpu(hdr->seq_ctrl);
801 u16 mpdu_seq_num = (sc & IEEE80211_SCTL_SEQ) >> 4;
802 u16 head_seq_num, buf_size;
803 int index;
Christian Lamparter2bff8eb2010-08-05 01:36:41 +0200804 bool ret = true;
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100805
Johannes Bergdd318572010-11-29 11:09:16 +0100806 spin_lock(&tid_agg_rx->reorder_lock);
807
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100808 buf_size = tid_agg_rx->buf_size;
809 head_seq_num = tid_agg_rx->head_seq_num;
810
811 /* frame with out of date sequence number */
812 if (seq_less(mpdu_seq_num, head_seq_num)) {
813 dev_kfree_skb(skb);
Christian Lamparter2bff8eb2010-08-05 01:36:41 +0200814 goto out;
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100815 }
816
817 /*
818 * If frame the sequence number exceeds our buffering window
819 * size release some previous frames to make room for this one.
820 */
821 if (!seq_less(mpdu_seq_num, head_seq_num + buf_size)) {
822 head_seq_num = seq_inc(seq_sub(mpdu_seq_num, buf_size));
823 /* release stored frames up to new head to stack */
Johannes Bergd3b2fb52012-06-22 12:48:38 +0200824 ieee80211_release_reorder_frames(sdata, tid_agg_rx,
Christian Lamparterf9e124f2013-02-04 17:44:44 +0000825 head_seq_num, frames);
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100826 }
827
828 /* Now the new frame is always in the range of the reordering buffer */
829
830 index = seq_sub(mpdu_seq_num, tid_agg_rx->ssn) % tid_agg_rx->buf_size;
831
832 /* check if we already stored this frame */
833 if (tid_agg_rx->reorder_buf[index]) {
834 dev_kfree_skb(skb);
Christian Lamparter2bff8eb2010-08-05 01:36:41 +0200835 goto out;
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100836 }
837
838 /*
839 * If the current MPDU is in the right order and nothing else
840 * is stored we can process it directly, no need to buffer it.
Johannes Bergc835b212011-03-15 23:17:01 +0100841 * If it is first but there's something stored, we may be able
842 * to release frames after this one.
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100843 */
844 if (mpdu_seq_num == tid_agg_rx->head_seq_num &&
845 tid_agg_rx->stored_mpdu_num == 0) {
846 tid_agg_rx->head_seq_num = seq_inc(tid_agg_rx->head_seq_num);
Christian Lamparter2bff8eb2010-08-05 01:36:41 +0200847 ret = false;
848 goto out;
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100849 }
850
851 /* put the frame in the reordering buffer */
852 tid_agg_rx->reorder_buf[index] = skb;
853 tid_agg_rx->reorder_time[index] = jiffies;
854 tid_agg_rx->stored_mpdu_num++;
Christian Lamparterf9e124f2013-02-04 17:44:44 +0000855 ieee80211_sta_reorder_release(sdata, tid_agg_rx, frames);
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100856
Christian Lamparter2bff8eb2010-08-05 01:36:41 +0200857 out:
858 spin_unlock(&tid_agg_rx->reorder_lock);
859 return ret;
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100860}
861
862/*
863 * Reorder MPDUs from A-MPDUs, keeping them on a buffer. Returns
864 * true if the MPDU was buffered, false if it should be processed.
865 */
Christian Lamparterf9e124f2013-02-04 17:44:44 +0000866static void ieee80211_rx_reorder_ampdu(struct ieee80211_rx_data *rx,
867 struct sk_buff_head *frames)
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100868{
Johannes Berg2569a822009-11-25 17:46:17 +0100869 struct sk_buff *skb = rx->skb;
870 struct ieee80211_local *local = rx->local;
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100871 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
Thomas Pedersen660c6a42011-11-03 21:11:12 -0700872 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
Johannes Berg2569a822009-11-25 17:46:17 +0100873 struct sta_info *sta = rx->sta;
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100874 struct tid_ampdu_rx *tid_agg_rx;
875 u16 sc;
Thomas Pedersen6cc00d52011-11-03 21:11:11 -0700876 u8 tid, ack_policy;
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100877
878 if (!ieee80211_is_data_qos(hdr->frame_control))
Johannes Berg2569a822009-11-25 17:46:17 +0100879 goto dont_reorder;
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100880
881 /*
882 * filter the QoS data rx stream according to
883 * STA/TID and check if this STA/TID is on aggregation
884 */
885
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100886 if (!sta)
Johannes Berg2569a822009-11-25 17:46:17 +0100887 goto dont_reorder;
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100888
Thomas Pedersen6cc00d52011-11-03 21:11:11 -0700889 ack_policy = *ieee80211_get_qos_ctl(hdr) &
890 IEEE80211_QOS_CTL_ACK_POLICY_MASK;
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100891 tid = *ieee80211_get_qos_ctl(hdr) & IEEE80211_QOS_CTL_TID_MASK;
892
Johannes Berga87f7362010-06-10 10:21:38 +0200893 tid_agg_rx = rcu_dereference(sta->ampdu_mlme.tid_rx[tid]);
894 if (!tid_agg_rx)
895 goto dont_reorder;
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100896
897 /* qos null data frames are excluded */
898 if (unlikely(hdr->frame_control & cpu_to_le16(IEEE80211_STYPE_NULLFUNC)))
Johannes Berga87f7362010-06-10 10:21:38 +0200899 goto dont_reorder;
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100900
Thomas Pedersen6cc00d52011-11-03 21:11:11 -0700901 /* not part of a BA session */
902 if (ack_policy != IEEE80211_QOS_CTL_ACK_POLICY_BLOCKACK &&
903 ack_policy != IEEE80211_QOS_CTL_ACK_POLICY_NORMAL)
904 goto dont_reorder;
905
Thomas Pedersen660c6a42011-11-03 21:11:12 -0700906 /* not actually part of this BA session */
907 if (!(status->rx_flags & IEEE80211_RX_RA_MATCH))
908 goto dont_reorder;
909
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100910 /* new, potentially un-ordered, ampdu frame - process it */
911
912 /* reset session timer */
913 if (tid_agg_rx->timeout)
Felix Fietkau12d3952f2012-03-18 22:58:06 +0100914 tid_agg_rx->last_rx = jiffies;
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100915
916 /* if this mpdu is fragmented - terminate rx aggregation session */
917 sc = le16_to_cpu(hdr->seq_ctrl);
918 if (sc & IEEE80211_SCTL_FRAG) {
Johannes Bergc1475ca2010-06-10 10:21:37 +0200919 skb->pkt_type = IEEE80211_SDATA_QUEUE_TYPE_FRAME;
Johannes Berg344eec62010-06-10 10:21:36 +0200920 skb_queue_tail(&rx->sdata->skb_queue, skb);
921 ieee80211_queue_work(&local->hw, &rx->sdata->work);
Johannes Berg2569a822009-11-25 17:46:17 +0100922 return;
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100923 }
924
Johannes Berga87f7362010-06-10 10:21:38 +0200925 /*
926 * No locking needed -- we will only ever process one
927 * RX packet at a time, and thus own tid_agg_rx. All
928 * other code manipulating it needs to (and does) make
929 * sure that we cannot get to it any more before doing
930 * anything with it.
931 */
Christian Lamparterf9e124f2013-02-04 17:44:44 +0000932 if (ieee80211_sta_manage_reorder_buf(rx->sdata, tid_agg_rx, skb,
933 frames))
Johannes Berg2569a822009-11-25 17:46:17 +0100934 return;
935
936 dont_reorder:
Christian Lamparterf9e124f2013-02-04 17:44:44 +0000937 __skb_queue_tail(frames, skb);
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100938}
Luis Carlos Cobo33b64eb2008-02-23 15:17:10 +0100939
Johannes Berg49461622008-06-30 15:10:45 +0200940static ieee80211_rx_result debug_noinline
Johannes Berg5cf121c2008-02-25 16:27:43 +0100941ieee80211_rx_h_check(struct ieee80211_rx_data *rx)
Johannes Berg571ecf62007-07-27 15:43:22 +0200942{
Harvey Harrisona7767f92008-07-02 16:30:51 -0700943 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
Johannes Berg554891e2010-09-24 12:38:25 +0200944 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb);
Johannes Berg571ecf62007-07-27 15:43:22 +0200945
946 /* Drop duplicate 802.11 retransmissions (IEEE 802.11 Chap. 9.2.9) */
947 if (rx->sta && !is_multicast_ether_addr(hdr->addr1)) {
Harvey Harrisona7767f92008-07-02 16:30:51 -0700948 if (unlikely(ieee80211_has_retry(hdr->frame_control) &&
Johannes Berg9e262972011-07-07 18:45:03 +0200949 rx->sta->last_seq_ctrl[rx->seqno_idx] ==
Johannes Berg571ecf62007-07-27 15:43:22 +0200950 hdr->seq_ctrl)) {
Johannes Berg554891e2010-09-24 12:38:25 +0200951 if (status->rx_flags & IEEE80211_RX_RA_MATCH) {
Johannes Berg571ecf62007-07-27 15:43:22 +0200952 rx->local->dot11FrameDuplicateCount++;
953 rx->sta->num_duplicates++;
954 }
Felix Fietkaub1f93312011-02-04 19:20:08 +0100955 return RX_DROP_UNUSABLE;
Johannes Berg571ecf62007-07-27 15:43:22 +0200956 } else
Johannes Berg9e262972011-07-07 18:45:03 +0200957 rx->sta->last_seq_ctrl[rx->seqno_idx] = hdr->seq_ctrl;
Johannes Berg571ecf62007-07-27 15:43:22 +0200958 }
959
Johannes Berg571ecf62007-07-27 15:43:22 +0200960 if (unlikely(rx->skb->len < 16)) {
961 I802_DEBUG_INC(rx->local->rx_handlers_drop_short);
Johannes Berge4c26ad2008-01-31 19:48:21 +0100962 return RX_DROP_MONITOR;
Johannes Berg571ecf62007-07-27 15:43:22 +0200963 }
964
Johannes Berg571ecf62007-07-27 15:43:22 +0200965 /* Drop disallowed frame classes based on STA auth/assoc state;
966 * IEEE 802.11, Chap 5.5.
967 *
Johannes Bergccd7b362008-09-11 00:01:56 +0200968 * mac80211 filters only based on association state, i.e. it drops
969 * Class 3 frames from not associated stations. hostapd sends
Johannes Berg571ecf62007-07-27 15:43:22 +0200970 * deauth/disassoc frames when needed. In addition, hostapd is
971 * responsible for filtering on both auth and assoc states.
972 */
Luis Carlos Cobo33b64eb2008-02-23 15:17:10 +0100973
Johannes Berg902acc72008-02-23 15:17:19 +0100974 if (ieee80211_vif_is_mesh(&rx->sdata->vif))
Luis Carlos Cobo33b64eb2008-02-23 15:17:10 +0100975 return ieee80211_rx_mesh_check(rx);
Luis Carlos Cobo33b64eb2008-02-23 15:17:10 +0100976
Harvey Harrisona7767f92008-07-02 16:30:51 -0700977 if (unlikely((ieee80211_is_data(hdr->frame_control) ||
978 ieee80211_is_pspoll(hdr->frame_control)) &&
Johannes Berg05c914f2008-09-11 00:01:58 +0200979 rx->sdata->vif.type != NL80211_IFTYPE_ADHOC &&
Bill Jordan1be7fe82010-10-01 11:20:41 -0400980 rx->sdata->vif.type != NL80211_IFTYPE_WDS &&
Johannes Bergc2c98fd2011-09-29 16:04:36 +0200981 (!rx->sta || !test_sta_flag(rx->sta, WLAN_STA_ASSOC)))) {
Johannes Berg7852e362012-01-20 13:55:24 +0100982 /*
983 * accept port control frames from the AP even when it's not
984 * yet marked ASSOC to prevent a race where we don't set the
985 * assoc bit quickly enough before it sends the first frame
986 */
987 if (rx->sta && rx->sdata->vif.type == NL80211_IFTYPE_STATION &&
Guy Eilam2a33bee2011-08-17 15:18:15 +0300988 ieee80211_is_data_present(hdr->frame_control)) {
Johannes Berg6dbda2d2012-10-26 00:41:23 +0200989 unsigned int hdrlen;
990 __be16 ethertype;
Guy Eilam2a33bee2011-08-17 15:18:15 +0300991
Johannes Berg6dbda2d2012-10-26 00:41:23 +0200992 hdrlen = ieee80211_hdrlen(hdr->frame_control);
993
994 if (rx->skb->len < hdrlen + 8)
995 return RX_DROP_MONITOR;
996
997 skb_copy_bits(rx->skb, hdrlen + 6, &ethertype, 2);
998 if (ethertype == rx->sdata->control_port_protocol)
Guy Eilam2a33bee2011-08-17 15:18:15 +0300999 return RX_CONTINUE;
1000 }
Johannes Berg21fc7562011-11-04 11:18:13 +01001001
1002 if (rx->sdata->vif.type == NL80211_IFTYPE_AP &&
1003 cfg80211_rx_spurious_frame(rx->sdata->dev,
1004 hdr->addr2,
1005 GFP_ATOMIC))
1006 return RX_DROP_UNUSABLE;
1007
Johannes Berge4c26ad2008-01-31 19:48:21 +01001008 return RX_DROP_MONITOR;
Guy Eilam2a33bee2011-08-17 15:18:15 +03001009 }
Johannes Berg571ecf62007-07-27 15:43:22 +02001010
Johannes Berg9ae54c82008-01-31 19:48:20 +01001011 return RX_CONTINUE;
Johannes Berg570bd532007-07-27 15:43:22 +02001012}
1013
1014
Johannes Berg49461622008-06-30 15:10:45 +02001015static ieee80211_rx_result debug_noinline
Johannes Berg5cf121c2008-02-25 16:27:43 +01001016ieee80211_rx_h_decrypt(struct ieee80211_rx_data *rx)
Johannes Berg570bd532007-07-27 15:43:22 +02001017{
Johannes Bergeb9fb5b2009-11-16 13:58:20 +01001018 struct sk_buff *skb = rx->skb;
1019 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
1020 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
Johannes Berg3017b802007-08-28 17:01:53 -04001021 int keyidx;
1022 int hdrlen;
Johannes Berge4c26ad2008-01-31 19:48:21 +01001023 ieee80211_rx_result result = RX_DROP_UNUSABLE;
Johannes Berge31b8212010-10-05 19:39:30 +02001024 struct ieee80211_key *sta_ptk = NULL;
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +02001025 int mmie_keyidx = -1;
Johannes Berg761ab472010-05-28 14:24:19 +02001026 __le16 fc;
Johannes Berg570bd532007-07-27 15:43:22 +02001027
Johannes Berg3017b802007-08-28 17:01:53 -04001028 /*
1029 * Key selection 101
1030 *
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +02001031 * There are four types of keys:
Johannes Berg3017b802007-08-28 17:01:53 -04001032 * - GTK (group keys)
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +02001033 * - IGTK (group keys for management frames)
Johannes Berg3017b802007-08-28 17:01:53 -04001034 * - PTK (pairwise keys)
1035 * - STK (station-to-station pairwise keys)
1036 *
1037 * When selecting a key, we have to distinguish between multicast
1038 * (including broadcast) and unicast frames, the latter can only
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +02001039 * use PTKs and STKs while the former always use GTKs and IGTKs.
1040 * Unless, of course, actual WEP keys ("pre-RSNA") are used, then
1041 * unicast frames can also use key indices like GTKs. Hence, if we
1042 * don't have a PTK/STK we check the key index for a WEP key.
Johannes Berg3017b802007-08-28 17:01:53 -04001043 *
Johannes Berg8dc06a12007-08-28 17:01:55 -04001044 * Note that in a regular BSS, multicast frames are sent by the
1045 * AP only, associated stations unicast the frame to the AP first
1046 * which then multicasts it on their behalf.
1047 *
Johannes Berg3017b802007-08-28 17:01:53 -04001048 * There is also a slight problem in IBSS mode: GTKs are negotiated
1049 * with each station, that is something we don't currently handle.
Johannes Berg8dc06a12007-08-28 17:01:55 -04001050 * The spec seems to expect that one negotiates the same key with
1051 * every station but there's no such requirement; VLANs could be
1052 * possible.
Johannes Berg3017b802007-08-28 17:01:53 -04001053 */
Johannes Berg571ecf62007-07-27 15:43:22 +02001054
Johannes Berg3017b802007-08-28 17:01:53 -04001055 /*
Johannes Berg1990af82007-09-26 17:53:15 +02001056 * No point in finding a key and decrypting if the frame is neither
Johannes Berg3017b802007-08-28 17:01:53 -04001057 * addressed to us nor a multicast frame.
1058 */
Johannes Berg554891e2010-09-24 12:38:25 +02001059 if (!(status->rx_flags & IEEE80211_RX_RA_MATCH))
Johannes Berg9ae54c82008-01-31 19:48:20 +01001060 return RX_CONTINUE;
Johannes Berg3017b802007-08-28 17:01:53 -04001061
Johannes Berg2569a822009-11-25 17:46:17 +01001062 /* start without a key */
1063 rx->key = NULL;
1064
Johannes Bergd4e46a32007-09-14 11:10:24 -04001065 if (rx->sta)
Johannes Berge31b8212010-10-05 19:39:30 +02001066 sta_ptk = rcu_dereference(rx->sta->ptk);
Johannes Bergd4e46a32007-09-14 11:10:24 -04001067
Johannes Berg761ab472010-05-28 14:24:19 +02001068 fc = hdr->frame_control;
1069
1070 if (!ieee80211_has_protected(fc))
Jouni Malinen0c7c10c2009-05-08 12:34:10 +03001071 mmie_keyidx = ieee80211_get_mmie_keyidx(rx->skb);
1072
Johannes Berge31b8212010-10-05 19:39:30 +02001073 if (!is_multicast_ether_addr(hdr->addr1) && sta_ptk) {
1074 rx->key = sta_ptk;
Johannes Bergdc1580d2010-08-10 09:46:40 +02001075 if ((status->flag & RX_FLAG_DECRYPTED) &&
1076 (status->flag & RX_FLAG_IV_STRIPPED))
1077 return RX_CONTINUE;
Jouni Malinen0c7c10c2009-05-08 12:34:10 +03001078 /* Skip decryption if the frame is not protected. */
Johannes Berg761ab472010-05-28 14:24:19 +02001079 if (!ieee80211_has_protected(fc))
Jouni Malinen0c7c10c2009-05-08 12:34:10 +03001080 return RX_CONTINUE;
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +02001081 } else if (mmie_keyidx >= 0) {
1082 /* Broadcast/multicast robust management frame / BIP */
Johannes Bergeb9fb5b2009-11-16 13:58:20 +01001083 if ((status->flag & RX_FLAG_DECRYPTED) &&
1084 (status->flag & RX_FLAG_IV_STRIPPED))
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +02001085 return RX_CONTINUE;
1086
1087 if (mmie_keyidx < NUM_DEFAULT_KEYS ||
1088 mmie_keyidx >= NUM_DEFAULT_KEYS + NUM_DEFAULT_MGMT_KEYS)
1089 return RX_DROP_MONITOR; /* unexpected BIP keyidx */
Johannes Berge31b8212010-10-05 19:39:30 +02001090 if (rx->sta)
1091 rx->key = rcu_dereference(rx->sta->gtk[mmie_keyidx]);
1092 if (!rx->key)
1093 rx->key = rcu_dereference(rx->sdata->keys[mmie_keyidx]);
Johannes Berg761ab472010-05-28 14:24:19 +02001094 } else if (!ieee80211_has_protected(fc)) {
Jouni Malinen0c7c10c2009-05-08 12:34:10 +03001095 /*
1096 * The frame was not protected, so skip decryption. However, we
1097 * need to set rx->key if there is a key that could have been
1098 * used so that the frame may be dropped if encryption would
1099 * have been expected.
1100 */
1101 struct ieee80211_key *key = NULL;
Johannes Berg897bed82010-12-09 19:49:00 +01001102 struct ieee80211_sub_if_data *sdata = rx->sdata;
1103 int i;
1104
Johannes Berg761ab472010-05-28 14:24:19 +02001105 if (ieee80211_is_mgmt(fc) &&
Jouni Malinen0c7c10c2009-05-08 12:34:10 +03001106 is_multicast_ether_addr(hdr->addr1) &&
1107 (key = rcu_dereference(rx->sdata->default_mgmt_key)))
1108 rx->key = key;
Johannes Berg897bed82010-12-09 19:49:00 +01001109 else {
1110 if (rx->sta) {
1111 for (i = 0; i < NUM_DEFAULT_KEYS; i++) {
1112 key = rcu_dereference(rx->sta->gtk[i]);
1113 if (key)
1114 break;
1115 }
1116 }
1117 if (!key) {
1118 for (i = 0; i < NUM_DEFAULT_KEYS; i++) {
1119 key = rcu_dereference(sdata->keys[i]);
1120 if (key)
1121 break;
1122 }
1123 }
1124 if (key)
1125 rx->key = key;
1126 }
Jouni Malinen0c7c10c2009-05-08 12:34:10 +03001127 return RX_CONTINUE;
Johannes Berg571ecf62007-07-27 15:43:22 +02001128 } else {
Zhu Yi39184b12010-04-08 15:35:10 +08001129 u8 keyid;
Johannes Berg3017b802007-08-28 17:01:53 -04001130 /*
1131 * The device doesn't give us the IV so we won't be
1132 * able to look up the key. That's ok though, we
1133 * don't need to decrypt the frame, we just won't
1134 * be able to keep statistics accurate.
1135 * Except for key threshold notifications, should
1136 * we somehow allow the driver to tell us which key
1137 * the hardware used if this flag is set?
1138 */
Johannes Bergeb9fb5b2009-11-16 13:58:20 +01001139 if ((status->flag & RX_FLAG_DECRYPTED) &&
1140 (status->flag & RX_FLAG_IV_STRIPPED))
Johannes Berg9ae54c82008-01-31 19:48:20 +01001141 return RX_CONTINUE;
Johannes Berg571ecf62007-07-27 15:43:22 +02001142
Johannes Berg761ab472010-05-28 14:24:19 +02001143 hdrlen = ieee80211_hdrlen(fc);
Johannes Berg571ecf62007-07-27 15:43:22 +02001144
Johannes Berg3017b802007-08-28 17:01:53 -04001145 if (rx->skb->len < 8 + hdrlen)
Johannes Berge4c26ad2008-01-31 19:48:21 +01001146 return RX_DROP_UNUSABLE; /* TODO: count this? */
Johannes Berg571ecf62007-07-27 15:43:22 +02001147
Johannes Berg3017b802007-08-28 17:01:53 -04001148 /*
1149 * no need to call ieee80211_wep_get_keyidx,
1150 * it verifies a bunch of things we've done already
1151 */
Zhu Yi39184b12010-04-08 15:35:10 +08001152 skb_copy_bits(rx->skb, hdrlen + 3, &keyid, 1);
1153 keyidx = keyid >> 6;
Johannes Berg3017b802007-08-28 17:01:53 -04001154
Johannes Berge31b8212010-10-05 19:39:30 +02001155 /* check per-station GTK first, if multicast packet */
1156 if (is_multicast_ether_addr(hdr->addr1) && rx->sta)
1157 rx->key = rcu_dereference(rx->sta->gtk[keyidx]);
Johannes Berg3017b802007-08-28 17:01:53 -04001158
Johannes Berge31b8212010-10-05 19:39:30 +02001159 /* if not found, try default key */
1160 if (!rx->key) {
1161 rx->key = rcu_dereference(rx->sdata->keys[keyidx]);
1162
1163 /*
1164 * RSNA-protected unicast frames should always be
1165 * sent with pairwise or station-to-station keys,
1166 * but for WEP we allow using a key index as well.
1167 */
1168 if (rx->key &&
1169 rx->key->conf.cipher != WLAN_CIPHER_SUITE_WEP40 &&
1170 rx->key->conf.cipher != WLAN_CIPHER_SUITE_WEP104 &&
1171 !is_multicast_ether_addr(hdr->addr1))
1172 rx->key = NULL;
1173 }
Johannes Berg571ecf62007-07-27 15:43:22 +02001174 }
1175
Johannes Berg3017b802007-08-28 17:01:53 -04001176 if (rx->key) {
Johannes Berg95acac62011-07-12 12:30:59 +02001177 if (unlikely(rx->key->flags & KEY_FLAG_TAINTED))
1178 return RX_DROP_MONITOR;
1179
Johannes Berg571ecf62007-07-27 15:43:22 +02001180 rx->key->tx_rx_count++;
Johannes Berg011bfcc2007-09-17 01:29:25 -04001181 /* TODO: add threshold stuff again */
Johannes Berg1990af82007-09-26 17:53:15 +02001182 } else {
Johannes Berge4c26ad2008-01-31 19:48:21 +01001183 return RX_DROP_MONITOR;
Johannes Berg70f08762007-09-26 17:53:14 +02001184 }
1185
Johannes Berg97359d12010-08-10 09:46:38 +02001186 switch (rx->key->conf.cipher) {
1187 case WLAN_CIPHER_SUITE_WEP40:
1188 case WLAN_CIPHER_SUITE_WEP104:
Mattias Nisslere2f036d2007-10-07 16:35:31 +02001189 result = ieee80211_crypto_wep_decrypt(rx);
1190 break;
Johannes Berg97359d12010-08-10 09:46:38 +02001191 case WLAN_CIPHER_SUITE_TKIP:
Mattias Nisslere2f036d2007-10-07 16:35:31 +02001192 result = ieee80211_crypto_tkip_decrypt(rx);
1193 break;
Johannes Berg97359d12010-08-10 09:46:38 +02001194 case WLAN_CIPHER_SUITE_CCMP:
Mattias Nisslere2f036d2007-10-07 16:35:31 +02001195 result = ieee80211_crypto_ccmp_decrypt(rx);
1196 break;
Johannes Berg97359d12010-08-10 09:46:38 +02001197 case WLAN_CIPHER_SUITE_AES_CMAC:
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +02001198 result = ieee80211_crypto_aes_cmac_decrypt(rx);
1199 break;
Johannes Berg3ffc2a92010-08-27 14:26:52 +03001200 default:
1201 /*
1202 * We can reach here only with HW-only algorithms
1203 * but why didn't it decrypt the frame?!
1204 */
1205 return RX_DROP_UNUSABLE;
Johannes Berg70f08762007-09-26 17:53:14 +02001206 }
1207
Johannes Berga8286912012-03-12 13:49:14 +01001208 /* the hdr variable is invalid after the decrypt handlers */
1209
Mattias Nisslere2f036d2007-10-07 16:35:31 +02001210 /* either the frame has been decrypted or will be dropped */
Johannes Bergeb9fb5b2009-11-16 13:58:20 +01001211 status->flag |= RX_FLAG_DECRYPTED;
Mattias Nisslere2f036d2007-10-07 16:35:31 +02001212
1213 return result;
Johannes Berg70f08762007-09-26 17:53:14 +02001214}
1215
Kalle Valo572e0012009-02-10 17:09:31 +02001216static ieee80211_rx_result debug_noinline
1217ieee80211_rx_h_check_more_data(struct ieee80211_rx_data *rx)
1218{
1219 struct ieee80211_local *local;
1220 struct ieee80211_hdr *hdr;
1221 struct sk_buff *skb;
1222
1223 local = rx->local;
1224 skb = rx->skb;
1225 hdr = (struct ieee80211_hdr *) skb->data;
1226
1227 if (!local->pspolling)
1228 return RX_CONTINUE;
1229
1230 if (!ieee80211_has_fromds(hdr->frame_control))
1231 /* this is not from AP */
1232 return RX_CONTINUE;
1233
1234 if (!ieee80211_is_data(hdr->frame_control))
1235 return RX_CONTINUE;
1236
1237 if (!ieee80211_has_moredata(hdr->frame_control)) {
1238 /* AP has no more frames buffered for us */
1239 local->pspolling = false;
1240 return RX_CONTINUE;
1241 }
1242
1243 /* more data bit is set, let's request a new frame from the AP */
1244 ieee80211_send_pspoll(local, rx->sdata);
1245
1246 return RX_CONTINUE;
1247}
1248
Marco Porschd012a602012-10-10 12:39:50 -07001249static void sta_ps_start(struct sta_info *sta)
Johannes Berg571ecf62007-07-27 15:43:22 +02001250{
Johannes Berg133b8222008-09-16 14:18:59 +02001251 struct ieee80211_sub_if_data *sdata = sta->sdata;
Christian Lamparter4571d3b2008-11-30 00:48:41 +01001252 struct ieee80211_local *local = sdata->local;
Marco Porschd012a602012-10-10 12:39:50 -07001253 struct ps_data *ps;
Joe Perches0795af52007-10-03 17:59:30 -07001254
Marco Porschd012a602012-10-10 12:39:50 -07001255 if (sta->sdata->vif.type == NL80211_IFTYPE_AP ||
1256 sta->sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
1257 ps = &sdata->bss->ps;
1258 else
1259 return;
1260
1261 atomic_inc(&ps->num_sta_ps);
Johannes Bergc2c98fd2011-09-29 16:04:36 +02001262 set_sta_flag(sta, WLAN_STA_PS_STA);
Arik Nemtsovd057e5a2011-01-31 22:29:13 +02001263 if (!(local->hw.flags & IEEE80211_HW_AP_LINK_PS))
1264 drv_sta_notify(local, sdata, STA_NOTIFY_SLEEP, &sta->sta);
Johannes Bergbdcbd8e2012-06-22 11:29:50 +02001265 ps_dbg(sdata, "STA %pM aid %d enters power save mode\n",
1266 sta->sta.addr, sta->sta.aid);
Johannes Berg571ecf62007-07-27 15:43:22 +02001267}
1268
Marco Porschd012a602012-10-10 12:39:50 -07001269static void sta_ps_end(struct sta_info *sta)
Johannes Berg571ecf62007-07-27 15:43:22 +02001270{
Johannes Bergbdcbd8e2012-06-22 11:29:50 +02001271 ps_dbg(sta->sdata, "STA %pM aid %d exits power save mode\n",
1272 sta->sta.addr, sta->sta.aid);
Johannes Berg004c8722008-02-20 11:21:35 +01001273
Johannes Bergc2c98fd2011-09-29 16:04:36 +02001274 if (test_sta_flag(sta, WLAN_STA_PS_DRIVER)) {
Johannes Bergbdcbd8e2012-06-22 11:29:50 +02001275 ps_dbg(sta->sdata, "STA %pM aid %d driver-ps-blocked\n",
1276 sta->sta.addr, sta->sta.aid);
Johannes Bergaf818582009-11-06 11:35:50 +01001277 return;
1278 }
1279
1280 ieee80211_sta_ps_deliver_wakeup(sta);
Johannes Berg571ecf62007-07-27 15:43:22 +02001281}
1282
Arik Nemtsovd057e5a2011-01-31 22:29:13 +02001283int ieee80211_sta_ps_transition(struct ieee80211_sta *sta, bool start)
1284{
1285 struct sta_info *sta_inf = container_of(sta, struct sta_info, sta);
1286 bool in_ps;
1287
1288 WARN_ON(!(sta_inf->local->hw.flags & IEEE80211_HW_AP_LINK_PS));
1289
1290 /* Don't let the same PS state be set twice */
Johannes Bergc2c98fd2011-09-29 16:04:36 +02001291 in_ps = test_sta_flag(sta_inf, WLAN_STA_PS_STA);
Arik Nemtsovd057e5a2011-01-31 22:29:13 +02001292 if ((start && in_ps) || (!start && !in_ps))
1293 return -EINVAL;
1294
1295 if (start)
Marco Porschd012a602012-10-10 12:39:50 -07001296 sta_ps_start(sta_inf);
Arik Nemtsovd057e5a2011-01-31 22:29:13 +02001297 else
Marco Porschd012a602012-10-10 12:39:50 -07001298 sta_ps_end(sta_inf);
Arik Nemtsovd057e5a2011-01-31 22:29:13 +02001299
1300 return 0;
1301}
1302EXPORT_SYMBOL(ieee80211_sta_ps_transition);
1303
Johannes Berg49461622008-06-30 15:10:45 +02001304static ieee80211_rx_result debug_noinline
Johannes Berg47086fc2011-09-29 16:04:33 +02001305ieee80211_rx_h_uapsd_and_pspoll(struct ieee80211_rx_data *rx)
1306{
1307 struct ieee80211_sub_if_data *sdata = rx->sdata;
1308 struct ieee80211_hdr *hdr = (void *)rx->skb->data;
1309 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb);
1310 int tid, ac;
1311
1312 if (!rx->sta || !(status->rx_flags & IEEE80211_RX_RA_MATCH))
1313 return RX_CONTINUE;
1314
1315 if (sdata->vif.type != NL80211_IFTYPE_AP &&
1316 sdata->vif.type != NL80211_IFTYPE_AP_VLAN)
1317 return RX_CONTINUE;
1318
1319 /*
1320 * The device handles station powersave, so don't do anything about
1321 * uAPSD and PS-Poll frames (the latter shouldn't even come up from
1322 * it to mac80211 since they're handled.)
1323 */
1324 if (sdata->local->hw.flags & IEEE80211_HW_AP_LINK_PS)
1325 return RX_CONTINUE;
1326
1327 /*
1328 * Don't do anything if the station isn't already asleep. In
1329 * the uAPSD case, the station will probably be marked asleep,
1330 * in the PS-Poll case the station must be confused ...
1331 */
Johannes Bergc2c98fd2011-09-29 16:04:36 +02001332 if (!test_sta_flag(rx->sta, WLAN_STA_PS_STA))
Johannes Berg47086fc2011-09-29 16:04:33 +02001333 return RX_CONTINUE;
1334
1335 if (unlikely(ieee80211_is_pspoll(hdr->frame_control))) {
Johannes Bergc2c98fd2011-09-29 16:04:36 +02001336 if (!test_sta_flag(rx->sta, WLAN_STA_SP)) {
1337 if (!test_sta_flag(rx->sta, WLAN_STA_PS_DRIVER))
Johannes Bergdeeaee12011-09-29 16:04:35 +02001338 ieee80211_sta_ps_deliver_poll_response(rx->sta);
1339 else
Johannes Bergc2c98fd2011-09-29 16:04:36 +02001340 set_sta_flag(rx->sta, WLAN_STA_PSPOLL);
Johannes Bergdeeaee12011-09-29 16:04:35 +02001341 }
Johannes Berg47086fc2011-09-29 16:04:33 +02001342
1343 /* Free PS Poll skb here instead of returning RX_DROP that would
1344 * count as an dropped frame. */
1345 dev_kfree_skb(rx->skb);
1346
1347 return RX_QUEUED;
1348 } else if (!ieee80211_has_morefrags(hdr->frame_control) &&
1349 !(status->rx_flags & IEEE80211_RX_DEFERRED_RELEASE) &&
1350 ieee80211_has_pm(hdr->frame_control) &&
1351 (ieee80211_is_data_qos(hdr->frame_control) ||
1352 ieee80211_is_qos_nullfunc(hdr->frame_control))) {
1353 tid = *ieee80211_get_qos_ctl(hdr) & IEEE80211_QOS_CTL_TID_MASK;
1354 ac = ieee802_1d_to_ac[tid & 7];
1355
1356 /*
1357 * If this AC is not trigger-enabled do nothing.
1358 *
1359 * NB: This could/should check a separate bitmap of trigger-
1360 * enabled queues, but for now we only implement uAPSD w/o
1361 * TSPEC changes to the ACs, so they're always the same.
1362 */
1363 if (!(rx->sta->sta.uapsd_queues & BIT(ac)))
1364 return RX_CONTINUE;
1365
1366 /* if we are in a service period, do nothing */
Johannes Bergc2c98fd2011-09-29 16:04:36 +02001367 if (test_sta_flag(rx->sta, WLAN_STA_SP))
Johannes Berg47086fc2011-09-29 16:04:33 +02001368 return RX_CONTINUE;
1369
Johannes Bergc2c98fd2011-09-29 16:04:36 +02001370 if (!test_sta_flag(rx->sta, WLAN_STA_PS_DRIVER))
Johannes Berg47086fc2011-09-29 16:04:33 +02001371 ieee80211_sta_ps_deliver_uapsd(rx->sta);
1372 else
Johannes Bergc2c98fd2011-09-29 16:04:36 +02001373 set_sta_flag(rx->sta, WLAN_STA_UAPSD);
Johannes Berg47086fc2011-09-29 16:04:33 +02001374 }
1375
1376 return RX_CONTINUE;
1377}
1378
1379static ieee80211_rx_result debug_noinline
Johannes Berg5cf121c2008-02-25 16:27:43 +01001380ieee80211_rx_h_sta_process(struct ieee80211_rx_data *rx)
Johannes Berg571ecf62007-07-27 15:43:22 +02001381{
1382 struct sta_info *sta = rx->sta;
Johannes Bergeb9fb5b2009-11-16 13:58:20 +01001383 struct sk_buff *skb = rx->skb;
1384 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
1385 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
Johannes Berg571ecf62007-07-27 15:43:22 +02001386
1387 if (!sta)
Johannes Berg9ae54c82008-01-31 19:48:20 +01001388 return RX_CONTINUE;
Johannes Berg571ecf62007-07-27 15:43:22 +02001389
Johannes Bergb291ba12009-07-10 15:29:03 +02001390 /*
1391 * Update last_rx only for IBSS packets which are for the current
Antonio Quartullie584da5e2012-11-25 23:13:42 +01001392 * BSSID and for station already AUTHORIZED to avoid keeping the
1393 * current IBSS network alive in cases where other STAs start
1394 * using different BSSID. This will also give the station another
1395 * chance to restart the authentication/authorization in case
1396 * something went wrong the first time.
Johannes Bergb291ba12009-07-10 15:29:03 +02001397 */
Johannes Berg05c914f2008-09-11 00:01:58 +02001398 if (rx->sdata->vif.type == NL80211_IFTYPE_ADHOC) {
Ron Rindjunsky71364712007-12-25 17:00:36 +02001399 u8 *bssid = ieee80211_get_bssid(hdr, rx->skb->len,
Johannes Berg05c914f2008-09-11 00:01:58 +02001400 NL80211_IFTYPE_ADHOC);
Antonio Quartullie584da5e2012-11-25 23:13:42 +01001401 if (ether_addr_equal(bssid, rx->sdata->u.ibss.bssid) &&
1402 test_sta_flag(sta, WLAN_STA_AUTHORIZED)) {
Johannes Berg571ecf62007-07-27 15:43:22 +02001403 sta->last_rx = jiffies;
Felix Fietkau3af63342011-02-27 22:08:01 +01001404 if (ieee80211_is_data(hdr->frame_control)) {
1405 sta->last_rx_rate_idx = status->rate_idx;
1406 sta->last_rx_rate_flag = status->flag;
Johannes Berg56146182012-11-09 15:07:02 +01001407 sta->last_rx_rate_vht_nss = status->vht_nss;
Felix Fietkau3af63342011-02-27 22:08:01 +01001408 }
1409 }
Johannes Bergb291ba12009-07-10 15:29:03 +02001410 } else if (!is_multicast_ether_addr(hdr->addr1)) {
1411 /*
Luis Carlos Cobo33b64eb2008-02-23 15:17:10 +01001412 * Mesh beacons will update last_rx when if they are found to
1413 * match the current local configuration when processed.
Johannes Berg571ecf62007-07-27 15:43:22 +02001414 */
Johannes Bergb291ba12009-07-10 15:29:03 +02001415 sta->last_rx = jiffies;
Felix Fietkau3af63342011-02-27 22:08:01 +01001416 if (ieee80211_is_data(hdr->frame_control)) {
1417 sta->last_rx_rate_idx = status->rate_idx;
1418 sta->last_rx_rate_flag = status->flag;
Johannes Berg56146182012-11-09 15:07:02 +01001419 sta->last_rx_rate_vht_nss = status->vht_nss;
Felix Fietkau3af63342011-02-27 22:08:01 +01001420 }
Johannes Berg571ecf62007-07-27 15:43:22 +02001421 }
1422
Johannes Berg554891e2010-09-24 12:38:25 +02001423 if (!(status->rx_flags & IEEE80211_RX_RA_MATCH))
Johannes Berg9ae54c82008-01-31 19:48:20 +01001424 return RX_CONTINUE;
Johannes Berg571ecf62007-07-27 15:43:22 +02001425
Kalle Valo3cf335d2009-03-22 21:57:06 +02001426 if (rx->sdata->vif.type == NL80211_IFTYPE_STATION)
1427 ieee80211_sta_rx_notify(rx->sdata, hdr);
1428
Johannes Berg571ecf62007-07-27 15:43:22 +02001429 sta->rx_fragments++;
1430 sta->rx_bytes += rx->skb->len;
Felix Fietkaufe8431f2012-03-01 18:00:07 +01001431 if (!(status->flag & RX_FLAG_NO_SIGNAL_VAL)) {
1432 sta->last_signal = status->signal;
1433 ewma_add(&sta->avg_signal, -status->signal);
1434 }
Johannes Berg571ecf62007-07-27 15:43:22 +02001435
Johannes Berg72eaa432008-11-26 15:02:58 +01001436 /*
1437 * Change STA power saving mode only at the end of a frame
1438 * exchange sequence.
1439 */
Arik Nemtsovd057e5a2011-01-31 22:29:13 +02001440 if (!(sta->local->hw.flags & IEEE80211_HW_AP_LINK_PS) &&
1441 !ieee80211_has_morefrags(hdr->frame_control) &&
Christian Lamparter4cfda472010-12-27 23:21:26 +01001442 !(status->rx_flags & IEEE80211_RX_DEFERRED_RELEASE) &&
Johannes Berg05c914f2008-09-11 00:01:58 +02001443 (rx->sdata->vif.type == NL80211_IFTYPE_AP ||
1444 rx->sdata->vif.type == NL80211_IFTYPE_AP_VLAN)) {
Johannes Bergc2c98fd2011-09-29 16:04:36 +02001445 if (test_sta_flag(sta, WLAN_STA_PS_STA)) {
Johannes Berg72eaa432008-11-26 15:02:58 +01001446 /*
1447 * Ignore doze->wake transitions that are
1448 * indicated by non-data frames, the standard
1449 * is unclear here, but for example going to
1450 * PS mode and then scanning would cause a
1451 * doze->wake transition for the probe request,
1452 * and that is clearly undesirable.
1453 */
1454 if (ieee80211_is_data(hdr->frame_control) &&
1455 !ieee80211_has_pm(hdr->frame_control))
Marco Porschd012a602012-10-10 12:39:50 -07001456 sta_ps_end(sta);
Johannes Berg72eaa432008-11-26 15:02:58 +01001457 } else {
1458 if (ieee80211_has_pm(hdr->frame_control))
Marco Porschd012a602012-10-10 12:39:50 -07001459 sta_ps_start(sta);
Johannes Berg72eaa432008-11-26 15:02:58 +01001460 }
Johannes Berg571ecf62007-07-27 15:43:22 +02001461 }
1462
Marco Porsch3f52b7e2013-01-30 18:14:08 +01001463 /* mesh power save support */
1464 if (ieee80211_vif_is_mesh(&rx->sdata->vif))
1465 ieee80211_mps_rx_h_sta_process(sta, hdr);
1466
Johannes Berg22403de2009-10-30 12:55:03 +01001467 /*
1468 * Drop (qos-)data::nullfunc frames silently, since they
1469 * are used only to control station power saving mode.
1470 */
1471 if (ieee80211_is_nullfunc(hdr->frame_control) ||
1472 ieee80211_is_qos_nullfunc(hdr->frame_control)) {
Johannes Berg571ecf62007-07-27 15:43:22 +02001473 I802_DEBUG_INC(rx->local->rx_handlers_drop_nullfunc);
Felix Fietkaud5242152010-01-08 18:06:26 +01001474
1475 /*
1476 * If we receive a 4-addr nullfunc frame from a STA
Johannes Berge7f4a942011-11-04 11:18:20 +01001477 * that was not moved to a 4-addr STA vlan yet send
1478 * the event to userspace and for older hostapd drop
1479 * the frame to the monitor interface.
Felix Fietkaud5242152010-01-08 18:06:26 +01001480 */
1481 if (ieee80211_has_a4(hdr->frame_control) &&
1482 (rx->sdata->vif.type == NL80211_IFTYPE_AP ||
1483 (rx->sdata->vif.type == NL80211_IFTYPE_AP_VLAN &&
Johannes Berge7f4a942011-11-04 11:18:20 +01001484 !rx->sdata->u.vlan.sta))) {
1485 if (!test_and_set_sta_flag(sta, WLAN_STA_4ADDR_EVENT))
1486 cfg80211_rx_unexpected_4addr_frame(
1487 rx->sdata->dev, sta->sta.addr,
1488 GFP_ATOMIC);
Felix Fietkaud5242152010-01-08 18:06:26 +01001489 return RX_DROP_MONITOR;
Johannes Berge7f4a942011-11-04 11:18:20 +01001490 }
Johannes Berg22403de2009-10-30 12:55:03 +01001491 /*
1492 * Update counter and free packet here to avoid
1493 * counting this as a dropped packed.
1494 */
Johannes Berg571ecf62007-07-27 15:43:22 +02001495 sta->rx_packets++;
1496 dev_kfree_skb(rx->skb);
Johannes Berg9ae54c82008-01-31 19:48:20 +01001497 return RX_QUEUED;
Johannes Berg571ecf62007-07-27 15:43:22 +02001498 }
1499
Johannes Berg9ae54c82008-01-31 19:48:20 +01001500 return RX_CONTINUE;
Johannes Berg571ecf62007-07-27 15:43:22 +02001501} /* ieee80211_rx_h_sta_process */
1502
Johannes Berg571ecf62007-07-27 15:43:22 +02001503static inline struct ieee80211_fragment_entry *
1504ieee80211_reassemble_add(struct ieee80211_sub_if_data *sdata,
1505 unsigned int frag, unsigned int seq, int rx_queue,
1506 struct sk_buff **skb)
1507{
1508 struct ieee80211_fragment_entry *entry;
Johannes Berg571ecf62007-07-27 15:43:22 +02001509
Johannes Berg571ecf62007-07-27 15:43:22 +02001510 entry = &sdata->fragments[sdata->fragment_next++];
1511 if (sdata->fragment_next >= IEEE80211_FRAGMENT_MAX)
1512 sdata->fragment_next = 0;
1513
Johannes Bergbdcbd8e2012-06-22 11:29:50 +02001514 if (!skb_queue_empty(&entry->skb_list))
Johannes Berg571ecf62007-07-27 15:43:22 +02001515 __skb_queue_purge(&entry->skb_list);
Johannes Berg571ecf62007-07-27 15:43:22 +02001516
1517 __skb_queue_tail(&entry->skb_list, *skb); /* no need for locking */
1518 *skb = NULL;
1519 entry->first_frag_time = jiffies;
1520 entry->seq = seq;
1521 entry->rx_queue = rx_queue;
1522 entry->last_frag = frag;
1523 entry->ccmp = 0;
1524 entry->extra_len = 0;
1525
1526 return entry;
1527}
1528
1529static inline struct ieee80211_fragment_entry *
1530ieee80211_reassemble_find(struct ieee80211_sub_if_data *sdata,
Harvey Harrisonb73d70a2008-07-15 18:44:12 -07001531 unsigned int frag, unsigned int seq,
Johannes Berg571ecf62007-07-27 15:43:22 +02001532 int rx_queue, struct ieee80211_hdr *hdr)
1533{
1534 struct ieee80211_fragment_entry *entry;
1535 int i, idx;
1536
1537 idx = sdata->fragment_next;
1538 for (i = 0; i < IEEE80211_FRAGMENT_MAX; i++) {
1539 struct ieee80211_hdr *f_hdr;
Johannes Berg571ecf62007-07-27 15:43:22 +02001540
1541 idx--;
1542 if (idx < 0)
1543 idx = IEEE80211_FRAGMENT_MAX - 1;
1544
1545 entry = &sdata->fragments[idx];
1546 if (skb_queue_empty(&entry->skb_list) || entry->seq != seq ||
1547 entry->rx_queue != rx_queue ||
1548 entry->last_frag + 1 != frag)
1549 continue;
1550
Harvey Harrisonb73d70a2008-07-15 18:44:12 -07001551 f_hdr = (struct ieee80211_hdr *)entry->skb_list.next->data;
Johannes Berg571ecf62007-07-27 15:43:22 +02001552
Harvey Harrisonb73d70a2008-07-15 18:44:12 -07001553 /*
1554 * Check ftype and addresses are equal, else check next fragment
1555 */
1556 if (((hdr->frame_control ^ f_hdr->frame_control) &
1557 cpu_to_le16(IEEE80211_FCTL_FTYPE)) ||
Joe Perchesb203ca32012-05-08 18:56:52 +00001558 !ether_addr_equal(hdr->addr1, f_hdr->addr1) ||
1559 !ether_addr_equal(hdr->addr2, f_hdr->addr2))
Johannes Berg571ecf62007-07-27 15:43:22 +02001560 continue;
1561
S.Çağlar Onurab466232008-02-14 17:36:47 +02001562 if (time_after(jiffies, entry->first_frag_time + 2 * HZ)) {
Johannes Berg571ecf62007-07-27 15:43:22 +02001563 __skb_queue_purge(&entry->skb_list);
1564 continue;
1565 }
1566 return entry;
1567 }
1568
1569 return NULL;
1570}
1571
Johannes Berg49461622008-06-30 15:10:45 +02001572static ieee80211_rx_result debug_noinline
Johannes Berg5cf121c2008-02-25 16:27:43 +01001573ieee80211_rx_h_defragment(struct ieee80211_rx_data *rx)
Johannes Berg571ecf62007-07-27 15:43:22 +02001574{
1575 struct ieee80211_hdr *hdr;
1576 u16 sc;
Harvey Harrison358c8d92008-07-15 18:44:13 -07001577 __le16 fc;
Johannes Berg571ecf62007-07-27 15:43:22 +02001578 unsigned int frag, seq;
1579 struct ieee80211_fragment_entry *entry;
1580 struct sk_buff *skb;
Johannes Berg554891e2010-09-24 12:38:25 +02001581 struct ieee80211_rx_status *status;
Johannes Berg571ecf62007-07-27 15:43:22 +02001582
Harvey Harrisonb73d70a2008-07-15 18:44:12 -07001583 hdr = (struct ieee80211_hdr *)rx->skb->data;
Harvey Harrison358c8d92008-07-15 18:44:13 -07001584 fc = hdr->frame_control;
Javier Cardonaf7fbf702012-10-25 11:10:18 -07001585
1586 if (ieee80211_is_ctl(fc))
1587 return RX_CONTINUE;
1588
Johannes Berg571ecf62007-07-27 15:43:22 +02001589 sc = le16_to_cpu(hdr->seq_ctrl);
1590 frag = sc & IEEE80211_SCTL_FRAG;
1591
Harvey Harrison358c8d92008-07-15 18:44:13 -07001592 if (likely((!ieee80211_has_morefrags(fc) && frag == 0) ||
Johannes Berg571ecf62007-07-27 15:43:22 +02001593 is_multicast_ether_addr(hdr->addr1))) {
1594 /* not fragmented */
1595 goto out;
1596 }
1597 I802_DEBUG_INC(rx->local->rx_handlers_fragments);
1598
Zhu Yie3cf8b32010-03-29 17:35:07 +08001599 if (skb_linearize(rx->skb))
1600 return RX_DROP_UNUSABLE;
1601
Abhijeet Kolekar058897a2010-05-11 11:22:11 -07001602 /*
1603 * skb_linearize() might change the skb->data and
1604 * previously cached variables (in this case, hdr) need to
1605 * be refreshed with the new data.
1606 */
1607 hdr = (struct ieee80211_hdr *)rx->skb->data;
Johannes Berg571ecf62007-07-27 15:43:22 +02001608 seq = (sc & IEEE80211_SCTL_SEQ) >> 4;
1609
1610 if (frag == 0) {
1611 /* This is the first fragment of a new frame. */
1612 entry = ieee80211_reassemble_add(rx->sdata, frag, seq,
Johannes Berg9e262972011-07-07 18:45:03 +02001613 rx->seqno_idx, &(rx->skb));
Johannes Berg97359d12010-08-10 09:46:38 +02001614 if (rx->key && rx->key->conf.cipher == WLAN_CIPHER_SUITE_CCMP &&
Harvey Harrison358c8d92008-07-15 18:44:13 -07001615 ieee80211_has_protected(fc)) {
Johannes Berg9e262972011-07-07 18:45:03 +02001616 int queue = rx->security_idx;
Johannes Berg571ecf62007-07-27 15:43:22 +02001617 /* Store CCMP PN so that we can verify that the next
1618 * fragment has a sequential PN value. */
1619 entry->ccmp = 1;
1620 memcpy(entry->last_pn,
Jouni Malinen91902522010-06-11 10:27:33 -07001621 rx->key->u.ccmp.rx_pn[queue],
Johannes Berg571ecf62007-07-27 15:43:22 +02001622 CCMP_PN_LEN);
1623 }
Johannes Berg9ae54c82008-01-31 19:48:20 +01001624 return RX_QUEUED;
Johannes Berg571ecf62007-07-27 15:43:22 +02001625 }
1626
1627 /* This is a fragment for a frame that should already be pending in
1628 * fragment cache. Add this fragment to the end of the pending entry.
1629 */
Johannes Berg9e262972011-07-07 18:45:03 +02001630 entry = ieee80211_reassemble_find(rx->sdata, frag, seq,
1631 rx->seqno_idx, hdr);
Johannes Berg571ecf62007-07-27 15:43:22 +02001632 if (!entry) {
1633 I802_DEBUG_INC(rx->local->rx_handlers_drop_defrag);
Johannes Berge4c26ad2008-01-31 19:48:21 +01001634 return RX_DROP_MONITOR;
Johannes Berg571ecf62007-07-27 15:43:22 +02001635 }
1636
1637 /* Verify that MPDUs within one MSDU have sequential PN values.
1638 * (IEEE 802.11i, 8.3.3.4.5) */
1639 if (entry->ccmp) {
1640 int i;
1641 u8 pn[CCMP_PN_LEN], *rpn;
Jouni Malinen91902522010-06-11 10:27:33 -07001642 int queue;
Johannes Berg97359d12010-08-10 09:46:38 +02001643 if (!rx->key || rx->key->conf.cipher != WLAN_CIPHER_SUITE_CCMP)
Johannes Berge4c26ad2008-01-31 19:48:21 +01001644 return RX_DROP_UNUSABLE;
Johannes Berg571ecf62007-07-27 15:43:22 +02001645 memcpy(pn, entry->last_pn, CCMP_PN_LEN);
1646 for (i = CCMP_PN_LEN - 1; i >= 0; i--) {
1647 pn[i]++;
1648 if (pn[i])
1649 break;
1650 }
Johannes Berg9e262972011-07-07 18:45:03 +02001651 queue = rx->security_idx;
Jouni Malinen91902522010-06-11 10:27:33 -07001652 rpn = rx->key->u.ccmp.rx_pn[queue];
Johannes Bergf4ea83d2008-06-30 15:10:46 +02001653 if (memcmp(pn, rpn, CCMP_PN_LEN))
Johannes Berge4c26ad2008-01-31 19:48:21 +01001654 return RX_DROP_UNUSABLE;
Johannes Berg571ecf62007-07-27 15:43:22 +02001655 memcpy(entry->last_pn, pn, CCMP_PN_LEN);
1656 }
1657
Harvey Harrison358c8d92008-07-15 18:44:13 -07001658 skb_pull(rx->skb, ieee80211_hdrlen(fc));
Johannes Berg571ecf62007-07-27 15:43:22 +02001659 __skb_queue_tail(&entry->skb_list, rx->skb);
1660 entry->last_frag = frag;
1661 entry->extra_len += rx->skb->len;
Harvey Harrison358c8d92008-07-15 18:44:13 -07001662 if (ieee80211_has_morefrags(fc)) {
Johannes Berg571ecf62007-07-27 15:43:22 +02001663 rx->skb = NULL;
Johannes Berg9ae54c82008-01-31 19:48:20 +01001664 return RX_QUEUED;
Johannes Berg571ecf62007-07-27 15:43:22 +02001665 }
1666
1667 rx->skb = __skb_dequeue(&entry->skb_list);
1668 if (skb_tailroom(rx->skb) < entry->extra_len) {
1669 I802_DEBUG_INC(rx->local->rx_expand_skb_head2);
1670 if (unlikely(pskb_expand_head(rx->skb, 0, entry->extra_len,
1671 GFP_ATOMIC))) {
1672 I802_DEBUG_INC(rx->local->rx_handlers_drop_defrag);
1673 __skb_queue_purge(&entry->skb_list);
Johannes Berge4c26ad2008-01-31 19:48:21 +01001674 return RX_DROP_UNUSABLE;
Johannes Berg571ecf62007-07-27 15:43:22 +02001675 }
1676 }
1677 while ((skb = __skb_dequeue(&entry->skb_list))) {
1678 memcpy(skb_put(rx->skb, skb->len), skb->data, skb->len);
1679 dev_kfree_skb(skb);
1680 }
1681
1682 /* Complete frame has been reassembled - process it now */
Johannes Berg554891e2010-09-24 12:38:25 +02001683 status = IEEE80211_SKB_RXCB(rx->skb);
1684 status->rx_flags |= IEEE80211_RX_FRAGMENTED;
Johannes Berg571ecf62007-07-27 15:43:22 +02001685
1686 out:
1687 if (rx->sta)
1688 rx->sta->rx_packets++;
1689 if (is_multicast_ether_addr(hdr->addr1))
1690 rx->local->dot11MulticastReceivedFrameCount++;
1691 else
1692 ieee80211_led_rx(rx->local);
Johannes Berg9ae54c82008-01-31 19:48:20 +01001693 return RX_CONTINUE;
Johannes Berg571ecf62007-07-27 15:43:22 +02001694}
1695
Johannes Berg1df332e2012-10-26 00:09:11 +02001696static int ieee80211_802_1x_port_control(struct ieee80211_rx_data *rx)
Johannes Berg571ecf62007-07-27 15:43:22 +02001697{
Johannes Berg1df332e2012-10-26 00:09:11 +02001698 if (unlikely(!rx->sta || !test_sta_flag(rx->sta, WLAN_STA_AUTHORIZED)))
Ron Rindjunsky76ee65b2007-11-22 19:49:12 +02001699 return -EACCES;
Johannes Berg571ecf62007-07-27 15:43:22 +02001700
Ron Rindjunsky76ee65b2007-11-22 19:49:12 +02001701 return 0;
Johannes Berg571ecf62007-07-27 15:43:22 +02001702}
1703
Johannes Berg1df332e2012-10-26 00:09:11 +02001704static int ieee80211_drop_unencrypted(struct ieee80211_rx_data *rx, __le16 fc)
Johannes Berg571ecf62007-07-27 15:43:22 +02001705{
Johannes Bergeb9fb5b2009-11-16 13:58:20 +01001706 struct sk_buff *skb = rx->skb;
1707 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
1708
Johannes Berg3017b802007-08-28 17:01:53 -04001709 /*
Johannes Berg7848ba72007-09-14 11:10:25 -04001710 * Pass through unencrypted frames if the hardware has
1711 * decrypted them already.
Johannes Berg3017b802007-08-28 17:01:53 -04001712 */
Johannes Bergeb9fb5b2009-11-16 13:58:20 +01001713 if (status->flag & RX_FLAG_DECRYPTED)
Ron Rindjunsky76ee65b2007-11-22 19:49:12 +02001714 return 0;
Johannes Berg571ecf62007-07-27 15:43:22 +02001715
1716 /* Drop unencrypted frames if key is set. */
Harvey Harrison358c8d92008-07-15 18:44:13 -07001717 if (unlikely(!ieee80211_has_protected(fc) &&
1718 !ieee80211_is_nullfunc(fc) &&
Jouni Malinenf2ca3ea2009-05-08 12:36:03 +03001719 ieee80211_is_data(fc) &&
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +02001720 (rx->key || rx->sdata->drop_unencrypted)))
1721 return -EACCES;
Johannes Bergbef5d1c2010-02-16 11:05:00 +01001722
1723 return 0;
1724}
1725
Johannes Berg1df332e2012-10-26 00:09:11 +02001726static int ieee80211_drop_unencrypted_mgmt(struct ieee80211_rx_data *rx)
Johannes Bergbef5d1c2010-02-16 11:05:00 +01001727{
1728 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
Jouni Malinene3efca02010-03-28 22:31:15 -07001729 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb);
Johannes Bergbef5d1c2010-02-16 11:05:00 +01001730 __le16 fc = hdr->frame_control;
Johannes Bergbef5d1c2010-02-16 11:05:00 +01001731
Jouni Malinene3efca02010-03-28 22:31:15 -07001732 /*
1733 * Pass through unencrypted frames if the hardware has
1734 * decrypted them already.
1735 */
1736 if (status->flag & RX_FLAG_DECRYPTED)
1737 return 0;
Johannes Bergbef5d1c2010-02-16 11:05:00 +01001738
Johannes Bergc2c98fd2011-09-29 16:04:36 +02001739 if (rx->sta && test_sta_flag(rx->sta, WLAN_STA_MFP)) {
Jouni Malinend211e902010-03-28 22:29:52 -07001740 if (unlikely(!ieee80211_has_protected(fc) &&
1741 ieee80211_is_unicast_robust_mgmt_frame(rx->skb) &&
Jouni Malinencf4e5942010-12-16 00:52:40 +02001742 rx->key)) {
1743 if (ieee80211_is_deauth(fc))
1744 cfg80211_send_unprot_deauth(rx->sdata->dev,
1745 rx->skb->data,
1746 rx->skb->len);
1747 else if (ieee80211_is_disassoc(fc))
1748 cfg80211_send_unprot_disassoc(rx->sdata->dev,
1749 rx->skb->data,
1750 rx->skb->len);
Jouni Malinenf2ca3ea2009-05-08 12:36:03 +03001751 return -EACCES;
Jouni Malinencf4e5942010-12-16 00:52:40 +02001752 }
Jouni Malinenf2ca3ea2009-05-08 12:36:03 +03001753 /* BIP does not use Protected field, so need to check MMIE */
Joe Perchesf64f9e72009-11-29 16:55:45 -08001754 if (unlikely(ieee80211_is_multicast_robust_mgmt_frame(rx->skb) &&
Jouni Malinencf4e5942010-12-16 00:52:40 +02001755 ieee80211_get_mmie_keyidx(rx->skb) < 0)) {
1756 if (ieee80211_is_deauth(fc))
1757 cfg80211_send_unprot_deauth(rx->sdata->dev,
1758 rx->skb->data,
1759 rx->skb->len);
1760 else if (ieee80211_is_disassoc(fc))
1761 cfg80211_send_unprot_disassoc(rx->sdata->dev,
1762 rx->skb->data,
1763 rx->skb->len);
Jouni Malinenf2ca3ea2009-05-08 12:36:03 +03001764 return -EACCES;
Jouni Malinencf4e5942010-12-16 00:52:40 +02001765 }
Jouni Malinenf2ca3ea2009-05-08 12:36:03 +03001766 /*
1767 * When using MFP, Action frames are not allowed prior to
1768 * having configured keys.
1769 */
1770 if (unlikely(ieee80211_is_action(fc) && !rx->key &&
1771 ieee80211_is_robust_mgmt_frame(
1772 (struct ieee80211_hdr *) rx->skb->data)))
1773 return -EACCES;
1774 }
Johannes Bergb3fc9c62008-04-13 10:12:47 +02001775
Ron Rindjunsky76ee65b2007-11-22 19:49:12 +02001776 return 0;
Johannes Berg571ecf62007-07-27 15:43:22 +02001777}
1778
Ron Rindjunsky76ee65b2007-11-22 19:49:12 +02001779static int
Felix Fietkau4114fa22011-04-12 19:15:22 +02001780__ieee80211_data_to_8023(struct ieee80211_rx_data *rx, bool *port_control)
Johannes Berg571ecf62007-07-27 15:43:22 +02001781{
Johannes Bergeb9fb5b2009-11-16 13:58:20 +01001782 struct ieee80211_sub_if_data *sdata = rx->sdata;
Felix Fietkauf14543ee2009-11-10 20:10:05 +01001783 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
Felix Fietkaufbb327c2011-01-18 15:48:48 +01001784 bool check_port_control = false;
1785 struct ethhdr *ehdr;
1786 int ret;
Felix Fietkauf14543ee2009-11-10 20:10:05 +01001787
Felix Fietkau4114fa22011-04-12 19:15:22 +02001788 *port_control = false;
Johannes Berg9bc383d2009-11-19 11:55:19 +01001789 if (ieee80211_has_a4(hdr->frame_control) &&
1790 sdata->vif.type == NL80211_IFTYPE_AP_VLAN && !sdata->u.vlan.sta)
Felix Fietkauf14543ee2009-11-10 20:10:05 +01001791 return -1;
Johannes Berg9bc383d2009-11-19 11:55:19 +01001792
Felix Fietkaufbb327c2011-01-18 15:48:48 +01001793 if (sdata->vif.type == NL80211_IFTYPE_STATION &&
1794 !!sdata->u.mgd.use_4addr != !!ieee80211_has_a4(hdr->frame_control)) {
1795
1796 if (!sdata->u.mgd.use_4addr)
1797 return -1;
1798 else
1799 check_port_control = true;
1800 }
1801
Johannes Berg9bc383d2009-11-19 11:55:19 +01001802 if (is_multicast_ether_addr(hdr->addr1) &&
Felix Fietkaufbb327c2011-01-18 15:48:48 +01001803 sdata->vif.type == NL80211_IFTYPE_AP_VLAN && sdata->u.vlan.sta)
Felix Fietkauf14543ee2009-11-10 20:10:05 +01001804 return -1;
Johannes Berg571ecf62007-07-27 15:43:22 +02001805
Felix Fietkaufbb327c2011-01-18 15:48:48 +01001806 ret = ieee80211_data_to_8023(rx->skb, sdata->vif.addr, sdata->vif.type);
Felix Fietkau4114fa22011-04-12 19:15:22 +02001807 if (ret < 0)
Felix Fietkaufbb327c2011-01-18 15:48:48 +01001808 return ret;
1809
1810 ehdr = (struct ethhdr *) rx->skb->data;
Felix Fietkau4114fa22011-04-12 19:15:22 +02001811 if (ehdr->h_proto == rx->sdata->control_port_protocol)
1812 *port_control = true;
1813 else if (check_port_control)
Felix Fietkaufbb327c2011-01-18 15:48:48 +01001814 return -1;
1815
1816 return 0;
Ron Rindjunsky76ee65b2007-11-22 19:49:12 +02001817}
Johannes Berg571ecf62007-07-27 15:43:22 +02001818
Johannes Bergce3edf6d02007-12-19 01:31:22 +01001819/*
1820 * requires that rx->skb is a frame with ethernet header
1821 */
Harvey Harrison358c8d92008-07-15 18:44:13 -07001822static bool ieee80211_frame_allowed(struct ieee80211_rx_data *rx, __le16 fc)
Johannes Bergce3edf6d02007-12-19 01:31:22 +01001823{
Senthil Balasubramanianc97c23e2008-05-28 23:15:32 +05301824 static const u8 pae_group_addr[ETH_ALEN] __aligned(2)
Johannes Bergce3edf6d02007-12-19 01:31:22 +01001825 = { 0x01, 0x80, 0xC2, 0x00, 0x00, 0x03 };
1826 struct ethhdr *ehdr = (struct ethhdr *) rx->skb->data;
1827
1828 /*
1829 * Allow EAPOL frames to us/the PAE group address regardless
1830 * of whether the frame was encrypted or not.
1831 */
Johannes Berga621fa42010-08-27 14:26:54 +03001832 if (ehdr->h_proto == rx->sdata->control_port_protocol &&
Joe Perches3bc79452012-05-08 18:56:53 +00001833 (ether_addr_equal(ehdr->h_dest, rx->sdata->vif.addr) ||
1834 ether_addr_equal(ehdr->h_dest, pae_group_addr)))
Johannes Bergce3edf6d02007-12-19 01:31:22 +01001835 return true;
1836
1837 if (ieee80211_802_1x_port_control(rx) ||
Harvey Harrison358c8d92008-07-15 18:44:13 -07001838 ieee80211_drop_unencrypted(rx, fc))
Johannes Bergce3edf6d02007-12-19 01:31:22 +01001839 return false;
1840
1841 return true;
1842}
1843
1844/*
1845 * requires that rx->skb is a frame with ethernet header
1846 */
Ron Rindjunsky76ee65b2007-11-22 19:49:12 +02001847static void
Johannes Berg5cf121c2008-02-25 16:27:43 +01001848ieee80211_deliver_skb(struct ieee80211_rx_data *rx)
Ron Rindjunsky76ee65b2007-11-22 19:49:12 +02001849{
Johannes Bergeb9fb5b2009-11-16 13:58:20 +01001850 struct ieee80211_sub_if_data *sdata = rx->sdata;
1851 struct net_device *dev = sdata->dev;
Ron Rindjunsky76ee65b2007-11-22 19:49:12 +02001852 struct sk_buff *skb, *xmit_skb;
Johannes Bergce3edf6d02007-12-19 01:31:22 +01001853 struct ethhdr *ehdr = (struct ethhdr *) rx->skb->data;
1854 struct sta_info *dsta;
Johannes Berg554891e2010-09-24 12:38:25 +02001855 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb);
Johannes Berg571ecf62007-07-27 15:43:22 +02001856
Ron Rindjunsky76ee65b2007-11-22 19:49:12 +02001857 skb = rx->skb;
1858 xmit_skb = NULL;
Johannes Berg571ecf62007-07-27 15:43:22 +02001859
Johannes Berg05c914f2008-09-11 00:01:58 +02001860 if ((sdata->vif.type == NL80211_IFTYPE_AP ||
1861 sdata->vif.type == NL80211_IFTYPE_AP_VLAN) &&
Johannes Berg213cd112008-09-11 00:01:54 +02001862 !(sdata->flags & IEEE80211_SDATA_DONT_BRIDGE_PACKETS) &&
Johannes Berg554891e2010-09-24 12:38:25 +02001863 (status->rx_flags & IEEE80211_RX_RA_MATCH) &&
Johannes Berg9bc383d2009-11-19 11:55:19 +01001864 (sdata->vif.type != NL80211_IFTYPE_AP_VLAN || !sdata->u.vlan.sta)) {
Johannes Bergce3edf6d02007-12-19 01:31:22 +01001865 if (is_multicast_ether_addr(ehdr->h_dest)) {
1866 /*
1867 * send multicast frames both to higher layers in
1868 * local net stack and back to the wireless medium
1869 */
Ron Rindjunsky76ee65b2007-11-22 19:49:12 +02001870 xmit_skb = skb_copy(skb, GFP_ATOMIC);
Joe Perchese87cc472012-05-13 21:56:26 +00001871 if (!xmit_skb)
Johannes Bergbdcbd8e2012-06-22 11:29:50 +02001872 net_info_ratelimited("%s: failed to clone multicast frame\n",
Joe Perchese87cc472012-05-13 21:56:26 +00001873 dev->name);
Johannes Berg571ecf62007-07-27 15:43:22 +02001874 } else {
Johannes Bergabe60632009-11-25 17:46:18 +01001875 dsta = sta_info_get(sdata, skb->data);
1876 if (dsta) {
Johannes Bergce3edf6d02007-12-19 01:31:22 +01001877 /*
1878 * The destination station is associated to
1879 * this AP (in this VLAN), so send the frame
1880 * directly to it and do not pass it to local
1881 * net stack.
Johannes Berg571ecf62007-07-27 15:43:22 +02001882 */
Ron Rindjunsky76ee65b2007-11-22 19:49:12 +02001883 xmit_skb = skb;
Johannes Berg571ecf62007-07-27 15:43:22 +02001884 skb = NULL;
1885 }
Johannes Berg571ecf62007-07-27 15:43:22 +02001886 }
1887 }
1888
1889 if (skb) {
Johannes Bergd1c3a372009-01-07 00:26:10 +01001890 int align __maybe_unused;
1891
Kalle Valo59d9cb02009-12-17 13:54:57 +01001892#ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
Johannes Bergd1c3a372009-01-07 00:26:10 +01001893 /*
1894 * 'align' will only take the values 0 or 2 here
1895 * since all frames are required to be aligned
1896 * to 2-byte boundaries when being passed to
1897 * mac80211. That also explains the __skb_push()
1898 * below.
1899 */
matthieu castetdacb6f12009-06-04 22:16:18 +02001900 align = ((unsigned long)(skb->data + sizeof(struct ethhdr))) & 3;
Johannes Bergd1c3a372009-01-07 00:26:10 +01001901 if (align) {
1902 if (WARN_ON(skb_headroom(skb) < 3)) {
1903 dev_kfree_skb(skb);
1904 skb = NULL;
1905 } else {
1906 u8 *data = skb->data;
Zhu Yi8ce0b582009-10-28 13:13:52 -07001907 size_t len = skb_headlen(skb);
1908 skb->data -= align;
1909 memmove(skb->data, data, len);
1910 skb_set_tail_pointer(skb, len);
Johannes Bergd1c3a372009-01-07 00:26:10 +01001911 }
1912 }
1913#endif
1914
1915 if (skb) {
1916 /* deliver to local stack */
1917 skb->protocol = eth_type_trans(skb, dev);
1918 memset(skb->cb, 0, sizeof(skb->cb));
John W. Linville5548a8a2010-06-24 14:25:56 -04001919 netif_receive_skb(skb);
Johannes Bergd1c3a372009-01-07 00:26:10 +01001920 }
Johannes Berg571ecf62007-07-27 15:43:22 +02001921 }
1922
Ron Rindjunsky76ee65b2007-11-22 19:49:12 +02001923 if (xmit_skb) {
Helmut Schaaaef6c922011-12-21 09:11:35 +01001924 /*
1925 * Send to wireless media and increase priority by 256 to
1926 * keep the received priority instead of reclassifying
1927 * the frame (see cfg80211_classify8021d).
1928 */
1929 xmit_skb->priority += 256;
YOSHIFUJI Hideakif831e902007-12-12 03:54:23 +09001930 xmit_skb->protocol = htons(ETH_P_802_3);
Johannes Bergce3edf6d02007-12-19 01:31:22 +01001931 skb_reset_network_header(xmit_skb);
1932 skb_reset_mac_header(xmit_skb);
Ron Rindjunsky76ee65b2007-11-22 19:49:12 +02001933 dev_queue_xmit(xmit_skb);
Johannes Berg571ecf62007-07-27 15:43:22 +02001934 }
Ron Rindjunsky76ee65b2007-11-22 19:49:12 +02001935}
1936
Johannes Berg49461622008-06-30 15:10:45 +02001937static ieee80211_rx_result debug_noinline
Johannes Berg5cf121c2008-02-25 16:27:43 +01001938ieee80211_rx_h_amsdu(struct ieee80211_rx_data *rx)
Ron Rindjunskyfd4c7f22007-11-26 16:14:33 +02001939{
Johannes Bergeb9fb5b2009-11-16 13:58:20 +01001940 struct net_device *dev = rx->sdata->dev;
Zhu Yieaf85ca2009-12-01 10:18:37 +08001941 struct sk_buff *skb = rx->skb;
Harvey Harrison358c8d92008-07-15 18:44:13 -07001942 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1943 __le16 fc = hdr->frame_control;
Zhu Yieaf85ca2009-12-01 10:18:37 +08001944 struct sk_buff_head frame_list;
Johannes Berg554891e2010-09-24 12:38:25 +02001945 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb);
Ron Rindjunskyfd4c7f22007-11-26 16:14:33 +02001946
Harvey Harrison358c8d92008-07-15 18:44:13 -07001947 if (unlikely(!ieee80211_is_data(fc)))
Johannes Berg9ae54c82008-01-31 19:48:20 +01001948 return RX_CONTINUE;
Ron Rindjunskyfd4c7f22007-11-26 16:14:33 +02001949
Harvey Harrison358c8d92008-07-15 18:44:13 -07001950 if (unlikely(!ieee80211_is_data_present(fc)))
Johannes Berge4c26ad2008-01-31 19:48:21 +01001951 return RX_DROP_MONITOR;
Ron Rindjunskyfd4c7f22007-11-26 16:14:33 +02001952
Johannes Berg554891e2010-09-24 12:38:25 +02001953 if (!(status->rx_flags & IEEE80211_RX_AMSDU))
Johannes Berg9ae54c82008-01-31 19:48:20 +01001954 return RX_CONTINUE;
Ron Rindjunskyfd4c7f22007-11-26 16:14:33 +02001955
Zhu Yieaf85ca2009-12-01 10:18:37 +08001956 if (ieee80211_has_a4(hdr->frame_control) &&
1957 rx->sdata->vif.type == NL80211_IFTYPE_AP_VLAN &&
1958 !rx->sdata->u.vlan.sta)
1959 return RX_DROP_UNUSABLE;
1960
1961 if (is_multicast_ether_addr(hdr->addr1) &&
1962 ((rx->sdata->vif.type == NL80211_IFTYPE_AP_VLAN &&
1963 rx->sdata->u.vlan.sta) ||
1964 (rx->sdata->vif.type == NL80211_IFTYPE_STATION &&
1965 rx->sdata->u.mgd.use_4addr)))
Johannes Berge4c26ad2008-01-31 19:48:21 +01001966 return RX_DROP_UNUSABLE;
Ron Rindjunskyfd4c7f22007-11-26 16:14:33 +02001967
1968 skb->dev = dev;
Zhu Yieaf85ca2009-12-01 10:18:37 +08001969 __skb_queue_head_init(&frame_list);
Ron Rindjunskyfd4c7f22007-11-26 16:14:33 +02001970
Zhu Yie3cf8b32010-03-29 17:35:07 +08001971 if (skb_linearize(skb))
1972 return RX_DROP_UNUSABLE;
1973
Zhu Yieaf85ca2009-12-01 10:18:37 +08001974 ieee80211_amsdu_to_8023s(skb, &frame_list, dev->dev_addr,
1975 rx->sdata->vif.type,
Yogesh Ashok Powar8b3beca2011-05-13 11:22:31 -07001976 rx->local->hw.extra_tx_headroom, true);
Ron Rindjunskyfd4c7f22007-11-26 16:14:33 +02001977
Zhu Yieaf85ca2009-12-01 10:18:37 +08001978 while (!skb_queue_empty(&frame_list)) {
1979 rx->skb = __skb_dequeue(&frame_list);
Ron Rindjunskyfd4c7f22007-11-26 16:14:33 +02001980
Harvey Harrison358c8d92008-07-15 18:44:13 -07001981 if (!ieee80211_frame_allowed(rx, fc)) {
Zhu Yieaf85ca2009-12-01 10:18:37 +08001982 dev_kfree_skb(rx->skb);
Johannes Bergce3edf6d02007-12-19 01:31:22 +01001983 continue;
1984 }
Zhu Yieaf85ca2009-12-01 10:18:37 +08001985 dev->stats.rx_packets++;
1986 dev->stats.rx_bytes += rx->skb->len;
Ron Rindjunskyfd4c7f22007-11-26 16:14:33 +02001987
1988 ieee80211_deliver_skb(rx);
1989 }
1990
Johannes Berg9ae54c82008-01-31 19:48:20 +01001991 return RX_QUEUED;
Ron Rindjunskyfd4c7f22007-11-26 16:14:33 +02001992}
1993
Ingo Molnarbf94e172008-10-12 23:51:38 -07001994#ifdef CONFIG_MAC80211_MESH
Davide Pesaventob0dee572008-09-27 17:29:12 +02001995static ieee80211_rx_result
Luis Carlos Coboe32f85f2008-08-05 19:34:52 +02001996ieee80211_rx_h_mesh_fwding(struct ieee80211_rx_data *rx)
1997{
Thomas Pedersen30789eb2011-11-24 17:15:26 -08001998 struct ieee80211_hdr *fwd_hdr, *hdr;
1999 struct ieee80211_tx_info *info;
Luis Carlos Coboe32f85f2008-08-05 19:34:52 +02002000 struct ieee80211s_hdr *mesh_hdr;
Luis Carlos Coboe32f85f2008-08-05 19:34:52 +02002001 struct sk_buff *skb = rx->skb, *fwd_skb;
Johannes Berg3b8d81e02009-06-17 17:43:56 +02002002 struct ieee80211_local *local = rx->local;
Johannes Bergeb9fb5b2009-11-16 13:58:20 +01002003 struct ieee80211_sub_if_data *sdata = rx->sdata;
Johannes Berg554891e2010-09-24 12:38:25 +02002004 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
Thomas Pedersen30789eb2011-11-24 17:15:26 -08002005 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
Thomas Pedersen0cfda852011-11-24 17:15:25 -08002006 __le16 reason = cpu_to_le16(WLAN_REASON_MESH_PATH_NOFORWARD);
Thomas Pedersen30789eb2011-11-24 17:15:26 -08002007 u16 q, hdrlen;
Luis Carlos Coboe32f85f2008-08-05 19:34:52 +02002008
2009 hdr = (struct ieee80211_hdr *) skb->data;
2010 hdrlen = ieee80211_hdrlen(hdr->frame_control);
Johannes Berg9b395bc2012-10-26 00:36:40 +02002011
2012 /* make sure fixed part of mesh header is there, also checks skb len */
2013 if (!pskb_may_pull(rx->skb, hdrlen + 6))
2014 return RX_DROP_MONITOR;
2015
2016 mesh_hdr = (struct ieee80211s_hdr *) (skb->data + hdrlen);
2017
2018 /* make sure full mesh header is there, also checks skb len */
2019 if (!pskb_may_pull(rx->skb,
2020 hdrlen + ieee80211_get_mesh_hdrlen(mesh_hdr)))
2021 return RX_DROP_MONITOR;
2022
2023 /* reload pointers */
2024 hdr = (struct ieee80211_hdr *) skb->data;
Luis Carlos Coboe32f85f2008-08-05 19:34:52 +02002025 mesh_hdr = (struct ieee80211s_hdr *) (skb->data + hdrlen);
2026
Thomas Pedersen2157fdd2011-09-01 12:32:14 -07002027 /* frame is in RMC, don't forward */
2028 if (ieee80211_is_data(hdr->frame_control) &&
2029 is_multicast_ether_addr(hdr->addr1) &&
Johannes Bergbf7cd942013-02-15 14:40:31 +01002030 mesh_rmc_check(rx->sdata, hdr->addr3, mesh_hdr))
Thomas Pedersen2157fdd2011-09-01 12:32:14 -07002031 return RX_DROP_MONITOR;
2032
Javier Cardona555cb712012-10-24 12:43:30 -07002033 if (!ieee80211_is_data(hdr->frame_control) ||
2034 !(status->rx_flags & IEEE80211_RX_RA_MATCH))
Luis Carlos Coboe32f85f2008-08-05 19:34:52 +02002035 return RX_CONTINUE;
2036
2037 if (!mesh_hdr->ttl)
Luis Carlos Coboe32f85f2008-08-05 19:34:52 +02002038 return RX_DROP_MONITOR;
2039
Javier Cardona43b7b312009-10-15 18:10:51 -07002040 if (mesh_hdr->flags & MESH_FLAGS_AE) {
YanBo79617de2008-09-22 13:30:32 +08002041 struct mesh_path *mppath;
Javier Cardona43b7b312009-10-15 18:10:51 -07002042 char *proxied_addr;
2043 char *mpp_addr;
2044
2045 if (is_multicast_ether_addr(hdr->addr1)) {
2046 mpp_addr = hdr->addr3;
2047 proxied_addr = mesh_hdr->eaddr1;
Johannes Berg9b395bc2012-10-26 00:36:40 +02002048 } else if (mesh_hdr->flags & MESH_FLAGS_AE_A5_A6) {
2049 /* has_a4 already checked in ieee80211_rx_mesh_check */
Javier Cardona43b7b312009-10-15 18:10:51 -07002050 mpp_addr = hdr->addr4;
2051 proxied_addr = mesh_hdr->eaddr2;
Johannes Berg9b395bc2012-10-26 00:36:40 +02002052 } else {
2053 return RX_DROP_MONITOR;
Javier Cardona43b7b312009-10-15 18:10:51 -07002054 }
YanBo79617de2008-09-22 13:30:32 +08002055
YanBo79617de2008-09-22 13:30:32 +08002056 rcu_read_lock();
Johannes Bergbf7cd942013-02-15 14:40:31 +01002057 mppath = mpp_path_lookup(sdata, proxied_addr);
YanBo79617de2008-09-22 13:30:32 +08002058 if (!mppath) {
Johannes Bergbf7cd942013-02-15 14:40:31 +01002059 mpp_path_add(sdata, proxied_addr, mpp_addr);
YanBo79617de2008-09-22 13:30:32 +08002060 } else {
2061 spin_lock_bh(&mppath->state_lock);
Joe Perchesb203ca32012-05-08 18:56:52 +00002062 if (!ether_addr_equal(mppath->mpp, mpp_addr))
Javier Cardona43b7b312009-10-15 18:10:51 -07002063 memcpy(mppath->mpp, mpp_addr, ETH_ALEN);
YanBo79617de2008-09-22 13:30:32 +08002064 spin_unlock_bh(&mppath->state_lock);
2065 }
2066 rcu_read_unlock();
2067 }
2068
Javier Cardona3c5772a2009-08-10 12:15:48 -07002069 /* Frame has reached destination. Don't forward */
2070 if (!is_multicast_ether_addr(hdr->addr1) &&
Joe Perchesb203ca32012-05-08 18:56:52 +00002071 ether_addr_equal(sdata->vif.addr, hdr->addr3))
Luis Carlos Coboe32f85f2008-08-05 19:34:52 +02002072 return RX_CONTINUE;
2073
Yoni Divinsky00e96de2012-06-20 15:39:13 +03002074 q = ieee80211_select_queue_80211(sdata, skb, hdr);
Thomas Pedersend3c15972011-11-24 17:15:23 -08002075 if (ieee80211_queue_stopped(&local->hw, q)) {
Thomas Pedersen30789eb2011-11-24 17:15:26 -08002076 IEEE80211_IFSTA_MESH_CTR_INC(ifmsh, dropped_frames_congestion);
Thomas Pedersend3c15972011-11-24 17:15:23 -08002077 return RX_DROP_MONITOR;
2078 }
2079 skb_set_queue_mapping(skb, q);
Luis Carlos Coboe32f85f2008-08-05 19:34:52 +02002080
Thomas Pedersen30789eb2011-11-24 17:15:26 -08002081 if (!--mesh_hdr->ttl) {
2082 IEEE80211_IFSTA_MESH_CTR_INC(ifmsh, dropped_frames_ttl);
Javier Cardona2ac64cd2012-10-24 12:43:31 -07002083 goto out;
Luis Carlos Coboe32f85f2008-08-05 19:34:52 +02002084 }
2085
Chun-Yeow Yeohd6655082012-03-02 02:03:19 +08002086 if (!ifmsh->mshcfg.dot11MeshForwarding)
2087 goto out;
2088
Thomas Pedersen30789eb2011-11-24 17:15:26 -08002089 fwd_skb = skb_copy(skb, GFP_ATOMIC);
2090 if (!fwd_skb) {
Johannes Bergbdcbd8e2012-06-22 11:29:50 +02002091 net_info_ratelimited("%s: failed to clone mesh frame\n",
Joe Perchese87cc472012-05-13 21:56:26 +00002092 sdata->name);
Thomas Pedersen30789eb2011-11-24 17:15:26 -08002093 goto out;
2094 }
2095
2096 fwd_hdr = (struct ieee80211_hdr *) fwd_skb->data;
2097 info = IEEE80211_SKB_CB(fwd_skb);
2098 memset(info, 0, sizeof(*info));
2099 info->flags |= IEEE80211_TX_INTFL_NEED_TXPROCESSING;
2100 info->control.vif = &rx->sdata->vif;
2101 info->control.jiffies = jiffies;
2102 if (is_multicast_ether_addr(fwd_hdr->addr1)) {
2103 IEEE80211_IFSTA_MESH_CTR_INC(ifmsh, fwded_mcast);
2104 memcpy(fwd_hdr->addr2, sdata->vif.addr, ETH_ALEN);
Marco Porsch3f52b7e2013-01-30 18:14:08 +01002105 /* update power mode indication when forwarding */
2106 ieee80211_mps_set_frame_flags(sdata, NULL, fwd_hdr);
Johannes Bergbf7cd942013-02-15 14:40:31 +01002107 } else if (!mesh_nexthop_lookup(sdata, fwd_skb)) {
Marco Porsch3f52b7e2013-01-30 18:14:08 +01002108 /* mesh power mode flags updated in mesh_nexthop_lookup */
Thomas Pedersen30789eb2011-11-24 17:15:26 -08002109 IEEE80211_IFSTA_MESH_CTR_INC(ifmsh, fwded_unicast);
2110 } else {
2111 /* unable to resolve next hop */
Johannes Bergbf7cd942013-02-15 14:40:31 +01002112 mesh_path_error_tx(sdata, ifmsh->mshcfg.element_ttl,
2113 fwd_hdr->addr3, 0, reason, fwd_hdr->addr2);
Thomas Pedersen30789eb2011-11-24 17:15:26 -08002114 IEEE80211_IFSTA_MESH_CTR_INC(ifmsh, dropped_frames_no_route);
Jesper Juhl74b8cc32012-01-14 21:52:17 +01002115 kfree_skb(fwd_skb);
Thomas Pedersen30789eb2011-11-24 17:15:26 -08002116 return RX_DROP_MONITOR;
2117 }
2118
2119 IEEE80211_IFSTA_MESH_CTR_INC(ifmsh, fwded_frames);
2120 ieee80211_add_pending_skb(local, fwd_skb);
Johannes Bergb51aff02010-12-22 10:15:07 +01002121 out:
Javier Cardona3c5772a2009-08-10 12:15:48 -07002122 if (is_multicast_ether_addr(hdr->addr1) ||
Johannes Bergeb9fb5b2009-11-16 13:58:20 +01002123 sdata->dev->flags & IFF_PROMISC)
Luis Carlos Coboe32f85f2008-08-05 19:34:52 +02002124 return RX_CONTINUE;
2125 else
2126 return RX_DROP_MONITOR;
2127}
Ingo Molnarbf94e172008-10-12 23:51:38 -07002128#endif
Luis Carlos Coboe32f85f2008-08-05 19:34:52 +02002129
2130static ieee80211_rx_result debug_noinline
Johannes Berg5cf121c2008-02-25 16:27:43 +01002131ieee80211_rx_h_data(struct ieee80211_rx_data *rx)
Ron Rindjunsky76ee65b2007-11-22 19:49:12 +02002132{
Johannes Bergeb9fb5b2009-11-16 13:58:20 +01002133 struct ieee80211_sub_if_data *sdata = rx->sdata;
Vivek Natarajane15276a2010-02-08 17:47:01 +05302134 struct ieee80211_local *local = rx->local;
Johannes Bergeb9fb5b2009-11-16 13:58:20 +01002135 struct net_device *dev = sdata->dev;
Harvey Harrison358c8d92008-07-15 18:44:13 -07002136 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
2137 __le16 fc = hdr->frame_control;
Felix Fietkau4114fa22011-04-12 19:15:22 +02002138 bool port_control;
Johannes Bergce3edf6d02007-12-19 01:31:22 +01002139 int err;
Ron Rindjunsky76ee65b2007-11-22 19:49:12 +02002140
Harvey Harrison358c8d92008-07-15 18:44:13 -07002141 if (unlikely(!ieee80211_is_data(hdr->frame_control)))
Johannes Berg9ae54c82008-01-31 19:48:20 +01002142 return RX_CONTINUE;
Ron Rindjunsky76ee65b2007-11-22 19:49:12 +02002143
Harvey Harrison358c8d92008-07-15 18:44:13 -07002144 if (unlikely(!ieee80211_is_data_present(hdr->frame_control)))
Johannes Berge4c26ad2008-01-31 19:48:21 +01002145 return RX_DROP_MONITOR;
Ron Rindjunsky76ee65b2007-11-22 19:49:12 +02002146
Felix Fietkauf14543ee2009-11-10 20:10:05 +01002147 /*
Johannes Berge7f4a942011-11-04 11:18:20 +01002148 * Send unexpected-4addr-frame event to hostapd. For older versions,
2149 * also drop the frame to cooked monitor interfaces.
Felix Fietkauf14543ee2009-11-10 20:10:05 +01002150 */
2151 if (ieee80211_has_a4(hdr->frame_control) &&
Johannes Berge7f4a942011-11-04 11:18:20 +01002152 sdata->vif.type == NL80211_IFTYPE_AP) {
2153 if (rx->sta &&
2154 !test_and_set_sta_flag(rx->sta, WLAN_STA_4ADDR_EVENT))
2155 cfg80211_rx_unexpected_4addr_frame(
2156 rx->sdata->dev, rx->sta->sta.addr, GFP_ATOMIC);
Felix Fietkauf14543ee2009-11-10 20:10:05 +01002157 return RX_DROP_MONITOR;
Johannes Berge7f4a942011-11-04 11:18:20 +01002158 }
Felix Fietkauf14543ee2009-11-10 20:10:05 +01002159
Felix Fietkau4114fa22011-04-12 19:15:22 +02002160 err = __ieee80211_data_to_8023(rx, &port_control);
Ron Rindjunsky76ee65b2007-11-22 19:49:12 +02002161 if (unlikely(err))
Johannes Berge4c26ad2008-01-31 19:48:21 +01002162 return RX_DROP_UNUSABLE;
Ron Rindjunsky76ee65b2007-11-22 19:49:12 +02002163
Harvey Harrison358c8d92008-07-15 18:44:13 -07002164 if (!ieee80211_frame_allowed(rx, fc))
Johannes Berge4c26ad2008-01-31 19:48:21 +01002165 return RX_DROP_MONITOR;
Johannes Bergce3edf6d02007-12-19 01:31:22 +01002166
Felix Fietkau4114fa22011-04-12 19:15:22 +02002167 if (rx->sdata->vif.type == NL80211_IFTYPE_AP_VLAN &&
2168 unlikely(port_control) && sdata->bss) {
2169 sdata = container_of(sdata->bss, struct ieee80211_sub_if_data,
2170 u.ap);
2171 dev = sdata->dev;
2172 rx->sdata = sdata;
2173 }
2174
Ron Rindjunsky76ee65b2007-11-22 19:49:12 +02002175 rx->skb->dev = dev;
2176
2177 dev->stats.rx_packets++;
2178 dev->stats.rx_bytes += rx->skb->len;
2179
Helmut Schaa08ca9442010-11-30 12:19:34 +01002180 if (local->ps_sdata && local->hw.conf.dynamic_ps_timeout > 0 &&
Rajkumar Manoharan8c99f692011-02-02 22:57:53 +05302181 !is_multicast_ether_addr(
2182 ((struct ethhdr *)rx->skb->data)->h_dest) &&
2183 (!local->scanning &&
2184 !test_bit(SDATA_STATE_OFFCHANNEL, &sdata->state))) {
Vivek Natarajane15276a2010-02-08 17:47:01 +05302185 mod_timer(&local->dynamic_ps_timer, jiffies +
2186 msecs_to_jiffies(local->hw.conf.dynamic_ps_timeout));
2187 }
2188
Ron Rindjunsky76ee65b2007-11-22 19:49:12 +02002189 ieee80211_deliver_skb(rx);
Johannes Berg571ecf62007-07-27 15:43:22 +02002190
Johannes Berg9ae54c82008-01-31 19:48:20 +01002191 return RX_QUEUED;
Johannes Berg571ecf62007-07-27 15:43:22 +02002192}
2193
Johannes Berg49461622008-06-30 15:10:45 +02002194static ieee80211_rx_result debug_noinline
Christian Lamparterf9e124f2013-02-04 17:44:44 +00002195ieee80211_rx_h_ctrl(struct ieee80211_rx_data *rx, struct sk_buff_head *frames)
Ron Rindjunsky71364712007-12-25 17:00:36 +02002196{
Ron Rindjunsky71364712007-12-25 17:00:36 +02002197 struct sk_buff *skb = rx->skb;
Harvey Harrisona7767f92008-07-02 16:30:51 -07002198 struct ieee80211_bar *bar = (struct ieee80211_bar *)skb->data;
Ron Rindjunsky71364712007-12-25 17:00:36 +02002199 struct tid_ampdu_rx *tid_agg_rx;
2200 u16 start_seq_num;
2201 u16 tid;
2202
Harvey Harrisona7767f92008-07-02 16:30:51 -07002203 if (likely(!ieee80211_is_ctl(bar->frame_control)))
Johannes Berg9ae54c82008-01-31 19:48:20 +01002204 return RX_CONTINUE;
Ron Rindjunsky71364712007-12-25 17:00:36 +02002205
Harvey Harrisona7767f92008-07-02 16:30:51 -07002206 if (ieee80211_is_back_req(bar->frame_control)) {
Johannes Berg8ae59772010-05-30 14:52:58 +02002207 struct {
2208 __le16 control, start_seq_num;
2209 } __packed bar_data;
2210
Ron Rindjunsky71364712007-12-25 17:00:36 +02002211 if (!rx->sta)
Johannes Berga02ae752009-11-16 12:00:40 +01002212 return RX_DROP_MONITOR;
Johannes Berg8ae59772010-05-30 14:52:58 +02002213
2214 if (skb_copy_bits(skb, offsetof(struct ieee80211_bar, control),
2215 &bar_data, sizeof(bar_data)))
2216 return RX_DROP_MONITOR;
2217
Johannes Berg8ae59772010-05-30 14:52:58 +02002218 tid = le16_to_cpu(bar_data.control) >> 12;
Johannes Berga87f7362010-06-10 10:21:38 +02002219
2220 tid_agg_rx = rcu_dereference(rx->sta->ampdu_mlme.tid_rx[tid]);
2221 if (!tid_agg_rx)
Johannes Berga02ae752009-11-16 12:00:40 +01002222 return RX_DROP_MONITOR;
Ron Rindjunsky71364712007-12-25 17:00:36 +02002223
Johannes Berg8ae59772010-05-30 14:52:58 +02002224 start_seq_num = le16_to_cpu(bar_data.start_seq_num) >> 4;
Ron Rindjunsky71364712007-12-25 17:00:36 +02002225
2226 /* reset session timer */
Johannes Berg20ad19d2009-02-10 21:25:45 +01002227 if (tid_agg_rx->timeout)
2228 mod_timer(&tid_agg_rx->session_timer,
2229 TU_TO_EXP_TIME(tid_agg_rx->timeout));
Ron Rindjunsky71364712007-12-25 17:00:36 +02002230
Johannes Bergdd318572010-11-29 11:09:16 +01002231 spin_lock(&tid_agg_rx->reorder_lock);
Johannes Berga02ae752009-11-16 12:00:40 +01002232 /* release stored frames up to start of BAR */
Johannes Bergd3b2fb52012-06-22 12:48:38 +02002233 ieee80211_release_reorder_frames(rx->sdata, tid_agg_rx,
Christian Lamparterf9e124f2013-02-04 17:44:44 +00002234 start_seq_num, frames);
Johannes Bergdd318572010-11-29 11:09:16 +01002235 spin_unlock(&tid_agg_rx->reorder_lock);
2236
Johannes Berga02ae752009-11-16 12:00:40 +01002237 kfree_skb(skb);
2238 return RX_QUEUED;
Ron Rindjunsky71364712007-12-25 17:00:36 +02002239 }
2240
Johannes Berg08daeca2010-05-30 14:53:43 +02002241 /*
2242 * After this point, we only want management frames,
2243 * so we can drop all remaining control frames to
2244 * cooked monitor interfaces.
2245 */
2246 return RX_DROP_MONITOR;
Ron Rindjunsky71364712007-12-25 17:00:36 +02002247}
2248
Jouni Malinenf4f727a2009-01-10 11:46:53 +02002249static void ieee80211_process_sa_query_req(struct ieee80211_sub_if_data *sdata,
2250 struct ieee80211_mgmt *mgmt,
2251 size_t len)
Jouni Malinenfea14732009-01-08 13:32:06 +02002252{
2253 struct ieee80211_local *local = sdata->local;
2254 struct sk_buff *skb;
2255 struct ieee80211_mgmt *resp;
2256
Joe Perchesb203ca32012-05-08 18:56:52 +00002257 if (!ether_addr_equal(mgmt->da, sdata->vif.addr)) {
Jouni Malinenfea14732009-01-08 13:32:06 +02002258 /* Not to own unicast address */
2259 return;
2260 }
2261
Joe Perchesb203ca32012-05-08 18:56:52 +00002262 if (!ether_addr_equal(mgmt->sa, sdata->u.mgd.bssid) ||
2263 !ether_addr_equal(mgmt->bssid, sdata->u.mgd.bssid)) {
Johannes Berg77fdaa12009-07-07 03:45:17 +02002264 /* Not from the current AP or not associated yet. */
Jouni Malinenfea14732009-01-08 13:32:06 +02002265 return;
2266 }
2267
2268 if (len < 24 + 1 + sizeof(resp->u.action.u.sa_query)) {
2269 /* Too short SA Query request frame */
2270 return;
2271 }
2272
2273 skb = dev_alloc_skb(sizeof(*resp) + local->hw.extra_tx_headroom);
2274 if (skb == NULL)
2275 return;
2276
2277 skb_reserve(skb, local->hw.extra_tx_headroom);
2278 resp = (struct ieee80211_mgmt *) skb_put(skb, 24);
2279 memset(resp, 0, 24);
2280 memcpy(resp->da, mgmt->sa, ETH_ALEN);
Johannes Berg47846c92009-11-25 17:46:19 +01002281 memcpy(resp->sa, sdata->vif.addr, ETH_ALEN);
Johannes Berg46900292009-02-15 12:44:28 +01002282 memcpy(resp->bssid, sdata->u.mgd.bssid, ETH_ALEN);
Jouni Malinenfea14732009-01-08 13:32:06 +02002283 resp->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
2284 IEEE80211_STYPE_ACTION);
2285 skb_put(skb, 1 + sizeof(resp->u.action.u.sa_query));
2286 resp->u.action.category = WLAN_CATEGORY_SA_QUERY;
2287 resp->u.action.u.sa_query.action = WLAN_ACTION_SA_QUERY_RESPONSE;
2288 memcpy(resp->u.action.u.sa_query.trans_id,
2289 mgmt->u.action.u.sa_query.trans_id,
2290 WLAN_SA_QUERY_TR_ID_LEN);
2291
Johannes Berg62ae67b2009-11-18 18:42:05 +01002292 ieee80211_tx_skb(sdata, skb);
Jouni Malinenfea14732009-01-08 13:32:06 +02002293}
2294
Johannes Berg49461622008-06-30 15:10:45 +02002295static ieee80211_rx_result debug_noinline
Johannes Berg2e161f72010-08-12 15:38:38 +02002296ieee80211_rx_h_mgmt_check(struct ieee80211_rx_data *rx)
2297{
2298 struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *) rx->skb->data;
Johannes Berg554891e2010-09-24 12:38:25 +02002299 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb);
Johannes Berg2e161f72010-08-12 15:38:38 +02002300
2301 /*
2302 * From here on, look only at management frames.
2303 * Data and control frames are already handled,
2304 * and unknown (reserved) frames are useless.
2305 */
2306 if (rx->skb->len < 24)
2307 return RX_DROP_MONITOR;
2308
2309 if (!ieee80211_is_mgmt(mgmt->frame_control))
2310 return RX_DROP_MONITOR;
2311
Johannes Bergee971922011-11-04 11:18:18 +01002312 if (rx->sdata->vif.type == NL80211_IFTYPE_AP &&
2313 ieee80211_is_beacon(mgmt->frame_control) &&
2314 !(rx->flags & IEEE80211_RX_BEACON_REPORTED)) {
Johannes Berg804483e2012-03-05 22:18:41 +01002315 int sig = 0;
2316
2317 if (rx->local->hw.flags & IEEE80211_HW_SIGNAL_DBM)
2318 sig = status->signal;
2319
Johannes Bergee971922011-11-04 11:18:18 +01002320 cfg80211_report_obss_beacon(rx->local->hw.wiphy,
2321 rx->skb->data, rx->skb->len,
Ben Greear37c73b52012-10-26 14:49:25 -07002322 status->freq, sig);
Johannes Bergee971922011-11-04 11:18:18 +01002323 rx->flags |= IEEE80211_RX_BEACON_REPORTED;
2324 }
2325
Johannes Berg554891e2010-09-24 12:38:25 +02002326 if (!(status->rx_flags & IEEE80211_RX_RA_MATCH))
Johannes Berg2e161f72010-08-12 15:38:38 +02002327 return RX_DROP_MONITOR;
2328
2329 if (ieee80211_drop_unencrypted_mgmt(rx))
2330 return RX_DROP_UNUSABLE;
2331
2332 return RX_CONTINUE;
2333}
2334
2335static ieee80211_rx_result debug_noinline
Johannes Bergde1ede72008-09-09 14:42:50 +02002336ieee80211_rx_h_action(struct ieee80211_rx_data *rx)
2337{
2338 struct ieee80211_local *local = rx->local;
Johannes Bergeb9fb5b2009-11-16 13:58:20 +01002339 struct ieee80211_sub_if_data *sdata = rx->sdata;
Johannes Bergde1ede72008-09-09 14:42:50 +02002340 struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *) rx->skb->data;
Johannes Berg554891e2010-09-24 12:38:25 +02002341 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb);
Johannes Bergde1ede72008-09-09 14:42:50 +02002342 int len = rx->skb->len;
2343
2344 if (!ieee80211_is_action(mgmt->frame_control))
2345 return RX_CONTINUE;
2346
Jouni Malinen026331c2010-02-15 12:53:10 +02002347 /* drop too small frames */
2348 if (len < IEEE80211_MIN_ACTION_SIZE)
2349 return RX_DROP_UNUSABLE;
2350
Marco Porsch815b8092012-12-05 15:04:26 -08002351 if (!rx->sta && mgmt->u.action.category != WLAN_CATEGORY_PUBLIC &&
2352 mgmt->u.action.category != WLAN_CATEGORY_SELF_PROTECTED)
Johannes Berg84040802010-02-15 12:46:39 +02002353 return RX_DROP_UNUSABLE;
Johannes Bergde1ede72008-09-09 14:42:50 +02002354
Johannes Berg554891e2010-09-24 12:38:25 +02002355 if (!(status->rx_flags & IEEE80211_RX_RA_MATCH))
Johannes Berg84040802010-02-15 12:46:39 +02002356 return RX_DROP_UNUSABLE;
Johannes Bergde1ede72008-09-09 14:42:50 +02002357
Johannes Bergde1ede72008-09-09 14:42:50 +02002358 switch (mgmt->u.action.category) {
Johannes Berg1d8d3de2011-12-16 15:28:57 +01002359 case WLAN_CATEGORY_HT:
2360 /* reject HT action frames from stations not supporting HT */
2361 if (!rx->sta->sta.ht_cap.ht_supported)
2362 goto invalid;
2363
2364 if (sdata->vif.type != NL80211_IFTYPE_STATION &&
2365 sdata->vif.type != NL80211_IFTYPE_MESH_POINT &&
2366 sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
2367 sdata->vif.type != NL80211_IFTYPE_AP &&
2368 sdata->vif.type != NL80211_IFTYPE_ADHOC)
2369 break;
2370
Johannes Bergec61cd62012-12-28 12:12:10 +01002371 /* verify action & smps_control/chanwidth are present */
Johannes Berg1d8d3de2011-12-16 15:28:57 +01002372 if (len < IEEE80211_MIN_ACTION_SIZE + 2)
2373 goto invalid;
2374
2375 switch (mgmt->u.action.u.ht_smps.action) {
2376 case WLAN_HT_ACTION_SMPS: {
2377 struct ieee80211_supported_band *sband;
Johannes Bergaf0ed692013-02-12 14:21:00 +01002378 enum ieee80211_smps_mode smps_mode;
Johannes Berg1d8d3de2011-12-16 15:28:57 +01002379
2380 /* convert to HT capability */
2381 switch (mgmt->u.action.u.ht_smps.smps_control) {
2382 case WLAN_HT_SMPS_CONTROL_DISABLED:
Johannes Bergaf0ed692013-02-12 14:21:00 +01002383 smps_mode = IEEE80211_SMPS_OFF;
Johannes Berg1d8d3de2011-12-16 15:28:57 +01002384 break;
2385 case WLAN_HT_SMPS_CONTROL_STATIC:
Johannes Bergaf0ed692013-02-12 14:21:00 +01002386 smps_mode = IEEE80211_SMPS_STATIC;
Johannes Berg1d8d3de2011-12-16 15:28:57 +01002387 break;
2388 case WLAN_HT_SMPS_CONTROL_DYNAMIC:
Johannes Bergaf0ed692013-02-12 14:21:00 +01002389 smps_mode = IEEE80211_SMPS_DYNAMIC;
Johannes Berg1d8d3de2011-12-16 15:28:57 +01002390 break;
2391 default:
2392 goto invalid;
2393 }
Johannes Berg1d8d3de2011-12-16 15:28:57 +01002394
2395 /* if no change do nothing */
Johannes Bergaf0ed692013-02-12 14:21:00 +01002396 if (rx->sta->sta.smps_mode == smps_mode)
Johannes Berg1d8d3de2011-12-16 15:28:57 +01002397 goto handled;
Johannes Bergaf0ed692013-02-12 14:21:00 +01002398 rx->sta->sta.smps_mode = smps_mode;
Johannes Berg1d8d3de2011-12-16 15:28:57 +01002399
2400 sband = rx->local->hw.wiphy->bands[status->band];
2401
Johannes Berg64f68e52012-03-28 10:58:37 +02002402 rate_control_rate_update(local, sband, rx->sta,
2403 IEEE80211_RC_SMPS_CHANGED);
Johannes Berg1d8d3de2011-12-16 15:28:57 +01002404 goto handled;
2405 }
Johannes Bergec61cd62012-12-28 12:12:10 +01002406 case WLAN_HT_ACTION_NOTIFY_CHANWIDTH: {
2407 struct ieee80211_supported_band *sband;
2408 u8 chanwidth = mgmt->u.action.u.ht_notify_cw.chanwidth;
Johannes Berge1a0c6b2013-02-07 11:47:44 +01002409 enum ieee80211_sta_rx_bandwidth new_bw;
Johannes Bergec61cd62012-12-28 12:12:10 +01002410
2411 /* If it doesn't support 40 MHz it can't change ... */
Johannes Berge1a0c6b2013-02-07 11:47:44 +01002412 if (!(rx->sta->sta.ht_cap.cap &
2413 IEEE80211_HT_CAP_SUP_WIDTH_20_40))
Johannes Bergec61cd62012-12-28 12:12:10 +01002414 goto handled;
2415
Johannes Berge1a0c6b2013-02-07 11:47:44 +01002416 if (chanwidth == IEEE80211_HT_CHANWIDTH_20MHZ)
2417 new_bw = IEEE80211_STA_RX_BW_20;
Johannes Bergec61cd62012-12-28 12:12:10 +01002418 else
Johannes Berge1a0c6b2013-02-07 11:47:44 +01002419 new_bw = ieee80211_sta_cur_vht_bw(rx->sta);
2420
2421 if (rx->sta->sta.bandwidth == new_bw)
2422 goto handled;
Johannes Bergec61cd62012-12-28 12:12:10 +01002423
2424 sband = rx->local->hw.wiphy->bands[status->band];
2425
2426 rate_control_rate_update(local, sband, rx->sta,
2427 IEEE80211_RC_BW_CHANGED);
2428 goto handled;
2429 }
Johannes Berg1d8d3de2011-12-16 15:28:57 +01002430 default:
2431 goto invalid;
2432 }
2433
2434 break;
Johannes Berg0af83d32012-12-27 18:55:36 +01002435 case WLAN_CATEGORY_VHT:
2436 if (sdata->vif.type != NL80211_IFTYPE_STATION &&
2437 sdata->vif.type != NL80211_IFTYPE_MESH_POINT &&
2438 sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
2439 sdata->vif.type != NL80211_IFTYPE_AP &&
2440 sdata->vif.type != NL80211_IFTYPE_ADHOC)
2441 break;
2442
2443 /* verify action code is present */
2444 if (len < IEEE80211_MIN_ACTION_SIZE + 1)
2445 goto invalid;
2446
2447 switch (mgmt->u.action.u.vht_opmode_notif.action_code) {
2448 case WLAN_VHT_ACTION_OPMODE_NOTIF: {
2449 u8 opmode;
2450
2451 /* verify opmode is present */
2452 if (len < IEEE80211_MIN_ACTION_SIZE + 2)
2453 goto invalid;
2454
2455 opmode = mgmt->u.action.u.vht_opmode_notif.operating_mode;
2456
2457 ieee80211_vht_handle_opmode(rx->sdata, rx->sta,
Johannes Bergbee7f582013-02-07 22:24:55 +01002458 opmode, status->band,
2459 false);
Johannes Berg0af83d32012-12-27 18:55:36 +01002460 goto handled;
2461 }
2462 default:
2463 break;
2464 }
2465 break;
Johannes Bergde1ede72008-09-09 14:42:50 +02002466 case WLAN_CATEGORY_BACK:
Johannes Berg8abd3f92009-02-10 21:25:47 +01002467 if (sdata->vif.type != NL80211_IFTYPE_STATION &&
Thomas Pedersenae2772b2011-10-26 14:47:29 -07002468 sdata->vif.type != NL80211_IFTYPE_MESH_POINT &&
Johannes Berg8abd3f92009-02-10 21:25:47 +01002469 sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
Alexander Simon13c40c52011-11-30 16:56:34 +01002470 sdata->vif.type != NL80211_IFTYPE_AP &&
2471 sdata->vif.type != NL80211_IFTYPE_ADHOC)
Johannes Berg84040802010-02-15 12:46:39 +02002472 break;
Johannes Berg8abd3f92009-02-10 21:25:47 +01002473
Jouni Malinen026331c2010-02-15 12:53:10 +02002474 /* verify action_code is present */
2475 if (len < IEEE80211_MIN_ACTION_SIZE + 1)
2476 break;
2477
Johannes Bergde1ede72008-09-09 14:42:50 +02002478 switch (mgmt->u.action.u.addba_req.action_code) {
2479 case WLAN_ACTION_ADDBA_REQ:
2480 if (len < (IEEE80211_MIN_ACTION_SIZE +
2481 sizeof(mgmt->u.action.u.addba_req)))
Johannes Bergbed7ee6e2010-06-10 10:21:35 +02002482 goto invalid;
2483 break;
Johannes Bergde1ede72008-09-09 14:42:50 +02002484 case WLAN_ACTION_ADDBA_RESP:
2485 if (len < (IEEE80211_MIN_ACTION_SIZE +
2486 sizeof(mgmt->u.action.u.addba_resp)))
Johannes Bergbed7ee6e2010-06-10 10:21:35 +02002487 goto invalid;
2488 break;
Johannes Bergde1ede72008-09-09 14:42:50 +02002489 case WLAN_ACTION_DELBA:
2490 if (len < (IEEE80211_MIN_ACTION_SIZE +
2491 sizeof(mgmt->u.action.u.delba)))
Johannes Bergbed7ee6e2010-06-10 10:21:35 +02002492 goto invalid;
2493 break;
2494 default:
2495 goto invalid;
Johannes Bergde1ede72008-09-09 14:42:50 +02002496 }
Johannes Bergbed7ee6e2010-06-10 10:21:35 +02002497
Johannes Berg8b58ff82010-06-10 10:21:51 +02002498 goto queue;
Johannes Berg39192c02008-09-09 14:49:03 +02002499 case WLAN_CATEGORY_SPECTRUM_MGMT:
Johannes Berg4797c7b2012-07-26 14:31:19 +02002500 if (status->band != IEEE80211_BAND_5GHZ)
Johannes Berg84040802010-02-15 12:46:39 +02002501 break;
Johannes Berg46900292009-02-15 12:44:28 +01002502
2503 if (sdata->vif.type != NL80211_IFTYPE_STATION)
Johannes Berg84040802010-02-15 12:46:39 +02002504 break;
Johannes Berg46900292009-02-15 12:44:28 +01002505
Jouni Malinen026331c2010-02-15 12:53:10 +02002506 /* verify action_code is present */
2507 if (len < IEEE80211_MIN_ACTION_SIZE + 1)
2508 break;
2509
Johannes Berg39192c02008-09-09 14:49:03 +02002510 switch (mgmt->u.action.u.measurement.action_code) {
2511 case WLAN_ACTION_SPCT_MSR_REQ:
2512 if (len < (IEEE80211_MIN_ACTION_SIZE +
2513 sizeof(mgmt->u.action.u.measurement)))
Johannes Berg84040802010-02-15 12:46:39 +02002514 break;
Johannes Berg39192c02008-09-09 14:49:03 +02002515 ieee80211_process_measurement_req(sdata, mgmt, len);
Johannes Berg84040802010-02-15 12:46:39 +02002516 goto handled;
Sujithc481ec92009-01-06 09:28:37 +05302517 case WLAN_ACTION_SPCT_CHL_SWITCH:
2518 if (len < (IEEE80211_MIN_ACTION_SIZE +
2519 sizeof(mgmt->u.action.u.chan_switch)))
Johannes Berg84040802010-02-15 12:46:39 +02002520 break;
Sujithc481ec92009-01-06 09:28:37 +05302521
Johannes Bergcc32abd2009-05-15 11:52:31 +02002522 if (sdata->vif.type != NL80211_IFTYPE_STATION)
Johannes Berg84040802010-02-15 12:46:39 +02002523 break;
Johannes Bergcc32abd2009-05-15 11:52:31 +02002524
Joe Perchesb203ca32012-05-08 18:56:52 +00002525 if (!ether_addr_equal(mgmt->bssid, sdata->u.mgd.bssid))
Johannes Berg84040802010-02-15 12:46:39 +02002526 break;
Sujithc481ec92009-01-06 09:28:37 +05302527
Johannes Berg8b58ff82010-06-10 10:21:51 +02002528 goto queue;
Johannes Berg39192c02008-09-09 14:49:03 +02002529 }
2530 break;
Jouni Malinenfea14732009-01-08 13:32:06 +02002531 case WLAN_CATEGORY_SA_QUERY:
2532 if (len < (IEEE80211_MIN_ACTION_SIZE +
2533 sizeof(mgmt->u.action.u.sa_query)))
Johannes Berg84040802010-02-15 12:46:39 +02002534 break;
2535
Jouni Malinenfea14732009-01-08 13:32:06 +02002536 switch (mgmt->u.action.u.sa_query.action) {
2537 case WLAN_ACTION_SA_QUERY_REQUEST:
2538 if (sdata->vif.type != NL80211_IFTYPE_STATION)
Johannes Berg84040802010-02-15 12:46:39 +02002539 break;
Jouni Malinenfea14732009-01-08 13:32:06 +02002540 ieee80211_process_sa_query_req(sdata, mgmt, len);
Johannes Berg84040802010-02-15 12:46:39 +02002541 goto handled;
Jouni Malinenfea14732009-01-08 13:32:06 +02002542 }
2543 break;
Thomas Pedersen8db09852011-08-12 20:01:00 -07002544 case WLAN_CATEGORY_SELF_PROTECTED:
Johannes Berg9b395bc2012-10-26 00:36:40 +02002545 if (len < (IEEE80211_MIN_ACTION_SIZE +
2546 sizeof(mgmt->u.action.u.self_prot.action_code)))
2547 break;
2548
Thomas Pedersen8db09852011-08-12 20:01:00 -07002549 switch (mgmt->u.action.u.self_prot.action_code) {
2550 case WLAN_SP_MESH_PEERING_OPEN:
2551 case WLAN_SP_MESH_PEERING_CLOSE:
2552 case WLAN_SP_MESH_PEERING_CONFIRM:
2553 if (!ieee80211_vif_is_mesh(&sdata->vif))
2554 goto invalid;
2555 if (sdata->u.mesh.security != IEEE80211_MESH_SEC_NONE)
2556 /* userspace handles this frame */
2557 break;
2558 goto queue;
2559 case WLAN_SP_MGK_INFORM:
2560 case WLAN_SP_MGK_ACK:
2561 if (!ieee80211_vif_is_mesh(&sdata->vif))
2562 goto invalid;
2563 break;
2564 }
2565 break;
Javier Cardonad3aaec8a2011-05-03 16:57:09 -07002566 case WLAN_CATEGORY_MESH_ACTION:
Johannes Berg9b395bc2012-10-26 00:36:40 +02002567 if (len < (IEEE80211_MIN_ACTION_SIZE +
2568 sizeof(mgmt->u.action.u.mesh_action.action_code)))
2569 break;
2570
Johannes Berg77a121c2010-06-10 10:21:34 +02002571 if (!ieee80211_vif_is_mesh(&sdata->vif))
2572 break;
Thomas Pedersen25d49e42011-08-11 19:35:15 -07002573 if (mesh_action_is_path_sel(mgmt) &&
Johannes Berg1df332e2012-10-26 00:09:11 +02002574 !mesh_path_sel_is_hwmp(sdata))
Javier Cardonac7108a72010-12-16 17:37:50 -08002575 break;
2576 goto queue;
Johannes Berg84040802010-02-15 12:46:39 +02002577 }
Jouni Malinen026331c2010-02-15 12:53:10 +02002578
Johannes Berg2e161f72010-08-12 15:38:38 +02002579 return RX_CONTINUE;
2580
Johannes Bergbed7ee6e2010-06-10 10:21:35 +02002581 invalid:
Johannes Berg554891e2010-09-24 12:38:25 +02002582 status->rx_flags |= IEEE80211_RX_MALFORMED_ACTION_FRM;
Johannes Berg2e161f72010-08-12 15:38:38 +02002583 /* will return in the next handlers */
2584 return RX_CONTINUE;
2585
2586 handled:
2587 if (rx->sta)
2588 rx->sta->rx_packets++;
2589 dev_kfree_skb(rx->skb);
2590 return RX_QUEUED;
2591
2592 queue:
2593 rx->skb->pkt_type = IEEE80211_SDATA_QUEUE_TYPE_FRAME;
2594 skb_queue_tail(&sdata->skb_queue, rx->skb);
2595 ieee80211_queue_work(&local->hw, &sdata->work);
2596 if (rx->sta)
2597 rx->sta->rx_packets++;
2598 return RX_QUEUED;
2599}
2600
2601static ieee80211_rx_result debug_noinline
2602ieee80211_rx_h_userspace_mgmt(struct ieee80211_rx_data *rx)
2603{
Johannes Berg554891e2010-09-24 12:38:25 +02002604 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb);
Johannes Berg804483e2012-03-05 22:18:41 +01002605 int sig = 0;
Johannes Berg2e161f72010-08-12 15:38:38 +02002606
2607 /* skip known-bad action frames and return them in the next handler */
Johannes Berg554891e2010-09-24 12:38:25 +02002608 if (status->rx_flags & IEEE80211_RX_MALFORMED_ACTION_FRM)
Johannes Berg2e161f72010-08-12 15:38:38 +02002609 return RX_CONTINUE;
Felix Fietkaud7907442010-01-07 20:23:53 +01002610
Jouni Malinen026331c2010-02-15 12:53:10 +02002611 /*
2612 * Getting here means the kernel doesn't know how to handle
2613 * it, but maybe userspace does ... include returned frames
2614 * so userspace can register for those to know whether ones
2615 * it transmitted were processed or returned.
2616 */
Jouni Malinen026331c2010-02-15 12:53:10 +02002617
Johannes Berg804483e2012-03-05 22:18:41 +01002618 if (rx->local->hw.flags & IEEE80211_HW_SIGNAL_DBM)
2619 sig = status->signal;
2620
Johannes Berg71bbc992012-06-15 15:30:18 +02002621 if (cfg80211_rx_mgmt(&rx->sdata->wdev, status->freq, sig,
Johannes Berg2e161f72010-08-12 15:38:38 +02002622 rx->skb->data, rx->skb->len,
2623 GFP_ATOMIC)) {
2624 if (rx->sta)
2625 rx->sta->rx_packets++;
2626 dev_kfree_skb(rx->skb);
2627 return RX_QUEUED;
2628 }
2629
Johannes Berg2e161f72010-08-12 15:38:38 +02002630 return RX_CONTINUE;
2631}
2632
2633static ieee80211_rx_result debug_noinline
2634ieee80211_rx_h_action_return(struct ieee80211_rx_data *rx)
2635{
2636 struct ieee80211_local *local = rx->local;
2637 struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *) rx->skb->data;
2638 struct sk_buff *nskb;
2639 struct ieee80211_sub_if_data *sdata = rx->sdata;
Johannes Berg554891e2010-09-24 12:38:25 +02002640 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb);
Johannes Berg2e161f72010-08-12 15:38:38 +02002641
2642 if (!ieee80211_is_action(mgmt->frame_control))
2643 return RX_CONTINUE;
2644
2645 /*
2646 * For AP mode, hostapd is responsible for handling any action
2647 * frames that we didn't handle, including returning unknown
2648 * ones. For all other modes we will return them to the sender,
2649 * setting the 0x80 bit in the action category, as required by
Johannes Berg4b5ebcc2012-06-27 15:38:56 +02002650 * 802.11-2012 9.24.4.
Johannes Berg2e161f72010-08-12 15:38:38 +02002651 * Newer versions of hostapd shall also use the management frame
2652 * registration mechanisms, but older ones still use cooked
2653 * monitor interfaces so push all frames there.
2654 */
Johannes Berg554891e2010-09-24 12:38:25 +02002655 if (!(status->rx_flags & IEEE80211_RX_MALFORMED_ACTION_FRM) &&
Johannes Berg2e161f72010-08-12 15:38:38 +02002656 (sdata->vif.type == NL80211_IFTYPE_AP ||
2657 sdata->vif.type == NL80211_IFTYPE_AP_VLAN))
2658 return RX_DROP_MONITOR;
Jouni Malinen026331c2010-02-15 12:53:10 +02002659
Johannes Berg4b5ebcc2012-06-27 15:38:56 +02002660 if (is_multicast_ether_addr(mgmt->da))
2661 return RX_DROP_MONITOR;
2662
Johannes Berg84040802010-02-15 12:46:39 +02002663 /* do not return rejected action frames */
2664 if (mgmt->u.action.category & 0x80)
2665 return RX_DROP_UNUSABLE;
2666
2667 nskb = skb_copy_expand(rx->skb, local->hw.extra_tx_headroom, 0,
2668 GFP_ATOMIC);
2669 if (nskb) {
John W. Linville292b4df2010-06-24 11:13:56 -04002670 struct ieee80211_mgmt *nmgmt = (void *)nskb->data;
Johannes Berg84040802010-02-15 12:46:39 +02002671
John W. Linville292b4df2010-06-24 11:13:56 -04002672 nmgmt->u.action.category |= 0x80;
2673 memcpy(nmgmt->da, nmgmt->sa, ETH_ALEN);
2674 memcpy(nmgmt->sa, rx->sdata->vif.addr, ETH_ALEN);
Johannes Berg84040802010-02-15 12:46:39 +02002675
2676 memset(nskb->cb, 0, sizeof(nskb->cb));
2677
2678 ieee80211_tx_skb(rx->sdata, nskb);
Johannes Bergde1ede72008-09-09 14:42:50 +02002679 }
Johannes Berg39192c02008-09-09 14:49:03 +02002680 dev_kfree_skb(rx->skb);
2681 return RX_QUEUED;
Johannes Bergde1ede72008-09-09 14:42:50 +02002682}
2683
2684static ieee80211_rx_result debug_noinline
Johannes Berg5cf121c2008-02-25 16:27:43 +01002685ieee80211_rx_h_mgmt(struct ieee80211_rx_data *rx)
Johannes Berg571ecf62007-07-27 15:43:22 +02002686{
Johannes Bergeb9fb5b2009-11-16 13:58:20 +01002687 struct ieee80211_sub_if_data *sdata = rx->sdata;
Johannes Berg77a121c2010-06-10 10:21:34 +02002688 struct ieee80211_mgmt *mgmt = (void *)rx->skb->data;
2689 __le16 stype;
Johannes Berg571ecf62007-07-27 15:43:22 +02002690
Johannes Berg77a121c2010-06-10 10:21:34 +02002691 stype = mgmt->frame_control & cpu_to_le16(IEEE80211_FCTL_STYPE);
Johannes Berg472dbc42008-09-11 00:01:49 +02002692
Johannes Berg77a121c2010-06-10 10:21:34 +02002693 if (!ieee80211_vif_is_mesh(&sdata->vif) &&
2694 sdata->vif.type != NL80211_IFTYPE_ADHOC &&
2695 sdata->vif.type != NL80211_IFTYPE_STATION)
2696 return RX_DROP_MONITOR;
Johannes Bergf9d540e2007-09-28 14:02:09 +02002697
Johannes Berg77a121c2010-06-10 10:21:34 +02002698 switch (stype) {
Johannes Berg66e67e42012-01-20 13:55:27 +01002699 case cpu_to_le16(IEEE80211_STYPE_AUTH):
Johannes Berg77a121c2010-06-10 10:21:34 +02002700 case cpu_to_le16(IEEE80211_STYPE_BEACON):
2701 case cpu_to_le16(IEEE80211_STYPE_PROBE_RESP):
2702 /* process for all: mesh, mlme, ibss */
2703 break;
Johannes Berg66e67e42012-01-20 13:55:27 +01002704 case cpu_to_le16(IEEE80211_STYPE_ASSOC_RESP):
2705 case cpu_to_le16(IEEE80211_STYPE_REASSOC_RESP):
Johannes Berg77a121c2010-06-10 10:21:34 +02002706 case cpu_to_le16(IEEE80211_STYPE_DEAUTH):
2707 case cpu_to_le16(IEEE80211_STYPE_DISASSOC):
Christian Lamparter2c313332010-11-29 20:53:23 +01002708 if (is_multicast_ether_addr(mgmt->da) &&
2709 !is_broadcast_ether_addr(mgmt->da))
2710 return RX_DROP_MONITOR;
2711
Johannes Berg77a121c2010-06-10 10:21:34 +02002712 /* process only for station */
2713 if (sdata->vif.type != NL80211_IFTYPE_STATION)
2714 return RX_DROP_MONITOR;
2715 break;
2716 case cpu_to_le16(IEEE80211_STYPE_PROBE_REQ):
Thomas Pedersen9fb04b52013-02-14 11:20:14 -08002717 /* process only for ibss and mesh */
2718 if (sdata->vif.type != NL80211_IFTYPE_ADHOC &&
2719 sdata->vif.type != NL80211_IFTYPE_MESH_POINT)
Johannes Berg77a121c2010-06-10 10:21:34 +02002720 return RX_DROP_MONITOR;
2721 break;
2722 default:
2723 return RX_DROP_MONITOR;
2724 }
Johannes Berg46900292009-02-15 12:44:28 +01002725
Johannes Berg77a121c2010-06-10 10:21:34 +02002726 /* queue up frame and kick off work to process it */
Johannes Bergc1475ca2010-06-10 10:21:37 +02002727 rx->skb->pkt_type = IEEE80211_SDATA_QUEUE_TYPE_FRAME;
Johannes Berg77a121c2010-06-10 10:21:34 +02002728 skb_queue_tail(&sdata->skb_queue, rx->skb);
2729 ieee80211_queue_work(&rx->local->hw, &sdata->work);
Johannes Berg8b58ff82010-06-10 10:21:51 +02002730 if (rx->sta)
2731 rx->sta->rx_packets++;
Johannes Berg77a121c2010-06-10 10:21:34 +02002732
2733 return RX_QUEUED;
Johannes Berg571ecf62007-07-27 15:43:22 +02002734}
2735
Johannes Berg5cf121c2008-02-25 16:27:43 +01002736/* TODO: use IEEE80211_RX_FRAGMENTED */
Johannes Berg5f0b7de2009-11-16 13:58:21 +01002737static void ieee80211_rx_cooked_monitor(struct ieee80211_rx_data *rx,
2738 struct ieee80211_rate *rate)
Michael Wu3d30d942008-01-31 19:48:27 +01002739{
2740 struct ieee80211_sub_if_data *sdata;
2741 struct ieee80211_local *local = rx->local;
Michael Wu3d30d942008-01-31 19:48:27 +01002742 struct sk_buff *skb = rx->skb, *skb2;
2743 struct net_device *prev_dev = NULL;
Johannes Bergeb9fb5b2009-11-16 13:58:20 +01002744 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
Johannes Berg293702a2012-03-02 13:18:19 +01002745 int needed_headroom;
Michael Wu3d30d942008-01-31 19:48:27 +01002746
Johannes Berg554891e2010-09-24 12:38:25 +02002747 /*
2748 * If cooked monitor has been processed already, then
2749 * don't do it again. If not, set the flag.
2750 */
2751 if (rx->flags & IEEE80211_RX_CMNTR)
John W. Linville7c1e1832010-09-24 15:52:49 -04002752 goto out_free_skb;
Johannes Berg554891e2010-09-24 12:38:25 +02002753 rx->flags |= IEEE80211_RX_CMNTR;
John W. Linville7c1e1832010-09-24 15:52:49 -04002754
Johannes Berg152c4772011-10-21 10:22:22 +02002755 /* If there are no cooked monitor interfaces, just free the SKB */
2756 if (!local->cooked_mntrs)
2757 goto out_free_skb;
2758
Johannes Berg293702a2012-03-02 13:18:19 +01002759 /* room for the radiotap header based on driver features */
Johannes Berg90b9e4462012-11-16 10:09:08 +01002760 needed_headroom = ieee80211_rx_radiotap_space(local, status);
Johannes Berg293702a2012-03-02 13:18:19 +01002761
2762 if (skb_headroom(skb) < needed_headroom &&
2763 pskb_expand_head(skb, needed_headroom, 0, GFP_ATOMIC))
Michael Wu3d30d942008-01-31 19:48:27 +01002764 goto out_free_skb;
2765
Johannes Berg293702a2012-03-02 13:18:19 +01002766 /* prepend radiotap information */
Felix Fietkau973ef212012-04-16 14:56:48 +02002767 ieee80211_add_rx_radiotap_header(local, skb, rate, needed_headroom,
2768 false);
Michael Wu3d30d942008-01-31 19:48:27 +01002769
2770 skb_set_mac_header(skb, 0);
2771 skb->ip_summed = CHECKSUM_UNNECESSARY;
2772 skb->pkt_type = PACKET_OTHERHOST;
2773 skb->protocol = htons(ETH_P_802_2);
2774
2775 list_for_each_entry_rcu(sdata, &local->interfaces, list) {
Johannes Berg9607e6b2009-12-23 13:15:31 +01002776 if (!ieee80211_sdata_running(sdata))
Michael Wu3d30d942008-01-31 19:48:27 +01002777 continue;
2778
Johannes Berg05c914f2008-09-11 00:01:58 +02002779 if (sdata->vif.type != NL80211_IFTYPE_MONITOR ||
Michael Wu3d30d942008-01-31 19:48:27 +01002780 !(sdata->u.mntr_flags & MONITOR_FLAG_COOK_FRAMES))
2781 continue;
2782
2783 if (prev_dev) {
2784 skb2 = skb_clone(skb, GFP_ATOMIC);
2785 if (skb2) {
2786 skb2->dev = prev_dev;
John W. Linville5548a8a2010-06-24 14:25:56 -04002787 netif_receive_skb(skb2);
Michael Wu3d30d942008-01-31 19:48:27 +01002788 }
2789 }
2790
2791 prev_dev = sdata->dev;
2792 sdata->dev->stats.rx_packets++;
2793 sdata->dev->stats.rx_bytes += skb->len;
2794 }
2795
2796 if (prev_dev) {
2797 skb->dev = prev_dev;
John W. Linville5548a8a2010-06-24 14:25:56 -04002798 netif_receive_skb(skb);
Johannes Berg554891e2010-09-24 12:38:25 +02002799 return;
2800 }
Michael Wu3d30d942008-01-31 19:48:27 +01002801
2802 out_free_skb:
2803 dev_kfree_skb(skb);
2804}
2805
Christian Lamparteraa0c8632010-08-05 01:36:04 +02002806static void ieee80211_rx_handlers_result(struct ieee80211_rx_data *rx,
2807 ieee80211_rx_result res)
2808{
2809 switch (res) {
2810 case RX_DROP_MONITOR:
2811 I802_DEBUG_INC(rx->sdata->local->rx_handlers_drop);
2812 if (rx->sta)
2813 rx->sta->rx_dropped++;
2814 /* fall through */
2815 case RX_CONTINUE: {
2816 struct ieee80211_rate *rate = NULL;
2817 struct ieee80211_supported_band *sband;
2818 struct ieee80211_rx_status *status;
2819
2820 status = IEEE80211_SKB_RXCB((rx->skb));
2821
2822 sband = rx->local->hw.wiphy->bands[status->band];
Johannes Berg56146182012-11-09 15:07:02 +01002823 if (!(status->flag & RX_FLAG_HT) &&
2824 !(status->flag & RX_FLAG_VHT))
Christian Lamparteraa0c8632010-08-05 01:36:04 +02002825 rate = &sband->bitrates[status->rate_idx];
2826
2827 ieee80211_rx_cooked_monitor(rx, rate);
2828 break;
2829 }
2830 case RX_DROP_UNUSABLE:
2831 I802_DEBUG_INC(rx->sdata->local->rx_handlers_drop);
2832 if (rx->sta)
2833 rx->sta->rx_dropped++;
2834 dev_kfree_skb(rx->skb);
2835 break;
2836 case RX_QUEUED:
2837 I802_DEBUG_INC(rx->sdata->local->rx_handlers_queued);
2838 break;
2839 }
2840}
2841
Christian Lamparterf9e124f2013-02-04 17:44:44 +00002842static void ieee80211_rx_handlers(struct ieee80211_rx_data *rx,
2843 struct sk_buff_head *frames)
Christian Lamparteraa0c8632010-08-05 01:36:04 +02002844{
2845 ieee80211_rx_result res = RX_DROP_MONITOR;
2846 struct sk_buff *skb;
2847
2848#define CALL_RXH(rxh) \
2849 do { \
2850 res = rxh(rx); \
2851 if (res != RX_CONTINUE) \
2852 goto rxh_next; \
2853 } while (0);
2854
Christian Lamparterf9e124f2013-02-04 17:44:44 +00002855 spin_lock_bh(&rx->local->rx_path_lock);
Christian Lamparter24a8fda2010-12-30 17:25:29 +01002856
Christian Lamparterf9e124f2013-02-04 17:44:44 +00002857 while ((skb = __skb_dequeue(frames))) {
Christian Lamparteraa0c8632010-08-05 01:36:04 +02002858 /*
2859 * all the other fields are valid across frames
2860 * that belong to an aMPDU since they are on the
2861 * same TID from the same station
2862 */
2863 rx->skb = skb;
2864
2865 CALL_RXH(ieee80211_rx_h_decrypt)
2866 CALL_RXH(ieee80211_rx_h_check_more_data)
Johannes Berg47086fc2011-09-29 16:04:33 +02002867 CALL_RXH(ieee80211_rx_h_uapsd_and_pspoll)
Christian Lamparteraa0c8632010-08-05 01:36:04 +02002868 CALL_RXH(ieee80211_rx_h_sta_process)
2869 CALL_RXH(ieee80211_rx_h_defragment)
Christian Lamparteraa0c8632010-08-05 01:36:04 +02002870 CALL_RXH(ieee80211_rx_h_michael_mic_verify)
2871 /* must be after MMIC verify so header is counted in MPDU mic */
Christian Lamparteraa0c8632010-08-05 01:36:04 +02002872#ifdef CONFIG_MAC80211_MESH
2873 if (ieee80211_vif_is_mesh(&rx->sdata->vif))
2874 CALL_RXH(ieee80211_rx_h_mesh_fwding);
2875#endif
Javier Cardona2154c812011-09-07 17:49:53 -07002876 CALL_RXH(ieee80211_rx_h_amsdu)
Christian Lamparteraa0c8632010-08-05 01:36:04 +02002877 CALL_RXH(ieee80211_rx_h_data)
Christian Lamparterf9e124f2013-02-04 17:44:44 +00002878
2879 /* special treatment -- needs the queue */
2880 res = ieee80211_rx_h_ctrl(rx, frames);
2881 if (res != RX_CONTINUE)
2882 goto rxh_next;
2883
Johannes Berg2e161f72010-08-12 15:38:38 +02002884 CALL_RXH(ieee80211_rx_h_mgmt_check)
Christian Lamparteraa0c8632010-08-05 01:36:04 +02002885 CALL_RXH(ieee80211_rx_h_action)
Johannes Berg2e161f72010-08-12 15:38:38 +02002886 CALL_RXH(ieee80211_rx_h_userspace_mgmt)
2887 CALL_RXH(ieee80211_rx_h_action_return)
Christian Lamparteraa0c8632010-08-05 01:36:04 +02002888 CALL_RXH(ieee80211_rx_h_mgmt)
2889
2890 rxh_next:
2891 ieee80211_rx_handlers_result(rx, res);
Christian Lamparterf9e124f2013-02-04 17:44:44 +00002892
Christian Lamparteraa0c8632010-08-05 01:36:04 +02002893#undef CALL_RXH
2894 }
Christian Lamparter24a8fda2010-12-30 17:25:29 +01002895
Christian Lamparterf9e124f2013-02-04 17:44:44 +00002896 spin_unlock_bh(&rx->local->rx_path_lock);
Christian Lamparteraa0c8632010-08-05 01:36:04 +02002897}
Johannes Berg571ecf62007-07-27 15:43:22 +02002898
Johannes Berg4406c372010-09-24 11:21:06 +02002899static void ieee80211_invoke_rx_handlers(struct ieee80211_rx_data *rx)
Johannes Berg58905292008-01-31 19:48:25 +01002900{
Christian Lamparterf9e124f2013-02-04 17:44:44 +00002901 struct sk_buff_head reorder_release;
Johannes Berg58905292008-01-31 19:48:25 +01002902 ieee80211_rx_result res = RX_DROP_MONITOR;
2903
Christian Lamparterf9e124f2013-02-04 17:44:44 +00002904 __skb_queue_head_init(&reorder_release);
2905
Luis Carlos Coboe32f85f2008-08-05 19:34:52 +02002906#define CALL_RXH(rxh) \
2907 do { \
2908 res = rxh(rx); \
2909 if (res != RX_CONTINUE) \
Johannes Berg2569a822009-11-25 17:46:17 +01002910 goto rxh_next; \
Luis Carlos Coboe32f85f2008-08-05 19:34:52 +02002911 } while (0);
Johannes Berg58905292008-01-31 19:48:25 +01002912
Johannes Berg49461622008-06-30 15:10:45 +02002913 CALL_RXH(ieee80211_rx_h_check)
Johannes Berg2569a822009-11-25 17:46:17 +01002914
Christian Lamparterf9e124f2013-02-04 17:44:44 +00002915 ieee80211_rx_reorder_ampdu(rx, &reorder_release);
Johannes Berg2569a822009-11-25 17:46:17 +01002916
Christian Lamparterf9e124f2013-02-04 17:44:44 +00002917 ieee80211_rx_handlers(rx, &reorder_release);
Christian Lamparteraa0c8632010-08-05 01:36:04 +02002918 return;
Johannes Berg49461622008-06-30 15:10:45 +02002919
Johannes Berg2569a822009-11-25 17:46:17 +01002920 rxh_next:
Christian Lamparteraa0c8632010-08-05 01:36:04 +02002921 ieee80211_rx_handlers_result(rx, res);
2922
2923#undef CALL_RXH
Johannes Berg58905292008-01-31 19:48:25 +01002924}
2925
Christian Lamparter2bff8eb2010-08-05 01:36:41 +02002926/*
Johannes Bergdd318572010-11-29 11:09:16 +01002927 * This function makes calls into the RX path, therefore
2928 * it has to be invoked under RCU read lock.
Christian Lamparter2bff8eb2010-08-05 01:36:41 +02002929 */
2930void ieee80211_release_reorder_timeout(struct sta_info *sta, int tid)
2931{
Christian Lamparterf9e124f2013-02-04 17:44:44 +00002932 struct sk_buff_head frames;
Johannes Berg554891e2010-09-24 12:38:25 +02002933 struct ieee80211_rx_data rx = {
2934 .sta = sta,
2935 .sdata = sta->sdata,
2936 .local = sta->local,
Johannes Berg9e262972011-07-07 18:45:03 +02002937 /* This is OK -- must be QoS data frame */
2938 .security_idx = tid,
2939 .seqno_idx = tid,
Helmut Schaafcf8bd32011-04-01 15:46:05 +02002940 .flags = 0,
Johannes Berg554891e2010-09-24 12:38:25 +02002941 };
Christian Lamparter2c15a0c2010-08-24 19:22:42 +02002942 struct tid_ampdu_rx *tid_agg_rx;
2943
2944 tid_agg_rx = rcu_dereference(sta->ampdu_mlme.tid_rx[tid]);
2945 if (!tid_agg_rx)
2946 return;
Christian Lamparter2bff8eb2010-08-05 01:36:41 +02002947
Christian Lamparterf9e124f2013-02-04 17:44:44 +00002948 __skb_queue_head_init(&frames);
2949
Christian Lamparter2c15a0c2010-08-24 19:22:42 +02002950 spin_lock(&tid_agg_rx->reorder_lock);
Christian Lamparterf9e124f2013-02-04 17:44:44 +00002951 ieee80211_sta_reorder_release(sta->sdata, tid_agg_rx, &frames);
Christian Lamparter2c15a0c2010-08-24 19:22:42 +02002952 spin_unlock(&tid_agg_rx->reorder_lock);
Christian Lamparter2bff8eb2010-08-05 01:36:41 +02002953
Christian Lamparterf9e124f2013-02-04 17:44:44 +00002954 ieee80211_rx_handlers(&rx, &frames);
Christian Lamparter2bff8eb2010-08-05 01:36:41 +02002955}
2956
Johannes Berg571ecf62007-07-27 15:43:22 +02002957/* main receive path */
2958
Johannes Berg20b01f82010-09-24 11:21:05 +02002959static int prepare_for_handlers(struct ieee80211_rx_data *rx,
Johannes Berg23a24de2007-07-27 15:43:22 +02002960 struct ieee80211_hdr *hdr)
2961{
Johannes Berg20b01f82010-09-24 11:21:05 +02002962 struct ieee80211_sub_if_data *sdata = rx->sdata;
Johannes Bergeb9fb5b2009-11-16 13:58:20 +01002963 struct sk_buff *skb = rx->skb;
2964 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
2965 u8 *bssid = ieee80211_get_bssid(hdr, skb->len, sdata->vif.type);
Johannes Berg23a24de2007-07-27 15:43:22 +02002966 int multicast = is_multicast_ether_addr(hdr->addr1);
2967
Johannes Berg51fb61e2007-12-19 01:31:27 +01002968 switch (sdata->vif.type) {
Johannes Berg05c914f2008-09-11 00:01:58 +02002969 case NL80211_IFTYPE_STATION:
Johannes Berg9bc383d2009-11-19 11:55:19 +01002970 if (!bssid && !sdata->u.mgd.use_4addr)
Johannes Berg23a24de2007-07-27 15:43:22 +02002971 return 0;
Johannes Berg77fdaa12009-07-07 03:45:17 +02002972 if (!multicast &&
Joe Perchesb203ca32012-05-08 18:56:52 +00002973 !ether_addr_equal(sdata->vif.addr, hdr->addr1)) {
Felix Fietkau4f312332011-02-05 23:48:37 +01002974 if (!(sdata->dev->flags & IFF_PROMISC) ||
2975 sdata->u.mgd.use_4addr)
Johannes Berg23a24de2007-07-27 15:43:22 +02002976 return 0;
Johannes Berg554891e2010-09-24 12:38:25 +02002977 status->rx_flags &= ~IEEE80211_RX_RA_MATCH;
Johannes Berg23a24de2007-07-27 15:43:22 +02002978 }
2979 break;
Johannes Berg05c914f2008-09-11 00:01:58 +02002980 case NL80211_IFTYPE_ADHOC:
Johannes Berg23a24de2007-07-27 15:43:22 +02002981 if (!bssid)
2982 return 0;
Harvey Harrisona7767f92008-07-02 16:30:51 -07002983 if (ieee80211_is_beacon(hdr->frame_control)) {
Bruno Randolf9d9bf772008-02-18 11:21:36 +09002984 return 1;
Johannes Bergd48b2962012-07-06 22:19:27 +02002985 } else if (!ieee80211_bssid_match(bssid, sdata->u.ibss.bssid)) {
2986 return 0;
Johannes Berg23a24de2007-07-27 15:43:22 +02002987 } else if (!multicast &&
Joe Perchesb203ca32012-05-08 18:56:52 +00002988 !ether_addr_equal(sdata->vif.addr, hdr->addr1)) {
Johannes Berg4150c572007-09-17 01:29:23 -04002989 if (!(sdata->dev->flags & IFF_PROMISC))
Johannes Berg23a24de2007-07-27 15:43:22 +02002990 return 0;
Johannes Berg554891e2010-09-24 12:38:25 +02002991 status->rx_flags &= ~IEEE80211_RX_RA_MATCH;
Jouni Malinen0fb8ca42008-12-12 14:38:33 +02002992 } else if (!rx->sta) {
2993 int rate_idx;
Johannes Berg56146182012-11-09 15:07:02 +01002994 if (status->flag & (RX_FLAG_HT | RX_FLAG_VHT))
2995 rate_idx = 0; /* TODO: HT/VHT rates */
Jouni Malinen0fb8ca42008-12-12 14:38:33 +02002996 else
Johannes Bergeb9fb5b2009-11-16 13:58:20 +01002997 rate_idx = status->rate_idx;
Johannes Berg8bf11d82011-12-15 11:17:37 +01002998 ieee80211_ibss_rx_no_sta(sdata, bssid, hdr->addr2,
2999 BIT(rate_idx));
Jouni Malinen0fb8ca42008-12-12 14:38:33 +02003000 }
Johannes Berg23a24de2007-07-27 15:43:22 +02003001 break;
Johannes Berg05c914f2008-09-11 00:01:58 +02003002 case NL80211_IFTYPE_MESH_POINT:
Johannes Berg6032f932008-02-23 15:17:07 +01003003 if (!multicast &&
Joe Perchesb203ca32012-05-08 18:56:52 +00003004 !ether_addr_equal(sdata->vif.addr, hdr->addr1)) {
Johannes Berg6032f932008-02-23 15:17:07 +01003005 if (!(sdata->dev->flags & IFF_PROMISC))
3006 return 0;
3007
Johannes Berg554891e2010-09-24 12:38:25 +02003008 status->rx_flags &= ~IEEE80211_RX_RA_MATCH;
Johannes Berg6032f932008-02-23 15:17:07 +01003009 }
3010 break;
Johannes Berg05c914f2008-09-11 00:01:58 +02003011 case NL80211_IFTYPE_AP_VLAN:
3012 case NL80211_IFTYPE_AP:
Johannes Berg23a24de2007-07-27 15:43:22 +02003013 if (!bssid) {
Joe Perchesb203ca32012-05-08 18:56:52 +00003014 if (!ether_addr_equal(sdata->vif.addr, hdr->addr1))
Johannes Berg23a24de2007-07-27 15:43:22 +02003015 return 0;
Johannes Bergf142c6b2012-06-18 20:07:15 +02003016 } else if (!ieee80211_bssid_match(bssid, sdata->vif.addr)) {
Johannes Berg3df6eae2011-12-06 10:39:40 +01003017 /*
3018 * Accept public action frames even when the
3019 * BSSID doesn't match, this is used for P2P
3020 * and location updates. Note that mac80211
3021 * itself never looks at these frames.
3022 */
Johannes Bergd48b2962012-07-06 22:19:27 +02003023 if (ieee80211_is_public_action(hdr, skb->len))
Johannes Berg3df6eae2011-12-06 10:39:40 +01003024 return 1;
Johannes Bergd48b2962012-07-06 22:19:27 +02003025 if (!ieee80211_is_beacon(hdr->frame_control))
Johannes Berg23a24de2007-07-27 15:43:22 +02003026 return 0;
Johannes Berg554891e2010-09-24 12:38:25 +02003027 status->rx_flags &= ~IEEE80211_RX_RA_MATCH;
Johannes Berg23a24de2007-07-27 15:43:22 +02003028 }
Johannes Berg23a24de2007-07-27 15:43:22 +02003029 break;
Johannes Berg05c914f2008-09-11 00:01:58 +02003030 case NL80211_IFTYPE_WDS:
Harvey Harrisona7767f92008-07-02 16:30:51 -07003031 if (bssid || !ieee80211_is_data(hdr->frame_control))
Johannes Berg23a24de2007-07-27 15:43:22 +02003032 return 0;
Joe Perchesb203ca32012-05-08 18:56:52 +00003033 if (!ether_addr_equal(sdata->u.wds.remote_addr, hdr->addr2))
Johannes Berg23a24de2007-07-27 15:43:22 +02003034 return 0;
3035 break;
Johannes Bergf142c6b2012-06-18 20:07:15 +02003036 case NL80211_IFTYPE_P2P_DEVICE:
3037 if (!ieee80211_is_public_action(hdr, skb->len) &&
3038 !ieee80211_is_probe_req(hdr->frame_control) &&
3039 !ieee80211_is_probe_resp(hdr->frame_control) &&
3040 !ieee80211_is_beacon(hdr->frame_control))
3041 return 0;
3042 if (!ether_addr_equal(sdata->vif.addr, hdr->addr1))
3043 status->rx_flags &= ~IEEE80211_RX_RA_MATCH;
3044 break;
Johannes Berg2ca27bc2010-09-16 14:58:23 +02003045 default:
Johannes Bergfb1c1cd2007-09-26 15:19:43 +02003046 /* should never get here */
Johannes Bergf142c6b2012-06-18 20:07:15 +02003047 WARN_ON_ONCE(1);
Johannes Bergfb1c1cd2007-09-26 15:19:43 +02003048 break;
Johannes Berg23a24de2007-07-27 15:43:22 +02003049 }
3050
3051 return 1;
3052}
3053
Johannes Berg571ecf62007-07-27 15:43:22 +02003054/*
Johannes Berg4406c372010-09-24 11:21:06 +02003055 * This function returns whether or not the SKB
3056 * was destined for RX processing or not, which,
3057 * if consume is true, is equivalent to whether
3058 * or not the skb was consumed.
3059 */
3060static bool ieee80211_prepare_and_rx_handle(struct ieee80211_rx_data *rx,
3061 struct sk_buff *skb, bool consume)
3062{
3063 struct ieee80211_local *local = rx->local;
3064 struct ieee80211_sub_if_data *sdata = rx->sdata;
3065 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
3066 struct ieee80211_hdr *hdr = (void *)skb->data;
3067 int prepares;
3068
3069 rx->skb = skb;
Johannes Berg554891e2010-09-24 12:38:25 +02003070 status->rx_flags |= IEEE80211_RX_RA_MATCH;
Johannes Berg4406c372010-09-24 11:21:06 +02003071 prepares = prepare_for_handlers(rx, hdr);
3072
3073 if (!prepares)
3074 return false;
3075
Johannes Berg4406c372010-09-24 11:21:06 +02003076 if (!consume) {
3077 skb = skb_copy(skb, GFP_ATOMIC);
3078 if (!skb) {
3079 if (net_ratelimit())
3080 wiphy_debug(local->hw.wiphy,
Ben Greearb305dae2011-01-08 10:30:54 -08003081 "failed to copy skb for %s\n",
Johannes Berg4406c372010-09-24 11:21:06 +02003082 sdata->name);
3083 return true;
3084 }
3085
3086 rx->skb = skb;
3087 }
3088
3089 ieee80211_invoke_rx_handlers(rx);
3090 return true;
3091}
3092
3093/*
Ron Rindjunsky6368e4b2007-12-24 13:36:39 +02003094 * This is the actual Rx frames handler. as it blongs to Rx path it must
3095 * be called with rcu_read_lock protection.
Johannes Berg571ecf62007-07-27 15:43:22 +02003096 */
Ron Rindjunsky71ebb4a2008-01-21 12:39:12 +02003097static void __ieee80211_rx_handle_packet(struct ieee80211_hw *hw,
Christian Lamparter071d9ac2010-08-05 01:36:36 +02003098 struct sk_buff *skb)
Johannes Berg571ecf62007-07-27 15:43:22 +02003099{
3100 struct ieee80211_local *local = hw_to_local(hw);
3101 struct ieee80211_sub_if_data *sdata;
Johannes Berg571ecf62007-07-27 15:43:22 +02003102 struct ieee80211_hdr *hdr;
Zhu Yie3cf8b32010-03-29 17:35:07 +08003103 __le16 fc;
Johannes Berg5cf121c2008-02-25 16:27:43 +01003104 struct ieee80211_rx_data rx;
Johannes Berg4406c372010-09-24 11:21:06 +02003105 struct ieee80211_sub_if_data *prev;
Ben Greear56af3262010-09-23 10:22:24 -07003106 struct sta_info *sta, *tmp, *prev_sta;
Zhu Yie3cf8b32010-03-29 17:35:07 +08003107 int err = 0;
Johannes Berg571ecf62007-07-27 15:43:22 +02003108
Zhu Yie3cf8b32010-03-29 17:35:07 +08003109 fc = ((struct ieee80211_hdr *)skb->data)->frame_control;
Johannes Berg571ecf62007-07-27 15:43:22 +02003110 memset(&rx, 0, sizeof(rx));
3111 rx.skb = skb;
3112 rx.local = local;
Johannes Berg72abd812007-09-17 01:29:22 -04003113
Zhu Yie3cf8b32010-03-29 17:35:07 +08003114 if (ieee80211_is_data(fc) || ieee80211_is_mgmt(fc))
Johannes Berg571ecf62007-07-27 15:43:22 +02003115 local->dot11ReceivedFragmentCount++;
Johannes Berg571ecf62007-07-27 15:43:22 +02003116
Johannes Berg4a4f1a52012-10-26 00:33:36 +02003117 if (ieee80211_is_mgmt(fc)) {
3118 /* drop frame if too short for header */
3119 if (skb->len < ieee80211_hdrlen(fc))
3120 err = -ENOBUFS;
3121 else
3122 err = skb_linearize(skb);
3123 } else {
Zhu Yie3cf8b32010-03-29 17:35:07 +08003124 err = !pskb_may_pull(skb, ieee80211_hdrlen(fc));
Johannes Berg4a4f1a52012-10-26 00:33:36 +02003125 }
Zhu Yie3cf8b32010-03-29 17:35:07 +08003126
3127 if (err) {
3128 dev_kfree_skb(skb);
3129 return;
3130 }
3131
3132 hdr = (struct ieee80211_hdr *)skb->data;
Johannes Berg38f37142008-01-29 17:07:43 +01003133 ieee80211_parse_qos(&rx);
Johannes Bergd1c3a372009-01-07 00:26:10 +01003134 ieee80211_verify_alignment(&rx);
Johannes Berg38f37142008-01-29 17:07:43 +01003135
Johannes Bergd48b2962012-07-06 22:19:27 +02003136 if (unlikely(ieee80211_is_probe_resp(hdr->frame_control) ||
3137 ieee80211_is_beacon(hdr->frame_control)))
3138 ieee80211_scan_rx(local, skb);
3139
Zhu Yie3cf8b32010-03-29 17:35:07 +08003140 if (ieee80211_is_data(fc)) {
Ben Greear56af3262010-09-23 10:22:24 -07003141 prev_sta = NULL;
Johannes Berg4406c372010-09-24 11:21:06 +02003142
Johannes Berg7852e362012-01-20 13:55:24 +01003143 for_each_sta_info(local, hdr->addr2, sta, tmp) {
Ben Greear56af3262010-09-23 10:22:24 -07003144 if (!prev_sta) {
3145 prev_sta = sta;
3146 continue;
3147 }
3148
3149 rx.sta = prev_sta;
3150 rx.sdata = prev_sta->sdata;
Johannes Berg4406c372010-09-24 11:21:06 +02003151 ieee80211_prepare_and_rx_handle(&rx, skb, false);
Johannes Berg571ecf62007-07-27 15:43:22 +02003152
Ben Greear56af3262010-09-23 10:22:24 -07003153 prev_sta = sta;
Johannes Berg4406c372010-09-24 11:21:06 +02003154 }
Ben Greear56af3262010-09-23 10:22:24 -07003155
3156 if (prev_sta) {
3157 rx.sta = prev_sta;
3158 rx.sdata = prev_sta->sdata;
3159
Johannes Berg4406c372010-09-24 11:21:06 +02003160 if (ieee80211_prepare_and_rx_handle(&rx, skb, true))
Ben Greear56af3262010-09-23 10:22:24 -07003161 return;
Senthil Balasubramanian8e26d5a2010-11-30 20:15:38 +05303162 goto out;
Ben Greear56af3262010-09-23 10:22:24 -07003163 }
Johannes Berg4406c372010-09-24 11:21:06 +02003164 }
3165
Johannes Berg4b0dd982010-09-24 11:21:07 +02003166 prev = NULL;
Johannes Berg4406c372010-09-24 11:21:06 +02003167
Johannes Berg4b0dd982010-09-24 11:21:07 +02003168 list_for_each_entry_rcu(sdata, &local->interfaces, list) {
3169 if (!ieee80211_sdata_running(sdata))
3170 continue;
Johannes Bergabe60632009-11-25 17:46:18 +01003171
Johannes Berg4b0dd982010-09-24 11:21:07 +02003172 if (sdata->vif.type == NL80211_IFTYPE_MONITOR ||
3173 sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
3174 continue;
Johannes Bergabe60632009-11-25 17:46:18 +01003175
Johannes Berg4b0dd982010-09-24 11:21:07 +02003176 /*
3177 * frame is destined for this interface, but if it's
3178 * not also for the previous one we handle that after
3179 * the loop to avoid copying the SKB once too much
3180 */
Johannes Bergb2e77712007-09-26 15:19:39 +02003181
Johannes Berg4b0dd982010-09-24 11:21:07 +02003182 if (!prev) {
Johannes Berg340e11f2007-07-27 15:43:22 +02003183 prev = sdata;
Johannes Berg4b0dd982010-09-24 11:21:07 +02003184 continue;
Johannes Berg8e6f00322007-07-27 15:43:22 +02003185 }
Felix Fietkau4bb29f82010-01-22 00:36:39 +01003186
Johannes Berg7852e362012-01-20 13:55:24 +01003187 rx.sta = sta_info_get_bss(prev, hdr->addr2);
Johannes Berg4b0dd982010-09-24 11:21:07 +02003188 rx.sdata = prev;
3189 ieee80211_prepare_and_rx_handle(&rx, skb, false);
Felix Fietkau4bb29f82010-01-22 00:36:39 +01003190
Johannes Berg4b0dd982010-09-24 11:21:07 +02003191 prev = sdata;
3192 }
Johannes Berg4406c372010-09-24 11:21:06 +02003193
Johannes Berg4b0dd982010-09-24 11:21:07 +02003194 if (prev) {
Johannes Berg7852e362012-01-20 13:55:24 +01003195 rx.sta = sta_info_get_bss(prev, hdr->addr2);
Johannes Berg4b0dd982010-09-24 11:21:07 +02003196 rx.sdata = prev;
3197
3198 if (ieee80211_prepare_and_rx_handle(&rx, skb, true))
3199 return;
Johannes Berg571ecf62007-07-27 15:43:22 +02003200 }
Johannes Berg4406c372010-09-24 11:21:06 +02003201
Senthil Balasubramanian8e26d5a2010-11-30 20:15:38 +05303202 out:
Johannes Berg4406c372010-09-24 11:21:06 +02003203 dev_kfree_skb(skb);
Johannes Berg571ecf62007-07-27 15:43:22 +02003204}
Ron Rindjunsky6368e4b2007-12-24 13:36:39 +02003205
3206/*
3207 * This is the receive path handler. It is called by a low level driver when an
3208 * 802.11 MPDU is received from the hardware.
3209 */
John W. Linville103bf9f2009-08-20 16:34:15 -04003210void ieee80211_rx(struct ieee80211_hw *hw, struct sk_buff *skb)
Ron Rindjunsky6368e4b2007-12-24 13:36:39 +02003211{
3212 struct ieee80211_local *local = hw_to_local(hw);
Johannes Berg8318d782008-01-24 19:38:38 +01003213 struct ieee80211_rate *rate = NULL;
3214 struct ieee80211_supported_band *sband;
Johannes Bergf1d58c22009-06-17 13:13:00 +02003215 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
Johannes Berg8318d782008-01-24 19:38:38 +01003216
Johannes Bergd20ef632009-10-11 15:10:40 +02003217 WARN_ON_ONCE(softirq_count() == 0);
3218
Johannes Berg444e38032012-09-30 17:08:35 +02003219 if (WARN_ON(status->band >= IEEE80211_NUM_BANDS))
Johannes Berg77a980d2009-08-24 11:46:30 +02003220 goto drop;
Johannes Berg8318d782008-01-24 19:38:38 +01003221
3222 sband = local->hw.wiphy->bands[status->band];
Johannes Berg77a980d2009-08-24 11:46:30 +02003223 if (WARN_ON(!sband))
3224 goto drop;
Johannes Berg8318d782008-01-24 19:38:38 +01003225
Johannes Berg89c3a8a2009-07-28 18:10:17 +02003226 /*
3227 * If we're suspending, it is possible although not too likely
3228 * that we'd be receiving frames after having already partially
3229 * quiesced the stack. We can't process such frames then since
3230 * that might, for example, cause stations to be added or other
3231 * driver callbacks be invoked.
3232 */
Johannes Berg77a980d2009-08-24 11:46:30 +02003233 if (unlikely(local->quiescing || local->suspended))
3234 goto drop;
Johannes Berg89c3a8a2009-07-28 18:10:17 +02003235
Arik Nemtsov04800ad2012-06-06 11:25:02 +03003236 /* We might be during a HW reconfig, prevent Rx for the same reason */
3237 if (unlikely(local->in_reconfig))
3238 goto drop;
3239
Johannes Bergea77f122009-08-21 14:44:45 +02003240 /*
3241 * The same happens when we're not even started,
3242 * but that's worth a warning.
3243 */
Johannes Berg77a980d2009-08-24 11:46:30 +02003244 if (WARN_ON(!local->started))
3245 goto drop;
Johannes Bergea77f122009-08-21 14:44:45 +02003246
Johannes Bergfc885182010-07-30 13:23:12 +02003247 if (likely(!(status->flag & RX_FLAG_FAILED_PLCP_CRC))) {
Luis R. Rodrigueze5d6eb82009-11-09 16:03:22 -05003248 /*
Johannes Bergfc885182010-07-30 13:23:12 +02003249 * Validate the rate, unless a PLCP error means that
3250 * we probably can't have a valid rate here anyway.
Luis R. Rodrigueze5d6eb82009-11-09 16:03:22 -05003251 */
Johannes Bergfc885182010-07-30 13:23:12 +02003252
3253 if (status->flag & RX_FLAG_HT) {
3254 /*
3255 * rate_idx is MCS index, which can be [0-76]
3256 * as documented on:
3257 *
3258 * http://wireless.kernel.org/en/developers/Documentation/ieee80211/802.11n
3259 *
3260 * Anything else would be some sort of driver or
3261 * hardware error. The driver should catch hardware
3262 * errors.
3263 */
Johannes Berg444e38032012-09-30 17:08:35 +02003264 if (WARN(status->rate_idx > 76,
Johannes Bergfc885182010-07-30 13:23:12 +02003265 "Rate marked as an HT rate but passed "
3266 "status->rate_idx is not "
3267 "an MCS index [0-76]: %d (0x%02x)\n",
3268 status->rate_idx,
3269 status->rate_idx))
3270 goto drop;
Johannes Berg56146182012-11-09 15:07:02 +01003271 } else if (status->flag & RX_FLAG_VHT) {
3272 if (WARN_ONCE(status->rate_idx > 9 ||
3273 !status->vht_nss ||
3274 status->vht_nss > 8,
3275 "Rate marked as a VHT rate but data is invalid: MCS: %d, NSS: %d\n",
3276 status->rate_idx, status->vht_nss))
3277 goto drop;
Johannes Bergfc885182010-07-30 13:23:12 +02003278 } else {
Johannes Berg444e38032012-09-30 17:08:35 +02003279 if (WARN_ON(status->rate_idx >= sband->n_bitrates))
Johannes Bergfc885182010-07-30 13:23:12 +02003280 goto drop;
3281 rate = &sband->bitrates[status->rate_idx];
3282 }
Jouni Malinen0fb8ca42008-12-12 14:38:33 +02003283 }
Ron Rindjunsky6368e4b2007-12-24 13:36:39 +02003284
Johannes Berg554891e2010-09-24 12:38:25 +02003285 status->rx_flags = 0;
3286
Ron Rindjunsky6368e4b2007-12-24 13:36:39 +02003287 /*
3288 * key references and virtual interfaces are protected using RCU
3289 * and this requires that we are in a read-side RCU section during
3290 * receive processing
3291 */
3292 rcu_read_lock();
3293
3294 /*
3295 * Frames with failed FCS/PLCP checksum are not returned,
3296 * all other frames are returned without radiotap header
3297 * if it was previously present.
3298 * Also, frames with less than 16 bytes are dropped.
3299 */
Johannes Bergf1d58c22009-06-17 13:13:00 +02003300 skb = ieee80211_rx_monitor(local, skb, rate);
Ron Rindjunsky6368e4b2007-12-24 13:36:39 +02003301 if (!skb) {
3302 rcu_read_unlock();
3303 return;
3304 }
3305
Johannes Berge1e54062010-11-30 08:58:45 +01003306 ieee80211_tpt_led_trig_rx(local,
3307 ((struct ieee80211_hdr *)skb->data)->frame_control,
3308 skb->len);
Christian Lamparter071d9ac2010-08-05 01:36:36 +02003309 __ieee80211_rx_handle_packet(hw, skb);
Ron Rindjunsky6368e4b2007-12-24 13:36:39 +02003310
3311 rcu_read_unlock();
Johannes Berg77a980d2009-08-24 11:46:30 +02003312
3313 return;
3314 drop:
3315 kfree_skb(skb);
Ron Rindjunsky6368e4b2007-12-24 13:36:39 +02003316}
John W. Linville103bf9f2009-08-20 16:34:15 -04003317EXPORT_SYMBOL(ieee80211_rx);
Johannes Berg571ecf62007-07-27 15:43:22 +02003318
3319/* This is a version of the rx handler that can be called from hard irq
3320 * context. Post the skb on the queue and schedule the tasklet */
Johannes Bergf1d58c22009-06-17 13:13:00 +02003321void ieee80211_rx_irqsafe(struct ieee80211_hw *hw, struct sk_buff *skb)
Johannes Berg571ecf62007-07-27 15:43:22 +02003322{
3323 struct ieee80211_local *local = hw_to_local(hw);
3324
3325 BUILD_BUG_ON(sizeof(struct ieee80211_rx_status) > sizeof(skb->cb));
3326
Johannes Berg571ecf62007-07-27 15:43:22 +02003327 skb->pkt_type = IEEE80211_RX_MSG;
3328 skb_queue_tail(&local->skb_queue, skb);
3329 tasklet_schedule(&local->tasklet);
3330}
3331EXPORT_SYMBOL(ieee80211_rx_irqsafe);