Merge master.kernel.org:/pub/scm/linux/kernel/git/davem/sparc-2.6
[linux-2.6] / net / ieee80211 / ieee80211_tx.c
1 /******************************************************************************
2
3   Copyright(c) 2003 - 2004 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   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>
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>
41 #include <linux/version.h>
42 #include <linux/wireless.h>
43 #include <linux/etherdevice.h>
44 #include <asm/uaccess.h>
45
46 #include <net/ieee80211.h>
47
48
49 /*
50
51
52 802.11 Data Frame
53
54       ,-------------------------------------------------------------------.
55 Bytes |  2   |  2   |    6    |    6    |    6    |  2   | 0..2312 |   4  |
56       |------|------|---------|---------|---------|------|---------|------|
57 Desc. | ctrl | dura |  DA/RA  |   TA    |    SA   | Sequ |  Frame  |  fcs |
58       |      | tion | (BSSID) |         |         | ence |  data   |      |
59       `--------------------------------------------------|         |------'
60 Total: 28 non-data bytes                                 `----.----'
61                                                               |
62        .- 'Frame data' expands to <---------------------------'
63        |
64        V
65       ,---------------------------------------------------.
66 Bytes |  1   |  1   |    1    |    3     |  2   |  0-2304 |
67       |------|------|---------|----------|------|---------|
68 Desc. | SNAP | SNAP | Control |Eth Tunnel| Type | IP      |
69       | DSAP | SSAP |         |          |      | Packet  |
70       | 0xAA | 0xAA |0x03 (UI)|0x00-00-F8|      |         |
71       `-----------------------------------------|         |
72 Total: 8 non-data bytes                         `----.----'
73                                                      |
74        .- 'IP Packet' expands, if WEP enabled, to <--'
75        |
76        V
77       ,-----------------------.
78 Bytes |  4  |   0-2296  |  4  |
79       |-----|-----------|-----|
80 Desc. | IV  | Encrypted | ICV |
81       |     | IP Packet |     |
82       `-----------------------'
83 Total: 8 non-data bytes
84
85
86 802.3 Ethernet Data Frame
87
88       ,-----------------------------------------.
89 Bytes |   6   |   6   |  2   |  Variable |   4  |
90       |-------|-------|------|-----------|------|
91 Desc. | Dest. | Source| Type | IP Packet |  fcs |
92       |  MAC  |  MAC  |      |           |      |
93       `-----------------------------------------'
94 Total: 18 non-data bytes
95
96 In the event that fragmentation is required, the incoming payload is split into
97 N parts of size ieee->fts.  The first fragment contains the SNAP header and the
98 remaining packets are just data.
99
100 If encryption is enabled, each fragment payload size is reduced by enough space
101 to add the prefix and postfix (IV and ICV totalling 8 bytes in the case of WEP)
102 So if you have 1500 bytes of payload with ieee->fts set to 500 without
103 encryption it will take 3 frames.  With WEP it will take 4 frames as the
104 payload of each frame is reduced to 492 bytes.
105
106 * SKB visualization
107 *
108 *  ,- skb->data
109 * |
110 * |    ETHERNET HEADER        ,-<-- PAYLOAD
111 * |                           |     14 bytes from skb->data
112 * |  2 bytes for Type --> ,T. |     (sizeof ethhdr)
113 * |                       | | |
114 * |,-Dest.--. ,--Src.---. | | |
115 * |  6 bytes| | 6 bytes | | | |
116 * v         | |         | | | |
117 * 0         | v       1 | v | v           2
118 * 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
119 *     ^     | ^         | ^ |
120 *     |     | |         | | |
121 *     |     | |         | `T' <---- 2 bytes for Type
122 *     |     | |         |
123 *     |     | '---SNAP--' <-------- 6 bytes for SNAP
124 *     |     |
125 *     `-IV--' <-------------------- 4 bytes for IV (WEP)
126 *
127 *      SNAP HEADER
128 *
129 */
130
131 static u8 P802_1H_OUI[P80211_OUI_LEN] = { 0x00, 0x00, 0xf8 };
132 static u8 RFC1042_OUI[P80211_OUI_LEN] = { 0x00, 0x00, 0x00 };
133
134 static inline int ieee80211_put_snap(u8 *data, u16 h_proto)
135 {
136         struct ieee80211_snap_hdr *snap;
137         u8 *oui;
138
139         snap = (struct ieee80211_snap_hdr *)data;
140         snap->dsap = 0xaa;
141         snap->ssap = 0xaa;
142         snap->ctrl = 0x03;
143
144         if (h_proto == 0x8137 || h_proto == 0x80f3)
145                 oui = P802_1H_OUI;
146         else
147                 oui = RFC1042_OUI;
148         snap->oui[0] = oui[0];
149         snap->oui[1] = oui[1];
150         snap->oui[2] = oui[2];
151
152         *(u16 *)(data + SNAP_SIZE) = htons(h_proto);
153
154         return SNAP_SIZE + sizeof(u16);
155 }
156
157 static inline int ieee80211_encrypt_fragment(
158         struct ieee80211_device *ieee,
159         struct sk_buff *frag,
160         int hdr_len)
161 {
162         struct ieee80211_crypt_data* crypt = ieee->crypt[ieee->tx_keyidx];
163         int res;
164
165 #ifdef CONFIG_IEEE80211_CRYPT_TKIP
166         struct ieee80211_hdr *header;
167
168         if (ieee->tkip_countermeasures &&
169             crypt && crypt->ops && strcmp(crypt->ops->name, "TKIP") == 0) {
170                 header = (struct ieee80211_hdr *) frag->data;
171                 if (net_ratelimit()) {
172                         printk(KERN_DEBUG "%s: TKIP countermeasures: dropped "
173                                "TX packet to " MAC_FMT "\n",
174                                ieee->dev->name, MAC_ARG(header->addr1));
175                 }
176                 return -1;
177         }
178 #endif
179         /* To encrypt, frame format is:
180          * IV (4 bytes), clear payload (including SNAP), ICV (4 bytes) */
181
182         // PR: FIXME: Copied from hostap. Check fragmentation/MSDU/MPDU encryption.
183         /* Host-based IEEE 802.11 fragmentation for TX is not yet supported, so
184          * call both MSDU and MPDU encryption functions from here. */
185         atomic_inc(&crypt->refcnt);
186         res = 0;
187         if (crypt->ops->encrypt_msdu)
188                 res = crypt->ops->encrypt_msdu(frag, hdr_len, crypt->priv);
189         if (res == 0 && crypt->ops->encrypt_mpdu)
190                 res = crypt->ops->encrypt_mpdu(frag, hdr_len, crypt->priv);
191
192         atomic_dec(&crypt->refcnt);
193         if (res < 0) {
194                 printk(KERN_INFO "%s: Encryption failed: len=%d.\n",
195                        ieee->dev->name, frag->len);
196                 ieee->ieee_stats.tx_discards++;
197                 return -1;
198         }
199
200         return 0;
201 }
202
203
204 void ieee80211_txb_free(struct ieee80211_txb *txb) {
205         int i;
206         if (unlikely(!txb))
207                 return;
208         for (i = 0; i < txb->nr_frags; i++)
209                 if (txb->fragments[i])
210                         dev_kfree_skb_any(txb->fragments[i]);
211         kfree(txb);
212 }
213
214 static struct ieee80211_txb *ieee80211_alloc_txb(int nr_frags, int txb_size,
215                                                  int gfp_mask)
216 {
217         struct ieee80211_txb *txb;
218         int i;
219         txb = kmalloc(
220                 sizeof(struct ieee80211_txb) + (sizeof(u8*) * nr_frags),
221                 gfp_mask);
222         if (!txb)
223                 return NULL;
224
225         memset(txb, 0, sizeof(struct ieee80211_txb));
226         txb->nr_frags = nr_frags;
227         txb->frag_size = txb_size;
228
229         for (i = 0; i < nr_frags; i++) {
230                 txb->fragments[i] = dev_alloc_skb(txb_size);
231                 if (unlikely(!txb->fragments[i])) {
232                         i--;
233                         break;
234                 }
235         }
236         if (unlikely(i != nr_frags)) {
237                 while (i >= 0)
238                         dev_kfree_skb_any(txb->fragments[i--]);
239                 kfree(txb);
240                 return NULL;
241         }
242         return txb;
243 }
244
245 /* SKBs are added to the ieee->tx_queue. */
246 int ieee80211_xmit(struct sk_buff *skb,
247                    struct net_device *dev)
248 {
249         struct ieee80211_device *ieee = netdev_priv(dev);
250         struct ieee80211_txb *txb = NULL;
251         struct ieee80211_hdr *frag_hdr;
252         int i, bytes_per_frag, nr_frags, bytes_last_frag, frag_size;
253         unsigned long flags;
254         struct net_device_stats *stats = &ieee->stats;
255         int ether_type, encrypt;
256         int bytes, fc, hdr_len;
257         struct sk_buff *skb_frag;
258         struct ieee80211_hdr header = { /* Ensure zero initialized */
259                 .duration_id = 0,
260                 .seq_ctl = 0
261         };
262         u8 dest[ETH_ALEN], src[ETH_ALEN];
263
264         struct ieee80211_crypt_data* crypt;
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",
272                        ieee->dev->name);
273                 goto success;
274         }
275
276         if (unlikely(skb->len < SNAP_SIZE + sizeof(u16))) {
277                 printk(KERN_WARNING "%s: skb too small (%d).\n",
278                        ieee->dev->name, skb->len);
279                 goto success;
280         }
281
282         ether_type = ntohs(((struct ethhdr *)skb->data)->h_proto);
283
284         crypt = ieee->crypt[ieee->tx_keyidx];
285
286         encrypt = !(ether_type == ETH_P_PAE && ieee->ieee802_1x) &&
287                 ieee->host_encrypt && crypt && crypt->ops;
288
289         if (!encrypt && ieee->ieee802_1x &&
290             ieee->drop_unencrypted && ether_type != ETH_P_PAE) {
291                 stats->tx_dropped++;
292                 goto success;
293         }
294
295         /* Save source and destination addresses */
296         memcpy(&dest, skb->data, ETH_ALEN);
297         memcpy(&src, skb->data+ETH_ALEN, ETH_ALEN);
298
299         /* Advance the SKB to the start of the payload */
300         skb_pull(skb, sizeof(struct ethhdr));
301
302         /* Determine total amount of storage required for TXB packets */
303         bytes = skb->len + SNAP_SIZE + sizeof(u16);
304
305         if (encrypt)
306                 fc = IEEE80211_FTYPE_DATA | IEEE80211_STYPE_DATA |
307                         IEEE80211_FCTL_PROTECTED;
308         else
309                 fc = IEEE80211_FTYPE_DATA | IEEE80211_STYPE_DATA;
310
311         if (ieee->iw_mode == IW_MODE_INFRA) {
312                 fc |= IEEE80211_FCTL_TODS;
313                 /* To DS: Addr1 = BSSID, Addr2 = SA,
314                    Addr3 = DA */
315                 memcpy(&header.addr1, ieee->bssid, ETH_ALEN);
316                 memcpy(&header.addr2, &src, ETH_ALEN);
317                 memcpy(&header.addr3, &dest, ETH_ALEN);
318         } else if (ieee->iw_mode == IW_MODE_ADHOC) {
319                 /* not From/To DS: Addr1 = DA, Addr2 = SA,
320                    Addr3 = BSSID */
321                 memcpy(&header.addr1, dest, ETH_ALEN);
322                 memcpy(&header.addr2, src, ETH_ALEN);
323                 memcpy(&header.addr3, ieee->bssid, ETH_ALEN);
324         }
325         header.frame_ctl = cpu_to_le16(fc);
326         hdr_len = IEEE80211_3ADDR_LEN;
327
328         /* Determine fragmentation size based on destination (multicast
329          * and broadcast are not fragmented) */
330         if (is_multicast_ether_addr(dest) ||
331             is_broadcast_ether_addr(dest))
332                 frag_size = MAX_FRAG_THRESHOLD;
333         else
334                 frag_size = ieee->fts;
335
336         /* Determine amount of payload per fragment.  Regardless of if
337          * this stack is providing the full 802.11 header, one will
338          * eventually be affixed to this fragment -- so we must account for
339          * it when determining the amount of payload space. */
340         bytes_per_frag = frag_size - IEEE80211_3ADDR_LEN;
341         if (ieee->config &
342             (CFG_IEEE80211_COMPUTE_FCS | CFG_IEEE80211_RESERVE_FCS))
343                 bytes_per_frag -= IEEE80211_FCS_LEN;
344
345         /* Each fragment may need to have room for encryptiong pre/postfix */
346         if (encrypt)
347                 bytes_per_frag -= crypt->ops->extra_prefix_len +
348                         crypt->ops->extra_postfix_len;
349
350         /* Number of fragments is the total bytes_per_frag /
351          * payload_per_fragment */
352         nr_frags = bytes / bytes_per_frag;
353         bytes_last_frag = bytes % bytes_per_frag;
354         if (bytes_last_frag)
355                 nr_frags++;
356         else
357                 bytes_last_frag = bytes_per_frag;
358
359         /* When we allocate the TXB we allocate enough space for the reserve
360          * and full fragment bytes (bytes_per_frag doesn't include prefix,
361          * postfix, header, FCS, etc.) */
362         txb = ieee80211_alloc_txb(nr_frags, frag_size, GFP_ATOMIC);
363         if (unlikely(!txb)) {
364                 printk(KERN_WARNING "%s: Could not allocate TXB\n",
365                        ieee->dev->name);
366                 goto failed;
367         }
368         txb->encrypted = encrypt;
369         txb->payload_size = bytes;
370
371         for (i = 0; i < nr_frags; i++) {
372                 skb_frag = txb->fragments[i];
373
374                 if (encrypt)
375                         skb_reserve(skb_frag, crypt->ops->extra_prefix_len);
376
377                 frag_hdr = (struct ieee80211_hdr *)skb_put(skb_frag, hdr_len);
378                 memcpy(frag_hdr, &header, hdr_len);
379
380                 /* If this is not the last fragment, then add the MOREFRAGS
381                  * bit to the frame control */
382                 if (i != nr_frags - 1) {
383                         frag_hdr->frame_ctl = cpu_to_le16(
384                                 fc | IEEE80211_FCTL_MOREFRAGS);
385                         bytes = bytes_per_frag;
386                 } else {
387                         /* The last fragment takes the remaining length */
388                         bytes = bytes_last_frag;
389                 }
390
391                 /* Put a SNAP header on the first fragment */
392                 if (i == 0) {
393                         ieee80211_put_snap(
394                                 skb_put(skb_frag, SNAP_SIZE + sizeof(u16)),
395                                 ether_type);
396                         bytes -= SNAP_SIZE + sizeof(u16);
397                 }
398
399                 memcpy(skb_put(skb_frag, bytes), skb->data, bytes);
400
401                 /* Advance the SKB... */
402                 skb_pull(skb, bytes);
403
404                 /* Encryption routine will move the header forward in order
405                  * to insert the IV between the header and the payload */
406                 if (encrypt)
407                         ieee80211_encrypt_fragment(ieee, skb_frag, hdr_len);
408                 if (ieee->config &
409                     (CFG_IEEE80211_COMPUTE_FCS | CFG_IEEE80211_RESERVE_FCS))
410                         skb_put(skb_frag, 4);
411         }
412
413
414  success:
415         spin_unlock_irqrestore(&ieee->lock, flags);
416
417         dev_kfree_skb_any(skb);
418
419         if (txb) {
420                 if ((*ieee->hard_start_xmit)(txb, dev) == 0) {
421                         stats->tx_packets++;
422                         stats->tx_bytes += txb->payload_size;
423                         return 0;
424                 }
425                 ieee80211_txb_free(txb);
426         }
427
428         return 0;
429
430  failed:
431         spin_unlock_irqrestore(&ieee->lock, flags);
432         netif_stop_queue(dev);
433         stats->tx_errors++;
434         return 1;
435
436 }
437
438 EXPORT_SYMBOL(ieee80211_txb_free);