Loading...
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 lib80211_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 = kmalloc(struct_size(txb, fragments, nr_frags), gfp_mask);
184 if (!txb)
185 return NULL;
186
187 memset(txb, 0, sizeof(struct libipw_txb));
188 txb->nr_frags = nr_frags;
189 txb->frag_size = txb_size;
190
191 for (i = 0; i < nr_frags; i++) {
192 txb->fragments[i] = __dev_alloc_skb(txb_size + headroom,
193 gfp_mask);
194 if (unlikely(!txb->fragments[i])) {
195 i--;
196 break;
197 }
198 skb_reserve(txb->fragments[i], headroom);
199 }
200 if (unlikely(i != nr_frags)) {
201 while (i >= 0)
202 dev_kfree_skb_any(txb->fragments[i--]);
203 kfree(txb);
204 return NULL;
205 }
206 return txb;
207}
208
209static int libipw_classify(struct sk_buff *skb)
210{
211 struct ethhdr *eth;
212 struct iphdr *ip;
213
214 eth = (struct ethhdr *)skb->data;
215 if (eth->h_proto != htons(ETH_P_IP))
216 return 0;
217
218 ip = ip_hdr(skb);
219 switch (ip->tos & 0xfc) {
220 case 0x20:
221 return 2;
222 case 0x40:
223 return 1;
224 case 0x60:
225 return 3;
226 case 0x80:
227 return 4;
228 case 0xa0:
229 return 5;
230 case 0xc0:
231 return 6;
232 case 0xe0:
233 return 7;
234 default:
235 return 0;
236 }
237}
238
239/* Incoming skb is converted to a txb which consists of
240 * a block of 802.11 fragment packets (stored as skbs) */
241netdev_tx_t libipw_xmit(struct sk_buff *skb, struct net_device *dev)
242{
243 struct libipw_device *ieee = netdev_priv(dev);
244 struct libipw_txb *txb = NULL;
245 struct libipw_hdr_3addrqos *frag_hdr;
246 int i, bytes_per_frag, nr_frags, bytes_last_frag, frag_size,
247 rts_required;
248 unsigned long flags;
249 int encrypt, host_encrypt, host_encrypt_msdu;
250 __be16 ether_type;
251 int bytes, fc, hdr_len;
252 struct sk_buff *skb_frag;
253 struct libipw_hdr_3addrqos header = {/* Ensure zero initialized */
254 .duration_id = 0,
255 .seq_ctl = 0,
256 .qos_ctl = 0
257 };
258 u8 dest[ETH_ALEN], src[ETH_ALEN];
259 struct lib80211_crypt_data *crypt;
260 int priority = skb->priority;
261 int snapped = 0;
262
263 if (ieee->is_queue_full && (*ieee->is_queue_full) (dev, priority))
264 return NETDEV_TX_BUSY;
265
266 spin_lock_irqsave(&ieee->lock, flags);
267
268 /* If there is no driver handler to take the TXB, dont' bother
269 * creating it... */
270 if (!ieee->hard_start_xmit) {
271 printk(KERN_WARNING "%s: No xmit handler.\n", ieee->dev->name);
272 goto success;
273 }
274
275 if (unlikely(skb->len < SNAP_SIZE + sizeof(u16))) {
276 printk(KERN_WARNING "%s: skb too small (%d).\n",
277 ieee->dev->name, skb->len);
278 goto success;
279 }
280
281 ether_type = ((struct ethhdr *)skb->data)->h_proto;
282
283 crypt = ieee->crypt_info.crypt[ieee->crypt_info.tx_keyidx];
284
285 encrypt = !(ether_type == htons(ETH_P_PAE) && ieee->ieee802_1x) &&
286 ieee->sec.encrypt;
287
288 host_encrypt = ieee->host_encrypt && encrypt && crypt;
289 host_encrypt_msdu = ieee->host_encrypt_msdu && encrypt && crypt;
290
291 if (!encrypt && ieee->ieee802_1x &&
292 ieee->drop_unencrypted && ether_type != htons(ETH_P_PAE)) {
293 dev->stats.tx_dropped++;
294 goto success;
295 }
296
297 /* Save source and destination addresses */
298 skb_copy_from_linear_data(skb, dest, ETH_ALEN);
299 skb_copy_from_linear_data_offset(skb, ETH_ALEN, src, ETH_ALEN);
300
301 if (host_encrypt)
302 fc = IEEE80211_FTYPE_DATA | IEEE80211_STYPE_DATA |
303 IEEE80211_FCTL_PROTECTED;
304 else
305 fc = IEEE80211_FTYPE_DATA | IEEE80211_STYPE_DATA;
306
307 if (ieee->iw_mode == IW_MODE_INFRA) {
308 fc |= IEEE80211_FCTL_TODS;
309 /* To DS: Addr1 = BSSID, Addr2 = SA, Addr3 = DA */
310 memcpy(header.addr1, ieee->bssid, ETH_ALEN);
311 memcpy(header.addr2, src, ETH_ALEN);
312 memcpy(header.addr3, dest, ETH_ALEN);
313 } else if (ieee->iw_mode == IW_MODE_ADHOC) {
314 /* not From/To DS: Addr1 = DA, Addr2 = SA, Addr3 = BSSID */
315 memcpy(header.addr1, dest, ETH_ALEN);
316 memcpy(header.addr2, src, ETH_ALEN);
317 memcpy(header.addr3, ieee->bssid, ETH_ALEN);
318 }
319 hdr_len = LIBIPW_3ADDR_LEN;
320
321 if (ieee->is_qos_active && ieee->is_qos_active(dev, skb)) {
322 fc |= IEEE80211_STYPE_QOS_DATA;
323 hdr_len += 2;
324
325 skb->priority = libipw_classify(skb);
326 header.qos_ctl |= cpu_to_le16(skb->priority & LIBIPW_QCTL_TID);
327 }
328 header.frame_ctl = cpu_to_le16(fc);
329
330 /* Advance the SKB to the start of the payload */
331 skb_pull(skb, sizeof(struct ethhdr));
332
333 /* Determine total amount of storage required for TXB packets */
334 bytes = skb->len + SNAP_SIZE + sizeof(u16);
335
336 /* Encrypt msdu first on the whole data packet. */
337 if ((host_encrypt || host_encrypt_msdu) &&
338 crypt && crypt->ops && crypt->ops->encrypt_msdu) {
339 int res = 0;
340 int len = bytes + hdr_len + crypt->ops->extra_msdu_prefix_len +
341 crypt->ops->extra_msdu_postfix_len;
342 struct sk_buff *skb_new = dev_alloc_skb(len);
343
344 if (unlikely(!skb_new))
345 goto failed;
346
347 skb_reserve(skb_new, crypt->ops->extra_msdu_prefix_len);
348 skb_put_data(skb_new, &header, hdr_len);
349 snapped = 1;
350 libipw_copy_snap(skb_put(skb_new, SNAP_SIZE + sizeof(u16)),
351 ether_type);
352 skb_copy_from_linear_data(skb, skb_put(skb_new, skb->len), skb->len);
353 res = crypt->ops->encrypt_msdu(skb_new, hdr_len, crypt->priv);
354 if (res < 0) {
355 LIBIPW_ERROR("msdu encryption failed\n");
356 dev_kfree_skb_any(skb_new);
357 goto failed;
358 }
359 dev_kfree_skb_any(skb);
360 skb = skb_new;
361 bytes += crypt->ops->extra_msdu_prefix_len +
362 crypt->ops->extra_msdu_postfix_len;
363 skb_pull(skb, hdr_len);
364 }
365
366 if (host_encrypt || ieee->host_open_frag) {
367 /* Determine fragmentation size based on destination (multicast
368 * and broadcast are not fragmented) */
369 if (is_multicast_ether_addr(dest) ||
370 is_broadcast_ether_addr(dest))
371 frag_size = MAX_FRAG_THRESHOLD;
372 else
373 frag_size = ieee->fts;
374
375 /* Determine amount of payload per fragment. Regardless of if
376 * this stack is providing the full 802.11 header, one will
377 * eventually be affixed to this fragment -- so we must account
378 * for it when determining the amount of payload space. */
379 bytes_per_frag = frag_size - hdr_len;
380 if (ieee->config &
381 (CFG_LIBIPW_COMPUTE_FCS | CFG_LIBIPW_RESERVE_FCS))
382 bytes_per_frag -= LIBIPW_FCS_LEN;
383
384 /* Each fragment may need to have room for encryption
385 * pre/postfix */
386 if (host_encrypt && crypt && crypt->ops)
387 bytes_per_frag -= crypt->ops->extra_mpdu_prefix_len +
388 crypt->ops->extra_mpdu_postfix_len;
389
390 /* Number of fragments is the total
391 * bytes_per_frag / payload_per_fragment */
392 nr_frags = bytes / bytes_per_frag;
393 bytes_last_frag = bytes % bytes_per_frag;
394 if (bytes_last_frag)
395 nr_frags++;
396 else
397 bytes_last_frag = bytes_per_frag;
398 } else {
399 nr_frags = 1;
400 bytes_per_frag = bytes_last_frag = bytes;
401 frag_size = bytes + hdr_len;
402 }
403
404 rts_required = (frag_size > ieee->rts
405 && ieee->config & CFG_LIBIPW_RTS);
406 if (rts_required)
407 nr_frags++;
408
409 /* When we allocate the TXB we allocate enough space for the reserve
410 * and full fragment bytes (bytes_per_frag doesn't include prefix,
411 * postfix, header, FCS, etc.) */
412 txb = libipw_alloc_txb(nr_frags, frag_size,
413 ieee->tx_headroom, GFP_ATOMIC);
414 if (unlikely(!txb)) {
415 printk(KERN_WARNING "%s: Could not allocate TXB\n",
416 ieee->dev->name);
417 goto failed;
418 }
419 txb->encrypted = encrypt;
420 if (host_encrypt)
421 txb->payload_size = frag_size * (nr_frags - 1) +
422 bytes_last_frag;
423 else
424 txb->payload_size = bytes;
425
426 if (rts_required) {
427 skb_frag = txb->fragments[0];
428 frag_hdr = skb_put(skb_frag, hdr_len);
429
430 /*
431 * Set header frame_ctl to the RTS.
432 */
433 header.frame_ctl =
434 cpu_to_le16(IEEE80211_FTYPE_CTL | IEEE80211_STYPE_RTS);
435 memcpy(frag_hdr, &header, hdr_len);
436
437 /*
438 * Restore header frame_ctl to the original data setting.
439 */
440 header.frame_ctl = cpu_to_le16(fc);
441
442 if (ieee->config &
443 (CFG_LIBIPW_COMPUTE_FCS | CFG_LIBIPW_RESERVE_FCS))
444 skb_put(skb_frag, 4);
445
446 txb->rts_included = 1;
447 i = 1;
448 } else
449 i = 0;
450
451 for (; i < nr_frags; i++) {
452 skb_frag = txb->fragments[i];
453
454 if (host_encrypt)
455 skb_reserve(skb_frag,
456 crypt->ops->extra_mpdu_prefix_len);
457
458 frag_hdr = skb_put_data(skb_frag, &header, hdr_len);
459
460 /* If this is not the last fragment, then add the MOREFRAGS
461 * bit to the frame control */
462 if (i != nr_frags - 1) {
463 frag_hdr->frame_ctl =
464 cpu_to_le16(fc | IEEE80211_FCTL_MOREFRAGS);
465 bytes = bytes_per_frag;
466 } else {
467 /* The last fragment takes the remaining length */
468 bytes = bytes_last_frag;
469 }
470
471 if (i == 0 && !snapped) {
472 libipw_copy_snap(skb_put
473 (skb_frag, SNAP_SIZE + sizeof(u16)),
474 ether_type);
475 bytes -= SNAP_SIZE + sizeof(u16);
476 }
477
478 skb_copy_from_linear_data(skb, skb_put(skb_frag, bytes), bytes);
479
480 /* Advance the SKB... */
481 skb_pull(skb, bytes);
482
483 /* Encryption routine will move the header forward in order
484 * to insert the IV between the header and the payload */
485 if (host_encrypt)
486 libipw_encrypt_fragment(ieee, skb_frag, hdr_len);
487
488 if (ieee->config &
489 (CFG_LIBIPW_COMPUTE_FCS | CFG_LIBIPW_RESERVE_FCS))
490 skb_put(skb_frag, 4);
491 }
492
493 success:
494 spin_unlock_irqrestore(&ieee->lock, flags);
495
496 dev_kfree_skb_any(skb);
497
498 if (txb) {
499 netdev_tx_t ret = (*ieee->hard_start_xmit)(txb, dev, priority);
500 if (ret == NETDEV_TX_OK) {
501 dev->stats.tx_packets++;
502 dev->stats.tx_bytes += txb->payload_size;
503 return NETDEV_TX_OK;
504 }
505
506 libipw_txb_free(txb);
507 }
508
509 return NETDEV_TX_OK;
510
511 failed:
512 spin_unlock_irqrestore(&ieee->lock, flags);
513 netif_stop_queue(dev);
514 dev->stats.tx_errors++;
515 return NETDEV_TX_BUSY;
516}
517EXPORT_SYMBOL(libipw_xmit);
518
519EXPORT_SYMBOL(libipw_txb_free);
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 <linux/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 skb_put_data(skb_new, &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 = skb_put(skb_frag, hdr_len);
443
444 /*
445 * Set header frame_ctl to the RTS.
446 */
447 header.frame_ctl =
448 cpu_to_le16(IEEE80211_FTYPE_CTL | IEEE80211_STYPE_RTS);
449 memcpy(frag_hdr, &header, hdr_len);
450
451 /*
452 * Restore header frame_ctl to the original data setting.
453 */
454 header.frame_ctl = cpu_to_le16(fc);
455
456 if (ieee->config &
457 (CFG_LIBIPW_COMPUTE_FCS | CFG_LIBIPW_RESERVE_FCS))
458 skb_put(skb_frag, 4);
459
460 txb->rts_included = 1;
461 i = 1;
462 } else
463 i = 0;
464
465 for (; i < nr_frags; i++) {
466 skb_frag = txb->fragments[i];
467
468 if (host_encrypt)
469 skb_reserve(skb_frag,
470 crypt->ops->extra_mpdu_prefix_len);
471
472 frag_hdr = skb_put_data(skb_frag, &header, hdr_len);
473
474 /* If this is not the last fragment, then add the MOREFRAGS
475 * bit to the frame control */
476 if (i != nr_frags - 1) {
477 frag_hdr->frame_ctl =
478 cpu_to_le16(fc | IEEE80211_FCTL_MOREFRAGS);
479 bytes = bytes_per_frag;
480 } else {
481 /* The last fragment takes the remaining length */
482 bytes = bytes_last_frag;
483 }
484
485 if (i == 0 && !snapped) {
486 libipw_copy_snap(skb_put
487 (skb_frag, SNAP_SIZE + sizeof(u16)),
488 ether_type);
489 bytes -= SNAP_SIZE + sizeof(u16);
490 }
491
492 skb_copy_from_linear_data(skb, skb_put(skb_frag, bytes), bytes);
493
494 /* Advance the SKB... */
495 skb_pull(skb, bytes);
496
497 /* Encryption routine will move the header forward in order
498 * to insert the IV between the header and the payload */
499 if (host_encrypt)
500 libipw_encrypt_fragment(ieee, skb_frag, hdr_len);
501
502 if (ieee->config &
503 (CFG_LIBIPW_COMPUTE_FCS | CFG_LIBIPW_RESERVE_FCS))
504 skb_put(skb_frag, 4);
505 }
506
507 success:
508 spin_unlock_irqrestore(&ieee->lock, flags);
509
510 dev_kfree_skb_any(skb);
511
512 if (txb) {
513 netdev_tx_t ret = (*ieee->hard_start_xmit)(txb, dev, priority);
514 if (ret == NETDEV_TX_OK) {
515 dev->stats.tx_packets++;
516 dev->stats.tx_bytes += txb->payload_size;
517 return NETDEV_TX_OK;
518 }
519
520 libipw_txb_free(txb);
521 }
522
523 return NETDEV_TX_OK;
524
525 failed:
526 spin_unlock_irqrestore(&ieee->lock, flags);
527 netif_stop_queue(dev);
528 dev->stats.tx_errors++;
529 return NETDEV_TX_BUSY;
530}
531EXPORT_SYMBOL(libipw_xmit);
532
533EXPORT_SYMBOL(libipw_txb_free);