[mirror_ubuntu-artful-kernel.git] / net / ieee80211 / ieee80211_tx.c

/******************************************************************************

  Copyright(c) 2003 - 2005 Intel Corporation. All rights reserved.

  This program is free software; you can redistribute it and/or modify it
  under the terms of version 2 of the GNU General Public License as
  published by the Free Software Foundation.

  This program is distributed in the hope that it will be useful, but WITHOUT
  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  more details.

  You should have received a copy of the GNU General Public License along with
  this program; if not, write to the Free Software Foundation, Inc., 59
  Temple Place - Suite 330, Boston, MA  02111-1307, USA.

  The full GNU General Public License is included in this distribution in the
  file called LICENSE.

  Contact Information:
  James P. Ketrenos <ipw2100-admin@linux.intel.com>
  Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497

******************************************************************************/
#include <linux/compiler.h>
#include <linux/config.h>
#include <linux/errno.h>
#include <linux/if_arp.h>
#include <linux/in6.h>
#include <linux/in.h>
#include <linux/ip.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/netdevice.h>
#include <linux/proc_fs.h>
#include <linux/skbuff.h>
#include <linux/slab.h>
#include <linux/tcp.h>
#include <linux/types.h>
#include <linux/wireless.h>
#include <linux/etherdevice.h>
#include <asm/uaccess.h>

#include <net/ieee80211.h>

/*

802.11 Data Frame

      ,-------------------------------------------------------------------.
Bytes |  2   |  2   |    6    |    6    |    6    |  2   | 0..2312 |   4  |
      |------|------|---------|---------|---------|------|---------|------|
Desc. | ctrl | dura |  DA/RA  |   TA    |    SA   | Sequ |  Frame  |  fcs |
      |      | tion | (BSSID) |         |         | ence |  data   |      |
      `--------------------------------------------------|         |------'
Total: 28 non-data bytes                                 `----.----'
                                                              |
       .- 'Frame data' expands, if WEP enabled, to <----------'
       |
       V
      ,-----------------------.
Bytes |  4  |   0-2296  |  4  |
      |-----|-----------|-----|
Desc. | IV  | Encrypted | ICV |
      |     | Packet    |     |
      `-----|           |-----'
            `-----.-----'
                  |
       .- 'Encrypted Packet' expands to
       |
       V
      ,---------------------------------------------------.
Bytes |  1   |  1   |    1    |    3     |  2   |  0-2304 |
      |------|------|---------|----------|------|---------|
Desc. | SNAP | SNAP | Control |Eth Tunnel| Type | IP      |
      | DSAP | SSAP |         |          |      | Packet  |
      | 0xAA | 0xAA |0x03 (UI)|0x00-00-F8|      |         |
      `----------------------------------------------------
Total: 8 non-data bytes

802.3 Ethernet Data Frame

      ,-----------------------------------------.
Bytes |   6   |   6   |  2   |  Variable |   4  |
      |-------|-------|------|-----------|------|
Desc. | Dest. | Source| Type | IP Packet |  fcs |
      |  MAC  |  MAC  |      |           |      |
      `-----------------------------------------'
Total: 18 non-data bytes

In the event that fragmentation is required, the incoming payload is split into
N parts of size ieee->fts.  The first fragment contains the SNAP header and the
remaining packets are just data.

If encryption is enabled, each fragment payload size is reduced by enough space
to add the prefix and postfix (IV and ICV totalling 8 bytes in the case of WEP)
So if you have 1500 bytes of payload with ieee->fts set to 500 without
encryption it will take 3 frames.  With WEP it will take 4 frames as the
payload of each frame is reduced to 492 bytes.

* SKB visualization
*
*  ,- skb->data
* |
* |    ETHERNET HEADER        ,-<-- PAYLOAD
* |                           |     14 bytes from skb->data
* |  2 bytes for Type --> ,T. |     (sizeof ethhdr)
* |                       | | |
* |,-Dest.--. ,--Src.---. | | |
* |  6 bytes| | 6 bytes | | | |
* v         | |         | | | |
* 0         | v       1 | v | v           2
* 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5
*     ^     | ^         | ^ |
*     |     | |         | | |
*     |     | |         | `T' <---- 2 bytes for Type
*     |     | |         |
*     |     | '---SNAP--' <-------- 6 bytes for SNAP
*     |     |
*     `-IV--' <-------------------- 4 bytes for IV (WEP)
*
*      SNAP HEADER
*
*/

static u8 P802_1H_OUI[P80211_OUI_LEN] = { 0x00, 0x00, 0xf8 };
static u8 RFC1042_OUI[P80211_OUI_LEN] = { 0x00, 0x00, 0x00 };

static int ieee80211_copy_snap(u8 * data, u16 h_proto)
{
	struct ieee80211_snap_hdr *snap;
	u8 *oui;

	snap = (struct ieee80211_snap_hdr *)data;
	snap->dsap = 0xaa;
	snap->ssap = 0xaa;
	snap->ctrl = 0x03;

	if (h_proto == 0x8137 || h_proto == 0x80f3)
		oui = P802_1H_OUI;
	else
		oui = RFC1042_OUI;
	snap->oui[0] = oui[0];
	snap->oui[1] = oui[1];
	snap->oui[2] = oui[2];

	*(u16 *) (data + SNAP_SIZE) = htons(h_proto);

	return SNAP_SIZE + sizeof(u16);
}

static int ieee80211_encrypt_fragment(struct ieee80211_device *ieee,
					     struct sk_buff *frag, int hdr_len)
{
	struct ieee80211_crypt_data *crypt = ieee->crypt[ieee->tx_keyidx];
	int res;

	if (crypt == NULL)
		return -1;

	/* To encrypt, frame format is:
	 * IV (4 bytes), clear payload (including SNAP), ICV (4 bytes) */
	atomic_inc(&crypt->refcnt);
	res = 0;
	if (crypt->ops && crypt->ops->encrypt_mpdu)
		res = crypt->ops->encrypt_mpdu(frag, hdr_len, crypt->priv);

