URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [rtos/] [ecos-2.0/] [packages/] [net/] [bsd_tcpip/] [v2_0/] [src/] [sys/] [net/] [if_loop.c] - Blame information for rev 174

Details | Compare with Previous | View Log


//==========================================================================
//
//      src/sys/net/if_loop.c
//
//==========================================================================
//####BSDCOPYRIGHTBEGIN####
//
// -------------------------------------------
//
// Portions of this software may have been derived from OpenBSD, 
// FreeBSD or other sources, and are covered by the appropriate
// copyright disclaimers included herein.
//
// Portions created by Red Hat are
// Copyright (C) 2002 Red Hat, Inc. All Rights Reserved.
//
// -------------------------------------------
//
//####BSDCOPYRIGHTEND####
//==========================================================================
 
/*
 * Copyright (c) 1982, 1986, 1993
 *      The Regents of the University of California.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *      This product includes software developed by the University of
 *      California, Berkeley and its contributors.
 * 4. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 *      @(#)if_loop.c   8.1 (Berkeley) 6/10/93
 * $FreeBSD: src/sys/net/if_loop.c,v 1.47.2.5 2001/07/03 11:01:41 ume Exp $
 */
 
/*
 * Loopback interface driver for protocol testing and timing.
 */
#include <sys/param.h>
#include <sys/mbuf.h>
#include <sys/socket.h>
#include <sys/sockio.h>
 
#include <net/if.h>
#include <net/if_types.h>
#include <net/netisr.h>
#include <net/route.h>
 
#ifdef  INET
#include <netinet/in.h>
#include <netinet/in_var.h>
#endif
 
#ifdef IPX
#include <netipx/ipx.h>
#include <netipx/ipx_if.h>
#endif
 
#ifdef INET6
#ifndef INET
#include <netinet/in.h>
#endif
#include <netinet6/in6_var.h>
#include <netinet/ip6.h>
#endif
 
#ifdef NS
#include <netns/ns.h>
#include <netns/ns_if.h>
#endif
 
#ifdef NETATALK
#include <netatalk/at.h>
#include <netatalk/at_var.h>
#endif /* NETATALK */
 
int loioctl __P((struct ifnet *, u_long, caddr_t));
static void lortrequest __P((int, struct rtentry *, struct sockaddr *));
 
static void loopattach __P((void *));
#ifdef ALTQ
static void lo_altqstart __P((struct ifnet *));
#endif
PSEUDO_SET(loopattach, if_loop);
 
int looutput __P((struct ifnet *ifp,
                struct mbuf *m, struct sockaddr *dst, struct rtentry *rt));
 
#ifdef TINY_LOMTU
#define LOMTU   (1024+512)
#elif defined(LARGE_LOMTU)
#define LOMTU   131072
#else
#define LOMTU   16384
#endif
 
struct  ifnet loif[NLOOP];
 
/* ARGSUSED */
static void
loopattach(dummy)
        void *dummy;
{
        register struct ifnet *ifp;
        register int i = 0;
 
        for (ifp = loif; i < NLOOP; ifp++) {
            ifp->if_name = "lo";
            ifp->if_unit = i++;
            ifp->if_mtu = LOMTU;
            ifp->if_flags = IFF_LOOPBACK | IFF_MULTICAST;
            ifp->if_ioctl = loioctl;
            ifp->if_output = looutput;
            ifp->if_type = IFT_LOOP;
            IFQ_SET_MAXLEN(&ifp->if_snd, ifqmaxlen);
            IFQ_SET_READY(&ifp->if_snd);
            if_attach(ifp);
#ifdef BPF
            bpfattach(ifp, DLT_NULL, sizeof(u_int));
#endif
        }
}
 
