Merge tag 'io_uring-5.11-2021-01-16' of git://git.kernel.dk/linux-block

[linux/fpc-iii.git] / drivers / staging / wlan-ng / p80211conv.c

// SPDX-License-Identifier: (GPL-2.0 OR MPL-1.1)
/* src/p80211/p80211conv.c
 *
 * Ether/802.11 conversions and packet buffer routines
 *
 * Copyright (C) 1999 AbsoluteValue Systems, Inc.  All Rights Reserved.
 * --------------------------------------------------------------------
 *
 * linux-wlan
 *
 *   The contents of this file are subject to the Mozilla Public
 *   License Version 1.1 (the "License"); you may not use this file
 *   except in compliance with the License. You may obtain a copy of
 *   the License at http://www.mozilla.org/MPL/
 *
 *   Software distributed under the License is distributed on an "AS
 *   IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
 *   implied. See the License for the specific language governing
 *   rights and limitations under the License.
 *
 *   Alternatively, the contents of this file may be used under the
 *   terms of the GNU Public License version 2 (the "GPL"), in which
 *   case the provisions of the GPL are applicable instead of the
 *   above.  If you wish to allow the use of your version of this file
 *   only under the terms of the GPL and not to allow others to use
 *   your version of this file under the MPL, indicate your decision
 *   by deleting the provisions above and replace them with the notice
 *   and other provisions required by the GPL.  If you do not delete
 *   the provisions above, a recipient may use your version of this
 *   file under either the MPL or the GPL.
 *
 * --------------------------------------------------------------------
 *
 * Inquiries regarding the linux-wlan Open Source project can be
 * made directly to:
 *
 * AbsoluteValue Systems Inc.
 * info@linux-wlan.com
 * http://www.linux-wlan.com
 *
 * --------------------------------------------------------------------
 *
 * Portions of the development of this software were funded by
 * Intersil Corporation as part of PRISM(R) chipset product development.
 *
 * --------------------------------------------------------------------
 *
 * This file defines the functions that perform Ethernet to/from
 * 802.11 frame conversions.
 *
 * --------------------------------------------------------------------
 *
 *================================================================
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/types.h>
#include <linux/skbuff.h>
#include <linux/slab.h>
#include <linux/wireless.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/if_ether.h>
#include <linux/byteorder/generic.h>

#include <asm/byteorder.h>

#include "p80211types.h"
#include "p80211hdr.h"
#include "p80211conv.h"
#include "p80211mgmt.h"
#include "p80211msg.h"
#include "p80211netdev.h"
#include "p80211ioctl.h"
#include "p80211req.h"

static const u8 oui_rfc1042[] = { 0x00, 0x00, 0x00 };
static const u8 oui_8021h[] = { 0x00, 0x00, 0xf8 };

/*----------------------------------------------------------------
 * p80211pb_ether_to_80211
 *
 * Uses the contents of the ether frame and the etherconv setting
 * to build the elements of the 802.11 frame.
 *
 * We don't actually set
 * up the frame header here.  That's the MAC's job.  We're only handling
 * conversion of DIXII or 802.3+LLC frames to something that works
 * with 802.11.
 *
 * Note -- 802.11 header is NOT part of the skb.  Likewise, the 802.11
 *         FCS is also not present and will need to be added elsewhere.
 *
 * Arguments:
 *      ethconv         Conversion type to perform
 *      skb             skbuff containing the ether frame
 *       p80211_hdr      802.11 header
 *
 * Returns:
 *      0 on success, non-zero otherwise
 *
 * Call context:
 *      May be called in interrupt or non-interrupt context
 *----------------------------------------------------------------
 */
int skb_ether_to_p80211(struct wlandevice *wlandev, u32 ethconv,
                        struct sk_buff *skb, union p80211_hdr *p80211_hdr,
                        struct p80211_metawep *p80211_wep)
{
        __le16 fc;
        u16 proto;
        struct wlan_ethhdr e_hdr;
        struct wlan_llc *e_llc;
        struct wlan_snap *e_snap;
        int foo;

        memcpy(&e_hdr, skb->data, sizeof(e_hdr));

        if (skb->len <= 0) {
                pr_debug("zero-length skb!\n");
                return 1;
        }

