drivers/net/wireless/intel/ipw2x00/libipw

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
libipw_copy_snap
libipw_encrypt_fragment
libipw_txb_free
libipw_alloc_txb
libipw_classify
libipw_xmit
   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 
  34 802.11 Data Frame
  35 
  36       ,-------------------------------------------------------------------.
  37 Bytes |  2   |  2   |    6    |    6    |    6    |  2   | 0..2312 |   4  |
  38       |------|------|---------|---------|---------|------|---------|------|
  39 Desc. | ctrl | dura |  DA/RA  |   TA    |    SA   | Sequ |  Frame  |  fcs |
  40       |      | tion | (BSSID) |         |         | ence |  data   |      |
  41       `--------------------------------------------------|         |------'
  42 Total: 28 non-data bytes                                 `----.----'
  43                                                               |
  44        .- 'Frame data' expands, if WEP enabled, to <----------'
  45        |
  46        V
  47       ,-----------------------.
  48 Bytes |  4  |   0-2296  |  4  |
  49       |-----|-----------|-----|
  50 Desc. | IV  | Encrypted | ICV |
  51       |     | Packet    |     |
  52       `-----|           |-----'
  53             `-----.-----'
  54                   |
  55        .- 'Encrypted Packet' expands to
  56        |
  57        V
  58       ,---------------------------------------------------.
  59 Bytes |  1   |  1   |    1    |    3     |  2   |  0-2304 |
  60       |------|------|---------|----------|------|---------|
  61 Desc. | SNAP | SNAP | Control |Eth Tunnel| Type | IP      |
  62       | DSAP | SSAP |         |          |      | Packet  |
  63       | 0xAA | 0xAA |0x03 (UI)|0x00-00-F8|      |         |
  64       `----------------------------------------------------
  65 Total: 8 non-data bytes
  66 
  67 802.3 Ethernet Data Frame
  68 
  69       ,-----------------------------------------.
  70 Bytes |   6   |   6   |  2   |  Variable |   4  |
  71       |-------|-------|------|-----------|------|
  72 Desc. | Dest. | Source| Type | IP Packet |  fcs |
  73       |  MAC  |  MAC  |      |           |      |
  74       `-----------------------------------------'
  75 Total: 18 non-data bytes
  76 
  77 In the event that fragmentation is required, the incoming payload is split into
  78 N parts of size ieee->fts.  The first fragment contains the SNAP header and the
  79 remaining packets are just data.
  80 
  81 If encryption is enabled, each fragment payload size is reduced by enough space
  82 to add the prefix and postfix (IV and ICV totalling 8 bytes in the case of WEP)
  83 So if you have 1500 bytes of payload with ieee->fts set to 500 without
  84 encryption it will take 3 frames.  With WEP it will take 4 frames as the
  85 payload 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 
 112 static u8 P802_1H_OUI[P80211_OUI_LEN] = { 0x00, 0x00, 0xf8 };
 113 static u8 RFC1042_OUI[P80211_OUI_LEN] = { 0x00, 0x00, 0x00 };
 114 
 115 static 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 
 138 static 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 
 166 void 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 
 177 static 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         txb = kmalloc(sizeof(struct libipw_txb) + (sizeof(u8 *) * nr_frags),
 183                       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 
 209 static 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) */
 241 netdev_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)
 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 }
 517 EXPORT_SYMBOL(libipw_xmit);
 518 
 519 EXPORT_SYMBOL(libipw_txb_free);
/* [<][>][^][v][top][bottom][index][help] */
root/drivers/net/wireless/intel/ipw2x00/libipw_tx.c

DEFINITIONS