int
looutput(ifp, m, dst, rt)
        struct ifnet *ifp;
        register struct mbuf *m;
        struct sockaddr *dst;
        register struct rtentry *rt;
{
        if ((m->m_flags & M_PKTHDR) == 0)
                panic("looutput no HDR");
 
        if (rt && rt->rt_flags & (RTF_REJECT|RTF_BLACKHOLE)) {
                m_freem(m);
                return (rt->rt_flags & RTF_BLACKHOLE ? 0 :
                        rt->rt_flags & RTF_HOST ? EHOSTUNREACH : ENETUNREACH);
        }
        /*
         * KAME requires that the packet to be contiguous on the
         * mbuf.  We need to make that sure.
         * this kind of code should be avoided.
         * XXX: fails to join if interface MTU > MCLBYTES.  jumbogram?
         */
        if (m && m->m_next != NULL && m->m_pkthdr.len < MCLBYTES) {
                struct mbuf *n;
 
                MGETHDR(n, M_DONTWAIT, MT_HEADER);
                if (!n)
                        goto contiguousfail;
                MCLGET(n, M_DONTWAIT);
                if (! (n->m_flags & M_EXT)) {
                        m_freem(n);
                        goto contiguousfail;
                }
 
                m_copydata(m, 0, m->m_pkthdr.len, mtod(n, caddr_t));
                n->m_pkthdr = m->m_pkthdr;
                n->m_len = m->m_pkthdr.len;
                n->m_pkthdr.aux = m->m_pkthdr.aux;
                m->m_pkthdr.aux = (struct mbuf *)NULL;
                m_freem(m);
                m = n;
        }
        if (0) {
contiguousfail:
                printf("looutput: mbuf allocation failed\n");
        }
 
        ifp->if_opackets++;
        ifp->if_obytes += m->m_pkthdr.len;
#if 1   /* XXX */
        switch (dst->sa_family) {
        case AF_INET:
        case AF_INET6:
        case AF_IPX:
        case AF_NS:
        case AF_APPLETALK:
                break;
        default:
                printf("looutput: af=%d unexpected\n", dst->sa_family);
                m_freem(m);
                return (EAFNOSUPPORT);
        }
#endif
        return(if_simloop(ifp, m, dst->sa_family, 0));
}
 
/*
 * if_simloop()
 *
 * This function is to support software emulation of hardware loopback,
 * i.e., for interfaces with the IFF_SIMPLEX attribute. Since they can't
 * hear their own broadcasts, we create a copy of the packet that we
 * would normally receive via a hardware loopback.
 *
 * This function expects the packet to include the media header of length hlen.
 */
 