        if (ethconv == WLAN_ETHCONV_ENCAP) {    /* simplest case */
                pr_debug("ENCAP len: %d\n", skb->len);
                /* here, we don't care what kind of ether frm. Just stick it */
                /*  in the 80211 payload */
                /* which is to say, leave the skb alone. */
        } else {
                /* step 1: classify ether frame, DIX or 802.3? */
                proto = ntohs(e_hdr.type);
                if (proto <= ETH_DATA_LEN) {
                        pr_debug("802.3 len: %d\n", skb->len);
                        /* codes <= 1500 reserved for 802.3 lengths */
                        /* it's 802.3, pass ether payload unchanged,  */

                        /* trim off ethernet header */
                        skb_pull(skb, ETH_HLEN);

                        /*   leave off any PAD octets.  */
                        skb_trim(skb, proto);
                } else {
                        pr_debug("DIXII len: %d\n", skb->len);
                        /* it's DIXII, time for some conversion */

                        /* trim off ethernet header */
                        skb_pull(skb, ETH_HLEN);

                        /* tack on SNAP */
                        e_snap = skb_push(skb, sizeof(struct wlan_snap));
                        e_snap->type = htons(proto);
                        if (ethconv == WLAN_ETHCONV_8021h &&
                            p80211_stt_findproto(proto)) {
                                memcpy(e_snap->oui, oui_8021h,
                                       WLAN_IEEE_OUI_LEN);
                        } else {
                                memcpy(e_snap->oui, oui_rfc1042,
                                       WLAN_IEEE_OUI_LEN);
                        }

                        /* tack on llc */
                        e_llc = skb_push(skb, sizeof(struct wlan_llc));
                        e_llc->dsap = 0xAA;     /* SNAP, see IEEE 802 */
                        e_llc->ssap = 0xAA;
                        e_llc->ctl = 0x03;
                }
        }

        /* Set up the 802.11 header */
        /* It's a data frame */
        fc = cpu_to_le16(WLAN_SET_FC_FTYPE(WLAN_FTYPE_DATA) |
                         WLAN_SET_FC_FSTYPE(WLAN_FSTYPE_DATAONLY));

        switch (wlandev->macmode) {
        case WLAN_MACMODE_IBSS_STA:
                memcpy(p80211_hdr->a3.a1, &e_hdr.daddr, ETH_ALEN);
                memcpy(p80211_hdr->a3.a2, wlandev->netdev->dev_addr, ETH_ALEN);
                memcpy(p80211_hdr->a3.a3, wlandev->bssid, ETH_ALEN);
                break;
        case WLAN_MACMODE_ESS_STA:
                fc |= cpu_to_le16(WLAN_SET_FC_TODS(1));
                memcpy(p80211_hdr->a3.a1, wlandev->bssid, ETH_ALEN);
                memcpy(p80211_hdr->a3.a2, wlandev->netdev->dev_addr, ETH_ALEN);
                memcpy(p80211_hdr->a3.a3, &e_hdr.daddr, ETH_ALEN);
                break;
        case WLAN_MACMODE_ESS_AP:
                fc |= cpu_to_le16(WLAN_SET_FC_FROMDS(1));
                memcpy(p80211_hdr->a3.a1, &e_hdr.daddr, ETH_ALEN);
                memcpy(p80211_hdr->a3.a2, wlandev->bssid, ETH_ALEN);
                memcpy(p80211_hdr->a3.a3, &e_hdr.saddr, ETH_ALEN);
                break;
        default:
                netdev_err(wlandev->netdev,
                           "Error: Converting eth to wlan in unknown mode.\n");
                return 1;
        }

        p80211_wep->data = NULL;

        if ((wlandev->hostwep & HOSTWEP_PRIVACYINVOKED) &&
            (wlandev->hostwep & HOSTWEP_ENCRYPT)) {
                /* XXXX need to pick keynum other than default? */

                p80211_wep->data = kmalloc(skb->len, GFP_ATOMIC);
                if (!p80211_wep->data)
                        return -ENOMEM;
                foo = wep_encrypt(wlandev, skb->data, p80211_wep->data,
                                  skb->len,
                                  wlandev->hostwep & HOSTWEP_DEFAULTKEY_MASK,
                                  p80211_wep->iv, p80211_wep->icv);
                if (foo) {
                        netdev_warn(wlandev->netdev,
                                    "Host en-WEP failed, dropping frame (%d).\n",
                                    foo);
                        kfree(p80211_wep->data);
                        return 2;
                }
                fc |= cpu_to_le16(WLAN_SET_FC_ISWEP(1));
        }