	atomic_dec(&crypt->refcnt);
	if (res < 0) {
		printk(KERN_INFO "%s: Encryption failed: len=%d.\n",
		       ieee->dev->name, frag->len);
		ieee->ieee_stats.tx_discards++;
		return -1;
	}

	return 0;
}

void ieee80211_txb_free(struct ieee80211_txb *txb)
{
	int i;
	if (unlikely(!txb))
		return;
	for (i = 0; i < txb->nr_frags; i++)
		if (txb->fragments[i])
			dev_kfree_skb_any(txb->fragments[i]);
	kfree(txb);
}

static struct ieee80211_txb *ieee80211_alloc_txb(int nr_frags, int txb_size,
						 int headroom, gfp_t gfp_mask)
{
	struct ieee80211_txb *txb;
	int i;
	txb = kmalloc(sizeof(struct ieee80211_txb) + (sizeof(u8 *) * nr_frags),
		      gfp_mask);
	if (!txb)
		return NULL;

	memset(txb, 0, sizeof(struct ieee80211_txb));
	txb->nr_frags = nr_frags;
	txb->frag_size = txb_size;

	for (i = 0; i < nr_frags; i++) {
		txb->fragments[i] = __dev_alloc_skb(txb_size + headroom,
						    gfp_mask);
		if (unlikely(!txb->fragments[i])) {
			i--;
			break;
		}
		skb_reserve(txb->fragments[i], headroom);
	}
	if (unlikely(i != nr_frags)) {
		while (i >= 0)
			dev_kfree_skb_any(txb->fragments[i--]);
		kfree(txb);
		return NULL;
	}
	return txb;
}

/* Incoming skb is converted to a txb which consists of
 * a block of 802.11 fragment packets (stored as skbs) */
