Loading...
1/******************************************************************************
2
3 Copyright(c) 2003 - 2005 Intel Corporation. All rights reserved.
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 Intel Linux Wireless <ilw@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/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>
35#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>
40#include <linux/wireless.h>
41#include <linux/etherdevice.h>
42#include <asm/uaccess.h>
43
44#include "libipw.h"
45
46/*
47
48802.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 |
58 .- '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
70 |
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| | |
78 `----------------------------------------------------
79Total: 8 non-data bytes
80
81802.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
129static int libipw_copy_snap(u8 * data, __be16 h_proto)
130{
131 struct libipw_snap_hdr *snap;
132 u8 *oui;
133
134 snap = (struct libipw_snap_hdr *)data;
135 snap->dsap = 0xaa;
136 snap->ssap = 0xaa;
137 snap->ctrl = 0x03;
138
139 if (h_proto == htons(ETH_P_AARP) || h_proto == htons(ETH_P_IPX))
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
147 memcpy(data + SNAP_SIZE, &h_proto, sizeof(u16));
148
149 return SNAP_SIZE + sizeof(u16);
150}
151
152static int libipw_encrypt_fragment(struct libipw_device *ieee,
153 struct sk_buff *frag, int hdr_len)
154{
155 struct lib80211_crypt_data *crypt =
156 ieee->crypt_info.crypt[ieee->crypt_info.tx_keyidx];
157 int res;
158
159 if (crypt == NULL)
160 return -1;
161
162 /* To encrypt, frame format is:
163 * IV (4 bytes), clear payload (including SNAP), ICV (4 bytes) */
164 atomic_inc(&crypt->refcnt);
165 res = 0;
166 if (crypt->ops && crypt->ops->encrypt_mpdu)
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
180void libipw_txb_free(struct libipw_txb *txb)
181{
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
191static struct libipw_txb *libipw_alloc_txb(int nr_frags, int txb_size,
192 int headroom, gfp_t gfp_mask)
193{
194 struct libipw_txb *txb;
195 int i;
196 txb = kmalloc(sizeof(struct libipw_txb) + (sizeof(u8 *) * nr_frags),
197 gfp_mask);
198 if (!txb)
199 return NULL;
200
201 memset(txb, 0, sizeof(struct libipw_txb));
202 txb->nr_frags = nr_frags;
203 txb->frag_size = txb_size;
204
205 for (i = 0; i < nr_frags; i++) {
206 txb->fragments[i] = __dev_alloc_skb(txb_size + headroom,
207 gfp_mask);
208 if (unlikely(!txb->fragments[i])) {
209 i--;
210 break;
211 }
212 skb_reserve(txb->fragments[i], headroom);
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
223static int libipw_classify(struct sk_buff *skb)
224{
225 struct ethhdr *eth;
226 struct iphdr *ip;
227
228 eth = (struct ethhdr *)skb->data;
229 if (eth->h_proto != htons(ETH_P_IP))
230 return 0;
231
232 ip = ip_hdr(skb);
233 switch (ip->tos & 0xfc) {
234 case 0x20:
235 return 2;
236 case 0x40:
237 return 1;
238 case 0x60:
239 return 3;
240 case 0x80:
241 return 4;
242 case 0xa0:
243 return 5;
244 case 0xc0:
245 return 6;
246 case 0xe0:
247 return 7;
248 default:
249 return 0;
250 }
251}
252
253/* Incoming skb is converted to a txb which consists of
254 * a block of 802.11 fragment packets (stored as skbs) */
255netdev_tx_t libipw_xmit(struct sk_buff *skb, struct net_device *dev)
256{
257 struct libipw_device *ieee = netdev_priv(dev);
258 struct libipw_txb *txb = NULL;
259 struct libipw_hdr_3addrqos *frag_hdr;
260 int i, bytes_per_frag, nr_frags, bytes_last_frag, frag_size,
261 rts_required;
262 unsigned long flags;
263 int encrypt, host_encrypt, host_encrypt_msdu;
264 __be16 ether_type;
265 int bytes, fc, hdr_len;
266 struct sk_buff *skb_frag;
267 struct libipw_hdr_3addrqos header = {/* Ensure zero initialized */
268 .duration_id = 0,
269 .seq_ctl = 0,
270 .qos_ctl = 0
271 };
272 u8 dest[ETH_ALEN], src[ETH_ALEN];
273 struct lib80211_crypt_data *crypt;
274 int priority = skb->priority;
275 int snapped = 0;
276
277 if (ieee->is_queue_full && (*ieee->is_queue_full) (dev, priority))
278 return NETDEV_TX_BUSY;
279
280 spin_lock_irqsave(&ieee->lock, flags);
281
282 /* If there is no driver handler to take the TXB, dont' bother
283 * creating it... */
284 if (!ieee->hard_start_xmit) {
285 printk(KERN_WARNING "%s: No xmit handler.\n", ieee->dev->name);
286 goto success;
287 }
288
289 if (unlikely(skb->len < SNAP_SIZE + sizeof(u16))) {
290 printk(KERN_WARNING "%s: skb too small (%d).\n",
291 ieee->dev->name, skb->len);
292 goto success;
293 }
294
295 ether_type = ((struct ethhdr *)skb->data)->h_proto;
296
297 crypt = ieee->crypt_info.crypt[ieee->crypt_info.tx_keyidx];
298
299 encrypt = !(ether_type == htons(ETH_P_PAE) && ieee->ieee802_1x) &&
300 ieee->sec.encrypt;
301
302 host_encrypt = ieee->host_encrypt && encrypt && crypt;
303 host_encrypt_msdu = ieee->host_encrypt_msdu && encrypt && crypt;
304
305 if (!encrypt && ieee->ieee802_1x &&
306 ieee->drop_unencrypted && ether_type != htons(ETH_P_PAE)) {
307 dev->stats.tx_dropped++;
308 goto success;
309 }
310
311 /* Save source and destination addresses */
312 skb_copy_from_linear_data(skb, dest, ETH_ALEN);
313 skb_copy_from_linear_data_offset(skb, ETH_ALEN, src, ETH_ALEN);
314
315 if (host_encrypt)
316 fc = IEEE80211_FTYPE_DATA | IEEE80211_STYPE_DATA |
317 IEEE80211_FCTL_PROTECTED;
318 else
319 fc = IEEE80211_FTYPE_DATA | IEEE80211_STYPE_DATA;
320
321 if (ieee->iw_mode == IW_MODE_INFRA) {
322 fc |= IEEE80211_FCTL_TODS;
323 /* To DS: Addr1 = BSSID, Addr2 = SA, Addr3 = DA */
324 memcpy(header.addr1, ieee->bssid, ETH_ALEN);
325 memcpy(header.addr2, src, ETH_ALEN);
326 memcpy(header.addr3, dest, ETH_ALEN);
327 } else if (ieee->iw_mode == IW_MODE_ADHOC) {
328 /* not From/To DS: Addr1 = DA, Addr2 = SA, Addr3 = BSSID */
329 memcpy(header.addr1, dest, ETH_ALEN);
330 memcpy(header.addr2, src, ETH_ALEN);
331 memcpy(header.addr3, ieee->bssid, ETH_ALEN);
332 }
333 hdr_len = LIBIPW_3ADDR_LEN;
334
335 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 = libipw_classify(skb);
340 header.qos_ctl |= cpu_to_le16(skb->priority & LIBIPW_QCTL_TID);
341 }
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
350 /* 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);
357
358 if (unlikely(!skb_new))
359 goto failed;
360
361 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 libipw_copy_snap(skb_put(skb_new, SNAP_SIZE + sizeof(u16)),
365 ether_type);
366 skb_copy_from_linear_data(skb, skb_put(skb_new, skb->len), skb->len);
367 res = crypt->ops->encrypt_msdu(skb_new, hdr_len, crypt->priv);
368 if (res < 0) {
369 LIBIPW_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 }
379
380 if (host_encrypt || ieee->host_open_frag) {
381 /* Determine fragmentation size based on destination (multicast
382 * and broadcast are not fragmented) */
383 if (is_multicast_ether_addr(dest) ||
384 is_broadcast_ether_addr(dest))
385 frag_size = MAX_FRAG_THRESHOLD;
386 else
387 frag_size = ieee->fts;
388
389 /* 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 - hdr_len;
394 if (ieee->config &
395 (CFG_LIBIPW_COMPUTE_FCS | CFG_LIBIPW_RESERVE_FCS))
396 bytes_per_frag -= LIBIPW_FCS_LEN;
397
398 /* Each fragment may need to have room for encryption
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 + hdr_len;
416 }
417
418 rts_required = (frag_size > ieee->rts
419 && ieee->config & CFG_LIBIPW_RTS);
420 if (rts_required)
421 nr_frags++;
422
423 /* 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.) */
426 txb = libipw_alloc_txb(nr_frags, frag_size,
427 ieee->tx_headroom, GFP_ATOMIC);
428 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;
434 if (host_encrypt)
435 txb->payload_size = frag_size * (nr_frags - 1) +
436 bytes_last_frag;
437 else
438 txb->payload_size = bytes;
439
440 if (rts_required) {
441 skb_frag = txb->fragments[0];
442 frag_hdr =
443 (struct libipw_hdr_3addrqos *)skb_put(skb_frag, hdr_len);
444
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_LIBIPW_COMPUTE_FCS | CFG_LIBIPW_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++) {
467 skb_frag = txb->fragments[i];
468
469 if (host_encrypt)
470 skb_reserve(skb_frag,
471 crypt->ops->extra_mpdu_prefix_len);
472
473 frag_hdr =
474 (struct libipw_hdr_3addrqos *)skb_put(skb_frag, hdr_len);
475 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) {
480 frag_hdr->frame_ctl =
481 cpu_to_le16(fc | IEEE80211_FCTL_MOREFRAGS);
482 bytes = bytes_per_frag;
483 } else {
484 /* The last fragment takes the remaining length */
485 bytes = bytes_last_frag;
486 }
487
488 if (i == 0 && !snapped) {
489 libipw_copy_snap(skb_put
490 (skb_frag, SNAP_SIZE + sizeof(u16)),
491 ether_type);
492 bytes -= SNAP_SIZE + sizeof(u16);
493 }
494
495 skb_copy_from_linear_data(skb, skb_put(skb_frag, bytes), 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 */
502 if (host_encrypt)
503 libipw_encrypt_fragment(ieee, skb_frag, hdr_len);
504
505 if (ieee->config &
506 (CFG_LIBIPW_COMPUTE_FCS | CFG_LIBIPW_RESERVE_FCS))
507 skb_put(skb_frag, 4);
508 }
509
510 success:
511 spin_unlock_irqrestore(&ieee->lock, flags);
512
513 dev_kfree_skb_any(skb);
514
515 if (txb) {
516 netdev_tx_t ret = (*ieee->hard_start_xmit)(txb, dev, priority);
517 if (ret == NETDEV_TX_OK) {
518 dev->stats.tx_packets++;
519 dev->stats.tx_bytes += txb->payload_size;
520 return NETDEV_TX_OK;
521 }
522
523 libipw_txb_free(txb);
524 }
525
526 return NETDEV_TX_OK;
527
528 failed:
529 spin_unlock_irqrestore(&ieee->lock, flags);
530 netif_stop_queue(dev);
531 dev->stats.tx_errors++;
532 return NETDEV_TX_BUSY;
533}
534EXPORT_SYMBOL(libipw_xmit);
535
536EXPORT_SYMBOL(libipw_txb_free);
1// SPDX-License-Identifier: GPL-2.0-only
2/******************************************************************************
3
4 Copyright(c) 2003 - 2005 Intel Corporation. All rights reserved.
5
6
7 Contact Information:
8 Intel Linux Wireless <ilw@linux.intel.com>
9 Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
10
11******************************************************************************/
12#include <linux/compiler.h>
13#include <linux/errno.h>
14#include <linux/if_arp.h>
15#include <linux/in6.h>
16#include <linux/in.h>
17#include <linux/ip.h>
18#include <linux/kernel.h>
19#include <linux/module.h>
20#include <linux/netdevice.h>
21#include <linux/proc_fs.h>
22#include <linux/skbuff.h>
23#include <linux/slab.h>
24#include <linux/tcp.h>
25#include <linux/types.h>
26#include <linux/wireless.h>
27#include <linux/etherdevice.h>
28#include <linux/uaccess.h>
29
30#include "libipw.h"
31
32/*
33
34802.11 Data Frame
35
36 ,-------------------------------------------------------------------.
37Bytes | 2 | 2 | 6 | 6 | 6 | 2 | 0..2312 | 4 |
38 |------|------|---------|---------|---------|------|---------|------|
39Desc. | ctrl | dura | DA/RA | TA | SA | Sequ | Frame | fcs |
40 | | tion | (BSSID) | | | ence | data | |
41 `--------------------------------------------------| |------'
42Total: 28 non-data bytes `----.----'
43 |
44 .- 'Frame data' expands, if WEP enabled, to <----------'
45 |
46 V
47 ,-----------------------.
48Bytes | 4 | 0-2296 | 4 |
49 |-----|-----------|-----|
50Desc. | IV | Encrypted | ICV |
51 | | Packet | |
52 `-----| |-----'
53 `-----.-----'
54 |
55 .- 'Encrypted Packet' expands to
56 |
57 V
58 ,---------------------------------------------------.
59Bytes | 1 | 1 | 1 | 3 | 2 | 0-2304 |
60 |------|------|---------|----------|------|---------|
61Desc. | SNAP | SNAP | Control |Eth Tunnel| Type | IP |
62 | DSAP | SSAP | | | | Packet |
63 | 0xAA | 0xAA |0x03 (UI)|0x00-00-F8| | |
64 `----------------------------------------------------
65Total: 8 non-data bytes
66
67802.3 Ethernet Data Frame
68
69 ,-----------------------------------------.
70Bytes | 6 | 6 | 2 | Variable | 4 |
71 |-------|-------|------|-----------|------|
72Desc. | Dest. | Source| Type | IP Packet | fcs |
73 | MAC | MAC | | | |
74 `-----------------------------------------'
75Total: 18 non-data bytes
76
77In the event that fragmentation is required, the incoming payload is split into
78N parts of size ieee->fts. The first fragment contains the SNAP header and the
79remaining packets are just data.
80
81If encryption is enabled, each fragment payload size is reduced by enough space
82to add the prefix and postfix (IV and ICV totalling 8 bytes in the case of WEP)
83So if you have 1500 bytes of payload with ieee->fts set to 500 without
84encryption it will take 3 frames. With WEP it will take 4 frames as the
85payload of each frame is reduced to 492 bytes.
86
87* SKB visualization
88*
89* ,- skb->data
90* |
91* | ETHERNET HEADER ,-<-- PAYLOAD
92* | | 14 bytes from skb->data
93* | 2 bytes for Type --> ,T. | (sizeof ethhdr)
94* | | | |
95* |,-Dest.--. ,--Src.---. | | |
96* | 6 bytes| | 6 bytes | | | |
97* v | | | | | |
98* 0 | v 1 | v | v 2
99* 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
100* ^ | ^ | ^ |
101* | | | | | |
102* | | | | `T' <---- 2 bytes for Type
103* | | | |
104* | | '---SNAP--' <-------- 6 bytes for SNAP
105* | |
106* `-IV--' <-------------------- 4 bytes for IV (WEP)
107*
108* SNAP HEADER
109*
110*/
111
112static u8 P802_1H_OUI[P80211_OUI_LEN] = { 0x00, 0x00, 0xf8 };
113static u8 RFC1042_OUI[P80211_OUI_LEN] = { 0x00, 0x00, 0x00 };
114
115static int libipw_copy_snap(u8 * data, __be16 h_proto)
116{
117 struct libipw_snap_hdr *snap;
118 u8 *oui;
119
120 snap = (struct libipw_snap_hdr *)data;
121 snap->dsap = 0xaa;
122 snap->ssap = 0xaa;
123 snap->ctrl = 0x03;
124
125 if (h_proto == htons(ETH_P_AARP) || h_proto == htons(ETH_P_IPX))
126 oui = P802_1H_OUI;
127 else
128 oui = RFC1042_OUI;
129 snap->oui[0] = oui[0];
130 snap->oui[1] = oui[1];
131 snap->oui[2] = oui[2];
132
133 memcpy(data + SNAP_SIZE, &h_proto, sizeof(u16));
134
135 return SNAP_SIZE + sizeof(u16);
136}
137
138static int libipw_encrypt_fragment(struct libipw_device *ieee,
139 struct sk_buff *frag, int hdr_len)
140{
141 struct libipw_crypt_data *crypt =
142 ieee->crypt_info.crypt[ieee->crypt_info.tx_keyidx];
143 int res;
144
145 if (crypt == NULL)
146 return -1;
147
148 /* To encrypt, frame format is:
149 * IV (4 bytes), clear payload (including SNAP), ICV (4 bytes) */
150 atomic_inc(&crypt->refcnt);
151 res = 0;
152 if (crypt->ops && crypt->ops->encrypt_mpdu)
153 res = crypt->ops->encrypt_mpdu(frag, hdr_len, crypt->priv);
154
155 atomic_dec(&crypt->refcnt);
156 if (res < 0) {
157 printk(KERN_INFO "%s: Encryption failed: len=%d.\n",
158 ieee->dev->name, frag->len);
159 ieee->ieee_stats.tx_discards++;
160 return -1;
161 }
162
163 return 0;
164}
165
166void libipw_txb_free(struct libipw_txb *txb)
167{
168 int i;
169 if (unlikely(!txb))
170 return;
171 for (i = 0; i < txb->nr_frags; i++)
172 if (txb->fragments[i])
173 dev_kfree_skb_any(txb->fragments[i]);
174 kfree(txb);
175}
176
177static struct libipw_txb *libipw_alloc_txb(int nr_frags, int txb_size,
178 int headroom, gfp_t gfp_mask)
179{
180 struct libipw_txb *txb;
181 int i;
182
183 txb = kzalloc(struct_size(txb, fragments, nr_frags), gfp_mask);
184 if (!txb)
185 return NULL;
186
187 txb->nr_frags = nr_frags;
188 txb->frag_size = txb_size;
189
190 for (i = 0; i < nr_frags; i++) {
191 txb->fragments[i] = __dev_alloc_skb(txb_size + headroom,
192 gfp_mask);
193 if (unlikely(!txb->fragments[i])) {
194 i--;
195 break;
196 }
197 skb_reserve(txb->fragments[i], headroom);
198 }
199 if (unlikely(i != nr_frags)) {
200 while (i >= 0)
201 dev_kfree_skb_any(txb->fragments[i--]);
202 kfree(txb);
203 return NULL;
204 }
205 return txb;
206}
207
208static int libipw_classify(struct sk_buff *skb)
209{
210 struct ethhdr *eth;
211 struct iphdr *ip;
212
213 eth = (struct ethhdr *)skb->data;
214 if (eth->h_proto != htons(ETH_P_IP))
215 return 0;
216
217 ip = ip_hdr(skb);
218 switch (ip->tos & 0xfc) {
219 case 0x20:
220 return 2;
221 case 0x40:
222 return 1;
223 case 0x60:
224 return 3;
225 case 0x80:
226 return 4;
227 case 0xa0:
228 return 5;
229 case 0xc0:
230 return 6;
231 case 0xe0:
232 return 7;
233 default:
234 return 0;
235 }
236}
237
238/* Incoming skb is converted to a txb which consists of
239 * a block of 802.11 fragment packets (stored as skbs) */
240netdev_tx_t libipw_xmit(struct sk_buff *skb, struct net_device *dev)
241{
242 struct libipw_device *ieee = netdev_priv(dev);
243 struct libipw_txb *txb = NULL;
244 struct libipw_hdr_3addrqos *frag_hdr;
245 int i, bytes_per_frag, nr_frags, bytes_last_frag, frag_size,
246 rts_required;
247 unsigned long flags;
248 int encrypt, host_encrypt, host_encrypt_msdu;
249 __be16 ether_type;
250 int bytes, fc, hdr_len;
251 struct sk_buff *skb_frag;
252 struct libipw_hdr_3addrqos header = {/* Ensure zero initialized */
253 .duration_id = 0,
254 .seq_ctl = 0,
255 .qos_ctl = 0
256 };
257 u8 dest[ETH_ALEN], src[ETH_ALEN];
258 struct libipw_crypt_data *crypt;
259 int priority = skb->priority;
260 int snapped = 0;
261
262 if (ieee->is_queue_full && (*ieee->is_queue_full) (dev, priority))
263 return NETDEV_TX_BUSY;
264
265 spin_lock_irqsave(&ieee->lock, flags);
266
267 /* If there is no driver handler to take the TXB, dont' bother
268 * creating it... */
269 if (!ieee->hard_start_xmit) {
270 printk(KERN_WARNING "%s: No xmit handler.\n", ieee->dev->name);
271 goto success;
272 }
273
274 if (unlikely(skb->len < SNAP_SIZE + sizeof(u16))) {
275 printk(KERN_WARNING "%s: skb too small (%d).\n",
276 ieee->dev->name, skb->len);
277 goto success;
278 }
279
280 ether_type = ((struct ethhdr *)skb->data)->h_proto;
281
282 crypt = ieee->crypt_info.crypt[ieee->crypt_info.tx_keyidx];
283
284 encrypt = !(ether_type == htons(ETH_P_PAE) && ieee->ieee802_1x) &&
285 ieee->sec.encrypt;
286
287 host_encrypt = ieee->host_encrypt && encrypt && crypt;
288 host_encrypt_msdu = ieee->host_encrypt_msdu && encrypt && crypt;
289
290 if (!encrypt && ieee->ieee802_1x &&
291 ieee->drop_unencrypted && ether_type != htons(ETH_P_PAE)) {
292 dev->stats.tx_dropped++;
293 goto success;
294 }
295
296 /* Save source and destination addresses */
297 skb_copy_from_linear_data(skb, dest, ETH_ALEN);
298 skb_copy_from_linear_data_offset(skb, ETH_ALEN, src, ETH_ALEN);
299
300 if (host_encrypt)
301 fc = IEEE80211_FTYPE_DATA | IEEE80211_STYPE_DATA |
302 IEEE80211_FCTL_PROTECTED;
303 else
304 fc = IEEE80211_FTYPE_DATA | IEEE80211_STYPE_DATA;
305
306 if (ieee->iw_mode == IW_MODE_INFRA) {
307 fc |= IEEE80211_FCTL_TODS;
308 /* To DS: Addr1 = BSSID, Addr2 = SA, Addr3 = DA */
309 memcpy(header.addr1, ieee->bssid, ETH_ALEN);
310 memcpy(header.addr2, src, ETH_ALEN);
311 memcpy(header.addr3, dest, ETH_ALEN);
312 } else if (ieee->iw_mode == IW_MODE_ADHOC) {
313 /* not From/To DS: Addr1 = DA, Addr2 = SA, Addr3 = BSSID */
314 memcpy(header.addr1, dest, ETH_ALEN);
315 memcpy(header.addr2, src, ETH_ALEN);
316 memcpy(header.addr3, ieee->bssid, ETH_ALEN);
317 }
318 hdr_len = LIBIPW_3ADDR_LEN;
319
320 if (ieee->is_qos_active && ieee->is_qos_active(dev, skb)) {
321 fc |= IEEE80211_STYPE_QOS_DATA;
322 hdr_len += 2;
323
324 skb->priority = libipw_classify(skb);
325 header.qos_ctl |= cpu_to_le16(skb->priority & LIBIPW_QCTL_TID);
326 }
327 header.frame_ctl = cpu_to_le16(fc);
328
329 /* Advance the SKB to the start of the payload */
330 skb_pull(skb, sizeof(struct ethhdr));
331
332 /* Determine total amount of storage required for TXB packets */
333 bytes = skb->len + SNAP_SIZE + sizeof(u16);
334
335 /* Encrypt msdu first on the whole data packet. */
336 if ((host_encrypt || host_encrypt_msdu) &&
337 crypt && crypt->ops && crypt->ops->encrypt_msdu) {
338 int res = 0;
339 int len = bytes + hdr_len + crypt->ops->extra_msdu_prefix_len +
340 crypt->ops->extra_msdu_postfix_len;
341 struct sk_buff *skb_new = dev_alloc_skb(len);
342
343 if (unlikely(!skb_new))
344 goto failed;
345
346 skb_reserve(skb_new, crypt->ops->extra_msdu_prefix_len);
347 skb_put_data(skb_new, &header, hdr_len);
348 snapped = 1;
349 libipw_copy_snap(skb_put(skb_new, SNAP_SIZE + sizeof(u16)),
350 ether_type);
351 skb_copy_from_linear_data(skb, skb_put(skb_new, skb->len), skb->len);
352 res = crypt->ops->encrypt_msdu(skb_new, hdr_len, crypt->priv);
353 if (res < 0) {
354 LIBIPW_ERROR("msdu encryption failed\n");
355 dev_kfree_skb_any(skb_new);
356 goto failed;
357 }
358 dev_kfree_skb_any(skb);
359 skb = skb_new;
360 bytes += crypt->ops->extra_msdu_prefix_len +
361 crypt->ops->extra_msdu_postfix_len;
362 skb_pull(skb, hdr_len);
363 }
364
365 if (host_encrypt || ieee->host_open_frag) {
366 /* Determine fragmentation size based on destination (multicast
367 * and broadcast are not fragmented) */
368 if (is_multicast_ether_addr(dest) ||
369 is_broadcast_ether_addr(dest))
370 frag_size = MAX_FRAG_THRESHOLD;
371 else
372 frag_size = ieee->fts;
373
374 /* Determine amount of payload per fragment. Regardless of if
375 * this stack is providing the full 802.11 header, one will
376 * eventually be affixed to this fragment -- so we must account
377 * for it when determining the amount of payload space. */
378 bytes_per_frag = frag_size - hdr_len;
379 if (ieee->config &
380 (CFG_LIBIPW_COMPUTE_FCS | CFG_LIBIPW_RESERVE_FCS))
381 bytes_per_frag -= LIBIPW_FCS_LEN;
382
383 /* Each fragment may need to have room for encryption
384 * pre/postfix */
385 if (host_encrypt && crypt && crypt->ops)
386 bytes_per_frag -= crypt->ops->extra_mpdu_prefix_len +
387 crypt->ops->extra_mpdu_postfix_len;
388
389 /* Number of fragments is the total
390 * bytes_per_frag / payload_per_fragment */
391 nr_frags = bytes / bytes_per_frag;
392 bytes_last_frag = bytes % bytes_per_frag;
393 if (bytes_last_frag)
394 nr_frags++;
395 else
396 bytes_last_frag = bytes_per_frag;
397 } else {
398 nr_frags = 1;
399 bytes_per_frag = bytes_last_frag = bytes;
400 frag_size = bytes + hdr_len;
401 }
402
403 rts_required = (frag_size > ieee->rts
404 && ieee->config & CFG_LIBIPW_RTS);
405 if (rts_required)
406 nr_frags++;
407
408 /* When we allocate the TXB we allocate enough space for the reserve
409 * and full fragment bytes (bytes_per_frag doesn't include prefix,
410 * postfix, header, FCS, etc.) */
411 txb = libipw_alloc_txb(nr_frags, frag_size,
412 ieee->tx_headroom, GFP_ATOMIC);
413 if (unlikely(!txb)) {
414 printk(KERN_WARNING "%s: Could not allocate TXB\n",
415 ieee->dev->name);
416 goto failed;
417 }
418 txb->encrypted = encrypt;
419 if (host_encrypt)
420 txb->payload_size = frag_size * (nr_frags - 1) +
421 bytes_last_frag;
422 else
423 txb->payload_size = bytes;
424
425 if (rts_required) {
426 skb_frag = txb->fragments[0];
427 frag_hdr = skb_put(skb_frag, hdr_len);
428
429 /*
430 * Set header frame_ctl to the RTS.
431 */
432 header.frame_ctl =
433 cpu_to_le16(IEEE80211_FTYPE_CTL | IEEE80211_STYPE_RTS);
434 memcpy(frag_hdr, &header, hdr_len);
435
436 /*
437 * Restore header frame_ctl to the original data setting.
438 */
439 header.frame_ctl = cpu_to_le16(fc);
440
441 if (ieee->config &
442 (CFG_LIBIPW_COMPUTE_FCS | CFG_LIBIPW_RESERVE_FCS))
443 skb_put(skb_frag, 4);
444
445 txb->rts_included = 1;
446 i = 1;
447 } else
448 i = 0;
449
450 for (; i < nr_frags; i++) {
451 skb_frag = txb->fragments[i];
452
453 if (host_encrypt)
454 skb_reserve(skb_frag,
455 crypt->ops->extra_mpdu_prefix_len);
456
457 frag_hdr = skb_put_data(skb_frag, &header, hdr_len);
458
459 /* If this is not the last fragment, then add the MOREFRAGS
460 * bit to the frame control */
461 if (i != nr_frags - 1) {
462 frag_hdr->frame_ctl =
463 cpu_to_le16(fc | IEEE80211_FCTL_MOREFRAGS);
464 bytes = bytes_per_frag;
465 } else {
466 /* The last fragment takes the remaining length */
467 bytes = bytes_last_frag;
468 }
469
470 if (i == 0 && !snapped) {
471 libipw_copy_snap(skb_put
472 (skb_frag, SNAP_SIZE + sizeof(u16)),
473 ether_type);
474 bytes -= SNAP_SIZE + sizeof(u16);
475 }
476
477 skb_copy_from_linear_data(skb, skb_put(skb_frag, bytes), bytes);
478
479 /* Advance the SKB... */
480 skb_pull(skb, bytes);
481
482 /* Encryption routine will move the header forward in order
483 * to insert the IV between the header and the payload */
484 if (host_encrypt)
485 libipw_encrypt_fragment(ieee, skb_frag, hdr_len);
486
487 if (ieee->config &
488 (CFG_LIBIPW_COMPUTE_FCS | CFG_LIBIPW_RESERVE_FCS))
489 skb_put(skb_frag, 4);
490 }
491
492 success:
493 spin_unlock_irqrestore(&ieee->lock, flags);
494
495 dev_kfree_skb_any(skb);
496
497 if (txb) {
498 netdev_tx_t ret = (*ieee->hard_start_xmit)(txb, dev, priority);
499 if (ret == NETDEV_TX_OK) {
500 dev->stats.tx_packets++;
501 dev->stats.tx_bytes += txb->payload_size;
502 return NETDEV_TX_OK;
503 }
504
505 libipw_txb_free(txb);
506 }
507
508 return NETDEV_TX_OK;
509
510 failed:
511 spin_unlock_irqrestore(&ieee->lock, flags);
512 netif_stop_queue(dev);
513 dev->stats.tx_errors++;
514 return NETDEV_TX_BUSY;
515}
516EXPORT_SYMBOL(libipw_xmit);
517
518EXPORT_SYMBOL(libipw_txb_free);