        /*      skb->nh.raw = skb->data; */

        p80211_hdr->a3.fc = fc;
        p80211_hdr->a3.dur = 0;
        p80211_hdr->a3.seq = 0;

        return 0;
}

/* jkriegl: from orinoco, modified */
static void orinoco_spy_gather(struct wlandevice *wlandev, char *mac,
                               struct p80211_rxmeta *rxmeta)
{
        int i;

        /* Gather wireless spy statistics: for each packet, compare the
         * source address with out list, and if match, get the stats...
         */

        for (i = 0; i < wlandev->spy_number; i++) {
                if (!memcmp(wlandev->spy_address[i], mac, ETH_ALEN)) {
                        wlandev->spy_stat[i].level = rxmeta->signal;
                        wlandev->spy_stat[i].noise = rxmeta->noise;
                        wlandev->spy_stat[i].qual =
                            (rxmeta->signal >
                             rxmeta->noise) ? (rxmeta->signal -
                                               rxmeta->noise) : 0;
                        wlandev->spy_stat[i].updated = 0x7;
                }
        }
}

/*----------------------------------------------------------------
 * p80211pb_80211_to_ether
 *
 * Uses the contents of a received 802.11 frame and the etherconv
 * setting to build an ether frame.
 *
 * This function extracts the src and dest address from the 802.11
 * frame to use in the construction of the eth frame.
 *
 * Arguments:
 *      ethconv         Conversion type to perform
 *      skb             Packet buffer containing the 802.11 frame
 *
 * Returns:
 *      0 on success, non-zero otherwise
 *
 * Call context:
 *      May be called in interrupt or non-interrupt context
 *----------------------------------------------------------------
 */
int skb_p80211_to_ether(struct wlandevice *wlandev, u32 ethconv,
                        struct sk_buff *skb)
{
        struct net_device *netdev = wlandev->netdev;
        u16 fc;
        unsigned int payload_length;
        unsigned int payload_offset;
        u8 daddr[ETH_ALEN];
        u8 saddr[ETH_ALEN];
        union p80211_hdr *w_hdr;
        struct wlan_ethhdr *e_hdr;
        struct wlan_llc *e_llc;
        struct wlan_snap *e_snap;

        int foo;

        payload_length = skb->len - WLAN_HDR_A3_LEN - WLAN_CRC_LEN;
        payload_offset = WLAN_HDR_A3_LEN;

        w_hdr = (union p80211_hdr *)skb->data;

        /* setup some vars for convenience */
        fc = le16_to_cpu(w_hdr->a3.fc);
        if ((WLAN_GET_FC_TODS(fc) == 0) && (WLAN_GET_FC_FROMDS(fc) == 0)) {
                ether_addr_copy(daddr, w_hdr->a3.a1);
                ether_addr_copy(saddr, w_hdr->a3.a2);
        } else if ((WLAN_GET_FC_TODS(fc) == 0) &&
                   (WLAN_GET_FC_FROMDS(fc) == 1)) {
                ether_addr_copy(daddr, w_hdr->a3.a1);
                ether_addr_copy(saddr, w_hdr->a3.a3);
        } else if ((WLAN_GET_FC_TODS(fc) == 1) &&
                   (WLAN_GET_FC_FROMDS(fc) == 0)) {
                ether_addr_copy(daddr, w_hdr->a3.a3);
                ether_addr_copy(saddr, w_hdr->a3.a2);
        } else {
                payload_offset = WLAN_HDR_A4_LEN;
                if (payload_length < WLAN_HDR_A4_LEN - WLAN_HDR_A3_LEN) {
                        netdev_err(netdev, "A4 frame too short!\n");
                        return 1;
                }
                payload_length -= (WLAN_HDR_A4_LEN - WLAN_HDR_A3_LEN);
                ether_addr_copy(daddr, w_hdr->a4.a3);
                ether_addr_copy(saddr, w_hdr->a4.a4);
        }