int ieee80211_xmit(struct sk_buff *skb, struct net_device *dev)
{
	struct ieee80211_device *ieee = netdev_priv(dev);
	struct ieee80211_txb *txb = NULL;
	struct ieee80211_hdr_3addr *frag_hdr;
	int i, bytes_per_frag, nr_frags, bytes_last_frag, frag_size,
	    rts_required;
	unsigned long flags;
	struct net_device_stats *stats = &ieee->stats;
	int ether_type, encrypt, host_encrypt, host_encrypt_msdu, host_build_iv;
	int bytes, fc, hdr_len;
	struct sk_buff *skb_frag;
	struct ieee80211_hdr_3addr header = {	/* Ensure zero initialized */
		.duration_id = 0,
		.seq_ctl = 0
	};
	u8 dest[ETH_ALEN], src[ETH_ALEN];
	struct ieee80211_crypt_data *crypt;
	int priority = skb->priority;
	int snapped = 0;

	if (ieee->is_queue_full && (*ieee->is_queue_full) (dev, priority))
		return NETDEV_TX_BUSY;

	spin_lock_irqsave(&ieee->lock, flags);

	/* If there is no driver handler to take the TXB, dont' bother
	 * creating it... */
	if (!ieee->hard_start_xmit) {
		printk(KERN_WARNING "%s: No xmit handler.\n", ieee->dev->name);
		goto success;
	}

	if (unlikely(skb->len < SNAP_SIZE + sizeof(u16))) {
		printk(KERN_WARNING "%s: skb too small (%d).\n",
		       ieee->dev->name, skb->len);
		goto success;
	}

	ether_type = ntohs(((struct ethhdr *)skb->data)->h_proto);

	crypt = ieee->crypt[ieee->tx_keyidx];

	encrypt = !(ether_type == ETH_P_PAE && ieee->ieee802_1x) &&
	    ieee->sec.encrypt;

	host_encrypt = ieee->host_encrypt && encrypt && crypt;
	host_encrypt_msdu = ieee->host_encrypt_msdu && encrypt && crypt;
	host_build_iv = ieee->host_build_iv && encrypt && crypt;

	if (!encrypt && ieee->ieee802_1x &&
	    ieee->drop_unencrypted && ether_type != ETH_P_PAE) {
		stats->tx_dropped++;
		goto success;
	}

	/* Save source and destination addresses */
	memcpy(dest, skb->data, ETH_ALEN);
	memcpy(src, skb->data + ETH_ALEN, ETH_ALEN);

	/* Advance the SKB to the start of the payload */
	skb_pull(skb, sizeof(struct ethhdr));

	/* Determine total amount of storage required for TXB packets */
	bytes = skb->len + SNAP_SIZE + sizeof(u16);

	if (host_encrypt || host_build_iv)
		fc = IEEE80211_FTYPE_DATA | IEEE80211_STYPE_DATA |
		    IEEE80211_FCTL_PROTECTED;
	else
		fc = IEEE80211_FTYPE_DATA | IEEE80211_STYPE_DATA;

	if (ieee->iw_mode == IW_MODE_INFRA) {
		fc |= IEEE80211_FCTL_TODS;
		/* To DS: Addr1 = BSSID, Addr2 = SA, Addr3 = DA */
		memcpy(header.addr1, ieee->bssid, ETH_ALEN);
		memcpy(header.addr2, src, ETH_ALEN);
		memcpy(header.addr3, dest, ETH_ALEN);
	} else if (ieee->iw_mode == IW_MODE_ADHOC) {
		/* not From/To DS: Addr1 = DA, Addr2 = SA, Addr3 = BSSID */
		memcpy(header.addr1, dest, ETH_ALEN);
		memcpy(header.addr2, src, ETH_ALEN);
		memcpy(header.addr3, ieee->bssid, ETH_ALEN);
	}
	header.frame_ctl = cpu_to_le16(fc);
	hdr_len = IEEE80211_3ADDR_LEN;

	/* Encrypt msdu first on the whole data packet. */
	if ((host_encrypt || host_encrypt_msdu) &&
	    crypt && crypt->ops && crypt->ops->encrypt_msdu) {
		int res = 0;
		int len = bytes + hdr_len + crypt->ops->extra_msdu_prefix_len +
		    crypt->ops->extra_msdu_postfix_len;
		struct sk_buff *skb_new = dev_alloc_skb(len);

		if (unlikely(!skb_new))
			goto failed;

		skb_reserve(skb_new, crypt->ops->extra_msdu_prefix_len);
		memcpy(skb_put(skb_new, hdr_len), &header, hdr_len);
		snapped = 1;
		ieee80211_copy_snap(skb_put(skb_new, SNAP_SIZE + sizeof(u16)),
				    ether_type);
		memcpy(skb_put(skb_new, skb->len), skb->data, skb->len);
		res = crypt->ops->encrypt_msdu(skb_new, hdr_len, crypt->priv);
		if (res < 0) {
			IEEE80211_ERROR("msdu encryption failed\n");
			dev_kfree_skb_any(skb_new);
			goto failed;
		}
		dev_kfree_skb_any(skb);
		skb = skb_new;
		bytes += crypt->ops->extra_msdu_prefix_len +
		    crypt->ops->extra_msdu_postfix_len;
		skb_pull(skb, hdr_len);
	}

	if (host_encrypt || ieee->host_open_frag) {
		/* Determine fragmentation size based on destination (multicast
		 * and broadcast are not fragmented) */
		if (is_multicast_ether_addr(dest) ||
		    is_broadcast_ether_addr(dest))
			frag_size = MAX_FRAG_THRESHOLD;
		else
			frag_size = ieee->fts;

		/* Determine amount of payload per fragment.  Regardless of if
		 * this stack is providing the full 802.11 header, one will
		 * eventually be affixed to this fragment -- so we must account
		 * for it when determining the amount of payload space. */
		bytes_per_frag = frag_size - IEEE80211_3ADDR_LEN;
		if (ieee->config &
		    (CFG_IEEE80211_COMPUTE_FCS | CFG_IEEE80211_RESERVE_FCS))
			bytes_per_frag -= IEEE80211_FCS_LEN;

		/* Each fragment may need to have room for encryptiong
		 * pre/postfix */
		if (host_encrypt)
			bytes_per_frag -= crypt->ops->extra_mpdu_prefix_len +
			    crypt->ops->extra_mpdu_postfix_len;

		/* Number of fragments is the total
		 * bytes_per_frag / payload_per_fragment */
		nr_frags = bytes / bytes_per_frag;
		bytes_last_frag = bytes % bytes_per_frag;
		if (bytes_last_frag)
			nr_frags++;
		else
			bytes_last_frag = bytes_per_frag;
	} else {
		nr_frags = 1;
		bytes_per_frag = bytes_last_frag = bytes;
		frag_size = bytes + IEEE80211_3ADDR_LEN;
	}

	rts_required = (frag_size > ieee->rts
			&& ieee->config & CFG_IEEE80211_RTS);
	if (rts_required)
		nr_frags++;

	/* When we allocate the TXB we allocate enough space for the reserve
	 * and full fragment bytes (bytes_per_frag doesn't include prefix,
	 * postfix, header, FCS, etc.) */
	txb = ieee80211_alloc_txb(nr_frags, frag_size,
				  ieee->tx_headroom, GFP_ATOMIC);
	if (unlikely(!txb)) {
		printk(KERN_WARNING "%s: Could not allocate TXB\n",
		       ieee->dev->name);
		goto failed;
	}
	txb->encrypted = encrypt;
	if (host_encrypt)
		txb->payload_size = frag_size * (nr_frags - 1) +
		    bytes_last_frag;
	else
		txb->payload_size = bytes;

	if (rts_required) {
		skb_frag = txb->fragments[0];
		frag_hdr =
		    (struct ieee80211_hdr_3addr *)skb_put(skb_frag, hdr_len);

		/*
		 * Set header frame_ctl to the RTS.
		 */
		header.frame_ctl =
		    cpu_to_le16(IEEE80211_FTYPE_CTL | IEEE80211_STYPE_RTS);
		memcpy(frag_hdr, &header, hdr_len);

		/*
		 * Restore header frame_ctl to the original data setting.
		 */
		header.frame_ctl = cpu_to_le16(fc);

		if (ieee->config &
		    (CFG_IEEE80211_COMPUTE_FCS | CFG_IEEE80211_RESERVE_FCS))
			skb_put(skb_frag, 4);

		txb->rts_included = 1;
		i = 1;
	} else
		i = 0;

	for (; i < nr_frags; i++) {
		skb_frag = txb->fragments[i];

		if (host_encrypt || host_build_iv)
			skb_reserve(skb_frag,
				    crypt->ops->extra_mpdu_prefix_len);

		frag_hdr =
		    (struct ieee80211_hdr_3addr *)skb_put(skb_frag, hdr_len);
		memcpy(frag_hdr, &header, hdr_len);

		/* If this is not the last fragment, then add the MOREFRAGS
		 * bit to the frame control */
		if (i != nr_frags - 1) {
			frag_hdr->frame_ctl =
			    cpu_to_le16(fc | IEEE80211_FCTL_MOREFRAGS);
			bytes = bytes_per_frag;
		} else {
			/* The last fragment takes the remaining length */
			bytes = bytes_last_frag;
		}

		if (i == 0 && !snapped) {
			ieee80211_copy_snap(skb_put
					    (skb_frag, SNAP_SIZE + sizeof(u16)),
					    ether_type);
			bytes -= SNAP_SIZE + sizeof(u16);
		}

		memcpy(skb_put(skb_frag, bytes), skb->data, bytes);

		/* Advance the SKB... */
		skb_pull(skb, bytes);

		/* Encryption routine will move the header forward in order
		 * to insert the IV between the header and the payload */
		if (host_encrypt)
			ieee80211_encrypt_fragment(ieee, skb_frag, hdr_len);
		else if (host_build_iv) {
			struct ieee80211_crypt_data *crypt;

			crypt = ieee->crypt[ieee->tx_keyidx];
			atomic_inc(&crypt->refcnt);
			if (crypt->ops->build_iv)
				crypt->ops->build_iv(skb_frag, hdr_len,
				      ieee->sec.keys[ieee->sec.active_key],
				      ieee->sec.key_sizes[ieee->sec.active_key],
				      crypt->priv);
			atomic_dec(&crypt->refcnt);
		}

		if (ieee->config &
		    (CFG_IEEE80211_COMPUTE_FCS | CFG_IEEE80211_RESERVE_FCS))
			skb_put(skb_frag, 4);
	}

      success:
	spin_unlock_irqrestore(&ieee->lock, flags);

	dev_kfree_skb_any(skb);

	if (txb) {
		int ret = (*ieee->hard_start_xmit) (txb, dev, priority);
		if (ret == 0) {
			stats->tx_packets++;
			stats->tx_bytes += txb->payload_size;
			return 0;
		}

		if (ret == NETDEV_TX_BUSY) {
			printk(KERN_ERR "%s: NETDEV_TX_BUSY returned; "
			       "driver should report queue full via "
			       "ieee_device->is_queue_full.\n",
			       ieee->dev->name);
		}

		ieee80211_txb_free(txb);
	}

	return 0;

      failed:
	spin_unlock_irqrestore(&ieee->lock, flags);
	netif_stop_queue(dev);
	stats->tx_errors++;
	return 1;
}

