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         /* To encrypt, frame format is:
 161          * IV (4 bytes), clear payload (including SNAP), ICV (4 bytes) */
 162
 163         // PR: FIXME: Copied from hostap. Check fragmentation/MSDU/MPDU encryption.
 164         /* Host-based IEEE 802.11 fragmentation for TX is not yet supported, so
 165          * call both MSDU and MPDU encryption functions from here. */
 166         atomic_inc(&crypt->refcnt);
 167         res = 0;
 168         if (crypt->ops->encrypt_msdu)
 169                 res = crypt->ops->encrypt_msdu(frag, hdr_len, crypt->priv);
 170         if (res == 0 && crypt->ops->encrypt_mpdu)
 171                 res = crypt->ops->encrypt_mpdu(frag, hdr_len, crypt->priv);
 172
 173         atomic_dec(&crypt->refcnt);
 174         if (res < 0) {
 175                 printk(KERN_INFO "%s: Encryption failed: len=%d.\n",
 176                        ieee->dev->name, frag->len);
 177                 ieee->ieee_stats.tx_discards++;
 178                 return -1;
 179         }
 180
 181         return 0;
 182 }
 183
 184 void ieee80211_txb_free(struct ieee80211_txb *txb)
 185 {
 186         int i;
 187         if (unlikely(!txb))
 188                 return;
 189         for (i = 0; i < txb->nr_frags; i++)
 190                 if (txb->fragments[i])
 191                         dev_kfree_skb_any(txb->fragments[i]);
 192         kfree(txb);
 193 }
 194
 195 static struct ieee80211_txb *ieee80211_alloc_txb(int nr_frags, int txb_size,
 196                                                  int gfp_mask)
 197 {
 198         struct ieee80211_txb *txb;
 199         int i;
 200         txb = kmalloc(sizeof(struct ieee80211_txb) + (sizeof(u8 *) * nr_frags),
 201                       gfp_mask);
 202         if (!txb)
 203                 return NULL;
 204
 205         memset(txb, 0, sizeof(struct ieee80211_txb));
 206         txb->nr_frags = nr_frags;
 207         txb->frag_size = txb_size;
 208
 209         for (i = 0; i < nr_frags; i++) {
 210                 txb->fragments[i] = dev_alloc_skb(txb_size);
 211                 if (unlikely(!txb->fragments[i])) {
 212                         i--;
 213                         break;
 214                 }
 215         }
 216         if (unlikely(i != nr_frags)) {
 217                 while (i >= 0)
 218                         dev_kfree_skb_any(txb->fragments[i--]);
 219                 kfree(txb);
 220                 return NULL;
 221         }
 222         return txb;
 223 }
 224
 225 /* Incoming skb is converted to a txb which consist of
 226  * a block of 802.11 fragment packets (stored as skbs) */
 227 int ieee80211_xmit(struct sk_buff *skb, struct net_device *dev)
 228 {
 229         struct ieee80211_device *ieee = netdev_priv(dev);
 230         struct ieee80211_txb *txb = NULL;
 231         struct ieee80211_hdr_3addr *frag_hdr;
 232         int i, bytes_per_frag, nr_frags, bytes_last_frag, frag_size,
 233             rts_required;
 234         unsigned long flags;
 235         struct net_device_stats *stats = &ieee->stats;
 236         int ether_type, encrypt, host_encrypt;
 237         int bytes, fc, hdr_len;
 238         struct sk_buff *skb_frag;
 239         struct ieee80211_hdr_3addr header = {   /* Ensure zero initialized */
 240                 .duration_id = 0,
 241                 .seq_ctl = 0
 242         };
 243         u8 dest[ETH_ALEN], src[ETH_ALEN];
 244
 245         struct ieee80211_crypt_data *crypt;
 246
 247         spin_lock_irqsave(&ieee->lock, flags);
 248
 249         /* If there is no driver handler to take the TXB, dont' bother
 250          * creating it... */
 251         if (!ieee->hard_start_xmit) {
 252                 printk(KERN_WARNING "%s: No xmit handler.\n", ieee->dev->name);
 253                 goto success;
 254         }
 255
 256         if (unlikely(skb->len < SNAP_SIZE + sizeof(u16))) {
 257                 printk(KERN_WARNING "%s: skb too small (%d).\n",
 258                        ieee->dev->name, skb->len);
 259                 goto success;
 260         }
 261
 262         ether_type = ntohs(((struct ethhdr *)skb->data)->h_proto);
 263
 264         crypt = ieee->crypt[ieee->tx_keyidx];
 265
 266         encrypt = !(ether_type == ETH_P_PAE && ieee->ieee802_1x) &&
 267             ieee->sec.encrypt;
 268         host_encrypt = ieee->host_encrypt && encrypt;
 269
 270         if (!encrypt && ieee->ieee802_1x &&
 271             ieee->drop_unencrypted && ether_type != ETH_P_PAE) {
 272                 stats->tx_dropped++;
 273                 goto success;
 274         }
 275
 276         /* Save source and destination addresses */
 277         memcpy(dest, skb->data, ETH_ALEN);
 278         memcpy(src, skb->data + ETH_ALEN, ETH_ALEN);
 279
 280         /* Advance the SKB to the start of the payload */
 281         skb_pull(skb, sizeof(struct ethhdr));
 282
 283         /* Determine total amount of storage required for TXB packets */
 284         bytes = skb->len + SNAP_SIZE + sizeof(u16);
 285
 286         if (host_encrypt)
 287                 fc = IEEE80211_FTYPE_DATA | IEEE80211_STYPE_DATA |
 288                     IEEE80211_FCTL_PROTECTED;
 289         else
 290                 fc = IEEE80211_FTYPE_DATA | IEEE80211_STYPE_DATA;
 291
 292         if (ieee->iw_mode == IW_MODE_INFRA) {
 293                 fc |= IEEE80211_FCTL_TODS;
 294                 /* To DS: Addr1 = BSSID, Addr2 = SA,
 295                    Addr3 = DA */
 296                 memcpy(header.addr1, ieee->bssid, ETH_ALEN);
 297                 memcpy(header.addr2, src, ETH_ALEN);
 298                 memcpy(header.addr3, dest, ETH_ALEN);
 299         } else if (ieee->iw_mode == IW_MODE_ADHOC) {
 300                 /* not From/To DS: Addr1 = DA, Addr2 = SA,
 301                    Addr3 = BSSID */
 302                 memcpy(header.addr1, dest, ETH_ALEN);
 303                 memcpy(header.addr2, src, ETH_ALEN);
 304                 memcpy(header.addr3, ieee->bssid, ETH_ALEN);
 305         }
 306         header.frame_ctl = cpu_to_le16(fc);
 307         hdr_len = IEEE80211_3ADDR_LEN;
 308
 309         /* Determine fragmentation size based on destination (multicast
 310          * and broadcast are not fragmented) */
 311         if (is_multicast_ether_addr(dest) || is_broadcast_ether_addr(dest))
 312                 frag_size = MAX_FRAG_THRESHOLD;
 313         else
 314                 frag_size = ieee->fts;
 315
 316         /* Determine amount of payload per fragment.  Regardless of if
 317          * this stack is providing the full 802.11 header, one will
 318          * eventually be affixed to this fragment -- so we must account for
 319          * it when determining the amount of payload space. */
 320         bytes_per_frag = frag_size - IEEE80211_3ADDR_LEN;
 321         if (ieee->config &
 322             (CFG_IEEE80211_COMPUTE_FCS | CFG_IEEE80211_RESERVE_FCS))
 323                 bytes_per_frag -= IEEE80211_FCS_LEN;
 324
 325         /* Each fragment may need to have room for encryptiong pre/postfix */
 326         if (host_encrypt)
 327                 bytes_per_frag -= crypt->ops->extra_prefix_len +
 328                     crypt->ops->extra_postfix_len;
 329
 330         /* Number of fragments is the total bytes_per_frag /
 331          * payload_per_fragment */
 332         nr_frags = bytes / bytes_per_frag;
 333         bytes_last_frag = bytes % bytes_per_frag;
 334         if (bytes_last_frag)
 335                 nr_frags++;
 336         else
 337                 bytes_last_frag = bytes_per_frag;
 338
 339         rts_required = (frag_size > ieee->rts
 340                         && ieee->config & CFG_IEEE80211_RTS);
 341         if (rts_required)
 342                 nr_frags++;
 343         else
 344                 bytes_last_frag = bytes_per_frag;
 345
 346         /* When we allocate the TXB we allocate enough space for the reserve
 347          * and full fragment bytes (bytes_per_frag doesn't include prefix,
 348          * postfix, header, FCS, etc.) */
 349         txb = ieee80211_alloc_txb(nr_frags, frag_size, GFP_ATOMIC);
 350         if (unlikely(!txb)) {
 351                 printk(KERN_WARNING "%s: Could not allocate TXB\n",
 352                        ieee->dev->name);
 353                 goto failed;
 354         }
 355         txb->encrypted = encrypt;
 356         txb->payload_size = bytes;
 357
 358         if (rts_required) {
 359                 skb_frag = txb->fragments[0];
 360                 frag_hdr =
 361                     (struct ieee80211_hdr_3addr *)skb_put(skb_frag, hdr_len);
 362
 363                 /*
 364                  * Set header frame_ctl to the RTS.
 365                  */
 366                 header.frame_ctl =
 367                     cpu_to_le16(IEEE80211_FTYPE_CTL | IEEE80211_STYPE_RTS);
 368                 memcpy(frag_hdr, &header, hdr_len);
 369
 370                 /*
 371                  * Restore header frame_ctl to the original data setting.
 372                  */
 373                 header.frame_ctl = cpu_to_le16(fc);
 374
 375                 if (ieee->config &
 376                     (CFG_IEEE80211_COMPUTE_FCS | CFG_IEEE80211_RESERVE_FCS))
 377                         skb_put(skb_frag, 4);
 378
 379                 txb->rts_included = 1;
 380                 i = 1;
 381         } else
 382                 i = 0;
 383
 384         for (; i < nr_frags; i++) {
 385                 skb_frag = txb->fragments[i];
 386
 387                 if (host_encrypt)
 388                         skb_reserve(skb_frag, crypt->ops->extra_prefix_len);
 389
 390                 frag_hdr =
 391                     (struct ieee80211_hdr_3addr *)skb_put(skb_frag, hdr_len);
 392                 memcpy(frag_hdr, &header, hdr_len);
 393
 394                 /* If this is not the last fragment, then add the MOREFRAGS
 395                  * bit to the frame control */
 396                 if (i != nr_frags - 1) {
 397                         frag_hdr->frame_ctl =
 398                             cpu_to_le16(fc | IEEE80211_FCTL_MOREFRAGS);
 399                         bytes = bytes_per_frag;
 400                 } else {
 401                         /* The last fragment takes the remaining length */
 402                         bytes = bytes_last_frag;
 403                 }
 404
 405                 /* Put a SNAP header on the first fragment */
 406                 if (i == 0) {
 407                         ieee80211_put_snap(skb_put
 408                                            (skb_frag, SNAP_SIZE + sizeof(u16)),
 409                                            ether_type);
 410                         bytes -= SNAP_SIZE + sizeof(u16);
 411                 }
 412
 413                 memcpy(skb_put(skb_frag, bytes), skb->data, bytes);
 414
 415                 /* Advance the SKB... */
 416                 skb_pull(skb, bytes);
 417
 418                 /* Encryption routine will move the header forward in order
 419                  * to insert the IV between the header and the payload */
 420                 if (host_encrypt)
 421                         ieee80211_encrypt_fragment(ieee, skb_frag, hdr_len);
 422
 423                 /* ipw2200/2915 Hardware encryption doesn't support TKIP MIC */
 424                 if (!ieee->host_encrypt && encrypt &&
 425                     (ieee->sec.level == SEC_LEVEL_2) &&
 426                     crypt && crypt->ops && crypt->ops->encrypt_msdu) {
 427                         int res = 0;
 428                         res = crypt->ops->encrypt_msdu(skb_frag, hdr_len,
 429                                                        crypt->priv);
 430                         if (res < 0) {
 431                                 IEEE80211_ERROR("TKIP MIC encryption failed\n");
 432                                 goto failed;
 433                         }
 434                 }
 435
 436                 if (ieee->config &
 437                     (CFG_IEEE80211_COMPUTE_FCS | CFG_IEEE80211_RESERVE_FCS))
 438                         skb_put(skb_frag, 4);
 439         }
 440
 441       success:
 442         spin_unlock_irqrestore(&ieee->lock, flags);
 443
 444         dev_kfree_skb_any(skb);
 445
 446         if (txb) {
 447                 if ((*ieee->hard_start_xmit) (txb, dev) == 0) {
 448                         stats->tx_packets++;
 449                         stats->tx_bytes += txb->payload_size;
 450                         return 0;
 451                 }
 452                 ieee80211_txb_free(txb);
 453         }
 454
 455         return 0;
 456
 457       failed:
 458         spin_unlock_irqrestore(&ieee->lock, flags);
 459         netif_stop_queue(dev);
 460         stats->tx_errors++;
 461         return 1;
 462
 463 }
 464
 465 EXPORT_SYMBOL(ieee80211_txb_free);