int
if_simloop(ifp, m, af, hlen)
        struct ifnet *ifp;
        struct mbuf *m;
        int af;
        int hlen;
{
        int s, isr;
        register struct ifqueue *ifq = 0;
 
        m->m_pkthdr.rcvif = ifp;
 
        /* BPF write needs to be handled specially */
        if (af == AF_UNSPEC) {
                af = *(mtod(m, int *));
                m->m_len -= sizeof(int);
                m->m_pkthdr.len -= sizeof(int);
                m->m_data += sizeof(int);
        }
 
#ifdef BPF
        /* Let BPF see incoming packet */
        if (ifp->if_bpf) {
                struct mbuf m0, *n = m;
 
                if (ifp->if_bpf->bif_dlt == DLT_NULL) {
                        /*
                         * We need to prepend the address family as
                         * a four byte field.  Cons up a dummy header
                         * to pacify bpf.  This is safe because bpf
                         * will only read from the mbuf (i.e., it won't
                         * try to free it or keep a pointer a to it).
                         */
                        m0.m_next = m;
                        m0.m_len = 4;
                        m0.m_data = (char *)&af;
                        n = &m0;
                }
                bpf_mtap(ifp, n);
        }
#endif
 
        /* Strip away media header */
        if (hlen > 0) {
                m_adj(m, hlen);
#ifdef __alpha__
                /* The alpha doesn't like unaligned data.
                 * We move data down in the first mbuf */
                if (mtod(m, vm_offset_t) & 3) {
//                      KASSERT(hlen >= 3, ("if_simloop: hlen too small"));
                        bcopy(m->m_data,
                            (char *)(mtod(m, vm_offset_t)
                                - (mtod(m, vm_offset_t) & 3)),
                            m->m_len);
                        mtod(m,vm_offset_t) -= (mtod(m, vm_offset_t) & 3);
                }
#endif
        }
 
        /* Deliver to upper layer protocol */
        switch (af) {
#ifdef INET
        case AF_INET:
                ifq = &ipintrq;
                isr = NETISR_IP;
                break;
#endif
#ifdef INET6
        case AF_INET6:
                m->m_flags |= M_LOOP;
                ifq = &ip6intrq;
                isr = NETISR_IPV6;
                break;
#endif
#ifdef IPX
        case AF_IPX:
                ifq = &ipxintrq;
                isr = NETISR_IPX;
                break;
#endif
#ifdef NS
        case AF_NS:
                ifq = &nsintrq;
                isr = NETISR_NS;
                break;
#endif
#ifdef NETATALK
        case AF_APPLETALK:
                ifq = &atintrq2;
                isr = NETISR_ATALK;
                break;
#endif /* NETATALK */
        default:
                printf("if_simloop: can't handle af=%d\n", af);
                m_freem(m);
                return (EAFNOSUPPORT);
        }
        s = splimp();
        if (IF_QFULL(ifq)) {
                IF_DROP(ifq);
                m_freem(m);
                splx(s);
                return (ENOBUFS);
        }
        IF_ENQUEUE(ifq, m);
        schednetisr(isr);
        ifp->if_ipackets++;
        ifp->if_ibytes += m->m_pkthdr.len;
        splx(s);
        return (0);
}
 
#ifdef ALTQ
static void
lo_altqstart(ifp)
        struct ifnet *ifp;
{
        struct ifqueue *ifq;
        struct mbuf *m;
        int32_t af, *afp;
        int s, isr;
 
        while (1) {
                s = splimp();
                IFQ_DEQUEUE(&ifp->if_snd, m);
                splx(s);
                if (m == NULL)
                        return;
 
                afp = mtod(m, int32_t *);
                af = *afp;
                m_adj(m, sizeof(int32_t));
 
                switch (af) {
#ifdef INET
                case AF_INET:
                        ifq = &ipintrq;
                        isr = NETISR_IP;
                        break;
#endif
#ifdef INET6
                case AF_INET6:
                        m->m_flags |= M_LOOP;
                        ifq = &ip6intrq;
                        isr = NETISR_IPV6;
                        break;
#endif
#ifdef IPX
                case AF_IPX:
                        ifq = &ipxintrq;
                        isr = NETISR_IPX;
                        break;
#endif
#ifdef NS
                case AF_NS:
                        ifq = &nsintrq;
                        isr = NETISR_NS;
                        break;
#endif
#ifdef ISO
                case AF_ISO:
                        ifq = &clnlintrq;
                        isr = NETISR_ISO;
                        break;
#endif
#ifdef NETATALK
                case AF_APPLETALK:
                        ifq = &atintrq2;
                        isr = NETISR_ATALK;
                        break;
#endif NETATALK
                default:
                        printf("lo_altqstart: can't handle af%d\n", af);
                        m_freem(m);
                        return;
                }
 
                s = splimp();
                if (IF_QFULL(ifq)) {
                        IF_DROP(ifq);
                        m_freem(m);
                        splx(s);
                        return;
                }
                IF_ENQUEUE(ifq, m);
                schednetisr(isr);
                ifp->if_ipackets++;
                ifp->if_ibytes += m->m_pkthdr.len;
                splx(s);
        }
}
#endif /* ALTQ */
 