/* Incoming 802.11 strucure is converted to a TXB
 * a block of 802.11 fragment packets (stored as skbs) */
int ieee80211_tx_frame(struct ieee80211_device *ieee,
		       struct ieee80211_hdr *frame, int len)
{
	struct ieee80211_txb *txb = NULL;
	unsigned long flags;
	struct net_device_stats *stats = &ieee->stats;
	struct sk_buff *skb_frag;
	int priority = -1;

	spin_lock_irqsave(&ieee->lock, flags);

	/* If there is no driver handler to take the TXB, dont' bother
	 * creating it... */
	if (!ieee->hard_start_xmit) {
		printk(KERN_WARNING "%s: No xmit handler.\n", ieee->dev->name);
		goto success;
	}

	if (unlikely(len < 24)) {
		printk(KERN_WARNING "%s: skb too small (%d).\n",
		       ieee->dev->name, len);
		goto success;
	}

	/* When we allocate the TXB we allocate enough space for the reserve
	 * and full fragment bytes (bytes_per_frag doesn't include prefix,
	 * postfix, header, FCS, etc.) */
	txb = ieee80211_alloc_txb(1, len, ieee->tx_headroom, GFP_ATOMIC);
	if (unlikely(!txb)) {
		printk(KERN_WARNING "%s: Could not allocate TXB\n",
		       ieee->dev->name);
		goto failed;
	}
	txb->encrypted = 0;
	txb->payload_size = len;

	skb_frag = txb->fragments[0];

	memcpy(skb_put(skb_frag, len), frame, len);

	if (ieee->config &
	    (CFG_IEEE80211_COMPUTE_FCS | CFG_IEEE80211_RESERVE_FCS))
		skb_put(skb_frag, 4);

      success:
	spin_unlock_irqrestore(&ieee->lock, flags);

	if (txb) {
		if ((*ieee->hard_start_xmit) (txb, ieee->dev, priority) == 0) {
			stats->tx_packets++;
			stats->tx_bytes += txb->payload_size;
			return 0;
		}
		ieee80211_txb_free(txb);
	}
	return 0;

      failed:
	spin_unlock_irqrestore(&ieee->lock, flags);
	stats->tx_errors++;
	return 1;
}

EXPORT_SYMBOL(ieee80211_tx_frame);
EXPORT_SYMBOL(ieee80211_txb_free);
Commit	Line	Data
b453872c JG	1	/******************************************************************************
b453872c JG	2
ebeaddcc	3	Copyright(c) 2003 - 2005 Intel Corporation. All rights reserved.
b453872c JG	4
	5	This program is free software; you can redistribute it and/or modify it
	6	under the terms of version 2 of the GNU General Public License as
	7	published by the Free Software Foundation.
	8
	9	This program is distributed in the hope that it will be useful, but WITHOUT
	10	ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	11	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	12	more details.
	13
	14	You should have received a copy of the GNU General Public License along with
	15	this program; if not, write to the Free Software Foundation, Inc., 59
	16	Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	17
	18	The full GNU General Public License is included in this distribution in the
	19	file called LICENSE.
	20
	21	Contact Information:
	22	James P. Ketrenos <ipw2100-admin@linux.intel.com>
	23	Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
	24
	25	******************************************************************************/
	26	#include <linux/compiler.h>
	27	#include <linux/config.h>
	28	#include <linux/errno.h>
	29	#include <linux/if_arp.h>
	30	#include <linux/in6.h>
	31	#include <linux/in.h>
	32	#include <linux/ip.h>
	33	#include <linux/kernel.h>
	34	#include <linux/module.h>
	35	#include <linux/netdevice.h>
b453872c JG	36	#include <linux/proc_fs.h>
	37	#include <linux/skbuff.h>
	38	#include <linux/slab.h>
	39	#include <linux/tcp.h>
	40	#include <linux/types.h>
b453872c JG	41	#include <linux/wireless.h>
	42	#include <linux/etherdevice.h>
	43	#include <asm/uaccess.h>
	44
	45	#include <net/ieee80211.h>
	46
