eth.c

Go to the documentation of this file.

/*
 * INET     An implementation of the TCP/IP protocol suite for the LINUX
 *      operating system.  INET is implemented using the  BSD Socket
 *      interface as the means of communication with the user level.
 *
 *      Ethernet-type device handling.
 *
 * Version: @(#)eth.c   1.0.7   05/25/93
 *
 * Authors: Ross Biro
 *      Fred N. van Kempen, <[email protected]>
 *      Mark Evans, <[email protected]>
 *      Florian  La Roche, <[email protected]>
 *      Alan Cox, <[email protected]>
 *
 * Fixes:
 *      Mr Linux    : Arp problems
 *      Alan Cox    : Generic queue tidyup (very tiny here)
 *      Alan Cox    : eth_header ntohs should be htons
 *      Alan Cox    : eth_rebuild_header missing an htons and
 *                minor other things.
 *      Tegge       : Arp bug fixes.
 *      Florian     : Removed many unnecessary functions, code cleanup
 *                and changes for new arp and skbuff.
 *      Alan Cox    : Redid header building to reflect new format.
 *      Alan Cox    : ARP only when compiled with CONFIG_INET
 *      Greg Page   : 802.2 and SNAP stuff.
 *      Alan Cox    : MAC layer pointers/new format.
 *      Paul Gortmaker  : eth_copy_and_sum shouldn't csum padding.
 *      Alan Cox    : Protect against forwarding explosions with
 *                older network drivers and IFF_ALLMULTI.
 *  Christer Weinigel   : Better rebuild header message.
 *             Andrew Morton    : 26Feb01: kill ether_setup() - use netdev_boot_setup().
 *
 *      This program is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU General Public License
 *      as published by the Free Software Foundation; either version
 *      2 of the License, or (at your option) any later version.
 */
#include <linux/module.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/string.h>
#include <linux/mm.h>
#include <linux/socket.h>
#include <linux/in.h>
#include <linux/inet.h>
#include <linux/ip.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/skbuff.h>
#include <linux/errno.h>
#include <linux/init.h>
#include <linux/if_ether.h>
#include <net/dst.h>
#include <net/arp.h>
#include <net/sock.h>
#include <net/ipv6.h>
#include <net/ip.h>
#include <net/dsa.h>
#include <asm/uaccess.h>

__setup("ether=", netdev_boot_setup);

int eth_header(struct sk_buff *skb, struct net_device *dev,
           unsigned short type,
           const void *daddr, const void *saddr, unsigned int len)
{
    struct ethhdr *eth = (struct ethhdr *)skb_push(skb, ETH_HLEN);

    if (type != ETH_P_802_3 && type != ETH_P_802_2)
        eth->h_proto = htons(type);
    else
        eth->h_proto = htons(len);

    /*
     *      Set the source hardware address.
     */

    if (!saddr)
        saddr = dev->dev_addr;
    memcpy(eth->h_source, saddr, ETH_ALEN);

    if (daddr) {
        memcpy(eth->h_dest, daddr, ETH_ALEN);
        return ETH_HLEN;
    }

    /*
     *      Anyway, the loopback-device should never use this function...
     */

    if (dev->flags & (IFF_LOOPBACK | IFF_NOARP)) {
        memset(eth->h_dest, 0, ETH_ALEN);
        return ETH_HLEN;
    }

    return -ETH_HLEN;
}
EXPORT_SYMBOL(eth_header);

int eth_rebuild_header(struct sk_buff *skb)
{
    struct ethhdr *eth = (struct ethhdr *)skb->data;
    struct net_device *dev = skb->dev;

    switch (eth->h_proto) {
#ifdef CONFIG_INET
    case htons(ETH_P_IP):
        return arp_find(eth->h_dest, skb);
#endif
    default:
        printk(KERN_DEBUG
               "%s: unable to resolve type %X addresses.\n",
               dev->name, ntohs(eth->h_proto));

        memcpy(eth->h_source, dev->dev_addr, ETH_ALEN);
        break;
    }

    return 0;
}
EXPORT_SYMBOL(eth_rebuild_header);

__be16 eth_type_trans(struct sk_buff *skb, struct net_device *dev)
{
    struct ethhdr *eth;

    skb->dev = dev;
    skb_reset_mac_header(skb);
    skb_pull_inline(skb, ETH_HLEN);
    eth = eth_hdr(skb);

    if (unlikely(is_multicast_ether_addr(eth->h_dest))) {
        if (ether_addr_equal_64bits(eth->h_dest, dev->broadcast))
            skb->pkt_type = PACKET_BROADCAST;
        else
            skb->pkt_type = PACKET_MULTICAST;
    }

    /*
     *      This ALLMULTI check should be redundant by 1.4
     *      so don't forget to remove it.
     *
     *      Seems, you forgot to remove it. All silly devices
     *      seems to set IFF_PROMISC.
     */

    else if (1 /*dev->flags&IFF_PROMISC */ ) {
        if (unlikely(!ether_addr_equal_64bits(eth->h_dest,
                              dev->dev_addr)))
            skb->pkt_type = PACKET_OTHERHOST;
    }

    /*
     * Some variants of DSA tagging don't have an ethertype field
     * at all, so we check here whether one of those tagging
     * variants has been configured on the receiving interface,
     * and if so, set skb->protocol without looking at the packet.
     */
    if (netdev_uses_dsa_tags(dev))
        return htons(ETH_P_DSA);
    if (netdev_uses_trailer_tags(dev))
        return htons(ETH_P_TRAILER);

    if (ntohs(eth->h_proto) >= 1536)
        return eth->h_proto;

    /*
     *      This is a magic hack to spot IPX packets. Older Novell breaks
     *      the protocol design and runs IPX over 802.3 without an 802.2 LLC
     *      layer. We look for FFFF which isn't a used 802.2 SSAP/DSAP. This
     *      won't work for fault tolerant netware but does for the rest.
     */
    if (skb->len >= 2 && *(unsigned short *)(skb->data) == 0xFFFF)
        return htons(ETH_P_802_3);

    /*
     *      Real 802.2 LLC
     */
    return htons(ETH_P_802_2);
}
EXPORT_SYMBOL(eth_type_trans);