        /* perform de-wep if necessary.. */
        if ((wlandev->hostwep & HOSTWEP_PRIVACYINVOKED) &&
            WLAN_GET_FC_ISWEP(fc) &&
            (wlandev->hostwep & HOSTWEP_DECRYPT)) {
                if (payload_length <= 8) {
                        netdev_err(netdev,
                                   "WEP frame too short (%u).\n", skb->len);
                        return 1;
                }
                foo = wep_decrypt(wlandev, skb->data + payload_offset + 4,
                                  payload_length - 8, -1,
                                  skb->data + payload_offset,
                                  skb->data + payload_offset +
                                  payload_length - 4);
                if (foo) {
                        /* de-wep failed, drop skb. */
                        pr_debug("Host de-WEP failed, dropping frame (%d).\n",
                                 foo);
                        wlandev->rx.decrypt_err++;
                        return 2;
                }

                /* subtract the IV+ICV length off the payload */
                payload_length -= 8;
                /* chop off the IV */
                skb_pull(skb, 4);
                /* chop off the ICV. */
                skb_trim(skb, skb->len - 4);

                wlandev->rx.decrypt++;
        }

        e_hdr = (struct wlan_ethhdr *)(skb->data + payload_offset);

        e_llc = (struct wlan_llc *)(skb->data + payload_offset);
        e_snap =
            (struct wlan_snap *)(skb->data + payload_offset +
                sizeof(struct wlan_llc));