b453872c JG	47	/*
b453872c JG	48
b453872c JG	49	802.11 Data Frame
	50
	51	,-------------------------------------------------------------------.
	52	Bytes \| 2 \| 2 \| 6 \| 6 \| 6 \| 2 \| 0..2312 \| 4 \|
	53	\|------\|------\|---------\|---------\|---------\|------\|---------\|------\|
	54	Desc. \| ctrl \| dura \| DA/RA \| TA \| SA \| Sequ \| Frame \| fcs \|
	55	\| \| tion \| (BSSID) \| \| \| ence \| data \| \|
	56	`--------------------------------------------------\| \|------'
	57	Total: 28 non-data bytes `----.----'
	58	\|
44d7a8cf DV	59	.- 'Frame data' expands, if WEP enabled, to <----------'
	60	\|
	61	V
	62	,-----------------------.
	63	Bytes \| 4 \| 0-2296 \| 4 \|
	64	\|-----\|-----------\|-----\|
	65	Desc. \| IV \| Encrypted \| ICV \|
	66	\| \| Packet \| \|
	67	`-----\| \|-----'
	68	`-----.-----'
	69	\|
	70	.- 'Encrypted Packet' expands to
b453872c JG	71	\|
	72	V
	73	,---------------------------------------------------.
	74	Bytes \| 1 \| 1 \| 1 \| 3 \| 2 \| 0-2304 \|
	75	\|------\|------\|---------\|----------\|------\|---------\|
	76	Desc. \| SNAP \| SNAP \| Control \|Eth Tunnel\| Type \| IP \|
	77	\| DSAP \| SSAP \| \| \| \| Packet \|
	78	\| 0xAA \| 0xAA \|0x03 (UI)\|0x00-00-F8\| \| \|
44d7a8cf	79	`----------------------------------------------------
b453872c JG	80	Total: 8 non-data bytes
b453872c JG	81
b453872c JG	82	802.3 Ethernet Data Frame
	83
	84	,-----------------------------------------.
	85	Bytes \| 6 \| 6 \| 2 \| Variable \| 4 \|
	86	\|-------\|-------\|------\|-----------\|------\|
	87	Desc. \| Dest. \| Source\| Type \| IP Packet \| fcs \|
	88	\| MAC \| MAC \| \| \| \|
	89	`-----------------------------------------'
	90	Total: 18 non-data bytes
	91
	92	In the event that fragmentation is required, the incoming payload is split into
	93	N parts of size ieee->fts. The first fragment contains the SNAP header and the
	94	remaining packets are just data.
	95
	96	If encryption is enabled, each fragment payload size is reduced by enough space
	97	to add the prefix and postfix (IV and ICV totalling 8 bytes in the case of WEP)
	98	So if you have 1500 bytes of payload with ieee->fts set to 500 without
	99	encryption it will take 3 frames. With WEP it will take 4 frames as the
	100	payload of each frame is reduced to 492 bytes.
	101
	102	* SKB visualization
	103	*
	104	* ,- skb->data
	105	* \|
	106	* \| ETHERNET HEADER ,-<-- PAYLOAD
	107	* \| \| 14 bytes from skb->data
	108	* \| 2 bytes for Type --> ,T. \| (sizeof ethhdr)
	109	* \| \| \| \|
	110	* \|,-Dest.--. ,--Src.---. \| \| \|
	111	* \| 6 bytes\| \| 6 bytes \| \| \| \|
	112	* v \| \| \| \| \| \|
	113	* 0 \| v 1 \| v \| v 2
	114	* 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5
	115	* ^ \| ^ \| ^ \|
	116	* \| \| \| \| \| \|
	117	* \| \| \| \| `T' <---- 2 bytes for Type
	118	* \| \| \| \|
	119	* \| \| '---SNAP--' <-------- 6 bytes for SNAP
	120	* \| \|
	121	* `-IV--' <-------------------- 4 bytes for IV (WEP)
	122	*
	123	* SNAP HEADER
	124	*
	125	*/
	126
	127	static u8 P802_1H_OUI[P80211_OUI_LEN] = { 0x00, 0x00, 0xf8 };
	128	static u8 RFC1042_OUI[P80211_OUI_LEN] = { 0x00, 0x00, 0x00 };
	129
858119e1	130	static int ieee80211_copy_snap(u8 * data, u16 h_proto)
b453872c JG	131	{
	132	struct ieee80211_snap_hdr *snap;
	133	u8 *oui;
	134
	135	snap = (struct ieee80211_snap_hdr *)data;
	136	snap->dsap = 0xaa;
	137	snap->ssap = 0xaa;
	138	snap->ctrl = 0x03;
	139
	140	if (h_proto == 0x8137 \|\| h_proto == 0x80f3)
	141	oui = P802_1H_OUI;
	142	else
	143	oui = RFC1042_OUI;
	144	snap->oui[0] = oui[0];
	145	snap->oui[1] = oui[1];
	146	snap->oui[2] = oui[2];
	147
0edd5b44	148	(u16 ) (data + SNAP_SIZE) = htons(h_proto);
b453872c JG	149
	150	return SNAP_SIZE + sizeof(u16);
	151	}
	152
858119e1	153	static int ieee80211_encrypt_fragment(struct ieee80211_device *ieee,
0edd5b44	154	struct sk_buff *frag, int hdr_len)
b453872c	155	{
0edd5b44	156	struct ieee80211_crypt_data *crypt = ieee->crypt[ieee->tx_keyidx];
b453872c JG	157	int res;
b453872c JG	158
f0f15ab5 HL	159	if (crypt == NULL)
	160	return -1;
	161
b453872c JG	162	/* To encrypt, frame format is:
b453872c JG	163	* IV (4 bytes), clear payload (including SNAP), ICV (4 bytes) */
b453872c JG	164	atomic_inc(&crypt->refcnt);
b453872c JG	165	res = 0;
f0f15ab5	166	if (crypt->ops && crypt->ops->encrypt_mpdu)
b453872c JG	167	res = crypt->ops->encrypt_mpdu(frag, hdr_len, crypt->priv);
	168
	169	atomic_dec(&crypt->refcnt);
	170	if (res < 0) {
	171	printk(KERN_INFO "%s: Encryption failed: len=%d.\n",
	172	ieee->dev->name, frag->len);
	173	ieee->ieee_stats.tx_discards++;
	174	return -1;
	175	}
	176
	177	return 0;
	178	}
	179
0edd5b44 JG	180	void ieee80211_txb_free(struct ieee80211_txb *txb)
0edd5b44 JG	181	{
b453872c JG	182	int i;
	183	if (unlikely(!txb))
	184	return;
	185	for (i = 0; i < txb->nr_frags; i++)
	186	if (txb->fragments[i])
	187	dev_kfree_skb_any(txb->fragments[i]);
	188	kfree(txb);
	189	}
	190
