2007-07-27 15:43:22 +02:00
|
|
|
/*
|
|
|
|
* Copyright 2002-2005, Instant802 Networks, Inc.
|
|
|
|
* Copyright 2005-2006, Devicescape Software, Inc.
|
|
|
|
* Copyright 2006-2007 Jiri Benc <jbenc@suse.cz>
|
|
|
|
* Copyright 2007 Johannes Berg <johannes@sipsolutions.net>
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
|
|
* published by the Free Software Foundation.
|
|
|
|
*/
|
|
|
|
|
2008-02-14 16:36:47 +01:00
|
|
|
#include <linux/jiffies.h>
|
2007-07-27 15:43:22 +02:00
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/skbuff.h>
|
|
|
|
#include <linux/netdevice.h>
|
|
|
|
#include <linux/etherdevice.h>
|
[MAC80211]: fix race conditions with keys
During receive processing, we select the key long before using it and
because there's no locking it is possible that we kfree() the key
after having selected it but before using it for crypto operations.
Obviously, this is bad.
Secondly, during transmit processing, there are two possible races: We
have a similar race between select_key() and using it for encryption,
but we also have a race here between select_key() and hardware
encryption (both when a key is removed.)
This patch solves these issues by using RCU: when a key is to be freed,
we first remove the pointer from the appropriate places (sdata->keys,
sdata->default_key, sta->key) using rcu_assign_pointer() and then
synchronize_rcu(). Then, we can safely kfree() the key and remove it
from the hardware. There's a window here where the hardware may still
be using it for decryption, but we can't work around that without having
two hardware callbacks, one to disable the key for RX and one to disable
it for TX; but the worst thing that will happen is that we receive a
packet decrypted that we don't find a key for any more and then drop it.
When we add a key, we first need to upload it to the hardware and then,
using rcu_assign_pointer() again, link it into our structures.
In the code using keys (TX/RX paths) we use rcu_dereference() to get the
key and enclose the whole tx/rx section in a rcu_read_lock() ...
rcu_read_unlock() block. Because we've uploaded the key to hardware
before linking it into internal structures, we can guarantee that it is
valid once get to into tx().
One possible race condition remains, however: when we have hardware
acceleration enabled and the driver shuts down the queues, we end up
queueing the frame. If now somebody removes the key, the key will be
removed from hwaccel and then then driver will be asked to encrypt the
frame with a key index that has been removed. Hence, drivers will need
to be aware that the hw_key_index they are passed might not be under
all circumstances. Most drivers will, however, simply ignore that
condition and encrypt the frame with the selected key anyway, this
only results in a frame being encrypted with a wrong key or dropped
(rightfully) because the key was not valid. There isn't much we can
do about it unless we want to walk the pending frame queue every time
a key is removed and remove all frames that used it.
This race condition, however, will most likely be solved once we add
multiqueue support to mac80211 because then frames will be queued
further up the stack instead of after being processed.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Acked-by: Michael Wu <flamingice@sourmilk.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-09-14 17:10:24 +02:00
|
|
|
#include <linux/rcupdate.h>
|
2007-07-27 15:43:22 +02:00
|
|
|
#include <net/mac80211.h>
|
|
|
|
#include <net/ieee80211_radiotap.h>
|
|
|
|
|
|
|
|
#include "ieee80211_i.h"
|
2009-04-23 18:52:52 +02:00
|
|
|
#include "driver-ops.h"
|
2008-04-08 21:14:40 +02:00
|
|
|
#include "led.h"
|
2008-02-23 15:17:10 +01:00
|
|
|
#include "mesh.h"
|
2007-07-27 15:43:22 +02:00
|
|
|
#include "wep.h"
|
|
|
|
#include "wpa.h"
|
|
|
|
#include "tkip.h"
|
|
|
|
#include "wme.h"
|
|
|
|
|
2009-11-16 12:00:40 +01:00
|
|
|
static void ieee80211_release_reorder_frames(struct ieee80211_hw *hw,
|
|
|
|
struct tid_ampdu_rx *tid_agg_rx,
|
|
|
|
u16 head_seq_num);
|
|
|
|
|
2007-09-26 15:19:39 +02:00
|
|
|
/*
|
|
|
|
* monitor mode reception
|
|
|
|
*
|
|
|
|
* This function cleans up the SKB, i.e. it removes all the stuff
|
|
|
|
* only useful for monitoring.
|
|
|
|
*/
|
|
|
|
static struct sk_buff *remove_monitor_info(struct ieee80211_local *local,
|
2009-10-28 10:03:35 +01:00
|
|
|
struct sk_buff *skb)
|
2007-09-26 15:19:39 +02:00
|
|
|
{
|
|
|
|
if (local->hw.flags & IEEE80211_HW_RX_INCLUDES_FCS) {
|
|
|
|
if (likely(skb->len > FCS_LEN))
|
|
|
|
skb_trim(skb, skb->len - FCS_LEN);
|
|
|
|
else {
|
|
|
|
/* driver bug */
|
|
|
|
WARN_ON(1);
|
|
|
|
dev_kfree_skb(skb);
|
|
|
|
skb = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return skb;
|
|
|
|
}
|
|
|
|
|
2009-06-17 13:13:00 +02:00
|
|
|
static inline int should_drop_frame(struct sk_buff *skb,
|
2009-10-28 10:03:35 +01:00
|
|
|
int present_fcs_len)
|
2007-09-26 15:19:39 +02:00
|
|
|
{
|
2009-06-17 13:13:00 +02:00
|
|
|
struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
|
2008-06-23 01:45:29 +02:00
|
|
|
struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
|
2007-09-26 15:19:39 +02:00
|
|
|
|
|
|
|
if (status->flag & (RX_FLAG_FAILED_FCS_CRC | RX_FLAG_FAILED_PLCP_CRC))
|
|
|
|
return 1;
|
2009-10-28 10:03:35 +01:00
|
|
|
if (unlikely(skb->len < 16 + present_fcs_len))
|
2007-09-26 15:19:39 +02:00
|
|
|
return 1;
|
2008-06-11 23:21:59 +02:00
|
|
|
if (ieee80211_is_ctl(hdr->frame_control) &&
|
|
|
|
!ieee80211_is_pspoll(hdr->frame_control) &&
|
|
|
|
!ieee80211_is_back_req(hdr->frame_control))
|
2007-09-26 15:19:39 +02:00
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-05-08 19:22:43 +02:00
|
|
|
static int
|
|
|
|
ieee80211_rx_radiotap_len(struct ieee80211_local *local,
|
|
|
|
struct ieee80211_rx_status *status)
|
|
|
|
{
|
|
|
|
int len;
|
|
|
|
|
|
|
|
/* always present fields */
|
|
|
|
len = sizeof(struct ieee80211_radiotap_header) + 9;
|
|
|
|
|
|
|
|
if (status->flag & RX_FLAG_TSFT)
|
|
|
|
len += 8;
|
2009-01-30 11:13:06 +01:00
|
|
|
if (local->hw.flags & IEEE80211_HW_SIGNAL_DBM)
|
2008-05-08 19:22:43 +02:00
|
|
|
len += 1;
|
|
|
|
if (local->hw.flags & IEEE80211_HW_NOISE_DBM)
|
|
|
|
len += 1;
|
|
|
|
|
|
|
|
if (len & 1) /* padding for RX_FLAGS if necessary */
|
|
|
|
len++;
|
|
|
|
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
2009-01-07 00:26:10 +01:00
|
|
|
/*
|
2008-05-08 19:22:43 +02:00
|
|
|
* ieee80211_add_rx_radiotap_header - add radiotap header
|
|
|
|
*
|
|
|
|
* add a radiotap header containing all the fields which the hardware provided.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
ieee80211_add_rx_radiotap_header(struct ieee80211_local *local,
|
|
|
|
struct sk_buff *skb,
|
|
|
|
struct ieee80211_rate *rate,
|
|
|
|
int rtap_len)
|
|
|
|
{
|
2009-06-17 13:13:00 +02:00
|
|
|
struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
|
2008-05-08 19:22:43 +02:00
|
|
|
struct ieee80211_radiotap_header *rthdr;
|
|
|
|
unsigned char *pos;
|
2009-10-28 09:58:52 +01:00
|
|
|
u16 rx_flags = 0;
|
2008-05-08 19:22:43 +02:00
|
|
|
|
|
|
|
rthdr = (struct ieee80211_radiotap_header *)skb_push(skb, rtap_len);
|
|
|
|
memset(rthdr, 0, rtap_len);
|
|
|
|
|
|
|
|
/* radiotap header, set always present flags */
|
|
|
|
rthdr->it_present =
|
|
|
|
cpu_to_le32((1 << IEEE80211_RADIOTAP_FLAGS) |
|
|
|
|
(1 << IEEE80211_RADIOTAP_CHANNEL) |
|
|
|
|
(1 << IEEE80211_RADIOTAP_ANTENNA) |
|
|
|
|
(1 << IEEE80211_RADIOTAP_RX_FLAGS));
|
|
|
|
rthdr->it_len = cpu_to_le16(rtap_len);
|
|
|
|
|
|
|
|
pos = (unsigned char *)(rthdr+1);
|
|
|
|
|
|
|
|
/* the order of the following fields is important */
|
|
|
|
|
|
|
|
/* IEEE80211_RADIOTAP_TSFT */
|
|
|
|
if (status->flag & RX_FLAG_TSFT) {
|
2009-10-28 09:58:52 +01:00
|
|
|
put_unaligned_le64(status->mactime, pos);
|
2008-05-08 19:22:43 +02:00
|
|
|
rthdr->it_present |=
|
|
|
|
cpu_to_le32(1 << IEEE80211_RADIOTAP_TSFT);
|
|
|
|
pos += 8;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* IEEE80211_RADIOTAP_FLAGS */
|
|
|
|
if (local->hw.flags & IEEE80211_HW_RX_INCLUDES_FCS)
|
|
|
|
*pos |= IEEE80211_RADIOTAP_F_FCS;
|
2009-03-13 12:52:10 +01:00
|
|
|
if (status->flag & (RX_FLAG_FAILED_FCS_CRC | RX_FLAG_FAILED_PLCP_CRC))
|
|
|
|
*pos |= IEEE80211_RADIOTAP_F_BADFCS;
|
2008-07-30 17:19:55 +02:00
|
|
|
if (status->flag & RX_FLAG_SHORTPRE)
|
|
|
|
*pos |= IEEE80211_RADIOTAP_F_SHORTPRE;
|
2008-05-08 19:22:43 +02:00
|
|
|
pos++;
|
|
|
|
|
|
|
|
/* IEEE80211_RADIOTAP_RATE */
|
2008-12-12 13:38:33 +01:00
|
|
|
if (status->flag & RX_FLAG_HT) {
|
|
|
|
/*
|
|
|
|
* TODO: add following information into radiotap header once
|
|
|
|
* suitable fields are defined for it:
|
|
|
|
* - MCS index (status->rate_idx)
|
|
|
|
* - HT40 (status->flag & RX_FLAG_40MHZ)
|
|
|
|
* - short-GI (status->flag & RX_FLAG_SHORT_GI)
|
|
|
|
*/
|
|
|
|
*pos = 0;
|
2008-12-15 09:37:50 +01:00
|
|
|
} else {
|
2009-01-10 10:47:33 +01:00
|
|
|
rthdr->it_present |= cpu_to_le32(1 << IEEE80211_RADIOTAP_RATE);
|
2008-12-12 13:38:33 +01:00
|
|
|
*pos = rate->bitrate / 5;
|
2008-12-15 09:37:50 +01:00
|
|
|
}
|
2008-05-08 19:22:43 +02:00
|
|
|
pos++;
|
|
|
|
|
|
|
|
/* IEEE80211_RADIOTAP_CHANNEL */
|
2009-10-28 09:58:52 +01:00
|
|
|
put_unaligned_le16(status->freq, pos);
|
2008-05-08 19:22:43 +02:00
|
|
|
pos += 2;
|
|
|
|
if (status->band == IEEE80211_BAND_5GHZ)
|
2009-10-28 09:58:52 +01:00
|
|
|
put_unaligned_le16(IEEE80211_CHAN_OFDM | IEEE80211_CHAN_5GHZ,
|
|
|
|
pos);
|
2009-11-16 13:58:21 +01:00
|
|
|
else if (status->flag & RX_FLAG_HT)
|
|
|
|
put_unaligned_le16(IEEE80211_CHAN_DYN | IEEE80211_CHAN_2GHZ,
|
|
|
|
pos);
|
2008-07-30 17:20:06 +02:00
|
|
|
else if (rate->flags & IEEE80211_RATE_ERP_G)
|
2009-10-28 09:58:52 +01:00
|
|
|
put_unaligned_le16(IEEE80211_CHAN_OFDM | IEEE80211_CHAN_2GHZ,
|
|
|
|
pos);
|
2008-05-08 19:22:43 +02:00
|
|
|
else
|
2009-10-28 09:58:52 +01:00
|
|
|
put_unaligned_le16(IEEE80211_CHAN_CCK | IEEE80211_CHAN_2GHZ,
|
|
|
|
pos);
|
2008-05-08 19:22:43 +02:00
|
|
|
pos += 2;
|
|
|
|
|
|
|
|
/* IEEE80211_RADIOTAP_DBM_ANTSIGNAL */
|
|
|
|
if (local->hw.flags & IEEE80211_HW_SIGNAL_DBM) {
|
|
|
|
*pos = status->signal;
|
|
|
|
rthdr->it_present |=
|
|
|
|
cpu_to_le32(1 << IEEE80211_RADIOTAP_DBM_ANTSIGNAL);
|
|
|
|
pos++;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* IEEE80211_RADIOTAP_DBM_ANTNOISE */
|
|
|
|
if (local->hw.flags & IEEE80211_HW_NOISE_DBM) {
|
|
|
|
*pos = status->noise;
|
|
|
|
rthdr->it_present |=
|
|
|
|
cpu_to_le32(1 << IEEE80211_RADIOTAP_DBM_ANTNOISE);
|
|
|
|
pos++;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* IEEE80211_RADIOTAP_LOCK_QUALITY is missing */
|
|
|
|
|
|
|
|
/* IEEE80211_RADIOTAP_ANTENNA */
|
|
|
|
*pos = status->antenna;
|
|
|
|
pos++;
|
|
|
|
|
|
|
|
/* IEEE80211_RADIOTAP_DB_ANTNOISE is not used */
|
|
|
|
|
|
|
|
/* IEEE80211_RADIOTAP_RX_FLAGS */
|
|
|
|
/* ensure 2 byte alignment for the 2 byte field as required */
|
2009-10-28 09:58:52 +01:00
|
|
|
if ((pos - (u8 *)rthdr) & 1)
|
2008-05-08 19:22:43 +02:00
|
|
|
pos++;
|
2009-03-13 12:52:10 +01:00
|
|
|
if (status->flag & RX_FLAG_FAILED_PLCP_CRC)
|
2009-10-28 09:58:52 +01:00
|
|
|
rx_flags |= IEEE80211_RADIOTAP_F_RX_BADPLCP;
|
|
|
|
put_unaligned_le16(rx_flags, pos);
|
2008-05-08 19:22:43 +02:00
|
|
|
pos += 2;
|
|
|
|
}
|
|
|
|
|
2007-09-26 15:19:39 +02:00
|
|
|
/*
|
|
|
|
* This function copies a received frame to all monitor interfaces and
|
|
|
|
* returns a cleaned-up SKB that no longer includes the FCS nor the
|
|
|
|
* radiotap header the driver might have added.
|
|
|
|
*/
|
|
|
|
static struct sk_buff *
|
|
|
|
ieee80211_rx_monitor(struct ieee80211_local *local, struct sk_buff *origskb,
|
2008-01-24 19:38:38 +01:00
|
|
|
struct ieee80211_rate *rate)
|
2007-09-26 15:19:39 +02:00
|
|
|
{
|
2009-06-17 13:13:00 +02:00
|
|
|
struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(origskb);
|
2007-09-26 15:19:39 +02:00
|
|
|
struct ieee80211_sub_if_data *sdata;
|
|
|
|
int needed_headroom = 0;
|
|
|
|
struct sk_buff *skb, *skb2;
|
|
|
|
struct net_device *prev_dev = NULL;
|
|
|
|
int present_fcs_len = 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* First, we may need to make a copy of the skb because
|
|
|
|
* (1) we need to modify it for radiotap (if not present), and
|
|
|
|
* (2) the other RX handlers will modify the skb we got.
|
|
|
|
*
|
|
|
|
* We don't need to, of course, if we aren't going to return
|
|
|
|
* the SKB because it has a bad FCS/PLCP checksum.
|
|
|
|
*/
|
2009-10-28 10:03:35 +01:00
|
|
|
|
|
|
|
/* room for the radiotap header based on driver features */
|
|
|
|
needed_headroom = ieee80211_rx_radiotap_len(local, status);
|
2007-09-26 15:19:39 +02:00
|
|
|
|
|
|
|
if (local->hw.flags & IEEE80211_HW_RX_INCLUDES_FCS)
|
|
|
|
present_fcs_len = FCS_LEN;
|
|
|
|
|
|
|
|
if (!local->monitors) {
|
2009-10-28 10:03:35 +01:00
|
|
|
if (should_drop_frame(origskb, present_fcs_len)) {
|
2007-09-26 15:19:39 +02:00
|
|
|
dev_kfree_skb(origskb);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2009-10-28 10:03:35 +01:00
|
|
|
return remove_monitor_info(local, origskb);
|
2007-09-26 15:19:39 +02:00
|
|
|
}
|
|
|
|
|
2009-10-28 10:03:35 +01:00
|
|
|
if (should_drop_frame(origskb, present_fcs_len)) {
|
2007-09-26 15:19:39 +02:00
|
|
|
/* only need to expand headroom if necessary */
|
|
|
|
skb = origskb;
|
|
|
|
origskb = NULL;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This shouldn't trigger often because most devices have an
|
|
|
|
* RX header they pull before we get here, and that should
|
|
|
|
* be big enough for our radiotap information. We should
|
|
|
|
* probably export the length to drivers so that we can have
|
|
|
|
* them allocate enough headroom to start with.
|
|
|
|
*/
|
|
|
|
if (skb_headroom(skb) < needed_headroom &&
|
2007-12-11 21:33:42 +01:00
|
|
|
pskb_expand_head(skb, needed_headroom, 0, GFP_ATOMIC)) {
|
2007-09-26 15:19:39 +02:00
|
|
|
dev_kfree_skb(skb);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* Need to make a copy and possibly remove radiotap header
|
|
|
|
* and FCS from the original.
|
|
|
|
*/
|
|
|
|
skb = skb_copy_expand(origskb, needed_headroom, 0, GFP_ATOMIC);
|
|
|
|
|
2009-10-28 10:03:35 +01:00
|
|
|
origskb = remove_monitor_info(local, origskb);
|
2007-09-26 15:19:39 +02:00
|
|
|
|
|
|
|
if (!skb)
|
|
|
|
return origskb;
|
|
|
|
}
|
|
|
|
|
2009-10-28 10:03:35 +01:00
|
|
|
/* prepend radiotap information */
|
|
|
|
ieee80211_add_rx_radiotap_header(local, skb, rate, needed_headroom);
|
2007-09-26 15:19:39 +02:00
|
|
|
|
2007-12-19 01:31:22 +01:00
|
|
|
skb_reset_mac_header(skb);
|
2007-09-26 15:19:39 +02:00
|
|
|
skb->ip_summed = CHECKSUM_UNNECESSARY;
|
|
|
|
skb->pkt_type = PACKET_OTHERHOST;
|
|
|
|
skb->protocol = htons(ETH_P_802_2);
|
|
|
|
|
|
|
|
list_for_each_entry_rcu(sdata, &local->interfaces, list) {
|
|
|
|
if (!netif_running(sdata->dev))
|
|
|
|
continue;
|
|
|
|
|
2008-09-11 00:01:58 +02:00
|
|
|
if (sdata->vif.type != NL80211_IFTYPE_MONITOR)
|
2007-09-26 15:19:39 +02:00
|
|
|
continue;
|
|
|
|
|
2008-01-31 19:48:27 +01:00
|
|
|
if (sdata->u.mntr_flags & MONITOR_FLAG_COOK_FRAMES)
|
|
|
|
continue;
|
|
|
|
|
2007-09-26 15:19:39 +02:00
|
|
|
if (prev_dev) {
|
|
|
|
skb2 = skb_clone(skb, GFP_ATOMIC);
|
|
|
|
if (skb2) {
|
|
|
|
skb2->dev = prev_dev;
|
|
|
|
netif_rx(skb2);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
prev_dev = sdata->dev;
|
|
|
|
sdata->dev->stats.rx_packets++;
|
|
|
|
sdata->dev->stats.rx_bytes += skb->len;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (prev_dev) {
|
|
|
|
skb->dev = prev_dev;
|
|
|
|
netif_rx(skb);
|
|
|
|
} else
|
|
|
|
dev_kfree_skb(skb);
|
|
|
|
|
|
|
|
return origskb;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-02-25 16:27:43 +01:00
|
|
|
static void ieee80211_parse_qos(struct ieee80211_rx_data *rx)
|
2007-07-27 15:43:22 +02:00
|
|
|
{
|
2008-07-02 20:05:34 +02:00
|
|
|
struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
|
2007-07-27 15:43:22 +02:00
|
|
|
int tid;
|
|
|
|
|
|
|
|
/* does the frame have a qos control field? */
|
2008-07-02 20:05:34 +02:00
|
|
|
if (ieee80211_is_data_qos(hdr->frame_control)) {
|
|
|
|
u8 *qc = ieee80211_get_qos_ctl(hdr);
|
2007-07-27 15:43:22 +02:00
|
|
|
/* frame has qos control */
|
2008-07-02 20:05:34 +02:00
|
|
|
tid = *qc & IEEE80211_QOS_CTL_TID_MASK;
|
|
|
|
if (*qc & IEEE80211_QOS_CONTROL_A_MSDU_PRESENT)
|
2008-02-25 16:27:43 +01:00
|
|
|
rx->flags |= IEEE80211_RX_AMSDU;
|
2007-11-26 15:14:33 +01:00
|
|
|
else
|
2008-02-25 16:27:43 +01:00
|
|
|
rx->flags &= ~IEEE80211_RX_AMSDU;
|
2007-07-27 15:43:22 +02:00
|
|
|
} else {
|
2008-07-10 10:11:02 +02:00
|
|
|
/*
|
|
|
|
* IEEE 802.11-2007, 7.1.3.4.1 ("Sequence Number field"):
|
|
|
|
*
|
|
|
|
* Sequence numbers for management frames, QoS data
|
|
|
|
* frames with a broadcast/multicast address in the
|
|
|
|
* Address 1 field, and all non-QoS data frames sent
|
|
|
|
* by QoS STAs are assigned using an additional single
|
|
|
|
* modulo-4096 counter, [...]
|
|
|
|
*
|
|
|
|
* We also use that counter for non-QoS STAs.
|
|
|
|
*/
|
|
|
|
tid = NUM_RX_DATA_QUEUES - 1;
|
2007-07-27 15:43:22 +02:00
|
|
|
}
|
2007-07-27 15:43:22 +02:00
|
|
|
|
2008-02-25 16:27:43 +01:00
|
|
|
rx->queue = tid;
|
2007-07-27 15:43:22 +02:00
|
|
|
/* Set skb->priority to 1d tag if highest order bit of TID is not set.
|
|
|
|
* For now, set skb->priority to 0 for other cases. */
|
|
|
|
rx->skb->priority = (tid > 7) ? 0 : tid;
|
2008-01-29 17:07:43 +01:00
|
|
|
}
|
2007-07-27 15:43:22 +02:00
|
|
|
|
2009-01-07 00:26:10 +01:00
|
|
|
/**
|
|
|
|
* DOC: Packet alignment
|
|
|
|
*
|
|
|
|
* Drivers always need to pass packets that are aligned to two-byte boundaries
|
|
|
|
* to the stack.
|
|
|
|
*
|
|
|
|
* Additionally, should, if possible, align the payload data in a way that
|
|
|
|
* guarantees that the contained IP header is aligned to a four-byte
|
|
|
|
* boundary. In the case of regular frames, this simply means aligning the
|
|
|
|
* payload to a four-byte boundary (because either the IP header is directly
|
|
|
|
* contained, or IV/RFC1042 headers that have a length divisible by four are
|
|
|
|
* in front of it).
|
|
|
|
*
|
|
|
|
* With A-MSDU frames, however, the payload data address must yield two modulo
|
|
|
|
* four because there are 14-byte 802.3 headers within the A-MSDU frames that
|
|
|
|
* push the IP header further back to a multiple of four again. Thankfully, the
|
|
|
|
* specs were sane enough this time around to require padding each A-MSDU
|
|
|
|
* subframe to a length that is a multiple of four.
|
|
|
|
*
|
|
|
|
* Padding like Atheros hardware adds which is inbetween the 802.11 header and
|
|
|
|
* the payload is not supported, the driver is required to move the 802.11
|
|
|
|
* header to be directly in front of the payload in that case.
|
|
|
|
*/
|
|
|
|
static void ieee80211_verify_alignment(struct ieee80211_rx_data *rx)
|
2008-01-29 17:07:43 +01:00
|
|
|
{
|
2008-07-03 01:30:51 +02:00
|
|
|
struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
|
2008-01-29 17:07:43 +01:00
|
|
|
int hdrlen;
|
|
|
|
|
2009-01-07 00:26:10 +01:00
|
|
|
#ifndef CONFIG_MAC80211_DEBUG_PACKET_ALIGNMENT
|
|
|
|
return;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if (WARN_ONCE((unsigned long)rx->skb->data & 1,
|
|
|
|
"unaligned packet at 0x%p\n", rx->skb->data))
|
|
|
|
return;
|
|
|
|
|
2008-07-03 01:30:51 +02:00
|
|
|
if (!ieee80211_is_data_present(hdr->frame_control))
|
2008-01-29 17:07:43 +01:00
|
|
|
return;
|
|
|
|
|
2008-07-03 01:30:51 +02:00
|
|
|
hdrlen = ieee80211_hdrlen(hdr->frame_control);
|
2008-02-25 16:27:43 +01:00
|
|
|
if (rx->flags & IEEE80211_RX_AMSDU)
|
2008-01-29 17:07:43 +01:00
|
|
|
hdrlen += ETH_HLEN;
|
2009-01-07 00:26:10 +01:00
|
|
|
WARN_ONCE(((unsigned long)(rx->skb->data + hdrlen)) & 3,
|
|
|
|
"unaligned IP payload at 0x%p\n", rx->skb->data + hdrlen);
|
2007-07-27 15:43:22 +02:00
|
|
|
}
|
|
|
|
|
2007-12-24 12:36:39 +01:00
|
|
|
|
2007-07-27 15:43:22 +02:00
|
|
|
/* rx handlers */
|
|
|
|
|
2008-06-30 15:10:45 +02:00
|
|
|
static ieee80211_rx_result debug_noinline
|
2008-02-25 16:27:43 +01:00
|
|
|
ieee80211_rx_h_passive_scan(struct ieee80211_rx_data *rx)
|
2007-07-27 15:43:22 +02:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = rx->local;
|
|
|
|
struct sk_buff *skb = rx->skb;
|
|
|
|
|
2009-07-23 12:14:04 +02:00
|
|
|
if (unlikely(test_bit(SCAN_HW_SCANNING, &local->scanning)))
|
2009-06-17 13:13:00 +02:00
|
|
|
return ieee80211_scan_rx(rx->sdata, skb);
|
2007-11-22 03:53:21 +01:00
|
|
|
|
2009-07-23 13:18:01 +02:00
|
|
|
if (unlikely(test_bit(SCAN_SW_SCANNING, &local->scanning) &&
|
|
|
|
(rx->flags & IEEE80211_RX_IN_SCAN))) {
|
2007-11-22 03:53:21 +01:00
|
|
|
/* drop all the other packets during a software scan anyway */
|
2009-06-17 13:13:00 +02:00
|
|
|
if (ieee80211_scan_rx(rx->sdata, skb) != RX_QUEUED)
|
2007-11-22 03:53:21 +01:00
|
|
|
dev_kfree_skb(skb);
|
2008-01-31 19:48:20 +01:00
|
|
|
return RX_QUEUED;
|
2007-07-27 15:43:22 +02:00
|
|
|
}
|
|
|
|
|
2008-02-25 16:27:43 +01:00
|
|
|
if (unlikely(rx->flags & IEEE80211_RX_IN_SCAN)) {
|
2007-07-27 15:43:22 +02:00
|
|
|
/* scanning finished during invoking of handlers */
|
|
|
|
I802_DEBUG_INC(local->rx_handlers_drop_passive_scan);
|
2008-01-31 19:48:21 +01:00
|
|
|
return RX_DROP_UNUSABLE;
|
2007-07-27 15:43:22 +02:00
|
|
|
}
|
|
|
|
|
2008-01-31 19:48:20 +01:00
|
|
|
return RX_CONTINUE;
|
2007-07-27 15:43:22 +02:00
|
|
|
}
|
|
|
|
|
2009-01-08 12:32:02 +01:00
|
|
|
|
|
|
|
static int ieee80211_is_unicast_robust_mgmt_frame(struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
|
|
|
|
|
|
|
|
if (skb->len < 24 || is_multicast_ether_addr(hdr->addr1))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return ieee80211_is_robust_mgmt_frame(hdr);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static int ieee80211_is_multicast_robust_mgmt_frame(struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
|
|
|
|
|
|
|
|
if (skb->len < 24 || !is_multicast_ether_addr(hdr->addr1))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return ieee80211_is_robust_mgmt_frame(hdr);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Get the BIP key index from MMIE; return -1 if this is not a BIP frame */
|
|
|
|
static int ieee80211_get_mmie_keyidx(struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
struct ieee80211_mgmt *hdr = (struct ieee80211_mgmt *) skb->data;
|
|
|
|
struct ieee80211_mmie *mmie;
|
|
|
|
|
|
|
|
if (skb->len < 24 + sizeof(*mmie) ||
|
|
|
|
!is_multicast_ether_addr(hdr->da))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (!ieee80211_is_robust_mgmt_frame((struct ieee80211_hdr *) hdr))
|
|
|
|
return -1; /* not a robust management frame */
|
|
|
|
|
|
|
|
mmie = (struct ieee80211_mmie *)
|
|
|
|
(skb->data + skb->len - sizeof(*mmie));
|
|
|
|
if (mmie->element_id != WLAN_EID_MMIE ||
|
|
|
|
mmie->length != sizeof(*mmie) - 2)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
return le16_to_cpu(mmie->key_id);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-02-23 15:17:10 +01:00
|
|
|
static ieee80211_rx_result
|
2008-02-25 16:27:43 +01:00
|
|
|
ieee80211_rx_mesh_check(struct ieee80211_rx_data *rx)
|
2008-02-23 15:17:10 +01:00
|
|
|
{
|
2008-07-03 01:30:51 +02:00
|
|
|
struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
|
|
|
|
unsigned int hdrlen = ieee80211_hdrlen(hdr->frame_control);
|
2009-11-16 13:58:20 +01:00
|
|
|
char *dev_addr = rx->sdata->dev->dev_addr;
|
2008-02-25 16:24:38 +01:00
|
|
|
|
2008-07-03 01:30:51 +02:00
|
|
|
if (ieee80211_is_data(hdr->frame_control)) {
|
2009-08-10 21:15:48 +02:00
|
|
|
if (is_multicast_ether_addr(hdr->addr1)) {
|
|
|
|
if (ieee80211_has_tods(hdr->frame_control) ||
|
|
|
|
!ieee80211_has_fromds(hdr->frame_control))
|
|
|
|
return RX_DROP_MONITOR;
|
|
|
|
if (memcmp(hdr->addr3, dev_addr, ETH_ALEN) == 0)
|
|
|
|
return RX_DROP_MONITOR;
|
|
|
|
} else {
|
|
|
|
if (!ieee80211_has_a4(hdr->frame_control))
|
|
|
|
return RX_DROP_MONITOR;
|
|
|
|
if (memcmp(hdr->addr4, dev_addr, ETH_ALEN) == 0)
|
|
|
|
return RX_DROP_MONITOR;
|
|
|
|
}
|
2008-02-23 15:17:10 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* If there is not an established peer link and this is not a peer link
|
|
|
|
* establisment frame, beacon or probe, drop the frame.
|
|
|
|
*/
|
|
|
|
|
2008-03-01 00:46:08 +01:00
|
|
|
if (!rx->sta || sta_plink_state(rx->sta) != PLINK_ESTAB) {
|
2008-02-23 15:17:10 +01:00
|
|
|
struct ieee80211_mgmt *mgmt;
|
2008-02-25 16:24:38 +01:00
|
|
|
|
2008-07-03 01:30:51 +02:00
|
|
|
if (!ieee80211_is_mgmt(hdr->frame_control))
|
2008-02-23 15:17:10 +01:00
|
|
|
return RX_DROP_MONITOR;
|
|
|
|
|
2008-07-03 01:30:51 +02:00
|
|
|
if (ieee80211_is_action(hdr->frame_control)) {
|
2008-02-23 15:17:10 +01:00
|
|
|
mgmt = (struct ieee80211_mgmt *)hdr;
|
2009-11-10 00:46:43 +01:00
|
|
|
if (mgmt->u.action.category != MESH_PLINK_CATEGORY)
|
2008-02-23 15:17:10 +01:00
|
|
|
return RX_DROP_MONITOR;
|
|
|
|
return RX_CONTINUE;
|
|
|
|
}
|
|
|
|
|
2008-07-03 01:30:51 +02:00
|
|
|
if (ieee80211_is_probe_req(hdr->frame_control) ||
|
|
|
|
ieee80211_is_probe_resp(hdr->frame_control) ||
|
|
|
|
ieee80211_is_beacon(hdr->frame_control))
|
|
|
|
return RX_CONTINUE;
|
|
|
|
|
|
|
|
return RX_DROP_MONITOR;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
#define msh_h_get(h, l) ((struct ieee80211s_hdr *) ((u8 *)h + l))
|
|
|
|
|
|
|
|
if (ieee80211_is_data(hdr->frame_control) &&
|
|
|
|
is_multicast_ether_addr(hdr->addr1) &&
|
2009-08-10 21:15:48 +02:00
|
|
|
mesh_rmc_check(hdr->addr3, msh_h_get(hdr, hdrlen), rx->sdata))
|
2008-02-23 15:17:10 +01:00
|
|
|
return RX_DROP_MONITOR;
|
2008-02-23 15:17:19 +01:00
|
|
|
#undef msh_h_get
|
2008-02-25 16:24:38 +01:00
|
|
|
|
2008-02-23 15:17:19 +01:00
|
|
|
return RX_CONTINUE;
|
|
|
|
}
|
2008-02-23 15:17:10 +01:00
|
|
|
|
|
|
|
|
2008-06-30 15:10:45 +02:00
|
|
|
static ieee80211_rx_result debug_noinline
|
2008-02-25 16:27:43 +01:00
|
|
|
ieee80211_rx_h_check(struct ieee80211_rx_data *rx)
|
2007-07-27 15:43:22 +02:00
|
|
|
{
|
2008-07-03 01:30:51 +02:00
|
|
|
struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
|
2007-07-27 15:43:22 +02:00
|
|
|
|
|
|
|
/* Drop duplicate 802.11 retransmissions (IEEE 802.11 Chap. 9.2.9) */
|
|
|
|
if (rx->sta && !is_multicast_ether_addr(hdr->addr1)) {
|
2008-07-03 01:30:51 +02:00
|
|
|
if (unlikely(ieee80211_has_retry(hdr->frame_control) &&
|
2008-02-25 16:27:43 +01:00
|
|
|
rx->sta->last_seq_ctrl[rx->queue] ==
|
2007-07-27 15:43:22 +02:00
|
|
|
hdr->seq_ctrl)) {
|
2008-02-25 16:27:43 +01:00
|
|
|
if (rx->flags & IEEE80211_RX_RA_MATCH) {
|
2007-07-27 15:43:22 +02:00
|
|
|
rx->local->dot11FrameDuplicateCount++;
|
|
|
|
rx->sta->num_duplicates++;
|
|
|
|
}
|
2008-01-31 19:48:21 +01:00
|
|
|
return RX_DROP_MONITOR;
|
2007-07-27 15:43:22 +02:00
|
|
|
} else
|
2008-02-25 16:27:43 +01:00
|
|
|
rx->sta->last_seq_ctrl[rx->queue] = hdr->seq_ctrl;
|
2007-07-27 15:43:22 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (unlikely(rx->skb->len < 16)) {
|
|
|
|
I802_DEBUG_INC(rx->local->rx_handlers_drop_short);
|
2008-01-31 19:48:21 +01:00
|
|
|
return RX_DROP_MONITOR;
|
2007-07-27 15:43:22 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Drop disallowed frame classes based on STA auth/assoc state;
|
|
|
|
* IEEE 802.11, Chap 5.5.
|
|
|
|
*
|
2008-09-11 00:01:56 +02:00
|
|
|
* mac80211 filters only based on association state, i.e. it drops
|
|
|
|
* Class 3 frames from not associated stations. hostapd sends
|
2007-07-27 15:43:22 +02:00
|
|
|
* deauth/disassoc frames when needed. In addition, hostapd is
|
|
|
|
* responsible for filtering on both auth and assoc states.
|
|
|
|
*/
|
2008-02-23 15:17:10 +01:00
|
|
|
|
2008-02-23 15:17:19 +01:00
|
|
|
if (ieee80211_vif_is_mesh(&rx->sdata->vif))
|
2008-02-23 15:17:10 +01:00
|
|
|
return ieee80211_rx_mesh_check(rx);
|
|
|
|
|
2008-07-03 01:30:51 +02:00
|
|
|
if (unlikely((ieee80211_is_data(hdr->frame_control) ||
|
|
|
|
ieee80211_is_pspoll(hdr->frame_control)) &&
|
2008-09-11 00:01:58 +02:00
|
|
|
rx->sdata->vif.type != NL80211_IFTYPE_ADHOC &&
|
2008-05-03 01:02:02 +02:00
|
|
|
(!rx->sta || !test_sta_flags(rx->sta, WLAN_STA_ASSOC)))) {
|
2008-07-03 01:30:51 +02:00
|
|
|
if ((!ieee80211_has_fromds(hdr->frame_control) &&
|
|
|
|
!ieee80211_has_tods(hdr->frame_control) &&
|
|
|
|
ieee80211_is_data(hdr->frame_control)) ||
|
|
|
|
!(rx->flags & IEEE80211_RX_RA_MATCH)) {
|
2007-07-27 15:43:22 +02:00
|
|
|
/* Drop IBSS frames and frames for other hosts
|
|
|
|
* silently. */
|
2008-01-31 19:48:21 +01:00
|
|
|
return RX_DROP_MONITOR;
|
2007-07-27 15:43:22 +02:00
|
|
|
}
|
|
|
|
|
2008-01-31 19:48:21 +01:00
|
|
|
return RX_DROP_MONITOR;
|
2007-07-27 15:43:22 +02:00
|
|
|
}
|
|
|
|
|
2008-01-31 19:48:20 +01:00
|
|
|
return RX_CONTINUE;
|
2007-07-27 15:43:22 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-06-30 15:10:45 +02:00
|
|
|
static ieee80211_rx_result debug_noinline
|
2008-02-25 16:27:43 +01:00
|
|
|
ieee80211_rx_h_decrypt(struct ieee80211_rx_data *rx)
|
2007-07-27 15:43:22 +02:00
|
|
|
{
|
2009-11-16 13:58:20 +01:00
|
|
|
struct sk_buff *skb = rx->skb;
|
|
|
|
struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
|
|
|
|
struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
|
2007-08-28 23:01:53 +02:00
|
|
|
int keyidx;
|
|
|
|
int hdrlen;
|
2008-01-31 19:48:21 +01:00
|
|
|
ieee80211_rx_result result = RX_DROP_UNUSABLE;
|
[MAC80211]: fix race conditions with keys
During receive processing, we select the key long before using it and
because there's no locking it is possible that we kfree() the key
after having selected it but before using it for crypto operations.
Obviously, this is bad.
Secondly, during transmit processing, there are two possible races: We
have a similar race between select_key() and using it for encryption,
but we also have a race here between select_key() and hardware
encryption (both when a key is removed.)
This patch solves these issues by using RCU: when a key is to be freed,
we first remove the pointer from the appropriate places (sdata->keys,
sdata->default_key, sta->key) using rcu_assign_pointer() and then
synchronize_rcu(). Then, we can safely kfree() the key and remove it
from the hardware. There's a window here where the hardware may still
be using it for decryption, but we can't work around that without having
two hardware callbacks, one to disable the key for RX and one to disable
it for TX; but the worst thing that will happen is that we receive a
packet decrypted that we don't find a key for any more and then drop it.
When we add a key, we first need to upload it to the hardware and then,
using rcu_assign_pointer() again, link it into our structures.
In the code using keys (TX/RX paths) we use rcu_dereference() to get the
key and enclose the whole tx/rx section in a rcu_read_lock() ...
rcu_read_unlock() block. Because we've uploaded the key to hardware
before linking it into internal structures, we can guarantee that it is
valid once get to into tx().
One possible race condition remains, however: when we have hardware
acceleration enabled and the driver shuts down the queues, we end up
queueing the frame. If now somebody removes the key, the key will be
removed from hwaccel and then then driver will be asked to encrypt the
frame with a key index that has been removed. Hence, drivers will need
to be aware that the hw_key_index they are passed might not be under
all circumstances. Most drivers will, however, simply ignore that
condition and encrypt the frame with the selected key anyway, this
only results in a frame being encrypted with a wrong key or dropped
(rightfully) because the key was not valid. There isn't much we can
do about it unless we want to walk the pending frame queue every time
a key is removed and remove all frames that used it.
This race condition, however, will most likely be solved once we add
multiqueue support to mac80211 because then frames will be queued
further up the stack instead of after being processed.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Acked-by: Michael Wu <flamingice@sourmilk.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-09-14 17:10:24 +02:00
|
|
|
struct ieee80211_key *stakey = NULL;
|
2009-01-08 12:32:02 +01:00
|
|
|
int mmie_keyidx = -1;
|
2007-07-27 15:43:22 +02:00
|
|
|
|
2007-08-28 23:01:53 +02:00
|
|
|
/*
|
|
|
|
* Key selection 101
|
|
|
|
*
|
2009-01-08 12:32:02 +01:00
|
|
|
* There are four types of keys:
|
2007-08-28 23:01:53 +02:00
|
|
|
* - GTK (group keys)
|
2009-01-08 12:32:02 +01:00
|
|
|
* - IGTK (group keys for management frames)
|
2007-08-28 23:01:53 +02:00
|
|
|
* - PTK (pairwise keys)
|
|
|
|
* - STK (station-to-station pairwise keys)
|
|
|
|
*
|
|
|
|
* When selecting a key, we have to distinguish between multicast
|
|
|
|
* (including broadcast) and unicast frames, the latter can only
|
2009-01-08 12:32:02 +01:00
|
|
|
* use PTKs and STKs while the former always use GTKs and IGTKs.
|
|
|
|
* Unless, of course, actual WEP keys ("pre-RSNA") are used, then
|
|
|
|
* unicast frames can also use key indices like GTKs. Hence, if we
|
|
|
|
* don't have a PTK/STK we check the key index for a WEP key.
|
2007-08-28 23:01:53 +02:00
|
|
|
*
|
2007-08-28 23:01:55 +02:00
|
|
|
* Note that in a regular BSS, multicast frames are sent by the
|
|
|
|
* AP only, associated stations unicast the frame to the AP first
|
|
|
|
* which then multicasts it on their behalf.
|
|
|
|
*
|
2007-08-28 23:01:53 +02:00
|
|
|
* There is also a slight problem in IBSS mode: GTKs are negotiated
|
|
|
|
* with each station, that is something we don't currently handle.
|
2007-08-28 23:01:55 +02:00
|
|
|
* The spec seems to expect that one negotiates the same key with
|
|
|
|
* every station but there's no such requirement; VLANs could be
|
|
|
|
* possible.
|
2007-08-28 23:01:53 +02:00
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
2007-09-26 17:53:15 +02:00
|
|
|
* No point in finding a key and decrypting if the frame is neither
|
2007-08-28 23:01:53 +02:00
|
|
|
* addressed to us nor a multicast frame.
|
|
|
|
*/
|
2008-02-25 16:27:43 +01:00
|
|
|
if (!(rx->flags & IEEE80211_RX_RA_MATCH))
|
2008-01-31 19:48:20 +01:00
|
|
|
return RX_CONTINUE;
|
2007-08-28 23:01:53 +02:00
|
|
|
|
[MAC80211]: fix race conditions with keys
During receive processing, we select the key long before using it and
because there's no locking it is possible that we kfree() the key
after having selected it but before using it for crypto operations.
Obviously, this is bad.
Secondly, during transmit processing, there are two possible races: We
have a similar race between select_key() and using it for encryption,
but we also have a race here between select_key() and hardware
encryption (both when a key is removed.)
This patch solves these issues by using RCU: when a key is to be freed,
we first remove the pointer from the appropriate places (sdata->keys,
sdata->default_key, sta->key) using rcu_assign_pointer() and then
synchronize_rcu(). Then, we can safely kfree() the key and remove it
from the hardware. There's a window here where the hardware may still
be using it for decryption, but we can't work around that without having
two hardware callbacks, one to disable the key for RX and one to disable
it for TX; but the worst thing that will happen is that we receive a
packet decrypted that we don't find a key for any more and then drop it.
When we add a key, we first need to upload it to the hardware and then,
using rcu_assign_pointer() again, link it into our structures.
In the code using keys (TX/RX paths) we use rcu_dereference() to get the
key and enclose the whole tx/rx section in a rcu_read_lock() ...
rcu_read_unlock() block. Because we've uploaded the key to hardware
before linking it into internal structures, we can guarantee that it is
valid once get to into tx().
One possible race condition remains, however: when we have hardware
acceleration enabled and the driver shuts down the queues, we end up
queueing the frame. If now somebody removes the key, the key will be
removed from hwaccel and then then driver will be asked to encrypt the
frame with a key index that has been removed. Hence, drivers will need
to be aware that the hw_key_index they are passed might not be under
all circumstances. Most drivers will, however, simply ignore that
condition and encrypt the frame with the selected key anyway, this
only results in a frame being encrypted with a wrong key or dropped
(rightfully) because the key was not valid. There isn't much we can
do about it unless we want to walk the pending frame queue every time
a key is removed and remove all frames that used it.
This race condition, however, will most likely be solved once we add
multiqueue support to mac80211 because then frames will be queued
further up the stack instead of after being processed.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Acked-by: Michael Wu <flamingice@sourmilk.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-09-14 17:10:24 +02:00
|
|
|
if (rx->sta)
|
|
|
|
stakey = rcu_dereference(rx->sta->key);
|
|
|
|
|
2009-05-08 11:34:10 +02:00
|
|
|
if (!ieee80211_has_protected(hdr->frame_control))
|
|
|
|
mmie_keyidx = ieee80211_get_mmie_keyidx(rx->skb);
|
|
|
|
|
[MAC80211]: fix race conditions with keys
During receive processing, we select the key long before using it and
because there's no locking it is possible that we kfree() the key
after having selected it but before using it for crypto operations.
Obviously, this is bad.
Secondly, during transmit processing, there are two possible races: We
have a similar race between select_key() and using it for encryption,
but we also have a race here between select_key() and hardware
encryption (both when a key is removed.)
This patch solves these issues by using RCU: when a key is to be freed,
we first remove the pointer from the appropriate places (sdata->keys,
sdata->default_key, sta->key) using rcu_assign_pointer() and then
synchronize_rcu(). Then, we can safely kfree() the key and remove it
from the hardware. There's a window here where the hardware may still
be using it for decryption, but we can't work around that without having
two hardware callbacks, one to disable the key for RX and one to disable
it for TX; but the worst thing that will happen is that we receive a
packet decrypted that we don't find a key for any more and then drop it.
When we add a key, we first need to upload it to the hardware and then,
using rcu_assign_pointer() again, link it into our structures.
In the code using keys (TX/RX paths) we use rcu_dereference() to get the
key and enclose the whole tx/rx section in a rcu_read_lock() ...
rcu_read_unlock() block. Because we've uploaded the key to hardware
before linking it into internal structures, we can guarantee that it is
valid once get to into tx().
One possible race condition remains, however: when we have hardware
acceleration enabled and the driver shuts down the queues, we end up
queueing the frame. If now somebody removes the key, the key will be
removed from hwaccel and then then driver will be asked to encrypt the
frame with a key index that has been removed. Hence, drivers will need
to be aware that the hw_key_index they are passed might not be under
all circumstances. Most drivers will, however, simply ignore that
condition and encrypt the frame with the selected key anyway, this
only results in a frame being encrypted with a wrong key or dropped
(rightfully) because the key was not valid. There isn't much we can
do about it unless we want to walk the pending frame queue every time
a key is removed and remove all frames that used it.
This race condition, however, will most likely be solved once we add
multiqueue support to mac80211 because then frames will be queued
further up the stack instead of after being processed.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Acked-by: Michael Wu <flamingice@sourmilk.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-09-14 17:10:24 +02:00
|
|
|
if (!is_multicast_ether_addr(hdr->addr1) && stakey) {
|
|
|
|
rx->key = stakey;
|
2009-05-08 11:34:10 +02:00
|
|
|
/* Skip decryption if the frame is not protected. */
|
|
|
|
if (!ieee80211_has_protected(hdr->frame_control))
|
|
|
|
return RX_CONTINUE;
|
2009-01-08 12:32:02 +01:00
|
|
|
} else if (mmie_keyidx >= 0) {
|
|
|
|
/* Broadcast/multicast robust management frame / BIP */
|
2009-11-16 13:58:20 +01:00
|
|
|
if ((status->flag & RX_FLAG_DECRYPTED) &&
|
|
|
|
(status->flag & RX_FLAG_IV_STRIPPED))
|
2009-01-08 12:32:02 +01:00
|
|
|
return RX_CONTINUE;
|
|
|
|
|
|
|
|
if (mmie_keyidx < NUM_DEFAULT_KEYS ||
|
|
|
|
mmie_keyidx >= NUM_DEFAULT_KEYS + NUM_DEFAULT_MGMT_KEYS)
|
|
|
|
return RX_DROP_MONITOR; /* unexpected BIP keyidx */
|
|
|
|
rx->key = rcu_dereference(rx->sdata->keys[mmie_keyidx]);
|
2009-05-08 11:34:10 +02:00
|
|
|
} else if (!ieee80211_has_protected(hdr->frame_control)) {
|
|
|
|
/*
|
|
|
|
* The frame was not protected, so skip decryption. However, we
|
|
|
|
* need to set rx->key if there is a key that could have been
|
|
|
|
* used so that the frame may be dropped if encryption would
|
|
|
|
* have been expected.
|
|
|
|
*/
|
|
|
|
struct ieee80211_key *key = NULL;
|
|
|
|
if (ieee80211_is_mgmt(hdr->frame_control) &&
|
|
|
|
is_multicast_ether_addr(hdr->addr1) &&
|
|
|
|
(key = rcu_dereference(rx->sdata->default_mgmt_key)))
|
|
|
|
rx->key = key;
|
|
|
|
else if ((key = rcu_dereference(rx->sdata->default_key)))
|
|
|
|
rx->key = key;
|
|
|
|
return RX_CONTINUE;
|
2007-07-27 15:43:22 +02:00
|
|
|
} else {
|
2007-08-28 23:01:53 +02:00
|
|
|
/*
|
|
|
|
* The device doesn't give us the IV so we won't be
|
|
|
|
* able to look up the key. That's ok though, we
|
|
|
|
* don't need to decrypt the frame, we just won't
|
|
|
|
* be able to keep statistics accurate.
|
|
|
|
* Except for key threshold notifications, should
|
|
|
|
* we somehow allow the driver to tell us which key
|
|
|
|
* the hardware used if this flag is set?
|
|
|
|
*/
|
2009-11-16 13:58:20 +01:00
|
|
|
if ((status->flag & RX_FLAG_DECRYPTED) &&
|
|
|
|
(status->flag & RX_FLAG_IV_STRIPPED))
|
2008-01-31 19:48:20 +01:00
|
|
|
return RX_CONTINUE;
|
2007-08-28 23:01:53 +02:00
|
|
|
|
2008-07-03 01:30:51 +02:00
|
|
|
hdrlen = ieee80211_hdrlen(hdr->frame_control);
|
2007-08-28 23:01:53 +02:00
|
|
|
|
|
|
|
if (rx->skb->len < 8 + hdrlen)
|
2008-01-31 19:48:21 +01:00
|
|
|
return RX_DROP_UNUSABLE; /* TODO: count this? */
|
2007-08-28 23:01:53 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* no need to call ieee80211_wep_get_keyidx,
|
|
|
|
* it verifies a bunch of things we've done already
|
|
|
|
*/
|
|
|
|
keyidx = rx->skb->data[hdrlen + 3] >> 6;
|
|
|
|
|
[MAC80211]: fix race conditions with keys
During receive processing, we select the key long before using it and
because there's no locking it is possible that we kfree() the key
after having selected it but before using it for crypto operations.
Obviously, this is bad.
Secondly, during transmit processing, there are two possible races: We
have a similar race between select_key() and using it for encryption,
but we also have a race here between select_key() and hardware
encryption (both when a key is removed.)
This patch solves these issues by using RCU: when a key is to be freed,
we first remove the pointer from the appropriate places (sdata->keys,
sdata->default_key, sta->key) using rcu_assign_pointer() and then
synchronize_rcu(). Then, we can safely kfree() the key and remove it
from the hardware. There's a window here where the hardware may still
be using it for decryption, but we can't work around that without having
two hardware callbacks, one to disable the key for RX and one to disable
it for TX; but the worst thing that will happen is that we receive a
packet decrypted that we don't find a key for any more and then drop it.
When we add a key, we first need to upload it to the hardware and then,
using rcu_assign_pointer() again, link it into our structures.
In the code using keys (TX/RX paths) we use rcu_dereference() to get the
key and enclose the whole tx/rx section in a rcu_read_lock() ...
rcu_read_unlock() block. Because we've uploaded the key to hardware
before linking it into internal structures, we can guarantee that it is
valid once get to into tx().
One possible race condition remains, however: when we have hardware
acceleration enabled and the driver shuts down the queues, we end up
queueing the frame. If now somebody removes the key, the key will be
removed from hwaccel and then then driver will be asked to encrypt the
frame with a key index that has been removed. Hence, drivers will need
to be aware that the hw_key_index they are passed might not be under
all circumstances. Most drivers will, however, simply ignore that
condition and encrypt the frame with the selected key anyway, this
only results in a frame being encrypted with a wrong key or dropped
(rightfully) because the key was not valid. There isn't much we can
do about it unless we want to walk the pending frame queue every time
a key is removed and remove all frames that used it.
This race condition, however, will most likely be solved once we add
multiqueue support to mac80211 because then frames will be queued
further up the stack instead of after being processed.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Acked-by: Michael Wu <flamingice@sourmilk.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-09-14 17:10:24 +02:00
|
|
|
rx->key = rcu_dereference(rx->sdata->keys[keyidx]);
|
2007-08-28 23:01:53 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* RSNA-protected unicast frames should always be sent with
|
|
|
|
* pairwise or station-to-station keys, but for WEP we allow
|
|
|
|
* using a key index as well.
|
|
|
|
*/
|
2007-08-28 23:01:54 +02:00
|
|
|
if (rx->key && rx->key->conf.alg != ALG_WEP &&
|
2007-08-28 23:01:53 +02:00
|
|
|
!is_multicast_ether_addr(hdr->addr1))
|
|
|
|
rx->key = NULL;
|
2007-07-27 15:43:22 +02:00
|
|
|
}
|
|
|
|
|
2007-08-28 23:01:53 +02:00
|
|
|
if (rx->key) {
|
2007-07-27 15:43:22 +02:00
|
|
|
rx->key->tx_rx_count++;
|
2007-09-17 07:29:25 +02:00
|
|
|
/* TODO: add threshold stuff again */
|
2007-09-26 17:53:15 +02:00
|
|
|
} else {
|
2008-01-31 19:48:21 +01:00
|
|
|
return RX_DROP_MONITOR;
|
2007-09-26 17:53:14 +02:00
|
|
|
}
|
|
|
|
|
2007-09-26 17:53:15 +02:00
|
|
|
/* Check for weak IVs if possible */
|
|
|
|
if (rx->sta && rx->key->conf.alg == ALG_WEP &&
|
2008-07-03 01:30:51 +02:00
|
|
|
ieee80211_is_data(hdr->frame_control) &&
|
2009-11-16 13:58:20 +01:00
|
|
|
(!(status->flag & RX_FLAG_IV_STRIPPED) ||
|
|
|
|
!(status->flag & RX_FLAG_DECRYPTED)) &&
|
2007-09-26 17:53:15 +02:00
|
|
|
ieee80211_wep_is_weak_iv(rx->skb, rx->key))
|
|
|
|
rx->sta->wep_weak_iv_count++;
|
|
|
|
|
2007-09-26 17:53:14 +02:00
|
|
|
switch (rx->key->conf.alg) {
|
|
|
|
case ALG_WEP:
|
2007-10-07 16:35:31 +02:00
|
|
|
result = ieee80211_crypto_wep_decrypt(rx);
|
|
|
|
break;
|
2007-09-26 17:53:14 +02:00
|
|
|
case ALG_TKIP:
|
2007-10-07 16:35:31 +02:00
|
|
|
result = ieee80211_crypto_tkip_decrypt(rx);
|
|
|
|
break;
|
2007-09-26 17:53:14 +02:00
|
|
|
case ALG_CCMP:
|
2007-10-07 16:35:31 +02:00
|
|
|
result = ieee80211_crypto_ccmp_decrypt(rx);
|
|
|
|
break;
|
2009-01-08 12:32:02 +01:00
|
|
|
case ALG_AES_CMAC:
|
|
|
|
result = ieee80211_crypto_aes_cmac_decrypt(rx);
|
|
|
|
break;
|
2007-09-26 17:53:14 +02:00
|
|
|
}
|
|
|
|
|
2007-10-07 16:35:31 +02:00
|
|
|
/* either the frame has been decrypted or will be dropped */
|
2009-11-16 13:58:20 +01:00
|
|
|
status->flag |= RX_FLAG_DECRYPTED;
|
2007-10-07 16:35:31 +02:00
|
|
|
|
|
|
|
return result;
|
2007-09-26 17:53:14 +02:00
|
|
|
}
|
|
|
|
|
2009-02-10 16:09:31 +01:00
|
|
|
static ieee80211_rx_result debug_noinline
|
|
|
|
ieee80211_rx_h_check_more_data(struct ieee80211_rx_data *rx)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local;
|
|
|
|
struct ieee80211_hdr *hdr;
|
|
|
|
struct sk_buff *skb;
|
|
|
|
|
|
|
|
local = rx->local;
|
|
|
|
skb = rx->skb;
|
|
|
|
hdr = (struct ieee80211_hdr *) skb->data;
|
|
|
|
|
|
|
|
if (!local->pspolling)
|
|
|
|
return RX_CONTINUE;
|
|
|
|
|
|
|
|
if (!ieee80211_has_fromds(hdr->frame_control))
|
|
|
|
/* this is not from AP */
|
|
|
|
return RX_CONTINUE;
|
|
|
|
|
|
|
|
if (!ieee80211_is_data(hdr->frame_control))
|
|
|
|
return RX_CONTINUE;
|
|
|
|
|
|
|
|
if (!ieee80211_has_moredata(hdr->frame_control)) {
|
|
|
|
/* AP has no more frames buffered for us */
|
|
|
|
local->pspolling = false;
|
|
|
|
return RX_CONTINUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* more data bit is set, let's request a new frame from the AP */
|
|
|
|
ieee80211_send_pspoll(local, rx->sdata);
|
|
|
|
|
|
|
|
return RX_CONTINUE;
|
|
|
|
}
|
|
|
|
|
2008-09-16 14:18:59 +02:00
|
|
|
static void ap_sta_ps_start(struct sta_info *sta)
|
2007-07-27 15:43:22 +02:00
|
|
|
{
|
2008-09-16 14:18:59 +02:00
|
|
|
struct ieee80211_sub_if_data *sdata = sta->sdata;
|
2008-11-30 00:48:41 +01:00
|
|
|
struct ieee80211_local *local = sdata->local;
|
2007-10-04 02:59:30 +02:00
|
|
|
|
mac80211: make master netdev handling sane
Currently, almost every interface type has a 'bss' pointer
pointing to BSS information. This BSS information, however,
is for a _local_ BSS, not for the BSS we joined, so having
it on a STA mode interface makes little sense, but now they
have it pointing to the master device, which is an AP mode
virtual interface. However, except for some bitrate control
data, this pointer is only used in AP/VLAN modes (for power
saving stations.)
Overall, it is not necessary to even have the master netdev
be a valid virtual interface, and it doesn't have to be on
the list of interfaces either.
This patch changes the master netdev to be special, it now
- no longer is on the list of virtual interfaces, which
lets me remove a lot of tests for that
- no longer has sub_if_data attached, since that isn't used
Additionally, this patch changes some vlan/ap mode handling
that is related to these 'bss' pointers described above (but
in the VLAN case they actually make sense because there they
point to the AP they belong to); it also adds some debugging
code to IEEE80211_DEV_TO_SUB_IF to validate it is not called
on the master netdev any more.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2008-07-09 14:40:34 +02:00
|
|
|
atomic_inc(&sdata->bss->num_sta_ps);
|
mac80211: async station powersave handling
Some devices require that all frames to a station
are flushed when that station goes into powersave
mode before being able to send frames to that
station again when it wakes up or polls -- all in
order to avoid reordering and too many or too few
frames being sent to the station when it polls.
Normally, this is the case unless the station
goes to sleep and wakes up very quickly again.
But in that case, frames for it may be pending
on the hardware queues, and thus races could
happen in the case of multiple hardware queues
used for QoS/WMM. Normally this isn't a problem,
but with the iwlwifi mechanism we need to make
sure the race doesn't happen.
This makes mac80211 able to cope with the race
with driver help by a new WLAN_STA_PS_DRIVER
per-station flag that can be controlled by the
driver and tells mac80211 whether it can transmit
frames or not. This flag must be set according to
very specific rules outlined in the documentation
for the function that controls it.
When we buffer new frames for the station, we
normally set the TIM bit right away, but while
the driver has blocked transmission to that sta
we need to avoid that as well since we cannot
respond to the station if it wakes up due to the
TIM bit. Once the driver unblocks, we can set
the TIM bit.
Similarly, when the station just wakes up, we
need to wait until all other frames are flushed
before we can transmit frames to that station,
so the same applies here, we need to wait for
the driver to give the OK.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-11-06 11:35:50 +01:00
|
|
|
set_sta_flags(sta, WLAN_STA_PS_STA);
|
2009-04-23 18:52:52 +02:00
|
|
|
drv_sta_notify(local, &sdata->vif, STA_NOTIFY_SLEEP, &sta->sta);
|
2007-07-27 15:43:22 +02:00
|
|
|
#ifdef CONFIG_MAC80211_VERBOSE_PS_DEBUG
|
2008-10-27 23:56:10 +01:00
|
|
|
printk(KERN_DEBUG "%s: STA %pM aid %d enters power save mode\n",
|
|
|
|
sdata->dev->name, sta->sta.addr, sta->sta.aid);
|
2007-07-27 15:43:22 +02:00
|
|
|
#endif /* CONFIG_MAC80211_VERBOSE_PS_DEBUG */
|
|
|
|
}
|
|
|
|
|
2009-10-30 12:56:02 +01:00
|
|
|
static void ap_sta_ps_end(struct sta_info *sta)
|
2007-07-27 15:43:22 +02:00
|
|
|
{
|
2008-09-16 14:18:59 +02:00
|
|
|
struct ieee80211_sub_if_data *sdata = sta->sdata;
|
2007-07-27 15:43:22 +02:00
|
|
|
|
mac80211: make master netdev handling sane
Currently, almost every interface type has a 'bss' pointer
pointing to BSS information. This BSS information, however,
is for a _local_ BSS, not for the BSS we joined, so having
it on a STA mode interface makes little sense, but now they
have it pointing to the master device, which is an AP mode
virtual interface. However, except for some bitrate control
data, this pointer is only used in AP/VLAN modes (for power
saving stations.)
Overall, it is not necessary to even have the master netdev
be a valid virtual interface, and it doesn't have to be on
the list of interfaces either.
This patch changes the master netdev to be special, it now
- no longer is on the list of virtual interfaces, which
lets me remove a lot of tests for that
- no longer has sub_if_data attached, since that isn't used
Additionally, this patch changes some vlan/ap mode handling
that is related to these 'bss' pointers described above (but
in the VLAN case they actually make sense because there they
point to the AP they belong to); it also adds some debugging
code to IEEE80211_DEV_TO_SUB_IF to validate it is not called
on the master netdev any more.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2008-07-09 14:40:34 +02:00
|
|
|
atomic_dec(&sdata->bss->num_sta_ps);
|
2008-02-20 11:21:35 +01:00
|
|
|
|
mac80211: async station powersave handling
Some devices require that all frames to a station
are flushed when that station goes into powersave
mode before being able to send frames to that
station again when it wakes up or polls -- all in
order to avoid reordering and too many or too few
frames being sent to the station when it polls.
Normally, this is the case unless the station
goes to sleep and wakes up very quickly again.
But in that case, frames for it may be pending
on the hardware queues, and thus races could
happen in the case of multiple hardware queues
used for QoS/WMM. Normally this isn't a problem,
but with the iwlwifi mechanism we need to make
sure the race doesn't happen.
This makes mac80211 able to cope with the race
with driver help by a new WLAN_STA_PS_DRIVER
per-station flag that can be controlled by the
driver and tells mac80211 whether it can transmit
frames or not. This flag must be set according to
very specific rules outlined in the documentation
for the function that controls it.
When we buffer new frames for the station, we
normally set the TIM bit right away, but while
the driver has blocked transmission to that sta
we need to avoid that as well since we cannot
respond to the station if it wakes up due to the
TIM bit. Once the driver unblocks, we can set
the TIM bit.
Similarly, when the station just wakes up, we
need to wait until all other frames are flushed
before we can transmit frames to that station,
so the same applies here, we need to wait for
the driver to give the OK.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-11-06 11:35:50 +01:00
|
|
|
clear_sta_flags(sta, WLAN_STA_PS_STA);
|
2008-02-20 11:21:35 +01:00
|
|
|
|
2007-07-27 15:43:22 +02:00
|
|
|
#ifdef CONFIG_MAC80211_VERBOSE_PS_DEBUG
|
2008-10-27 23:56:10 +01:00
|
|
|
printk(KERN_DEBUG "%s: STA %pM aid %d exits power save mode\n",
|
|
|
|
sdata->dev->name, sta->sta.addr, sta->sta.aid);
|
2007-07-27 15:43:22 +02:00
|
|
|
#endif /* CONFIG_MAC80211_VERBOSE_PS_DEBUG */
|
2008-02-20 11:21:35 +01:00
|
|
|
|
mac80211: async station powersave handling
Some devices require that all frames to a station
are flushed when that station goes into powersave
mode before being able to send frames to that
station again when it wakes up or polls -- all in
order to avoid reordering and too many or too few
frames being sent to the station when it polls.
Normally, this is the case unless the station
goes to sleep and wakes up very quickly again.
But in that case, frames for it may be pending
on the hardware queues, and thus races could
happen in the case of multiple hardware queues
used for QoS/WMM. Normally this isn't a problem,
but with the iwlwifi mechanism we need to make
sure the race doesn't happen.
This makes mac80211 able to cope with the race
with driver help by a new WLAN_STA_PS_DRIVER
per-station flag that can be controlled by the
driver and tells mac80211 whether it can transmit
frames or not. This flag must be set according to
very specific rules outlined in the documentation
for the function that controls it.
When we buffer new frames for the station, we
normally set the TIM bit right away, but while
the driver has blocked transmission to that sta
we need to avoid that as well since we cannot
respond to the station if it wakes up due to the
TIM bit. Once the driver unblocks, we can set
the TIM bit.
Similarly, when the station just wakes up, we
need to wait until all other frames are flushed
before we can transmit frames to that station,
so the same applies here, we need to wait for
the driver to give the OK.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-11-06 11:35:50 +01:00
|
|
|
if (test_sta_flags(sta, WLAN_STA_PS_DRIVER)) {
|
2007-07-27 15:43:22 +02:00
|
|
|
#ifdef CONFIG_MAC80211_VERBOSE_PS_DEBUG
|
mac80211: async station powersave handling
Some devices require that all frames to a station
are flushed when that station goes into powersave
mode before being able to send frames to that
station again when it wakes up or polls -- all in
order to avoid reordering and too many or too few
frames being sent to the station when it polls.
Normally, this is the case unless the station
goes to sleep and wakes up very quickly again.
But in that case, frames for it may be pending
on the hardware queues, and thus races could
happen in the case of multiple hardware queues
used for QoS/WMM. Normally this isn't a problem,
but with the iwlwifi mechanism we need to make
sure the race doesn't happen.
This makes mac80211 able to cope with the race
with driver help by a new WLAN_STA_PS_DRIVER
per-station flag that can be controlled by the
driver and tells mac80211 whether it can transmit
frames or not. This flag must be set according to
very specific rules outlined in the documentation
for the function that controls it.
When we buffer new frames for the station, we
normally set the TIM bit right away, but while
the driver has blocked transmission to that sta
we need to avoid that as well since we cannot
respond to the station if it wakes up due to the
TIM bit. Once the driver unblocks, we can set
the TIM bit.
Similarly, when the station just wakes up, we
need to wait until all other frames are flushed
before we can transmit frames to that station,
so the same applies here, we need to wait for
the driver to give the OK.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-11-06 11:35:50 +01:00
|
|
|
printk(KERN_DEBUG "%s: STA %pM aid %d driver-ps-blocked\n",
|
|
|
|
sdata->dev->name, sta->sta.addr, sta->sta.aid);
|
2007-07-27 15:43:22 +02:00
|
|
|
#endif /* CONFIG_MAC80211_VERBOSE_PS_DEBUG */
|
mac80211: async station powersave handling
Some devices require that all frames to a station
are flushed when that station goes into powersave
mode before being able to send frames to that
station again when it wakes up or polls -- all in
order to avoid reordering and too many or too few
frames being sent to the station when it polls.
Normally, this is the case unless the station
goes to sleep and wakes up very quickly again.
But in that case, frames for it may be pending
on the hardware queues, and thus races could
happen in the case of multiple hardware queues
used for QoS/WMM. Normally this isn't a problem,
but with the iwlwifi mechanism we need to make
sure the race doesn't happen.
This makes mac80211 able to cope with the race
with driver help by a new WLAN_STA_PS_DRIVER
per-station flag that can be controlled by the
driver and tells mac80211 whether it can transmit
frames or not. This flag must be set according to
very specific rules outlined in the documentation
for the function that controls it.
When we buffer new frames for the station, we
normally set the TIM bit right away, but while
the driver has blocked transmission to that sta
we need to avoid that as well since we cannot
respond to the station if it wakes up due to the
TIM bit. Once the driver unblocks, we can set
the TIM bit.
Similarly, when the station just wakes up, we
need to wait until all other frames are flushed
before we can transmit frames to that station,
so the same applies here, we need to wait for
the driver to give the OK.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-11-06 11:35:50 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
ieee80211_sta_ps_deliver_wakeup(sta);
|
2007-07-27 15:43:22 +02:00
|
|
|
}
|
|
|
|
|
2008-06-30 15:10:45 +02:00
|
|
|
static ieee80211_rx_result debug_noinline
|
2008-02-25 16:27:43 +01:00
|
|
|
ieee80211_rx_h_sta_process(struct ieee80211_rx_data *rx)
|
2007-07-27 15:43:22 +02:00
|
|
|
{
|
|
|
|
struct sta_info *sta = rx->sta;
|
2009-11-16 13:58:20 +01:00
|
|
|
struct sk_buff *skb = rx->skb;
|
|
|
|
struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
|
|
|
|
struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
|
2007-07-27 15:43:22 +02:00
|
|
|
|
|
|
|
if (!sta)
|
2008-01-31 19:48:20 +01:00
|
|
|
return RX_CONTINUE;
|
2007-07-27 15:43:22 +02:00
|
|
|
|
2009-07-10 15:29:03 +02:00
|
|
|
/*
|
|
|
|
* Update last_rx only for IBSS packets which are for the current
|
|
|
|
* BSSID to avoid keeping the current IBSS network alive in cases
|
|
|
|
* where other STAs start using different BSSID.
|
|
|
|
*/
|
2008-09-11 00:01:58 +02:00
|
|
|
if (rx->sdata->vif.type == NL80211_IFTYPE_ADHOC) {
|
2007-12-25 16:00:36 +01:00
|
|
|
u8 *bssid = ieee80211_get_bssid(hdr, rx->skb->len,
|
2008-09-11 00:01:58 +02:00
|
|
|
NL80211_IFTYPE_ADHOC);
|
2009-02-15 12:44:28 +01:00
|
|
|
if (compare_ether_addr(bssid, rx->sdata->u.ibss.bssid) == 0)
|
2007-07-27 15:43:22 +02:00
|
|
|
sta->last_rx = jiffies;
|
2009-07-10 15:29:03 +02:00
|
|
|
} else if (!is_multicast_ether_addr(hdr->addr1)) {
|
|
|
|
/*
|
2008-02-23 15:17:10 +01:00
|
|
|
* Mesh beacons will update last_rx when if they are found to
|
|
|
|
* match the current local configuration when processed.
|
2007-07-27 15:43:22 +02:00
|
|
|
*/
|
2009-07-10 15:29:03 +02:00
|
|
|
sta->last_rx = jiffies;
|
2007-07-27 15:43:22 +02:00
|
|
|
}
|
|
|
|
|
2008-02-25 16:27:43 +01:00
|
|
|
if (!(rx->flags & IEEE80211_RX_RA_MATCH))
|
2008-01-31 19:48:20 +01:00
|
|
|
return RX_CONTINUE;
|
2007-07-27 15:43:22 +02:00
|
|
|
|
2009-03-22 20:57:06 +01:00
|
|
|
if (rx->sdata->vif.type == NL80211_IFTYPE_STATION)
|
|
|
|
ieee80211_sta_rx_notify(rx->sdata, hdr);
|
|
|
|
|
2007-07-27 15:43:22 +02:00
|
|
|
sta->rx_fragments++;
|
|
|
|
sta->rx_bytes += rx->skb->len;
|
2009-11-16 13:58:20 +01:00
|
|
|
sta->last_signal = status->signal;
|
|
|
|
sta->last_noise = status->noise;
|
2007-07-27 15:43:22 +02:00
|
|
|
|
2008-11-26 15:02:58 +01:00
|
|
|
/*
|
|
|
|
* Change STA power saving mode only at the end of a frame
|
|
|
|
* exchange sequence.
|
|
|
|
*/
|
mac80211: make master netdev handling sane
Currently, almost every interface type has a 'bss' pointer
pointing to BSS information. This BSS information, however,
is for a _local_ BSS, not for the BSS we joined, so having
it on a STA mode interface makes little sense, but now they
have it pointing to the master device, which is an AP mode
virtual interface. However, except for some bitrate control
data, this pointer is only used in AP/VLAN modes (for power
saving stations.)
Overall, it is not necessary to even have the master netdev
be a valid virtual interface, and it doesn't have to be on
the list of interfaces either.
This patch changes the master netdev to be special, it now
- no longer is on the list of virtual interfaces, which
lets me remove a lot of tests for that
- no longer has sub_if_data attached, since that isn't used
Additionally, this patch changes some vlan/ap mode handling
that is related to these 'bss' pointers described above (but
in the VLAN case they actually make sense because there they
point to the AP they belong to); it also adds some debugging
code to IEEE80211_DEV_TO_SUB_IF to validate it is not called
on the master netdev any more.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2008-07-09 14:40:34 +02:00
|
|
|
if (!ieee80211_has_morefrags(hdr->frame_control) &&
|
2008-09-11 00:01:58 +02:00
|
|
|
(rx->sdata->vif.type == NL80211_IFTYPE_AP ||
|
|
|
|
rx->sdata->vif.type == NL80211_IFTYPE_AP_VLAN)) {
|
mac80211: async station powersave handling
Some devices require that all frames to a station
are flushed when that station goes into powersave
mode before being able to send frames to that
station again when it wakes up or polls -- all in
order to avoid reordering and too many or too few
frames being sent to the station when it polls.
Normally, this is the case unless the station
goes to sleep and wakes up very quickly again.
But in that case, frames for it may be pending
on the hardware queues, and thus races could
happen in the case of multiple hardware queues
used for QoS/WMM. Normally this isn't a problem,
but with the iwlwifi mechanism we need to make
sure the race doesn't happen.
This makes mac80211 able to cope with the race
with driver help by a new WLAN_STA_PS_DRIVER
per-station flag that can be controlled by the
driver and tells mac80211 whether it can transmit
frames or not. This flag must be set according to
very specific rules outlined in the documentation
for the function that controls it.
When we buffer new frames for the station, we
normally set the TIM bit right away, but while
the driver has blocked transmission to that sta
we need to avoid that as well since we cannot
respond to the station if it wakes up due to the
TIM bit. Once the driver unblocks, we can set
the TIM bit.
Similarly, when the station just wakes up, we
need to wait until all other frames are flushed
before we can transmit frames to that station,
so the same applies here, we need to wait for
the driver to give the OK.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-11-06 11:35:50 +01:00
|
|
|
if (test_sta_flags(sta, WLAN_STA_PS_STA)) {
|
2008-11-26 15:02:58 +01:00
|
|
|
/*
|
|
|
|
* Ignore doze->wake transitions that are
|
|
|
|
* indicated by non-data frames, the standard
|
|
|
|
* is unclear here, but for example going to
|
|
|
|
* PS mode and then scanning would cause a
|
|
|
|
* doze->wake transition for the probe request,
|
|
|
|
* and that is clearly undesirable.
|
|
|
|
*/
|
|
|
|
if (ieee80211_is_data(hdr->frame_control) &&
|
|
|
|
!ieee80211_has_pm(hdr->frame_control))
|
2009-10-30 12:56:02 +01:00
|
|
|
ap_sta_ps_end(sta);
|
2008-11-26 15:02:58 +01:00
|
|
|
} else {
|
|
|
|
if (ieee80211_has_pm(hdr->frame_control))
|
|
|
|
ap_sta_ps_start(sta);
|
|
|
|
}
|
2007-07-27 15:43:22 +02:00
|
|
|
}
|
|
|
|
|
2009-10-30 12:55:03 +01:00
|
|
|
/*
|
|
|
|
* Drop (qos-)data::nullfunc frames silently, since they
|
|
|
|
* are used only to control station power saving mode.
|
|
|
|
*/
|
|
|
|
if (ieee80211_is_nullfunc(hdr->frame_control) ||
|
|
|
|
ieee80211_is_qos_nullfunc(hdr->frame_control)) {
|
2007-07-27 15:43:22 +02:00
|
|
|
I802_DEBUG_INC(rx->local->rx_handlers_drop_nullfunc);
|
2009-10-30 12:55:03 +01:00
|
|
|
/*
|
|
|
|
* Update counter and free packet here to avoid
|
|
|
|
* counting this as a dropped packed.
|
|
|
|
*/
|
2007-07-27 15:43:22 +02:00
|
|
|
sta->rx_packets++;
|
|
|
|
dev_kfree_skb(rx->skb);
|
2008-01-31 19:48:20 +01:00
|
|
|
return RX_QUEUED;
|
2007-07-27 15:43:22 +02:00
|
|
|
}
|
|
|
|
|
2008-01-31 19:48:20 +01:00
|
|
|
return RX_CONTINUE;
|
2007-07-27 15:43:22 +02:00
|
|
|
} /* ieee80211_rx_h_sta_process */
|
|
|
|
|
|
|
|
static inline struct ieee80211_fragment_entry *
|
|
|
|
ieee80211_reassemble_add(struct ieee80211_sub_if_data *sdata,
|
|
|
|
unsigned int frag, unsigned int seq, int rx_queue,
|
|
|
|
struct sk_buff **skb)
|
|
|
|
{
|
|
|
|
struct ieee80211_fragment_entry *entry;
|
|
|
|
int idx;
|
|
|
|
|
|
|
|
idx = sdata->fragment_next;
|
|
|
|
entry = &sdata->fragments[sdata->fragment_next++];
|
|
|
|
if (sdata->fragment_next >= IEEE80211_FRAGMENT_MAX)
|
|
|
|
sdata->fragment_next = 0;
|
|
|
|
|
|
|
|
if (!skb_queue_empty(&entry->skb_list)) {
|
2008-06-30 15:10:46 +02:00
|
|
|
#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
|
2007-07-27 15:43:22 +02:00
|
|
|
struct ieee80211_hdr *hdr =
|
|
|
|
(struct ieee80211_hdr *) entry->skb_list.next->data;
|
|
|
|
printk(KERN_DEBUG "%s: RX reassembly removed oldest "
|
|
|
|
"fragment entry (idx=%d age=%lu seq=%d last_frag=%d "
|
2008-10-27 23:56:10 +01:00
|
|
|
"addr1=%pM addr2=%pM\n",
|
2007-07-27 15:43:22 +02:00
|
|
|
sdata->dev->name, idx,
|
|
|
|
jiffies - entry->first_frag_time, entry->seq,
|
2008-10-27 23:56:10 +01:00
|
|
|
entry->last_frag, hdr->addr1, hdr->addr2);
|
2008-06-30 15:10:46 +02:00
|
|
|
#endif
|
2007-07-27 15:43:22 +02:00
|
|
|
__skb_queue_purge(&entry->skb_list);
|
|
|
|
}
|
|
|
|
|
|
|
|
__skb_queue_tail(&entry->skb_list, *skb); /* no need for locking */
|
|
|
|
*skb = NULL;
|
|
|
|
entry->first_frag_time = jiffies;
|
|
|
|
entry->seq = seq;
|
|
|
|
entry->rx_queue = rx_queue;
|
|
|
|
entry->last_frag = frag;
|
|
|
|
entry->ccmp = 0;
|
|
|
|
entry->extra_len = 0;
|
|
|
|
|
|
|
|
return entry;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline struct ieee80211_fragment_entry *
|
|
|
|
ieee80211_reassemble_find(struct ieee80211_sub_if_data *sdata,
|
2008-07-16 03:44:12 +02:00
|
|
|
unsigned int frag, unsigned int seq,
|
2007-07-27 15:43:22 +02:00
|
|
|
int rx_queue, struct ieee80211_hdr *hdr)
|
|
|
|
{
|
|
|
|
struct ieee80211_fragment_entry *entry;
|
|
|
|
int i, idx;
|
|
|
|
|
|
|
|
idx = sdata->fragment_next;
|
|
|
|
for (i = 0; i < IEEE80211_FRAGMENT_MAX; i++) {
|
|
|
|
struct ieee80211_hdr *f_hdr;
|
|
|
|
|
|
|
|
idx--;
|
|
|
|
if (idx < 0)
|
|
|
|
idx = IEEE80211_FRAGMENT_MAX - 1;
|
|
|
|
|
|
|
|
entry = &sdata->fragments[idx];
|
|
|
|
if (skb_queue_empty(&entry->skb_list) || entry->seq != seq ||
|
|
|
|
entry->rx_queue != rx_queue ||
|
|
|
|
entry->last_frag + 1 != frag)
|
|
|
|
continue;
|
|
|
|
|
2008-07-16 03:44:12 +02:00
|
|
|
f_hdr = (struct ieee80211_hdr *)entry->skb_list.next->data;
|
2007-07-27 15:43:22 +02:00
|
|
|
|
2008-07-16 03:44:12 +02:00
|
|
|
/*
|
|
|
|
* Check ftype and addresses are equal, else check next fragment
|
|
|
|
*/
|
|
|
|
if (((hdr->frame_control ^ f_hdr->frame_control) &
|
|
|
|
cpu_to_le16(IEEE80211_FCTL_FTYPE)) ||
|
2007-07-27 15:43:22 +02:00
|
|
|
compare_ether_addr(hdr->addr1, f_hdr->addr1) != 0 ||
|
|
|
|
compare_ether_addr(hdr->addr2, f_hdr->addr2) != 0)
|
|
|
|
continue;
|
|
|
|
|
2008-02-14 16:36:47 +01:00
|
|
|
if (time_after(jiffies, entry->first_frag_time + 2 * HZ)) {
|
2007-07-27 15:43:22 +02:00
|
|
|
__skb_queue_purge(&entry->skb_list);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
return entry;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2008-06-30 15:10:45 +02:00
|
|
|
static ieee80211_rx_result debug_noinline
|
2008-02-25 16:27:43 +01:00
|
|
|
ieee80211_rx_h_defragment(struct ieee80211_rx_data *rx)
|
2007-07-27 15:43:22 +02:00
|
|
|
{
|
|
|
|
struct ieee80211_hdr *hdr;
|
|
|
|
u16 sc;
|
2008-07-16 03:44:13 +02:00
|
|
|
__le16 fc;
|
2007-07-27 15:43:22 +02:00
|
|
|
unsigned int frag, seq;
|
|
|
|
struct ieee80211_fragment_entry *entry;
|
|
|
|
struct sk_buff *skb;
|
|
|
|
|
2008-07-16 03:44:12 +02:00
|
|
|
hdr = (struct ieee80211_hdr *)rx->skb->data;
|
2008-07-16 03:44:13 +02:00
|
|
|
fc = hdr->frame_control;
|
2007-07-27 15:43:22 +02:00
|
|
|
sc = le16_to_cpu(hdr->seq_ctrl);
|
|
|
|
frag = sc & IEEE80211_SCTL_FRAG;
|
|
|
|
|
2008-07-16 03:44:13 +02:00
|
|
|
if (likely((!ieee80211_has_morefrags(fc) && frag == 0) ||
|
2007-07-27 15:43:22 +02:00
|
|
|
(rx->skb)->len < 24 ||
|
|
|
|
is_multicast_ether_addr(hdr->addr1))) {
|
|
|
|
/* not fragmented */
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
I802_DEBUG_INC(rx->local->rx_handlers_fragments);
|
|
|
|
|
|
|
|
seq = (sc & IEEE80211_SCTL_SEQ) >> 4;
|
|
|
|
|
|
|
|
if (frag == 0) {
|
|
|
|
/* This is the first fragment of a new frame. */
|
|
|
|
entry = ieee80211_reassemble_add(rx->sdata, frag, seq,
|
2008-02-25 16:27:43 +01:00
|
|
|
rx->queue, &(rx->skb));
|
2007-08-28 23:01:54 +02:00
|
|
|
if (rx->key && rx->key->conf.alg == ALG_CCMP &&
|
2008-07-16 03:44:13 +02:00
|
|
|
ieee80211_has_protected(fc)) {
|
2007-07-27 15:43:22 +02:00
|
|
|
/* Store CCMP PN so that we can verify that the next
|
|
|
|
* fragment has a sequential PN value. */
|
|
|
|
entry->ccmp = 1;
|
|
|
|
memcpy(entry->last_pn,
|
2008-02-25 16:27:43 +01:00
|
|
|
rx->key->u.ccmp.rx_pn[rx->queue],
|
2007-07-27 15:43:22 +02:00
|
|
|
CCMP_PN_LEN);
|
|
|
|
}
|
2008-01-31 19:48:20 +01:00
|
|
|
return RX_QUEUED;
|
2007-07-27 15:43:22 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* This is a fragment for a frame that should already be pending in
|
|
|
|
* fragment cache. Add this fragment to the end of the pending entry.
|
|
|
|
*/
|
2008-07-16 03:44:12 +02:00
|
|
|
entry = ieee80211_reassemble_find(rx->sdata, frag, seq, rx->queue, hdr);
|
2007-07-27 15:43:22 +02:00
|
|
|
if (!entry) {
|
|
|
|
I802_DEBUG_INC(rx->local->rx_handlers_drop_defrag);
|
2008-01-31 19:48:21 +01:00
|
|
|
return RX_DROP_MONITOR;
|
2007-07-27 15:43:22 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Verify that MPDUs within one MSDU have sequential PN values.
|
|
|
|
* (IEEE 802.11i, 8.3.3.4.5) */
|
|
|
|
if (entry->ccmp) {
|
|
|
|
int i;
|
|
|
|
u8 pn[CCMP_PN_LEN], *rpn;
|
2007-08-28 23:01:54 +02:00
|
|
|
if (!rx->key || rx->key->conf.alg != ALG_CCMP)
|
2008-01-31 19:48:21 +01:00
|
|
|
return RX_DROP_UNUSABLE;
|
2007-07-27 15:43:22 +02:00
|
|
|
memcpy(pn, entry->last_pn, CCMP_PN_LEN);
|
|
|
|
for (i = CCMP_PN_LEN - 1; i >= 0; i--) {
|
|
|
|
pn[i]++;
|
|
|
|
if (pn[i])
|
|
|
|
break;
|
|
|
|
}
|
2008-02-25 16:27:43 +01:00
|
|
|
rpn = rx->key->u.ccmp.rx_pn[rx->queue];
|
2008-06-30 15:10:46 +02:00
|
|
|
if (memcmp(pn, rpn, CCMP_PN_LEN))
|
2008-01-31 19:48:21 +01:00
|
|
|
return RX_DROP_UNUSABLE;
|
2007-07-27 15:43:22 +02:00
|
|
|
memcpy(entry->last_pn, pn, CCMP_PN_LEN);
|
|
|
|
}
|
|
|
|
|
2008-07-16 03:44:13 +02:00
|
|
|
skb_pull(rx->skb, ieee80211_hdrlen(fc));
|
2007-07-27 15:43:22 +02:00
|
|
|
__skb_queue_tail(&entry->skb_list, rx->skb);
|
|
|
|
entry->last_frag = frag;
|
|
|
|
entry->extra_len += rx->skb->len;
|
2008-07-16 03:44:13 +02:00
|
|
|
if (ieee80211_has_morefrags(fc)) {
|
2007-07-27 15:43:22 +02:00
|
|
|
rx->skb = NULL;
|
2008-01-31 19:48:20 +01:00
|
|
|
return RX_QUEUED;
|
2007-07-27 15:43:22 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
rx->skb = __skb_dequeue(&entry->skb_list);
|
|
|
|
if (skb_tailroom(rx->skb) < entry->extra_len) {
|
|
|
|
I802_DEBUG_INC(rx->local->rx_expand_skb_head2);
|
|
|
|
if (unlikely(pskb_expand_head(rx->skb, 0, entry->extra_len,
|
|
|
|
GFP_ATOMIC))) {
|
|
|
|
I802_DEBUG_INC(rx->local->rx_handlers_drop_defrag);
|
|
|
|
__skb_queue_purge(&entry->skb_list);
|
2008-01-31 19:48:21 +01:00
|
|
|
return RX_DROP_UNUSABLE;
|
2007-07-27 15:43:22 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
while ((skb = __skb_dequeue(&entry->skb_list))) {
|
|
|
|
memcpy(skb_put(rx->skb, skb->len), skb->data, skb->len);
|
|
|
|
dev_kfree_skb(skb);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Complete frame has been reassembled - process it now */
|
2008-02-25 16:27:43 +01:00
|
|
|
rx->flags |= IEEE80211_RX_FRAGMENTED;
|
2007-07-27 15:43:22 +02:00
|
|
|
|
|
|
|
out:
|
|
|
|
if (rx->sta)
|
|
|
|
rx->sta->rx_packets++;
|
|
|
|
if (is_multicast_ether_addr(hdr->addr1))
|
|
|
|
rx->local->dot11MulticastReceivedFrameCount++;
|
|
|
|
else
|
|
|
|
ieee80211_led_rx(rx->local);
|
2008-01-31 19:48:20 +01:00
|
|
|
return RX_CONTINUE;
|
2007-07-27 15:43:22 +02:00
|
|
|
}
|
|
|
|
|
2008-06-30 15:10:45 +02:00
|
|
|
static ieee80211_rx_result debug_noinline
|
2008-02-25 16:27:43 +01:00
|
|
|
ieee80211_rx_h_ps_poll(struct ieee80211_rx_data *rx)
|
2007-07-27 15:43:22 +02:00
|
|
|
{
|
mac80211: async station powersave handling
Some devices require that all frames to a station
are flushed when that station goes into powersave
mode before being able to send frames to that
station again when it wakes up or polls -- all in
order to avoid reordering and too many or too few
frames being sent to the station when it polls.
Normally, this is the case unless the station
goes to sleep and wakes up very quickly again.
But in that case, frames for it may be pending
on the hardware queues, and thus races could
happen in the case of multiple hardware queues
used for QoS/WMM. Normally this isn't a problem,
but with the iwlwifi mechanism we need to make
sure the race doesn't happen.
This makes mac80211 able to cope with the race
with driver help by a new WLAN_STA_PS_DRIVER
per-station flag that can be controlled by the
driver and tells mac80211 whether it can transmit
frames or not. This flag must be set according to
very specific rules outlined in the documentation
for the function that controls it.
When we buffer new frames for the station, we
normally set the TIM bit right away, but while
the driver has blocked transmission to that sta
we need to avoid that as well since we cannot
respond to the station if it wakes up due to the
TIM bit. Once the driver unblocks, we can set
the TIM bit.
Similarly, when the station just wakes up, we
need to wait until all other frames are flushed
before we can transmit frames to that station,
so the same applies here, we need to wait for
the driver to give the OK.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-11-06 11:35:50 +01:00
|
|
|
struct ieee80211_sub_if_data *sdata = rx->sdata;
|
2008-07-16 03:44:13 +02:00
|
|
|
__le16 fc = ((struct ieee80211_hdr *)rx->skb->data)->frame_control;
|
2007-07-27 15:43:22 +02:00
|
|
|
|
2008-07-16 03:44:13 +02:00
|
|
|
if (likely(!rx->sta || !ieee80211_is_pspoll(fc) ||
|
2008-02-25 16:27:43 +01:00
|
|
|
!(rx->flags & IEEE80211_RX_RA_MATCH)))
|
2008-01-31 19:48:20 +01:00
|
|
|
return RX_CONTINUE;
|
2007-07-27 15:43:22 +02:00
|
|
|
|
2008-09-11 00:01:58 +02:00
|
|
|
if ((sdata->vif.type != NL80211_IFTYPE_AP) &&
|
|
|
|
(sdata->vif.type != NL80211_IFTYPE_AP_VLAN))
|
2008-01-31 19:48:21 +01:00
|
|
|
return RX_DROP_UNUSABLE;
|
2007-12-18 16:23:53 +01:00
|
|
|
|
mac80211: async station powersave handling
Some devices require that all frames to a station
are flushed when that station goes into powersave
mode before being able to send frames to that
station again when it wakes up or polls -- all in
order to avoid reordering and too many or too few
frames being sent to the station when it polls.
Normally, this is the case unless the station
goes to sleep and wakes up very quickly again.
But in that case, frames for it may be pending
on the hardware queues, and thus races could
happen in the case of multiple hardware queues
used for QoS/WMM. Normally this isn't a problem,
but with the iwlwifi mechanism we need to make
sure the race doesn't happen.
This makes mac80211 able to cope with the race
with driver help by a new WLAN_STA_PS_DRIVER
per-station flag that can be controlled by the
driver and tells mac80211 whether it can transmit
frames or not. This flag must be set according to
very specific rules outlined in the documentation
for the function that controls it.
When we buffer new frames for the station, we
normally set the TIM bit right away, but while
the driver has blocked transmission to that sta
we need to avoid that as well since we cannot
respond to the station if it wakes up due to the
TIM bit. Once the driver unblocks, we can set
the TIM bit.
Similarly, when the station just wakes up, we
need to wait until all other frames are flushed
before we can transmit frames to that station,
so the same applies here, we need to wait for
the driver to give the OK.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-11-06 11:35:50 +01:00
|
|
|
if (!test_sta_flags(rx->sta, WLAN_STA_PS_DRIVER))
|
|
|
|
ieee80211_sta_ps_deliver_poll_response(rx->sta);
|
|
|
|
else
|
|
|
|
set_sta_flags(rx->sta, WLAN_STA_PSPOLL);
|
2007-07-27 15:43:22 +02:00
|
|
|
|
2008-01-31 19:48:20 +01:00
|
|
|
/* Free PS Poll skb here instead of returning RX_DROP that would
|
2007-07-27 15:43:22 +02:00
|
|
|
* count as an dropped frame. */
|
|
|
|
dev_kfree_skb(rx->skb);
|
|
|
|
|
2008-01-31 19:48:20 +01:00
|
|
|
return RX_QUEUED;
|
2007-07-27 15:43:22 +02:00
|
|
|
}
|
|
|
|
|
2008-06-30 15:10:45 +02:00
|
|
|
static ieee80211_rx_result debug_noinline
|
2008-02-25 16:27:43 +01:00
|
|
|
ieee80211_rx_h_remove_qos_control(struct ieee80211_rx_data *rx)
|
2007-07-27 15:43:22 +02:00
|
|
|
{
|
|
|
|
u8 *data = rx->skb->data;
|
2008-07-02 20:05:34 +02:00
|
|
|
struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)data;
|
2007-07-27 15:43:22 +02:00
|
|
|
|
2008-07-02 20:05:34 +02:00
|
|
|
if (!ieee80211_is_data_qos(hdr->frame_control))
|
2008-01-31 19:48:20 +01:00
|
|
|
return RX_CONTINUE;
|
2007-07-27 15:43:22 +02:00
|
|
|
|
|
|
|
/* remove the qos control field, update frame type and meta-data */
|
2008-07-02 20:05:34 +02:00
|
|
|
memmove(data + IEEE80211_QOS_CTL_LEN, data,
|
|
|
|
ieee80211_hdrlen(hdr->frame_control) - IEEE80211_QOS_CTL_LEN);
|
|
|
|
hdr = (struct ieee80211_hdr *)skb_pull(rx->skb, IEEE80211_QOS_CTL_LEN);
|
2007-07-27 15:43:22 +02:00
|
|
|
/* change frame type to non QOS */
|
2008-07-02 20:05:34 +02:00
|
|
|
hdr->frame_control &= ~cpu_to_le16(IEEE80211_STYPE_QOS_DATA);
|
2007-07-27 15:43:22 +02:00
|
|
|
|
2008-01-31 19:48:20 +01:00
|
|
|
return RX_CONTINUE;
|
2007-07-27 15:43:22 +02:00
|
|
|
}
|
|
|
|
|
2007-11-22 18:49:12 +01:00
|
|
|
static int
|
2008-02-25 16:27:43 +01:00
|
|
|
ieee80211_802_1x_port_control(struct ieee80211_rx_data *rx)
|
2007-07-27 15:43:22 +02:00
|
|
|
{
|
2008-05-03 01:02:02 +02:00
|
|
|
if (unlikely(!rx->sta ||
|
2008-06-30 15:10:46 +02:00
|
|
|
!test_sta_flags(rx->sta, WLAN_STA_AUTHORIZED)))
|
2007-11-22 18:49:12 +01:00
|
|
|
return -EACCES;
|
2007-07-27 15:43:22 +02:00
|
|
|
|
2007-11-22 18:49:12 +01:00
|
|
|
return 0;
|
2007-07-27 15:43:22 +02:00
|
|
|
}
|
|
|
|
|
2007-11-22 18:49:12 +01:00
|
|
|
static int
|
2008-07-16 03:44:13 +02:00
|
|
|
ieee80211_drop_unencrypted(struct ieee80211_rx_data *rx, __le16 fc)
|
2007-07-27 15:43:22 +02:00
|
|
|
{
|
2009-11-16 13:58:20 +01:00
|
|
|
struct sk_buff *skb = rx->skb;
|
|
|
|
struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
|
|
|
|
|
2007-08-28 23:01:53 +02:00
|
|
|
/*
|
2007-09-14 17:10:25 +02:00
|
|
|
* Pass through unencrypted frames if the hardware has
|
|
|
|
* decrypted them already.
|
2007-08-28 23:01:53 +02:00
|
|
|
*/
|
2009-11-16 13:58:20 +01:00
|
|
|
if (status->flag & RX_FLAG_DECRYPTED)
|
2007-11-22 18:49:12 +01:00
|
|
|
return 0;
|
2007-07-27 15:43:22 +02:00
|
|
|
|
|
|
|
/* Drop unencrypted frames if key is set. */
|
2008-07-16 03:44:13 +02:00
|
|
|
if (unlikely(!ieee80211_has_protected(fc) &&
|
|
|
|
!ieee80211_is_nullfunc(fc) &&
|
2009-05-08 11:36:03 +02:00
|
|
|
ieee80211_is_data(fc) &&
|
2008-04-13 10:12:47 +02:00
|
|
|
(rx->key || rx->sdata->drop_unencrypted)))
|
2007-11-22 18:49:12 +01:00
|
|
|
return -EACCES;
|
2009-05-08 11:36:03 +02:00
|
|
|
if (rx->sta && test_sta_flags(rx->sta, WLAN_STA_MFP)) {
|
|
|
|
if (unlikely(ieee80211_is_unicast_robust_mgmt_frame(rx->skb) &&
|
|
|
|
rx->key))
|
|
|
|
return -EACCES;
|
|
|
|
/* BIP does not use Protected field, so need to check MMIE */
|
|
|
|
if (unlikely(ieee80211_is_multicast_robust_mgmt_frame(rx->skb)
|
|
|
|
&& ieee80211_get_mmie_keyidx(rx->skb) < 0 &&
|
|
|
|
rx->key))
|
|
|
|
return -EACCES;
|
|
|
|
/*
|
|
|
|
* When using MFP, Action frames are not allowed prior to
|
|
|
|
* having configured keys.
|
|
|
|
*/
|
|
|
|
if (unlikely(ieee80211_is_action(fc) && !rx->key &&
|
|
|
|
ieee80211_is_robust_mgmt_frame(
|
|
|
|
(struct ieee80211_hdr *) rx->skb->data)))
|
|
|
|
return -EACCES;
|
|
|
|
}
|
2008-04-13 10:12:47 +02:00
|
|
|
|
2007-11-22 18:49:12 +01:00
|
|
|
return 0;
|
2007-07-27 15:43:22 +02:00
|
|
|
}
|
|
|
|
|
2007-11-22 18:49:12 +01:00
|
|
|
static int
|
2009-05-21 15:47:03 +02:00
|
|
|
__ieee80211_data_to_8023(struct ieee80211_rx_data *rx)
|
2007-07-27 15:43:22 +02:00
|
|
|
{
|
2009-11-16 13:58:20 +01:00
|
|
|
struct ieee80211_sub_if_data *sdata = rx->sdata;
|
|
|
|
struct net_device *dev = sdata->dev;
|
2009-11-10 20:10:05 +01:00
|
|
|
struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
|
|
|
|
|
2009-11-19 11:55:19 +01:00
|
|
|
if (ieee80211_has_a4(hdr->frame_control) &&
|
|
|
|
sdata->vif.type == NL80211_IFTYPE_AP_VLAN && !sdata->u.vlan.sta)
|
2009-11-10 20:10:05 +01:00
|
|
|
return -1;
|
2009-11-19 11:55:19 +01:00
|
|
|
|
|
|
|
if (is_multicast_ether_addr(hdr->addr1) &&
|
|
|
|
((sdata->vif.type == NL80211_IFTYPE_AP_VLAN && sdata->u.vlan.sta) ||
|
|
|
|
(sdata->vif.type == NL80211_IFTYPE_STATION && sdata->u.mgd.use_4addr)))
|
2009-11-10 20:10:05 +01:00
|
|
|
return -1;
|
2007-07-27 15:43:22 +02:00
|
|
|
|
2009-05-21 15:47:03 +02:00
|
|
|
return ieee80211_data_to_8023(rx->skb, dev->dev_addr, sdata->vif.type);
|
2007-11-22 18:49:12 +01:00
|
|
|
}
|
2007-07-27 15:43:22 +02:00
|
|
|
|
2007-12-19 01:31:22 +01:00
|
|
|
/*
|
|
|
|
* requires that rx->skb is a frame with ethernet header
|
|
|
|
*/
|
2008-07-16 03:44:13 +02:00
|
|
|
static bool ieee80211_frame_allowed(struct ieee80211_rx_data *rx, __le16 fc)
|
2007-12-19 01:31:22 +01:00
|
|
|
{
|
2008-05-28 19:45:32 +02:00
|
|
|
static const u8 pae_group_addr[ETH_ALEN] __aligned(2)
|
2007-12-19 01:31:22 +01:00
|
|
|
= { 0x01, 0x80, 0xC2, 0x00, 0x00, 0x03 };
|
|
|
|
struct ethhdr *ehdr = (struct ethhdr *) rx->skb->data;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Allow EAPOL frames to us/the PAE group address regardless
|
|
|
|
* of whether the frame was encrypted or not.
|
|
|
|
*/
|
|
|
|
if (ehdr->h_proto == htons(ETH_P_PAE) &&
|
2009-11-16 13:58:20 +01:00
|
|
|
(compare_ether_addr(ehdr->h_dest, rx->sdata->dev->dev_addr) == 0 ||
|
2007-12-19 01:31:22 +01:00
|
|
|
compare_ether_addr(ehdr->h_dest, pae_group_addr) == 0))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
if (ieee80211_802_1x_port_control(rx) ||
|
2008-07-16 03:44:13 +02:00
|
|
|
ieee80211_drop_unencrypted(rx, fc))
|
2007-12-19 01:31:22 +01:00
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* requires that rx->skb is a frame with ethernet header
|
|
|
|
*/
|
2007-11-22 18:49:12 +01:00
|
|
|
static void
|
2008-02-25 16:27:43 +01:00
|
|
|
ieee80211_deliver_skb(struct ieee80211_rx_data *rx)
|
2007-11-22 18:49:12 +01:00
|
|
|
{
|
2009-11-16 13:58:20 +01:00
|
|
|
struct ieee80211_sub_if_data *sdata = rx->sdata;
|
|
|
|
struct net_device *dev = sdata->dev;
|
2007-11-22 18:49:12 +01:00
|
|
|
struct ieee80211_local *local = rx->local;
|
|
|
|
struct sk_buff *skb, *xmit_skb;
|
2007-12-19 01:31:22 +01:00
|
|
|
struct ethhdr *ehdr = (struct ethhdr *) rx->skb->data;
|
|
|
|
struct sta_info *dsta;
|
2007-07-27 15:43:22 +02:00
|
|
|
|
2007-11-22 18:49:12 +01:00
|
|
|
skb = rx->skb;
|
|
|
|
xmit_skb = NULL;
|
2007-07-27 15:43:22 +02:00
|
|
|
|
2008-09-11 00:01:58 +02:00
|
|
|
if ((sdata->vif.type == NL80211_IFTYPE_AP ||
|
|
|
|
sdata->vif.type == NL80211_IFTYPE_AP_VLAN) &&
|
2008-09-11 00:01:54 +02:00
|
|
|
!(sdata->flags & IEEE80211_SDATA_DONT_BRIDGE_PACKETS) &&
|
2009-11-19 11:55:19 +01:00
|
|
|
(rx->flags & IEEE80211_RX_RA_MATCH) &&
|
|
|
|
(sdata->vif.type != NL80211_IFTYPE_AP_VLAN || !sdata->u.vlan.sta)) {
|
2007-12-19 01:31:22 +01:00
|
|
|
if (is_multicast_ether_addr(ehdr->h_dest)) {
|
|
|
|
/*
|
|
|
|
* send multicast frames both to higher layers in
|
|
|
|
* local net stack and back to the wireless medium
|
|
|
|
*/
|
2007-11-22 18:49:12 +01:00
|
|
|
xmit_skb = skb_copy(skb, GFP_ATOMIC);
|
|
|
|
if (!xmit_skb && net_ratelimit())
|
2007-07-27 15:43:22 +02:00
|
|
|
printk(KERN_DEBUG "%s: failed to clone "
|
|
|
|
"multicast frame\n", dev->name);
|
|
|
|
} else {
|
|
|
|
dsta = sta_info_get(local, skb->data);
|
2008-02-25 16:27:46 +01:00
|
|
|
if (dsta && dsta->sdata->dev == dev) {
|
2007-12-19 01:31:22 +01:00
|
|
|
/*
|
|
|
|
* The destination station is associated to
|
|
|
|
* this AP (in this VLAN), so send the frame
|
|
|
|
* directly to it and do not pass it to local
|
|
|
|
* net stack.
|
2007-07-27 15:43:22 +02:00
|
|
|
*/
|
2007-11-22 18:49:12 +01:00
|
|
|
xmit_skb = skb;
|
2007-07-27 15:43:22 +02:00
|
|
|
skb = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (skb) {
|
2009-01-07 00:26:10 +01:00
|
|
|
int align __maybe_unused;
|
|
|
|
|
|
|
|
#if defined(CONFIG_MAC80211_DEBUG_PACKET_ALIGNMENT) || !defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS)
|
|
|
|
/*
|
|
|
|
* 'align' will only take the values 0 or 2 here
|
|
|
|
* since all frames are required to be aligned
|
|
|
|
* to 2-byte boundaries when being passed to
|
|
|
|
* mac80211. That also explains the __skb_push()
|
|
|
|
* below.
|
|
|
|
*/
|
2009-06-04 22:16:18 +02:00
|
|
|
align = ((unsigned long)(skb->data + sizeof(struct ethhdr))) & 3;
|
2009-01-07 00:26:10 +01:00
|
|
|
if (align) {
|
|
|
|
if (WARN_ON(skb_headroom(skb) < 3)) {
|
|
|
|
dev_kfree_skb(skb);
|
|
|
|
skb = NULL;
|
|
|
|
} else {
|
|
|
|
u8 *data = skb->data;
|
2009-10-28 21:13:52 +01:00
|
|
|
size_t len = skb_headlen(skb);
|
|
|
|
skb->data -= align;
|
|
|
|
memmove(skb->data, data, len);
|
|
|
|
skb_set_tail_pointer(skb, len);
|
2009-01-07 00:26:10 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if (skb) {
|
|
|
|
/* deliver to local stack */
|
|
|
|
skb->protocol = eth_type_trans(skb, dev);
|
|
|
|
memset(skb->cb, 0, sizeof(skb->cb));
|
|
|
|
netif_rx(skb);
|
|
|
|
}
|
2007-07-27 15:43:22 +02:00
|
|
|
}
|
|
|
|
|
2007-11-22 18:49:12 +01:00
|
|
|
if (xmit_skb) {
|
2007-07-27 15:43:22 +02:00
|
|
|
/* send to wireless media */
|
2007-12-11 19:54:23 +01:00
|
|
|
xmit_skb->protocol = htons(ETH_P_802_3);
|
2007-12-19 01:31:22 +01:00
|
|
|
skb_reset_network_header(xmit_skb);
|
|
|
|
skb_reset_mac_header(xmit_skb);
|
2007-11-22 18:49:12 +01:00
|
|
|
dev_queue_xmit(xmit_skb);
|
2007-07-27 15:43:22 +02:00
|
|
|
}
|
2007-11-22 18:49:12 +01:00
|
|
|
}
|
|
|
|
|
2008-06-30 15:10:45 +02:00
|
|
|
static ieee80211_rx_result debug_noinline
|
2008-02-25 16:27:43 +01:00
|
|
|
ieee80211_rx_h_amsdu(struct ieee80211_rx_data *rx)
|
2007-11-26 15:14:33 +01:00
|
|
|
{
|
2009-11-16 13:58:20 +01:00
|
|
|
struct net_device *dev = rx->sdata->dev;
|
2007-11-26 15:14:33 +01:00
|
|
|
struct ieee80211_local *local = rx->local;
|
2008-07-16 03:44:13 +02:00
|
|
|
u16 ethertype;
|
2007-11-26 15:14:33 +01:00
|
|
|
u8 *payload;
|
|
|
|
struct sk_buff *skb = rx->skb, *frame = NULL;
|
2008-07-16 03:44:13 +02:00
|
|
|
struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
|
|
|
|
__le16 fc = hdr->frame_control;
|
2007-11-26 15:14:33 +01:00
|
|
|
const struct ethhdr *eth;
|
|
|
|
int remaining, err;
|
|
|
|
u8 dst[ETH_ALEN];
|
|
|
|
u8 src[ETH_ALEN];
|
|
|
|
|
2008-07-16 03:44:13 +02:00
|
|
|
if (unlikely(!ieee80211_is_data(fc)))
|
2008-01-31 19:48:20 +01:00
|
|
|
return RX_CONTINUE;
|
2007-11-26 15:14:33 +01:00
|
|
|
|
2008-07-16 03:44:13 +02:00
|
|
|
if (unlikely(!ieee80211_is_data_present(fc)))
|
2008-01-31 19:48:21 +01:00
|
|
|
return RX_DROP_MONITOR;
|
2007-11-26 15:14:33 +01:00
|
|
|
|
2008-02-25 16:27:43 +01:00
|
|
|
if (!(rx->flags & IEEE80211_RX_AMSDU))
|
2008-01-31 19:48:20 +01:00
|
|
|
return RX_CONTINUE;
|
2007-11-26 15:14:33 +01:00
|
|
|
|
2009-05-21 15:47:03 +02:00
|
|
|
err = __ieee80211_data_to_8023(rx);
|
2007-11-26 15:14:33 +01:00
|
|
|
if (unlikely(err))
|
2008-01-31 19:48:21 +01:00
|
|
|
return RX_DROP_UNUSABLE;
|
2007-11-26 15:14:33 +01:00
|
|
|
|
|
|
|
skb->dev = dev;
|
|
|
|
|
|
|
|
dev->stats.rx_packets++;
|
|
|
|
dev->stats.rx_bytes += skb->len;
|
|
|
|
|
|
|
|
/* skip the wrapping header */
|
|
|
|
eth = (struct ethhdr *) skb_pull(skb, sizeof(struct ethhdr));
|
|
|
|
if (!eth)
|
2008-01-31 19:48:21 +01:00
|
|
|
return RX_DROP_UNUSABLE;
|
2007-11-26 15:14:33 +01:00
|
|
|
|
|
|
|
while (skb != frame) {
|
|
|
|
u8 padding;
|
|
|
|
__be16 len = eth->h_proto;
|
|
|
|
unsigned int subframe_len = sizeof(struct ethhdr) + ntohs(len);
|
|
|
|
|
|
|
|
remaining = skb->len;
|
|
|
|
memcpy(dst, eth->h_dest, ETH_ALEN);
|
|
|
|
memcpy(src, eth->h_source, ETH_ALEN);
|
|
|
|
|
|
|
|
padding = ((4 - subframe_len) & 0x3);
|
|
|
|
/* the last MSDU has no padding */
|
2008-06-30 15:10:46 +02:00
|
|
|
if (subframe_len > remaining)
|
2008-01-31 19:48:21 +01:00
|
|
|
return RX_DROP_UNUSABLE;
|
2007-11-26 15:14:33 +01:00
|
|
|
|
|
|
|
skb_pull(skb, sizeof(struct ethhdr));
|
|
|
|
/* if last subframe reuse skb */
|
|
|
|
if (remaining <= subframe_len + padding)
|
|
|
|
frame = skb;
|
|
|
|
else {
|
2009-01-07 00:26:10 +01:00
|
|
|
/*
|
|
|
|
* Allocate and reserve two bytes more for payload
|
|
|
|
* alignment since sizeof(struct ethhdr) is 14.
|
|
|
|
*/
|
|
|
|
frame = dev_alloc_skb(
|
|
|
|
ALIGN(local->hw.extra_tx_headroom, 4) +
|
|
|
|
subframe_len + 2);
|
2007-11-26 15:14:33 +01:00
|
|
|
|
|
|
|
if (frame == NULL)
|
2008-01-31 19:48:21 +01:00
|
|
|
return RX_DROP_UNUSABLE;
|
2007-11-26 15:14:33 +01:00
|
|
|
|
2009-01-07 00:26:10 +01:00
|
|
|
skb_reserve(frame,
|
|
|
|
ALIGN(local->hw.extra_tx_headroom, 4) +
|
|
|
|
sizeof(struct ethhdr) + 2);
|
2007-11-26 15:14:33 +01:00
|
|
|
memcpy(skb_put(frame, ntohs(len)), skb->data,
|
|
|
|
ntohs(len));
|
|
|
|
|
|
|
|
eth = (struct ethhdr *) skb_pull(skb, ntohs(len) +
|
|
|
|
padding);
|
|
|
|
if (!eth) {
|
|
|
|
dev_kfree_skb(frame);
|
2008-01-31 19:48:21 +01:00
|
|
|
return RX_DROP_UNUSABLE;
|
2007-11-26 15:14:33 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-12-19 01:31:22 +01:00
|
|
|
skb_reset_network_header(frame);
|
2007-11-26 15:14:33 +01:00
|
|
|
frame->dev = dev;
|
|
|
|
frame->priority = skb->priority;
|
|
|
|
rx->skb = frame;
|
|
|
|
|
|
|
|
payload = frame->data;
|
|
|
|
ethertype = (payload[6] << 8) | payload[7];
|
|
|
|
|
|
|
|
if (likely((compare_ether_addr(payload, rfc1042_header) == 0 &&
|
2007-12-19 01:31:22 +01:00
|
|
|
ethertype != ETH_P_AARP && ethertype != ETH_P_IPX) ||
|
|
|
|
compare_ether_addr(payload,
|
|
|
|
bridge_tunnel_header) == 0)) {
|
2007-11-26 15:14:33 +01:00
|
|
|
/* remove RFC1042 or Bridge-Tunnel
|
|
|
|
* encapsulation and replace EtherType */
|
|
|
|
skb_pull(frame, 6);
|
|
|
|
memcpy(skb_push(frame, ETH_ALEN), src, ETH_ALEN);
|
|
|
|
memcpy(skb_push(frame, ETH_ALEN), dst, ETH_ALEN);
|
|
|
|
} else {
|
2007-12-19 01:31:22 +01:00
|
|
|
memcpy(skb_push(frame, sizeof(__be16)),
|
|
|
|
&len, sizeof(__be16));
|
2007-11-26 15:14:33 +01:00
|
|
|
memcpy(skb_push(frame, ETH_ALEN), src, ETH_ALEN);
|
|
|
|
memcpy(skb_push(frame, ETH_ALEN), dst, ETH_ALEN);
|
|
|
|
}
|
|
|
|
|
2008-07-16 03:44:13 +02:00
|
|
|
if (!ieee80211_frame_allowed(rx, fc)) {
|
2007-12-19 01:31:22 +01:00
|
|
|
if (skb == frame) /* last frame */
|
2008-01-31 19:48:21 +01:00
|
|
|
return RX_DROP_UNUSABLE;
|
2007-12-19 01:31:22 +01:00
|
|
|
dev_kfree_skb(frame);
|
|
|
|
continue;
|
|
|
|
}
|
2007-11-26 15:14:33 +01:00
|
|
|
|
|
|
|
ieee80211_deliver_skb(rx);
|
|
|
|
}
|
|
|
|
|
2008-01-31 19:48:20 +01:00
|
|
|
return RX_QUEUED;
|
2007-11-26 15:14:33 +01:00
|
|
|
}
|
|
|
|
|
2008-10-13 08:51:38 +02:00
|
|
|
#ifdef CONFIG_MAC80211_MESH
|
2008-09-27 17:29:12 +02:00
|
|
|
static ieee80211_rx_result
|
2008-08-05 19:34:52 +02:00
|
|
|
ieee80211_rx_h_mesh_fwding(struct ieee80211_rx_data *rx)
|
|
|
|
{
|
|
|
|
struct ieee80211_hdr *hdr;
|
|
|
|
struct ieee80211s_hdr *mesh_hdr;
|
|
|
|
unsigned int hdrlen;
|
|
|
|
struct sk_buff *skb = rx->skb, *fwd_skb;
|
2009-06-17 17:43:56 +02:00
|
|
|
struct ieee80211_local *local = rx->local;
|
2009-11-16 13:58:20 +01:00
|
|
|
struct ieee80211_sub_if_data *sdata = rx->sdata;
|
2008-08-05 19:34:52 +02:00
|
|
|
|
|
|
|
hdr = (struct ieee80211_hdr *) skb->data;
|
|
|
|
hdrlen = ieee80211_hdrlen(hdr->frame_control);
|
|
|
|
mesh_hdr = (struct ieee80211s_hdr *) (skb->data + hdrlen);
|
|
|
|
|
|
|
|
if (!ieee80211_is_data(hdr->frame_control))
|
|
|
|
return RX_CONTINUE;
|
|
|
|
|
|
|
|
if (!mesh_hdr->ttl)
|
|
|
|
/* illegal frame */
|
|
|
|
return RX_DROP_MONITOR;
|
|
|
|
|
2009-10-16 03:10:51 +02:00
|
|
|
if (mesh_hdr->flags & MESH_FLAGS_AE) {
|
2008-09-22 07:30:32 +02:00
|
|
|
struct mesh_path *mppath;
|
2009-10-16 03:10:51 +02:00
|
|
|
char *proxied_addr;
|
|
|
|
char *mpp_addr;
|
|
|
|
|
|
|
|
if (is_multicast_ether_addr(hdr->addr1)) {
|
|
|
|
mpp_addr = hdr->addr3;
|
|
|
|
proxied_addr = mesh_hdr->eaddr1;
|
|
|
|
} else {
|
|
|
|
mpp_addr = hdr->addr4;
|
|
|
|
proxied_addr = mesh_hdr->eaddr2;
|
|
|
|
}
|
2008-09-22 07:30:32 +02:00
|
|
|
|
|
|
|
rcu_read_lock();
|
2009-10-16 03:10:51 +02:00
|
|
|
mppath = mpp_path_lookup(proxied_addr, sdata);
|
2008-09-22 07:30:32 +02:00
|
|
|
if (!mppath) {
|
2009-10-16 03:10:51 +02:00
|
|
|
mpp_path_add(proxied_addr, mpp_addr, sdata);
|
2008-09-22 07:30:32 +02:00
|
|
|
} else {
|
|
|
|
spin_lock_bh(&mppath->state_lock);
|
|
|
|
mppath->exp_time = jiffies;
|
2009-10-16 03:10:51 +02:00
|
|
|
if (compare_ether_addr(mppath->mpp, mpp_addr) != 0)
|
|
|
|
memcpy(mppath->mpp, mpp_addr, ETH_ALEN);
|
2008-09-22 07:30:32 +02:00
|
|
|
spin_unlock_bh(&mppath->state_lock);
|
|
|
|
}
|
|
|
|
rcu_read_unlock();
|
|
|
|
}
|
|
|
|
|
2009-08-10 21:15:48 +02:00
|
|
|
/* Frame has reached destination. Don't forward */
|
|
|
|
if (!is_multicast_ether_addr(hdr->addr1) &&
|
2009-11-16 13:58:20 +01:00
|
|
|
compare_ether_addr(sdata->dev->dev_addr, hdr->addr3) == 0)
|
2008-08-05 19:34:52 +02:00
|
|
|
return RX_CONTINUE;
|
|
|
|
|
|
|
|
mesh_hdr->ttl--;
|
|
|
|
|
|
|
|
if (rx->flags & IEEE80211_RX_RA_MATCH) {
|
|
|
|
if (!mesh_hdr->ttl)
|
2008-09-11 00:01:49 +02:00
|
|
|
IEEE80211_IFSTA_MESH_CTR_INC(&rx->sdata->u.mesh,
|
2008-08-05 19:34:52 +02:00
|
|
|
dropped_frames_ttl);
|
|
|
|
else {
|
|
|
|
struct ieee80211_hdr *fwd_hdr;
|
2009-06-17 17:43:56 +02:00
|
|
|
struct ieee80211_tx_info *info;
|
|
|
|
|
2008-08-05 19:34:52 +02:00
|
|
|
fwd_skb = skb_copy(skb, GFP_ATOMIC);
|
|
|
|
|
|
|
|
if (!fwd_skb && net_ratelimit())
|
|
|
|
printk(KERN_DEBUG "%s: failed to clone mesh frame\n",
|
2009-11-16 13:58:20 +01:00
|
|
|
sdata->dev->name);
|
2008-08-05 19:34:52 +02:00
|
|
|
|
|
|
|
fwd_hdr = (struct ieee80211_hdr *) fwd_skb->data;
|
2009-11-16 13:58:20 +01:00
|
|
|
memcpy(fwd_hdr->addr2, sdata->dev->dev_addr, ETH_ALEN);
|
2009-06-17 17:43:56 +02:00
|
|
|
info = IEEE80211_SKB_CB(fwd_skb);
|
|
|
|
memset(info, 0, sizeof(*info));
|
|
|
|
info->flags |= IEEE80211_TX_INTFL_NEED_TXPROCESSING;
|
2009-07-14 00:33:34 +02:00
|
|
|
info->control.vif = &rx->sdata->vif;
|
2009-06-17 17:43:56 +02:00
|
|
|
ieee80211_select_queue(local, fwd_skb);
|
2009-08-18 19:59:00 +02:00
|
|
|
if (is_multicast_ether_addr(fwd_hdr->addr1))
|
|
|
|
IEEE80211_IFSTA_MESH_CTR_INC(&sdata->u.mesh,
|
|
|
|
fwded_mcast);
|
|
|
|
else {
|
2009-08-10 21:15:48 +02:00
|
|
|
int err;
|
|
|
|
/*
|
|
|
|
* Save TA to addr1 to send TA a path error if a
|
|
|
|
* suitable next hop is not found
|
|
|
|
*/
|
|
|
|
memcpy(fwd_hdr->addr1, fwd_hdr->addr2,
|
2009-07-07 19:55:03 +02:00
|
|
|
ETH_ALEN);
|
2009-08-10 21:15:48 +02:00
|
|
|
err = mesh_nexthop_lookup(fwd_skb, sdata);
|
2009-07-07 19:55:03 +02:00
|
|
|
/* Failed to immediately resolve next hop:
|
|
|
|
* fwded frame was dropped or will be added
|
|
|
|
* later to the pending skb queue. */
|
|
|
|
if (err)
|
|
|
|
return RX_DROP_MONITOR;
|
2009-08-18 19:59:00 +02:00
|
|
|
|
|
|
|
IEEE80211_IFSTA_MESH_CTR_INC(&sdata->u.mesh,
|
|
|
|
fwded_unicast);
|
2009-07-07 19:55:03 +02:00
|
|
|
}
|
|
|
|
IEEE80211_IFSTA_MESH_CTR_INC(&sdata->u.mesh,
|
|
|
|
fwded_frames);
|
2009-06-17 17:43:56 +02:00
|
|
|
ieee80211_add_pending_skb(local, fwd_skb);
|
2008-08-05 19:34:52 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-08-10 21:15:48 +02:00
|
|
|
if (is_multicast_ether_addr(hdr->addr1) ||
|
2009-11-16 13:58:20 +01:00
|
|
|
sdata->dev->flags & IFF_PROMISC)
|
2008-08-05 19:34:52 +02:00
|
|
|
return RX_CONTINUE;
|
|
|
|
else
|
|
|
|
return RX_DROP_MONITOR;
|
|
|
|
}
|
2008-10-13 08:51:38 +02:00
|
|
|
#endif
|
2008-08-05 19:34:52 +02:00
|
|
|
|
2008-06-30 15:10:45 +02:00
|
|
|
static ieee80211_rx_result debug_noinline
|
2008-02-25 16:27:43 +01:00
|
|
|
ieee80211_rx_h_data(struct ieee80211_rx_data *rx)
|
2007-11-22 18:49:12 +01:00
|
|
|
{
|
2009-11-16 13:58:20 +01:00
|
|
|
struct ieee80211_sub_if_data *sdata = rx->sdata;
|
|
|
|
struct net_device *dev = sdata->dev;
|
2008-07-16 03:44:13 +02:00
|
|
|
struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
|
|
|
|
__le16 fc = hdr->frame_control;
|
2007-12-19 01:31:22 +01:00
|
|
|
int err;
|
2007-11-22 18:49:12 +01:00
|
|
|
|
2008-07-16 03:44:13 +02:00
|
|
|
if (unlikely(!ieee80211_is_data(hdr->frame_control)))
|
2008-01-31 19:48:20 +01:00
|
|
|
return RX_CONTINUE;
|
2007-11-22 18:49:12 +01:00
|
|
|
|
2008-07-16 03:44:13 +02:00
|
|
|
if (unlikely(!ieee80211_is_data_present(hdr->frame_control)))
|
2008-01-31 19:48:21 +01:00
|
|
|
return RX_DROP_MONITOR;
|
2007-11-22 18:49:12 +01:00
|
|
|
|
2009-11-10 20:10:05 +01:00
|
|
|
/*
|
|
|
|
* Allow the cooked monitor interface of an AP to see 4-addr frames so
|
|
|
|
* that a 4-addr station can be detected and moved into a separate VLAN
|
|
|
|
*/
|
|
|
|
if (ieee80211_has_a4(hdr->frame_control) &&
|
|
|
|
sdata->vif.type == NL80211_IFTYPE_AP)
|
|
|
|
return RX_DROP_MONITOR;
|
|
|
|
|
2009-05-21 15:47:03 +02:00
|
|
|
err = __ieee80211_data_to_8023(rx);
|
2007-11-22 18:49:12 +01:00
|
|
|
if (unlikely(err))
|
2008-01-31 19:48:21 +01:00
|
|
|
return RX_DROP_UNUSABLE;
|
2007-11-22 18:49:12 +01:00
|
|
|
|
2008-07-16 03:44:13 +02:00
|
|
|
if (!ieee80211_frame_allowed(rx, fc))
|
2008-01-31 19:48:21 +01:00
|
|
|
return RX_DROP_MONITOR;
|
2007-12-19 01:31:22 +01:00
|
|
|
|
2007-11-22 18:49:12 +01:00
|
|
|
rx->skb->dev = dev;
|
|
|
|
|
|
|
|
dev->stats.rx_packets++;
|
|
|
|
dev->stats.rx_bytes += rx->skb->len;
|
|
|
|
|
|
|
|
ieee80211_deliver_skb(rx);
|
2007-07-27 15:43:22 +02:00
|
|
|
|
2008-01-31 19:48:20 +01:00
|
|
|
return RX_QUEUED;
|
2007-07-27 15:43:22 +02:00
|
|
|
}
|
|
|
|
|
2008-06-30 15:10:45 +02:00
|
|
|
static ieee80211_rx_result debug_noinline
|
2008-02-25 16:27:43 +01:00
|
|
|
ieee80211_rx_h_ctrl(struct ieee80211_rx_data *rx)
|
2007-12-25 16:00:36 +01:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = rx->local;
|
|
|
|
struct ieee80211_hw *hw = &local->hw;
|
|
|
|
struct sk_buff *skb = rx->skb;
|
2008-07-03 01:30:51 +02:00
|
|
|
struct ieee80211_bar *bar = (struct ieee80211_bar *)skb->data;
|
2007-12-25 16:00:36 +01:00
|
|
|
struct tid_ampdu_rx *tid_agg_rx;
|
|
|
|
u16 start_seq_num;
|
|
|
|
u16 tid;
|
|
|
|
|
2008-07-03 01:30:51 +02:00
|
|
|
if (likely(!ieee80211_is_ctl(bar->frame_control)))
|
2008-01-31 19:48:20 +01:00
|
|
|
return RX_CONTINUE;
|
2007-12-25 16:00:36 +01:00
|
|
|
|
2008-07-03 01:30:51 +02:00
|
|
|
if (ieee80211_is_back_req(bar->frame_control)) {
|
2007-12-25 16:00:36 +01:00
|
|
|
if (!rx->sta)
|
2009-11-16 12:00:40 +01:00
|
|
|
return RX_DROP_MONITOR;
|
2007-12-25 16:00:36 +01:00
|
|
|
tid = le16_to_cpu(bar->control) >> 12;
|
2008-03-26 19:36:03 +01:00
|
|
|
if (rx->sta->ampdu_mlme.tid_state_rx[tid]
|
|
|
|
!= HT_AGG_STATE_OPERATIONAL)
|
2009-11-16 12:00:40 +01:00
|
|
|
return RX_DROP_MONITOR;
|
2008-03-26 19:36:03 +01:00
|
|
|
tid_agg_rx = rx->sta->ampdu_mlme.tid_rx[tid];
|
2007-12-25 16:00:36 +01:00
|
|
|
|
|
|
|
start_seq_num = le16_to_cpu(bar->start_seq_num) >> 4;
|
|
|
|
|
|
|
|
/* reset session timer */
|
2009-02-10 21:25:45 +01:00
|
|
|
if (tid_agg_rx->timeout)
|
|
|
|
mod_timer(&tid_agg_rx->session_timer,
|
|
|
|
TU_TO_EXP_TIME(tid_agg_rx->timeout));
|
2007-12-25 16:00:36 +01:00
|
|
|
|
2009-11-16 12:00:40 +01:00
|
|
|
/* release stored frames up to start of BAR */
|
|
|
|
ieee80211_release_reorder_frames(hw, tid_agg_rx, start_seq_num);
|
|
|
|
kfree_skb(skb);
|
|
|
|
return RX_QUEUED;
|
2007-12-25 16:00:36 +01:00
|
|
|
}
|
|
|
|
|
2008-01-31 19:48:20 +01:00
|
|
|
return RX_CONTINUE;
|
2007-12-25 16:00:36 +01:00
|
|
|
}
|
|
|
|
|
2009-01-10 10:46:53 +01:00
|
|
|
static void ieee80211_process_sa_query_req(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct ieee80211_mgmt *mgmt,
|
|
|
|
size_t len)
|
2009-01-08 12:32:06 +01:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
struct sk_buff *skb;
|
|
|
|
struct ieee80211_mgmt *resp;
|
|
|
|
|
|
|
|
if (compare_ether_addr(mgmt->da, sdata->dev->dev_addr) != 0) {
|
|
|
|
/* Not to own unicast address */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-02-15 12:44:28 +01:00
|
|
|
if (compare_ether_addr(mgmt->sa, sdata->u.mgd.bssid) != 0 ||
|
|
|
|
compare_ether_addr(mgmt->bssid, sdata->u.mgd.bssid) != 0) {
|
2009-07-07 03:45:17 +02:00
|
|
|
/* Not from the current AP or not associated yet. */
|
2009-01-08 12:32:06 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (len < 24 + 1 + sizeof(resp->u.action.u.sa_query)) {
|
|
|
|
/* Too short SA Query request frame */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
skb = dev_alloc_skb(sizeof(*resp) + local->hw.extra_tx_headroom);
|
|
|
|
if (skb == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
skb_reserve(skb, local->hw.extra_tx_headroom);
|
|
|
|
resp = (struct ieee80211_mgmt *) skb_put(skb, 24);
|
|
|
|
memset(resp, 0, 24);
|
|
|
|
memcpy(resp->da, mgmt->sa, ETH_ALEN);
|
|
|
|
memcpy(resp->sa, sdata->dev->dev_addr, ETH_ALEN);
|
2009-02-15 12:44:28 +01:00
|
|
|
memcpy(resp->bssid, sdata->u.mgd.bssid, ETH_ALEN);
|
2009-01-08 12:32:06 +01:00
|
|
|
resp->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
|
|
|
|
IEEE80211_STYPE_ACTION);
|
|
|
|
skb_put(skb, 1 + sizeof(resp->u.action.u.sa_query));
|
|
|
|
resp->u.action.category = WLAN_CATEGORY_SA_QUERY;
|
|
|
|
resp->u.action.u.sa_query.action = WLAN_ACTION_SA_QUERY_RESPONSE;
|
|
|
|
memcpy(resp->u.action.u.sa_query.trans_id,
|
|
|
|
mgmt->u.action.u.sa_query.trans_id,
|
|
|
|
WLAN_SA_QUERY_TR_ID_LEN);
|
|
|
|
|
2009-11-18 18:42:05 +01:00
|
|
|
ieee80211_tx_skb(sdata, skb);
|
2009-01-08 12:32:06 +01:00
|
|
|
}
|
|
|
|
|
2008-09-09 14:42:50 +02:00
|
|
|
static ieee80211_rx_result debug_noinline
|
|
|
|
ieee80211_rx_h_action(struct ieee80211_rx_data *rx)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = rx->local;
|
2009-11-16 13:58:20 +01:00
|
|
|
struct ieee80211_sub_if_data *sdata = rx->sdata;
|
2008-09-09 14:42:50 +02:00
|
|
|
struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *) rx->skb->data;
|
|
|
|
int len = rx->skb->len;
|
|
|
|
|
|
|
|
if (!ieee80211_is_action(mgmt->frame_control))
|
|
|
|
return RX_CONTINUE;
|
|
|
|
|
|
|
|
if (!rx->sta)
|
|
|
|
return RX_DROP_MONITOR;
|
|
|
|
|
|
|
|
if (!(rx->flags & IEEE80211_RX_RA_MATCH))
|
|
|
|
return RX_DROP_MONITOR;
|
|
|
|
|
2009-01-08 12:32:08 +01:00
|
|
|
if (ieee80211_drop_unencrypted(rx, mgmt->frame_control))
|
|
|
|
return RX_DROP_MONITOR;
|
|
|
|
|
2008-09-09 14:42:50 +02:00
|
|
|
/* all categories we currently handle have action_code */
|
|
|
|
if (len < IEEE80211_MIN_ACTION_SIZE + 1)
|
|
|
|
return RX_DROP_MONITOR;
|
|
|
|
|
|
|
|
switch (mgmt->u.action.category) {
|
|
|
|
case WLAN_CATEGORY_BACK:
|
2009-02-10 21:25:47 +01:00
|
|
|
/*
|
|
|
|
* The aggregation code is not prepared to handle
|
|
|
|
* anything but STA/AP due to the BSSID handling;
|
|
|
|
* IBSS could work in the code but isn't supported
|
|
|
|
* by drivers or the standard.
|
|
|
|
*/
|
|
|
|
if (sdata->vif.type != NL80211_IFTYPE_STATION &&
|
|
|
|
sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
|
|
|
|
sdata->vif.type != NL80211_IFTYPE_AP)
|
|
|
|
return RX_DROP_MONITOR;
|
|
|
|
|
2008-09-09 14:42:50 +02:00
|
|
|
switch (mgmt->u.action.u.addba_req.action_code) {
|
|
|
|
case WLAN_ACTION_ADDBA_REQ:
|
|
|
|
if (len < (IEEE80211_MIN_ACTION_SIZE +
|
|
|
|
sizeof(mgmt->u.action.u.addba_req)))
|
|
|
|
return RX_DROP_MONITOR;
|
|
|
|
ieee80211_process_addba_request(local, rx->sta, mgmt, len);
|
|
|
|
break;
|
|
|
|
case WLAN_ACTION_ADDBA_RESP:
|
|
|
|
if (len < (IEEE80211_MIN_ACTION_SIZE +
|
|
|
|
sizeof(mgmt->u.action.u.addba_resp)))
|
|
|
|
return RX_DROP_MONITOR;
|
|
|
|
ieee80211_process_addba_resp(local, rx->sta, mgmt, len);
|
|
|
|
break;
|
|
|
|
case WLAN_ACTION_DELBA:
|
|
|
|
if (len < (IEEE80211_MIN_ACTION_SIZE +
|
|
|
|
sizeof(mgmt->u.action.u.delba)))
|
|
|
|
return RX_DROP_MONITOR;
|
|
|
|
ieee80211_process_delba(sdata, rx->sta, mgmt, len);
|
|
|
|
break;
|
|
|
|
}
|
2008-09-09 14:49:03 +02:00
|
|
|
break;
|
|
|
|
case WLAN_CATEGORY_SPECTRUM_MGMT:
|
|
|
|
if (local->hw.conf.channel->band != IEEE80211_BAND_5GHZ)
|
|
|
|
return RX_DROP_MONITOR;
|
2009-02-15 12:44:28 +01:00
|
|
|
|
|
|
|
if (sdata->vif.type != NL80211_IFTYPE_STATION)
|
|
|
|
return RX_DROP_MONITOR;
|
|
|
|
|
2008-09-09 14:49:03 +02:00
|
|
|
switch (mgmt->u.action.u.measurement.action_code) {
|
|
|
|
case WLAN_ACTION_SPCT_MSR_REQ:
|
|
|
|
if (len < (IEEE80211_MIN_ACTION_SIZE +
|
|
|
|
sizeof(mgmt->u.action.u.measurement)))
|
|
|
|
return RX_DROP_MONITOR;
|
|
|
|
ieee80211_process_measurement_req(sdata, mgmt, len);
|
|
|
|
break;
|
2009-01-06 04:58:37 +01:00
|
|
|
case WLAN_ACTION_SPCT_CHL_SWITCH:
|
|
|
|
if (len < (IEEE80211_MIN_ACTION_SIZE +
|
|
|
|
sizeof(mgmt->u.action.u.chan_switch)))
|
|
|
|
return RX_DROP_MONITOR;
|
|
|
|
|
2009-05-15 11:52:31 +02:00
|
|
|
if (sdata->vif.type != NL80211_IFTYPE_STATION)
|
|
|
|
return RX_DROP_MONITOR;
|
|
|
|
|
2009-02-15 12:44:28 +01:00
|
|
|
if (memcmp(mgmt->bssid, sdata->u.mgd.bssid, ETH_ALEN))
|
2009-01-06 04:58:37 +01:00
|
|
|
return RX_DROP_MONITOR;
|
|
|
|
|
2009-07-07 03:45:17 +02:00
|
|
|
return ieee80211_sta_rx_mgmt(sdata, rx->skb);
|
2008-09-09 14:49:03 +02:00
|
|
|
}
|
|
|
|
break;
|
2009-01-08 12:32:06 +01:00
|
|
|
case WLAN_CATEGORY_SA_QUERY:
|
|
|
|
if (len < (IEEE80211_MIN_ACTION_SIZE +
|
|
|
|
sizeof(mgmt->u.action.u.sa_query)))
|
|
|
|
return RX_DROP_MONITOR;
|
|
|
|
switch (mgmt->u.action.u.sa_query.action) {
|
|
|
|
case WLAN_ACTION_SA_QUERY_REQUEST:
|
|
|
|
if (sdata->vif.type != NL80211_IFTYPE_STATION)
|
|
|
|
return RX_DROP_MONITOR;
|
|
|
|
ieee80211_process_sa_query_req(sdata, mgmt, len);
|
|
|
|
break;
|
|
|
|
case WLAN_ACTION_SA_QUERY_RESPONSE:
|
|
|
|
/*
|
|
|
|
* SA Query response is currently only used in AP mode
|
|
|
|
* and it is processed in user space.
|
|
|
|
*/
|
|
|
|
return RX_CONTINUE;
|
|
|
|
}
|
|
|
|
break;
|
2008-09-09 14:49:03 +02:00
|
|
|
default:
|
|
|
|
return RX_CONTINUE;
|
2008-09-09 14:42:50 +02:00
|
|
|
}
|
|
|
|
|
2008-09-09 14:49:03 +02:00
|
|
|
rx->sta->rx_packets++;
|
|
|
|
dev_kfree_skb(rx->skb);
|
|
|
|
return RX_QUEUED;
|
2008-09-09 14:42:50 +02:00
|
|
|
}
|
|
|
|
|
2008-06-30 15:10:45 +02:00
|
|
|
static ieee80211_rx_result debug_noinline
|
2008-02-25 16:27:43 +01:00
|
|
|
ieee80211_rx_h_mgmt(struct ieee80211_rx_data *rx)
|
2007-07-27 15:43:22 +02:00
|
|
|
{
|
2009-11-16 13:58:20 +01:00
|
|
|
struct ieee80211_sub_if_data *sdata = rx->sdata;
|
2009-01-08 12:32:08 +01:00
|
|
|
struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *) rx->skb->data;
|
2007-07-27 15:43:22 +02:00
|
|
|
|
2008-02-25 16:27:43 +01:00
|
|
|
if (!(rx->flags & IEEE80211_RX_RA_MATCH))
|
2008-01-31 19:48:21 +01:00
|
|
|
return RX_DROP_MONITOR;
|
2007-07-27 15:43:22 +02:00
|
|
|
|
2009-01-08 12:32:08 +01:00
|
|
|
if (ieee80211_drop_unencrypted(rx, mgmt->frame_control))
|
|
|
|
return RX_DROP_MONITOR;
|
|
|
|
|
2008-09-11 00:01:49 +02:00
|
|
|
if (ieee80211_vif_is_mesh(&sdata->vif))
|
2009-06-17 13:13:00 +02:00
|
|
|
return ieee80211_mesh_rx_mgmt(sdata, rx->skb);
|
2008-09-11 00:01:49 +02:00
|
|
|
|
2009-03-24 08:46:57 +01:00
|
|
|
if (sdata->vif.type == NL80211_IFTYPE_ADHOC)
|
2009-06-17 13:13:00 +02:00
|
|
|
return ieee80211_ibss_rx_mgmt(sdata, rx->skb);
|
2007-09-28 14:02:09 +02:00
|
|
|
|
2009-03-21 17:08:43 +01:00
|
|
|
if (sdata->vif.type == NL80211_IFTYPE_STATION)
|
2009-06-17 13:13:00 +02:00
|
|
|
return ieee80211_sta_rx_mgmt(sdata, rx->skb);
|
2009-02-15 12:44:28 +01:00
|
|
|
|
2009-03-21 17:08:43 +01:00
|
|
|
return RX_DROP_MONITOR;
|
2007-07-27 15:43:22 +02:00
|
|
|
}
|
|
|
|
|
2009-06-17 17:43:56 +02:00
|
|
|
static void ieee80211_rx_michael_mic_report(struct ieee80211_hdr *hdr,
|
2008-02-25 16:27:43 +01:00
|
|
|
struct ieee80211_rx_data *rx)
|
2007-07-27 15:43:22 +02:00
|
|
|
{
|
2008-07-03 01:30:51 +02:00
|
|
|
int keyidx;
|
|
|
|
unsigned int hdrlen;
|
2007-07-27 15:43:22 +02:00
|
|
|
|
2008-07-03 01:30:51 +02:00
|
|
|
hdrlen = ieee80211_hdrlen(hdr->frame_control);
|
2007-07-27 15:43:22 +02:00
|
|
|
if (rx->skb->len >= hdrlen + 4)
|
|
|
|
keyidx = rx->skb->data[hdrlen + 3] >> 6;
|
|
|
|
else
|
|
|
|
keyidx = -1;
|
|
|
|
|
2008-01-31 19:48:26 +01:00
|
|
|
if (!rx->sta) {
|
2007-09-10 14:15:25 +02:00
|
|
|
/*
|
|
|
|
* Some hardware seem to generate incorrect Michael MIC
|
|
|
|
* reports; ignore them to avoid triggering countermeasures.
|
|
|
|
*/
|
2009-11-16 12:00:39 +01:00
|
|
|
return;
|
2007-07-27 15:43:22 +02:00
|
|
|
}
|
|
|
|
|
2008-07-03 01:30:51 +02:00
|
|
|
if (!ieee80211_has_protected(hdr->frame_control))
|
2009-11-16 12:00:39 +01:00
|
|
|
return;
|
2007-07-27 15:43:22 +02:00
|
|
|
|
2008-09-11 00:01:58 +02:00
|
|
|
if (rx->sdata->vif.type == NL80211_IFTYPE_AP && keyidx) {
|
2007-09-10 14:15:25 +02:00
|
|
|
/*
|
|
|
|
* APs with pairwise keys should never receive Michael MIC
|
|
|
|
* errors for non-zero keyidx because these are reserved for
|
|
|
|
* group keys and only the AP is sending real multicast
|
|
|
|
* frames in the BSS.
|
|
|
|
*/
|
2009-11-16 12:00:39 +01:00
|
|
|
return;
|
2007-07-27 15:43:22 +02:00
|
|
|
}
|
|
|
|
|
2008-07-03 01:30:51 +02:00
|
|
|
if (!ieee80211_is_data(hdr->frame_control) &&
|
|
|
|
!ieee80211_is_auth(hdr->frame_control))
|
2009-11-16 12:00:39 +01:00
|
|
|
return;
|
2007-07-27 15:43:22 +02:00
|
|
|
|
2009-07-01 21:26:47 +02:00
|
|
|
mac80211_ev_michael_mic_failure(rx->sdata, keyidx, hdr, NULL,
|
|
|
|
GFP_ATOMIC);
|
2007-07-27 15:43:22 +02:00
|
|
|
}
|
|
|
|
|
2008-02-25 16:27:43 +01:00
|
|
|
/* TODO: use IEEE80211_RX_FRAGMENTED */
|
2009-11-16 13:58:21 +01:00
|
|
|
static void ieee80211_rx_cooked_monitor(struct ieee80211_rx_data *rx,
|
|
|
|
struct ieee80211_rate *rate)
|
2008-01-31 19:48:27 +01:00
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata;
|
|
|
|
struct ieee80211_local *local = rx->local;
|
|
|
|
struct ieee80211_rtap_hdr {
|
|
|
|
struct ieee80211_radiotap_header hdr;
|
|
|
|
u8 flags;
|
2009-11-16 13:58:21 +01:00
|
|
|
u8 rate_or_pad;
|
2008-01-31 19:48:27 +01:00
|
|
|
__le16 chan_freq;
|
|
|
|
__le16 chan_flags;
|
|
|
|
} __attribute__ ((packed)) *rthdr;
|
|
|
|
struct sk_buff *skb = rx->skb, *skb2;
|
|
|
|
struct net_device *prev_dev = NULL;
|
2009-11-16 13:58:20 +01:00
|
|
|
struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
|
2008-01-31 19:48:27 +01:00
|
|
|
|
2008-02-25 16:27:43 +01:00
|
|
|
if (rx->flags & IEEE80211_RX_CMNTR_REPORTED)
|
2008-01-31 19:48:27 +01:00
|
|
|
goto out_free_skb;
|
|
|
|
|
|
|
|
if (skb_headroom(skb) < sizeof(*rthdr) &&
|
|
|
|
pskb_expand_head(skb, sizeof(*rthdr), 0, GFP_ATOMIC))
|
|
|
|
goto out_free_skb;
|
|
|
|
|
|
|
|
rthdr = (void *)skb_push(skb, sizeof(*rthdr));
|
|
|
|
memset(rthdr, 0, sizeof(*rthdr));
|
|
|
|
rthdr->hdr.it_len = cpu_to_le16(sizeof(*rthdr));
|
|
|
|
rthdr->hdr.it_present =
|
|
|
|
cpu_to_le32((1 << IEEE80211_RADIOTAP_FLAGS) |
|
|
|
|
(1 << IEEE80211_RADIOTAP_CHANNEL));
|
|
|
|
|
2009-11-16 13:58:21 +01:00
|
|
|
if (rate) {
|
|
|
|
rthdr->rate_or_pad = rate->bitrate / 5;
|
|
|
|
rthdr->hdr.it_present |=
|
|
|
|
cpu_to_le32(1 << IEEE80211_RADIOTAP_RATE);
|
|
|
|
}
|
2008-01-31 19:48:27 +01:00
|
|
|
rthdr->chan_freq = cpu_to_le16(status->freq);
|
|
|
|
|
|
|
|
if (status->band == IEEE80211_BAND_5GHZ)
|
|
|
|
rthdr->chan_flags = cpu_to_le16(IEEE80211_CHAN_OFDM |
|
|
|
|
IEEE80211_CHAN_5GHZ);
|
|
|
|
else
|
|
|
|
rthdr->chan_flags = cpu_to_le16(IEEE80211_CHAN_DYN |
|
|
|
|
IEEE80211_CHAN_2GHZ);
|
|
|
|
|
|
|
|
skb_set_mac_header(skb, 0);
|
|
|
|
skb->ip_summed = CHECKSUM_UNNECESSARY;
|
|
|
|
skb->pkt_type = PACKET_OTHERHOST;
|
|
|
|
skb->protocol = htons(ETH_P_802_2);
|
|
|
|
|
|
|
|
list_for_each_entry_rcu(sdata, &local->interfaces, list) {
|
|
|
|
if (!netif_running(sdata->dev))
|
|
|
|
continue;
|
|
|
|
|
2008-09-11 00:01:58 +02:00
|
|
|
if (sdata->vif.type != NL80211_IFTYPE_MONITOR ||
|
2008-01-31 19:48:27 +01:00
|
|
|
!(sdata->u.mntr_flags & MONITOR_FLAG_COOK_FRAMES))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (prev_dev) {
|
|
|
|
skb2 = skb_clone(skb, GFP_ATOMIC);
|
|
|
|
if (skb2) {
|
|
|
|
skb2->dev = prev_dev;
|
|
|
|
netif_rx(skb2);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
prev_dev = sdata->dev;
|
|
|
|
sdata->dev->stats.rx_packets++;
|
|
|
|
sdata->dev->stats.rx_bytes += skb->len;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (prev_dev) {
|
|
|
|
skb->dev = prev_dev;
|
|
|
|
netif_rx(skb);
|
|
|
|
skb = NULL;
|
|
|
|
} else
|
|
|
|
goto out_free_skb;
|
|
|
|
|
2008-02-25 16:27:43 +01:00
|
|
|
rx->flags |= IEEE80211_RX_CMNTR_REPORTED;
|
2008-01-31 19:48:27 +01:00
|
|
|
return;
|
|
|
|
|
|
|
|
out_free_skb:
|
|
|
|
dev_kfree_skb(skb);
|
|
|
|
}
|
|
|
|
|
2007-07-27 15:43:22 +02:00
|
|
|
|
2008-01-31 19:48:26 +01:00
|
|
|
static void ieee80211_invoke_rx_handlers(struct ieee80211_sub_if_data *sdata,
|
2008-02-25 16:27:43 +01:00
|
|
|
struct ieee80211_rx_data *rx,
|
2009-11-16 13:58:21 +01:00
|
|
|
struct sk_buff *skb,
|
|
|
|
struct ieee80211_rate *rate)
|
2008-01-31 19:48:25 +01:00
|
|
|
{
|
|
|
|
ieee80211_rx_result res = RX_DROP_MONITOR;
|
|
|
|
|
2008-01-31 19:48:26 +01:00
|
|
|
rx->skb = skb;
|
|
|
|
rx->sdata = sdata;
|
|
|
|
|
2008-08-05 19:34:52 +02:00
|
|
|
#define CALL_RXH(rxh) \
|
|
|
|
do { \
|
|
|
|
res = rxh(rx); \
|
|
|
|
if (res != RX_CONTINUE) \
|
|
|
|
goto rxh_done; \
|
|
|
|
} while (0);
|
2008-06-30 15:10:45 +02:00
|
|
|
|
|
|
|
CALL_RXH(ieee80211_rx_h_passive_scan)
|
|
|
|
CALL_RXH(ieee80211_rx_h_check)
|
|
|
|
CALL_RXH(ieee80211_rx_h_decrypt)
|
2009-02-10 16:09:31 +01:00
|
|
|
CALL_RXH(ieee80211_rx_h_check_more_data)
|
2008-06-30 15:10:45 +02:00
|
|
|
CALL_RXH(ieee80211_rx_h_sta_process)
|
|
|
|
CALL_RXH(ieee80211_rx_h_defragment)
|
|
|
|
CALL_RXH(ieee80211_rx_h_ps_poll)
|
|
|
|
CALL_RXH(ieee80211_rx_h_michael_mic_verify)
|
|
|
|
/* must be after MMIC verify so header is counted in MPDU mic */
|
|
|
|
CALL_RXH(ieee80211_rx_h_remove_qos_control)
|
|
|
|
CALL_RXH(ieee80211_rx_h_amsdu)
|
2008-10-13 08:51:38 +02:00
|
|
|
#ifdef CONFIG_MAC80211_MESH
|
2008-08-05 19:34:52 +02:00
|
|
|
if (ieee80211_vif_is_mesh(&sdata->vif))
|
|
|
|
CALL_RXH(ieee80211_rx_h_mesh_fwding);
|
2008-10-13 08:51:38 +02:00
|
|
|
#endif
|
2008-06-30 15:10:45 +02:00
|
|
|
CALL_RXH(ieee80211_rx_h_data)
|
|
|
|
CALL_RXH(ieee80211_rx_h_ctrl)
|
2008-09-09 14:42:50 +02:00
|
|
|
CALL_RXH(ieee80211_rx_h_action)
|
2008-06-30 15:10:45 +02:00
|
|
|
CALL_RXH(ieee80211_rx_h_mgmt)
|
|
|
|
|
|
|
|
#undef CALL_RXH
|
|
|
|
|
|
|
|
rxh_done:
|
2008-01-31 19:48:25 +01:00
|
|
|
switch (res) {
|
|
|
|
case RX_DROP_MONITOR:
|
2008-06-30 15:10:45 +02:00
|
|
|
I802_DEBUG_INC(sdata->local->rx_handlers_drop);
|
|
|
|
if (rx->sta)
|
|
|
|
rx->sta->rx_dropped++;
|
|
|
|
/* fall through */
|
|
|
|
case RX_CONTINUE:
|
2009-11-16 13:58:21 +01:00
|
|
|
ieee80211_rx_cooked_monitor(rx, rate);
|
2008-01-31 19:48:27 +01:00
|
|
|
break;
|
2008-01-31 19:48:25 +01:00
|
|
|
case RX_DROP_UNUSABLE:
|
2008-06-30 15:10:45 +02:00
|
|
|
I802_DEBUG_INC(sdata->local->rx_handlers_drop);
|
|
|
|
if (rx->sta)
|
|
|
|
rx->sta->rx_dropped++;
|
2008-01-31 19:48:25 +01:00
|
|
|
dev_kfree_skb(rx->skb);
|
|
|
|
break;
|
2008-06-30 15:10:45 +02:00
|
|
|
case RX_QUEUED:
|
|
|
|
I802_DEBUG_INC(sdata->local->rx_handlers_queued);
|
|
|
|
break;
|
2008-01-31 19:48:25 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-07-27 15:43:22 +02:00
|
|
|
/* main receive path */
|
|
|
|
|
2007-07-27 15:43:22 +02:00
|
|
|
static int prepare_for_handlers(struct ieee80211_sub_if_data *sdata,
|
2009-02-10 21:25:43 +01:00
|
|
|
struct ieee80211_rx_data *rx,
|
2007-07-27 15:43:22 +02:00
|
|
|
struct ieee80211_hdr *hdr)
|
|
|
|
{
|
2009-11-16 13:58:20 +01:00
|
|
|
struct sk_buff *skb = rx->skb;
|
|
|
|
struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
|
|
|
|
u8 *bssid = ieee80211_get_bssid(hdr, skb->len, sdata->vif.type);
|
2007-07-27 15:43:22 +02:00
|
|
|
int multicast = is_multicast_ether_addr(hdr->addr1);
|
|
|
|
|
2007-12-19 01:31:27 +01:00
|
|
|
switch (sdata->vif.type) {
|
2008-09-11 00:01:58 +02:00
|
|
|
case NL80211_IFTYPE_STATION:
|
2009-11-19 11:55:19 +01:00
|
|
|
if (!bssid && !sdata->u.mgd.use_4addr)
|
2007-07-27 15:43:22 +02:00
|
|
|
return 0;
|
2009-07-07 03:45:17 +02:00
|
|
|
if (!multicast &&
|
|
|
|
compare_ether_addr(sdata->dev->dev_addr, hdr->addr1) != 0) {
|
[PATCH] mac80211: revamp interface and filter configuration
Drivers are currently supposed to keep track of monitor
interfaces if they allow so-called "hard" monitor, and
they are also supposed to keep track of multicast etc.
This patch changes that, replaces the set_multicast_list()
callback with a new configure_filter() callback that takes
filter flags (FIF_*) instead of interface flags (IFF_*).
For a driver, this means it should open the filter as much
as necessary to get all frames requested by the filter flags.
Accordingly, the filter flags are named "positively", e.g.
FIF_ALLMULTI.
Multicast filtering is a bit special in that drivers that
have no multicast address filters need to allow multicast
frames through when either the FIF_ALLMULTI flag is set or
when the mc_count value is positive.
At the same time, drivers are no longer notified about
monitor interfaces at all, this means they now need to
implement the start() and stop() callbacks and the new
change_filter_flags() callback. Also, the start()/stop()
ordering changed, start() is now called *before* any
add_interface() as it really should be, and stop() after
any remove_interface().
The patch also changes the behaviour of setting the bssid
to multicast for scanning when IEEE80211_HW_NO_PROBE_FILTERING
is set; the IEEE80211_HW_NO_PROBE_FILTERING flag is removed
and the filter flag FIF_BCN_PRBRESP_PROMISC introduced.
This is a lot more efficient for hardware like b43 that
supports it and other hardware can still set the BSSID
to all-ones.
Driver modifications by Johannes Berg (b43 & iwlwifi), Michael Wu
(rtl8187, adm8211, and p54), Larry Finger (b43legacy), and
Ivo van Doorn (rt2x00).
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: Michael Wu <flamingice@sourmilk.net>
Signed-off-by: Larry Finger <Larry.Finger@lwfinger.net>
Signed-off-by: Ivo van Doorn <IvDoorn@gmail.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2007-09-17 07:29:23 +02:00
|
|
|
if (!(sdata->dev->flags & IFF_PROMISC))
|
2007-07-27 15:43:22 +02:00
|
|
|
return 0;
|
2008-02-25 16:27:43 +01:00
|
|
|
rx->flags &= ~IEEE80211_RX_RA_MATCH;
|
2007-07-27 15:43:22 +02:00
|
|
|
}
|
|
|
|
break;
|
2008-09-11 00:01:58 +02:00
|
|
|
case NL80211_IFTYPE_ADHOC:
|
2007-07-27 15:43:22 +02:00
|
|
|
if (!bssid)
|
|
|
|
return 0;
|
2008-07-03 01:30:51 +02:00
|
|
|
if (ieee80211_is_beacon(hdr->frame_control)) {
|
2008-02-18 03:21:36 +01:00
|
|
|
return 1;
|
2008-06-13 16:50:44 +02:00
|
|
|
}
|
2009-02-15 12:44:28 +01:00
|
|
|
else if (!ieee80211_bssid_match(bssid, sdata->u.ibss.bssid)) {
|
2008-02-25 16:27:43 +01:00
|
|
|
if (!(rx->flags & IEEE80211_RX_IN_SCAN))
|
2007-07-27 15:43:22 +02:00
|
|
|
return 0;
|
2008-02-25 16:27:43 +01:00
|
|
|
rx->flags &= ~IEEE80211_RX_RA_MATCH;
|
2007-07-27 15:43:22 +02:00
|
|
|
} else if (!multicast &&
|
|
|
|
compare_ether_addr(sdata->dev->dev_addr,
|
|
|
|
hdr->addr1) != 0) {
|
[PATCH] mac80211: revamp interface and filter configuration
Drivers are currently supposed to keep track of monitor
interfaces if they allow so-called "hard" monitor, and
they are also supposed to keep track of multicast etc.
This patch changes that, replaces the set_multicast_list()
callback with a new configure_filter() callback that takes
filter flags (FIF_*) instead of interface flags (IFF_*).
For a driver, this means it should open the filter as much
as necessary to get all frames requested by the filter flags.
Accordingly, the filter flags are named "positively", e.g.
FIF_ALLMULTI.
Multicast filtering is a bit special in that drivers that
have no multicast address filters need to allow multicast
frames through when either the FIF_ALLMULTI flag is set or
when the mc_count value is positive.
At the same time, drivers are no longer notified about
monitor interfaces at all, this means they now need to
implement the start() and stop() callbacks and the new
change_filter_flags() callback. Also, the start()/stop()
ordering changed, start() is now called *before* any
add_interface() as it really should be, and stop() after
any remove_interface().
The patch also changes the behaviour of setting the bssid
to multicast for scanning when IEEE80211_HW_NO_PROBE_FILTERING
is set; the IEEE80211_HW_NO_PROBE_FILTERING flag is removed
and the filter flag FIF_BCN_PRBRESP_PROMISC introduced.
This is a lot more efficient for hardware like b43 that
supports it and other hardware can still set the BSSID
to all-ones.
Driver modifications by Johannes Berg (b43 & iwlwifi), Michael Wu
(rtl8187, adm8211, and p54), Larry Finger (b43legacy), and
Ivo van Doorn (rt2x00).
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: Michael Wu <flamingice@sourmilk.net>
Signed-off-by: Larry Finger <Larry.Finger@lwfinger.net>
Signed-off-by: Ivo van Doorn <IvDoorn@gmail.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2007-09-17 07:29:23 +02:00
|
|
|
if (!(sdata->dev->flags & IFF_PROMISC))
|
2007-07-27 15:43:22 +02:00
|
|
|
return 0;
|
2008-02-25 16:27:43 +01:00
|
|
|
rx->flags &= ~IEEE80211_RX_RA_MATCH;
|
2008-12-12 13:38:33 +01:00
|
|
|
} else if (!rx->sta) {
|
|
|
|
int rate_idx;
|
2009-11-16 13:58:20 +01:00
|
|
|
if (status->flag & RX_FLAG_HT)
|
2008-12-12 13:38:33 +01:00
|
|
|
rate_idx = 0; /* TODO: HT rates */
|
|
|
|
else
|
2009-11-16 13:58:20 +01:00
|
|
|
rate_idx = status->rate_idx;
|
2008-12-11 13:00:25 +01:00
|
|
|
rx->sta = ieee80211_ibss_add_sta(sdata, bssid, hdr->addr2,
|
2008-12-12 13:38:33 +01:00
|
|
|
BIT(rate_idx));
|
|
|
|
}
|
2007-07-27 15:43:22 +02:00
|
|
|
break;
|
2008-09-11 00:01:58 +02:00
|
|
|
case NL80211_IFTYPE_MESH_POINT:
|
2008-02-23 15:17:07 +01:00
|
|
|
if (!multicast &&
|
|
|
|
compare_ether_addr(sdata->dev->dev_addr,
|
|
|
|
hdr->addr1) != 0) {
|
|
|
|
if (!(sdata->dev->flags & IFF_PROMISC))
|
|
|
|
return 0;
|
|
|
|
|
2008-02-25 16:27:43 +01:00
|
|
|
rx->flags &= ~IEEE80211_RX_RA_MATCH;
|
2008-02-23 15:17:07 +01:00
|
|
|
}
|
|
|
|
break;
|
2008-09-11 00:01:58 +02:00
|
|
|
case NL80211_IFTYPE_AP_VLAN:
|
|
|
|
case NL80211_IFTYPE_AP:
|
2007-07-27 15:43:22 +02:00
|
|
|
if (!bssid) {
|
|
|
|
if (compare_ether_addr(sdata->dev->dev_addr,
|
|
|
|
hdr->addr1))
|
|
|
|
return 0;
|
|
|
|
} else if (!ieee80211_bssid_match(bssid,
|
|
|
|
sdata->dev->dev_addr)) {
|
2008-02-25 16:27:43 +01:00
|
|
|
if (!(rx->flags & IEEE80211_RX_IN_SCAN))
|
2007-07-27 15:43:22 +02:00
|
|
|
return 0;
|
2008-02-25 16:27:43 +01:00
|
|
|
rx->flags &= ~IEEE80211_RX_RA_MATCH;
|
2007-07-27 15:43:22 +02:00
|
|
|
}
|
|
|
|
break;
|
2008-09-11 00:01:58 +02:00
|
|
|
case NL80211_IFTYPE_WDS:
|
2008-07-03 01:30:51 +02:00
|
|
|
if (bssid || !ieee80211_is_data(hdr->frame_control))
|
2007-07-27 15:43:22 +02:00
|
|
|
return 0;
|
|
|
|
if (compare_ether_addr(sdata->u.wds.remote_addr, hdr->addr2))
|
|
|
|
return 0;
|
|
|
|
break;
|
2008-09-11 00:01:58 +02:00
|
|
|
case NL80211_IFTYPE_MONITOR:
|
|
|
|
case NL80211_IFTYPE_UNSPECIFIED:
|
|
|
|
case __NL80211_IFTYPE_AFTER_LAST:
|
2007-09-26 15:19:43 +02:00
|
|
|
/* should never get here */
|
|
|
|
WARN_ON(1);
|
|
|
|
break;
|
2007-07-27 15:43:22 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2007-07-27 15:43:22 +02:00
|
|
|
/*
|
2007-12-24 12:36:39 +01:00
|
|
|
* This is the actual Rx frames handler. as it blongs to Rx path it must
|
|
|
|
* be called with rcu_read_lock protection.
|
2007-07-27 15:43:22 +02:00
|
|
|
*/
|
2008-01-21 11:39:12 +01:00
|
|
|
static void __ieee80211_rx_handle_packet(struct ieee80211_hw *hw,
|
|
|
|
struct sk_buff *skb,
|
2008-01-24 19:38:38 +01:00
|
|
|
struct ieee80211_rate *rate)
|
2007-07-27 15:43:22 +02:00
|
|
|
{
|
2009-06-17 13:13:00 +02:00
|
|
|
struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
|
2007-07-27 15:43:22 +02:00
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
|
|
struct ieee80211_sub_if_data *sdata;
|
|
|
|
struct ieee80211_hdr *hdr;
|
2008-02-25 16:27:43 +01:00
|
|
|
struct ieee80211_rx_data rx;
|
2007-12-24 12:36:39 +01:00
|
|
|
int prepares;
|
2007-07-27 15:43:22 +02:00
|
|
|
struct ieee80211_sub_if_data *prev = NULL;
|
|
|
|
struct sk_buff *skb_new;
|
2007-07-27 15:43:22 +02:00
|
|
|
|
2008-07-16 03:44:13 +02:00
|
|
|
hdr = (struct ieee80211_hdr *)skb->data;
|
2007-07-27 15:43:22 +02:00
|
|
|
memset(&rx, 0, sizeof(rx));
|
|
|
|
rx.skb = skb;
|
|
|
|
rx.local = local;
|
2007-09-17 07:29:22 +02:00
|
|
|
|
2008-07-16 03:44:13 +02:00
|
|
|
if (ieee80211_is_data(hdr->frame_control) || ieee80211_is_mgmt(hdr->frame_control))
|
2007-07-27 15:43:22 +02:00
|
|
|
local->dot11ReceivedFragmentCount++;
|
|
|
|
|
2009-07-23 13:18:01 +02:00
|
|
|
if (unlikely(test_bit(SCAN_HW_SCANNING, &local->scanning) ||
|
|
|
|
test_bit(SCAN_OFF_CHANNEL, &local->scanning)))
|
2008-02-25 16:27:43 +01:00
|
|
|
rx.flags |= IEEE80211_RX_IN_SCAN;
|
2007-07-27 15:43:22 +02:00
|
|
|
|
2008-01-29 17:07:43 +01:00
|
|
|
ieee80211_parse_qos(&rx);
|
2009-01-07 00:26:10 +01:00
|
|
|
ieee80211_verify_alignment(&rx);
|
2008-01-29 17:07:43 +01:00
|
|
|
|
2009-11-16 12:00:39 +01:00
|
|
|
rx.sta = sta_info_get(local, hdr->addr2);
|
2009-11-16 13:58:20 +01:00
|
|
|
if (rx.sta)
|
2009-11-16 12:00:39 +01:00
|
|
|
rx.sdata = rx.sta->sdata;
|
2007-07-27 15:43:22 +02:00
|
|
|
|
2009-10-01 22:06:29 +02:00
|
|
|
if (rx.sdata && ieee80211_is_data(hdr->frame_control)) {
|
|
|
|
rx.flags |= IEEE80211_RX_RA_MATCH;
|
|
|
|
prepares = prepare_for_handlers(rx.sdata, &rx, hdr);
|
2009-11-16 12:00:39 +01:00
|
|
|
if (prepares) {
|
|
|
|
if (status->flag & RX_FLAG_MMIC_ERROR) {
|
|
|
|
if (rx.flags & IEEE80211_RX_RA_MATCH)
|
|
|
|
ieee80211_rx_michael_mic_report(hdr, &rx);
|
|
|
|
} else
|
|
|
|
prev = rx.sdata;
|
|
|
|
}
|
2009-10-01 22:06:29 +02:00
|
|
|
} else list_for_each_entry_rcu(sdata, &local->interfaces, list) {
|
2007-08-28 23:01:52 +02:00
|
|
|
if (!netif_running(sdata->dev))
|
|
|
|
continue;
|
|
|
|
|
2009-10-01 22:06:29 +02:00
|
|
|
if (sdata->vif.type == NL80211_IFTYPE_MONITOR ||
|
|
|
|
sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
|
2007-09-26 15:19:39 +02:00
|
|
|
continue;
|
|
|
|
|
2008-02-25 16:27:43 +01:00
|
|
|
rx.flags |= IEEE80211_RX_RA_MATCH;
|
2009-02-10 21:25:43 +01:00
|
|
|
prepares = prepare_for_handlers(sdata, &rx, hdr);
|
2007-07-27 15:43:22 +02:00
|
|
|
|
2007-12-24 12:36:39 +01:00
|
|
|
if (!prepares)
|
2007-07-27 15:43:22 +02:00
|
|
|
continue;
|
2007-07-27 15:43:22 +02:00
|
|
|
|
2009-11-16 12:00:39 +01:00
|
|
|
if (status->flag & RX_FLAG_MMIC_ERROR) {
|
|
|
|
rx.sdata = sdata;
|
|
|
|
if (rx.flags & IEEE80211_RX_RA_MATCH)
|
|
|
|
ieee80211_rx_michael_mic_report(hdr, &rx);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2007-07-27 15:43:22 +02:00
|
|
|
/*
|
|
|
|
* frame is destined for this interface, but if it's not
|
|
|
|
* also for the previous one we handle that after the
|
|
|
|
* loop to avoid copying the SKB once too much
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (!prev) {
|
|
|
|
prev = sdata;
|
|
|
|
continue;
|
2007-07-27 15:43:22 +02:00
|
|
|
}
|
2007-07-27 15:43:22 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* frame was destined for the previous interface
|
|
|
|
* so invoke RX handlers for it
|
|
|
|
*/
|
|
|
|
|
|
|
|
skb_new = skb_copy(skb, GFP_ATOMIC);
|
|
|
|
if (!skb_new) {
|
|
|
|
if (net_ratelimit())
|
|
|
|
printk(KERN_DEBUG "%s: failed to copy "
|
2008-05-12 15:02:24 +02:00
|
|
|
"multicast frame for %s\n",
|
2007-09-18 23:29:20 +02:00
|
|
|
wiphy_name(local->hw.wiphy),
|
|
|
|
prev->dev->name);
|
2007-07-27 15:43:22 +02:00
|
|
|
continue;
|
|
|
|
}
|
2009-11-16 13:58:21 +01:00
|
|
|
ieee80211_invoke_rx_handlers(prev, &rx, skb_new, rate);
|
2007-07-27 15:43:22 +02:00
|
|
|
prev = sdata;
|
2007-07-27 15:43:22 +02:00
|
|
|
}
|
2008-07-16 03:44:14 +02:00
|
|
|
if (prev)
|
2009-11-16 13:58:21 +01:00
|
|
|
ieee80211_invoke_rx_handlers(prev, &rx, skb, rate);
|
2008-07-16 03:44:14 +02:00
|
|
|
else
|
2007-07-27 15:43:22 +02:00
|
|
|
dev_kfree_skb(skb);
|
2007-07-27 15:43:22 +02:00
|
|
|
}
|
2007-12-24 12:36:39 +01:00
|
|
|
|
2007-12-25 16:00:35 +01:00
|
|
|
#define SEQ_MODULO 0x1000
|
|
|
|
#define SEQ_MASK 0xfff
|
|
|
|
|
|
|
|
static inline int seq_less(u16 sq1, u16 sq2)
|
|
|
|
{
|
2008-10-07 12:04:32 +02:00
|
|
|
return ((sq1 - sq2) & SEQ_MASK) > (SEQ_MODULO >> 1);
|
2007-12-25 16:00:35 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline u16 seq_inc(u16 sq)
|
|
|
|
{
|
2008-10-07 12:04:32 +02:00
|
|
|
return (sq + 1) & SEQ_MASK;
|
2007-12-25 16:00:35 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline u16 seq_sub(u16 sq1, u16 sq2)
|
|
|
|
{
|
2008-10-07 12:04:32 +02:00
|
|
|
return (sq1 - sq2) & SEQ_MASK;
|
2007-12-25 16:00:35 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-05-05 19:35:13 +02:00
|
|
|
static void ieee80211_release_reorder_frame(struct ieee80211_hw *hw,
|
|
|
|
struct tid_ampdu_rx *tid_agg_rx,
|
|
|
|
int index)
|
|
|
|
{
|
|
|
|
struct ieee80211_supported_band *sband;
|
2009-11-16 13:58:21 +01:00
|
|
|
struct ieee80211_rate *rate = NULL;
|
2009-06-17 13:13:00 +02:00
|
|
|
struct sk_buff *skb = tid_agg_rx->reorder_buf[index];
|
|
|
|
struct ieee80211_rx_status *status;
|
2009-05-05 19:35:13 +02:00
|
|
|
|
2009-06-17 13:13:00 +02:00
|
|
|
if (!skb)
|
2009-05-05 19:35:13 +02:00
|
|
|
goto no_frame;
|
|
|
|
|
2009-06-17 13:13:00 +02:00
|
|
|
status = IEEE80211_SKB_RXCB(skb);
|
|
|
|
|
2009-05-05 19:35:13 +02:00
|
|
|
/* release the reordered frames to stack */
|
2009-06-17 13:13:00 +02:00
|
|
|
sband = hw->wiphy->bands[status->band];
|
2009-11-16 13:58:21 +01:00
|
|
|
if (!(status->flag & RX_FLAG_HT))
|
2009-06-17 13:13:00 +02:00
|
|
|
rate = &sband->bitrates[status->rate_idx];
|
|
|
|
__ieee80211_rx_handle_packet(hw, skb, rate);
|
2009-05-05 19:35:13 +02:00
|
|
|
tid_agg_rx->stored_mpdu_num--;
|
|
|
|
tid_agg_rx->reorder_buf[index] = NULL;
|
|
|
|
|
|
|
|
no_frame:
|
|
|
|
tid_agg_rx->head_seq_num = seq_inc(tid_agg_rx->head_seq_num);
|
|
|
|
}
|
|
|
|
|
2009-11-16 12:00:40 +01:00
|
|
|
static void ieee80211_release_reorder_frames(struct ieee80211_hw *hw,
|
|
|
|
struct tid_ampdu_rx *tid_agg_rx,
|
|
|
|
u16 head_seq_num)
|
|
|
|
{
|
|
|
|
int index;
|
|
|
|
|
|
|
|
while (seq_less(tid_agg_rx->head_seq_num, head_seq_num)) {
|
|
|
|
index = seq_sub(tid_agg_rx->head_seq_num, tid_agg_rx->ssn) %
|
|
|
|
tid_agg_rx->buf_size;
|
|
|
|
ieee80211_release_reorder_frame(hw, tid_agg_rx, index);
|
|
|
|
}
|
|
|
|
}
|
2009-05-05 19:35:13 +02:00
|
|
|
|
2009-05-05 19:35:14 +02:00
|
|
|
/*
|
|
|
|
* Timeout (in jiffies) for skb's that are waiting in the RX reorder buffer. If
|
|
|
|
* the skb was added to the buffer longer than this time ago, the earlier
|
|
|
|
* frames that have not yet been received are assumed to be lost and the skb
|
|
|
|
* can be released for processing. This may also release other skb's from the
|
|
|
|
* reorder buffer if there are no additional gaps between the frames.
|
|
|
|
*/
|
|
|
|
#define HT_RX_REORDER_BUF_TIMEOUT (HZ / 10)
|
|
|
|
|
2007-12-25 16:00:36 +01:00
|
|
|
/*
|
2009-11-16 12:00:40 +01:00
|
|
|
* As this function belongs to the RX path it must be under
|
|
|
|
* rcu_read_lock protection. It returns false if the frame
|
|
|
|
* can be processed immediately, true if it was consumed.
|
2007-12-25 16:00:36 +01:00
|
|
|
*/
|
2009-11-16 12:00:40 +01:00
|
|
|
static bool ieee80211_sta_manage_reorder_buf(struct ieee80211_hw *hw,
|
|
|
|
struct tid_ampdu_rx *tid_agg_rx,
|
|
|
|
struct sk_buff *skb)
|
2007-12-25 16:00:35 +01:00
|
|
|
{
|
2009-11-16 12:00:40 +01:00
|
|
|
struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
|
|
|
|
u16 sc = le16_to_cpu(hdr->seq_ctrl);
|
|
|
|
u16 mpdu_seq_num = (sc & IEEE80211_SCTL_SEQ) >> 4;
|
2007-12-25 16:00:35 +01:00
|
|
|
u16 head_seq_num, buf_size;
|
|
|
|
int index;
|
|
|
|
|
|
|
|
buf_size = tid_agg_rx->buf_size;
|
|
|
|
head_seq_num = tid_agg_rx->head_seq_num;
|
|
|
|
|
|
|
|
/* frame with out of date sequence number */
|
|
|
|
if (seq_less(mpdu_seq_num, head_seq_num)) {
|
|
|
|
dev_kfree_skb(skb);
|
2009-11-16 12:00:40 +01:00
|
|
|
return true;
|
2007-12-25 16:00:35 +01:00
|
|
|
}
|
|
|
|
|
2009-11-16 12:00:40 +01:00
|
|
|
/*
|
|
|
|
* If frame the sequence number exceeds our buffering window
|
|
|
|
* size release some previous frames to make room for this one.
|
|
|
|
*/
|
|
|
|
if (!seq_less(mpdu_seq_num, head_seq_num + buf_size)) {
|
|
|
|
head_seq_num = seq_inc(seq_sub(mpdu_seq_num, buf_size));
|
2007-12-25 16:00:35 +01:00
|
|
|
/* release stored frames up to new head to stack */
|
2009-11-16 12:00:40 +01:00
|
|
|
ieee80211_release_reorder_frames(hw, tid_agg_rx, head_seq_num);
|
2007-12-25 16:00:35 +01:00
|
|
|
}
|
|
|
|
|
2009-11-16 12:00:40 +01:00
|
|
|
/* Now the new frame is always in the range of the reordering buffer */
|
|
|
|
|
|
|
|
index = seq_sub(mpdu_seq_num, tid_agg_rx->ssn) % tid_agg_rx->buf_size;
|
|
|
|
|
2007-12-25 16:00:35 +01:00
|
|
|
/* check if we already stored this frame */
|
|
|
|
if (tid_agg_rx->reorder_buf[index]) {
|
|
|
|
dev_kfree_skb(skb);
|
2009-11-16 12:00:40 +01:00
|
|
|
return true;
|
2007-12-25 16:00:35 +01:00
|
|
|
}
|
|
|
|
|
2009-11-16 12:00:40 +01:00
|
|
|
/*
|
|
|
|
* If the current MPDU is in the right order and nothing else
|
|
|
|
* is stored we can process it directly, no need to buffer it.
|
|
|
|
*/
|
2007-12-25 16:00:35 +01:00
|
|
|
if (mpdu_seq_num == tid_agg_rx->head_seq_num &&
|
2009-11-16 12:00:40 +01:00
|
|
|
tid_agg_rx->stored_mpdu_num == 0) {
|
|
|
|
tid_agg_rx->head_seq_num = seq_inc(tid_agg_rx->head_seq_num);
|
|
|
|
return false;
|
2007-12-25 16:00:35 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* put the frame in the reordering buffer */
|
|
|
|
tid_agg_rx->reorder_buf[index] = skb;
|
2009-05-05 19:35:14 +02:00
|
|
|
tid_agg_rx->reorder_time[index] = jiffies;
|
2007-12-25 16:00:35 +01:00
|
|
|
tid_agg_rx->stored_mpdu_num++;
|
|
|
|
/* release the buffer until next missing frame */
|
2009-11-16 12:00:40 +01:00
|
|
|
index = seq_sub(tid_agg_rx->head_seq_num, tid_agg_rx->ssn) %
|
|
|
|
tid_agg_rx->buf_size;
|
2009-05-05 19:35:14 +02:00
|
|
|
if (!tid_agg_rx->reorder_buf[index] &&
|
|
|
|
tid_agg_rx->stored_mpdu_num > 1) {
|
|
|
|
/*
|
|
|
|
* No buffers ready to be released, but check whether any
|
|
|
|
* frames in the reorder buffer have timed out.
|
|
|
|
*/
|
|
|
|
int j;
|
|
|
|
int skipped = 1;
|
|
|
|
for (j = (index + 1) % tid_agg_rx->buf_size; j != index;
|
|
|
|
j = (j + 1) % tid_agg_rx->buf_size) {
|
2009-11-16 12:00:40 +01:00
|
|
|
if (!tid_agg_rx->reorder_buf[j]) {
|
2009-05-05 19:35:14 +02:00
|
|
|
skipped++;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (!time_after(jiffies, tid_agg_rx->reorder_time[j] +
|
2009-11-16 12:00:40 +01:00
|
|
|
HT_RX_REORDER_BUF_TIMEOUT))
|
2009-05-05 19:35:14 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
#ifdef CONFIG_MAC80211_HT_DEBUG
|
|
|
|
if (net_ratelimit())
|
|
|
|
printk(KERN_DEBUG "%s: release an RX reorder "
|
|
|
|
"frame due to timeout on earlier "
|
|
|
|
"frames\n",
|
|
|
|
wiphy_name(hw->wiphy));
|
|
|
|
#endif
|
|
|
|
ieee80211_release_reorder_frame(hw, tid_agg_rx, j);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Increment the head seq# also for the skipped slots.
|
|
|
|
*/
|
|
|
|
tid_agg_rx->head_seq_num =
|
2009-11-16 12:00:40 +01:00
|
|
|
(tid_agg_rx->head_seq_num + skipped) & SEQ_MASK;
|
2009-05-05 19:35:14 +02:00
|
|
|
skipped = 0;
|
|
|
|
}
|
|
|
|
} else while (tid_agg_rx->reorder_buf[index]) {
|
2009-05-05 19:35:13 +02:00
|
|
|
ieee80211_release_reorder_frame(hw, tid_agg_rx, index);
|
2009-11-16 12:00:40 +01:00
|
|
|
index = seq_sub(tid_agg_rx->head_seq_num, tid_agg_rx->ssn) %
|
|
|
|
tid_agg_rx->buf_size;
|
2007-12-25 16:00:35 +01:00
|
|
|
}
|
2009-11-16 12:00:40 +01:00
|
|
|
|
|
|
|
return true;
|
2007-12-25 16:00:35 +01:00
|
|
|
}
|
|
|
|
|
2009-11-16 12:00:40 +01:00
|
|
|
/*
|
|
|
|
* Reorder MPDUs from A-MPDUs, keeping them on a buffer. Returns
|
|
|
|
* true if the MPDU was buffered, false if it should be processed.
|
|
|
|
*/
|
|
|
|
static bool ieee80211_rx_reorder_ampdu(struct ieee80211_local *local,
|
|
|
|
struct sk_buff *skb)
|
2007-12-25 16:00:35 +01:00
|
|
|
{
|
|
|
|
struct ieee80211_hw *hw = &local->hw;
|
|
|
|
struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
|
|
|
|
struct sta_info *sta;
|
|
|
|
struct tid_ampdu_rx *tid_agg_rx;
|
2008-06-11 23:21:59 +02:00
|
|
|
u16 sc;
|
2007-12-25 16:00:35 +01:00
|
|
|
int tid;
|
|
|
|
|
2009-11-16 12:00:40 +01:00
|
|
|
if (!ieee80211_is_data_qos(hdr->frame_control))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* filter the QoS data rx stream according to
|
|
|
|
* STA/TID and check if this STA/TID is on aggregation
|
|
|
|
*/
|
|
|
|
|
2007-12-25 16:00:35 +01:00
|
|
|
sta = sta_info_get(local, hdr->addr2);
|
|
|
|
if (!sta)
|
2009-11-16 12:00:40 +01:00
|
|
|
return false;
|
2007-12-25 16:00:35 +01:00
|
|
|
|
2008-07-02 20:05:34 +02:00
|
|
|
tid = *ieee80211_get_qos_ctl(hdr) & IEEE80211_QOS_CTL_TID_MASK;
|
2007-12-25 16:00:35 +01:00
|
|
|
|
2008-03-26 19:36:03 +01:00
|
|
|
if (sta->ampdu_mlme.tid_state_rx[tid] != HT_AGG_STATE_OPERATIONAL)
|
2009-11-16 12:00:40 +01:00
|
|
|
return false;
|
2007-12-25 16:00:35 +01:00
|
|
|
|
2008-03-26 19:36:03 +01:00
|
|
|
tid_agg_rx = sta->ampdu_mlme.tid_rx[tid];
|
|
|
|
|
2008-07-09 23:47:19 +02:00
|
|
|
/* qos null data frames are excluded */
|
|
|
|
if (unlikely(hdr->frame_control & cpu_to_le16(IEEE80211_STYPE_NULLFUNC)))
|
2009-11-16 12:00:40 +01:00
|
|
|
return false;
|
2007-12-25 16:00:35 +01:00
|
|
|
|
2009-11-16 12:00:40 +01:00
|
|
|
/* new, potentially un-ordered, ampdu frame - process it */
|
2007-12-25 16:00:35 +01:00
|
|
|
|
|
|
|
/* reset session timer */
|
2009-02-10 21:25:45 +01:00
|
|
|
if (tid_agg_rx->timeout)
|
|
|
|
mod_timer(&tid_agg_rx->session_timer,
|
|
|
|
TU_TO_EXP_TIME(tid_agg_rx->timeout));
|
2007-12-25 16:00:35 +01:00
|
|
|
|
|
|
|
/* if this mpdu is fragmented - terminate rx aggregation session */
|
|
|
|
sc = le16_to_cpu(hdr->seq_ctrl);
|
|
|
|
if (sc & IEEE80211_SCTL_FRAG) {
|
2008-09-11 00:02:02 +02:00
|
|
|
ieee80211_sta_stop_rx_ba_session(sta->sdata, sta->sta.addr,
|
2007-12-25 16:00:35 +01:00
|
|
|
tid, 0, WLAN_REASON_QSTA_REQUIRE_SETUP);
|
2009-11-16 12:00:40 +01:00
|
|
|
dev_kfree_skb(skb);
|
|
|
|
return true;
|
2007-12-25 16:00:35 +01:00
|
|
|
}
|
|
|
|
|
2009-11-16 12:00:40 +01:00
|
|
|
return ieee80211_sta_manage_reorder_buf(hw, tid_agg_rx, skb);
|
2007-12-25 16:00:35 +01:00
|
|
|
}
|
|
|
|
|
2007-12-24 12:36:39 +01:00
|
|
|
/*
|
|
|
|
* This is the receive path handler. It is called by a low level driver when an
|
|
|
|
* 802.11 MPDU is received from the hardware.
|
|
|
|
*/
|
2009-08-20 22:34:15 +02:00
|
|
|
void ieee80211_rx(struct ieee80211_hw *hw, struct sk_buff *skb)
|
2007-12-24 12:36:39 +01:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
2008-01-24 19:38:38 +01:00
|
|
|
struct ieee80211_rate *rate = NULL;
|
|
|
|
struct ieee80211_supported_band *sband;
|
2009-06-17 13:13:00 +02:00
|
|
|
struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
|
2008-01-24 19:38:38 +01:00
|
|
|
|
2009-10-11 15:10:40 +02:00
|
|
|
WARN_ON_ONCE(softirq_count() == 0);
|
|
|
|
|
2009-08-24 11:46:30 +02:00
|
|
|
if (WARN_ON(status->band < 0 ||
|
|
|
|
status->band >= IEEE80211_NUM_BANDS))
|
|
|
|
goto drop;
|
2008-01-24 19:38:38 +01:00
|
|
|
|
|
|
|
sband = local->hw.wiphy->bands[status->band];
|
2009-08-24 11:46:30 +02:00
|
|
|
if (WARN_ON(!sband))
|
|
|
|
goto drop;
|
2008-01-24 19:38:38 +01:00
|
|
|
|
2009-07-28 18:10:17 +02:00
|
|
|
/*
|
|
|
|
* If we're suspending, it is possible although not too likely
|
|
|
|
* that we'd be receiving frames after having already partially
|
|
|
|
* quiesced the stack. We can't process such frames then since
|
|
|
|
* that might, for example, cause stations to be added or other
|
|
|
|
* driver callbacks be invoked.
|
|
|
|
*/
|
2009-08-24 11:46:30 +02:00
|
|
|
if (unlikely(local->quiescing || local->suspended))
|
|
|
|
goto drop;
|
2009-07-28 18:10:17 +02:00
|
|
|
|
2009-08-21 14:44:45 +02:00
|
|
|
/*
|
|
|
|
* The same happens when we're not even started,
|
|
|
|
* but that's worth a warning.
|
|
|
|
*/
|
2009-08-24 11:46:30 +02:00
|
|
|
if (WARN_ON(!local->started))
|
|
|
|
goto drop;
|
2009-08-21 14:44:45 +02:00
|
|
|
|
2008-12-12 13:38:33 +01:00
|
|
|
if (status->flag & RX_FLAG_HT) {
|
2009-11-09 22:03:22 +01:00
|
|
|
/*
|
|
|
|
* rate_idx is MCS index, which can be [0-76] as documented on:
|
|
|
|
*
|
|
|
|
* http://wireless.kernel.org/en/developers/Documentation/ieee80211/802.11n
|
|
|
|
*
|
|
|
|
* Anything else would be some sort of driver or hardware error.
|
|
|
|
* The driver should catch hardware errors.
|
|
|
|
*/
|
|
|
|
if (WARN((status->rate_idx < 0 ||
|
|
|
|
status->rate_idx > 76),
|
|
|
|
"Rate marked as an HT rate but passed "
|
|
|
|
"status->rate_idx is not "
|
|
|
|
"an MCS index [0-76]: %d (0x%02x)\n",
|
|
|
|
status->rate_idx,
|
|
|
|
status->rate_idx))
|
2009-08-24 11:46:30 +02:00
|
|
|
goto drop;
|
2008-12-12 13:38:33 +01:00
|
|
|
} else {
|
|
|
|
if (WARN_ON(status->rate_idx < 0 ||
|
|
|
|
status->rate_idx >= sband->n_bitrates))
|
2009-08-24 11:46:30 +02:00
|
|
|
goto drop;
|
2008-12-12 13:38:33 +01:00
|
|
|
rate = &sband->bitrates[status->rate_idx];
|
|
|
|
}
|
2007-12-24 12:36:39 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* key references and virtual interfaces are protected using RCU
|
|
|
|
* and this requires that we are in a read-side RCU section during
|
|
|
|
* receive processing
|
|
|
|
*/
|
|
|
|
rcu_read_lock();
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Frames with failed FCS/PLCP checksum are not returned,
|
|
|
|
* all other frames are returned without radiotap header
|
|
|
|
* if it was previously present.
|
|
|
|
* Also, frames with less than 16 bytes are dropped.
|
|
|
|
*/
|
2009-06-17 13:13:00 +02:00
|
|
|
skb = ieee80211_rx_monitor(local, skb, rate);
|
2007-12-24 12:36:39 +01:00
|
|
|
if (!skb) {
|
|
|
|
rcu_read_unlock();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-05-05 19:35:15 +02:00
|
|
|
/*
|
|
|
|
* In theory, the block ack reordering should happen after duplicate
|
|
|
|
* removal (ieee80211_rx_h_check(), which is an RX handler). As such,
|
|
|
|
* the call to ieee80211_rx_reorder_ampdu() should really be moved to
|
|
|
|
* happen as a new RX handler between ieee80211_rx_h_check and
|
|
|
|
* ieee80211_rx_h_decrypt. This cleanup may eventually happen, but for
|
|
|
|
* the time being, the call can be here since RX reorder buf processing
|
|
|
|
* will implicitly skip duplicates. We could, in theory at least,
|
|
|
|
* process frames that ieee80211_rx_h_passive_scan would drop (e.g.,
|
|
|
|
* frames from other than operational channel), but that should not
|
|
|
|
* happen in normal networks.
|
|
|
|
*/
|
2009-06-17 13:13:00 +02:00
|
|
|
if (!ieee80211_rx_reorder_ampdu(local, skb))
|
|
|
|
__ieee80211_rx_handle_packet(hw, skb, rate);
|
2007-12-24 12:36:39 +01:00
|
|
|
|
|
|
|
rcu_read_unlock();
|
2009-08-24 11:46:30 +02:00
|
|
|
|
|
|
|
return;
|
|
|
|
drop:
|
|
|
|
kfree_skb(skb);
|
2007-12-24 12:36:39 +01:00
|
|
|
}
|
2009-08-20 22:34:15 +02:00
|
|
|
EXPORT_SYMBOL(ieee80211_rx);
|
2007-07-27 15:43:22 +02:00
|
|
|
|
|
|
|
/* This is a version of the rx handler that can be called from hard irq
|
|
|
|
* context. Post the skb on the queue and schedule the tasklet */
|
2009-06-17 13:13:00 +02:00
|
|
|
void ieee80211_rx_irqsafe(struct ieee80211_hw *hw, struct sk_buff *skb)
|
2007-07-27 15:43:22 +02:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
|
|
|
|
|
|
BUILD_BUG_ON(sizeof(struct ieee80211_rx_status) > sizeof(skb->cb));
|
|
|
|
|
|
|
|
skb->pkt_type = IEEE80211_RX_MSG;
|
|
|
|
skb_queue_tail(&local->skb_queue, skb);
|
|
|
|
tasklet_schedule(&local->tasklet);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_rx_irqsafe);
|