usr/src/sys/net/if_ethersubr.c

/*
 * Copyright (c) 1982, 1986, 1988 Regents of the University of California.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms are permitted
 * provided that the above copyright notice and this paragraph are
 * duplicated in all such forms and that any documentation,
 * advertising materials, and other materials related to such
 * distribution and use acknowledge that the software was developed
 * by the University of California, Berkeley.  The name of the
 * University may not be used to endorse or promote products derived
 * from this software without specific prior written permission.
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
 * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 *
 *      @(#)if_ethersubr.c      1.2 (Berkeley) %G%
 */

#include "param.h"
#include "systm.h"
#include "malloc.h"
#include "mbuf.h"
#include "protosw.h"
#include "socket.h"
#include "ioctl.h"
#include "errno.h"
#include "syslog.h"

#include "if.h"
#include "netisr.h"
#include "route.h"

#include "../machine/mtpr.h"

#ifdef INET
#include "../netinet/in.h"
#include "../netinet/in_var.h"
#include "../netinet/if_ether.h"
#endif

#ifdef NS
#include "../netns/ns.h"
#include "../netns/ns_if.h"
#endif

u_char  etherbroadcastaddr[6] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };

/*
 * Ethernet output routine.
 * Encapsulate a packet of type family for the local net.
 * Use trailer local net encapsulation if enough data in first
 * packet leaves a multiple of 512 bytes of data in remainder.
 * Assumes that ifp is actually pointer to arpcom structure.
 */
enoutput(ifp, m0, dst)
        register struct ifnet *ifp;
        struct mbuf *m0;
        struct sockaddr *dst;
{
        int type, s, error;
        u_char edst[6];
        struct in_addr idst;
        register struct mbuf *m = m0;
        register struct ether_header *eh;
        register int off;
        int usetrailers;
#define ac ((struct arpcom *)ifp)

        if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING)) {
                error = ENETDOWN;
                goto bad;
        }
        switch (dst->sa_family) {

#ifdef INET
        case AF_INET:
                idst = ((struct sockaddr_in *)dst)->sin_addr;
                if (!arpresolve(ac, m, &idst, edst, &usetrailers))
                        return (0);     /* if not yet resolved */
                off = m->m_pkthdr.len - m->m_len;
                if (usetrailers && off > 0 && (off & 0x1ff) == 0 &&
                    (m->m_flags & M_EXT) == 0 &&
                    m->m_data >= m->m_pktdat + 2 * sizeof (u_short)) {
                        type = ETHERTYPE_TRAIL + (off>>9);
                        m->m_data -= 2 * sizeof (u_short);
                        m->m_len += 2 * sizeof (u_short);
                        *mtod(m, u_short *) = htons((u_short)ETHERTYPE_IP);
                        *(mtod(m, u_short *) + 1) = htons((u_short)m->m_len);
                        goto gottrailertype;
                }
                type = ETHERTYPE_IP;
                off = 0;
                goto gottype;
#endif
#ifdef NS
        case AF_NS:
                type = ETHERTYPE_NS;
                bcopy((caddr_t)&(((struct sockaddr_ns *)dst)->sns_addr.x_host),
                (caddr_t)edst, sizeof (edst));
                off = 0;
                goto gottype;
#endif

        case AF_UNSPEC:
                eh = (struct ether_header *)dst->sa_data;
                bcopy((caddr_t)eh->ether_dhost, (caddr_t)edst, sizeof (edst));
                type = eh->ether_type;
                goto gottype;

        default:
                printf("%s%d: can't handle af%d\n", ifp->if_name, ifp->if_unit,
                        dst->sa_family);
                error = EAFNOSUPPORT;
                goto bad;
        }

gottrailertype:
        /*
         * Packet to be sent as trailer: move first packet
         * (control information) to end of chain.
         */
        while (m->m_next)
                m = m->m_next;
        m->m_next = m0;
        m = m0->m_next;
        m0->m_next = 0;
        m0 = m;

gottype:
        /*
         * Add local net header.  If no space in first mbuf,
         * allocate another.
         */
        M_PREPEND(m, sizeof (struct ether_header), M_DONTWAIT);
        if (m == 0) {
                error = ENOBUFS;
                goto bad;
        }
        eh = mtod(m, struct ether_header *);
        eh->ether_type = htons((u_short)type);
        bcopy((caddr_t)edst, (caddr_t)eh->ether_dhost, sizeof (edst));
        bcopy((caddr_t)ac->ac_enaddr, (caddr_t)eh->ether_shost,
            sizeof(eh->ether_shost));

        /*
         * Queue message on interface, and start output if interface
         * not yet active.
         */
        s = splimp();
        if (IF_QFULL(&ifp->if_snd)) {
                IF_DROP(&ifp->if_snd);
                splx(s);
                m_freem(m);
                return (ENOBUFS);
        }
        IF_ENQUEUE(&ifp->if_snd, m);
        if ((ifp->if_flags & IFF_OACTIVE) == 0)
                (*ifp->if_start)(ifp);
        splx(s);
        return (0);

bad:
        m_freem(m0);
        return (error);
}

/*
 * Pull packet off interface.  Off is nonzero if packet
 * has trailing header; we still have to drop
 * the type and length which are at the front of any trailer data.
 */
en_doproto(ifp, eh, m)
        struct ifnet *ifp;
        register struct ether_header *eh;
        struct mbuf *m;
{
        register struct ifqueue *inq;
        int s;

        if (bcmp((caddr_t)etherbroadcastaddr, (caddr_t)eh->ether_shost,
            sizeof(etherbroadcastaddr)) == 0)
                m->m_flags |= M_BCAST;

        switch (eh->ether_type) {
#ifdef INET
        case ETHERTYPE_IP:
                schednetisr(NETISR_IP);
                inq = &ipintrq;
                break;

        case ETHERTYPE_ARP:
                arpinput((struct arpcom *)ifp, m);
                return;
#endif
#ifdef NS
        case ETHERTYPE_NS:
                schednetisr(NETISR_NS);
                inq = &nsintrq;
                break;

#endif
        default:
                m_freem(m);
                return;
        }

        s = splimp();
        if (IF_QFULL(inq)) {
                IF_DROP(inq);
                m_freem(m);
        } else
                IF_ENQUEUE(inq, m);
        splx(s);
}

/*
 * Convert Ethernet address to printable (loggable) representation.
 */
char *
ether_sprintf(ap)
        register u_char *ap;
{
        register i;
        static char etherbuf[18];
        register char *cp = etherbuf;
        static char digits[] = "0123456789abcdef";

        for (i = 0; i < 6; i++) {
                *cp++ = digits[*ap >> 4];
                *cp++ = digits[*ap++ & 0xf];
                *cp++ = ':';
        }
        *--cp = 0;
        return (etherbuf);
}