/* ARGSUSED */
static void
lortrequest(cmd, rt, sa)
        int cmd;
        struct rtentry *rt;
        struct sockaddr *sa;
{
        if (rt) {
                rt->rt_rmx.rmx_mtu = rt->rt_ifp->if_mtu; /* for ISO */
                /*
                 * For optimal performance, the send and receive buffers
                 * should be at least twice the MTU plus a little more for
                 * overhead.
                 */
                rt->rt_rmx.rmx_recvpipe =
                        rt->rt_rmx.rmx_sendpipe = 3 * LOMTU;
        }
}
 
/*
 * Process an ioctl request.
 */
/* ARGSUSED */
int
loioctl(ifp, cmd, data)
        register struct ifnet *ifp;
        u_long cmd;
        caddr_t data;
{
        register struct ifaddr *ifa;
        register struct ifreq *ifr = (struct ifreq *)data;
        register int error = 0;
 
        switch (cmd) {
 
        case SIOCSIFADDR:
                ifp->if_flags |= IFF_UP | IFF_RUNNING | IFF_LOOPBACK;
                ifa = (struct ifaddr *)data;
                ifa->ifa_rtrequest = lortrequest;
                /*
                 * Everything else is done at a higher level.
                 */
                break;
 
        case SIOCADDMULTI:
        case SIOCDELMULTI:
                if (ifr == 0) {
                        error = EAFNOSUPPORT;           /* XXX */
                        break;
                }
                switch (ifr->ifr_addr.sa_family) {
 
#ifdef INET
                case AF_INET:
                        break;
#endif
#ifdef INET6
                case AF_INET6:
                        break;
#endif
 
                default:
                        error = EAFNOSUPPORT;
                        break;
                }
                break;
 
        case SIOCSIFMTU:
                ifp->if_mtu = ifr->ifr_mtu;
                break;
 
        case SIOCSIFFLAGS:
                break;
 
        default:
                error = EINVAL;
        }
        return (error);
}

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [rtos/] [ecos-2.0/] [packages/] [net/] [bsd_tcpip/] [v2_0/] [src/] [sys/] [net/] [if_loop.c] - Blame information for rev 174