int eth_header_parse(const struct sk_buff *skb, unsigned char *haddr)
{
    const struct ethhdr *eth = eth_hdr(skb);
    memcpy(haddr, eth->h_source, ETH_ALEN);
    return ETH_ALEN;
}
EXPORT_SYMBOL(eth_header_parse);

int eth_header_cache(const struct neighbour *neigh, struct hh_cache *hh, __be16 type)
{
    struct ethhdr *eth;
    const struct net_device *dev = neigh->dev;

    eth = (struct ethhdr *)
        (((u8 *) hh->hh_data) + (HH_DATA_OFF(sizeof(*eth))));

    if (type == htons(ETH_P_802_3))
        return -1;

    eth->h_proto = type;
    memcpy(eth->h_source, dev->dev_addr, ETH_ALEN);
    memcpy(eth->h_dest, neigh->ha, ETH_ALEN);
    hh->hh_len = ETH_HLEN;
    return 0;
}
EXPORT_SYMBOL(eth_header_cache);

void eth_header_cache_update(struct hh_cache *hh,
                 const struct net_device *dev,
                 const unsigned char *haddr)
{
    memcpy(((u8 *) hh->hh_data) + HH_DATA_OFF(sizeof(struct ethhdr)),
           haddr, ETH_ALEN);
}
EXPORT_SYMBOL(eth_header_cache_update);

int eth_mac_addr(struct net_device *dev, void *p)
{
    struct sockaddr *addr = p;

    if (!(dev->priv_flags & IFF_LIVE_ADDR_CHANGE) && netif_running(dev))
        return -EBUSY;
    if (!is_valid_ether_addr(addr->sa_data))
        return -EADDRNOTAVAIL;
    memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN);
    /* if device marked as NET_ADDR_RANDOM, reset it */
    dev->addr_assign_type &= ~NET_ADDR_RANDOM;
    return 0;
}
EXPORT_SYMBOL(eth_mac_addr);

int eth_change_mtu(struct net_device *dev, int new_mtu)
{
    if (new_mtu < 68 || new_mtu > ETH_DATA_LEN)
        return -EINVAL;
    dev->mtu = new_mtu;
    return 0;
}
EXPORT_SYMBOL(eth_change_mtu);

int eth_validate_addr(struct net_device *dev)
{
    if (!is_valid_ether_addr(dev->dev_addr))
        return -EADDRNOTAVAIL;

    return 0;
}
EXPORT_SYMBOL(eth_validate_addr);

const struct header_ops eth_header_ops ____cacheline_aligned = {
    .create     = eth_header,
    .parse      = eth_header_parse,
    .rebuild    = eth_rebuild_header,
    .cache      = eth_header_cache,
    .cache_update   = eth_header_cache_update,
};

void ether_setup(struct net_device *dev)
{
    dev->header_ops     = &eth_header_ops;
    dev->type       = ARPHRD_ETHER;
    dev->hard_header_len    = ETH_HLEN;
    dev->mtu        = ETH_DATA_LEN;
    dev->addr_len       = ETH_ALEN;
    dev->tx_queue_len   = 1000; /* Ethernet wants good queues */
    dev->flags      = IFF_BROADCAST|IFF_MULTICAST;
    dev->priv_flags     |= IFF_TX_SKB_SHARING;

    memset(dev->broadcast, 0xFF, ETH_ALEN);

}
EXPORT_SYMBOL(ether_setup);

struct net_device *alloc_etherdev_mqs(int sizeof_priv, unsigned int txqs,
                      unsigned int rxqs)
{
    return alloc_netdev_mqs(sizeof_priv, "eth%d", ether_setup, txqs, rxqs);
}
EXPORT_SYMBOL(alloc_etherdev_mqs);

static size_t _format_mac_addr(char *buf, int buflen,
                   const unsigned char *addr, int len)
{
    int i;
    char *cp = buf;

    for (i = 0; i < len; i++) {
        cp += scnprintf(cp, buflen - (cp - buf), "%02x", addr[i]);
        if (i == len - 1)
            break;
        cp += scnprintf(cp, buflen - (cp - buf), ":");
    }
    return cp - buf;
}

ssize_t sysfs_format_mac(char *buf, const unsigned char *addr, int len)
{
    size_t l;

    l = _format_mac_addr(buf, PAGE_SIZE, addr, len);
    l += scnprintf(buf + l, PAGE_SIZE - l, "\n");
    return (ssize_t)l;
}
EXPORT_SYMBOL(sysfs_format_mac);