        /* Test for the various encodings */
        if ((payload_length >= sizeof(struct wlan_ethhdr)) &&
            (e_llc->dsap != 0xaa || e_llc->ssap != 0xaa) &&
            ((!ether_addr_equal_unaligned(daddr, e_hdr->daddr)) ||
             (!ether_addr_equal_unaligned(saddr, e_hdr->saddr)))) {
                pr_debug("802.3 ENCAP len: %d\n", payload_length);
                /* 802.3 Encapsulated */
                /* Test for an overlength frame */
                if (payload_length > (netdev->mtu + ETH_HLEN)) {
                        /* A bogus length ethfrm has been encap'd. */
                        /* Is someone trying an oflow attack? */
                        netdev_err(netdev, "ENCAP frame too large (%d > %d)\n",
                                   payload_length, netdev->mtu + ETH_HLEN);
                        return 1;
                }

                /* Chop off the 802.11 header.  it's already sane. */
                skb_pull(skb, payload_offset);
                /* chop off the 802.11 CRC */
                skb_trim(skb, skb->len - WLAN_CRC_LEN);

        } else if ((payload_length >= sizeof(struct wlan_llc) +
                sizeof(struct wlan_snap)) &&
                (e_llc->dsap == 0xaa) &&
                (e_llc->ssap == 0xaa) &&
                (e_llc->ctl == 0x03) &&
                   (((memcmp(e_snap->oui, oui_rfc1042,
                   WLAN_IEEE_OUI_LEN) == 0) &&
                   (ethconv == WLAN_ETHCONV_8021h) &&
                   (p80211_stt_findproto(be16_to_cpu(e_snap->type)))) ||
                   (memcmp(e_snap->oui, oui_rfc1042, WLAN_IEEE_OUI_LEN) !=
                        0))) {
                pr_debug("SNAP+RFC1042 len: %d\n", payload_length);
                /* it's a SNAP + RFC1042 frame && protocol is in STT */
                /* build 802.3 + RFC1042 */

                /* Test for an overlength frame */
                if (payload_length > netdev->mtu) {
                        /* A bogus length ethfrm has been sent. */
                        /* Is someone trying an oflow attack? */
                        netdev_err(netdev, "SNAP frame too large (%d > %d)\n",
                                   payload_length, netdev->mtu);
                        return 1;
                }

                /* chop 802.11 header from skb. */
                skb_pull(skb, payload_offset);

                /* create 802.3 header at beginning of skb. */
                e_hdr = skb_push(skb, ETH_HLEN);
                ether_addr_copy(e_hdr->daddr, daddr);
                ether_addr_copy(e_hdr->saddr, saddr);
                e_hdr->type = htons(payload_length);

                /* chop off the 802.11 CRC */
                skb_trim(skb, skb->len - WLAN_CRC_LEN);

        } else if ((payload_length >= sizeof(struct wlan_llc) +
                sizeof(struct wlan_snap)) &&
                (e_llc->dsap == 0xaa) &&
                (e_llc->ssap == 0xaa) &&
                (e_llc->ctl == 0x03)) {
                pr_debug("802.1h/RFC1042 len: %d\n", payload_length);
                /* it's an 802.1h frame || (an RFC1042 && protocol not in STT)
                 * build a DIXII + RFC894
                 */

                /* Test for an overlength frame */
                if ((payload_length - sizeof(struct wlan_llc) -
                        sizeof(struct wlan_snap))
                        > netdev->mtu) {
                        /* A bogus length ethfrm has been sent. */
                        /* Is someone trying an oflow attack? */
                        netdev_err(netdev, "DIXII frame too large (%ld > %d)\n",
                                   (long)(payload_length -
                                   sizeof(struct wlan_llc) -
                                   sizeof(struct wlan_snap)), netdev->mtu);
                        return 1;
                }

                /* chop 802.11 header from skb. */
                skb_pull(skb, payload_offset);

                /* chop llc header from skb. */
                skb_pull(skb, sizeof(struct wlan_llc));

                /* chop snap header from skb. */
                skb_pull(skb, sizeof(struct wlan_snap));

                /* create 802.3 header at beginning of skb. */
                e_hdr = skb_push(skb, ETH_HLEN);
                e_hdr->type = e_snap->type;
                ether_addr_copy(e_hdr->daddr, daddr);
                ether_addr_copy(e_hdr->saddr, saddr);

                /* chop off the 802.11 CRC */
                skb_trim(skb, skb->len - WLAN_CRC_LEN);
        } else {
                pr_debug("NON-ENCAP len: %d\n", payload_length);
                /* any NON-ENCAP */
                /* it's a generic 80211+LLC or IPX 'Raw 802.3' */
                /*  build an 802.3 frame */
                /* allocate space and setup hostbuf */

                /* Test for an overlength frame */
                if (payload_length > netdev->mtu) {
                        /* A bogus length ethfrm has been sent. */
                        /* Is someone trying an oflow attack? */
                        netdev_err(netdev, "OTHER frame too large (%d > %d)\n",
                                   payload_length, netdev->mtu);
                        return 1;
                }

                /* Chop off the 802.11 header. */
                skb_pull(skb, payload_offset);

                /* create 802.3 header at beginning of skb. */
                e_hdr = skb_push(skb, ETH_HLEN);
                ether_addr_copy(e_hdr->daddr, daddr);
                ether_addr_copy(e_hdr->saddr, saddr);
                e_hdr->type = htons(payload_length);

                /* chop off the 802.11 CRC */
                skb_trim(skb, skb->len - WLAN_CRC_LEN);
        }

        /*
         * Note that eth_type_trans() expects an skb w/ skb->data pointing
         * at the MAC header, it then sets the following skb members:
         * skb->mac_header,
         * skb->data, and
         * skb->pkt_type.
         * It then _returns_ the value that _we're_ supposed to stuff in
         * skb->protocol.  This is nuts.
         */
        skb->protocol = eth_type_trans(skb, netdev);

        /* jkriegl: process signal and noise as set in hfa384x_int_rx() */
        /* jkriegl: only process signal/noise if requested by iwspy */
        if (wlandev->spy_number)
                orinoco_spy_gather(wlandev, eth_hdr(skb)->h_source,
                                   p80211skb_rxmeta(skb));

        /* Free the metadata */
        p80211skb_rxmeta_detach(skb);

        return 0;
}

/*----------------------------------------------------------------
 * p80211_stt_findproto
 *
 * Searches the 802.1h Selective Translation Table for a given
 * protocol.
 *
 * Arguments:
 *      proto   protocol number (in host order) to search for.
 *
 * Returns:
 *      1 - if the table is empty or a match is found.
 *      0 - if the table is non-empty and a match is not found.
 *
 * Call context:
 *      May be called in interrupt or non-interrupt context
 *----------------------------------------------------------------
 */