Line No.	Rev	Author	Line
1	27	unneback	`//==========================================================================`
2			`//`
3			`// src/sys/net/if_loop.c`
4			`//`
5			`//==========================================================================`
6			`//####BSDCOPYRIGHTBEGIN####`
7			`//`
8			`// -------------------------------------------`
9			`//`
10			`// Portions of this software may have been derived from OpenBSD,`
11			`// FreeBSD or other sources, and are covered by the appropriate`
12			`// copyright disclaimers included herein.`
13			`//`
14			`// Portions created by Red Hat are`
15			`// Copyright (C) 2002 Red Hat, Inc. All Rights Reserved.`
16			`//`
17			`// -------------------------------------------`
18			`//`
19			`//####BSDCOPYRIGHTEND####`
20			`//==========================================================================`
21
22			`/*`
23			`* Copyright (c) 1982, 1986, 1993`
24			`* The Regents of the University of California. All rights reserved.`
25			`*`
26			`* Redistribution and use in source and binary forms, with or without`
27			`* modification, are permitted provided that the following conditions`
28			`* are met:`
29			`* 1. Redistributions of source code must retain the above copyright`
30			`* notice, this list of conditions and the following disclaimer.`
31			`* 2. Redistributions in binary form must reproduce the above copyright`
32			`* notice, this list of conditions and the following disclaimer in the`
33			`* documentation and/or other materials provided with the distribution.`
34			`* 3. All advertising materials mentioning features or use of this software`
35			`* must display the following acknowledgement:`
36			`* This product includes software developed by the University of`
37			`* California, Berkeley and its contributors.`
38			`* 4. Neither the name of the University nor the names of its contributors`
39			`* may be used to endorse or promote products derived from this software`
40			`* without specific prior written permission.`
41			`*`
42			* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
43			`* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE`
44			`* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE`
45			`* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE`
46			`* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL`
47			`* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS`
48			`* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)`
49			`* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT`
50			`* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY`
51			`* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF`
52			`* SUCH DAMAGE.`
53			`*`
54			`* @(#)if_loop.c 8.1 (Berkeley) 6/10/93`
55			`* $FreeBSD: src/sys/net/if_loop.c,v 1.47.2.5 2001/07/03 11:01:41 ume Exp $`
56			`*/`
57
58			`/*`
59			`* Loopback interface driver for protocol testing and timing.`
60			`*/`
61			`#include <sys/param.h>`
62			`#include <sys/mbuf.h>`
63			`#include <sys/socket.h>`
64			`#include <sys/sockio.h>`
65
66			`#include <net/if.h>`
67			`#include <net/if_types.h>`
68			`#include <net/netisr.h>`
69			`#include <net/route.h>`
70
71			`#ifdef INET`
72			`#include <netinet/in.h>`
73			`#include <netinet/in_var.h>`
74			`#endif`
75
76			`#ifdef IPX`
77			`#include <netipx/ipx.h>`
78			`#include <netipx/ipx_if.h>`
79			`#endif`
80
81			`#ifdef INET6`
82			`#ifndef INET`
83			`#include <netinet/in.h>`
84			`#endif`
85			`#include <netinet6/in6_var.h>`
86			`#include <netinet/ip6.h>`
87			`#endif`
88
89			`#ifdef NS`
90			`#include <netns/ns.h>`
91			`#include <netns/ns_if.h>`
92			`#endif`
93
94			`#ifdef NETATALK`
95			`#include <netatalk/at.h>`
96			`#include <netatalk/at_var.h>`
97			`#endif /* NETATALK */`
98
99			`int loioctl __P((struct ifnet *, u_long, caddr_t));`
100			`static void lortrequest __P((int, struct rtentry , struct sockaddr ));`
101
102			`static void loopattach __P((void *));`
103			`#ifdef ALTQ`
104			`static void lo_altqstart __P((struct ifnet *));`
105			`#endif`
106			`PSEUDO_SET(loopattach, if_loop);`
107
108			`int looutput __P((struct ifnet *ifp,`
109			`struct mbuf m, struct sockaddr dst, struct rtentry *rt));`
110
111			`#ifdef TINY_LOMTU`
112			`#define LOMTU (1024+512)`
113			`#elif defined(LARGE_LOMTU)`
114			`#define LOMTU 131072`
115			`#else`
116			`#define LOMTU 16384`
117			`#endif`
118
119			`struct ifnet loif[NLOOP];`
120
121			`/* ARGSUSED */`
122			`static void`
123			`loopattach(dummy)`
124			`void *dummy;`
125			`{`
126			`register struct ifnet *ifp;`
127			`register int i = 0;`
128
129			`for (ifp = loif; i < NLOOP; ifp++) {`
130			`ifp->if_name = "lo";`
131			`ifp->if_unit = i++;`
132			`ifp->if_mtu = LOMTU;`
133			`ifp->if_flags = IFF_LOOPBACK \| IFF_MULTICAST;`
134			`ifp->if_ioctl = loioctl;`
135			`ifp->if_output = looutput;`
136			`ifp->if_type = IFT_LOOP;`
137			`IFQ_SET_MAXLEN(&ifp->if_snd, ifqmaxlen);`
138			`IFQ_SET_READY(&ifp->if_snd);`
139			`if_attach(ifp);`
140			`#ifdef BPF`
141			`bpfattach(ifp, DLT_NULL, sizeof(u_int));`
142			`#endif`
143			`}`
144			`}`
145
146			`int`
147			`looutput(ifp, m, dst, rt)`
148			`struct ifnet *ifp;`
149			`register struct mbuf *m;`
150			`struct sockaddr *dst;`
151			`register struct rtentry *rt;`
152			`{`
153			`if ((m->m_flags & M_PKTHDR) == 0)`
154			`panic("looutput no HDR");`
155
156			`if (rt && rt->rt_flags & (RTF_REJECT\|RTF_BLACKHOLE)) {`
157			`m_freem(m);`
158			`return (rt->rt_flags & RTF_BLACKHOLE ? 0 :`
159			`rt->rt_flags & RTF_HOST ? EHOSTUNREACH : ENETUNREACH);`
160			`}`
161			`/*`
162			`* KAME requires that the packet to be contiguous on the`
163			`* mbuf. We need to make that sure.`
164			`* this kind of code should be avoided.`
165			`* XXX: fails to join if interface MTU > MCLBYTES. jumbogram?`
166			`*/`
167			`if (m && m->m_next != NULL && m->m_pkthdr.len < MCLBYTES) {`
168			`struct mbuf *n;`
169
170			`MGETHDR(n, M_DONTWAIT, MT_HEADER);`
171			`if (!n)`
172			`goto contiguousfail;`
173			`MCLGET(n, M_DONTWAIT);`
174			`if (! (n->m_flags & M_EXT)) {`
175			`m_freem(n);`
176			`goto contiguousfail;`
177			`}`
178
179			`m_copydata(m, 0, m->m_pkthdr.len, mtod(n, caddr_t));`
180			`n->m_pkthdr = m->m_pkthdr;`
181			`n->m_len = m->m_pkthdr.len;`
182			`n->m_pkthdr.aux = m->m_pkthdr.aux;`
183			`m->m_pkthdr.aux = (struct mbuf *)NULL;`
184			`m_freem(m);`
185			`m = n;`
186			`}`
187			`if (0) {`
188			`contiguousfail:`
189			`printf("looutput: mbuf allocation failed\n");`
190			`}`
191
192			`ifp->if_opackets++;`
193			`ifp->if_obytes += m->m_pkthdr.len;`
194			`#if 1 /* XXX */`
195			`switch (dst->sa_family) {`
196			`case AF_INET:`
197			`case AF_INET6:`
198			`case AF_IPX:`
199			`case AF_NS:`
200			`case AF_APPLETALK:`
201			`break;`
202			`default:`
203			`printf("looutput: af=%d unexpected\n", dst->sa_family);`
204			`m_freem(m);`
205			`return (EAFNOSUPPORT);`
206			`}`
207			`#endif`
208			`return(if_simloop(ifp, m, dst->sa_family, 0));`
209			`}`
210
211			`/*`
212			`* if_simloop()`
213			`*`
214			`* This function is to support software emulation of hardware loopback,`
215			`* i.e., for interfaces with the IFF_SIMPLEX attribute. Since they can't`
216			`* hear their own broadcasts, we create a copy of the packet that we`
217			`* would normally receive via a hardware loopback.`
218			`*`
219			`* This function expects the packet to include the media header of length hlen.`
220			`*/`
221
222			`int`
223			`if_simloop(ifp, m, af, hlen)`
224			`struct ifnet *ifp;`
225			`struct mbuf *m;`
226			`int af;`
227			`int hlen;`
228			`{`
229			`int s, isr;`
230			`register struct ifqueue *ifq = 0;`
231
232			`m->m_pkthdr.rcvif = ifp;`
233
234			`/* BPF write needs to be handled specially */`
235			`if (af == AF_UNSPEC) {`
236			`af = (mtod(m, int ));`
237			`m->m_len -= sizeof(int);`
238			`m->m_pkthdr.len -= sizeof(int);`
239			`m->m_data += sizeof(int);`
240			`}`
241
242			`#ifdef BPF`
243			`/* Let BPF see incoming packet */`
244			`if (ifp->if_bpf) {`
245			`struct mbuf m0, *n = m;`
246
247			`if (ifp->if_bpf->bif_dlt == DLT_NULL) {`
248			`/*`
249			`* We need to prepend the address family as`
250			`* a four byte field. Cons up a dummy header`
251			`* to pacify bpf. This is safe because bpf`
252			`* will only read from the mbuf (i.e., it won't`
253			`* try to free it or keep a pointer a to it).`
254			`*/`
255			`m0.m_next = m;`
256			`m0.m_len = 4;`
257			`m0.m_data = (char *)⁡`
258			`n = &m0;`
259			`}`
260			`bpf_mtap(ifp, n);`
261			`}`
262			`#endif`
263
264			`/* Strip away media header */`
265			`if (hlen > 0) {`
266			`m_adj(m, hlen);`
267			`#ifdef __alpha__`
268			`/* The alpha doesn't like unaligned data.`
269			`* We move data down in the first mbuf */`
270			`if (mtod(m, vm_offset_t) & 3) {`
271			`// KASSERT(hlen >= 3, ("if_simloop: hlen too small"));`
272			`bcopy(m->m_data,`
273			`(char *)(mtod(m, vm_offset_t)`
274			`- (mtod(m, vm_offset_t) & 3)),`
275			`m->m_len);`
276			`mtod(m,vm_offset_t) -= (mtod(m, vm_offset_t) & 3);`
277			`}`
278			`#endif`
279			`}`
280
281			`/* Deliver to upper layer protocol */`
282			`switch (af) {`
283			`#ifdef INET`
284			`case AF_INET:`
285			`ifq = &ipintrq;`
286			`isr = NETISR_IP;`
287			`break;`
288			`#endif`
289			`#ifdef INET6`
290			`case AF_INET6:`
291			`m->m_flags \|= M_LOOP;`
292			`ifq = &ip6intrq;`
293			`isr = NETISR_IPV6;`
294			`break;`
295			`#endif`
296			`#ifdef IPX`
297			`case AF_IPX:`
298			`ifq = &ipxintrq;`
299			`isr = NETISR_IPX;`
300			`break;`
301			`#endif`
302			`#ifdef NS`
303			`case AF_NS:`
304			`ifq = &nsintrq;`
305			`isr = NETISR_NS;`
306			`break;`
307			`#endif`
308			`#ifdef NETATALK`
309			`case AF_APPLETALK:`
310			`ifq = &atintrq2;`
311			`isr = NETISR_ATALK;`
312			`break;`
313			`#endif /* NETATALK */`
314			`default:`
315			`printf("if_simloop: can't handle af=%d\n", af);`
316			`m_freem(m);`
317			`return (EAFNOSUPPORT);`
318			`}`
319			`s = splimp();`
320			`if (IF_QFULL(ifq)) {`
321			`IF_DROP(ifq);`
322			`m_freem(m);`
323			`splx(s);`
324			`return (ENOBUFS);`
325			`}`
326			`IF_ENQUEUE(ifq, m);`
327			`schednetisr(isr);`
328			`ifp->if_ipackets++;`
329			`ifp->if_ibytes += m->m_pkthdr.len;`
330			`splx(s);`
331			`return (0);`
332			`}`
333
334			`#ifdef ALTQ`
335			`static void`
336			`lo_altqstart(ifp)`
337			`struct ifnet *ifp;`
338			`{`
339			`struct ifqueue *ifq;`
340			`struct mbuf *m;`
341			`int32_t af, *afp;`
342			`int s, isr;`
343
344			`while (1) {`
345			`s = splimp();`
346			`IFQ_DEQUEUE(&ifp->if_snd, m);`
347			`splx(s);`
348			`if (m == NULL)`
349			`return;`
350
351			`afp = mtod(m, int32_t *);`
352			`af = *afp;`
353			`m_adj(m, sizeof(int32_t));`
354
355			`switch (af) {`
356			`#ifdef INET`
357			`case AF_INET:`
358			`ifq = &ipintrq;`
359			`isr = NETISR_IP;`
360			`break;`
361			`#endif`
362			`#ifdef INET6`
363			`case AF_INET6:`
364			`m->m_flags \|= M_LOOP;`
365			`ifq = &ip6intrq;`
366			`isr = NETISR_IPV6;`
367			`break;`
368			`#endif`
369			`#ifdef IPX`
370			`case AF_IPX:`
371			`ifq = &ipxintrq;`
372			`isr = NETISR_IPX;`
373			`break;`
374			`#endif`
375			`#ifdef NS`
376			`case AF_NS:`
377			`ifq = &nsintrq;`
378			`isr = NETISR_NS;`
379			`break;`
380			`#endif`
381			`#ifdef ISO`
382			`case AF_ISO:`
383			`ifq = &clnlintrq;`
384			`isr = NETISR_ISO;`
385			`break;`
386			`#endif`
387			`#ifdef NETATALK`
388			`case AF_APPLETALK:`
389			`ifq = &atintrq2;`
390			`isr = NETISR_ATALK;`
391			`break;`
392			`#endif NETATALK`
393			`default:`
394			`printf("lo_altqstart: can't handle af%d\n", af);`
395			`m_freem(m);`
396			`return;`
397			`}`
398
399			`s = splimp();`
400			`if (IF_QFULL(ifq)) {`
401			`IF_DROP(ifq);`
402			`m_freem(m);`
403			`splx(s);`
404			`return;`
405			`}`
406			`IF_ENQUEUE(ifq, m);`
407			`schednetisr(isr);`
408			`ifp->if_ipackets++;`
409			`ifp->if_ibytes += m->m_pkthdr.len;`
410			`splx(s);`
411			`}`
412			`}`
413			`#endif /* ALTQ */`
414
415			`/* ARGSUSED */`
416			`static void`
417			`lortrequest(cmd, rt, sa)`
418			`int cmd;`
419			`struct rtentry *rt;`
420			`struct sockaddr *sa;`
421			`{`
422			`if (rt) {`
423			`rt->rt_rmx.rmx_mtu = rt->rt_ifp->if_mtu; /* for ISO */`
424			`/*`
425			`* For optimal performance, the send and receive buffers`
426			`* should be at least twice the MTU plus a little more for`
427			`* overhead.`
428			`*/`
429			`rt->rt_rmx.rmx_recvpipe =`
430			`rt->rt_rmx.rmx_sendpipe = 3 * LOMTU;`
431			`}`
432			`}`
433
434			`/*`
435			`* Process an ioctl request.`
436			`*/`
437			`/* ARGSUSED */`
438			`int`
439			`loioctl(ifp, cmd, data)`
440			`register struct ifnet *ifp;`
441			`u_long cmd;`
442			`caddr_t data;`
443			`{`
444			`register struct ifaddr *ifa;`
445			`register struct ifreq ifr = (struct ifreq )data;`
446			`register int error = 0;`
447
448			`switch (cmd) {`
449
450			`case SIOCSIFADDR:`
451			`ifp->if_flags \|= IFF_UP \| IFF_RUNNING \| IFF_LOOPBACK;`
452			`ifa = (struct ifaddr *)data;`
453			`ifa->ifa_rtrequest = lortrequest;`
454			`/*`
455			`* Everything else is done at a higher level.`
456			`*/`
457			`break;`
458
459			`case SIOCADDMULTI:`
460			`case SIOCDELMULTI:`
461			`if (ifr == 0) {`
462			`error = EAFNOSUPPORT; /* XXX */`
463			`break;`
464			`}`
465			`switch (ifr->ifr_addr.sa_family) {`
466
467			`#ifdef INET`
468			`case AF_INET:`
469			`break;`
470			`#endif`
471			`#ifdef INET6`
472			`case AF_INET6:`
473			`break;`
474			`#endif`
475
476			`default:`
477			`error = EAFNOSUPPORT;`
478			`break;`
479			`}`
480			`break;`
481
482			`case SIOCSIFMTU:`
483			`ifp->if_mtu = ifr->ifr_mtu;`
484			`break;`
485
486			`case SIOCSIFFLAGS:`
487			`break;`
488
489			`default:`
490			`error = EINVAL;`
491			`}`
492			`return (error);`
493			`}`