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