blob: bcfe8c77c8392dae5e730d8b76c0c18bb9720622 [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 Bergb2e77712007-09-26 15:19:39 +020043 if (local->hw.flags & IEEE80211_HW_RX_INCLUDES_FCS) {
44 if (likely(skb->len > FCS_LEN))
Zhu Yie3cf8b32010-03-29 17:35:07 +080045 __pskb_trim(skb, skb->len - FCS_LEN);
Johannes Bergb2e77712007-09-26 15:19:39 +020046 else {
47 /* driver bug */
48 WARN_ON(1);
49 dev_kfree_skb(skb);
50 skb = NULL;
51 }
52 }
53
54 return skb;
55}
56
Johannes Bergf1d58c22009-06-17 13:13:00 +020057static inline int should_drop_frame(struct sk_buff *skb,
Johannes Berg0869aea2009-10-28 10:03:35 +010058 int present_fcs_len)
Johannes Bergb2e77712007-09-26 15:19:39 +020059{
Johannes Bergf1d58c22009-06-17 13:13:00 +020060 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
Harvey Harrison182503a2008-06-22 16:45:29 -070061 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
Johannes Bergb2e77712007-09-26 15:19:39 +020062
63 if (status->flag & (RX_FLAG_FAILED_FCS_CRC | RX_FLAG_FAILED_PLCP_CRC))
64 return 1;
Johannes Berg0869aea2009-10-28 10:03:35 +010065 if (unlikely(skb->len < 16 + present_fcs_len))
Johannes Bergb2e77712007-09-26 15:19:39 +020066 return 1;
Harvey Harrison87228f52008-06-11 14:21:59 -070067 if (ieee80211_is_ctl(hdr->frame_control) &&
68 !ieee80211_is_pspoll(hdr->frame_control) &&
69 !ieee80211_is_back_req(hdr->frame_control))
Johannes Bergb2e77712007-09-26 15:19:39 +020070 return 1;
71 return 0;
72}
73
Bruno Randolf601ae7f2008-05-08 19:22:43 +020074static int
75ieee80211_rx_radiotap_len(struct ieee80211_local *local,
76 struct ieee80211_rx_status *status)
77{
78 int len;
79
80 /* always present fields */
81 len = sizeof(struct ieee80211_radiotap_header) + 9;
82
Johannes Berg6ebacbb2011-02-23 15:06:08 +010083 if (status->flag & RX_FLAG_MACTIME_MPDU)
Bruno Randolf601ae7f2008-05-08 19:22:43 +020084 len += 8;
Johannes Berg7fee5372009-01-30 11:13:06 +010085 if (local->hw.flags & IEEE80211_HW_SIGNAL_DBM)
Bruno Randolf601ae7f2008-05-08 19:22:43 +020086 len += 1;
Bruno Randolf601ae7f2008-05-08 19:22:43 +020087
88 if (len & 1) /* padding for RX_FLAGS if necessary */
89 len++;
90
Johannes Berg6d744ba2011-01-27 14:13:17 +010091 if (status->flag & RX_FLAG_HT) /* HT info */
92 len += 3;
93
Bruno Randolf601ae7f2008-05-08 19:22:43 +020094 return len;
95}
96
Johannes Bergd1c3a372009-01-07 00:26:10 +010097/*
Bruno Randolf601ae7f2008-05-08 19:22:43 +020098 * ieee80211_add_rx_radiotap_header - add radiotap header
99 *
100 * add a radiotap header containing all the fields which the hardware provided.
101 */
102static void
103ieee80211_add_rx_radiotap_header(struct ieee80211_local *local,
104 struct sk_buff *skb,
Bruno Randolf601ae7f2008-05-08 19:22:43 +0200105 struct ieee80211_rate *rate,
106 int rtap_len)
107{
Johannes Bergf1d58c22009-06-17 13:13:00 +0200108 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
Bruno Randolf601ae7f2008-05-08 19:22:43 +0200109 struct ieee80211_radiotap_header *rthdr;
110 unsigned char *pos;
Johannes Berg6a86b9c2009-10-28 09:58:52 +0100111 u16 rx_flags = 0;
Bruno Randolf601ae7f2008-05-08 19:22:43 +0200112
113 rthdr = (struct ieee80211_radiotap_header *)skb_push(skb, rtap_len);
114 memset(rthdr, 0, rtap_len);
115
116 /* radiotap header, set always present flags */
117 rthdr->it_present =
118 cpu_to_le32((1 << IEEE80211_RADIOTAP_FLAGS) |
Bruno Randolf601ae7f2008-05-08 19:22:43 +0200119 (1 << IEEE80211_RADIOTAP_CHANNEL) |
120 (1 << IEEE80211_RADIOTAP_ANTENNA) |
121 (1 << IEEE80211_RADIOTAP_RX_FLAGS));
122 rthdr->it_len = cpu_to_le16(rtap_len);
123
124 pos = (unsigned char *)(rthdr+1);
125
126 /* the order of the following fields is important */
127
128 /* IEEE80211_RADIOTAP_TSFT */
Johannes Berg6ebacbb2011-02-23 15:06:08 +0100129 if (status->flag & RX_FLAG_MACTIME_MPDU) {
Johannes Berg6a86b9c2009-10-28 09:58:52 +0100130 put_unaligned_le64(status->mactime, pos);
Bruno Randolf601ae7f2008-05-08 19:22:43 +0200131 rthdr->it_present |=
132 cpu_to_le32(1 << IEEE80211_RADIOTAP_TSFT);
133 pos += 8;
134 }
135
136 /* IEEE80211_RADIOTAP_FLAGS */
137 if (local->hw.flags & IEEE80211_HW_RX_INCLUDES_FCS)
138 *pos |= IEEE80211_RADIOTAP_F_FCS;
Johannes Bergaae89832009-03-13 12:52:10 +0100139 if (status->flag & (RX_FLAG_FAILED_FCS_CRC | RX_FLAG_FAILED_PLCP_CRC))
140 *pos |= IEEE80211_RADIOTAP_F_BADFCS;
Bruno Randolfb4f28bb2008-07-30 17:19:55 +0200141 if (status->flag & RX_FLAG_SHORTPRE)
142 *pos |= IEEE80211_RADIOTAP_F_SHORTPRE;
Bruno Randolf601ae7f2008-05-08 19:22:43 +0200143 pos++;
144
145 /* IEEE80211_RADIOTAP_RATE */
Johannes Bergf8d1ccf2011-11-08 12:28:33 +0100146 if (!rate || status->flag & RX_FLAG_HT) {
Jouni Malinen0fb8ca42008-12-12 14:38:33 +0200147 /*
Johannes Bergf8d1ccf2011-11-08 12:28:33 +0100148 * Without rate information don't add it. If we have,
Mohammed Shafi Shajakhan38f37be2011-02-07 10:10:04 +0530149 * MCS information is a separate field in radiotap,
Johannes Berg73b48092011-04-18 17:05:21 +0200150 * added below. The byte here is needed as padding
151 * for the channel though, so initialise it to 0.
Jouni Malinen0fb8ca42008-12-12 14:38:33 +0200152 */
153 *pos = 0;
Jouni Malinen8d6f6582008-12-15 10:37:50 +0200154 } else {
Jouni Malinenebe6c7b2009-01-10 11:47:33 +0200155 rthdr->it_present |= cpu_to_le32(1 << IEEE80211_RADIOTAP_RATE);
Jouni Malinen0fb8ca42008-12-12 14:38:33 +0200156 *pos = rate->bitrate / 5;
Jouni Malinen8d6f6582008-12-15 10:37:50 +0200157 }
Bruno Randolf601ae7f2008-05-08 19:22:43 +0200158 pos++;
159
160 /* IEEE80211_RADIOTAP_CHANNEL */
Johannes Berg6a86b9c2009-10-28 09:58:52 +0100161 put_unaligned_le16(status->freq, pos);
Bruno Randolf601ae7f2008-05-08 19:22:43 +0200162 pos += 2;
163 if (status->band == IEEE80211_BAND_5GHZ)
Johannes Berg6a86b9c2009-10-28 09:58:52 +0100164 put_unaligned_le16(IEEE80211_CHAN_OFDM | IEEE80211_CHAN_5GHZ,
165 pos);
Johannes Berg5f0b7de2009-11-16 13:58:21 +0100166 else if (status->flag & RX_FLAG_HT)
167 put_unaligned_le16(IEEE80211_CHAN_DYN | IEEE80211_CHAN_2GHZ,
168 pos);
Johannes Bergf8d1ccf2011-11-08 12:28:33 +0100169 else if (rate && rate->flags & IEEE80211_RATE_ERP_G)
Johannes Berg6a86b9c2009-10-28 09:58:52 +0100170 put_unaligned_le16(IEEE80211_CHAN_OFDM | IEEE80211_CHAN_2GHZ,
171 pos);
Johannes Bergf8d1ccf2011-11-08 12:28:33 +0100172 else if (rate)
Johannes Berg6a86b9c2009-10-28 09:58:52 +0100173 put_unaligned_le16(IEEE80211_CHAN_CCK | IEEE80211_CHAN_2GHZ,
174 pos);
Johannes Bergf8d1ccf2011-11-08 12:28:33 +0100175 else
176 put_unaligned_le16(IEEE80211_CHAN_2GHZ, pos);
Bruno Randolf601ae7f2008-05-08 19:22:43 +0200177 pos += 2;
178
179 /* IEEE80211_RADIOTAP_DBM_ANTSIGNAL */
Felix Fietkaufe8431f2012-03-01 18:00:07 +0100180 if (local->hw.flags & IEEE80211_HW_SIGNAL_DBM &&
181 !(status->flag & RX_FLAG_NO_SIGNAL_VAL)) {
Bruno Randolf601ae7f2008-05-08 19:22:43 +0200182 *pos = status->signal;
183 rthdr->it_present |=
184 cpu_to_le32(1 << IEEE80211_RADIOTAP_DBM_ANTSIGNAL);
185 pos++;
186 }
187
Bruno Randolf601ae7f2008-05-08 19:22:43 +0200188 /* IEEE80211_RADIOTAP_LOCK_QUALITY is missing */
189
190 /* IEEE80211_RADIOTAP_ANTENNA */
191 *pos = status->antenna;
192 pos++;
193
Bruno Randolf601ae7f2008-05-08 19:22:43 +0200194 /* IEEE80211_RADIOTAP_DB_ANTNOISE is not used */
195
196 /* IEEE80211_RADIOTAP_RX_FLAGS */
197 /* ensure 2 byte alignment for the 2 byte field as required */
Johannes Berg6a86b9c2009-10-28 09:58:52 +0100198 if ((pos - (u8 *)rthdr) & 1)
Bruno Randolf601ae7f2008-05-08 19:22:43 +0200199 pos++;
Johannes Bergaae89832009-03-13 12:52:10 +0100200 if (status->flag & RX_FLAG_FAILED_PLCP_CRC)
Johannes Berg6a86b9c2009-10-28 09:58:52 +0100201 rx_flags |= IEEE80211_RADIOTAP_F_RX_BADPLCP;
202 put_unaligned_le16(rx_flags, pos);
Bruno Randolf601ae7f2008-05-08 19:22:43 +0200203 pos += 2;
Johannes Berg6d744ba2011-01-27 14:13:17 +0100204
205 if (status->flag & RX_FLAG_HT) {
206 rthdr->it_present |= cpu_to_le32(1 << IEEE80211_RADIOTAP_MCS);
207 *pos++ = IEEE80211_RADIOTAP_MCS_HAVE_MCS |
208 IEEE80211_RADIOTAP_MCS_HAVE_GI |
209 IEEE80211_RADIOTAP_MCS_HAVE_BW;
210 *pos = 0;
211 if (status->flag & RX_FLAG_SHORT_GI)
212 *pos |= IEEE80211_RADIOTAP_MCS_SGI;
213 if (status->flag & RX_FLAG_40MHZ)
214 *pos |= IEEE80211_RADIOTAP_MCS_BW_40;
215 pos++;
216 *pos++ = status->rate_idx;
217 }
Bruno Randolf601ae7f2008-05-08 19:22:43 +0200218}
219
Johannes Bergb2e77712007-09-26 15:19:39 +0200220/*
221 * This function copies a received frame to all monitor interfaces and
222 * returns a cleaned-up SKB that no longer includes the FCS nor the
223 * radiotap header the driver might have added.
224 */
225static struct sk_buff *
226ieee80211_rx_monitor(struct ieee80211_local *local, struct sk_buff *origskb,
Johannes Berg8318d782008-01-24 19:38:38 +0100227 struct ieee80211_rate *rate)
Johannes Bergb2e77712007-09-26 15:19:39 +0200228{
Johannes Bergf1d58c22009-06-17 13:13:00 +0200229 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(origskb);
Johannes Bergb2e77712007-09-26 15:19:39 +0200230 struct ieee80211_sub_if_data *sdata;
Johannes Berg293702a2012-03-02 13:18:19 +0100231 int needed_headroom;
Johannes Bergb2e77712007-09-26 15:19:39 +0200232 struct sk_buff *skb, *skb2;
233 struct net_device *prev_dev = NULL;
234 int present_fcs_len = 0;
Johannes Bergb2e77712007-09-26 15:19:39 +0200235
236 /*
237 * First, we may need to make a copy of the skb because
238 * (1) we need to modify it for radiotap (if not present), and
239 * (2) the other RX handlers will modify the skb we got.
240 *
241 * We don't need to, of course, if we aren't going to return
242 * the SKB because it has a bad FCS/PLCP checksum.
243 */
Johannes Berg0869aea2009-10-28 10:03:35 +0100244
245 /* room for the radiotap header based on driver features */
246 needed_headroom = ieee80211_rx_radiotap_len(local, status);
Johannes Bergb2e77712007-09-26 15:19:39 +0200247
248 if (local->hw.flags & IEEE80211_HW_RX_INCLUDES_FCS)
249 present_fcs_len = FCS_LEN;
250
Zhu Yie3cf8b32010-03-29 17:35:07 +0800251 /* make sure hdr->frame_control is on the linear part */
252 if (!pskb_may_pull(origskb, 2)) {
253 dev_kfree_skb(origskb);
254 return NULL;
255 }
256
Johannes Bergb2e77712007-09-26 15:19:39 +0200257 if (!local->monitors) {
Johannes Berg0869aea2009-10-28 10:03:35 +0100258 if (should_drop_frame(origskb, present_fcs_len)) {
Johannes Bergb2e77712007-09-26 15:19:39 +0200259 dev_kfree_skb(origskb);
260 return NULL;
261 }
262
Johannes Berg0869aea2009-10-28 10:03:35 +0100263 return remove_monitor_info(local, origskb);
Johannes Bergb2e77712007-09-26 15:19:39 +0200264 }
265
Johannes Berg0869aea2009-10-28 10:03:35 +0100266 if (should_drop_frame(origskb, present_fcs_len)) {
Johannes Bergb2e77712007-09-26 15:19:39 +0200267 /* only need to expand headroom if necessary */
268 skb = origskb;
269 origskb = NULL;
270
271 /*
272 * This shouldn't trigger often because most devices have an
273 * RX header they pull before we get here, and that should
274 * be big enough for our radiotap information. We should
275 * probably export the length to drivers so that we can have
276 * them allocate enough headroom to start with.
277 */
278 if (skb_headroom(skb) < needed_headroom &&
Johannes Bergc49e5ea2007-12-11 21:33:42 +0100279 pskb_expand_head(skb, needed_headroom, 0, GFP_ATOMIC)) {
Johannes Bergb2e77712007-09-26 15:19:39 +0200280 dev_kfree_skb(skb);
281 return NULL;
282 }
283 } else {
284 /*
285 * Need to make a copy and possibly remove radiotap header
286 * and FCS from the original.
287 */
288 skb = skb_copy_expand(origskb, needed_headroom, 0, GFP_ATOMIC);
289
Johannes Berg0869aea2009-10-28 10:03:35 +0100290 origskb = remove_monitor_info(local, origskb);
Johannes Bergb2e77712007-09-26 15:19:39 +0200291
292 if (!skb)
293 return origskb;
294 }
295
Johannes Berg0869aea2009-10-28 10:03:35 +0100296 /* prepend radiotap information */
297 ieee80211_add_rx_radiotap_header(local, skb, rate, needed_headroom);
Johannes Bergb2e77712007-09-26 15:19:39 +0200298
Johannes Bergce3edf6d02007-12-19 01:31:22 +0100299 skb_reset_mac_header(skb);
Johannes Bergb2e77712007-09-26 15:19:39 +0200300 skb->ip_summed = CHECKSUM_UNNECESSARY;
301 skb->pkt_type = PACKET_OTHERHOST;
302 skb->protocol = htons(ETH_P_802_2);
303
304 list_for_each_entry_rcu(sdata, &local->interfaces, list) {
Johannes Berg05c914f2008-09-11 00:01:58 +0200305 if (sdata->vif.type != NL80211_IFTYPE_MONITOR)
Johannes Bergb2e77712007-09-26 15:19:39 +0200306 continue;
307
Michael Wu3d30d942008-01-31 19:48:27 +0100308 if (sdata->u.mntr_flags & MONITOR_FLAG_COOK_FRAMES)
309 continue;
310
Johannes Berg9607e6b2009-12-23 13:15:31 +0100311 if (!ieee80211_sdata_running(sdata))
Johannes Berg47846c92009-11-25 17:46:19 +0100312 continue;
313
Johannes Bergb2e77712007-09-26 15:19:39 +0200314 if (prev_dev) {
315 skb2 = skb_clone(skb, GFP_ATOMIC);
316 if (skb2) {
317 skb2->dev = prev_dev;
John W. Linville5548a8a2010-06-24 14:25:56 -0400318 netif_receive_skb(skb2);
Johannes Bergb2e77712007-09-26 15:19:39 +0200319 }
320 }
321
322 prev_dev = sdata->dev;
323 sdata->dev->stats.rx_packets++;
324 sdata->dev->stats.rx_bytes += skb->len;
325 }
326
327 if (prev_dev) {
328 skb->dev = prev_dev;
John W. Linville5548a8a2010-06-24 14:25:56 -0400329 netif_receive_skb(skb);
Johannes Bergb2e77712007-09-26 15:19:39 +0200330 } else
331 dev_kfree_skb(skb);
332
333 return origskb;
334}
335
336
Johannes Berg5cf121c2008-02-25 16:27:43 +0100337static void ieee80211_parse_qos(struct ieee80211_rx_data *rx)
Johannes Berg6e0d1142007-07-27 15:43:22 +0200338{
Harvey Harrison238f74a2008-07-02 11:05:34 -0700339 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
Johannes Berg554891e2010-09-24 12:38:25 +0200340 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb);
Johannes Berg9e262972011-07-07 18:45:03 +0200341 int tid, seqno_idx, security_idx;
Johannes Berg6e0d1142007-07-27 15:43:22 +0200342
343 /* does the frame have a qos control field? */
Harvey Harrison238f74a2008-07-02 11:05:34 -0700344 if (ieee80211_is_data_qos(hdr->frame_control)) {
345 u8 *qc = ieee80211_get_qos_ctl(hdr);
Johannes Berg6e0d1142007-07-27 15:43:22 +0200346 /* frame has qos control */
Harvey Harrison238f74a2008-07-02 11:05:34 -0700347 tid = *qc & IEEE80211_QOS_CTL_TID_MASK;
Johannes Berg04b7dcf2011-06-22 10:06:59 +0200348 if (*qc & IEEE80211_QOS_CTL_A_MSDU_PRESENT)
Johannes Berg554891e2010-09-24 12:38:25 +0200349 status->rx_flags |= IEEE80211_RX_AMSDU;
Johannes Berg9e262972011-07-07 18:45:03 +0200350
351 seqno_idx = tid;
352 security_idx = tid;
Johannes Berg6e0d1142007-07-27 15:43:22 +0200353 } else {
Johannes Berg1411f9b2008-07-10 10:11:02 +0200354 /*
355 * IEEE 802.11-2007, 7.1.3.4.1 ("Sequence Number field"):
356 *
357 * Sequence numbers for management frames, QoS data
358 * frames with a broadcast/multicast address in the
359 * Address 1 field, and all non-QoS data frames sent
360 * by QoS STAs are assigned using an additional single
361 * modulo-4096 counter, [...]
362 *
363 * We also use that counter for non-QoS STAs.
364 */
Johannes Berg9e262972011-07-07 18:45:03 +0200365 seqno_idx = NUM_RX_DATA_QUEUES;
366 security_idx = 0;
367 if (ieee80211_is_mgmt(hdr->frame_control))
368 security_idx = NUM_RX_DATA_QUEUES;
369 tid = 0;
Johannes Berg6e0d1142007-07-27 15:43:22 +0200370 }
Johannes Berg52865dfd2007-07-27 15:43:22 +0200371
Johannes Berg9e262972011-07-07 18:45:03 +0200372 rx->seqno_idx = seqno_idx;
373 rx->security_idx = security_idx;
Johannes Berg6e0d1142007-07-27 15:43:22 +0200374 /* Set skb->priority to 1d tag if highest order bit of TID is not set.
375 * For now, set skb->priority to 0 for other cases. */
376 rx->skb->priority = (tid > 7) ? 0 : tid;
Johannes Berg38f37142008-01-29 17:07:43 +0100377}
Johannes Berg6e0d1142007-07-27 15:43:22 +0200378
Johannes Bergd1c3a372009-01-07 00:26:10 +0100379/**
380 * DOC: Packet alignment
381 *
382 * Drivers always need to pass packets that are aligned to two-byte boundaries
383 * to the stack.
384 *
385 * Additionally, should, if possible, align the payload data in a way that
386 * guarantees that the contained IP header is aligned to a four-byte
387 * boundary. In the case of regular frames, this simply means aligning the
388 * payload to a four-byte boundary (because either the IP header is directly
389 * contained, or IV/RFC1042 headers that have a length divisible by four are
Kalle Valo59d9cb02009-12-17 13:54:57 +0100390 * in front of it). If the payload data is not properly aligned and the
391 * architecture doesn't support efficient unaligned operations, mac80211
392 * will align the data.
Johannes Bergd1c3a372009-01-07 00:26:10 +0100393 *
394 * With A-MSDU frames, however, the payload data address must yield two modulo
395 * four because there are 14-byte 802.3 headers within the A-MSDU frames that
396 * push the IP header further back to a multiple of four again. Thankfully, the
397 * specs were sane enough this time around to require padding each A-MSDU
398 * subframe to a length that is a multiple of four.
399 *
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300400 * Padding like Atheros hardware adds which is between the 802.11 header and
Johannes Bergd1c3a372009-01-07 00:26:10 +0100401 * the payload is not supported, the driver is required to move the 802.11
402 * header to be directly in front of the payload in that case.
403 */
404static void ieee80211_verify_alignment(struct ieee80211_rx_data *rx)
Johannes Berg38f37142008-01-29 17:07:43 +0100405{
Kalle Valo59d9cb02009-12-17 13:54:57 +0100406#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
407 WARN_ONCE((unsigned long)rx->skb->data & 1,
408 "unaligned packet at 0x%p\n", rx->skb->data);
Johannes Bergd1c3a372009-01-07 00:26:10 +0100409#endif
Johannes Berg6e0d1142007-07-27 15:43:22 +0200410}
411
Ron Rindjunsky6368e4b2007-12-24 13:36:39 +0200412
Johannes Berg571ecf62007-07-27 15:43:22 +0200413/* rx handlers */
414
Johannes Berg49461622008-06-30 15:10:45 +0200415static ieee80211_rx_result debug_noinline
Johannes Berg5cf121c2008-02-25 16:27:43 +0100416ieee80211_rx_h_passive_scan(struct ieee80211_rx_data *rx)
Johannes Berg571ecf62007-07-27 15:43:22 +0200417{
418 struct ieee80211_local *local = rx->local;
Johannes Berg554891e2010-09-24 12:38:25 +0200419 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb);
Johannes Berg571ecf62007-07-27 15:43:22 +0200420 struct sk_buff *skb = rx->skb;
421
Luciano Coelho79f460c2011-05-11 17:09:36 +0300422 if (likely(!(status->rx_flags & IEEE80211_RX_IN_SCAN) &&
423 !local->sched_scanning))
Johannes Berg4080c7c2010-09-24 11:21:08 +0200424 return RX_CONTINUE;
425
Ben Greearb23b0252011-02-04 11:54:17 -0800426 if (test_bit(SCAN_HW_SCANNING, &local->scanning) ||
Luciano Coelho79f460c2011-05-11 17:09:36 +0300427 test_bit(SCAN_SW_SCANNING, &local->scanning) ||
428 local->sched_scanning)
Johannes Bergf1d58c22009-06-17 13:13:00 +0200429 return ieee80211_scan_rx(rx->sdata, skb);
Zhu Yiece8edd2007-11-22 10:53:21 +0800430
Johannes Berg4080c7c2010-09-24 11:21:08 +0200431 /* scanning finished during invoking of handlers */
432 I802_DEBUG_INC(local->rx_handlers_drop_passive_scan);
433 return RX_DROP_UNUSABLE;
Johannes Berg571ecf62007-07-27 15:43:22 +0200434}
435
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +0200436
437static int ieee80211_is_unicast_robust_mgmt_frame(struct sk_buff *skb)
438{
439 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
440
441 if (skb->len < 24 || is_multicast_ether_addr(hdr->addr1))
442 return 0;
443
444 return ieee80211_is_robust_mgmt_frame(hdr);
445}
446
447
448static int ieee80211_is_multicast_robust_mgmt_frame(struct sk_buff *skb)
449{
450 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
451
452 if (skb->len < 24 || !is_multicast_ether_addr(hdr->addr1))
453 return 0;
454
455 return ieee80211_is_robust_mgmt_frame(hdr);
456}
457
458
459/* Get the BIP key index from MMIE; return -1 if this is not a BIP frame */
460static int ieee80211_get_mmie_keyidx(struct sk_buff *skb)
461{
462 struct ieee80211_mgmt *hdr = (struct ieee80211_mgmt *) skb->data;
463 struct ieee80211_mmie *mmie;
464
465 if (skb->len < 24 + sizeof(*mmie) ||
466 !is_multicast_ether_addr(hdr->da))
467 return -1;
468
469 if (!ieee80211_is_robust_mgmt_frame((struct ieee80211_hdr *) hdr))
470 return -1; /* not a robust management frame */
471
472 mmie = (struct ieee80211_mmie *)
473 (skb->data + skb->len - sizeof(*mmie));
474 if (mmie->element_id != WLAN_EID_MMIE ||
475 mmie->length != sizeof(*mmie) - 2)
476 return -1;
477
478 return le16_to_cpu(mmie->key_id);
479}
480
481
Luis Carlos Cobo33b64eb2008-02-23 15:17:10 +0100482static ieee80211_rx_result
Johannes Berg5cf121c2008-02-25 16:27:43 +0100483ieee80211_rx_mesh_check(struct ieee80211_rx_data *rx)
Luis Carlos Cobo33b64eb2008-02-23 15:17:10 +0100484{
Harvey Harrisona7767f92008-07-02 16:30:51 -0700485 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
Johannes Berg47846c92009-11-25 17:46:19 +0100486 char *dev_addr = rx->sdata->vif.addr;
Johannes Bergd6d1a5a2008-02-25 16:24:38 +0100487
Harvey Harrisona7767f92008-07-02 16:30:51 -0700488 if (ieee80211_is_data(hdr->frame_control)) {
Javier Cardona3c5772a2009-08-10 12:15:48 -0700489 if (is_multicast_ether_addr(hdr->addr1)) {
490 if (ieee80211_has_tods(hdr->frame_control) ||
491 !ieee80211_has_fromds(hdr->frame_control))
492 return RX_DROP_MONITOR;
Felix Fietkau888d04d2012-03-01 15:22:09 +0100493 if (compare_ether_addr(hdr->addr3, dev_addr) == 0)
Javier Cardona3c5772a2009-08-10 12:15:48 -0700494 return RX_DROP_MONITOR;
495 } else {
496 if (!ieee80211_has_a4(hdr->frame_control))
497 return RX_DROP_MONITOR;
Felix Fietkau888d04d2012-03-01 15:22:09 +0100498 if (compare_ether_addr(hdr->addr4, dev_addr) == 0)
Javier Cardona3c5772a2009-08-10 12:15:48 -0700499 return RX_DROP_MONITOR;
500 }
Luis Carlos Cobo33b64eb2008-02-23 15:17:10 +0100501 }
502
503 /* If there is not an established peer link and this is not a peer link
504 * establisment frame, beacon or probe, drop the frame.
505 */
506
Javier Cardona57cf8042011-05-13 10:45:43 -0700507 if (!rx->sta || sta_plink_state(rx->sta) != NL80211_PLINK_ESTAB) {
Luis Carlos Cobo33b64eb2008-02-23 15:17:10 +0100508 struct ieee80211_mgmt *mgmt;
Johannes Bergd6d1a5a2008-02-25 16:24:38 +0100509
Harvey Harrisona7767f92008-07-02 16:30:51 -0700510 if (!ieee80211_is_mgmt(hdr->frame_control))
Luis Carlos Cobo33b64eb2008-02-23 15:17:10 +0100511 return RX_DROP_MONITOR;
512
Harvey Harrisona7767f92008-07-02 16:30:51 -0700513 if (ieee80211_is_action(hdr->frame_control)) {
Javier Cardonad3aaec8a2011-05-03 16:57:09 -0700514 u8 category;
Luis Carlos Cobo33b64eb2008-02-23 15:17:10 +0100515 mgmt = (struct ieee80211_mgmt *)hdr;
Javier Cardonad3aaec8a2011-05-03 16:57:09 -0700516 category = mgmt->u.action.category;
517 if (category != WLAN_CATEGORY_MESH_ACTION &&
518 category != WLAN_CATEGORY_SELF_PROTECTED)
Luis Carlos Cobo33b64eb2008-02-23 15:17:10 +0100519 return RX_DROP_MONITOR;
Luis Carlos Cobo33b64eb2008-02-23 15:17:10 +0100520 return RX_CONTINUE;
Luis Carlos Cobo33b64eb2008-02-23 15:17:10 +0100521 }
522
Harvey Harrisona7767f92008-07-02 16:30:51 -0700523 if (ieee80211_is_probe_req(hdr->frame_control) ||
524 ieee80211_is_probe_resp(hdr->frame_control) ||
Javier Cardona71839122011-04-07 15:08:31 -0700525 ieee80211_is_beacon(hdr->frame_control) ||
526 ieee80211_is_auth(hdr->frame_control))
Harvey Harrisona7767f92008-07-02 16:30:51 -0700527 return RX_CONTINUE;
528
529 return RX_DROP_MONITOR;
530
531 }
532
Johannes Berg902acc72008-02-23 15:17:19 +0100533 return RX_CONTINUE;
534}
Luis Carlos Cobo33b64eb2008-02-23 15:17:10 +0100535
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100536#define SEQ_MODULO 0x1000
537#define SEQ_MASK 0xfff
538
539static inline int seq_less(u16 sq1, u16 sq2)
540{
541 return ((sq1 - sq2) & SEQ_MASK) > (SEQ_MODULO >> 1);
542}
543
544static inline u16 seq_inc(u16 sq)
545{
546 return (sq + 1) & SEQ_MASK;
547}
548
549static inline u16 seq_sub(u16 sq1, u16 sq2)
550{
551 return (sq1 - sq2) & SEQ_MASK;
552}
553
554
555static void ieee80211_release_reorder_frame(struct ieee80211_hw *hw,
556 struct tid_ampdu_rx *tid_agg_rx,
Christian Lamparter24a8fda2010-12-30 17:25:29 +0100557 int index)
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100558{
Christian Lamparter24a8fda2010-12-30 17:25:29 +0100559 struct ieee80211_local *local = hw_to_local(hw);
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100560 struct sk_buff *skb = tid_agg_rx->reorder_buf[index];
Christian Lamparter4cfda472010-12-27 23:21:26 +0100561 struct ieee80211_rx_status *status;
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100562
Johannes Bergdd318572010-11-29 11:09:16 +0100563 lockdep_assert_held(&tid_agg_rx->reorder_lock);
564
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100565 if (!skb)
566 goto no_frame;
567
Christian Lamparter071d9ac2010-08-05 01:36:36 +0200568 /* release the frame from the reorder ring buffer */
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100569 tid_agg_rx->stored_mpdu_num--;
570 tid_agg_rx->reorder_buf[index] = NULL;
Christian Lamparter4cfda472010-12-27 23:21:26 +0100571 status = IEEE80211_SKB_RXCB(skb);
572 status->rx_flags |= IEEE80211_RX_DEFERRED_RELEASE;
Christian Lamparter24a8fda2010-12-30 17:25:29 +0100573 skb_queue_tail(&local->rx_skb_queue, skb);
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100574
575no_frame:
576 tid_agg_rx->head_seq_num = seq_inc(tid_agg_rx->head_seq_num);
577}
578
579static void ieee80211_release_reorder_frames(struct ieee80211_hw *hw,
580 struct tid_ampdu_rx *tid_agg_rx,
Christian Lamparter24a8fda2010-12-30 17:25:29 +0100581 u16 head_seq_num)
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100582{
583 int index;
584
Johannes Bergdd318572010-11-29 11:09:16 +0100585 lockdep_assert_held(&tid_agg_rx->reorder_lock);
586
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100587 while (seq_less(tid_agg_rx->head_seq_num, head_seq_num)) {
588 index = seq_sub(tid_agg_rx->head_seq_num, tid_agg_rx->ssn) %
589 tid_agg_rx->buf_size;
Christian Lamparter24a8fda2010-12-30 17:25:29 +0100590 ieee80211_release_reorder_frame(hw, tid_agg_rx, index);
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100591 }
592}
593
594/*
595 * Timeout (in jiffies) for skb's that are waiting in the RX reorder buffer. If
596 * the skb was added to the buffer longer than this time ago, the earlier
597 * frames that have not yet been received are assumed to be lost and the skb
598 * can be released for processing. This may also release other skb's from the
599 * reorder buffer if there are no additional gaps between the frames.
Christian Lamparter2bff8eb2010-08-05 01:36:41 +0200600 *
601 * Callers must hold tid_agg_rx->reorder_lock.
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100602 */
603#define HT_RX_REORDER_BUF_TIMEOUT (HZ / 10)
604
Christian Lamparteraa0c8632010-08-05 01:36:04 +0200605static void ieee80211_sta_reorder_release(struct ieee80211_hw *hw,
Christian Lamparter24a8fda2010-12-30 17:25:29 +0100606 struct tid_ampdu_rx *tid_agg_rx)
Christian Lamparteraa0c8632010-08-05 01:36:04 +0200607{
Christian Lamparter2bff8eb2010-08-05 01:36:41 +0200608 int index, j;
Christian Lamparteraa0c8632010-08-05 01:36:04 +0200609
Johannes Bergdd318572010-11-29 11:09:16 +0100610 lockdep_assert_held(&tid_agg_rx->reorder_lock);
611
Christian Lamparteraa0c8632010-08-05 01:36:04 +0200612 /* release the buffer until next missing frame */
613 index = seq_sub(tid_agg_rx->head_seq_num, tid_agg_rx->ssn) %
614 tid_agg_rx->buf_size;
615 if (!tid_agg_rx->reorder_buf[index] &&
Eliad Peller07ae2df2012-02-01 18:48:09 +0200616 tid_agg_rx->stored_mpdu_num) {
Christian Lamparteraa0c8632010-08-05 01:36:04 +0200617 /*
618 * No buffers ready to be released, but check whether any
619 * frames in the reorder buffer have timed out.
620 */
Christian Lamparteraa0c8632010-08-05 01:36:04 +0200621 int skipped = 1;
622 for (j = (index + 1) % tid_agg_rx->buf_size; j != index;
623 j = (j + 1) % tid_agg_rx->buf_size) {
624 if (!tid_agg_rx->reorder_buf[j]) {
625 skipped++;
626 continue;
627 }
Daniel Halperin499fe9a2011-03-24 16:01:48 -0700628 if (skipped &&
629 !time_after(jiffies, tid_agg_rx->reorder_time[j] +
Christian Lamparteraa0c8632010-08-05 01:36:04 +0200630 HT_RX_REORDER_BUF_TIMEOUT))
Christian Lamparter2bff8eb2010-08-05 01:36:41 +0200631 goto set_release_timer;
Christian Lamparteraa0c8632010-08-05 01:36:04 +0200632
633#ifdef CONFIG_MAC80211_HT_DEBUG
634 if (net_ratelimit())
Joe Perches0fb9a9e2010-08-20 16:25:38 -0700635 wiphy_debug(hw->wiphy,
636 "release an RX reorder frame due to timeout on earlier frames\n");
Christian Lamparteraa0c8632010-08-05 01:36:04 +0200637#endif
Christian Lamparter24a8fda2010-12-30 17:25:29 +0100638 ieee80211_release_reorder_frame(hw, tid_agg_rx, j);
Christian Lamparteraa0c8632010-08-05 01:36:04 +0200639
640 /*
641 * Increment the head seq# also for the skipped slots.
642 */
643 tid_agg_rx->head_seq_num =
644 (tid_agg_rx->head_seq_num + skipped) & SEQ_MASK;
645 skipped = 0;
646 }
647 } else while (tid_agg_rx->reorder_buf[index]) {
Christian Lamparter24a8fda2010-12-30 17:25:29 +0100648 ieee80211_release_reorder_frame(hw, tid_agg_rx, index);
Christian Lamparteraa0c8632010-08-05 01:36:04 +0200649 index = seq_sub(tid_agg_rx->head_seq_num, tid_agg_rx->ssn) %
650 tid_agg_rx->buf_size;
651 }
Christian Lamparter2bff8eb2010-08-05 01:36:41 +0200652
653 if (tid_agg_rx->stored_mpdu_num) {
654 j = index = seq_sub(tid_agg_rx->head_seq_num,
655 tid_agg_rx->ssn) % tid_agg_rx->buf_size;
656
657 for (; j != (index - 1) % tid_agg_rx->buf_size;
658 j = (j + 1) % tid_agg_rx->buf_size) {
659 if (tid_agg_rx->reorder_buf[j])
660 break;
661 }
662
663 set_release_timer:
664
665 mod_timer(&tid_agg_rx->reorder_timer,
Christian Lamparter334df732011-04-24 20:41:16 +0200666 tid_agg_rx->reorder_time[j] + 1 +
Christian Lamparter2bff8eb2010-08-05 01:36:41 +0200667 HT_RX_REORDER_BUF_TIMEOUT);
668 } else {
669 del_timer(&tid_agg_rx->reorder_timer);
670 }
Christian Lamparteraa0c8632010-08-05 01:36:04 +0200671}
672
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100673/*
674 * As this function belongs to the RX path it must be under
675 * rcu_read_lock protection. It returns false if the frame
676 * can be processed immediately, true if it was consumed.
677 */
678static bool ieee80211_sta_manage_reorder_buf(struct ieee80211_hw *hw,
679 struct tid_ampdu_rx *tid_agg_rx,
Christian Lamparter24a8fda2010-12-30 17:25:29 +0100680 struct sk_buff *skb)
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100681{
682 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
683 u16 sc = le16_to_cpu(hdr->seq_ctrl);
684 u16 mpdu_seq_num = (sc & IEEE80211_SCTL_SEQ) >> 4;
685 u16 head_seq_num, buf_size;
686 int index;
Christian Lamparter2bff8eb2010-08-05 01:36:41 +0200687 bool ret = true;
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100688
Johannes Bergdd318572010-11-29 11:09:16 +0100689 spin_lock(&tid_agg_rx->reorder_lock);
690
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100691 buf_size = tid_agg_rx->buf_size;
692 head_seq_num = tid_agg_rx->head_seq_num;
693
694 /* frame with out of date sequence number */
695 if (seq_less(mpdu_seq_num, head_seq_num)) {
696 dev_kfree_skb(skb);
Christian Lamparter2bff8eb2010-08-05 01:36:41 +0200697 goto out;
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100698 }
699
700 /*
701 * If frame the sequence number exceeds our buffering window
702 * size release some previous frames to make room for this one.
703 */
704 if (!seq_less(mpdu_seq_num, head_seq_num + buf_size)) {
705 head_seq_num = seq_inc(seq_sub(mpdu_seq_num, buf_size));
706 /* release stored frames up to new head to stack */
Christian Lamparter24a8fda2010-12-30 17:25:29 +0100707 ieee80211_release_reorder_frames(hw, tid_agg_rx, head_seq_num);
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100708 }
709
710 /* Now the new frame is always in the range of the reordering buffer */
711
712 index = seq_sub(mpdu_seq_num, tid_agg_rx->ssn) % tid_agg_rx->buf_size;
713
714 /* check if we already stored this frame */
715 if (tid_agg_rx->reorder_buf[index]) {
716 dev_kfree_skb(skb);
Christian Lamparter2bff8eb2010-08-05 01:36:41 +0200717 goto out;
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100718 }
719
720 /*
721 * If the current MPDU is in the right order and nothing else
722 * is stored we can process it directly, no need to buffer it.
Johannes Bergc835b212011-03-15 23:17:01 +0100723 * If it is first but there's something stored, we may be able
724 * to release frames after this one.
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100725 */
726 if (mpdu_seq_num == tid_agg_rx->head_seq_num &&
727 tid_agg_rx->stored_mpdu_num == 0) {
728 tid_agg_rx->head_seq_num = seq_inc(tid_agg_rx->head_seq_num);
Christian Lamparter2bff8eb2010-08-05 01:36:41 +0200729 ret = false;
730 goto out;
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100731 }
732
733 /* put the frame in the reordering buffer */
734 tid_agg_rx->reorder_buf[index] = skb;
735 tid_agg_rx->reorder_time[index] = jiffies;
736 tid_agg_rx->stored_mpdu_num++;
Christian Lamparter24a8fda2010-12-30 17:25:29 +0100737 ieee80211_sta_reorder_release(hw, tid_agg_rx);
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100738
Christian Lamparter2bff8eb2010-08-05 01:36:41 +0200739 out:
740 spin_unlock(&tid_agg_rx->reorder_lock);
741 return ret;
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100742}
743
744/*
745 * Reorder MPDUs from A-MPDUs, keeping them on a buffer. Returns
746 * true if the MPDU was buffered, false if it should be processed.
747 */
Christian Lamparter24a8fda2010-12-30 17:25:29 +0100748static void ieee80211_rx_reorder_ampdu(struct ieee80211_rx_data *rx)
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100749{
Johannes Berg2569a822009-11-25 17:46:17 +0100750 struct sk_buff *skb = rx->skb;
751 struct ieee80211_local *local = rx->local;
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100752 struct ieee80211_hw *hw = &local->hw;
753 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
Thomas Pedersen660c6a42011-11-03 21:11:12 -0700754 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
Johannes Berg2569a822009-11-25 17:46:17 +0100755 struct sta_info *sta = rx->sta;
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100756 struct tid_ampdu_rx *tid_agg_rx;
757 u16 sc;
Thomas Pedersen6cc00d52011-11-03 21:11:11 -0700758 u8 tid, ack_policy;
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100759
760 if (!ieee80211_is_data_qos(hdr->frame_control))
Johannes Berg2569a822009-11-25 17:46:17 +0100761 goto dont_reorder;
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100762
763 /*
764 * filter the QoS data rx stream according to
765 * STA/TID and check if this STA/TID is on aggregation
766 */
767
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100768 if (!sta)
Johannes Berg2569a822009-11-25 17:46:17 +0100769 goto dont_reorder;
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100770
Thomas Pedersen6cc00d52011-11-03 21:11:11 -0700771 ack_policy = *ieee80211_get_qos_ctl(hdr) &
772 IEEE80211_QOS_CTL_ACK_POLICY_MASK;
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100773 tid = *ieee80211_get_qos_ctl(hdr) & IEEE80211_QOS_CTL_TID_MASK;
774
Johannes Berga87f7362010-06-10 10:21:38 +0200775 tid_agg_rx = rcu_dereference(sta->ampdu_mlme.tid_rx[tid]);
776 if (!tid_agg_rx)
777 goto dont_reorder;
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100778
779 /* qos null data frames are excluded */
780 if (unlikely(hdr->frame_control & cpu_to_le16(IEEE80211_STYPE_NULLFUNC)))
Johannes Berga87f7362010-06-10 10:21:38 +0200781 goto dont_reorder;
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100782
Thomas Pedersen6cc00d52011-11-03 21:11:11 -0700783 /* not part of a BA session */
784 if (ack_policy != IEEE80211_QOS_CTL_ACK_POLICY_BLOCKACK &&
785 ack_policy != IEEE80211_QOS_CTL_ACK_POLICY_NORMAL)
786 goto dont_reorder;
787
Thomas Pedersen660c6a42011-11-03 21:11:12 -0700788 /* not actually part of this BA session */
789 if (!(status->rx_flags & IEEE80211_RX_RA_MATCH))
790 goto dont_reorder;
791
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100792 /* new, potentially un-ordered, ampdu frame - process it */
793
794 /* reset session timer */
795 if (tid_agg_rx->timeout)
796 mod_timer(&tid_agg_rx->session_timer,
797 TU_TO_EXP_TIME(tid_agg_rx->timeout));
798
799 /* if this mpdu is fragmented - terminate rx aggregation session */
800 sc = le16_to_cpu(hdr->seq_ctrl);
801 if (sc & IEEE80211_SCTL_FRAG) {
Johannes Bergc1475ca2010-06-10 10:21:37 +0200802 skb->pkt_type = IEEE80211_SDATA_QUEUE_TYPE_FRAME;
Johannes Berg344eec62010-06-10 10:21:36 +0200803 skb_queue_tail(&rx->sdata->skb_queue, skb);
804 ieee80211_queue_work(&local->hw, &rx->sdata->work);
Johannes Berg2569a822009-11-25 17:46:17 +0100805 return;
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100806 }
807
Johannes Berga87f7362010-06-10 10:21:38 +0200808 /*
809 * No locking needed -- we will only ever process one
810 * RX packet at a time, and thus own tid_agg_rx. All
811 * other code manipulating it needs to (and does) make
812 * sure that we cannot get to it any more before doing
813 * anything with it.
814 */
Christian Lamparter24a8fda2010-12-30 17:25:29 +0100815 if (ieee80211_sta_manage_reorder_buf(hw, tid_agg_rx, skb))
Johannes Berg2569a822009-11-25 17:46:17 +0100816 return;
817
818 dont_reorder:
Christian Lamparter24a8fda2010-12-30 17:25:29 +0100819 skb_queue_tail(&local->rx_skb_queue, skb);
Johannes Berg1edfb1a2009-11-25 17:46:16 +0100820}
Luis Carlos Cobo33b64eb2008-02-23 15:17:10 +0100821
Johannes Berg49461622008-06-30 15:10:45 +0200822static ieee80211_rx_result debug_noinline
Johannes Berg5cf121c2008-02-25 16:27:43 +0100823ieee80211_rx_h_check(struct ieee80211_rx_data *rx)
Johannes Berg571ecf62007-07-27 15:43:22 +0200824{
Harvey Harrisona7767f92008-07-02 16:30:51 -0700825 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
Johannes Berg554891e2010-09-24 12:38:25 +0200826 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb);
Johannes Berg571ecf62007-07-27 15:43:22 +0200827
828 /* Drop duplicate 802.11 retransmissions (IEEE 802.11 Chap. 9.2.9) */
829 if (rx->sta && !is_multicast_ether_addr(hdr->addr1)) {
Harvey Harrisona7767f92008-07-02 16:30:51 -0700830 if (unlikely(ieee80211_has_retry(hdr->frame_control) &&
Johannes Berg9e262972011-07-07 18:45:03 +0200831 rx->sta->last_seq_ctrl[rx->seqno_idx] ==
Johannes Berg571ecf62007-07-27 15:43:22 +0200832 hdr->seq_ctrl)) {
Johannes Berg554891e2010-09-24 12:38:25 +0200833 if (status->rx_flags & IEEE80211_RX_RA_MATCH) {
Johannes Berg571ecf62007-07-27 15:43:22 +0200834 rx->local->dot11FrameDuplicateCount++;
835 rx->sta->num_duplicates++;
836 }
Felix Fietkaub1f93312011-02-04 19:20:08 +0100837 return RX_DROP_UNUSABLE;
Johannes Berg571ecf62007-07-27 15:43:22 +0200838 } else
Johannes Berg9e262972011-07-07 18:45:03 +0200839 rx->sta->last_seq_ctrl[rx->seqno_idx] = hdr->seq_ctrl;
Johannes Berg571ecf62007-07-27 15:43:22 +0200840 }
841
Johannes Berg571ecf62007-07-27 15:43:22 +0200842 if (unlikely(rx->skb->len < 16)) {
843 I802_DEBUG_INC(rx->local->rx_handlers_drop_short);
Johannes Berge4c26ad2008-01-31 19:48:21 +0100844 return RX_DROP_MONITOR;
Johannes Berg571ecf62007-07-27 15:43:22 +0200845 }
846
Johannes Berg571ecf62007-07-27 15:43:22 +0200847 /* Drop disallowed frame classes based on STA auth/assoc state;
848 * IEEE 802.11, Chap 5.5.
849 *
Johannes Bergccd7b362008-09-11 00:01:56 +0200850 * mac80211 filters only based on association state, i.e. it drops
851 * Class 3 frames from not associated stations. hostapd sends
Johannes Berg571ecf62007-07-27 15:43:22 +0200852 * deauth/disassoc frames when needed. In addition, hostapd is
853 * responsible for filtering on both auth and assoc states.
854 */
Luis Carlos Cobo33b64eb2008-02-23 15:17:10 +0100855
Johannes Berg902acc72008-02-23 15:17:19 +0100856 if (ieee80211_vif_is_mesh(&rx->sdata->vif))
Luis Carlos Cobo33b64eb2008-02-23 15:17:10 +0100857 return ieee80211_rx_mesh_check(rx);
Luis Carlos Cobo33b64eb2008-02-23 15:17:10 +0100858
Harvey Harrisona7767f92008-07-02 16:30:51 -0700859 if (unlikely((ieee80211_is_data(hdr->frame_control) ||
860 ieee80211_is_pspoll(hdr->frame_control)) &&
Johannes Berg05c914f2008-09-11 00:01:58 +0200861 rx->sdata->vif.type != NL80211_IFTYPE_ADHOC &&
Bill Jordan1be7fe82010-10-01 11:20:41 -0400862 rx->sdata->vif.type != NL80211_IFTYPE_WDS &&
Johannes Bergc2c98fd2011-09-29 16:04:36 +0200863 (!rx->sta || !test_sta_flag(rx->sta, WLAN_STA_ASSOC)))) {
Johannes Berg7852e362012-01-20 13:55:24 +0100864 /*
865 * accept port control frames from the AP even when it's not
866 * yet marked ASSOC to prevent a race where we don't set the
867 * assoc bit quickly enough before it sends the first frame
868 */
869 if (rx->sta && rx->sdata->vif.type == NL80211_IFTYPE_STATION &&
Guy Eilam2a33bee2011-08-17 15:18:15 +0300870 ieee80211_is_data_present(hdr->frame_control)) {
871 u16 ethertype;
872 u8 *payload;
873
874 payload = rx->skb->data +
875 ieee80211_hdrlen(hdr->frame_control);
876 ethertype = (payload[6] << 8) | payload[7];
877 if (cpu_to_be16(ethertype) ==
878 rx->sdata->control_port_protocol)
879 return RX_CONTINUE;
880 }
Johannes Berg21fc7562011-11-04 11:18:13 +0100881
882 if (rx->sdata->vif.type == NL80211_IFTYPE_AP &&
883 cfg80211_rx_spurious_frame(rx->sdata->dev,
884 hdr->addr2,
885 GFP_ATOMIC))
886 return RX_DROP_UNUSABLE;
887
Johannes Berge4c26ad2008-01-31 19:48:21 +0100888 return RX_DROP_MONITOR;
Guy Eilam2a33bee2011-08-17 15:18:15 +0300889 }
Johannes Berg571ecf62007-07-27 15:43:22 +0200890
Johannes Berg9ae54c82008-01-31 19:48:20 +0100891 return RX_CONTINUE;
Johannes Berg570bd532007-07-27 15:43:22 +0200892}
893
894
Johannes Berg49461622008-06-30 15:10:45 +0200895static ieee80211_rx_result debug_noinline
Johannes Berg5cf121c2008-02-25 16:27:43 +0100896ieee80211_rx_h_decrypt(struct ieee80211_rx_data *rx)
Johannes Berg570bd532007-07-27 15:43:22 +0200897{
Johannes Bergeb9fb5b2009-11-16 13:58:20 +0100898 struct sk_buff *skb = rx->skb;
899 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
900 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
Johannes Berg3017b802007-08-28 17:01:53 -0400901 int keyidx;
902 int hdrlen;
Johannes Berge4c26ad2008-01-31 19:48:21 +0100903 ieee80211_rx_result result = RX_DROP_UNUSABLE;
Johannes Berge31b8212010-10-05 19:39:30 +0200904 struct ieee80211_key *sta_ptk = NULL;
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +0200905 int mmie_keyidx = -1;
Johannes Berg761ab472010-05-28 14:24:19 +0200906 __le16 fc;
Johannes Berg570bd532007-07-27 15:43:22 +0200907
Johannes Berg3017b802007-08-28 17:01:53 -0400908 /*
909 * Key selection 101
910 *
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +0200911 * There are four types of keys:
Johannes Berg3017b802007-08-28 17:01:53 -0400912 * - GTK (group keys)
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +0200913 * - IGTK (group keys for management frames)
Johannes Berg3017b802007-08-28 17:01:53 -0400914 * - PTK (pairwise keys)
915 * - STK (station-to-station pairwise keys)
916 *
917 * When selecting a key, we have to distinguish between multicast
918 * (including broadcast) and unicast frames, the latter can only
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +0200919 * use PTKs and STKs while the former always use GTKs and IGTKs.
920 * Unless, of course, actual WEP keys ("pre-RSNA") are used, then
921 * unicast frames can also use key indices like GTKs. Hence, if we
922 * don't have a PTK/STK we check the key index for a WEP key.
Johannes Berg3017b802007-08-28 17:01:53 -0400923 *
Johannes Berg8dc06a12007-08-28 17:01:55 -0400924 * Note that in a regular BSS, multicast frames are sent by the
925 * AP only, associated stations unicast the frame to the AP first
926 * which then multicasts it on their behalf.
927 *
Johannes Berg3017b802007-08-28 17:01:53 -0400928 * There is also a slight problem in IBSS mode: GTKs are negotiated
929 * with each station, that is something we don't currently handle.
Johannes Berg8dc06a12007-08-28 17:01:55 -0400930 * The spec seems to expect that one negotiates the same key with
931 * every station but there's no such requirement; VLANs could be
932 * possible.
Johannes Berg3017b802007-08-28 17:01:53 -0400933 */
Johannes Berg571ecf62007-07-27 15:43:22 +0200934
Johannes Berg3017b802007-08-28 17:01:53 -0400935 /*
Johannes Berg1990af82007-09-26 17:53:15 +0200936 * No point in finding a key and decrypting if the frame is neither
Johannes Berg3017b802007-08-28 17:01:53 -0400937 * addressed to us nor a multicast frame.
938 */
Johannes Berg554891e2010-09-24 12:38:25 +0200939 if (!(status->rx_flags & IEEE80211_RX_RA_MATCH))
Johannes Berg9ae54c82008-01-31 19:48:20 +0100940 return RX_CONTINUE;
Johannes Berg3017b802007-08-28 17:01:53 -0400941
Johannes Berg2569a822009-11-25 17:46:17 +0100942 /* start without a key */
943 rx->key = NULL;
944
Johannes Bergd4e46a32007-09-14 11:10:24 -0400945 if (rx->sta)
Johannes Berge31b8212010-10-05 19:39:30 +0200946 sta_ptk = rcu_dereference(rx->sta->ptk);
Johannes Bergd4e46a32007-09-14 11:10:24 -0400947
Johannes Berg761ab472010-05-28 14:24:19 +0200948 fc = hdr->frame_control;
949
950 if (!ieee80211_has_protected(fc))
Jouni Malinen0c7c10c2009-05-08 12:34:10 +0300951 mmie_keyidx = ieee80211_get_mmie_keyidx(rx->skb);
952
Johannes Berge31b8212010-10-05 19:39:30 +0200953 if (!is_multicast_ether_addr(hdr->addr1) && sta_ptk) {
954 rx->key = sta_ptk;
Johannes Bergdc1580d2010-08-10 09:46:40 +0200955 if ((status->flag & RX_FLAG_DECRYPTED) &&
956 (status->flag & RX_FLAG_IV_STRIPPED))
957 return RX_CONTINUE;
Jouni Malinen0c7c10c2009-05-08 12:34:10 +0300958 /* Skip decryption if the frame is not protected. */
Johannes Berg761ab472010-05-28 14:24:19 +0200959 if (!ieee80211_has_protected(fc))
Jouni Malinen0c7c10c2009-05-08 12:34:10 +0300960 return RX_CONTINUE;
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +0200961 } else if (mmie_keyidx >= 0) {
962 /* Broadcast/multicast robust management frame / BIP */
Johannes Bergeb9fb5b2009-11-16 13:58:20 +0100963 if ((status->flag & RX_FLAG_DECRYPTED) &&
964 (status->flag & RX_FLAG_IV_STRIPPED))
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +0200965 return RX_CONTINUE;
966
967 if (mmie_keyidx < NUM_DEFAULT_KEYS ||
968 mmie_keyidx >= NUM_DEFAULT_KEYS + NUM_DEFAULT_MGMT_KEYS)
969 return RX_DROP_MONITOR; /* unexpected BIP keyidx */
Johannes Berge31b8212010-10-05 19:39:30 +0200970 if (rx->sta)
971 rx->key = rcu_dereference(rx->sta->gtk[mmie_keyidx]);
972 if (!rx->key)
973 rx->key = rcu_dereference(rx->sdata->keys[mmie_keyidx]);
Johannes Berg761ab472010-05-28 14:24:19 +0200974 } else if (!ieee80211_has_protected(fc)) {
Jouni Malinen0c7c10c2009-05-08 12:34:10 +0300975 /*
976 * The frame was not protected, so skip decryption. However, we
977 * need to set rx->key if there is a key that could have been
978 * used so that the frame may be dropped if encryption would
979 * have been expected.
980 */
981 struct ieee80211_key *key = NULL;
Johannes Berg897bed82010-12-09 19:49:00 +0100982 struct ieee80211_sub_if_data *sdata = rx->sdata;
983 int i;
984
Johannes Berg761ab472010-05-28 14:24:19 +0200985 if (ieee80211_is_mgmt(fc) &&
Jouni Malinen0c7c10c2009-05-08 12:34:10 +0300986 is_multicast_ether_addr(hdr->addr1) &&
987 (key = rcu_dereference(rx->sdata->default_mgmt_key)))
988 rx->key = key;
Johannes Berg897bed82010-12-09 19:49:00 +0100989 else {
990 if (rx->sta) {
991 for (i = 0; i < NUM_DEFAULT_KEYS; i++) {
992 key = rcu_dereference(rx->sta->gtk[i]);
993 if (key)
994 break;
995 }
996 }
997 if (!key) {
998 for (i = 0; i < NUM_DEFAULT_KEYS; i++) {
999 key = rcu_dereference(sdata->keys[i]);
1000 if (key)
1001 break;
1002 }
1003 }
1004 if (key)
1005 rx->key = key;
1006 }
Jouni Malinen0c7c10c2009-05-08 12:34:10 +03001007 return RX_CONTINUE;
Johannes Berg571ecf62007-07-27 15:43:22 +02001008 } else {
Zhu Yi39184b12010-04-08 15:35:10 +08001009 u8 keyid;
Johannes Berg3017b802007-08-28 17:01:53 -04001010 /*
1011 * The device doesn't give us the IV so we won't be
1012 * able to look up the key. That's ok though, we
1013 * don't need to decrypt the frame, we just won't
1014 * be able to keep statistics accurate.
1015 * Except for key threshold notifications, should
1016 * we somehow allow the driver to tell us which key
1017 * the hardware used if this flag is set?
1018 */
Johannes Bergeb9fb5b2009-11-16 13:58:20 +01001019 if ((status->flag & RX_FLAG_DECRYPTED) &&
1020 (status->flag & RX_FLAG_IV_STRIPPED))
Johannes Berg9ae54c82008-01-31 19:48:20 +01001021 return RX_CONTINUE;
Johannes Berg571ecf62007-07-27 15:43:22 +02001022
Johannes Berg761ab472010-05-28 14:24:19 +02001023 hdrlen = ieee80211_hdrlen(fc);
Johannes Berg571ecf62007-07-27 15:43:22 +02001024
Johannes Berg3017b802007-08-28 17:01:53 -04001025 if (rx->skb->len < 8 + hdrlen)
Johannes Berge4c26ad2008-01-31 19:48:21 +01001026 return RX_DROP_UNUSABLE; /* TODO: count this? */
Johannes Berg571ecf62007-07-27 15:43:22 +02001027
Johannes Berg3017b802007-08-28 17:01:53 -04001028 /*
1029 * no need to call ieee80211_wep_get_keyidx,
1030 * it verifies a bunch of things we've done already
1031 */
Zhu Yi39184b12010-04-08 15:35:10 +08001032 skb_copy_bits(rx->skb, hdrlen + 3, &keyid, 1);
1033 keyidx = keyid >> 6;
Johannes Berg3017b802007-08-28 17:01:53 -04001034
Johannes Berge31b8212010-10-05 19:39:30 +02001035 /* check per-station GTK first, if multicast packet */
1036 if (is_multicast_ether_addr(hdr->addr1) && rx->sta)
1037 rx->key = rcu_dereference(rx->sta->gtk[keyidx]);
Johannes Berg3017b802007-08-28 17:01:53 -04001038
Johannes Berge31b8212010-10-05 19:39:30 +02001039 /* if not found, try default key */
1040 if (!rx->key) {
1041 rx->key = rcu_dereference(rx->sdata->keys[keyidx]);
1042
1043 /*
1044 * RSNA-protected unicast frames should always be
1045 * sent with pairwise or station-to-station keys,
1046 * but for WEP we allow using a key index as well.
1047 */
1048 if (rx->key &&
1049 rx->key->conf.cipher != WLAN_CIPHER_SUITE_WEP40 &&
1050 rx->key->conf.cipher != WLAN_CIPHER_SUITE_WEP104 &&
1051 !is_multicast_ether_addr(hdr->addr1))
1052 rx->key = NULL;
1053 }
Johannes Berg571ecf62007-07-27 15:43:22 +02001054 }
1055
Johannes Berg3017b802007-08-28 17:01:53 -04001056 if (rx->key) {
Johannes Berg95acac62011-07-12 12:30:59 +02001057 if (unlikely(rx->key->flags & KEY_FLAG_TAINTED))
1058 return RX_DROP_MONITOR;
1059
Johannes Berg571ecf62007-07-27 15:43:22 +02001060 rx->key->tx_rx_count++;
Johannes Berg011bfcc2007-09-17 01:29:25 -04001061 /* TODO: add threshold stuff again */
Johannes Berg1990af82007-09-26 17:53:15 +02001062 } else {
Johannes Berge4c26ad2008-01-31 19:48:21 +01001063 return RX_DROP_MONITOR;
Johannes Berg70f08762007-09-26 17:53:14 +02001064 }
1065
Johannes Berg97359d12010-08-10 09:46:38 +02001066 switch (rx->key->conf.cipher) {
1067 case WLAN_CIPHER_SUITE_WEP40:
1068 case WLAN_CIPHER_SUITE_WEP104:
Mattias Nisslere2f036d2007-10-07 16:35:31 +02001069 result = ieee80211_crypto_wep_decrypt(rx);
1070 break;
Johannes Berg97359d12010-08-10 09:46:38 +02001071 case WLAN_CIPHER_SUITE_TKIP:
Mattias Nisslere2f036d2007-10-07 16:35:31 +02001072 result = ieee80211_crypto_tkip_decrypt(rx);
1073 break;
Johannes Berg97359d12010-08-10 09:46:38 +02001074 case WLAN_CIPHER_SUITE_CCMP:
Mattias Nisslere2f036d2007-10-07 16:35:31 +02001075 result = ieee80211_crypto_ccmp_decrypt(rx);
1076 break;
Johannes Berg97359d12010-08-10 09:46:38 +02001077 case WLAN_CIPHER_SUITE_AES_CMAC:
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +02001078 result = ieee80211_crypto_aes_cmac_decrypt(rx);
1079 break;
Johannes Berg3ffc2a92010-08-27 14:26:52 +03001080 default:
1081 /*
1082 * We can reach here only with HW-only algorithms
1083 * but why didn't it decrypt the frame?!
1084 */
1085 return RX_DROP_UNUSABLE;
Johannes Berg70f08762007-09-26 17:53:14 +02001086 }
1087
Johannes Berga8286912012-03-12 13:49:14 +01001088 /* the hdr variable is invalid after the decrypt handlers */
1089
Mattias Nisslere2f036d2007-10-07 16:35:31 +02001090 /* either the frame has been decrypted or will be dropped */
Johannes Bergeb9fb5b2009-11-16 13:58:20 +01001091 status->flag |= RX_FLAG_DECRYPTED;
Mattias Nisslere2f036d2007-10-07 16:35:31 +02001092
1093 return result;
Johannes Berg70f08762007-09-26 17:53:14 +02001094}
1095
Kalle Valo572e0012009-02-10 17:09:31 +02001096static ieee80211_rx_result debug_noinline
1097ieee80211_rx_h_check_more_data(struct ieee80211_rx_data *rx)
1098{
1099 struct ieee80211_local *local;
1100 struct ieee80211_hdr *hdr;
1101 struct sk_buff *skb;
1102
1103 local = rx->local;
1104 skb = rx->skb;
1105 hdr = (struct ieee80211_hdr *) skb->data;
1106
1107 if (!local->pspolling)
1108 return RX_CONTINUE;
1109
1110 if (!ieee80211_has_fromds(hdr->frame_control))
1111 /* this is not from AP */
1112 return RX_CONTINUE;
1113
1114 if (!ieee80211_is_data(hdr->frame_control))
1115 return RX_CONTINUE;
1116
1117 if (!ieee80211_has_moredata(hdr->frame_control)) {
1118 /* AP has no more frames buffered for us */
1119 local->pspolling = false;
1120 return RX_CONTINUE;
1121 }
1122
1123 /* more data bit is set, let's request a new frame from the AP */
1124 ieee80211_send_pspoll(local, rx->sdata);
1125
1126 return RX_CONTINUE;
1127}
1128
Johannes Berg133b8222008-09-16 14:18:59 +02001129static void ap_sta_ps_start(struct sta_info *sta)
Johannes Berg571ecf62007-07-27 15:43:22 +02001130{
Johannes Berg133b8222008-09-16 14:18:59 +02001131 struct ieee80211_sub_if_data *sdata = sta->sdata;
Christian Lamparter4571d3b2008-11-30 00:48:41 +01001132 struct ieee80211_local *local = sdata->local;
Joe Perches0795af52007-10-03 17:59:30 -07001133
Johannes Berg3e122be2008-07-09 14:40:34 +02001134 atomic_inc(&sdata->bss->num_sta_ps);
Johannes Bergc2c98fd2011-09-29 16:04:36 +02001135 set_sta_flag(sta, WLAN_STA_PS_STA);
Arik Nemtsovd057e5a2011-01-31 22:29:13 +02001136 if (!(local->hw.flags & IEEE80211_HW_AP_LINK_PS))
1137 drv_sta_notify(local, sdata, STA_NOTIFY_SLEEP, &sta->sta);
Johannes Berg571ecf62007-07-27 15:43:22 +02001138#ifdef CONFIG_MAC80211_VERBOSE_PS_DEBUG
Johannes Berg0c68ae262008-10-27 15:56:10 -07001139 printk(KERN_DEBUG "%s: STA %pM aid %d enters power save mode\n",
Johannes Berg47846c92009-11-25 17:46:19 +01001140 sdata->name, sta->sta.addr, sta->sta.aid);
Johannes Berg571ecf62007-07-27 15:43:22 +02001141#endif /* CONFIG_MAC80211_VERBOSE_PS_DEBUG */
1142}
1143
Johannes Bergff9458d2009-10-30 12:56:02 +01001144static void ap_sta_ps_end(struct sta_info *sta)
Johannes Berg571ecf62007-07-27 15:43:22 +02001145{
Johannes Berg571ecf62007-07-27 15:43:22 +02001146#ifdef CONFIG_MAC80211_VERBOSE_PS_DEBUG
Johannes Berg0c68ae262008-10-27 15:56:10 -07001147 printk(KERN_DEBUG "%s: STA %pM aid %d exits power save mode\n",
Helmut Schaa608383b2012-01-30 15:18:00 +01001148 sta->sdata->name, sta->sta.addr, sta->sta.aid);
Johannes Berg571ecf62007-07-27 15:43:22 +02001149#endif /* CONFIG_MAC80211_VERBOSE_PS_DEBUG */
Johannes Berg004c8722008-02-20 11:21:35 +01001150
Johannes Bergc2c98fd2011-09-29 16:04:36 +02001151 if (test_sta_flag(sta, WLAN_STA_PS_DRIVER)) {
Johannes Berg571ecf62007-07-27 15:43:22 +02001152#ifdef CONFIG_MAC80211_VERBOSE_PS_DEBUG
Johannes Bergaf818582009-11-06 11:35:50 +01001153 printk(KERN_DEBUG "%s: STA %pM aid %d driver-ps-blocked\n",
Helmut Schaa608383b2012-01-30 15:18:00 +01001154 sta->sdata->name, sta->sta.addr, sta->sta.aid);
Johannes Berg571ecf62007-07-27 15:43:22 +02001155#endif /* CONFIG_MAC80211_VERBOSE_PS_DEBUG */
Johannes Bergaf818582009-11-06 11:35:50 +01001156 return;
1157 }
1158
1159 ieee80211_sta_ps_deliver_wakeup(sta);
Johannes Berg571ecf62007-07-27 15:43:22 +02001160}
1161
Arik Nemtsovd057e5a2011-01-31 22:29:13 +02001162int ieee80211_sta_ps_transition(struct ieee80211_sta *sta, bool start)
1163{
1164 struct sta_info *sta_inf = container_of(sta, struct sta_info, sta);
1165 bool in_ps;
1166
1167 WARN_ON(!(sta_inf->local->hw.flags & IEEE80211_HW_AP_LINK_PS));
1168
1169 /* Don't let the same PS state be set twice */
Johannes Bergc2c98fd2011-09-29 16:04:36 +02001170 in_ps = test_sta_flag(sta_inf, WLAN_STA_PS_STA);
Arik Nemtsovd057e5a2011-01-31 22:29:13 +02001171 if ((start && in_ps) || (!start && !in_ps))
1172 return -EINVAL;
1173
1174 if (start)
1175 ap_sta_ps_start(sta_inf);
1176 else
1177 ap_sta_ps_end(sta_inf);
1178
1179 return 0;
1180}
1181EXPORT_SYMBOL(ieee80211_sta_ps_transition);
1182
Johannes Berg49461622008-06-30 15:10:45 +02001183static ieee80211_rx_result debug_noinline
Johannes Berg47086fc2011-09-29 16:04:33 +02001184ieee80211_rx_h_uapsd_and_pspoll(struct ieee80211_rx_data *rx)
1185{
1186 struct ieee80211_sub_if_data *sdata = rx->sdata;
1187 struct ieee80211_hdr *hdr = (void *)rx->skb->data;
1188 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb);
1189 int tid, ac;
1190
1191 if (!rx->sta || !(status->rx_flags & IEEE80211_RX_RA_MATCH))
1192 return RX_CONTINUE;
1193
1194 if (sdata->vif.type != NL80211_IFTYPE_AP &&
1195 sdata->vif.type != NL80211_IFTYPE_AP_VLAN)
1196 return RX_CONTINUE;
1197
1198 /*
1199 * The device handles station powersave, so don't do anything about
1200 * uAPSD and PS-Poll frames (the latter shouldn't even come up from
1201 * it to mac80211 since they're handled.)
1202 */
1203 if (sdata->local->hw.flags & IEEE80211_HW_AP_LINK_PS)
1204 return RX_CONTINUE;
1205
1206 /*
1207 * Don't do anything if the station isn't already asleep. In
1208 * the uAPSD case, the station will probably be marked asleep,
1209 * in the PS-Poll case the station must be confused ...
1210 */
Johannes Bergc2c98fd2011-09-29 16:04:36 +02001211 if (!test_sta_flag(rx->sta, WLAN_STA_PS_STA))
Johannes Berg47086fc2011-09-29 16:04:33 +02001212 return RX_CONTINUE;
1213
1214 if (unlikely(ieee80211_is_pspoll(hdr->frame_control))) {
Johannes Bergc2c98fd2011-09-29 16:04:36 +02001215 if (!test_sta_flag(rx->sta, WLAN_STA_SP)) {
1216 if (!test_sta_flag(rx->sta, WLAN_STA_PS_DRIVER))
Johannes Bergdeeaee12011-09-29 16:04:35 +02001217 ieee80211_sta_ps_deliver_poll_response(rx->sta);
1218 else
Johannes Bergc2c98fd2011-09-29 16:04:36 +02001219 set_sta_flag(rx->sta, WLAN_STA_PSPOLL);
Johannes Bergdeeaee12011-09-29 16:04:35 +02001220 }
Johannes Berg47086fc2011-09-29 16:04:33 +02001221
1222 /* Free PS Poll skb here instead of returning RX_DROP that would
1223 * count as an dropped frame. */
1224 dev_kfree_skb(rx->skb);
1225
1226 return RX_QUEUED;
1227 } else if (!ieee80211_has_morefrags(hdr->frame_control) &&
1228 !(status->rx_flags & IEEE80211_RX_DEFERRED_RELEASE) &&
1229 ieee80211_has_pm(hdr->frame_control) &&
1230 (ieee80211_is_data_qos(hdr->frame_control) ||
1231 ieee80211_is_qos_nullfunc(hdr->frame_control))) {
1232 tid = *ieee80211_get_qos_ctl(hdr) & IEEE80211_QOS_CTL_TID_MASK;
1233 ac = ieee802_1d_to_ac[tid & 7];
1234
1235 /*
1236 * If this AC is not trigger-enabled do nothing.
1237 *
1238 * NB: This could/should check a separate bitmap of trigger-
1239 * enabled queues, but for now we only implement uAPSD w/o
1240 * TSPEC changes to the ACs, so they're always the same.
1241 */
1242 if (!(rx->sta->sta.uapsd_queues & BIT(ac)))
1243 return RX_CONTINUE;
1244
1245 /* if we are in a service period, do nothing */
Johannes Bergc2c98fd2011-09-29 16:04:36 +02001246 if (test_sta_flag(rx->sta, WLAN_STA_SP))
Johannes Berg47086fc2011-09-29 16:04:33 +02001247 return RX_CONTINUE;
1248
Johannes Bergc2c98fd2011-09-29 16:04:36 +02001249 if (!test_sta_flag(rx->sta, WLAN_STA_PS_DRIVER))
Johannes Berg47086fc2011-09-29 16:04:33 +02001250 ieee80211_sta_ps_deliver_uapsd(rx->sta);
1251 else
Johannes Bergc2c98fd2011-09-29 16:04:36 +02001252 set_sta_flag(rx->sta, WLAN_STA_UAPSD);
Johannes Berg47086fc2011-09-29 16:04:33 +02001253 }
1254
1255 return RX_CONTINUE;
1256}
1257
1258static ieee80211_rx_result debug_noinline
Johannes Berg5cf121c2008-02-25 16:27:43 +01001259ieee80211_rx_h_sta_process(struct ieee80211_rx_data *rx)
Johannes Berg571ecf62007-07-27 15:43:22 +02001260{
1261 struct sta_info *sta = rx->sta;
Johannes Bergeb9fb5b2009-11-16 13:58:20 +01001262 struct sk_buff *skb = rx->skb;
1263 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
1264 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
Johannes Berg571ecf62007-07-27 15:43:22 +02001265
1266 if (!sta)
Johannes Berg9ae54c82008-01-31 19:48:20 +01001267 return RX_CONTINUE;
Johannes Berg571ecf62007-07-27 15:43:22 +02001268
Johannes Bergb291ba12009-07-10 15:29:03 +02001269 /*
1270 * Update last_rx only for IBSS packets which are for the current
1271 * BSSID to avoid keeping the current IBSS network alive in cases
1272 * where other STAs start using different BSSID.
1273 */
Johannes Berg05c914f2008-09-11 00:01:58 +02001274 if (rx->sdata->vif.type == NL80211_IFTYPE_ADHOC) {
Ron Rindjunsky71364712007-12-25 17:00:36 +02001275 u8 *bssid = ieee80211_get_bssid(hdr, rx->skb->len,
Johannes Berg05c914f2008-09-11 00:01:58 +02001276 NL80211_IFTYPE_ADHOC);
Felix Fietkau3af63342011-02-27 22:08:01 +01001277 if (compare_ether_addr(bssid, rx->sdata->u.ibss.bssid) == 0) {
Johannes Berg571ecf62007-07-27 15:43:22 +02001278 sta->last_rx = jiffies;
Felix Fietkau3af63342011-02-27 22:08:01 +01001279 if (ieee80211_is_data(hdr->frame_control)) {
1280 sta->last_rx_rate_idx = status->rate_idx;
1281 sta->last_rx_rate_flag = status->flag;
1282 }
1283 }
Johannes Bergb291ba12009-07-10 15:29:03 +02001284 } else if (!is_multicast_ether_addr(hdr->addr1)) {
1285 /*
Luis Carlos Cobo33b64eb2008-02-23 15:17:10 +01001286 * Mesh beacons will update last_rx when if they are found to
1287 * match the current local configuration when processed.
Johannes Berg571ecf62007-07-27 15:43:22 +02001288 */
Johannes Bergb291ba12009-07-10 15:29:03 +02001289 sta->last_rx = jiffies;
Felix Fietkau3af63342011-02-27 22:08:01 +01001290 if (ieee80211_is_data(hdr->frame_control)) {
1291 sta->last_rx_rate_idx = status->rate_idx;
1292 sta->last_rx_rate_flag = status->flag;
1293 }
Johannes Berg571ecf62007-07-27 15:43:22 +02001294 }
1295
Johannes Berg554891e2010-09-24 12:38:25 +02001296 if (!(status->rx_flags & IEEE80211_RX_RA_MATCH))
Johannes Berg9ae54c82008-01-31 19:48:20 +01001297 return RX_CONTINUE;
Johannes Berg571ecf62007-07-27 15:43:22 +02001298
Kalle Valo3cf335d2009-03-22 21:57:06 +02001299 if (rx->sdata->vif.type == NL80211_IFTYPE_STATION)
1300 ieee80211_sta_rx_notify(rx->sdata, hdr);
1301
Johannes Berg571ecf62007-07-27 15:43:22 +02001302 sta->rx_fragments++;
1303 sta->rx_bytes += rx->skb->len;
Felix Fietkaufe8431f2012-03-01 18:00:07 +01001304 if (!(status->flag & RX_FLAG_NO_SIGNAL_VAL)) {
1305 sta->last_signal = status->signal;
1306 ewma_add(&sta->avg_signal, -status->signal);
1307 }
Johannes Berg571ecf62007-07-27 15:43:22 +02001308
Johannes Berg72eaa432008-11-26 15:02:58 +01001309 /*
1310 * Change STA power saving mode only at the end of a frame
1311 * exchange sequence.
1312 */
Arik Nemtsovd057e5a2011-01-31 22:29:13 +02001313 if (!(sta->local->hw.flags & IEEE80211_HW_AP_LINK_PS) &&
1314 !ieee80211_has_morefrags(hdr->frame_control) &&
Christian Lamparter4cfda472010-12-27 23:21:26 +01001315 !(status->rx_flags & IEEE80211_RX_DEFERRED_RELEASE) &&
Johannes Berg05c914f2008-09-11 00:01:58 +02001316 (rx->sdata->vif.type == NL80211_IFTYPE_AP ||
1317 rx->sdata->vif.type == NL80211_IFTYPE_AP_VLAN)) {
Johannes Bergc2c98fd2011-09-29 16:04:36 +02001318 if (test_sta_flag(sta, WLAN_STA_PS_STA)) {
Johannes Berg72eaa432008-11-26 15:02:58 +01001319 /*
1320 * Ignore doze->wake transitions that are
1321 * indicated by non-data frames, the standard
1322 * is unclear here, but for example going to
1323 * PS mode and then scanning would cause a
1324 * doze->wake transition for the probe request,
1325 * and that is clearly undesirable.
1326 */
1327 if (ieee80211_is_data(hdr->frame_control) &&
1328 !ieee80211_has_pm(hdr->frame_control))
Johannes Bergff9458d2009-10-30 12:56:02 +01001329 ap_sta_ps_end(sta);
Johannes Berg72eaa432008-11-26 15:02:58 +01001330 } else {
1331 if (ieee80211_has_pm(hdr->frame_control))
1332 ap_sta_ps_start(sta);
1333 }
Johannes Berg571ecf62007-07-27 15:43:22 +02001334 }
1335
Johannes Berg22403de2009-10-30 12:55:03 +01001336 /*
1337 * Drop (qos-)data::nullfunc frames silently, since they
1338 * are used only to control station power saving mode.
1339 */
1340 if (ieee80211_is_nullfunc(hdr->frame_control) ||
1341 ieee80211_is_qos_nullfunc(hdr->frame_control)) {
Johannes Berg571ecf62007-07-27 15:43:22 +02001342 I802_DEBUG_INC(rx->local->rx_handlers_drop_nullfunc);
Felix Fietkaud5242152010-01-08 18:06:26 +01001343
1344 /*
1345 * If we receive a 4-addr nullfunc frame from a STA
Johannes Berge7f4a942011-11-04 11:18:20 +01001346 * that was not moved to a 4-addr STA vlan yet send
1347 * the event to userspace and for older hostapd drop
1348 * the frame to the monitor interface.
Felix Fietkaud5242152010-01-08 18:06:26 +01001349 */
1350 if (ieee80211_has_a4(hdr->frame_control) &&
1351 (rx->sdata->vif.type == NL80211_IFTYPE_AP ||
1352 (rx->sdata->vif.type == NL80211_IFTYPE_AP_VLAN &&
Johannes Berge7f4a942011-11-04 11:18:20 +01001353 !rx->sdata->u.vlan.sta))) {
1354 if (!test_and_set_sta_flag(sta, WLAN_STA_4ADDR_EVENT))
1355 cfg80211_rx_unexpected_4addr_frame(
1356 rx->sdata->dev, sta->sta.addr,
1357 GFP_ATOMIC);
Felix Fietkaud5242152010-01-08 18:06:26 +01001358 return RX_DROP_MONITOR;
Johannes Berge7f4a942011-11-04 11:18:20 +01001359 }
Johannes Berg22403de2009-10-30 12:55:03 +01001360 /*
1361 * Update counter and free packet here to avoid
1362 * counting this as a dropped packed.
1363 */
Johannes Berg571ecf62007-07-27 15:43:22 +02001364 sta->rx_packets++;
1365 dev_kfree_skb(rx->skb);
Johannes Berg9ae54c82008-01-31 19:48:20 +01001366 return RX_QUEUED;
Johannes Berg571ecf62007-07-27 15:43:22 +02001367 }
1368
Johannes Berg9ae54c82008-01-31 19:48:20 +01001369 return RX_CONTINUE;
Johannes Berg571ecf62007-07-27 15:43:22 +02001370} /* ieee80211_rx_h_sta_process */
1371
Johannes Berg571ecf62007-07-27 15:43:22 +02001372static inline struct ieee80211_fragment_entry *
1373ieee80211_reassemble_add(struct ieee80211_sub_if_data *sdata,
1374 unsigned int frag, unsigned int seq, int rx_queue,
1375 struct sk_buff **skb)
1376{
1377 struct ieee80211_fragment_entry *entry;
1378 int idx;
1379
1380 idx = sdata->fragment_next;
1381 entry = &sdata->fragments[sdata->fragment_next++];
1382 if (sdata->fragment_next >= IEEE80211_FRAGMENT_MAX)
1383 sdata->fragment_next = 0;
1384
1385 if (!skb_queue_empty(&entry->skb_list)) {
Johannes Bergf4ea83d2008-06-30 15:10:46 +02001386#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
Johannes Berg571ecf62007-07-27 15:43:22 +02001387 struct ieee80211_hdr *hdr =
1388 (struct ieee80211_hdr *) entry->skb_list.next->data;
1389 printk(KERN_DEBUG "%s: RX reassembly removed oldest "
1390 "fragment entry (idx=%d age=%lu seq=%d last_frag=%d "
Johannes Berg0c68ae262008-10-27 15:56:10 -07001391 "addr1=%pM addr2=%pM\n",
Johannes Berg47846c92009-11-25 17:46:19 +01001392 sdata->name, idx,
Johannes Berg571ecf62007-07-27 15:43:22 +02001393 jiffies - entry->first_frag_time, entry->seq,
Johannes Berg0c68ae262008-10-27 15:56:10 -07001394 entry->last_frag, hdr->addr1, hdr->addr2);
Johannes Bergf4ea83d2008-06-30 15:10:46 +02001395#endif
Johannes Berg571ecf62007-07-27 15:43:22 +02001396 __skb_queue_purge(&entry->skb_list);
1397 }
1398
1399 __skb_queue_tail(&entry->skb_list, *skb); /* no need for locking */
1400 *skb = NULL;
1401 entry->first_frag_time = jiffies;
1402 entry->seq = seq;
1403 entry->rx_queue = rx_queue;
1404 entry->last_frag = frag;
1405 entry->ccmp = 0;
1406 entry->extra_len = 0;
1407
1408 return entry;
1409}
1410
1411static inline struct ieee80211_fragment_entry *
1412ieee80211_reassemble_find(struct ieee80211_sub_if_data *sdata,
Harvey Harrisonb73d70a2008-07-15 18:44:12 -07001413 unsigned int frag, unsigned int seq,
Johannes Berg571ecf62007-07-27 15:43:22 +02001414 int rx_queue, struct ieee80211_hdr *hdr)
1415{
1416 struct ieee80211_fragment_entry *entry;
1417 int i, idx;
1418
1419 idx = sdata->fragment_next;
1420 for (i = 0; i < IEEE80211_FRAGMENT_MAX; i++) {
1421 struct ieee80211_hdr *f_hdr;
Johannes Berg571ecf62007-07-27 15:43:22 +02001422
1423 idx--;
1424 if (idx < 0)
1425 idx = IEEE80211_FRAGMENT_MAX - 1;
1426
1427 entry = &sdata->fragments[idx];
1428 if (skb_queue_empty(&entry->skb_list) || entry->seq != seq ||
1429 entry->rx_queue != rx_queue ||
1430 entry->last_frag + 1 != frag)
1431 continue;
1432
Harvey Harrisonb73d70a2008-07-15 18:44:12 -07001433 f_hdr = (struct ieee80211_hdr *)entry->skb_list.next->data;
Johannes Berg571ecf62007-07-27 15:43:22 +02001434
Harvey Harrisonb73d70a2008-07-15 18:44:12 -07001435 /*
1436 * Check ftype and addresses are equal, else check next fragment
1437 */
1438 if (((hdr->frame_control ^ f_hdr->frame_control) &
1439 cpu_to_le16(IEEE80211_FCTL_FTYPE)) ||
Johannes Berg571ecf62007-07-27 15:43:22 +02001440 compare_ether_addr(hdr->addr1, f_hdr->addr1) != 0 ||
1441 compare_ether_addr(hdr->addr2, f_hdr->addr2) != 0)
1442 continue;
1443
S.Çağlar Onurab466232008-02-14 17:36:47 +02001444 if (time_after(jiffies, entry->first_frag_time + 2 * HZ)) {
Johannes Berg571ecf62007-07-27 15:43:22 +02001445 __skb_queue_purge(&entry->skb_list);
1446 continue;
1447 }
1448 return entry;
1449 }
1450
1451 return NULL;
1452}
1453
Johannes Berg49461622008-06-30 15:10:45 +02001454static ieee80211_rx_result debug_noinline
Johannes Berg5cf121c2008-02-25 16:27:43 +01001455ieee80211_rx_h_defragment(struct ieee80211_rx_data *rx)
Johannes Berg571ecf62007-07-27 15:43:22 +02001456{
1457 struct ieee80211_hdr *hdr;
1458 u16 sc;
Harvey Harrison358c8d92008-07-15 18:44:13 -07001459 __le16 fc;
Johannes Berg571ecf62007-07-27 15:43:22 +02001460 unsigned int frag, seq;
1461 struct ieee80211_fragment_entry *entry;
1462 struct sk_buff *skb;
Johannes Berg554891e2010-09-24 12:38:25 +02001463 struct ieee80211_rx_status *status;
Johannes Berg571ecf62007-07-27 15:43:22 +02001464
Harvey Harrisonb73d70a2008-07-15 18:44:12 -07001465 hdr = (struct ieee80211_hdr *)rx->skb->data;
Harvey Harrison358c8d92008-07-15 18:44:13 -07001466 fc = hdr->frame_control;
Johannes Berg571ecf62007-07-27 15:43:22 +02001467 sc = le16_to_cpu(hdr->seq_ctrl);
1468 frag = sc & IEEE80211_SCTL_FRAG;
1469
Harvey Harrison358c8d92008-07-15 18:44:13 -07001470 if (likely((!ieee80211_has_morefrags(fc) && frag == 0) ||
Johannes Berg571ecf62007-07-27 15:43:22 +02001471 (rx->skb)->len < 24 ||
1472 is_multicast_ether_addr(hdr->addr1))) {
1473 /* not fragmented */
1474 goto out;
1475 }
1476 I802_DEBUG_INC(rx->local->rx_handlers_fragments);
1477
Zhu Yie3cf8b32010-03-29 17:35:07 +08001478 if (skb_linearize(rx->skb))
1479 return RX_DROP_UNUSABLE;
1480
Abhijeet Kolekar058897a2010-05-11 11:22:11 -07001481 /*
1482 * skb_linearize() might change the skb->data and
1483 * previously cached variables (in this case, hdr) need to
1484 * be refreshed with the new data.
1485 */
1486 hdr = (struct ieee80211_hdr *)rx->skb->data;
Johannes Berg571ecf62007-07-27 15:43:22 +02001487 seq = (sc & IEEE80211_SCTL_SEQ) >> 4;
1488
1489 if (frag == 0) {
1490 /* This is the first fragment of a new frame. */
1491 entry = ieee80211_reassemble_add(rx->sdata, frag, seq,
Johannes Berg9e262972011-07-07 18:45:03 +02001492 rx->seqno_idx, &(rx->skb));
Johannes Berg97359d12010-08-10 09:46:38 +02001493 if (rx->key && rx->key->conf.cipher == WLAN_CIPHER_SUITE_CCMP &&
Harvey Harrison358c8d92008-07-15 18:44:13 -07001494 ieee80211_has_protected(fc)) {
Johannes Berg9e262972011-07-07 18:45:03 +02001495 int queue = rx->security_idx;
Johannes Berg571ecf62007-07-27 15:43:22 +02001496 /* Store CCMP PN so that we can verify that the next
1497 * fragment has a sequential PN value. */
1498 entry->ccmp = 1;
1499 memcpy(entry->last_pn,
Jouni Malinen91902522010-06-11 10:27:33 -07001500 rx->key->u.ccmp.rx_pn[queue],
Johannes Berg571ecf62007-07-27 15:43:22 +02001501 CCMP_PN_LEN);
1502 }
Johannes Berg9ae54c82008-01-31 19:48:20 +01001503 return RX_QUEUED;
Johannes Berg571ecf62007-07-27 15:43:22 +02001504 }
1505
1506 /* This is a fragment for a frame that should already be pending in
1507 * fragment cache. Add this fragment to the end of the pending entry.
1508 */
Johannes Berg9e262972011-07-07 18:45:03 +02001509 entry = ieee80211_reassemble_find(rx->sdata, frag, seq,
1510 rx->seqno_idx, hdr);
Johannes Berg571ecf62007-07-27 15:43:22 +02001511 if (!entry) {
1512 I802_DEBUG_INC(rx->local->rx_handlers_drop_defrag);
Johannes Berge4c26ad2008-01-31 19:48:21 +01001513 return RX_DROP_MONITOR;
Johannes Berg571ecf62007-07-27 15:43:22 +02001514 }
1515
1516 /* Verify that MPDUs within one MSDU have sequential PN values.
1517 * (IEEE 802.11i, 8.3.3.4.5) */
1518 if (entry->ccmp) {
1519 int i;
1520 u8 pn[CCMP_PN_LEN], *rpn;
Jouni Malinen91902522010-06-11 10:27:33 -07001521 int queue;
Johannes Berg97359d12010-08-10 09:46:38 +02001522 if (!rx->key || rx->key->conf.cipher != WLAN_CIPHER_SUITE_CCMP)
Johannes Berge4c26ad2008-01-31 19:48:21 +01001523 return RX_DROP_UNUSABLE;
Johannes Berg571ecf62007-07-27 15:43:22 +02001524 memcpy(pn, entry->last_pn, CCMP_PN_LEN);
1525 for (i = CCMP_PN_LEN - 1; i >= 0; i--) {
1526 pn[i]++;
1527 if (pn[i])
1528 break;
1529 }
Johannes Berg9e262972011-07-07 18:45:03 +02001530 queue = rx->security_idx;
Jouni Malinen91902522010-06-11 10:27:33 -07001531 rpn = rx->key->u.ccmp.rx_pn[queue];
Johannes Bergf4ea83d2008-06-30 15:10:46 +02001532 if (memcmp(pn, rpn, CCMP_PN_LEN))
Johannes Berge4c26ad2008-01-31 19:48:21 +01001533 return RX_DROP_UNUSABLE;
Johannes Berg571ecf62007-07-27 15:43:22 +02001534 memcpy(entry->last_pn, pn, CCMP_PN_LEN);
1535 }
1536
Harvey Harrison358c8d92008-07-15 18:44:13 -07001537 skb_pull(rx->skb, ieee80211_hdrlen(fc));
Johannes Berg571ecf62007-07-27 15:43:22 +02001538 __skb_queue_tail(&entry->skb_list, rx->skb);
1539 entry->last_frag = frag;
1540 entry->extra_len += rx->skb->len;
Harvey Harrison358c8d92008-07-15 18:44:13 -07001541 if (ieee80211_has_morefrags(fc)) {
Johannes Berg571ecf62007-07-27 15:43:22 +02001542 rx->skb = NULL;
Johannes Berg9ae54c82008-01-31 19:48:20 +01001543 return RX_QUEUED;
Johannes Berg571ecf62007-07-27 15:43:22 +02001544 }
1545
1546 rx->skb = __skb_dequeue(&entry->skb_list);
1547 if (skb_tailroom(rx->skb) < entry->extra_len) {
1548 I802_DEBUG_INC(rx->local->rx_expand_skb_head2);
1549 if (unlikely(pskb_expand_head(rx->skb, 0, entry->extra_len,
1550 GFP_ATOMIC))) {
1551 I802_DEBUG_INC(rx->local->rx_handlers_drop_defrag);
1552 __skb_queue_purge(&entry->skb_list);
Johannes Berge4c26ad2008-01-31 19:48:21 +01001553 return RX_DROP_UNUSABLE;
Johannes Berg571ecf62007-07-27 15:43:22 +02001554 }
1555 }
1556 while ((skb = __skb_dequeue(&entry->skb_list))) {
1557 memcpy(skb_put(rx->skb, skb->len), skb->data, skb->len);
1558 dev_kfree_skb(skb);
1559 }
1560
1561 /* Complete frame has been reassembled - process it now */
Johannes Berg554891e2010-09-24 12:38:25 +02001562 status = IEEE80211_SKB_RXCB(rx->skb);
1563 status->rx_flags |= IEEE80211_RX_FRAGMENTED;
Johannes Berg571ecf62007-07-27 15:43:22 +02001564
1565 out:
1566 if (rx->sta)
1567 rx->sta->rx_packets++;
1568 if (is_multicast_ether_addr(hdr->addr1))
1569 rx->local->dot11MulticastReceivedFrameCount++;
1570 else
1571 ieee80211_led_rx(rx->local);
Johannes Berg9ae54c82008-01-31 19:48:20 +01001572 return RX_CONTINUE;
Johannes Berg571ecf62007-07-27 15:43:22 +02001573}
1574
Ron Rindjunsky76ee65b2007-11-22 19:49:12 +02001575static int
Johannes Berg5cf121c2008-02-25 16:27:43 +01001576ieee80211_802_1x_port_control(struct ieee80211_rx_data *rx)
Johannes Berg571ecf62007-07-27 15:43:22 +02001577{
Johannes Berg07346f812008-05-03 01:02:02 +02001578 if (unlikely(!rx->sta ||
Johannes Bergc2c98fd2011-09-29 16:04:36 +02001579 !test_sta_flag(rx->sta, WLAN_STA_AUTHORIZED)))
Ron Rindjunsky76ee65b2007-11-22 19:49:12 +02001580 return -EACCES;
Johannes Berg571ecf62007-07-27 15:43:22 +02001581
Ron Rindjunsky76ee65b2007-11-22 19:49:12 +02001582 return 0;
Johannes Berg571ecf62007-07-27 15:43:22 +02001583}
1584
Ron Rindjunsky76ee65b2007-11-22 19:49:12 +02001585static int
Harvey Harrison358c8d92008-07-15 18:44:13 -07001586ieee80211_drop_unencrypted(struct ieee80211_rx_data *rx, __le16 fc)
Johannes Berg571ecf62007-07-27 15:43:22 +02001587{
Johannes Bergeb9fb5b2009-11-16 13:58:20 +01001588 struct sk_buff *skb = rx->skb;
1589 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
1590
Johannes Berg3017b802007-08-28 17:01:53 -04001591 /*
Johannes Berg7848ba72007-09-14 11:10:25 -04001592 * Pass through unencrypted frames if the hardware has
1593 * decrypted them already.
Johannes Berg3017b802007-08-28 17:01:53 -04001594 */
Johannes Bergeb9fb5b2009-11-16 13:58:20 +01001595 if (status->flag & RX_FLAG_DECRYPTED)
Ron Rindjunsky76ee65b2007-11-22 19:49:12 +02001596 return 0;
Johannes Berg571ecf62007-07-27 15:43:22 +02001597
1598 /* Drop unencrypted frames if key is set. */
Harvey Harrison358c8d92008-07-15 18:44:13 -07001599 if (unlikely(!ieee80211_has_protected(fc) &&
1600 !ieee80211_is_nullfunc(fc) &&
Jouni Malinenf2ca3ea2009-05-08 12:36:03 +03001601 ieee80211_is_data(fc) &&
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +02001602 (rx->key || rx->sdata->drop_unencrypted)))
1603 return -EACCES;
Johannes Bergbef5d1c2010-02-16 11:05:00 +01001604
1605 return 0;
1606}
1607
1608static int
1609ieee80211_drop_unencrypted_mgmt(struct ieee80211_rx_data *rx)
1610{
1611 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
Jouni Malinene3efca02010-03-28 22:31:15 -07001612 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb);
Johannes Bergbef5d1c2010-02-16 11:05:00 +01001613 __le16 fc = hdr->frame_control;
Johannes Bergbef5d1c2010-02-16 11:05:00 +01001614
Jouni Malinene3efca02010-03-28 22:31:15 -07001615 /*
1616 * Pass through unencrypted frames if the hardware has
1617 * decrypted them already.
1618 */
1619 if (status->flag & RX_FLAG_DECRYPTED)
1620 return 0;
Johannes Bergbef5d1c2010-02-16 11:05:00 +01001621
Johannes Bergc2c98fd2011-09-29 16:04:36 +02001622 if (rx->sta && test_sta_flag(rx->sta, WLAN_STA_MFP)) {
Jouni Malinend211e902010-03-28 22:29:52 -07001623 if (unlikely(!ieee80211_has_protected(fc) &&
1624 ieee80211_is_unicast_robust_mgmt_frame(rx->skb) &&
Jouni Malinencf4e5942010-12-16 00:52:40 +02001625 rx->key)) {
1626 if (ieee80211_is_deauth(fc))
1627 cfg80211_send_unprot_deauth(rx->sdata->dev,
1628 rx->skb->data,
1629 rx->skb->len);
1630 else if (ieee80211_is_disassoc(fc))
1631 cfg80211_send_unprot_disassoc(rx->sdata->dev,
1632 rx->skb->data,
1633 rx->skb->len);
Jouni Malinenf2ca3ea2009-05-08 12:36:03 +03001634 return -EACCES;
Jouni Malinencf4e5942010-12-16 00:52:40 +02001635 }
Jouni Malinenf2ca3ea2009-05-08 12:36:03 +03001636 /* BIP does not use Protected field, so need to check MMIE */
Joe Perchesf64f9e72009-11-29 16:55:45 -08001637 if (unlikely(ieee80211_is_multicast_robust_mgmt_frame(rx->skb) &&
Jouni Malinencf4e5942010-12-16 00:52:40 +02001638 ieee80211_get_mmie_keyidx(rx->skb) < 0)) {
1639 if (ieee80211_is_deauth(fc))
1640 cfg80211_send_unprot_deauth(rx->sdata->dev,
1641 rx->skb->data,
1642 rx->skb->len);
1643 else if (ieee80211_is_disassoc(fc))
1644 cfg80211_send_unprot_disassoc(rx->sdata->dev,
1645 rx->skb->data,
1646 rx->skb->len);
Jouni Malinenf2ca3ea2009-05-08 12:36:03 +03001647 return -EACCES;
Jouni Malinencf4e5942010-12-16 00:52:40 +02001648 }
Jouni Malinenf2ca3ea2009-05-08 12:36:03 +03001649 /*
1650 * When using MFP, Action frames are not allowed prior to
1651 * having configured keys.
1652 */
1653 if (unlikely(ieee80211_is_action(fc) && !rx->key &&
1654 ieee80211_is_robust_mgmt_frame(
1655 (struct ieee80211_hdr *) rx->skb->data)))
1656 return -EACCES;
1657 }
Johannes Bergb3fc9c62008-04-13 10:12:47 +02001658
Ron Rindjunsky76ee65b2007-11-22 19:49:12 +02001659 return 0;
Johannes Berg571ecf62007-07-27 15:43:22 +02001660}
1661
Ron Rindjunsky76ee65b2007-11-22 19:49:12 +02001662static int
Felix Fietkau4114fa22011-04-12 19:15:22 +02001663__ieee80211_data_to_8023(struct ieee80211_rx_data *rx, bool *port_control)
Johannes Berg571ecf62007-07-27 15:43:22 +02001664{
Johannes Bergeb9fb5b2009-11-16 13:58:20 +01001665 struct ieee80211_sub_if_data *sdata = rx->sdata;
Felix Fietkauf14543ee2009-11-10 20:10:05 +01001666 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
Felix Fietkaufbb327c2011-01-18 15:48:48 +01001667 bool check_port_control = false;
1668 struct ethhdr *ehdr;
1669 int ret;
Felix Fietkauf14543ee2009-11-10 20:10:05 +01001670
Felix Fietkau4114fa22011-04-12 19:15:22 +02001671 *port_control = false;
Johannes Berg9bc383d2009-11-19 11:55:19 +01001672 if (ieee80211_has_a4(hdr->frame_control) &&
1673 sdata->vif.type == NL80211_IFTYPE_AP_VLAN && !sdata->u.vlan.sta)
Felix Fietkauf14543ee2009-11-10 20:10:05 +01001674 return -1;
Johannes Berg9bc383d2009-11-19 11:55:19 +01001675
Felix Fietkaufbb327c2011-01-18 15:48:48 +01001676 if (sdata->vif.type == NL80211_IFTYPE_STATION &&
1677 !!sdata->u.mgd.use_4addr != !!ieee80211_has_a4(hdr->frame_control)) {
1678
1679 if (!sdata->u.mgd.use_4addr)
1680 return -1;
1681 else
1682 check_port_control = true;
1683 }
1684
Johannes Berg9bc383d2009-11-19 11:55:19 +01001685 if (is_multicast_ether_addr(hdr->addr1) &&
Felix Fietkaufbb327c2011-01-18 15:48:48 +01001686 sdata->vif.type == NL80211_IFTYPE_AP_VLAN && sdata->u.vlan.sta)
Felix Fietkauf14543ee2009-11-10 20:10:05 +01001687 return -1;
Johannes Berg571ecf62007-07-27 15:43:22 +02001688
Felix Fietkaufbb327c2011-01-18 15:48:48 +01001689 ret = ieee80211_data_to_8023(rx->skb, sdata->vif.addr, sdata->vif.type);
Felix Fietkau4114fa22011-04-12 19:15:22 +02001690 if (ret < 0)
Felix Fietkaufbb327c2011-01-18 15:48:48 +01001691 return ret;
1692
1693 ehdr = (struct ethhdr *) rx->skb->data;
Felix Fietkau4114fa22011-04-12 19:15:22 +02001694 if (ehdr->h_proto == rx->sdata->control_port_protocol)
1695 *port_control = true;
1696 else if (check_port_control)
Felix Fietkaufbb327c2011-01-18 15:48:48 +01001697 return -1;
1698
1699 return 0;
Ron Rindjunsky76ee65b2007-11-22 19:49:12 +02001700}
Johannes Berg571ecf62007-07-27 15:43:22 +02001701
Johannes Bergce3edf6d02007-12-19 01:31:22 +01001702/*
1703 * requires that rx->skb is a frame with ethernet header
1704 */
Harvey Harrison358c8d92008-07-15 18:44:13 -07001705static bool ieee80211_frame_allowed(struct ieee80211_rx_data *rx, __le16 fc)
Johannes Bergce3edf6d02007-12-19 01:31:22 +01001706{
Senthil Balasubramanianc97c23e2008-05-28 23:15:32 +05301707 static const u8 pae_group_addr[ETH_ALEN] __aligned(2)
Johannes Bergce3edf6d02007-12-19 01:31:22 +01001708 = { 0x01, 0x80, 0xC2, 0x00, 0x00, 0x03 };
1709 struct ethhdr *ehdr = (struct ethhdr *) rx->skb->data;
1710
1711 /*
1712 * Allow EAPOL frames to us/the PAE group address regardless
1713 * of whether the frame was encrypted or not.
1714 */
Johannes Berga621fa42010-08-27 14:26:54 +03001715 if (ehdr->h_proto == rx->sdata->control_port_protocol &&
Johannes Berg47846c92009-11-25 17:46:19 +01001716 (compare_ether_addr(ehdr->h_dest, rx->sdata->vif.addr) == 0 ||
Johannes Bergce3edf6d02007-12-19 01:31:22 +01001717 compare_ether_addr(ehdr->h_dest, pae_group_addr) == 0))
1718 return true;
1719
1720 if (ieee80211_802_1x_port_control(rx) ||
Harvey Harrison358c8d92008-07-15 18:44:13 -07001721 ieee80211_drop_unencrypted(rx, fc))
Johannes Bergce3edf6d02007-12-19 01:31:22 +01001722 return false;
1723
1724 return true;
1725}
1726
1727/*
1728 * requires that rx->skb is a frame with ethernet header
1729 */
Ron Rindjunsky76ee65b2007-11-22 19:49:12 +02001730static void
Johannes Berg5cf121c2008-02-25 16:27:43 +01001731ieee80211_deliver_skb(struct ieee80211_rx_data *rx)
Ron Rindjunsky76ee65b2007-11-22 19:49:12 +02001732{
Johannes Bergeb9fb5b2009-11-16 13:58:20 +01001733 struct ieee80211_sub_if_data *sdata = rx->sdata;
1734 struct net_device *dev = sdata->dev;
Ron Rindjunsky76ee65b2007-11-22 19:49:12 +02001735 struct sk_buff *skb, *xmit_skb;
Johannes Bergce3edf6d02007-12-19 01:31:22 +01001736 struct ethhdr *ehdr = (struct ethhdr *) rx->skb->data;
1737 struct sta_info *dsta;
Johannes Berg554891e2010-09-24 12:38:25 +02001738 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb);
Johannes Berg571ecf62007-07-27 15:43:22 +02001739
Ron Rindjunsky76ee65b2007-11-22 19:49:12 +02001740 skb = rx->skb;
1741 xmit_skb = NULL;
Johannes Berg571ecf62007-07-27 15:43:22 +02001742
Johannes Berg05c914f2008-09-11 00:01:58 +02001743 if ((sdata->vif.type == NL80211_IFTYPE_AP ||
1744 sdata->vif.type == NL80211_IFTYPE_AP_VLAN) &&
Johannes Berg213cd112008-09-11 00:01:54 +02001745 !(sdata->flags & IEEE80211_SDATA_DONT_BRIDGE_PACKETS) &&
Johannes Berg554891e2010-09-24 12:38:25 +02001746 (status->rx_flags & IEEE80211_RX_RA_MATCH) &&
Johannes Berg9bc383d2009-11-19 11:55:19 +01001747 (sdata->vif.type != NL80211_IFTYPE_AP_VLAN || !sdata->u.vlan.sta)) {
Johannes Bergce3edf6d02007-12-19 01:31:22 +01001748 if (is_multicast_ether_addr(ehdr->h_dest)) {
1749 /*
1750 * send multicast frames both to higher layers in
1751 * local net stack and back to the wireless medium
1752 */
Ron Rindjunsky76ee65b2007-11-22 19:49:12 +02001753 xmit_skb = skb_copy(skb, GFP_ATOMIC);
1754 if (!xmit_skb && net_ratelimit())
Johannes Berg571ecf62007-07-27 15:43:22 +02001755 printk(KERN_DEBUG "%s: failed to clone "
1756 "multicast frame\n", dev->name);
1757 } else {
Johannes Bergabe60632009-11-25 17:46:18 +01001758 dsta = sta_info_get(sdata, skb->data);
1759 if (dsta) {
Johannes Bergce3edf6d02007-12-19 01:31:22 +01001760 /*
1761 * The destination station is associated to
1762 * this AP (in this VLAN), so send the frame
1763 * directly to it and do not pass it to local
1764 * net stack.
Johannes Berg571ecf62007-07-27 15:43:22 +02001765 */
Ron Rindjunsky76ee65b2007-11-22 19:49:12 +02001766 xmit_skb = skb;
Johannes Berg571ecf62007-07-27 15:43:22 +02001767 skb = NULL;
1768 }
Johannes Berg571ecf62007-07-27 15:43:22 +02001769 }
1770 }
1771
1772 if (skb) {
Johannes Bergd1c3a372009-01-07 00:26:10 +01001773 int align __maybe_unused;
1774
Kalle Valo59d9cb02009-12-17 13:54:57 +01001775#ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
Johannes Bergd1c3a372009-01-07 00:26:10 +01001776 /*
1777 * 'align' will only take the values 0 or 2 here
1778 * since all frames are required to be aligned
1779 * to 2-byte boundaries when being passed to
1780 * mac80211. That also explains the __skb_push()
1781 * below.
1782 */
matthieu castetdacb6f12009-06-04 22:16:18 +02001783 align = ((unsigned long)(skb->data + sizeof(struct ethhdr))) & 3;
Johannes Bergd1c3a372009-01-07 00:26:10 +01001784 if (align) {
1785 if (WARN_ON(skb_headroom(skb) < 3)) {
1786 dev_kfree_skb(skb);
1787 skb = NULL;
1788 } else {
1789 u8 *data = skb->data;
Zhu Yi8ce0b582009-10-28 13:13:52 -07001790 size_t len = skb_headlen(skb);
1791 skb->data -= align;
1792 memmove(skb->data, data, len);
1793 skb_set_tail_pointer(skb, len);
Johannes Bergd1c3a372009-01-07 00:26:10 +01001794 }
1795 }
1796#endif
1797
1798 if (skb) {
1799 /* deliver to local stack */
1800 skb->protocol = eth_type_trans(skb, dev);
1801 memset(skb->cb, 0, sizeof(skb->cb));
John W. Linville5548a8a2010-06-24 14:25:56 -04001802 netif_receive_skb(skb);
Johannes Bergd1c3a372009-01-07 00:26:10 +01001803 }
Johannes Berg571ecf62007-07-27 15:43:22 +02001804 }
1805
Ron Rindjunsky76ee65b2007-11-22 19:49:12 +02001806 if (xmit_skb) {
Helmut Schaaaef6c922011-12-21 09:11:35 +01001807 /*
1808 * Send to wireless media and increase priority by 256 to
1809 * keep the received priority instead of reclassifying
1810 * the frame (see cfg80211_classify8021d).
1811 */
1812 xmit_skb->priority += 256;
YOSHIFUJI Hideakif831e902007-12-12 03:54:23 +09001813 xmit_skb->protocol = htons(ETH_P_802_3);
Johannes Bergce3edf6d02007-12-19 01:31:22 +01001814 skb_reset_network_header(xmit_skb);
1815 skb_reset_mac_header(xmit_skb);
Ron Rindjunsky76ee65b2007-11-22 19:49:12 +02001816 dev_queue_xmit(xmit_skb);
Johannes Berg571ecf62007-07-27 15:43:22 +02001817 }
Ron Rindjunsky76ee65b2007-11-22 19:49:12 +02001818}
1819
Johannes Berg49461622008-06-30 15:10:45 +02001820static ieee80211_rx_result debug_noinline
Johannes Berg5cf121c2008-02-25 16:27:43 +01001821ieee80211_rx_h_amsdu(struct ieee80211_rx_data *rx)
Ron Rindjunskyfd4c7f22007-11-26 16:14:33 +02001822{
Johannes Bergeb9fb5b2009-11-16 13:58:20 +01001823 struct net_device *dev = rx->sdata->dev;
Zhu Yieaf85ca2009-12-01 10:18:37 +08001824 struct sk_buff *skb = rx->skb;
Harvey Harrison358c8d92008-07-15 18:44:13 -07001825 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1826 __le16 fc = hdr->frame_control;
Zhu Yieaf85ca2009-12-01 10:18:37 +08001827 struct sk_buff_head frame_list;
Johannes Berg554891e2010-09-24 12:38:25 +02001828 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb);
Ron Rindjunskyfd4c7f22007-11-26 16:14:33 +02001829
Harvey Harrison358c8d92008-07-15 18:44:13 -07001830 if (unlikely(!ieee80211_is_data(fc)))
Johannes Berg9ae54c82008-01-31 19:48:20 +01001831 return RX_CONTINUE;
Ron Rindjunskyfd4c7f22007-11-26 16:14:33 +02001832
Harvey Harrison358c8d92008-07-15 18:44:13 -07001833 if (unlikely(!ieee80211_is_data_present(fc)))
Johannes Berge4c26ad2008-01-31 19:48:21 +01001834 return RX_DROP_MONITOR;
Ron Rindjunskyfd4c7f22007-11-26 16:14:33 +02001835
Johannes Berg554891e2010-09-24 12:38:25 +02001836 if (!(status->rx_flags & IEEE80211_RX_AMSDU))
Johannes Berg9ae54c82008-01-31 19:48:20 +01001837 return RX_CONTINUE;
Ron Rindjunskyfd4c7f22007-11-26 16:14:33 +02001838
Zhu Yieaf85ca2009-12-01 10:18:37 +08001839 if (ieee80211_has_a4(hdr->frame_control) &&
1840 rx->sdata->vif.type == NL80211_IFTYPE_AP_VLAN &&
1841 !rx->sdata->u.vlan.sta)
1842 return RX_DROP_UNUSABLE;
1843
1844 if (is_multicast_ether_addr(hdr->addr1) &&
1845 ((rx->sdata->vif.type == NL80211_IFTYPE_AP_VLAN &&
1846 rx->sdata->u.vlan.sta) ||
1847 (rx->sdata->vif.type == NL80211_IFTYPE_STATION &&
1848 rx->sdata->u.mgd.use_4addr)))
Johannes Berge4c26ad2008-01-31 19:48:21 +01001849 return RX_DROP_UNUSABLE;
Ron Rindjunskyfd4c7f22007-11-26 16:14:33 +02001850
1851 skb->dev = dev;
Zhu Yieaf85ca2009-12-01 10:18:37 +08001852 __skb_queue_head_init(&frame_list);
Ron Rindjunskyfd4c7f22007-11-26 16:14:33 +02001853
Zhu Yie3cf8b32010-03-29 17:35:07 +08001854 if (skb_linearize(skb))
1855 return RX_DROP_UNUSABLE;
1856
Zhu Yieaf85ca2009-12-01 10:18:37 +08001857 ieee80211_amsdu_to_8023s(skb, &frame_list, dev->dev_addr,
1858 rx->sdata->vif.type,
Yogesh Ashok Powar8b3beca2011-05-13 11:22:31 -07001859 rx->local->hw.extra_tx_headroom, true);
Ron Rindjunskyfd4c7f22007-11-26 16:14:33 +02001860
Zhu Yieaf85ca2009-12-01 10:18:37 +08001861 while (!skb_queue_empty(&frame_list)) {
1862 rx->skb = __skb_dequeue(&frame_list);
Ron Rindjunskyfd4c7f22007-11-26 16:14:33 +02001863
Harvey Harrison358c8d92008-07-15 18:44:13 -07001864 if (!ieee80211_frame_allowed(rx, fc)) {
Zhu Yieaf85ca2009-12-01 10:18:37 +08001865 dev_kfree_skb(rx->skb);
Johannes Bergce3edf6d02007-12-19 01:31:22 +01001866 continue;
1867 }
Zhu Yieaf85ca2009-12-01 10:18:37 +08001868 dev->stats.rx_packets++;
1869 dev->stats.rx_bytes += rx->skb->len;
Ron Rindjunskyfd4c7f22007-11-26 16:14:33 +02001870
1871 ieee80211_deliver_skb(rx);
1872 }
1873
Johannes Berg9ae54c82008-01-31 19:48:20 +01001874 return RX_QUEUED;
Ron Rindjunskyfd4c7f22007-11-26 16:14:33 +02001875}
1876
Ingo Molnarbf94e172008-10-12 23:51:38 -07001877#ifdef CONFIG_MAC80211_MESH
Davide Pesaventob0dee572008-09-27 17:29:12 +02001878static ieee80211_rx_result
Luis Carlos Coboe32f85f2008-08-05 19:34:52 +02001879ieee80211_rx_h_mesh_fwding(struct ieee80211_rx_data *rx)
1880{
Thomas Pedersen30789eb2011-11-24 17:15:26 -08001881 struct ieee80211_hdr *fwd_hdr, *hdr;
1882 struct ieee80211_tx_info *info;
Luis Carlos Coboe32f85f2008-08-05 19:34:52 +02001883 struct ieee80211s_hdr *mesh_hdr;
Luis Carlos Coboe32f85f2008-08-05 19:34:52 +02001884 struct sk_buff *skb = rx->skb, *fwd_skb;
Johannes Berg3b8d81e02009-06-17 17:43:56 +02001885 struct ieee80211_local *local = rx->local;
Johannes Bergeb9fb5b2009-11-16 13:58:20 +01001886 struct ieee80211_sub_if_data *sdata = rx->sdata;
Johannes Berg554891e2010-09-24 12:38:25 +02001887 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
Thomas Pedersen30789eb2011-11-24 17:15:26 -08001888 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
Thomas Pedersen0cfda852011-11-24 17:15:25 -08001889 __le16 reason = cpu_to_le16(WLAN_REASON_MESH_PATH_NOFORWARD);
Thomas Pedersen30789eb2011-11-24 17:15:26 -08001890 u16 q, hdrlen;
Luis Carlos Coboe32f85f2008-08-05 19:34:52 +02001891
1892 hdr = (struct ieee80211_hdr *) skb->data;
1893 hdrlen = ieee80211_hdrlen(hdr->frame_control);
1894 mesh_hdr = (struct ieee80211s_hdr *) (skb->data + hdrlen);
1895
Thomas Pedersen2157fdd2011-09-01 12:32:14 -07001896 /* frame is in RMC, don't forward */
1897 if (ieee80211_is_data(hdr->frame_control) &&
1898 is_multicast_ether_addr(hdr->addr1) &&
1899 mesh_rmc_check(hdr->addr3, mesh_hdr, rx->sdata))
1900 return RX_DROP_MONITOR;
1901
Luis Carlos Coboe32f85f2008-08-05 19:34:52 +02001902 if (!ieee80211_is_data(hdr->frame_control))
1903 return RX_CONTINUE;
1904
1905 if (!mesh_hdr->ttl)
Luis Carlos Coboe32f85f2008-08-05 19:34:52 +02001906 return RX_DROP_MONITOR;
1907
Javier Cardona43b7b312009-10-15 18:10:51 -07001908 if (mesh_hdr->flags & MESH_FLAGS_AE) {
YanBo79617de2008-09-22 13:30:32 +08001909 struct mesh_path *mppath;
Javier Cardona43b7b312009-10-15 18:10:51 -07001910 char *proxied_addr;
1911 char *mpp_addr;
1912
1913 if (is_multicast_ether_addr(hdr->addr1)) {
1914 mpp_addr = hdr->addr3;
1915 proxied_addr = mesh_hdr->eaddr1;
1916 } else {
1917 mpp_addr = hdr->addr4;
1918 proxied_addr = mesh_hdr->eaddr2;
1919 }
YanBo79617de2008-09-22 13:30:32 +08001920
YanBo79617de2008-09-22 13:30:32 +08001921 rcu_read_lock();
Javier Cardona43b7b312009-10-15 18:10:51 -07001922 mppath = mpp_path_lookup(proxied_addr, sdata);
YanBo79617de2008-09-22 13:30:32 +08001923 if (!mppath) {
Javier Cardona43b7b312009-10-15 18:10:51 -07001924 mpp_path_add(proxied_addr, mpp_addr, sdata);
YanBo79617de2008-09-22 13:30:32 +08001925 } else {
1926 spin_lock_bh(&mppath->state_lock);
Javier Cardona43b7b312009-10-15 18:10:51 -07001927 if (compare_ether_addr(mppath->mpp, mpp_addr) != 0)
1928 memcpy(mppath->mpp, mpp_addr, ETH_ALEN);
YanBo79617de2008-09-22 13:30:32 +08001929 spin_unlock_bh(&mppath->state_lock);
1930 }
1931 rcu_read_unlock();
1932 }
1933
Javier Cardona3c5772a2009-08-10 12:15:48 -07001934 /* Frame has reached destination. Don't forward */
1935 if (!is_multicast_ether_addr(hdr->addr1) &&
Johannes Berg47846c92009-11-25 17:46:19 +01001936 compare_ether_addr(sdata->vif.addr, hdr->addr3) == 0)
Luis Carlos Coboe32f85f2008-08-05 19:34:52 +02001937 return RX_CONTINUE;
1938
Thomas Pedersend3c15972011-11-24 17:15:23 -08001939 q = ieee80211_select_queue_80211(local, skb, hdr);
1940 if (ieee80211_queue_stopped(&local->hw, q)) {
Thomas Pedersen30789eb2011-11-24 17:15:26 -08001941 IEEE80211_IFSTA_MESH_CTR_INC(ifmsh, dropped_frames_congestion);
Thomas Pedersend3c15972011-11-24 17:15:23 -08001942 return RX_DROP_MONITOR;
1943 }
1944 skb_set_queue_mapping(skb, q);
Luis Carlos Coboe32f85f2008-08-05 19:34:52 +02001945
Thomas Pedersen30789eb2011-11-24 17:15:26 -08001946 if (!(status->rx_flags & IEEE80211_RX_RA_MATCH))
1947 goto out;
Johannes Berg3b8d81e02009-06-17 17:43:56 +02001948
Thomas Pedersen30789eb2011-11-24 17:15:26 -08001949 if (!--mesh_hdr->ttl) {
1950 IEEE80211_IFSTA_MESH_CTR_INC(ifmsh, dropped_frames_ttl);
1951 return RX_DROP_MONITOR;
Luis Carlos Coboe32f85f2008-08-05 19:34:52 +02001952 }
1953
Chun-Yeow Yeohd6655082012-03-02 02:03:19 +08001954 if (!ifmsh->mshcfg.dot11MeshForwarding)
1955 goto out;
1956
Thomas Pedersen30789eb2011-11-24 17:15:26 -08001957 fwd_skb = skb_copy(skb, GFP_ATOMIC);
1958 if (!fwd_skb) {
1959 if (net_ratelimit())
1960 printk(KERN_DEBUG "%s: failed to clone mesh frame\n",
1961 sdata->name);
1962 goto out;
1963 }
1964
1965 fwd_hdr = (struct ieee80211_hdr *) fwd_skb->data;
1966 info = IEEE80211_SKB_CB(fwd_skb);
1967 memset(info, 0, sizeof(*info));
1968 info->flags |= IEEE80211_TX_INTFL_NEED_TXPROCESSING;
1969 info->control.vif = &rx->sdata->vif;
1970 info->control.jiffies = jiffies;
1971 if (is_multicast_ether_addr(fwd_hdr->addr1)) {
1972 IEEE80211_IFSTA_MESH_CTR_INC(ifmsh, fwded_mcast);
1973 memcpy(fwd_hdr->addr2, sdata->vif.addr, ETH_ALEN);
1974 } else if (!mesh_nexthop_lookup(fwd_skb, sdata)) {
1975 IEEE80211_IFSTA_MESH_CTR_INC(ifmsh, fwded_unicast);
1976 } else {
1977 /* unable to resolve next hop */
1978 mesh_path_error_tx(ifmsh->mshcfg.element_ttl, fwd_hdr->addr3,
1979 0, reason, fwd_hdr->addr2, sdata);
1980 IEEE80211_IFSTA_MESH_CTR_INC(ifmsh, dropped_frames_no_route);
Jesper Juhl74b8cc32012-01-14 21:52:17 +01001981 kfree_skb(fwd_skb);
Thomas Pedersen30789eb2011-11-24 17:15:26 -08001982 return RX_DROP_MONITOR;
1983 }
1984
1985 IEEE80211_IFSTA_MESH_CTR_INC(ifmsh, fwded_frames);
1986 ieee80211_add_pending_skb(local, fwd_skb);
Johannes Bergb51aff02010-12-22 10:15:07 +01001987 out:
Javier Cardona3c5772a2009-08-10 12:15:48 -07001988 if (is_multicast_ether_addr(hdr->addr1) ||
Johannes Bergeb9fb5b2009-11-16 13:58:20 +01001989 sdata->dev->flags & IFF_PROMISC)
Luis Carlos Coboe32f85f2008-08-05 19:34:52 +02001990 return RX_CONTINUE;
1991 else
1992 return RX_DROP_MONITOR;
1993}
Ingo Molnarbf94e172008-10-12 23:51:38 -07001994#endif
Luis Carlos Coboe32f85f2008-08-05 19:34:52 +02001995
1996static ieee80211_rx_result debug_noinline
Johannes Berg5cf121c2008-02-25 16:27:43 +01001997ieee80211_rx_h_data(struct ieee80211_rx_data *rx)
Ron Rindjunsky76ee65b2007-11-22 19:49:12 +02001998{
Johannes Bergeb9fb5b2009-11-16 13:58:20 +01001999 struct ieee80211_sub_if_data *sdata = rx->sdata;
Vivek Natarajane15276a2010-02-08 17:47:01 +05302000 struct ieee80211_local *local = rx->local;
Johannes Bergeb9fb5b2009-11-16 13:58:20 +01002001 struct net_device *dev = sdata->dev;
Harvey Harrison358c8d92008-07-15 18:44:13 -07002002 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
2003 __le16 fc = hdr->frame_control;
Felix Fietkau4114fa22011-04-12 19:15:22 +02002004 bool port_control;
Johannes Bergce3edf6d02007-12-19 01:31:22 +01002005 int err;
Ron Rindjunsky76ee65b2007-11-22 19:49:12 +02002006
Harvey Harrison358c8d92008-07-15 18:44:13 -07002007 if (unlikely(!ieee80211_is_data(hdr->frame_control)))
Johannes Berg9ae54c82008-01-31 19:48:20 +01002008 return RX_CONTINUE;
Ron Rindjunsky76ee65b2007-11-22 19:49:12 +02002009
Harvey Harrison358c8d92008-07-15 18:44:13 -07002010 if (unlikely(!ieee80211_is_data_present(hdr->frame_control)))
Johannes Berge4c26ad2008-01-31 19:48:21 +01002011 return RX_DROP_MONITOR;
Ron Rindjunsky76ee65b2007-11-22 19:49:12 +02002012
Felix Fietkauf14543ee2009-11-10 20:10:05 +01002013 /*
Johannes Berge7f4a942011-11-04 11:18:20 +01002014 * Send unexpected-4addr-frame event to hostapd. For older versions,
2015 * also drop the frame to cooked monitor interfaces.
Felix Fietkauf14543ee2009-11-10 20:10:05 +01002016 */
2017 if (ieee80211_has_a4(hdr->frame_control) &&
Johannes Berge7f4a942011-11-04 11:18:20 +01002018 sdata->vif.type == NL80211_IFTYPE_AP) {
2019 if (rx->sta &&
2020 !test_and_set_sta_flag(rx->sta, WLAN_STA_4ADDR_EVENT))
2021 cfg80211_rx_unexpected_4addr_frame(
2022 rx->sdata->dev, rx->sta->sta.addr, GFP_ATOMIC);
Felix Fietkauf14543ee2009-11-10 20:10:05 +01002023 return RX_DROP_MONITOR;
Johannes Berge7f4a942011-11-04 11:18:20 +01002024 }
Felix Fietkauf14543ee2009-11-10 20:10:05 +01002025
Felix Fietkau4114fa22011-04-12 19:15:22 +02002026 err = __ieee80211_data_to_8023(rx, &port_control);
Ron Rindjunsky76ee65b2007-11-22 19:49:12 +02002027 if (unlikely(err))
Johannes Berge4c26ad2008-01-31 19:48:21 +01002028 return RX_DROP_UNUSABLE;
Ron Rindjunsky76ee65b2007-11-22 19:49:12 +02002029
Harvey Harrison358c8d92008-07-15 18:44:13 -07002030 if (!ieee80211_frame_allowed(rx, fc))
Johannes Berge4c26ad2008-01-31 19:48:21 +01002031 return RX_DROP_MONITOR;
Johannes Bergce3edf6d02007-12-19 01:31:22 +01002032
Felix Fietkau4114fa22011-04-12 19:15:22 +02002033 if (rx->sdata->vif.type == NL80211_IFTYPE_AP_VLAN &&
2034 unlikely(port_control) && sdata->bss) {
2035 sdata = container_of(sdata->bss, struct ieee80211_sub_if_data,
2036 u.ap);
2037 dev = sdata->dev;
2038 rx->sdata = sdata;
2039 }
2040
Ron Rindjunsky76ee65b2007-11-22 19:49:12 +02002041 rx->skb->dev = dev;
2042
2043 dev->stats.rx_packets++;
2044 dev->stats.rx_bytes += rx->skb->len;
2045
Helmut Schaa08ca9442010-11-30 12:19:34 +01002046 if (local->ps_sdata && local->hw.conf.dynamic_ps_timeout > 0 &&
Rajkumar Manoharan8c99f692011-02-02 22:57:53 +05302047 !is_multicast_ether_addr(
2048 ((struct ethhdr *)rx->skb->data)->h_dest) &&
2049 (!local->scanning &&
2050 !test_bit(SDATA_STATE_OFFCHANNEL, &sdata->state))) {
Vivek Natarajane15276a2010-02-08 17:47:01 +05302051 mod_timer(&local->dynamic_ps_timer, jiffies +
2052 msecs_to_jiffies(local->hw.conf.dynamic_ps_timeout));
2053 }
2054
Ron Rindjunsky76ee65b2007-11-22 19:49:12 +02002055 ieee80211_deliver_skb(rx);
Johannes Berg571ecf62007-07-27 15:43:22 +02002056
Johannes Berg9ae54c82008-01-31 19:48:20 +01002057 return RX_QUEUED;
Johannes Berg571ecf62007-07-27 15:43:22 +02002058}
2059
Johannes Berg49461622008-06-30 15:10:45 +02002060static ieee80211_rx_result debug_noinline
Christian Lamparter24a8fda2010-12-30 17:25:29 +01002061ieee80211_rx_h_ctrl(struct ieee80211_rx_data *rx)
Ron Rindjunsky71364712007-12-25 17:00:36 +02002062{
2063 struct ieee80211_local *local = rx->local;
2064 struct ieee80211_hw *hw = &local->hw;
2065 struct sk_buff *skb = rx->skb;
Harvey Harrisona7767f92008-07-02 16:30:51 -07002066 struct ieee80211_bar *bar = (struct ieee80211_bar *)skb->data;
Ron Rindjunsky71364712007-12-25 17:00:36 +02002067 struct tid_ampdu_rx *tid_agg_rx;
2068 u16 start_seq_num;
2069 u16 tid;
2070
Harvey Harrisona7767f92008-07-02 16:30:51 -07002071 if (likely(!ieee80211_is_ctl(bar->frame_control)))
Johannes Berg9ae54c82008-01-31 19:48:20 +01002072 return RX_CONTINUE;
Ron Rindjunsky71364712007-12-25 17:00:36 +02002073
Harvey Harrisona7767f92008-07-02 16:30:51 -07002074 if (ieee80211_is_back_req(bar->frame_control)) {
Johannes Berg8ae59772010-05-30 14:52:58 +02002075 struct {
2076 __le16 control, start_seq_num;
2077 } __packed bar_data;
2078
Ron Rindjunsky71364712007-12-25 17:00:36 +02002079 if (!rx->sta)
Johannes Berga02ae752009-11-16 12:00:40 +01002080 return RX_DROP_MONITOR;
Johannes Berg8ae59772010-05-30 14:52:58 +02002081
2082 if (skb_copy_bits(skb, offsetof(struct ieee80211_bar, control),
2083 &bar_data, sizeof(bar_data)))
2084 return RX_DROP_MONITOR;
2085
Johannes Berg8ae59772010-05-30 14:52:58 +02002086 tid = le16_to_cpu(bar_data.control) >> 12;
Johannes Berga87f7362010-06-10 10:21:38 +02002087
2088 tid_agg_rx = rcu_dereference(rx->sta->ampdu_mlme.tid_rx[tid]);
2089 if (!tid_agg_rx)
Johannes Berga02ae752009-11-16 12:00:40 +01002090 return RX_DROP_MONITOR;
Ron Rindjunsky71364712007-12-25 17:00:36 +02002091
Johannes Berg8ae59772010-05-30 14:52:58 +02002092 start_seq_num = le16_to_cpu(bar_data.start_seq_num) >> 4;
Ron Rindjunsky71364712007-12-25 17:00:36 +02002093
2094 /* reset session timer */
Johannes Berg20ad19d2009-02-10 21:25:45 +01002095 if (tid_agg_rx->timeout)
2096 mod_timer(&tid_agg_rx->session_timer,
2097 TU_TO_EXP_TIME(tid_agg_rx->timeout));
Ron Rindjunsky71364712007-12-25 17:00:36 +02002098
Johannes Bergdd318572010-11-29 11:09:16 +01002099 spin_lock(&tid_agg_rx->reorder_lock);
Johannes Berga02ae752009-11-16 12:00:40 +01002100 /* release stored frames up to start of BAR */
Christian Lamparter24a8fda2010-12-30 17:25:29 +01002101 ieee80211_release_reorder_frames(hw, tid_agg_rx, start_seq_num);
Johannes Bergdd318572010-11-29 11:09:16 +01002102 spin_unlock(&tid_agg_rx->reorder_lock);
2103
Johannes Berga02ae752009-11-16 12:00:40 +01002104 kfree_skb(skb);
2105 return RX_QUEUED;
Ron Rindjunsky71364712007-12-25 17:00:36 +02002106 }
2107
Johannes Berg08daeca2010-05-30 14:53:43 +02002108 /*
2109 * After this point, we only want management frames,
2110 * so we can drop all remaining control frames to
2111 * cooked monitor interfaces.
2112 */
2113 return RX_DROP_MONITOR;
Ron Rindjunsky71364712007-12-25 17:00:36 +02002114}
2115
Jouni Malinenf4f727a2009-01-10 11:46:53 +02002116static void ieee80211_process_sa_query_req(struct ieee80211_sub_if_data *sdata,
2117 struct ieee80211_mgmt *mgmt,
2118 size_t len)
Jouni Malinenfea14732009-01-08 13:32:06 +02002119{
2120 struct ieee80211_local *local = sdata->local;
2121 struct sk_buff *skb;
2122 struct ieee80211_mgmt *resp;
2123
Johannes Berg47846c92009-11-25 17:46:19 +01002124 if (compare_ether_addr(mgmt->da, sdata->vif.addr) != 0) {
Jouni Malinenfea14732009-01-08 13:32:06 +02002125 /* Not to own unicast address */
2126 return;
2127 }
2128
Johannes Berg46900292009-02-15 12:44:28 +01002129 if (compare_ether_addr(mgmt->sa, sdata->u.mgd.bssid) != 0 ||
2130 compare_ether_addr(mgmt->bssid, sdata->u.mgd.bssid) != 0) {
Johannes Berg77fdaa12009-07-07 03:45:17 +02002131 /* Not from the current AP or not associated yet. */
Jouni Malinenfea14732009-01-08 13:32:06 +02002132 return;
2133 }
2134
2135 if (len < 24 + 1 + sizeof(resp->u.action.u.sa_query)) {
2136 /* Too short SA Query request frame */
2137 return;
2138 }
2139
2140 skb = dev_alloc_skb(sizeof(*resp) + local->hw.extra_tx_headroom);
2141 if (skb == NULL)
2142 return;
2143
2144 skb_reserve(skb, local->hw.extra_tx_headroom);
2145 resp = (struct ieee80211_mgmt *) skb_put(skb, 24);
2146 memset(resp, 0, 24);
2147 memcpy(resp->da, mgmt->sa, ETH_ALEN);
Johannes Berg47846c92009-11-25 17:46:19 +01002148 memcpy(resp->sa, sdata->vif.addr, ETH_ALEN);
Johannes Berg46900292009-02-15 12:44:28 +01002149 memcpy(resp->bssid, sdata->u.mgd.bssid, ETH_ALEN);
Jouni Malinenfea14732009-01-08 13:32:06 +02002150 resp->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
2151 IEEE80211_STYPE_ACTION);
2152 skb_put(skb, 1 + sizeof(resp->u.action.u.sa_query));
2153 resp->u.action.category = WLAN_CATEGORY_SA_QUERY;
2154 resp->u.action.u.sa_query.action = WLAN_ACTION_SA_QUERY_RESPONSE;
2155 memcpy(resp->u.action.u.sa_query.trans_id,
2156 mgmt->u.action.u.sa_query.trans_id,
2157 WLAN_SA_QUERY_TR_ID_LEN);
2158
Johannes Berg62ae67b2009-11-18 18:42:05 +01002159 ieee80211_tx_skb(sdata, skb);
Jouni Malinenfea14732009-01-08 13:32:06 +02002160}
2161
Johannes Berg49461622008-06-30 15:10:45 +02002162static ieee80211_rx_result debug_noinline
Johannes Berg2e161f72010-08-12 15:38:38 +02002163ieee80211_rx_h_mgmt_check(struct ieee80211_rx_data *rx)
2164{
2165 struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *) rx->skb->data;
Johannes Berg554891e2010-09-24 12:38:25 +02002166 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb);
Johannes Berg2e161f72010-08-12 15:38:38 +02002167
2168 /*
2169 * From here on, look only at management frames.
2170 * Data and control frames are already handled,
2171 * and unknown (reserved) frames are useless.
2172 */
2173 if (rx->skb->len < 24)
2174 return RX_DROP_MONITOR;
2175
2176 if (!ieee80211_is_mgmt(mgmt->frame_control))
2177 return RX_DROP_MONITOR;
2178
Johannes Bergee971922011-11-04 11:18:18 +01002179 if (rx->sdata->vif.type == NL80211_IFTYPE_AP &&
2180 ieee80211_is_beacon(mgmt->frame_control) &&
2181 !(rx->flags & IEEE80211_RX_BEACON_REPORTED)) {
Johannes Berg804483e2012-03-05 22:18:41 +01002182 int sig = 0;
2183
2184 if (rx->local->hw.flags & IEEE80211_HW_SIGNAL_DBM)
2185 sig = status->signal;
2186
Johannes Bergee971922011-11-04 11:18:18 +01002187 cfg80211_report_obss_beacon(rx->local->hw.wiphy,
2188 rx->skb->data, rx->skb->len,
Johannes Berg804483e2012-03-05 22:18:41 +01002189 status->freq, sig, GFP_ATOMIC);
Johannes Bergee971922011-11-04 11:18:18 +01002190 rx->flags |= IEEE80211_RX_BEACON_REPORTED;
2191 }
2192
Johannes Berg554891e2010-09-24 12:38:25 +02002193 if (!(status->rx_flags & IEEE80211_RX_RA_MATCH))
Johannes Berg2e161f72010-08-12 15:38:38 +02002194 return RX_DROP_MONITOR;
2195
2196 if (ieee80211_drop_unencrypted_mgmt(rx))
2197 return RX_DROP_UNUSABLE;
2198
2199 return RX_CONTINUE;
2200}
2201
2202static ieee80211_rx_result debug_noinline
Johannes Bergde1ede72008-09-09 14:42:50 +02002203ieee80211_rx_h_action(struct ieee80211_rx_data *rx)
2204{
2205 struct ieee80211_local *local = rx->local;
Johannes Bergeb9fb5b2009-11-16 13:58:20 +01002206 struct ieee80211_sub_if_data *sdata = rx->sdata;
Johannes Bergde1ede72008-09-09 14:42:50 +02002207 struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *) rx->skb->data;
Johannes Berg554891e2010-09-24 12:38:25 +02002208 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb);
Johannes Bergde1ede72008-09-09 14:42:50 +02002209 int len = rx->skb->len;
2210
2211 if (!ieee80211_is_action(mgmt->frame_control))
2212 return RX_CONTINUE;
2213
Jouni Malinen026331c2010-02-15 12:53:10 +02002214 /* drop too small frames */
2215 if (len < IEEE80211_MIN_ACTION_SIZE)
2216 return RX_DROP_UNUSABLE;
2217
2218 if (!rx->sta && mgmt->u.action.category != WLAN_CATEGORY_PUBLIC)
Johannes Berg84040802010-02-15 12:46:39 +02002219 return RX_DROP_UNUSABLE;
Johannes Bergde1ede72008-09-09 14:42:50 +02002220
Johannes Berg554891e2010-09-24 12:38:25 +02002221 if (!(status->rx_flags & IEEE80211_RX_RA_MATCH))
Johannes Berg84040802010-02-15 12:46:39 +02002222 return RX_DROP_UNUSABLE;
Johannes Bergde1ede72008-09-09 14:42:50 +02002223
Johannes Bergde1ede72008-09-09 14:42:50 +02002224 switch (mgmt->u.action.category) {
Johannes Berg1d8d3de2011-12-16 15:28:57 +01002225 case WLAN_CATEGORY_HT:
2226 /* reject HT action frames from stations not supporting HT */
2227 if (!rx->sta->sta.ht_cap.ht_supported)
2228 goto invalid;
2229
2230 if (sdata->vif.type != NL80211_IFTYPE_STATION &&
2231 sdata->vif.type != NL80211_IFTYPE_MESH_POINT &&
2232 sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
2233 sdata->vif.type != NL80211_IFTYPE_AP &&
2234 sdata->vif.type != NL80211_IFTYPE_ADHOC)
2235 break;
2236
2237 /* verify action & smps_control are present */
2238 if (len < IEEE80211_MIN_ACTION_SIZE + 2)
2239 goto invalid;
2240
2241 switch (mgmt->u.action.u.ht_smps.action) {
2242 case WLAN_HT_ACTION_SMPS: {
2243 struct ieee80211_supported_band *sband;
2244 u8 smps;
2245
2246 /* convert to HT capability */
2247 switch (mgmt->u.action.u.ht_smps.smps_control) {
2248 case WLAN_HT_SMPS_CONTROL_DISABLED:
2249 smps = WLAN_HT_CAP_SM_PS_DISABLED;
2250 break;
2251 case WLAN_HT_SMPS_CONTROL_STATIC:
2252 smps = WLAN_HT_CAP_SM_PS_STATIC;
2253 break;
2254 case WLAN_HT_SMPS_CONTROL_DYNAMIC:
2255 smps = WLAN_HT_CAP_SM_PS_DYNAMIC;
2256 break;
2257 default:
2258 goto invalid;
2259 }
2260 smps <<= IEEE80211_HT_CAP_SM_PS_SHIFT;
2261
2262 /* if no change do nothing */
2263 if ((rx->sta->sta.ht_cap.cap &
2264 IEEE80211_HT_CAP_SM_PS) == smps)
2265 goto handled;
2266
2267 rx->sta->sta.ht_cap.cap &= ~IEEE80211_HT_CAP_SM_PS;
2268 rx->sta->sta.ht_cap.cap |= smps;
2269
2270 sband = rx->local->hw.wiphy->bands[status->band];
2271
Paul Stewart3117bbdb2012-03-13 07:46:18 -07002272 rate_control_rate_update(
2273 local, sband, rx->sta,
2274 IEEE80211_RC_SMPS_CHANGED,
2275 ieee80211_get_tx_channel_type(
2276 local, local->_oper_channel_type));
Johannes Berg1d8d3de2011-12-16 15:28:57 +01002277 goto handled;
2278 }
2279 default:
2280 goto invalid;
2281 }
2282
2283 break;
Johannes Bergde1ede72008-09-09 14:42:50 +02002284 case WLAN_CATEGORY_BACK:
Johannes Berg8abd3f92009-02-10 21:25:47 +01002285 if (sdata->vif.type != NL80211_IFTYPE_STATION &&
Thomas Pedersenae2772b2011-10-26 14:47:29 -07002286 sdata->vif.type != NL80211_IFTYPE_MESH_POINT &&
Johannes Berg8abd3f92009-02-10 21:25:47 +01002287 sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
Alexander Simon13c40c52011-11-30 16:56:34 +01002288 sdata->vif.type != NL80211_IFTYPE_AP &&
2289 sdata->vif.type != NL80211_IFTYPE_ADHOC)
Johannes Berg84040802010-02-15 12:46:39 +02002290 break;
Johannes Berg8abd3f92009-02-10 21:25:47 +01002291
Jouni Malinen026331c2010-02-15 12:53:10 +02002292 /* verify action_code is present */
2293 if (len < IEEE80211_MIN_ACTION_SIZE + 1)
2294 break;
2295
Johannes Bergde1ede72008-09-09 14:42:50 +02002296 switch (mgmt->u.action.u.addba_req.action_code) {
2297 case WLAN_ACTION_ADDBA_REQ:
2298 if (len < (IEEE80211_MIN_ACTION_SIZE +
2299 sizeof(mgmt->u.action.u.addba_req)))
Johannes Bergbed7ee6e2010-06-10 10:21:35 +02002300 goto invalid;
2301 break;
Johannes Bergde1ede72008-09-09 14:42:50 +02002302 case WLAN_ACTION_ADDBA_RESP:
2303 if (len < (IEEE80211_MIN_ACTION_SIZE +
2304 sizeof(mgmt->u.action.u.addba_resp)))
Johannes Bergbed7ee6e2010-06-10 10:21:35 +02002305 goto invalid;
2306 break;
Johannes Bergde1ede72008-09-09 14:42:50 +02002307 case WLAN_ACTION_DELBA:
2308 if (len < (IEEE80211_MIN_ACTION_SIZE +
2309 sizeof(mgmt->u.action.u.delba)))
Johannes Bergbed7ee6e2010-06-10 10:21:35 +02002310 goto invalid;
2311 break;
2312 default:
2313 goto invalid;
Johannes Bergde1ede72008-09-09 14:42:50 +02002314 }
Johannes Bergbed7ee6e2010-06-10 10:21:35 +02002315
Johannes Berg8b58ff82010-06-10 10:21:51 +02002316 goto queue;
Johannes Berg39192c02008-09-09 14:49:03 +02002317 case WLAN_CATEGORY_SPECTRUM_MGMT:
2318 if (local->hw.conf.channel->band != IEEE80211_BAND_5GHZ)
Johannes Berg84040802010-02-15 12:46:39 +02002319 break;
Johannes Berg46900292009-02-15 12:44:28 +01002320
2321 if (sdata->vif.type != NL80211_IFTYPE_STATION)
Johannes Berg84040802010-02-15 12:46:39 +02002322 break;
Johannes Berg46900292009-02-15 12:44:28 +01002323
Jouni Malinen026331c2010-02-15 12:53:10 +02002324 /* verify action_code is present */
2325 if (len < IEEE80211_MIN_ACTION_SIZE + 1)
2326 break;
2327
Johannes Berg39192c02008-09-09 14:49:03 +02002328 switch (mgmt->u.action.u.measurement.action_code) {
2329 case WLAN_ACTION_SPCT_MSR_REQ:
2330 if (len < (IEEE80211_MIN_ACTION_SIZE +
2331 sizeof(mgmt->u.action.u.measurement)))
Johannes Berg84040802010-02-15 12:46:39 +02002332 break;
Johannes Berg39192c02008-09-09 14:49:03 +02002333 ieee80211_process_measurement_req(sdata, mgmt, len);
Johannes Berg84040802010-02-15 12:46:39 +02002334 goto handled;
Sujithc481ec92009-01-06 09:28:37 +05302335 case WLAN_ACTION_SPCT_CHL_SWITCH:
2336 if (len < (IEEE80211_MIN_ACTION_SIZE +
2337 sizeof(mgmt->u.action.u.chan_switch)))
Johannes Berg84040802010-02-15 12:46:39 +02002338 break;
Sujithc481ec92009-01-06 09:28:37 +05302339
Johannes Bergcc32abd2009-05-15 11:52:31 +02002340 if (sdata->vif.type != NL80211_IFTYPE_STATION)
Johannes Berg84040802010-02-15 12:46:39 +02002341 break;
Johannes Bergcc32abd2009-05-15 11:52:31 +02002342
Felix Fietkau888d04d2012-03-01 15:22:09 +01002343 if (compare_ether_addr(mgmt->bssid, sdata->u.mgd.bssid))
Johannes Berg84040802010-02-15 12:46:39 +02002344 break;
Sujithc481ec92009-01-06 09:28:37 +05302345
Johannes Berg8b58ff82010-06-10 10:21:51 +02002346 goto queue;
Johannes Berg39192c02008-09-09 14:49:03 +02002347 }
2348 break;
Jouni Malinenfea14732009-01-08 13:32:06 +02002349 case WLAN_CATEGORY_SA_QUERY:
2350 if (len < (IEEE80211_MIN_ACTION_SIZE +
2351 sizeof(mgmt->u.action.u.sa_query)))
Johannes Berg84040802010-02-15 12:46:39 +02002352 break;
2353
Jouni Malinenfea14732009-01-08 13:32:06 +02002354 switch (mgmt->u.action.u.sa_query.action) {
2355 case WLAN_ACTION_SA_QUERY_REQUEST:
2356 if (sdata->vif.type != NL80211_IFTYPE_STATION)
Johannes Berg84040802010-02-15 12:46:39 +02002357 break;
Jouni Malinenfea14732009-01-08 13:32:06 +02002358 ieee80211_process_sa_query_req(sdata, mgmt, len);
Johannes Berg84040802010-02-15 12:46:39 +02002359 goto handled;
Jouni Malinenfea14732009-01-08 13:32:06 +02002360 }
2361 break;
Thomas Pedersen8db09852011-08-12 20:01:00 -07002362 case WLAN_CATEGORY_SELF_PROTECTED:
2363 switch (mgmt->u.action.u.self_prot.action_code) {
2364 case WLAN_SP_MESH_PEERING_OPEN:
2365 case WLAN_SP_MESH_PEERING_CLOSE:
2366 case WLAN_SP_MESH_PEERING_CONFIRM:
2367 if (!ieee80211_vif_is_mesh(&sdata->vif))
2368 goto invalid;
2369 if (sdata->u.mesh.security != IEEE80211_MESH_SEC_NONE)
2370 /* userspace handles this frame */
2371 break;
2372 goto queue;
2373 case WLAN_SP_MGK_INFORM:
2374 case WLAN_SP_MGK_ACK:
2375 if (!ieee80211_vif_is_mesh(&sdata->vif))
2376 goto invalid;
2377 break;
2378 }
2379 break;
Javier Cardonad3aaec8a2011-05-03 16:57:09 -07002380 case WLAN_CATEGORY_MESH_ACTION:
Johannes Berg77a121c2010-06-10 10:21:34 +02002381 if (!ieee80211_vif_is_mesh(&sdata->vif))
2382 break;
Thomas Pedersen25d49e42011-08-11 19:35:15 -07002383 if (mesh_action_is_path_sel(mgmt) &&
2384 (!mesh_path_sel_is_hwmp(sdata)))
Javier Cardonac7108a72010-12-16 17:37:50 -08002385 break;
2386 goto queue;
Johannes Berg84040802010-02-15 12:46:39 +02002387 }
Jouni Malinen026331c2010-02-15 12:53:10 +02002388
Johannes Berg2e161f72010-08-12 15:38:38 +02002389 return RX_CONTINUE;
2390
Johannes Bergbed7ee6e2010-06-10 10:21:35 +02002391 invalid:
Johannes Berg554891e2010-09-24 12:38:25 +02002392 status->rx_flags |= IEEE80211_RX_MALFORMED_ACTION_FRM;
Johannes Berg2e161f72010-08-12 15:38:38 +02002393 /* will return in the next handlers */
2394 return RX_CONTINUE;
2395
2396 handled:
2397 if (rx->sta)
2398 rx->sta->rx_packets++;
2399 dev_kfree_skb(rx->skb);
2400 return RX_QUEUED;
2401
2402 queue:
2403 rx->skb->pkt_type = IEEE80211_SDATA_QUEUE_TYPE_FRAME;
2404 skb_queue_tail(&sdata->skb_queue, rx->skb);
2405 ieee80211_queue_work(&local->hw, &sdata->work);
2406 if (rx->sta)
2407 rx->sta->rx_packets++;
2408 return RX_QUEUED;
2409}
2410
2411static ieee80211_rx_result debug_noinline
2412ieee80211_rx_h_userspace_mgmt(struct ieee80211_rx_data *rx)
2413{
Johannes Berg554891e2010-09-24 12:38:25 +02002414 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb);
Johannes Berg804483e2012-03-05 22:18:41 +01002415 int sig = 0;
Johannes Berg2e161f72010-08-12 15:38:38 +02002416
2417 /* skip known-bad action frames and return them in the next handler */
Johannes Berg554891e2010-09-24 12:38:25 +02002418 if (status->rx_flags & IEEE80211_RX_MALFORMED_ACTION_FRM)
Johannes Berg2e161f72010-08-12 15:38:38 +02002419 return RX_CONTINUE;
Felix Fietkaud7907442010-01-07 20:23:53 +01002420
Jouni Malinen026331c2010-02-15 12:53:10 +02002421 /*
2422 * Getting here means the kernel doesn't know how to handle
2423 * it, but maybe userspace does ... include returned frames
2424 * so userspace can register for those to know whether ones
2425 * it transmitted were processed or returned.
2426 */
Jouni Malinen026331c2010-02-15 12:53:10 +02002427
Johannes Berg804483e2012-03-05 22:18:41 +01002428 if (rx->local->hw.flags & IEEE80211_HW_SIGNAL_DBM)
2429 sig = status->signal;
2430
2431 if (cfg80211_rx_mgmt(rx->sdata->dev, status->freq, sig,
Johannes Berg2e161f72010-08-12 15:38:38 +02002432 rx->skb->data, rx->skb->len,
2433 GFP_ATOMIC)) {
2434 if (rx->sta)
2435 rx->sta->rx_packets++;
2436 dev_kfree_skb(rx->skb);
2437 return RX_QUEUED;
2438 }
2439
2440
2441 return RX_CONTINUE;
2442}
2443
2444static ieee80211_rx_result debug_noinline
2445ieee80211_rx_h_action_return(struct ieee80211_rx_data *rx)
2446{
2447 struct ieee80211_local *local = rx->local;
2448 struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *) rx->skb->data;
2449 struct sk_buff *nskb;
2450 struct ieee80211_sub_if_data *sdata = rx->sdata;
Johannes Berg554891e2010-09-24 12:38:25 +02002451 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb);
Johannes Berg2e161f72010-08-12 15:38:38 +02002452
2453 if (!ieee80211_is_action(mgmt->frame_control))
2454 return RX_CONTINUE;
2455
2456 /*
2457 * For AP mode, hostapd is responsible for handling any action
2458 * frames that we didn't handle, including returning unknown
2459 * ones. For all other modes we will return them to the sender,
2460 * setting the 0x80 bit in the action category, as required by
2461 * 802.11-2007 7.3.1.11.
2462 * Newer versions of hostapd shall also use the management frame
2463 * registration mechanisms, but older ones still use cooked
2464 * monitor interfaces so push all frames there.
2465 */
Johannes Berg554891e2010-09-24 12:38:25 +02002466 if (!(status->rx_flags & IEEE80211_RX_MALFORMED_ACTION_FRM) &&
Johannes Berg2e161f72010-08-12 15:38:38 +02002467 (sdata->vif.type == NL80211_IFTYPE_AP ||
2468 sdata->vif.type == NL80211_IFTYPE_AP_VLAN))
2469 return RX_DROP_MONITOR;
Jouni Malinen026331c2010-02-15 12:53:10 +02002470
Johannes Berg84040802010-02-15 12:46:39 +02002471 /* do not return rejected action frames */
2472 if (mgmt->u.action.category & 0x80)
2473 return RX_DROP_UNUSABLE;
2474
2475 nskb = skb_copy_expand(rx->skb, local->hw.extra_tx_headroom, 0,
2476 GFP_ATOMIC);
2477 if (nskb) {
John W. Linville292b4df2010-06-24 11:13:56 -04002478 struct ieee80211_mgmt *nmgmt = (void *)nskb->data;
Johannes Berg84040802010-02-15 12:46:39 +02002479
John W. Linville292b4df2010-06-24 11:13:56 -04002480 nmgmt->u.action.category |= 0x80;
2481 memcpy(nmgmt->da, nmgmt->sa, ETH_ALEN);
2482 memcpy(nmgmt->sa, rx->sdata->vif.addr, ETH_ALEN);
Johannes Berg84040802010-02-15 12:46:39 +02002483
2484 memset(nskb->cb, 0, sizeof(nskb->cb));
2485
2486 ieee80211_tx_skb(rx->sdata, nskb);
Johannes Bergde1ede72008-09-09 14:42:50 +02002487 }
Johannes Berg39192c02008-09-09 14:49:03 +02002488 dev_kfree_skb(rx->skb);
2489 return RX_QUEUED;
Johannes Bergde1ede72008-09-09 14:42:50 +02002490}
2491
2492static ieee80211_rx_result debug_noinline
Johannes Berg5cf121c2008-02-25 16:27:43 +01002493ieee80211_rx_h_mgmt(struct ieee80211_rx_data *rx)
Johannes Berg571ecf62007-07-27 15:43:22 +02002494{
Johannes Bergeb9fb5b2009-11-16 13:58:20 +01002495 struct ieee80211_sub_if_data *sdata = rx->sdata;
Johannes Berg77a121c2010-06-10 10:21:34 +02002496 struct ieee80211_mgmt *mgmt = (void *)rx->skb->data;
2497 __le16 stype;
Johannes Berg571ecf62007-07-27 15:43:22 +02002498
Johannes Berg77a121c2010-06-10 10:21:34 +02002499 stype = mgmt->frame_control & cpu_to_le16(IEEE80211_FCTL_STYPE);
Johannes Berg472dbc42008-09-11 00:01:49 +02002500
Johannes Berg77a121c2010-06-10 10:21:34 +02002501 if (!ieee80211_vif_is_mesh(&sdata->vif) &&
2502 sdata->vif.type != NL80211_IFTYPE_ADHOC &&
2503 sdata->vif.type != NL80211_IFTYPE_STATION)
2504 return RX_DROP_MONITOR;
Johannes Bergf9d540e2007-09-28 14:02:09 +02002505
Johannes Berg77a121c2010-06-10 10:21:34 +02002506 switch (stype) {
Johannes Berg66e67e42012-01-20 13:55:27 +01002507 case cpu_to_le16(IEEE80211_STYPE_AUTH):
Johannes Berg77a121c2010-06-10 10:21:34 +02002508 case cpu_to_le16(IEEE80211_STYPE_BEACON):
2509 case cpu_to_le16(IEEE80211_STYPE_PROBE_RESP):
2510 /* process for all: mesh, mlme, ibss */
2511 break;
Johannes Berg66e67e42012-01-20 13:55:27 +01002512 case cpu_to_le16(IEEE80211_STYPE_ASSOC_RESP):
2513 case cpu_to_le16(IEEE80211_STYPE_REASSOC_RESP):
Johannes Berg77a121c2010-06-10 10:21:34 +02002514 case cpu_to_le16(IEEE80211_STYPE_DEAUTH):
2515 case cpu_to_le16(IEEE80211_STYPE_DISASSOC):
Christian Lamparter2c313332010-11-29 20:53:23 +01002516 if (is_multicast_ether_addr(mgmt->da) &&
2517 !is_broadcast_ether_addr(mgmt->da))
2518 return RX_DROP_MONITOR;
2519
Johannes Berg77a121c2010-06-10 10:21:34 +02002520 /* process only for station */
2521 if (sdata->vif.type != NL80211_IFTYPE_STATION)
2522 return RX_DROP_MONITOR;
2523 break;
2524 case cpu_to_le16(IEEE80211_STYPE_PROBE_REQ):
Johannes Berg77a121c2010-06-10 10:21:34 +02002525 /* process only for ibss */
2526 if (sdata->vif.type != NL80211_IFTYPE_ADHOC)
2527 return RX_DROP_MONITOR;
2528 break;
2529 default:
2530 return RX_DROP_MONITOR;
2531 }
Johannes Berg46900292009-02-15 12:44:28 +01002532
Johannes Berg77a121c2010-06-10 10:21:34 +02002533 /* queue up frame and kick off work to process it */
Johannes Bergc1475ca2010-06-10 10:21:37 +02002534 rx->skb->pkt_type = IEEE80211_SDATA_QUEUE_TYPE_FRAME;
Johannes Berg77a121c2010-06-10 10:21:34 +02002535 skb_queue_tail(&sdata->skb_queue, rx->skb);
2536 ieee80211_queue_work(&rx->local->hw, &sdata->work);
Johannes Berg8b58ff82010-06-10 10:21:51 +02002537 if (rx->sta)
2538 rx->sta->rx_packets++;
Johannes Berg77a121c2010-06-10 10:21:34 +02002539
2540 return RX_QUEUED;
Johannes Berg571ecf62007-07-27 15:43:22 +02002541}
2542
Johannes Berg5cf121c2008-02-25 16:27:43 +01002543/* TODO: use IEEE80211_RX_FRAGMENTED */
Johannes Berg5f0b7de2009-11-16 13:58:21 +01002544static void ieee80211_rx_cooked_monitor(struct ieee80211_rx_data *rx,
2545 struct ieee80211_rate *rate)
Michael Wu3d30d942008-01-31 19:48:27 +01002546{
2547 struct ieee80211_sub_if_data *sdata;
2548 struct ieee80211_local *local = rx->local;
Michael Wu3d30d942008-01-31 19:48:27 +01002549 struct sk_buff *skb = rx->skb, *skb2;
2550 struct net_device *prev_dev = NULL;
Johannes Bergeb9fb5b2009-11-16 13:58:20 +01002551 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
Johannes Berg293702a2012-03-02 13:18:19 +01002552 int needed_headroom;
Michael Wu3d30d942008-01-31 19:48:27 +01002553
Johannes Berg554891e2010-09-24 12:38:25 +02002554 /*
2555 * If cooked monitor has been processed already, then
2556 * don't do it again. If not, set the flag.
2557 */
2558 if (rx->flags & IEEE80211_RX_CMNTR)
John W. Linville7c1e1832010-09-24 15:52:49 -04002559 goto out_free_skb;
Johannes Berg554891e2010-09-24 12:38:25 +02002560 rx->flags |= IEEE80211_RX_CMNTR;
John W. Linville7c1e1832010-09-24 15:52:49 -04002561
Johannes Berg152c4772011-10-21 10:22:22 +02002562 /* If there are no cooked monitor interfaces, just free the SKB */
2563 if (!local->cooked_mntrs)
2564 goto out_free_skb;
2565
Johannes Berg293702a2012-03-02 13:18:19 +01002566 /* room for the radiotap header based on driver features */
2567 needed_headroom = ieee80211_rx_radiotap_len(local, status);
2568
2569 if (skb_headroom(skb) < needed_headroom &&
2570 pskb_expand_head(skb, needed_headroom, 0, GFP_ATOMIC))
Michael Wu3d30d942008-01-31 19:48:27 +01002571 goto out_free_skb;
2572
Johannes Berg293702a2012-03-02 13:18:19 +01002573 /* prepend radiotap information */
2574 ieee80211_add_rx_radiotap_header(local, skb, rate, needed_headroom);
Michael Wu3d30d942008-01-31 19:48:27 +01002575
2576 skb_set_mac_header(skb, 0);
2577 skb->ip_summed = CHECKSUM_UNNECESSARY;
2578 skb->pkt_type = PACKET_OTHERHOST;
2579 skb->protocol = htons(ETH_P_802_2);
2580
2581 list_for_each_entry_rcu(sdata, &local->interfaces, list) {
Johannes Berg9607e6b2009-12-23 13:15:31 +01002582 if (!ieee80211_sdata_running(sdata))
Michael Wu3d30d942008-01-31 19:48:27 +01002583 continue;
2584
Johannes Berg05c914f2008-09-11 00:01:58 +02002585 if (sdata->vif.type != NL80211_IFTYPE_MONITOR ||
Michael Wu3d30d942008-01-31 19:48:27 +01002586 !(sdata->u.mntr_flags & MONITOR_FLAG_COOK_FRAMES))
2587 continue;
2588
2589 if (prev_dev) {
2590 skb2 = skb_clone(skb, GFP_ATOMIC);
2591 if (skb2) {
2592 skb2->dev = prev_dev;
John W. Linville5548a8a2010-06-24 14:25:56 -04002593 netif_receive_skb(skb2);
Michael Wu3d30d942008-01-31 19:48:27 +01002594 }
2595 }
2596
2597 prev_dev = sdata->dev;
2598 sdata->dev->stats.rx_packets++;
2599 sdata->dev->stats.rx_bytes += skb->len;
2600 }
2601
2602 if (prev_dev) {
2603 skb->dev = prev_dev;
John W. Linville5548a8a2010-06-24 14:25:56 -04002604 netif_receive_skb(skb);
Johannes Berg554891e2010-09-24 12:38:25 +02002605 return;
2606 }
Michael Wu3d30d942008-01-31 19:48:27 +01002607
2608 out_free_skb:
2609 dev_kfree_skb(skb);
2610}
2611
Christian Lamparteraa0c8632010-08-05 01:36:04 +02002612static void ieee80211_rx_handlers_result(struct ieee80211_rx_data *rx,
2613 ieee80211_rx_result res)
2614{
2615 switch (res) {
2616 case RX_DROP_MONITOR:
2617 I802_DEBUG_INC(rx->sdata->local->rx_handlers_drop);
2618 if (rx->sta)
2619 rx->sta->rx_dropped++;
2620 /* fall through */
2621 case RX_CONTINUE: {
2622 struct ieee80211_rate *rate = NULL;
2623 struct ieee80211_supported_band *sband;
2624 struct ieee80211_rx_status *status;
2625
2626 status = IEEE80211_SKB_RXCB((rx->skb));
2627
2628 sband = rx->local->hw.wiphy->bands[status->band];
2629 if (!(status->flag & RX_FLAG_HT))
2630 rate = &sband->bitrates[status->rate_idx];
2631
2632 ieee80211_rx_cooked_monitor(rx, rate);
2633 break;
2634 }
2635 case RX_DROP_UNUSABLE:
2636 I802_DEBUG_INC(rx->sdata->local->rx_handlers_drop);
2637 if (rx->sta)
2638 rx->sta->rx_dropped++;
2639 dev_kfree_skb(rx->skb);
2640 break;
2641 case RX_QUEUED:
2642 I802_DEBUG_INC(rx->sdata->local->rx_handlers_queued);
2643 break;
2644 }
2645}
2646
Christian Lamparter24a8fda2010-12-30 17:25:29 +01002647static void ieee80211_rx_handlers(struct ieee80211_rx_data *rx)
Christian Lamparteraa0c8632010-08-05 01:36:04 +02002648{
2649 ieee80211_rx_result res = RX_DROP_MONITOR;
2650 struct sk_buff *skb;
2651
2652#define CALL_RXH(rxh) \
2653 do { \
2654 res = rxh(rx); \
2655 if (res != RX_CONTINUE) \
2656 goto rxh_next; \
2657 } while (0);
2658
Christian Lamparter24a8fda2010-12-30 17:25:29 +01002659 spin_lock(&rx->local->rx_skb_queue.lock);
2660 if (rx->local->running_rx_handler)
2661 goto unlock;
2662
2663 rx->local->running_rx_handler = true;
2664
2665 while ((skb = __skb_dequeue(&rx->local->rx_skb_queue))) {
2666 spin_unlock(&rx->local->rx_skb_queue.lock);
2667
Christian Lamparteraa0c8632010-08-05 01:36:04 +02002668 /*
2669 * all the other fields are valid across frames
2670 * that belong to an aMPDU since they are on the
2671 * same TID from the same station
2672 */
2673 rx->skb = skb;
2674
2675 CALL_RXH(ieee80211_rx_h_decrypt)
2676 CALL_RXH(ieee80211_rx_h_check_more_data)
Johannes Berg47086fc2011-09-29 16:04:33 +02002677 CALL_RXH(ieee80211_rx_h_uapsd_and_pspoll)
Christian Lamparteraa0c8632010-08-05 01:36:04 +02002678 CALL_RXH(ieee80211_rx_h_sta_process)
2679 CALL_RXH(ieee80211_rx_h_defragment)
Christian Lamparteraa0c8632010-08-05 01:36:04 +02002680 CALL_RXH(ieee80211_rx_h_michael_mic_verify)
2681 /* must be after MMIC verify so header is counted in MPDU mic */
Christian Lamparteraa0c8632010-08-05 01:36:04 +02002682#ifdef CONFIG_MAC80211_MESH
2683 if (ieee80211_vif_is_mesh(&rx->sdata->vif))
2684 CALL_RXH(ieee80211_rx_h_mesh_fwding);
2685#endif
Javier Cardona2154c812011-09-07 17:49:53 -07002686 CALL_RXH(ieee80211_rx_h_amsdu)
Christian Lamparteraa0c8632010-08-05 01:36:04 +02002687 CALL_RXH(ieee80211_rx_h_data)
Christian Lamparter24a8fda2010-12-30 17:25:29 +01002688 CALL_RXH(ieee80211_rx_h_ctrl);
Johannes Berg2e161f72010-08-12 15:38:38 +02002689 CALL_RXH(ieee80211_rx_h_mgmt_check)
Christian Lamparteraa0c8632010-08-05 01:36:04 +02002690 CALL_RXH(ieee80211_rx_h_action)
Johannes Berg2e161f72010-08-12 15:38:38 +02002691 CALL_RXH(ieee80211_rx_h_userspace_mgmt)
2692 CALL_RXH(ieee80211_rx_h_action_return)
Christian Lamparteraa0c8632010-08-05 01:36:04 +02002693 CALL_RXH(ieee80211_rx_h_mgmt)
2694
2695 rxh_next:
2696 ieee80211_rx_handlers_result(rx, res);
Christian Lamparter24a8fda2010-12-30 17:25:29 +01002697 spin_lock(&rx->local->rx_skb_queue.lock);
Christian Lamparteraa0c8632010-08-05 01:36:04 +02002698#undef CALL_RXH
2699 }
Christian Lamparter24a8fda2010-12-30 17:25:29 +01002700
2701 rx->local->running_rx_handler = false;
2702
2703 unlock:
2704 spin_unlock(&rx->local->rx_skb_queue.lock);
Christian Lamparteraa0c8632010-08-05 01:36:04 +02002705}
Johannes Berg571ecf62007-07-27 15:43:22 +02002706
Johannes Berg4406c372010-09-24 11:21:06 +02002707static void ieee80211_invoke_rx_handlers(struct ieee80211_rx_data *rx)
Johannes Berg58905292008-01-31 19:48:25 +01002708{
Johannes Berg58905292008-01-31 19:48:25 +01002709 ieee80211_rx_result res = RX_DROP_MONITOR;
2710
Luis Carlos Coboe32f85f2008-08-05 19:34:52 +02002711#define CALL_RXH(rxh) \
2712 do { \
2713 res = rxh(rx); \
2714 if (res != RX_CONTINUE) \
Johannes Berg2569a822009-11-25 17:46:17 +01002715 goto rxh_next; \
Luis Carlos Coboe32f85f2008-08-05 19:34:52 +02002716 } while (0);
Johannes Berg58905292008-01-31 19:48:25 +01002717
Johannes Berg49461622008-06-30 15:10:45 +02002718 CALL_RXH(ieee80211_rx_h_passive_scan)
2719 CALL_RXH(ieee80211_rx_h_check)
Johannes Berg2569a822009-11-25 17:46:17 +01002720
Christian Lamparter24a8fda2010-12-30 17:25:29 +01002721 ieee80211_rx_reorder_ampdu(rx);
Johannes Berg2569a822009-11-25 17:46:17 +01002722
Christian Lamparter24a8fda2010-12-30 17:25:29 +01002723 ieee80211_rx_handlers(rx);
Christian Lamparteraa0c8632010-08-05 01:36:04 +02002724 return;
Johannes Berg49461622008-06-30 15:10:45 +02002725
Johannes Berg2569a822009-11-25 17:46:17 +01002726 rxh_next:
Christian Lamparteraa0c8632010-08-05 01:36:04 +02002727 ieee80211_rx_handlers_result(rx, res);
2728
2729#undef CALL_RXH
Johannes Berg58905292008-01-31 19:48:25 +01002730}
2731
Christian Lamparter2bff8eb2010-08-05 01:36:41 +02002732/*
Johannes Bergdd318572010-11-29 11:09:16 +01002733 * This function makes calls into the RX path, therefore
2734 * it has to be invoked under RCU read lock.
Christian Lamparter2bff8eb2010-08-05 01:36:41 +02002735 */
2736void ieee80211_release_reorder_timeout(struct sta_info *sta, int tid)
2737{
Johannes Berg554891e2010-09-24 12:38:25 +02002738 struct ieee80211_rx_data rx = {
2739 .sta = sta,
2740 .sdata = sta->sdata,
2741 .local = sta->local,
Johannes Berg9e262972011-07-07 18:45:03 +02002742 /* This is OK -- must be QoS data frame */
2743 .security_idx = tid,
2744 .seqno_idx = tid,
Helmut Schaafcf8bd32011-04-01 15:46:05 +02002745 .flags = 0,
Johannes Berg554891e2010-09-24 12:38:25 +02002746 };
Christian Lamparter2c15a0c2010-08-24 19:22:42 +02002747 struct tid_ampdu_rx *tid_agg_rx;
2748
2749 tid_agg_rx = rcu_dereference(sta->ampdu_mlme.tid_rx[tid]);
2750 if (!tid_agg_rx)
2751 return;
Christian Lamparter2bff8eb2010-08-05 01:36:41 +02002752
Christian Lamparter2c15a0c2010-08-24 19:22:42 +02002753 spin_lock(&tid_agg_rx->reorder_lock);
Christian Lamparter24a8fda2010-12-30 17:25:29 +01002754 ieee80211_sta_reorder_release(&sta->local->hw, tid_agg_rx);
Christian Lamparter2c15a0c2010-08-24 19:22:42 +02002755 spin_unlock(&tid_agg_rx->reorder_lock);
Christian Lamparter2bff8eb2010-08-05 01:36:41 +02002756
Christian Lamparter24a8fda2010-12-30 17:25:29 +01002757 ieee80211_rx_handlers(&rx);
Christian Lamparter2bff8eb2010-08-05 01:36:41 +02002758}
2759
Johannes Berg571ecf62007-07-27 15:43:22 +02002760/* main receive path */
2761
Johannes Berg20b01f82010-09-24 11:21:05 +02002762static int prepare_for_handlers(struct ieee80211_rx_data *rx,
Johannes Berg23a24de2007-07-27 15:43:22 +02002763 struct ieee80211_hdr *hdr)
2764{
Johannes Berg20b01f82010-09-24 11:21:05 +02002765 struct ieee80211_sub_if_data *sdata = rx->sdata;
Johannes Bergeb9fb5b2009-11-16 13:58:20 +01002766 struct sk_buff *skb = rx->skb;
2767 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
2768 u8 *bssid = ieee80211_get_bssid(hdr, skb->len, sdata->vif.type);
Johannes Berg23a24de2007-07-27 15:43:22 +02002769 int multicast = is_multicast_ether_addr(hdr->addr1);
2770
Johannes Berg51fb61e2007-12-19 01:31:27 +01002771 switch (sdata->vif.type) {
Johannes Berg05c914f2008-09-11 00:01:58 +02002772 case NL80211_IFTYPE_STATION:
Johannes Berg9bc383d2009-11-19 11:55:19 +01002773 if (!bssid && !sdata->u.mgd.use_4addr)
Johannes Berg23a24de2007-07-27 15:43:22 +02002774 return 0;
Johannes Berg77fdaa12009-07-07 03:45:17 +02002775 if (!multicast &&
Johannes Berg47846c92009-11-25 17:46:19 +01002776 compare_ether_addr(sdata->vif.addr, hdr->addr1) != 0) {
Felix Fietkau4f312332011-02-05 23:48:37 +01002777 if (!(sdata->dev->flags & IFF_PROMISC) ||
2778 sdata->u.mgd.use_4addr)
Johannes Berg23a24de2007-07-27 15:43:22 +02002779 return 0;
Johannes Berg554891e2010-09-24 12:38:25 +02002780 status->rx_flags &= ~IEEE80211_RX_RA_MATCH;
Johannes Berg23a24de2007-07-27 15:43:22 +02002781 }
2782 break;
Johannes Berg05c914f2008-09-11 00:01:58 +02002783 case NL80211_IFTYPE_ADHOC:
Johannes Berg23a24de2007-07-27 15:43:22 +02002784 if (!bssid)
2785 return 0;
Harvey Harrisona7767f92008-07-02 16:30:51 -07002786 if (ieee80211_is_beacon(hdr->frame_control)) {
Bruno Randolf9d9bf772008-02-18 11:21:36 +09002787 return 1;
Vladimir Koutny87291c02008-06-13 16:50:44 +02002788 }
Johannes Berg46900292009-02-15 12:44:28 +01002789 else if (!ieee80211_bssid_match(bssid, sdata->u.ibss.bssid)) {
Johannes Berg554891e2010-09-24 12:38:25 +02002790 if (!(status->rx_flags & IEEE80211_RX_IN_SCAN))
Johannes Berg23a24de2007-07-27 15:43:22 +02002791 return 0;
Johannes Berg554891e2010-09-24 12:38:25 +02002792 status->rx_flags &= ~IEEE80211_RX_RA_MATCH;
Johannes Berg23a24de2007-07-27 15:43:22 +02002793 } else if (!multicast &&
Johannes Berg47846c92009-11-25 17:46:19 +01002794 compare_ether_addr(sdata->vif.addr,
Johannes Berg23a24de2007-07-27 15:43:22 +02002795 hdr->addr1) != 0) {
Johannes Berg4150c572007-09-17 01:29:23 -04002796 if (!(sdata->dev->flags & IFF_PROMISC))
Johannes Berg23a24de2007-07-27 15:43:22 +02002797 return 0;
Johannes Berg554891e2010-09-24 12:38:25 +02002798 status->rx_flags &= ~IEEE80211_RX_RA_MATCH;
Jouni Malinen0fb8ca42008-12-12 14:38:33 +02002799 } else if (!rx->sta) {
2800 int rate_idx;
Johannes Bergeb9fb5b2009-11-16 13:58:20 +01002801 if (status->flag & RX_FLAG_HT)
Jouni Malinen0fb8ca42008-12-12 14:38:33 +02002802 rate_idx = 0; /* TODO: HT rates */
2803 else
Johannes Bergeb9fb5b2009-11-16 13:58:20 +01002804 rate_idx = status->rate_idx;
Johannes Berg8bf11d82011-12-15 11:17:37 +01002805 ieee80211_ibss_rx_no_sta(sdata, bssid, hdr->addr2,
2806 BIT(rate_idx));
Jouni Malinen0fb8ca42008-12-12 14:38:33 +02002807 }
Johannes Berg23a24de2007-07-27 15:43:22 +02002808 break;
Johannes Berg05c914f2008-09-11 00:01:58 +02002809 case NL80211_IFTYPE_MESH_POINT:
Johannes Berg6032f932008-02-23 15:17:07 +01002810 if (!multicast &&
Johannes Berg47846c92009-11-25 17:46:19 +01002811 compare_ether_addr(sdata->vif.addr,
Johannes Berg6032f932008-02-23 15:17:07 +01002812 hdr->addr1) != 0) {
2813 if (!(sdata->dev->flags & IFF_PROMISC))
2814 return 0;
2815
Johannes Berg554891e2010-09-24 12:38:25 +02002816 status->rx_flags &= ~IEEE80211_RX_RA_MATCH;
Johannes Berg6032f932008-02-23 15:17:07 +01002817 }
2818 break;
Johannes Berg05c914f2008-09-11 00:01:58 +02002819 case NL80211_IFTYPE_AP_VLAN:
2820 case NL80211_IFTYPE_AP:
Johannes Berg23a24de2007-07-27 15:43:22 +02002821 if (!bssid) {
Johannes Berg47846c92009-11-25 17:46:19 +01002822 if (compare_ether_addr(sdata->vif.addr,
Johannes Berg23a24de2007-07-27 15:43:22 +02002823 hdr->addr1))
2824 return 0;
2825 } else if (!ieee80211_bssid_match(bssid,
Johannes Berg47846c92009-11-25 17:46:19 +01002826 sdata->vif.addr)) {
Johannes Berg3df6eae2011-12-06 10:39:40 +01002827 /*
2828 * Accept public action frames even when the
2829 * BSSID doesn't match, this is used for P2P
2830 * and location updates. Note that mac80211
2831 * itself never looks at these frames.
2832 */
Arik Nemtsov771bbd02011-02-01 13:23:05 +02002833 if (!(status->rx_flags & IEEE80211_RX_IN_SCAN) &&
Johannes Berg3df6eae2011-12-06 10:39:40 +01002834 ieee80211_is_public_action(hdr, skb->len))
2835 return 1;
2836 if (!(status->rx_flags & IEEE80211_RX_IN_SCAN) &&
2837 !ieee80211_is_beacon(hdr->frame_control))
Johannes Berg23a24de2007-07-27 15:43:22 +02002838 return 0;
Johannes Berg554891e2010-09-24 12:38:25 +02002839 status->rx_flags &= ~IEEE80211_RX_RA_MATCH;
Johannes Berg23a24de2007-07-27 15:43:22 +02002840 }
Johannes Berg23a24de2007-07-27 15:43:22 +02002841 break;
Johannes Berg05c914f2008-09-11 00:01:58 +02002842 case NL80211_IFTYPE_WDS:
Harvey Harrisona7767f92008-07-02 16:30:51 -07002843 if (bssid || !ieee80211_is_data(hdr->frame_control))
Johannes Berg23a24de2007-07-27 15:43:22 +02002844 return 0;
2845 if (compare_ether_addr(sdata->u.wds.remote_addr, hdr->addr2))
2846 return 0;
2847 break;
Johannes Berg2ca27bc2010-09-16 14:58:23 +02002848 default:
Johannes Bergfb1c1cd2007-09-26 15:19:43 +02002849 /* should never get here */
2850 WARN_ON(1);
2851 break;
Johannes Berg23a24de2007-07-27 15:43:22 +02002852 }
2853
2854 return 1;
2855}
2856
Johannes Berg571ecf62007-07-27 15:43:22 +02002857/*
Johannes Berg4406c372010-09-24 11:21:06 +02002858 * This function returns whether or not the SKB
2859 * was destined for RX processing or not, which,
2860 * if consume is true, is equivalent to whether
2861 * or not the skb was consumed.
2862 */
2863static bool ieee80211_prepare_and_rx_handle(struct ieee80211_rx_data *rx,
2864 struct sk_buff *skb, bool consume)
2865{
2866 struct ieee80211_local *local = rx->local;
2867 struct ieee80211_sub_if_data *sdata = rx->sdata;
2868 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
2869 struct ieee80211_hdr *hdr = (void *)skb->data;
2870 int prepares;
2871
2872 rx->skb = skb;
Johannes Berg554891e2010-09-24 12:38:25 +02002873 status->rx_flags |= IEEE80211_RX_RA_MATCH;
Johannes Berg4406c372010-09-24 11:21:06 +02002874 prepares = prepare_for_handlers(rx, hdr);
2875
2876 if (!prepares)
2877 return false;
2878
Johannes Berg4406c372010-09-24 11:21:06 +02002879 if (!consume) {
2880 skb = skb_copy(skb, GFP_ATOMIC);
2881 if (!skb) {
2882 if (net_ratelimit())
2883 wiphy_debug(local->hw.wiphy,
Ben Greearb305dae2011-01-08 10:30:54 -08002884 "failed to copy skb for %s\n",
Johannes Berg4406c372010-09-24 11:21:06 +02002885 sdata->name);
2886 return true;
2887 }
2888
2889 rx->skb = skb;
2890 }
2891
2892 ieee80211_invoke_rx_handlers(rx);
2893 return true;
2894}
2895
2896/*
Ron Rindjunsky6368e4b2007-12-24 13:36:39 +02002897 * This is the actual Rx frames handler. as it blongs to Rx path it must
2898 * be called with rcu_read_lock protection.
Johannes Berg571ecf62007-07-27 15:43:22 +02002899 */
Ron Rindjunsky71ebb4a2008-01-21 12:39:12 +02002900static void __ieee80211_rx_handle_packet(struct ieee80211_hw *hw,
Christian Lamparter071d9ac2010-08-05 01:36:36 +02002901 struct sk_buff *skb)
Johannes Berg571ecf62007-07-27 15:43:22 +02002902{
Johannes Berg554891e2010-09-24 12:38:25 +02002903 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
Johannes Berg571ecf62007-07-27 15:43:22 +02002904 struct ieee80211_local *local = hw_to_local(hw);
2905 struct ieee80211_sub_if_data *sdata;
Johannes Berg571ecf62007-07-27 15:43:22 +02002906 struct ieee80211_hdr *hdr;
Zhu Yie3cf8b32010-03-29 17:35:07 +08002907 __le16 fc;
Johannes Berg5cf121c2008-02-25 16:27:43 +01002908 struct ieee80211_rx_data rx;
Johannes Berg4406c372010-09-24 11:21:06 +02002909 struct ieee80211_sub_if_data *prev;
Ben Greear56af3262010-09-23 10:22:24 -07002910 struct sta_info *sta, *tmp, *prev_sta;
Zhu Yie3cf8b32010-03-29 17:35:07 +08002911 int err = 0;
Johannes Berg571ecf62007-07-27 15:43:22 +02002912
Zhu Yie3cf8b32010-03-29 17:35:07 +08002913 fc = ((struct ieee80211_hdr *)skb->data)->frame_control;
Johannes Berg571ecf62007-07-27 15:43:22 +02002914 memset(&rx, 0, sizeof(rx));
2915 rx.skb = skb;
2916 rx.local = local;
Johannes Berg72abd812007-09-17 01:29:22 -04002917
Zhu Yie3cf8b32010-03-29 17:35:07 +08002918 if (ieee80211_is_data(fc) || ieee80211_is_mgmt(fc))
Johannes Berg571ecf62007-07-27 15:43:22 +02002919 local->dot11ReceivedFragmentCount++;
Johannes Berg571ecf62007-07-27 15:43:22 +02002920
Helmut Schaa142b9f52009-07-23 13:18:01 +02002921 if (unlikely(test_bit(SCAN_HW_SCANNING, &local->scanning) ||
Ben Greearb23b0252011-02-04 11:54:17 -08002922 test_bit(SCAN_SW_SCANNING, &local->scanning)))
Johannes Berg554891e2010-09-24 12:38:25 +02002923 status->rx_flags |= IEEE80211_RX_IN_SCAN;
Johannes Berg571ecf62007-07-27 15:43:22 +02002924
Zhu Yie3cf8b32010-03-29 17:35:07 +08002925 if (ieee80211_is_mgmt(fc))
2926 err = skb_linearize(skb);
2927 else
2928 err = !pskb_may_pull(skb, ieee80211_hdrlen(fc));
2929
2930 if (err) {
2931 dev_kfree_skb(skb);
2932 return;
2933 }
2934
2935 hdr = (struct ieee80211_hdr *)skb->data;
Johannes Berg38f37142008-01-29 17:07:43 +01002936 ieee80211_parse_qos(&rx);
Johannes Bergd1c3a372009-01-07 00:26:10 +01002937 ieee80211_verify_alignment(&rx);
Johannes Berg38f37142008-01-29 17:07:43 +01002938
Zhu Yie3cf8b32010-03-29 17:35:07 +08002939 if (ieee80211_is_data(fc)) {
Ben Greear56af3262010-09-23 10:22:24 -07002940 prev_sta = NULL;
Johannes Berg4406c372010-09-24 11:21:06 +02002941
Johannes Berg7852e362012-01-20 13:55:24 +01002942 for_each_sta_info(local, hdr->addr2, sta, tmp) {
Ben Greear56af3262010-09-23 10:22:24 -07002943 if (!prev_sta) {
2944 prev_sta = sta;
2945 continue;
2946 }
2947
2948 rx.sta = prev_sta;
2949 rx.sdata = prev_sta->sdata;
Johannes Berg4406c372010-09-24 11:21:06 +02002950 ieee80211_prepare_and_rx_handle(&rx, skb, false);
Johannes Berg571ecf62007-07-27 15:43:22 +02002951
Ben Greear56af3262010-09-23 10:22:24 -07002952 prev_sta = sta;
Johannes Berg4406c372010-09-24 11:21:06 +02002953 }
Ben Greear56af3262010-09-23 10:22:24 -07002954
2955 if (prev_sta) {
2956 rx.sta = prev_sta;
2957 rx.sdata = prev_sta->sdata;
2958
Johannes Berg4406c372010-09-24 11:21:06 +02002959 if (ieee80211_prepare_and_rx_handle(&rx, skb, true))
Ben Greear56af3262010-09-23 10:22:24 -07002960 return;
Senthil Balasubramanian8e26d5a2010-11-30 20:15:38 +05302961 goto out;
Ben Greear56af3262010-09-23 10:22:24 -07002962 }
Johannes Berg4406c372010-09-24 11:21:06 +02002963 }
2964
Johannes Berg4b0dd982010-09-24 11:21:07 +02002965 prev = NULL;
Johannes Berg4406c372010-09-24 11:21:06 +02002966
Johannes Berg4b0dd982010-09-24 11:21:07 +02002967 list_for_each_entry_rcu(sdata, &local->interfaces, list) {
2968 if (!ieee80211_sdata_running(sdata))
2969 continue;
Johannes Bergabe60632009-11-25 17:46:18 +01002970
Johannes Berg4b0dd982010-09-24 11:21:07 +02002971 if (sdata->vif.type == NL80211_IFTYPE_MONITOR ||
2972 sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
2973 continue;
Johannes Bergabe60632009-11-25 17:46:18 +01002974
Johannes Berg4b0dd982010-09-24 11:21:07 +02002975 /*
2976 * frame is destined for this interface, but if it's
2977 * not also for the previous one we handle that after
2978 * the loop to avoid copying the SKB once too much
2979 */
Johannes Bergb2e77712007-09-26 15:19:39 +02002980
Johannes Berg4b0dd982010-09-24 11:21:07 +02002981 if (!prev) {
Johannes Berg340e11f2007-07-27 15:43:22 +02002982 prev = sdata;
Johannes Berg4b0dd982010-09-24 11:21:07 +02002983 continue;
Johannes Berg8e6f00322007-07-27 15:43:22 +02002984 }
Felix Fietkau4bb29f82010-01-22 00:36:39 +01002985
Johannes Berg7852e362012-01-20 13:55:24 +01002986 rx.sta = sta_info_get_bss(prev, hdr->addr2);
Johannes Berg4b0dd982010-09-24 11:21:07 +02002987 rx.sdata = prev;
2988 ieee80211_prepare_and_rx_handle(&rx, skb, false);
Felix Fietkau4bb29f82010-01-22 00:36:39 +01002989
Johannes Berg4b0dd982010-09-24 11:21:07 +02002990 prev = sdata;
2991 }
Johannes Berg4406c372010-09-24 11:21:06 +02002992
Johannes Berg4b0dd982010-09-24 11:21:07 +02002993 if (prev) {
Johannes Berg7852e362012-01-20 13:55:24 +01002994 rx.sta = sta_info_get_bss(prev, hdr->addr2);
Johannes Berg4b0dd982010-09-24 11:21:07 +02002995 rx.sdata = prev;
2996
2997 if (ieee80211_prepare_and_rx_handle(&rx, skb, true))
2998 return;
Johannes Berg571ecf62007-07-27 15:43:22 +02002999 }
Johannes Berg4406c372010-09-24 11:21:06 +02003000
Senthil Balasubramanian8e26d5a2010-11-30 20:15:38 +05303001 out:
Johannes Berg4406c372010-09-24 11:21:06 +02003002 dev_kfree_skb(skb);
Johannes Berg571ecf62007-07-27 15:43:22 +02003003}
Ron Rindjunsky6368e4b2007-12-24 13:36:39 +02003004
3005/*
3006 * This is the receive path handler. It is called by a low level driver when an
3007 * 802.11 MPDU is received from the hardware.
3008 */
John W. Linville103bf9f2009-08-20 16:34:15 -04003009void ieee80211_rx(struct ieee80211_hw *hw, struct sk_buff *skb)
Ron Rindjunsky6368e4b2007-12-24 13:36:39 +02003010{
3011 struct ieee80211_local *local = hw_to_local(hw);
Johannes Berg8318d782008-01-24 19:38:38 +01003012 struct ieee80211_rate *rate = NULL;
3013 struct ieee80211_supported_band *sband;
Johannes Bergf1d58c22009-06-17 13:13:00 +02003014 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
Johannes Berg8318d782008-01-24 19:38:38 +01003015
Johannes Bergd20ef632009-10-11 15:10:40 +02003016 WARN_ON_ONCE(softirq_count() == 0);
3017
Johannes Berg77a980d2009-08-24 11:46:30 +02003018 if (WARN_ON(status->band < 0 ||
3019 status->band >= IEEE80211_NUM_BANDS))
3020 goto drop;
Johannes Berg8318d782008-01-24 19:38:38 +01003021
3022 sband = local->hw.wiphy->bands[status->band];
Johannes Berg77a980d2009-08-24 11:46:30 +02003023 if (WARN_ON(!sband))
3024 goto drop;
Johannes Berg8318d782008-01-24 19:38:38 +01003025
Johannes Berg89c3a8a2009-07-28 18:10:17 +02003026 /*
3027 * If we're suspending, it is possible although not too likely
3028 * that we'd be receiving frames after having already partially
3029 * quiesced the stack. We can't process such frames then since
3030 * that might, for example, cause stations to be added or other
3031 * driver callbacks be invoked.
3032 */
Johannes Berg77a980d2009-08-24 11:46:30 +02003033 if (unlikely(local->quiescing || local->suspended))
3034 goto drop;
Johannes Berg89c3a8a2009-07-28 18:10:17 +02003035
Johannes Bergea77f122009-08-21 14:44:45 +02003036 /*
3037 * The same happens when we're not even started,
3038 * but that's worth a warning.
3039 */
Johannes Berg77a980d2009-08-24 11:46:30 +02003040 if (WARN_ON(!local->started))
3041 goto drop;
Johannes Bergea77f122009-08-21 14:44:45 +02003042
Johannes Bergfc885182010-07-30 13:23:12 +02003043 if (likely(!(status->flag & RX_FLAG_FAILED_PLCP_CRC))) {
Luis R. Rodrigueze5d6eb82009-11-09 16:03:22 -05003044 /*
Johannes Bergfc885182010-07-30 13:23:12 +02003045 * Validate the rate, unless a PLCP error means that
3046 * we probably can't have a valid rate here anyway.
Luis R. Rodrigueze5d6eb82009-11-09 16:03:22 -05003047 */
Johannes Bergfc885182010-07-30 13:23:12 +02003048
3049 if (status->flag & RX_FLAG_HT) {
3050 /*
3051 * rate_idx is MCS index, which can be [0-76]
3052 * as documented on:
3053 *
3054 * http://wireless.kernel.org/en/developers/Documentation/ieee80211/802.11n
3055 *
3056 * Anything else would be some sort of driver or
3057 * hardware error. The driver should catch hardware
3058 * errors.
3059 */
3060 if (WARN((status->rate_idx < 0 ||
3061 status->rate_idx > 76),
3062 "Rate marked as an HT rate but passed "
3063 "status->rate_idx is not "
3064 "an MCS index [0-76]: %d (0x%02x)\n",
3065 status->rate_idx,
3066 status->rate_idx))
3067 goto drop;
3068 } else {
3069 if (WARN_ON(status->rate_idx < 0 ||
3070 status->rate_idx >= sband->n_bitrates))
3071 goto drop;
3072 rate = &sband->bitrates[status->rate_idx];
3073 }
Jouni Malinen0fb8ca42008-12-12 14:38:33 +02003074 }
Ron Rindjunsky6368e4b2007-12-24 13:36:39 +02003075
Johannes Berg554891e2010-09-24 12:38:25 +02003076 status->rx_flags = 0;
3077
Ron Rindjunsky6368e4b2007-12-24 13:36:39 +02003078 /*
3079 * key references and virtual interfaces are protected using RCU
3080 * and this requires that we are in a read-side RCU section during
3081 * receive processing
3082 */
3083 rcu_read_lock();
3084
3085 /*
3086 * Frames with failed FCS/PLCP checksum are not returned,
3087 * all other frames are returned without radiotap header
3088 * if it was previously present.
3089 * Also, frames with less than 16 bytes are dropped.
3090 */
Johannes Bergf1d58c22009-06-17 13:13:00 +02003091 skb = ieee80211_rx_monitor(local, skb, rate);
Ron Rindjunsky6368e4b2007-12-24 13:36:39 +02003092 if (!skb) {
3093 rcu_read_unlock();
3094 return;
3095 }
3096
Johannes Berge1e54062010-11-30 08:58:45 +01003097 ieee80211_tpt_led_trig_rx(local,
3098 ((struct ieee80211_hdr *)skb->data)->frame_control,
3099 skb->len);
Christian Lamparter071d9ac2010-08-05 01:36:36 +02003100 __ieee80211_rx_handle_packet(hw, skb);
Ron Rindjunsky6368e4b2007-12-24 13:36:39 +02003101
3102 rcu_read_unlock();
Johannes Berg77a980d2009-08-24 11:46:30 +02003103
3104 return;
3105 drop:
3106 kfree_skb(skb);
Ron Rindjunsky6368e4b2007-12-24 13:36:39 +02003107}
John W. Linville103bf9f2009-08-20 16:34:15 -04003108EXPORT_SYMBOL(ieee80211_rx);
Johannes Berg571ecf62007-07-27 15:43:22 +02003109
3110/* This is a version of the rx handler that can be called from hard irq
3111 * context. Post the skb on the queue and schedule the tasklet */
Johannes Bergf1d58c22009-06-17 13:13:00 +02003112void ieee80211_rx_irqsafe(struct ieee80211_hw *hw, struct sk_buff *skb)
Johannes Berg571ecf62007-07-27 15:43:22 +02003113{
3114 struct ieee80211_local *local = hw_to_local(hw);
3115
3116 BUILD_BUG_ON(sizeof(struct ieee80211_rx_status) > sizeof(skb->cb));
3117
Johannes Berg571ecf62007-07-27 15:43:22 +02003118 skb->pkt_type = IEEE80211_RX_MSG;
3119 skb_queue_tail(&local->skb_queue, skb);
3120 tasklet_schedule(&local->tasklet);
3121}
3122EXPORT_SYMBOL(ieee80211_rx_irqsafe);