e157249d	191	static struct ieee80211_txb *ieee80211_alloc_txb(int nr_frags, int txb_size,
d3f7bf4f	192	int headroom, gfp_t gfp_mask)
b453872c JG	193	{
	194	struct ieee80211_txb *txb;
	195	int i;
0edd5b44 JG	196	txb = kmalloc(sizeof(struct ieee80211_txb) + (sizeof(u8 ) nr_frags),
0edd5b44 JG	197	gfp_mask);
b453872c JG	198	if (!txb)
	199	return NULL;
	200
0a989b24	201	memset(txb, 0, sizeof(struct ieee80211_txb));
b453872c JG	202	txb->nr_frags = nr_frags;
	203	txb->frag_size = txb_size;
	204
	205	for (i = 0; i < nr_frags; i++) {
d3f7bf4f MB	206	txb->fragments[i] = __dev_alloc_skb(txb_size + headroom,
d3f7bf4f MB	207	gfp_mask);
b453872c JG	208	if (unlikely(!txb->fragments[i])) {
	209	i--;
	210	break;
	211	}
d3f7bf4f	212	skb_reserve(txb->fragments[i], headroom);
b453872c JG	213	}
	214	if (unlikely(i != nr_frags)) {
	215	while (i >= 0)
	216	dev_kfree_skb_any(txb->fragments[i--]);
	217	kfree(txb);
	218	return NULL;
	219	}
	220	return txb;
	221	}
	222
