blob: ae254497ba3d8dac57a3521fab214936f6847e2a [file] [log] [blame]
Jeff Garzikb4538722005-05-12 22:48:20 -04001/******************************************************************************
2
James Ketrenosebeaddc2005-09-21 11:58:43 -05003 Copyright(c) 2003 - 2005 Intel Corporation. All rights reserved.
Jeff Garzikb4538722005-05-12 22:48:20 -04004
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>
Jeff Garzikb4538722005-05-12 22:48:20 -040027#include <linux/errno.h>
28#include <linux/if_arp.h>
29#include <linux/in6.h>
30#include <linux/in.h>
31#include <linux/ip.h>
32#include <linux/kernel.h>
33#include <linux/module.h>
34#include <linux/netdevice.h>
Jeff Garzikb4538722005-05-12 22:48:20 -040035#include <linux/proc_fs.h>
36#include <linux/skbuff.h>
37#include <linux/slab.h>
38#include <linux/tcp.h>
39#include <linux/types.h>
Jeff Garzikb4538722005-05-12 22:48:20 -040040#include <linux/wireless.h>
41#include <linux/etherdevice.h>
42#include <asm/uaccess.h>
43
44#include <net/ieee80211.h>
45
Jeff Garzikb4538722005-05-12 22:48:20 -040046/*
47
Jeff Garzikb4538722005-05-12 22:48:20 -040048802.11 Data Frame
49
50 ,-------------------------------------------------------------------.
51Bytes | 2 | 2 | 6 | 6 | 6 | 2 | 0..2312 | 4 |
52 |------|------|---------|---------|---------|------|---------|------|
53Desc. | ctrl | dura | DA/RA | TA | SA | Sequ | Frame | fcs |
54 | | tion | (BSSID) | | | ence | data | |
55 `--------------------------------------------------| |------'
56Total: 28 non-data bytes `----.----'
57 |
Denis Vlasenko44d7a8c2006-01-18 12:02:33 +020058 .- 'Frame data' expands, if WEP enabled, to <----------'
59 |
60 V
61 ,-----------------------.
62Bytes | 4 | 0-2296 | 4 |
63 |-----|-----------|-----|
64Desc. | IV | Encrypted | ICV |
65 | | Packet | |
66 `-----| |-----'
67 `-----.-----'
68 |
69 .- 'Encrypted Packet' expands to
Jeff Garzikb4538722005-05-12 22:48:20 -040070 |
71 V
72 ,---------------------------------------------------.
73Bytes | 1 | 1 | 1 | 3 | 2 | 0-2304 |
74 |------|------|---------|----------|------|---------|
75Desc. | SNAP | SNAP | Control |Eth Tunnel| Type | IP |
76 | DSAP | SSAP | | | | Packet |
77 | 0xAA | 0xAA |0x03 (UI)|0x00-00-F8| | |
Denis Vlasenko44d7a8c2006-01-18 12:02:33 +020078 `----------------------------------------------------
Jeff Garzikb4538722005-05-12 22:48:20 -040079Total: 8 non-data bytes
80
Jeff Garzikb4538722005-05-12 22:48:20 -040081802.3 Ethernet Data Frame
82
83 ,-----------------------------------------.
84Bytes | 6 | 6 | 2 | Variable | 4 |
85 |-------|-------|------|-----------|------|
86Desc. | Dest. | Source| Type | IP Packet | fcs |
87 | MAC | MAC | | | |
88 `-----------------------------------------'
89Total: 18 non-data bytes
90
91In the event that fragmentation is required, the incoming payload is split into
92N parts of size ieee->fts. The first fragment contains the SNAP header and the
93remaining packets are just data.
94
95If encryption is enabled, each fragment payload size is reduced by enough space
96to add the prefix and postfix (IV and ICV totalling 8 bytes in the case of WEP)
97So if you have 1500 bytes of payload with ieee->fts set to 500 without
98encryption it will take 3 frames. With WEP it will take 4 frames as the
99payload of each frame is reduced to 492 bytes.
100
101* SKB visualization
102*
103* ,- skb->data
104* |
105* | ETHERNET HEADER ,-<-- PAYLOAD
106* | | 14 bytes from skb->data
107* | 2 bytes for Type --> ,T. | (sizeof ethhdr)
108* | | | |
109* |,-Dest.--. ,--Src.---. | | |
110* | 6 bytes| | 6 bytes | | | |
111* v | | | | | |
112* 0 | v 1 | v | v 2
113* 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
114* ^ | ^ | ^ |
115* | | | | | |
116* | | | | `T' <---- 2 bytes for Type
117* | | | |
118* | | '---SNAP--' <-------- 6 bytes for SNAP
119* | |
120* `-IV--' <-------------------- 4 bytes for IV (WEP)
121*
122* SNAP HEADER
123*
124*/
125
126static u8 P802_1H_OUI[P80211_OUI_LEN] = { 0x00, 0x00, 0xf8 };
127static u8 RFC1042_OUI[P80211_OUI_LEN] = { 0x00, 0x00, 0x00 };
128
Arjan van de Ven858119e2006-01-14 13:20:43 -0800129static int ieee80211_copy_snap(u8 * data, u16 h_proto)
Jeff Garzikb4538722005-05-12 22:48:20 -0400130{
131 struct ieee80211_snap_hdr *snap;
132 u8 *oui;
133
134 snap = (struct ieee80211_snap_hdr *)data;
135 snap->dsap = 0xaa;
136 snap->ssap = 0xaa;
137 snap->ctrl = 0x03;
138
139 if (h_proto == 0x8137 || h_proto == 0x80f3)
140 oui = P802_1H_OUI;
141 else
142 oui = RFC1042_OUI;
143 snap->oui[0] = oui[0];
144 snap->oui[1] = oui[1];
145 snap->oui[2] = oui[2];
146
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400147 *(u16 *) (data + SNAP_SIZE) = htons(h_proto);
Jeff Garzikb4538722005-05-12 22:48:20 -0400148
149 return SNAP_SIZE + sizeof(u16);
150}
151
Arjan van de Ven858119e2006-01-14 13:20:43 -0800152static int ieee80211_encrypt_fragment(struct ieee80211_device *ieee,
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400153 struct sk_buff *frag, int hdr_len)
Jeff Garzikb4538722005-05-12 22:48:20 -0400154{
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400155 struct ieee80211_crypt_data *crypt = ieee->crypt[ieee->tx_keyidx];
Jeff Garzikb4538722005-05-12 22:48:20 -0400156 int res;
157
Hong Liuf0f15ab2005-10-20 11:06:36 -0500158 if (crypt == NULL)
159 return -1;
160
Jeff Garzikb4538722005-05-12 22:48:20 -0400161 /* To encrypt, frame format is:
162 * IV (4 bytes), clear payload (including SNAP), ICV (4 bytes) */
Jeff Garzikb4538722005-05-12 22:48:20 -0400163 atomic_inc(&crypt->refcnt);
164 res = 0;
Hong Liuf0f15ab2005-10-20 11:06:36 -0500165 if (crypt->ops && crypt->ops->encrypt_mpdu)
Jeff Garzikb4538722005-05-12 22:48:20 -0400166 res = crypt->ops->encrypt_mpdu(frag, hdr_len, crypt->priv);
167
168 atomic_dec(&crypt->refcnt);
169 if (res < 0) {
170 printk(KERN_INFO "%s: Encryption failed: len=%d.\n",
171 ieee->dev->name, frag->len);
172 ieee->ieee_stats.tx_discards++;
173 return -1;
174 }
175
176 return 0;
177}
178
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400179void ieee80211_txb_free(struct ieee80211_txb *txb)
180{
Jeff Garzikb4538722005-05-12 22:48:20 -0400181 int i;
182 if (unlikely(!txb))
183 return;
184 for (i = 0; i < txb->nr_frags; i++)
185 if (txb->fragments[i])
186 dev_kfree_skb_any(txb->fragments[i]);
187 kfree(txb);
188}
189
Adrian Bunke1572492005-05-06 23:32:39 +0200190static struct ieee80211_txb *ieee80211_alloc_txb(int nr_frags, int txb_size,
Michael Bueschd3f7bf42005-10-21 12:39:52 -0500191 int headroom, gfp_t gfp_mask)
Jeff Garzikb4538722005-05-12 22:48:20 -0400192{
193 struct ieee80211_txb *txb;
194 int i;
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400195 txb = kmalloc(sizeof(struct ieee80211_txb) + (sizeof(u8 *) * nr_frags),
196 gfp_mask);
Jeff Garzikb4538722005-05-12 22:48:20 -0400197 if (!txb)
198 return NULL;
199
Adrian Bunk0a989b22005-04-11 16:52:15 -0700200 memset(txb, 0, sizeof(struct ieee80211_txb));
Jeff Garzikb4538722005-05-12 22:48:20 -0400201 txb->nr_frags = nr_frags;
202 txb->frag_size = txb_size;
203
204 for (i = 0; i < nr_frags; i++) {
Michael Bueschd3f7bf42005-10-21 12:39:52 -0500205 txb->fragments[i] = __dev_alloc_skb(txb_size + headroom,
206 gfp_mask);
Jeff Garzikb4538722005-05-12 22:48:20 -0400207 if (unlikely(!txb->fragments[i])) {
208 i--;
209 break;
210 }
Michael Bueschd3f7bf42005-10-21 12:39:52 -0500211 skb_reserve(txb->fragments[i], headroom);
Jeff Garzikb4538722005-05-12 22:48:20 -0400212 }
213 if (unlikely(i != nr_frags)) {
214 while (i >= 0)
215 dev_kfree_skb_any(txb->fragments[i--]);
216 kfree(txb);
217 return NULL;
218 }
219 return txb;
220}
221
Zhu Yi738580622006-04-13 17:17:17 +0800222static int ieee80211_classify(struct sk_buff *skb)
223{
224 struct ethhdr *eth;
225 struct iphdr *ip;
226
227 eth = (struct ethhdr *)skb->data;
228 if (eth->h_proto != __constant_htons(ETH_P_IP))
229 return 0;
230
231 ip = skb->nh.iph;
232 switch (ip->tos & 0xfc) {
233 case 0x20:
234 return 2;
235 case 0x40:
236 return 1;
237 case 0x60:
238 return 3;
239 case 0x80:
240 return 4;
241 case 0xa0:
242 return 5;
243 case 0xc0:
244 return 6;
245 case 0xe0:
246 return 7;
247 default:
248 return 0;
249 }
250}
251
James Ketrenos1264fc02005-09-21 11:54:53 -0500252/* Incoming skb is converted to a txb which consists of
James Ketrenos3cdd00c2005-09-21 11:54:43 -0500253 * a block of 802.11 fragment packets (stored as skbs) */
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400254int ieee80211_xmit(struct sk_buff *skb, struct net_device *dev)
Jeff Garzikb4538722005-05-12 22:48:20 -0400255{
256 struct ieee80211_device *ieee = netdev_priv(dev);
257 struct ieee80211_txb *txb = NULL;
Zhu Yi738580622006-04-13 17:17:17 +0800258 struct ieee80211_hdr_3addrqos *frag_hdr;
James Ketrenos3cdd00c2005-09-21 11:54:43 -0500259 int i, bytes_per_frag, nr_frags, bytes_last_frag, frag_size,
260 rts_required;
Jeff Garzikb4538722005-05-12 22:48:20 -0400261 unsigned long flags;
262 struct net_device_stats *stats = &ieee->stats;
James Ketrenos31b59ea2005-09-21 11:58:49 -0500263 int ether_type, encrypt, host_encrypt, host_encrypt_msdu, host_build_iv;
Jeff Garzikb4538722005-05-12 22:48:20 -0400264 int bytes, fc, hdr_len;
265 struct sk_buff *skb_frag;
Zhu Yi738580622006-04-13 17:17:17 +0800266 struct ieee80211_hdr_3addrqos header = {/* Ensure zero initialized */
Jeff Garzikb4538722005-05-12 22:48:20 -0400267 .duration_id = 0,
Zhu Yi738580622006-04-13 17:17:17 +0800268 .seq_ctl = 0,
269 .qos_ctl = 0
Jeff Garzikb4538722005-05-12 22:48:20 -0400270 };
271 u8 dest[ETH_ALEN], src[ETH_ALEN];
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400272 struct ieee80211_crypt_data *crypt;
James Ketrenos2c0aa2a2005-09-21 11:56:27 -0500273 int priority = skb->priority;
James Ketrenos1264fc02005-09-21 11:54:53 -0500274 int snapped = 0;
Jeff Garzikb4538722005-05-12 22:48:20 -0400275
James Ketrenos2c0aa2a2005-09-21 11:56:27 -0500276 if (ieee->is_queue_full && (*ieee->is_queue_full) (dev, priority))
277 return NETDEV_TX_BUSY;
278
Jeff Garzikb4538722005-05-12 22:48:20 -0400279 spin_lock_irqsave(&ieee->lock, flags);
280
281 /* If there is no driver handler to take the TXB, dont' bother
282 * creating it... */
283 if (!ieee->hard_start_xmit) {
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400284 printk(KERN_WARNING "%s: No xmit handler.\n", ieee->dev->name);
Jeff Garzikb4538722005-05-12 22:48:20 -0400285 goto success;
286 }
287
288 if (unlikely(skb->len < SNAP_SIZE + sizeof(u16))) {
289 printk(KERN_WARNING "%s: skb too small (%d).\n",
290 ieee->dev->name, skb->len);
291 goto success;
292 }
293
294 ether_type = ntohs(((struct ethhdr *)skb->data)->h_proto);
295
296 crypt = ieee->crypt[ieee->tx_keyidx];
297
298 encrypt = !(ether_type == ETH_P_PAE && ieee->ieee802_1x) &&
James Ketrenosf1bf6632005-09-21 11:53:54 -0500299 ieee->sec.encrypt;
James Ketrenos31b59ea2005-09-21 11:58:49 -0500300
Hong Liuf0f15ab2005-10-20 11:06:36 -0500301 host_encrypt = ieee->host_encrypt && encrypt && crypt;
302 host_encrypt_msdu = ieee->host_encrypt_msdu && encrypt && crypt;
303 host_build_iv = ieee->host_build_iv && encrypt && crypt;
Jeff Garzikb4538722005-05-12 22:48:20 -0400304
305 if (!encrypt && ieee->ieee802_1x &&
306 ieee->drop_unencrypted && ether_type != ETH_P_PAE) {
307 stats->tx_dropped++;
308 goto success;
309 }
310
Jeff Garzikb4538722005-05-12 22:48:20 -0400311 /* Save source and destination addresses */
James Ketrenos18294d82005-09-13 17:40:29 -0500312 memcpy(dest, skb->data, ETH_ALEN);
313 memcpy(src, skb->data + ETH_ALEN, ETH_ALEN);
Jeff Garzikb4538722005-05-12 22:48:20 -0400314
Johannes Berga4bf26f2005-12-31 11:35:20 +0100315 if (host_encrypt || host_build_iv)
Jeff Garzikb4538722005-05-12 22:48:20 -0400316 fc = IEEE80211_FTYPE_DATA | IEEE80211_STYPE_DATA |
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400317 IEEE80211_FCTL_PROTECTED;
Jeff Garzikb4538722005-05-12 22:48:20 -0400318 else
319 fc = IEEE80211_FTYPE_DATA | IEEE80211_STYPE_DATA;
320
321 if (ieee->iw_mode == IW_MODE_INFRA) {
322 fc |= IEEE80211_FCTL_TODS;
James Ketrenos1264fc02005-09-21 11:54:53 -0500323 /* To DS: Addr1 = BSSID, Addr2 = SA, Addr3 = DA */
James Ketrenos18294d82005-09-13 17:40:29 -0500324 memcpy(header.addr1, ieee->bssid, ETH_ALEN);
325 memcpy(header.addr2, src, ETH_ALEN);
326 memcpy(header.addr3, dest, ETH_ALEN);
Jeff Garzikb4538722005-05-12 22:48:20 -0400327 } else if (ieee->iw_mode == IW_MODE_ADHOC) {
James Ketrenos1264fc02005-09-21 11:54:53 -0500328 /* not From/To DS: Addr1 = DA, Addr2 = SA, Addr3 = BSSID */
James Ketrenos18294d82005-09-13 17:40:29 -0500329 memcpy(header.addr1, dest, ETH_ALEN);
330 memcpy(header.addr2, src, ETH_ALEN);
331 memcpy(header.addr3, ieee->bssid, ETH_ALEN);
Jeff Garzikb4538722005-05-12 22:48:20 -0400332 }
Jeff Garzikb4538722005-05-12 22:48:20 -0400333 hdr_len = IEEE80211_3ADDR_LEN;
334
Zhu Yi738580622006-04-13 17:17:17 +0800335 if (ieee->is_qos_active && ieee->is_qos_active(dev, skb)) {
336 fc |= IEEE80211_STYPE_QOS_DATA;
337 hdr_len += 2;
338
339 skb->priority = ieee80211_classify(skb);
Zhu Yi65b6a272006-08-21 11:32:31 +0800340 header.qos_ctl |= cpu_to_le16(skb->priority & IEEE80211_QCTL_TID);
Zhu Yi738580622006-04-13 17:17:17 +0800341 }
342 header.frame_ctl = cpu_to_le16(fc);
343
344 /* Advance the SKB to the start of the payload */
345 skb_pull(skb, sizeof(struct ethhdr));
346
347 /* Determine total amount of storage required for TXB packets */
348 bytes = skb->len + SNAP_SIZE + sizeof(u16);
349
James Ketrenos1264fc02005-09-21 11:54:53 -0500350 /* Encrypt msdu first on the whole data packet. */
351 if ((host_encrypt || host_encrypt_msdu) &&
352 crypt && crypt->ops && crypt->ops->encrypt_msdu) {
353 int res = 0;
354 int len = bytes + hdr_len + crypt->ops->extra_msdu_prefix_len +
355 crypt->ops->extra_msdu_postfix_len;
356 struct sk_buff *skb_new = dev_alloc_skb(len);
James Ketrenos31b59ea2005-09-21 11:58:49 -0500357
James Ketrenos1264fc02005-09-21 11:54:53 -0500358 if (unlikely(!skb_new))
359 goto failed;
James Ketrenos31b59ea2005-09-21 11:58:49 -0500360
James Ketrenos1264fc02005-09-21 11:54:53 -0500361 skb_reserve(skb_new, crypt->ops->extra_msdu_prefix_len);
362 memcpy(skb_put(skb_new, hdr_len), &header, hdr_len);
363 snapped = 1;
364 ieee80211_copy_snap(skb_put(skb_new, SNAP_SIZE + sizeof(u16)),
365 ether_type);
366 memcpy(skb_put(skb_new, skb->len), skb->data, skb->len);
367 res = crypt->ops->encrypt_msdu(skb_new, hdr_len, crypt->priv);
368 if (res < 0) {
369 IEEE80211_ERROR("msdu encryption failed\n");
370 dev_kfree_skb_any(skb_new);
371 goto failed;
372 }
373 dev_kfree_skb_any(skb);
374 skb = skb_new;
375 bytes += crypt->ops->extra_msdu_prefix_len +
376 crypt->ops->extra_msdu_postfix_len;
377 skb_pull(skb, hdr_len);
378 }
Jeff Garzikb4538722005-05-12 22:48:20 -0400379
James Ketrenos1264fc02005-09-21 11:54:53 -0500380 if (host_encrypt || ieee->host_open_frag) {
381 /* Determine fragmentation size based on destination (multicast
382 * and broadcast are not fragmented) */
Hong Liu5b74eda2005-10-19 16:31:34 -0500383 if (is_multicast_ether_addr(dest) ||
384 is_broadcast_ether_addr(dest))
James Ketrenos1264fc02005-09-21 11:54:53 -0500385 frag_size = MAX_FRAG_THRESHOLD;
386 else
387 frag_size = ieee->fts;
Jeff Garzikb4538722005-05-12 22:48:20 -0400388
James Ketrenos1264fc02005-09-21 11:54:53 -0500389 /* Determine amount of payload per fragment. Regardless of if
390 * this stack is providing the full 802.11 header, one will
391 * eventually be affixed to this fragment -- so we must account
392 * for it when determining the amount of payload space. */
393 bytes_per_frag = frag_size - IEEE80211_3ADDR_LEN;
394 if (ieee->config &
395 (CFG_IEEE80211_COMPUTE_FCS | CFG_IEEE80211_RESERVE_FCS))
396 bytes_per_frag -= IEEE80211_FCS_LEN;
Jeff Garzikb4538722005-05-12 22:48:20 -0400397
James Ketrenos1264fc02005-09-21 11:54:53 -0500398 /* Each fragment may need to have room for encryptiong
399 * pre/postfix */
400 if (host_encrypt)
401 bytes_per_frag -= crypt->ops->extra_mpdu_prefix_len +
402 crypt->ops->extra_mpdu_postfix_len;
403
404 /* Number of fragments is the total
405 * bytes_per_frag / payload_per_fragment */
406 nr_frags = bytes / bytes_per_frag;
407 bytes_last_frag = bytes % bytes_per_frag;
408 if (bytes_last_frag)
409 nr_frags++;
410 else
411 bytes_last_frag = bytes_per_frag;
412 } else {
413 nr_frags = 1;
414 bytes_per_frag = bytes_last_frag = bytes;
415 frag_size = bytes + IEEE80211_3ADDR_LEN;
416 }
Jeff Garzikb4538722005-05-12 22:48:20 -0400417
James Ketrenos3cdd00c2005-09-21 11:54:43 -0500418 rts_required = (frag_size > ieee->rts
419 && ieee->config & CFG_IEEE80211_RTS);
420 if (rts_required)
421 nr_frags++;
James Ketrenos3cdd00c2005-09-21 11:54:43 -0500422
Jeff Garzikb4538722005-05-12 22:48:20 -0400423 /* When we allocate the TXB we allocate enough space for the reserve
424 * and full fragment bytes (bytes_per_frag doesn't include prefix,
425 * postfix, header, FCS, etc.) */
Michael Bueschd3f7bf42005-10-21 12:39:52 -0500426 txb = ieee80211_alloc_txb(nr_frags, frag_size,
427 ieee->tx_headroom, GFP_ATOMIC);
Jeff Garzikb4538722005-05-12 22:48:20 -0400428 if (unlikely(!txb)) {
429 printk(KERN_WARNING "%s: Could not allocate TXB\n",
430 ieee->dev->name);
431 goto failed;
432 }
433 txb->encrypted = encrypt;
James Ketrenos1264fc02005-09-21 11:54:53 -0500434 if (host_encrypt)
435 txb->payload_size = frag_size * (nr_frags - 1) +
436 bytes_last_frag;
437 else
438 txb->payload_size = bytes;
Jeff Garzikb4538722005-05-12 22:48:20 -0400439
James Ketrenos3cdd00c2005-09-21 11:54:43 -0500440 if (rts_required) {
441 skb_frag = txb->fragments[0];
442 frag_hdr =
Zhu Yi738580622006-04-13 17:17:17 +0800443 (struct ieee80211_hdr_3addrqos *)skb_put(skb_frag, hdr_len);
James Ketrenos3cdd00c2005-09-21 11:54:43 -0500444
445 /*
446 * Set header frame_ctl to the RTS.
447 */
448 header.frame_ctl =
449 cpu_to_le16(IEEE80211_FTYPE_CTL | IEEE80211_STYPE_RTS);
450 memcpy(frag_hdr, &header, hdr_len);
451
452 /*
453 * Restore header frame_ctl to the original data setting.
454 */
455 header.frame_ctl = cpu_to_le16(fc);
456
457 if (ieee->config &
458 (CFG_IEEE80211_COMPUTE_FCS | CFG_IEEE80211_RESERVE_FCS))
459 skb_put(skb_frag, 4);
460
461 txb->rts_included = 1;
462 i = 1;
463 } else
464 i = 0;
465
466 for (; i < nr_frags; i++) {
Jeff Garzikb4538722005-05-12 22:48:20 -0400467 skb_frag = txb->fragments[i];
468
James Ketrenos31b59ea2005-09-21 11:58:49 -0500469 if (host_encrypt || host_build_iv)
James Ketrenos1264fc02005-09-21 11:54:53 -0500470 skb_reserve(skb_frag,
471 crypt->ops->extra_mpdu_prefix_len);
Jeff Garzikb4538722005-05-12 22:48:20 -0400472
James Ketrenosee34af32005-09-21 11:54:36 -0500473 frag_hdr =
Zhu Yi738580622006-04-13 17:17:17 +0800474 (struct ieee80211_hdr_3addrqos *)skb_put(skb_frag, hdr_len);
Jeff Garzikb4538722005-05-12 22:48:20 -0400475 memcpy(frag_hdr, &header, hdr_len);
476
477 /* If this is not the last fragment, then add the MOREFRAGS
478 * bit to the frame control */
479 if (i != nr_frags - 1) {
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400480 frag_hdr->frame_ctl =
481 cpu_to_le16(fc | IEEE80211_FCTL_MOREFRAGS);
Jeff Garzikb4538722005-05-12 22:48:20 -0400482 bytes = bytes_per_frag;
483 } else {
484 /* The last fragment takes the remaining length */
485 bytes = bytes_last_frag;
486 }
487
James Ketrenos1264fc02005-09-21 11:54:53 -0500488 if (i == 0 && !snapped) {
489 ieee80211_copy_snap(skb_put
490 (skb_frag, SNAP_SIZE + sizeof(u16)),
491 ether_type);
Jeff Garzikb4538722005-05-12 22:48:20 -0400492 bytes -= SNAP_SIZE + sizeof(u16);
493 }
494
495 memcpy(skb_put(skb_frag, bytes), skb->data, bytes);
496
497 /* Advance the SKB... */
498 skb_pull(skb, bytes);
499
500 /* Encryption routine will move the header forward in order
501 * to insert the IV between the header and the payload */
James Ketrenosf1bf6632005-09-21 11:53:54 -0500502 if (host_encrypt)
Jeff Garzikb4538722005-05-12 22:48:20 -0400503 ieee80211_encrypt_fragment(ieee, skb_frag, hdr_len);
James Ketrenos31b59ea2005-09-21 11:58:49 -0500504 else if (host_build_iv) {
505 struct ieee80211_crypt_data *crypt;
506
507 crypt = ieee->crypt[ieee->tx_keyidx];
508 atomic_inc(&crypt->refcnt);
509 if (crypt->ops->build_iv)
510 crypt->ops->build_iv(skb_frag, hdr_len,
Zhu Yi9184d932006-01-19 16:22:32 +0800511 ieee->sec.keys[ieee->sec.active_key],
512 ieee->sec.key_sizes[ieee->sec.active_key],
513 crypt->priv);
James Ketrenos31b59ea2005-09-21 11:58:49 -0500514 atomic_dec(&crypt->refcnt);
515 }
James Ketrenosf1bf6632005-09-21 11:53:54 -0500516
Jeff Garzikb4538722005-05-12 22:48:20 -0400517 if (ieee->config &
518 (CFG_IEEE80211_COMPUTE_FCS | CFG_IEEE80211_RESERVE_FCS))
519 skb_put(skb_frag, 4);
520 }
521
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400522 success:
Jeff Garzikb4538722005-05-12 22:48:20 -0400523 spin_unlock_irqrestore(&ieee->lock, flags);
524
525 dev_kfree_skb_any(skb);
526
527 if (txb) {
James Ketrenos9e8571a2005-09-21 11:56:33 -0500528 int ret = (*ieee->hard_start_xmit) (txb, dev, priority);
James Ketrenos1264fc02005-09-21 11:54:53 -0500529 if (ret == 0) {
Jeff Garzikb4538722005-05-12 22:48:20 -0400530 stats->tx_packets++;
531 stats->tx_bytes += txb->payload_size;
532 return 0;
533 }
James Ketrenos2c0aa2a2005-09-21 11:56:27 -0500534
Jeff Garzikb4538722005-05-12 22:48:20 -0400535 ieee80211_txb_free(txb);
536 }
537
538 return 0;
539
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400540 failed:
Jeff Garzikb4538722005-05-12 22:48:20 -0400541 spin_unlock_irqrestore(&ieee->lock, flags);
542 netif_stop_queue(dev);
543 stats->tx_errors++;
544 return 1;
Jeff Garzikb4538722005-05-12 22:48:20 -0400545}
546
James Ketrenos3f552bb2005-09-21 11:54:47 -0500547/* Incoming 802.11 strucure is converted to a TXB
548 * a block of 802.11 fragment packets (stored as skbs) */
549int ieee80211_tx_frame(struct ieee80211_device *ieee,
Daniel Drake76ea4c72006-06-01 15:34:26 +0100550 struct ieee80211_hdr *frame, int hdr_len, int total_len,
551 int encrypt_mpdu)
James Ketrenos3f552bb2005-09-21 11:54:47 -0500552{
553 struct ieee80211_txb *txb = NULL;
554 unsigned long flags;
555 struct net_device_stats *stats = &ieee->stats;
556 struct sk_buff *skb_frag;
James Ketrenos9e8571a2005-09-21 11:56:33 -0500557 int priority = -1;
Hong Liu4b301532006-06-21 11:35:08 +0800558 int fraglen = total_len;
559 int headroom = ieee->tx_headroom;
560 struct ieee80211_crypt_data *crypt = ieee->crypt[ieee->tx_keyidx];
James Ketrenos3f552bb2005-09-21 11:54:47 -0500561
562 spin_lock_irqsave(&ieee->lock, flags);
563
Hong Liu4b301532006-06-21 11:35:08 +0800564 if (encrypt_mpdu && (!ieee->sec.encrypt || !crypt))
Daniel Drake76ea4c72006-06-01 15:34:26 +0100565 encrypt_mpdu = 0;
566
James Ketrenos3f552bb2005-09-21 11:54:47 -0500567 /* If there is no driver handler to take the TXB, dont' bother
568 * creating it... */
569 if (!ieee->hard_start_xmit) {
570 printk(KERN_WARNING "%s: No xmit handler.\n", ieee->dev->name);
571 goto success;
572 }
573
Daniel Drake76ea4c72006-06-01 15:34:26 +0100574 if (unlikely(total_len < 24)) {
James Ketrenos3f552bb2005-09-21 11:54:47 -0500575 printk(KERN_WARNING "%s: skb too small (%d).\n",
Daniel Drake76ea4c72006-06-01 15:34:26 +0100576 ieee->dev->name, total_len);
James Ketrenos3f552bb2005-09-21 11:54:47 -0500577 goto success;
578 }
579
Hong Liu4b301532006-06-21 11:35:08 +0800580 if (encrypt_mpdu) {
Daniel Drake76ea4c72006-06-01 15:34:26 +0100581 frame->frame_ctl |= cpu_to_le16(IEEE80211_FCTL_PROTECTED);
Hong Liu4b301532006-06-21 11:35:08 +0800582 fraglen += crypt->ops->extra_mpdu_prefix_len +
583 crypt->ops->extra_mpdu_postfix_len;
584 headroom += crypt->ops->extra_mpdu_prefix_len;
585 }
Daniel Drake76ea4c72006-06-01 15:34:26 +0100586
James Ketrenos3f552bb2005-09-21 11:54:47 -0500587 /* When we allocate the TXB we allocate enough space for the reserve
588 * and full fragment bytes (bytes_per_frag doesn't include prefix,
589 * postfix, header, FCS, etc.) */
Hong Liu4b301532006-06-21 11:35:08 +0800590 txb = ieee80211_alloc_txb(1, fraglen, headroom, GFP_ATOMIC);
James Ketrenos3f552bb2005-09-21 11:54:47 -0500591 if (unlikely(!txb)) {
592 printk(KERN_WARNING "%s: Could not allocate TXB\n",
593 ieee->dev->name);
594 goto failed;
595 }
596 txb->encrypted = 0;
Hong Liu4b301532006-06-21 11:35:08 +0800597 txb->payload_size = fraglen;
James Ketrenos3f552bb2005-09-21 11:54:47 -0500598
599 skb_frag = txb->fragments[0];
600
Daniel Drake76ea4c72006-06-01 15:34:26 +0100601 memcpy(skb_put(skb_frag, total_len), frame, total_len);
James Ketrenos3f552bb2005-09-21 11:54:47 -0500602
603 if (ieee->config &
604 (CFG_IEEE80211_COMPUTE_FCS | CFG_IEEE80211_RESERVE_FCS))
605 skb_put(skb_frag, 4);
606
Daniel Drake76ea4c72006-06-01 15:34:26 +0100607 /* To avoid overcomplicating things, we do the corner-case frame
608 * encryption in software. The only real situation where encryption is
609 * needed here is during software-based shared key authentication. */
610 if (encrypt_mpdu)
611 ieee80211_encrypt_fragment(ieee, skb_frag, hdr_len);
612
James Ketrenos3f552bb2005-09-21 11:54:47 -0500613 success:
614 spin_unlock_irqrestore(&ieee->lock, flags);
615
616 if (txb) {
James Ketrenos9e8571a2005-09-21 11:56:33 -0500617 if ((*ieee->hard_start_xmit) (txb, ieee->dev, priority) == 0) {
James Ketrenos3f552bb2005-09-21 11:54:47 -0500618 stats->tx_packets++;
619 stats->tx_bytes += txb->payload_size;
620 return 0;
621 }
622 ieee80211_txb_free(txb);
623 }
624 return 0;
625
626 failed:
627 spin_unlock_irqrestore(&ieee->lock, flags);
628 stats->tx_errors++;
629 return 1;
630}
631
632EXPORT_SYMBOL(ieee80211_tx_frame);
Jeff Garzikb4538722005-05-12 22:48:20 -0400633EXPORT_SYMBOL(ieee80211_txb_free);