int p80211_stt_findproto(u16 proto)
{
        /* Always return found for now.  This is the behavior used by the */
        /* Zoom Win95 driver when 802.1h mode is selected */
        /* TODO: If necessary, add an actual search we'll probably
         * need this to match the CMAC's way of doing things.
         * Need to do some testing to confirm.
         */

        if (proto == ETH_P_AARP)        /* APPLETALK */
                return 1;

        return 0;
}

/*----------------------------------------------------------------
 * p80211skb_rxmeta_detach
 *
 * Disconnects the frmmeta and rxmeta from an skb.
 *
 * Arguments:
 *      wlandev         The wlandev this skb belongs to.
 *      skb             The skb we're attaching to.
 *
 * Returns:
 *      0 on success, non-zero otherwise
 *
 * Call context:
 *      May be called in interrupt or non-interrupt context
 *----------------------------------------------------------------
 */
void p80211skb_rxmeta_detach(struct sk_buff *skb)
{
        struct p80211_rxmeta *rxmeta;
        struct p80211_frmmeta *frmmeta;

        /* Sanity checks */
        if (!skb) {     /* bad skb */
                pr_debug("Called w/ null skb.\n");
                return;
        }
        frmmeta = p80211skb_frmmeta(skb);
        if (!frmmeta) { /* no magic */
                pr_debug("Called w/ bad frmmeta magic.\n");
                return;
        }
        rxmeta = frmmeta->rx;
        if (!rxmeta) {  /* bad meta ptr */
                pr_debug("Called w/ bad rxmeta ptr.\n");
                return;
        }

        /* Free rxmeta */
        kfree(rxmeta);

        /* Clear skb->cb */
        memset(skb->cb, 0, sizeof(skb->cb));
}

/*----------------------------------------------------------------
 * p80211skb_rxmeta_attach
 *
 * Allocates a p80211rxmeta structure, initializes it, and attaches
 * it to an skb.
 *
 * Arguments:
 *      wlandev         The wlandev this skb belongs to.
 *      skb             The skb we're attaching to.
 *
 * Returns:
 *      0 on success, non-zero otherwise
 *
 * Call context:
 *      May be called in interrupt or non-interrupt context
 *----------------------------------------------------------------
 */
int p80211skb_rxmeta_attach(struct wlandevice *wlandev, struct sk_buff *skb)
{
        int result = 0;
        struct p80211_rxmeta *rxmeta;
        struct p80211_frmmeta *frmmeta;

        /* If these already have metadata, we error out! */
        if (p80211skb_rxmeta(skb)) {
                netdev_err(wlandev->netdev,
                           "%s: RXmeta already attached!\n", wlandev->name);
                result = 0;
                goto exit;
        }

        /* Allocate the rxmeta */
        rxmeta = kzalloc(sizeof(*rxmeta), GFP_ATOMIC);

        if (!rxmeta) {
                result = 1;
                goto exit;
        }

        /* Initialize the rxmeta */
        rxmeta->wlandev = wlandev;
        rxmeta->hosttime = jiffies;

        /* Overlay a frmmeta_t onto skb->cb */
        memset(skb->cb, 0, sizeof(struct p80211_frmmeta));
        frmmeta = (struct p80211_frmmeta *)(skb->cb);
        frmmeta->magic = P80211_FRMMETA_MAGIC;
        frmmeta->rx = rxmeta;
exit:
        return result;
}

/*----------------------------------------------------------------
 * p80211skb_free
 *
 * Frees an entire p80211skb by checking and freeing the meta struct
 * and then freeing the skb.
 *
 * Arguments:
 *      wlandev         The wlandev this skb belongs to.
 *      skb             The skb we're attaching to.
 *
 * Returns:
 *      0 on success, non-zero otherwise
 *
 * Call context:
 *      May be called in interrupt or non-interrupt context
 *----------------------------------------------------------------
 */
void p80211skb_free(struct wlandevice *wlandev, struct sk_buff *skb)
{
        struct p80211_frmmeta *meta;

        meta = p80211skb_frmmeta(skb);
        if (meta && meta->rx)
                p80211skb_rxmeta_detach(skb);
        else
                netdev_err(wlandev->netdev,
                           "Freeing an skb (%p) w/ no frmmeta.\n", skb);
        dev_kfree_skb(skb);
}