1264fc04	223	/* Incoming skb is converted to a txb which consists of
3cdd00c5	224	* a block of 802.11 fragment packets (stored as skbs) */
0edd5b44	225	int ieee80211_xmit(struct sk_buff skb, struct net_device dev)
b453872c JG	226	{
	227	struct ieee80211_device *ieee = netdev_priv(dev);
	228	struct ieee80211_txb *txb = NULL;
ee34af37	229	struct ieee80211_hdr_3addr *frag_hdr;
3cdd00c5 JK	230	int i, bytes_per_frag, nr_frags, bytes_last_frag, frag_size,
3cdd00c5 JK	231	rts_required;
b453872c JG	232	unsigned long flags;
b453872c JG	233	struct net_device_stats *stats = &ieee->stats;
31b59eae	234	int ether_type, encrypt, host_encrypt, host_encrypt_msdu, host_build_iv;
b453872c JG	235	int bytes, fc, hdr_len;
b453872c JG	236	struct sk_buff *skb_frag;
ee34af37	237	struct ieee80211_hdr_3addr header = { /* Ensure zero initialized */
b453872c JG	238	.duration_id = 0,
	239	.seq_ctl = 0
	240	};
	241	u8 dest[ETH_ALEN], src[ETH_ALEN];
0edd5b44	242	struct ieee80211_crypt_data *crypt;
2c0aa2a5	243	int priority = skb->priority;
1264fc04	244	int snapped = 0;
b453872c	245
2c0aa2a5 JK	246	if (ieee->is_queue_full && (*ieee->is_queue_full) (dev, priority))
	247	return NETDEV_TX_BUSY;
	248
b453872c JG	249	spin_lock_irqsave(&ieee->lock, flags);
	250
	251	/* If there is no driver handler to take the TXB, dont' bother
	252	* creating it... */
	253	if (!ieee->hard_start_xmit) {
0edd5b44	254	printk(KERN_WARNING "%s: No xmit handler.\n", ieee->dev->name);
b453872c JG	255	goto success;
	256	}
	257
	258	if (unlikely(skb->len < SNAP_SIZE + sizeof(u16))) {
	259	printk(KERN_WARNING "%s: skb too small (%d).\n",
	260	ieee->dev->name, skb->len);
	261	goto success;
	262	}
	263
	264	ether_type = ntohs(((struct ethhdr *)skb->data)->h_proto);
	265
	266	crypt = ieee->crypt[ieee->tx_keyidx];
	267
	268	encrypt = !(ether_type == ETH_P_PAE && ieee->ieee802_1x) &&
f1bf6638	269	ieee->sec.encrypt;
31b59eae	270
f0f15ab5 HL	271	host_encrypt = ieee->host_encrypt && encrypt && crypt;
	272	host_encrypt_msdu = ieee->host_encrypt_msdu && encrypt && crypt;
	273	host_build_iv = ieee->host_build_iv && encrypt && crypt;
b453872c JG	274
	275	if (!encrypt && ieee->ieee802_1x &&
	276	ieee->drop_unencrypted && ether_type != ETH_P_PAE) {
	277	stats->tx_dropped++;
	278	goto success;
	279	}
	280
b453872c	281	/* Save source and destination addresses */
18294d87 JK	282	memcpy(dest, skb->data, ETH_ALEN);
18294d87 JK	283	memcpy(src, skb->data + ETH_ALEN, ETH_ALEN);
b453872c JG	284
	285	/* Advance the SKB to the start of the payload */
	286	skb_pull(skb, sizeof(struct ethhdr));
	287
	288	/* Determine total amount of storage required for TXB packets */
	289	bytes = skb->len + SNAP_SIZE + sizeof(u16);
	290
a4bf26f3	291	if (host_encrypt \|\| host_build_iv)
b453872c	292	fc = IEEE80211_FTYPE_DATA \| IEEE80211_STYPE_DATA \|
0edd5b44	293	IEEE80211_FCTL_PROTECTED;
b453872c JG	294	else
	295	fc = IEEE80211_FTYPE_DATA \| IEEE80211_STYPE_DATA;
	296
	297	if (ieee->iw_mode == IW_MODE_INFRA) {
	298	fc \|= IEEE80211_FCTL_TODS;
1264fc04	299	/* To DS: Addr1 = BSSID, Addr2 = SA, Addr3 = DA */
18294d87 JK	300	memcpy(header.addr1, ieee->bssid, ETH_ALEN);
	301	memcpy(header.addr2, src, ETH_ALEN);
	302	memcpy(header.addr3, dest, ETH_ALEN);
b453872c	303	} else if (ieee->iw_mode == IW_MODE_ADHOC) {
1264fc04	304	/* not From/To DS: Addr1 = DA, Addr2 = SA, Addr3 = BSSID */
18294d87 JK	305	memcpy(header.addr1, dest, ETH_ALEN);
	306	memcpy(header.addr2, src, ETH_ALEN);
	307	memcpy(header.addr3, ieee->bssid, ETH_ALEN);
b453872c JG	308	}
	309	header.frame_ctl = cpu_to_le16(fc);
	310	hdr_len = IEEE80211_3ADDR_LEN;
	311
1264fc04 JK	312	/* Encrypt msdu first on the whole data packet. */
	313	if ((host_encrypt \|\| host_encrypt_msdu) &&
	314	crypt && crypt->ops && crypt->ops->encrypt_msdu) {
	315	int res = 0;
	316	int len = bytes + hdr_len + crypt->ops->extra_msdu_prefix_len +
	317	crypt->ops->extra_msdu_postfix_len;
	318	struct sk_buff *skb_new = dev_alloc_skb(len);
31b59eae	319
1264fc04 JK	320	if (unlikely(!skb_new))
1264fc04 JK	321	goto failed;
31b59eae	322
1264fc04 JK	323	skb_reserve(skb_new, crypt->ops->extra_msdu_prefix_len);
	324	memcpy(skb_put(skb_new, hdr_len), &header, hdr_len);
	325	snapped = 1;
	326	ieee80211_copy_snap(skb_put(skb_new, SNAP_SIZE + sizeof(u16)),
	327	ether_type);
	328	memcpy(skb_put(skb_new, skb->len), skb->data, skb->len);
	329	res = crypt->ops->encrypt_msdu(skb_new, hdr_len, crypt->priv);
	330	if (res < 0) {
	331	IEEE80211_ERROR("msdu encryption failed\n");
	332	dev_kfree_skb_any(skb_new);
	333	goto failed;
	334	}
	335	dev_kfree_skb_any(skb);
	336	skb = skb_new;
	337	bytes += crypt->ops->extra_msdu_prefix_len +
	338	crypt->ops->extra_msdu_postfix_len;
	339	skb_pull(skb, hdr_len);
	340	}
	341
	342	if (host_encrypt \|\| ieee->host_open_frag) {
	343	/* Determine fragmentation size based on destination (multicast
	344	* and broadcast are not fragmented) */
5b74eda7 HL	345	if (is_multicast_ether_addr(dest) \|\|
5b74eda7 HL	346	is_broadcast_ether_addr(dest))
1264fc04 JK	347	frag_size = MAX_FRAG_THRESHOLD;
	348	else
	349	frag_size = ieee->fts;
	350
	351	/* Determine amount of payload per fragment. Regardless of if
	352	* this stack is providing the full 802.11 header, one will
	353	* eventually be affixed to this fragment -- so we must account
	354	* for it when determining the amount of payload space. */
	355	bytes_per_frag = frag_size - IEEE80211_3ADDR_LEN;
	356	if (ieee->config &
	357	(CFG_IEEE80211_COMPUTE_FCS \| CFG_IEEE80211_RESERVE_FCS))
	358	bytes_per_frag -= IEEE80211_FCS_LEN;
	359
	360	/* Each fragment may need to have room for encryptiong
	361	* pre/postfix */
	362	if (host_encrypt)
	363	bytes_per_frag -= crypt->ops->extra_mpdu_prefix_len +
	364	crypt->ops->extra_mpdu_postfix_len;
	365
	366	/* Number of fragments is the total
	367	* bytes_per_frag / payload_per_fragment */
	368	nr_frags = bytes / bytes_per_frag;
	369	bytes_last_frag = bytes % bytes_per_frag;
	370	if (bytes_last_frag)
	371	nr_frags++;
	372	else
	373	bytes_last_frag = bytes_per_frag;
	374	} else {
	375	nr_frags = 1;
	376	bytes_per_frag = bytes_last_frag = bytes;
	377	frag_size = bytes + IEEE80211_3ADDR_LEN;
	378	}
b453872c	379
3cdd00c5 JK	380	rts_required = (frag_size > ieee->rts
	381	&& ieee->config & CFG_IEEE80211_RTS);
	382	if (rts_required)
	383	nr_frags++;
3cdd00c5	384
b453872c JG	385	/* When we allocate the TXB we allocate enough space for the reserve
	386	* and full fragment bytes (bytes_per_frag doesn't include prefix,
	387	* postfix, header, FCS, etc.) */
d3f7bf4f MB	388	txb = ieee80211_alloc_txb(nr_frags, frag_size,
d3f7bf4f MB	389	ieee->tx_headroom, GFP_ATOMIC);
b453872c JG	390	if (unlikely(!txb)) {
	391	printk(KERN_WARNING "%s: Could not allocate TXB\n",
	392	ieee->dev->name);
	393	goto failed;
	394	}
	395	txb->encrypted = encrypt;
1264fc04 JK	396	if (host_encrypt)
	397	txb->payload_size = frag_size * (nr_frags - 1) +
	398	bytes_last_frag;
	399	else
	400	txb->payload_size = bytes;
b453872c	401
3cdd00c5 JK	402	if (rts_required) {
	403	skb_frag = txb->fragments[0];
	404	frag_hdr =
	405	(struct ieee80211_hdr_3addr *)skb_put(skb_frag, hdr_len);
	406
	407	/*
	408	* Set header frame_ctl to the RTS.
	409	*/
	410	header.frame_ctl =
	411	cpu_to_le16(IEEE80211_FTYPE_CTL \| IEEE80211_STYPE_RTS);
	412	memcpy(frag_hdr, &header, hdr_len);
	413
	414	/*
	415	* Restore header frame_ctl to the original data setting.
	416	*/
	417	header.frame_ctl = cpu_to_le16(fc);
	418
	419	if (ieee->config &
	420	(CFG_IEEE80211_COMPUTE_FCS \| CFG_IEEE80211_RESERVE_FCS))
	421	skb_put(skb_frag, 4);
	422
	423	txb->rts_included = 1;
	424	i = 1;
	425	} else
	426	i = 0;
	427
	428	for (; i < nr_frags; i++) {
b453872c JG	429	skb_frag = txb->fragments[i];
b453872c JG	430
31b59eae	431	if (host_encrypt \|\| host_build_iv)
1264fc04 JK	432	skb_reserve(skb_frag,
1264fc04 JK	433	crypt->ops->extra_mpdu_prefix_len);
b453872c	434
ee34af37 JK	435	frag_hdr =
ee34af37 JK	436	(struct ieee80211_hdr_3addr *)skb_put(skb_frag, hdr_len);
b453872c JG	437	memcpy(frag_hdr, &header, hdr_len);
	438
	439	/* If this is not the last fragment, then add the MOREFRAGS
	440	* bit to the frame control */
	441	if (i != nr_frags - 1) {
0edd5b44 JG	442	frag_hdr->frame_ctl =
0edd5b44 JG	443	cpu_to_le16(fc \| IEEE80211_FCTL_MOREFRAGS);
b453872c JG	444	bytes = bytes_per_frag;
	445	} else {
	446	/* The last fragment takes the remaining length */
	447	bytes = bytes_last_frag;
	448	}
	449
1264fc04 JK	450	if (i == 0 && !snapped) {
	451	ieee80211_copy_snap(skb_put
	452	(skb_frag, SNAP_SIZE + sizeof(u16)),
	453	ether_type);
b453872c JG	454	bytes -= SNAP_SIZE + sizeof(u16);
	455	}
	456
	457	memcpy(skb_put(skb_frag, bytes), skb->data, bytes);
	458
	459	/* Advance the SKB... */
	460	skb_pull(skb, bytes);
	461
	462	/* Encryption routine will move the header forward in order
	463	* to insert the IV between the header and the payload */
f1bf6638	464	if (host_encrypt)
b453872c	465	ieee80211_encrypt_fragment(ieee, skb_frag, hdr_len);
31b59eae JK	466	else if (host_build_iv) {
	467	struct ieee80211_crypt_data *crypt;
	468
	469	crypt = ieee->crypt[ieee->tx_keyidx];
	470	atomic_inc(&crypt->refcnt);
	471	if (crypt->ops->build_iv)
	472	crypt->ops->build_iv(skb_frag, hdr_len,
9184d934 ZY	473	ieee->sec.keys[ieee->sec.active_key],
	474	ieee->sec.key_sizes[ieee->sec.active_key],
	475	crypt->priv);
31b59eae JK	476	atomic_dec(&crypt->refcnt);
31b59eae JK	477	}
f1bf6638	478
b453872c JG	479	if (ieee->config &
	480	(CFG_IEEE80211_COMPUTE_FCS \| CFG_IEEE80211_RESERVE_FCS))
	481	skb_put(skb_frag, 4);
	482	}
	483
0edd5b44	484	success:
b453872c JG	485	spin_unlock_irqrestore(&ieee->lock, flags);
	486
	487	dev_kfree_skb_any(skb);
	488
	489	if (txb) {
9e8571af	490	int ret = (*ieee->hard_start_xmit) (txb, dev, priority);
1264fc04	491	if (ret == 0) {
b453872c JG	492	stats->tx_packets++;
	493	stats->tx_bytes += txb->payload_size;
	494	return 0;
	495	}
2c0aa2a5 JK	496
	497	if (ret == NETDEV_TX_BUSY) {
	498	printk(KERN_ERR "%s: NETDEV_TX_BUSY returned; "
	499	"driver should report queue full via "
	500	"ieee_device->is_queue_full.\n",
	501	ieee->dev->name);
	502	}
	503
b453872c JG	504	ieee80211_txb_free(txb);
	505	}
	506
	507	return 0;
	508
0edd5b44	509	failed:
b453872c JG	510	spin_unlock_irqrestore(&ieee->lock, flags);
	511	netif_stop_queue(dev);
	512	stats->tx_errors++;
	513	return 1;
3f552bbf JK	514	}
	515
	516	/* Incoming 802.11 strucure is converted to a TXB
	517	* a block of 802.11 fragment packets (stored as skbs) */
	518	int ieee80211_tx_frame(struct ieee80211_device *ieee,
	519	struct ieee80211_hdr *frame, int len)
	520	{
	521	struct ieee80211_txb *txb = NULL;
	522	unsigned long flags;
	523	struct net_device_stats *stats = &ieee->stats;
	524	struct sk_buff *skb_frag;
9e8571af	525	int priority = -1;
3f552bbf JK	526
	527	spin_lock_irqsave(&ieee->lock, flags);
	528
	529	/* If there is no driver handler to take the TXB, dont' bother
	530	* creating it... */
	531	if (!ieee->hard_start_xmit) {
	532	printk(KERN_WARNING "%s: No xmit handler.\n", ieee->dev->name);
	533	goto success;
	534	}
b453872c	535
3f552bbf JK	536	if (unlikely(len < 24)) {
	537	printk(KERN_WARNING "%s: skb too small (%d).\n",
	538	ieee->dev->name, len);
	539	goto success;
	540	}
	541
	542	/* When we allocate the TXB we allocate enough space for the reserve
	543	* and full fragment bytes (bytes_per_frag doesn't include prefix,
	544	* postfix, header, FCS, etc.) */
077783f8	545	txb = ieee80211_alloc_txb(1, len, ieee->tx_headroom, GFP_ATOMIC);
3f552bbf JK	546	if (unlikely(!txb)) {
	547	printk(KERN_WARNING "%s: Could not allocate TXB\n",
	548	ieee->dev->name);
	549	goto failed;
	550	}
	551	txb->encrypted = 0;
	552	txb->payload_size = len;
	553
	554	skb_frag = txb->fragments[0];
	555
	556	memcpy(skb_put(skb_frag, len), frame, len);
	557
	558	if (ieee->config &
	559	(CFG_IEEE80211_COMPUTE_FCS \| CFG_IEEE80211_RESERVE_FCS))
	560	skb_put(skb_frag, 4);
	561
	562	success:
	563	spin_unlock_irqrestore(&ieee->lock, flags);
	564
	565	if (txb) {
9e8571af	566	if ((*ieee->hard_start_xmit) (txb, ieee->dev, priority) == 0) {
3f552bbf JK	567	stats->tx_packets++;
	568	stats->tx_bytes += txb->payload_size;
	569	return 0;
	570	}
	571	ieee80211_txb_free(txb);
	572	}
	573	return 0;
	574
	575	failed:
	576	spin_unlock_irqrestore(&ieee->lock, flags);
	577	stats->tx_errors++;
	578	return 1;
b453872c JG	579	}
b453872c JG	580
3f552bbf	581	EXPORT_SYMBOL(ieee80211_tx_frame);
b453872c	582	EXPORT_SYMBOL(ieee80211_txb_free);