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