xref: /netbsd/sys/net/if_gif.c (revision c4a72b64) 
1 /*	$NetBSD: if_gif.c,v 1.42 2002/11/11 18:35:27 itojun Exp $	*/
2 /*	$KAME: if_gif.c,v 1.76 2001/08/20 02:01:02 kjc Exp $	*/
3 
4 /*
5  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  * 3. Neither the name of the project nor the names of its contributors
17  *    may be used to endorse or promote products derived from this software
18  *    without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30  * SUCH DAMAGE.
31  */
32 
33 #include <sys/cdefs.h>
34 __KERNEL_RCSID(0, "$NetBSD: if_gif.c,v 1.42 2002/11/11 18:35:27 itojun Exp $");
35 
36 #include "opt_inet.h"
37 #include "opt_iso.h"
38 
39 #include <sys/param.h>
40 #include <sys/systm.h>
41 #include <sys/kernel.h>
42 #include <sys/mbuf.h>
43 #include <sys/socket.h>
44 #include <sys/sockio.h>
45 #include <sys/errno.h>
46 #include <sys/ioctl.h>
47 #include <sys/time.h>
48 #include <sys/syslog.h>
49 #include <sys/proc.h>
50 #include <sys/protosw.h>
51 #include <machine/cpu.h>
52 #include <machine/intr.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 #include <netinet/in.h>
61 #include <netinet/in_systm.h>
62 #include <netinet/ip.h>
63 #ifdef	INET
64 #include <netinet/in_var.h>
65 #include <netinet/in_gif.h>
66 #endif	/* INET */
67 
68 #ifdef INET6
69 #ifndef INET
70 #include <netinet/in.h>
71 #endif
72 #include <netinet6/in6_var.h>
73 #include <netinet/ip6.h>
74 #include <netinet6/ip6_var.h>
75 #include <netinet6/in6_gif.h>
76 #include <netinet6/ip6protosw.h>
77 #endif /* INET6 */
78 
79 #ifdef ISO
80 #include <netiso/iso.h>
81 #include <netiso/iso_var.h>
82 #endif
83 
84 #include <netinet/ip_encap.h>
85 #include <net/if_gif.h>
86 
87 #include "bpfilter.h"
88 
89 #include <net/net_osdep.h>
90 
91 void gifattach __P((int));
92 #ifndef __HAVE_GENERIC_SOFT_INTERRUPTS
93 void gifnetisr __P((void));
94 #endif
95 void gifintr __P((void *));
96 #ifdef ISO
97 static struct mbuf *gif_eon_encap __P((struct mbuf *));
98 static struct mbuf *gif_eon_decap __P((struct ifnet *, struct mbuf *));
99 #endif
100 
101 /*
102  * gif global variable definitions
103  */
104 LIST_HEAD(, gif_softc) gif_softc_list;
105 
106 int	gif_clone_create __P((struct if_clone *, int));
107 void	gif_clone_destroy __P((struct ifnet *));
108 
109 struct if_clone gif_cloner =
110     IF_CLONE_INITIALIZER("gif", gif_clone_create, gif_clone_destroy);
111 
112 #ifndef MAX_GIF_NEST
113 /*
114  * This macro controls the upper limitation on nesting of gif tunnels.
115  * Since, setting a large value to this macro with a careless configuration
116  * may introduce system crash, we don't allow any nestings by default.
117  * If you need to configure nested gif tunnels, you can define this macro
118  * in your kernel configuration file.  However, if you do so, please be
119  * careful to configure the tunnels so that it won't make a loop.
120  */
121 #define MAX_GIF_NEST 1
122 #endif
123 static int max_gif_nesting = MAX_GIF_NEST;
124 
125 /* ARGSUSED */
126 void
127 gifattach(count)
128 	int count;
129 {
130 
131 	LIST_INIT(&gif_softc_list);
132 	if_clone_attach(&gif_cloner);
133 }
134 
135 int
136 gif_clone_create(ifc, unit)
137 	struct if_clone *ifc;
138 	int unit;
139 {
140 	struct gif_softc *sc;
141 
142 	sc = malloc(sizeof(struct gif_softc), M_DEVBUF, M_WAIT);
143 	memset(sc, 0, sizeof(struct gif_softc));
144 
145 	sprintf(sc->gif_if.if_xname, "%s%d", ifc->ifc_name, unit);
146 
147 	gifattach0(sc);
148 
149 	LIST_INSERT_HEAD(&gif_softc_list, sc, gif_list);
150 	return (0);
151 }
152 
153 void
154 gifattach0(sc)
155 	struct gif_softc *sc;
156 {
157 
158 	sc->encap_cookie4 = sc->encap_cookie6 = NULL;
159 
160 	sc->gif_if.if_addrlen = 0;
161 	sc->gif_if.if_mtu    = GIF_MTU;
162 	sc->gif_if.if_flags  = IFF_POINTOPOINT | IFF_MULTICAST;
163 	sc->gif_if.if_ioctl  = gif_ioctl;
164 	sc->gif_if.if_output = gif_output;
165 	sc->gif_if.if_type   = IFT_GIF;
166 	sc->gif_if.if_dlt    = DLT_NULL;
167 	IFQ_SET_READY(&sc->gif_if.if_snd);
168 	if_attach(&sc->gif_if);
169 	if_alloc_sadl(&sc->gif_if);
170 #if NBPFILTER > 0
171 	bpfattach(&sc->gif_if, DLT_NULL, sizeof(u_int));
172 #endif
173 }
174 
175 void
176 gif_clone_destroy(ifp)
177 	struct ifnet *ifp;
178 {
179 	struct gif_softc *sc = (void *) ifp;
180 
181 	gif_delete_tunnel(&sc->gif_if);
182 	LIST_REMOVE(sc, gif_list);
183 #ifdef INET6
184 	encap_detach(sc->encap_cookie6);
185 #endif
186 #ifdef INET
187 	encap_detach(sc->encap_cookie4);
188 #endif
189 
190 #if NBPFILTER > 0
191 	bpfdetach(ifp);
192 #endif
193 	if_detach(ifp);
194 
195 	free(sc, M_DEVBUF);
196 }
197 
198 #ifdef GIF_ENCAPCHECK
199 int
200 gif_encapcheck(m, off, proto, arg)
201 	const struct mbuf *m;
202 	int off;
203 	int proto;
204 	void *arg;
205 {
206 	struct ip ip;
207 	struct gif_softc *sc;
208 
209 	sc = (struct gif_softc *)arg;
210 	if (sc == NULL)
211 		return 0;
212 
213 	if ((sc->gif_if.if_flags & IFF_UP) == 0)
214 		return 0;
215 
216 	/* no physical address */
217 	if (!sc->gif_psrc || !sc->gif_pdst)
218 		return 0;
219 
220 	switch (proto) {
221 #ifdef INET
222 	case IPPROTO_IPV4:
223 		break;
224 #endif
225 #ifdef INET6
226 	case IPPROTO_IPV6:
227 		break;
228 #endif
229 #ifdef ISO
230 	case IPPROTO_EON:
231 		break;
232 #endif
233 	default:
234 		return 0;
235 	}
236 
237 	/* Bail on short packets */
238 	KASSERT(m->m_flags & M_PKTHDR);
239 	if (m->m_pkthdr.len < sizeof(ip))
240 		return 0;
241 
242 	/* LINTED const cast */
243 	m_copydata((struct mbuf *)m, 0, sizeof(ip), (caddr_t)&ip);
244 
245 	switch (ip.ip_v) {
246 #ifdef INET
247 	case 4:
248 		if (sc->gif_psrc->sa_family != AF_INET ||
249 		    sc->gif_pdst->sa_family != AF_INET)
250 			return 0;
251 		return gif_encapcheck4(m, off, proto, arg);
252 #endif
253 #ifdef INET6
254 	case 6:
255 		if (m->m_pkthdr.len < sizeof(struct ip6_hdr))
256 			return 0;
257 		if (sc->gif_psrc->sa_family != AF_INET6 ||
258 		    sc->gif_pdst->sa_family != AF_INET6)
259 			return 0;
260 		return gif_encapcheck6(m, off, proto, arg);
261 #endif
262 	default:
263 		return 0;
264 	}
265 }
266 #endif
267 
268 int
269 gif_output(ifp, m, dst, rt)
270 	struct ifnet *ifp;
271 	struct mbuf *m;
272 	struct sockaddr *dst;
273 	struct rtentry *rt;	/* added in net2 */
274 {
275 	struct gif_softc *sc = (struct gif_softc*)ifp;
276 	int error = 0;
277 	static int called = 0;	/* XXX: MUTEX */
278 	ALTQ_DECL(struct altq_pktattr pktattr;)
279 	int s;
280 
281 	IFQ_CLASSIFY(&ifp->if_snd, m, dst->sa_family, &pktattr);
282 
283 	/*
284 	 * gif may cause infinite recursion calls when misconfigured.
285 	 * We'll prevent this by introducing upper limit.
286 	 * XXX: this mechanism may introduce another problem about
287 	 *      mutual exclusion of the variable CALLED, especially if we
288 	 *      use kernel thread.
289 	 */
290 	if (++called > max_gif_nesting) {
291 		log(LOG_NOTICE,
292 		    "gif_output: recursively called too many times(%d)\n",
293 		    called);
294 		m_freem(m);
295 		error = EIO;	/* is there better errno? */
296 		goto end;
297 	}
298 
299 	m->m_flags &= ~(M_BCAST|M_MCAST);
300 	if (!(ifp->if_flags & IFF_UP) ||
301 	    sc->gif_psrc == NULL || sc->gif_pdst == NULL) {
302 		m_freem(m);
303 		error = ENETDOWN;
304 		goto end;
305 	}
306 
307 	/* inner AF-specific encapsulation */
308 	switch (dst->sa_family) {
309 #ifdef ISO
310 	case AF_ISO:
311 		m = gif_eon_encap(m);
312 		if (!m) {
313 			error = ENOBUFS;
314 			goto end;
315 		}
316 		break;
317 #endif
318 	default:
319 		break;
320 	}
321 
322 	/* XXX should we check if our outer source is legal? */
323 
324 	/* use DLT_NULL encapsulation here to pass inner af type */
325 	M_PREPEND(m, sizeof(int), M_DONTWAIT);
326 	if (!m) {
327 		error = ENOBUFS;
328 		goto end;
329 	}
330 	*mtod(m, int *) = dst->sa_family;
331 
332 	s = splnet();
333 	IFQ_ENQUEUE(&ifp->if_snd, m, &pktattr, error);
334 	if (error) {
335 		splx(s);
336 		goto end;
337 	}
338 	splx(s);
339 
340 #ifdef __HAVE_GENERIC_SOFT_INTERRUPTS
341 	softintr_schedule(sc->gif_si);
342 #else
343 	/* XXX bad spl level? */
344 	gifnetisr();
345 #endif
346 	error = 0;
347 
348   end:
349 	called = 0;		/* reset recursion counter */
350 	if (error)
351 		ifp->if_oerrors++;
352 	return error;
353 }
354 
355 #ifndef __HAVE_GENERIC_SOFT_INTERRUPTS
356 void
357 gifnetisr()
358 {
359 	struct gif_softc *sc;
360 
361 	for (sc = LIST_FIRST(&gif_softc_list); sc != NULL;
362 	     sc = LIST_NEXT(sc, gif_list)) {
363 		gifintr(sc);
364 	}
365 }
366 #endif
367 
368 void
369 gifintr(arg)
370 	void *arg;
371 {
372 	struct gif_softc *sc;
373 	struct ifnet *ifp;
374 	struct mbuf *m;
375 	int family;
376 	int len;
377 	int s;
378 	int error;
379 
380 	sc = (struct gif_softc *)arg;
381 	ifp = &sc->gif_if;
382 
383 	/* output processing */
384 	while (1) {
385 		s = splnet();
386 		IFQ_DEQUEUE(&sc->gif_if.if_snd, m);
387 		splx(s);
388 		if (m == NULL)
389 			break;
390 
391 		/* grab and chop off inner af type */
392 		if (sizeof(int) > m->m_len) {
393 			m = m_pullup(m, sizeof(int));
394 			if (!m) {
395 				ifp->if_oerrors++;
396 				continue;
397 			}
398 		}
399 		family = *mtod(m, int *);
400 #if NBPFILTER > 0
401 		if (ifp->if_bpf) {
402 #ifdef HAVE_OLD_BPF
403 			bpf_mtap(ifp, m);
404 #else
405 			bpf_mtap(ifp->if_bpf, m);
406 #endif
407 		}
408 #endif
409 		m_adj(m, sizeof(int));
410 
411 		len = m->m_pkthdr.len;
412 
413 		/* dispatch to output logic based on outer AF */
414 		switch (sc->gif_psrc->sa_family) {
415 #ifdef INET
416 		case AF_INET:
417 			error = in_gif_output(ifp, family, m);
418 			break;
419 #endif
420 #ifdef INET6
421 		case AF_INET6:
422 			error = in6_gif_output(ifp, family, m);
423 			break;
424 #endif
425 		default:
426 			m_freem(m);
427 			error = ENETDOWN;
428 			break;
429 		}
430 
431 		if (error)
432 			ifp->if_oerrors++;
433 		else {
434 			ifp->if_opackets++;
435 			ifp->if_obytes += len;
436 		}
437 	}
438 }
439 
440 void
441 gif_input(m, af, ifp)
442 	struct mbuf *m;
443 	int af;
444 	struct ifnet *ifp;
445 {
446 	int s, isr;
447 	struct ifqueue *ifq = NULL;
448 
449 	if (ifp == NULL) {
450 		/* just in case */
451 		m_freem(m);
452 		return;
453 	}
454 
455 	m->m_pkthdr.rcvif = ifp;
456 
457 #if NBPFILTER > 0
458 	if (ifp->if_bpf) {
459 		/*
460 		 * We need to prepend the address family as
461 		 * a four byte field.  Cons up a dummy header
462 		 * to pacify bpf.  This is safe because bpf
463 		 * will only read from the mbuf (i.e., it won't
464 		 * try to free it or keep a pointer a to it).
465 		 */
466 		struct mbuf m0;
467 		u_int32_t af1 = af;
468 
469 		m0.m_next = m;
470 		m0.m_len = 4;
471 		m0.m_data = (char *)&af1;
472 
473 #ifdef HAVE_OLD_BPF
474 		bpf_mtap(ifp, &m0);
475 #else
476 		bpf_mtap(ifp->if_bpf, &m0);
477 #endif
478 	}
479 #endif /*NBPFILTER > 0*/
480 
481 	/*
482 	 * Put the packet to the network layer input queue according to the
483 	 * specified address family.
484 	 * Note: older versions of gif_input directly called network layer
485 	 * input functions, e.g. ip6_input, here.  We changed the policy to
486 	 * prevent too many recursive calls of such input functions, which
487 	 * might cause kernel panic.  But the change may introduce another
488 	 * problem; if the input queue is full, packets are discarded.
489 	 * The kernel stack overflow really happened, and we believed
490 	 * queue-full rarely occurs, so we changed the policy.
491 	 */
492 	switch (af) {
493 #ifdef INET
494 	case AF_INET:
495 		ifq = &ipintrq;
496 		isr = NETISR_IP;
497 		break;
498 #endif
499 #ifdef INET6
500 	case AF_INET6:
501 		ifq = &ip6intrq;
502 		isr = NETISR_IPV6;
503 		break;
504 #endif
505 #ifdef ISO
506 	case AF_ISO:
507 		m = gif_eon_decap(ifp, m);
508 		if (!m)
509 			return;
510 		ifq = &clnlintrq;
511 		isr = NETISR_ISO;
512 		break;
513 #endif
514 	default:
515 		m_freem(m);
516 		return;
517 	}
518 
519 	s = splnet();
520 	if (IF_QFULL(ifq)) {
521 		IF_DROP(ifq);	/* update statistics */
522 		m_freem(m);
523 		splx(s);
524 		return;
525 	}
526 	ifp->if_ipackets++;
527 	ifp->if_ibytes += m->m_pkthdr.len;
528 	IF_ENQUEUE(ifq, m);
529 	/* we need schednetisr since the address family may change */
530 	schednetisr(isr);
531 	splx(s);
532 }
533 
534 /* XXX how should we handle IPv6 scope on SIOC[GS]IFPHYADDR? */
535 int
536 gif_ioctl(ifp, cmd, data)
537 	struct ifnet *ifp;
538 	u_long cmd;
539 	caddr_t data;
540 {
541 	struct proc *p = curproc;	/* XXX */
542 	struct gif_softc *sc  = (struct gif_softc*)ifp;
543 	struct ifreq     *ifr = (struct ifreq*)data;
544 	int error = 0, size;
545 	struct sockaddr *dst, *src;
546 #ifdef SIOCSIFMTU
547 	u_long mtu;
548 #endif
549 
550 	switch (cmd) {
551 	case SIOCSIFADDR:
552 		ifp->if_flags |= IFF_UP;
553 		break;
554 
555 	case SIOCSIFDSTADDR:
556 		break;
557 
558 	case SIOCADDMULTI:
559 	case SIOCDELMULTI:
560 		if ((error = suser(p->p_ucred, &p->p_acflag)) != 0)
561 			break;
562 		switch (ifr->ifr_addr.sa_family) {
563 #ifdef INET
564 		case AF_INET:	/* IP supports Multicast */
565 			break;
566 #endif /* INET */
567 #ifdef INET6
568 		case AF_INET6:	/* IP6 supports Multicast */
569 			break;
570 #endif /* INET6 */
571 		default:  /* Other protocols doesn't support Multicast */
572 			error = EAFNOSUPPORT;
573 			break;
574 		}
575 		break;
576 
577 #ifdef	SIOCSIFMTU /* xxx */
578 	case SIOCGIFMTU:
579 		break;
580 
581 	case SIOCSIFMTU:
582 		if ((error = suser(p->p_ucred, &p->p_acflag)) != 0)
583 			break;
584 		mtu = ifr->ifr_mtu;
585 		if (mtu < GIF_MTU_MIN || mtu > GIF_MTU_MAX)
586 			return (EINVAL);
587 		ifp->if_mtu = mtu;
588 		break;
589 #endif /* SIOCSIFMTU */
590 
591 #ifdef INET
592 	case SIOCSIFPHYADDR:
593 #endif
594 #ifdef INET6
595 	case SIOCSIFPHYADDR_IN6:
596 #endif /* INET6 */
597 	case SIOCSLIFPHYADDR:
598 		if ((error = suser(p->p_ucred, &p->p_acflag)) != 0)
599 			break;
600 		switch (cmd) {
601 #ifdef INET
602 		case SIOCSIFPHYADDR:
603 			src = (struct sockaddr *)
604 				&(((struct in_aliasreq *)data)->ifra_addr);
605 			dst = (struct sockaddr *)
606 				&(((struct in_aliasreq *)data)->ifra_dstaddr);
607 			break;
608 #endif
609 #ifdef INET6
610 		case SIOCSIFPHYADDR_IN6:
611 			src = (struct sockaddr *)
612 				&(((struct in6_aliasreq *)data)->ifra_addr);
613 			dst = (struct sockaddr *)
614 				&(((struct in6_aliasreq *)data)->ifra_dstaddr);
615 			break;
616 #endif
617 		case SIOCSLIFPHYADDR:
618 			src = (struct sockaddr *)
619 				&(((struct if_laddrreq *)data)->addr);
620 			dst = (struct sockaddr *)
621 				&(((struct if_laddrreq *)data)->dstaddr);
622 			break;
623 		default:
624 			return EINVAL;
625 		}
626 
627 		/* sa_family must be equal */
628 		if (src->sa_family != dst->sa_family)
629 			return EINVAL;
630 
631 		/* validate sa_len */
632 		switch (src->sa_family) {
633 #ifdef INET
634 		case AF_INET:
635 			if (src->sa_len != sizeof(struct sockaddr_in))
636 				return EINVAL;
637 			break;
638 #endif
639 #ifdef INET6
640 		case AF_INET6:
641 			if (src->sa_len != sizeof(struct sockaddr_in6))
642 				return EINVAL;
643 			break;
644 #endif
645 		default:
646 			return EAFNOSUPPORT;
647 		}
648 		switch (dst->sa_family) {
649 #ifdef INET
650 		case AF_INET:
651 			if (dst->sa_len != sizeof(struct sockaddr_in))
652 				return EINVAL;
653 			break;
654 #endif
655 #ifdef INET6
656 		case AF_INET6:
657 			if (dst->sa_len != sizeof(struct sockaddr_in6))
658 				return EINVAL;
659 			break;
660 #endif
661 		default:
662 			return EAFNOSUPPORT;
663 		}
664 
665 		/* check sa_family looks sane for the cmd */
666 		switch (cmd) {
667 		case SIOCSIFPHYADDR:
668 			if (src->sa_family == AF_INET)
669 				break;
670 			return EAFNOSUPPORT;
671 #ifdef INET6
672 		case SIOCSIFPHYADDR_IN6:
673 			if (src->sa_family == AF_INET6)
674 				break;
675 			return EAFNOSUPPORT;
676 #endif /* INET6 */
677 		case SIOCSLIFPHYADDR:
678 			/* checks done in the above */
679 			break;
680 		}
681 
682 		error = gif_set_tunnel(&sc->gif_if, src, dst);
683 		break;
684 
685 #ifdef SIOCDIFPHYADDR
686 	case SIOCDIFPHYADDR:
687 		if ((error = suser(p->p_ucred, &p->p_acflag)) != 0)
688 			break;
689 		gif_delete_tunnel(&sc->gif_if);
690 		break;
691 #endif
692 
693 	case SIOCGIFPSRCADDR:
694 #ifdef INET6
695 	case SIOCGIFPSRCADDR_IN6:
696 #endif /* INET6 */
697 		if (sc->gif_psrc == NULL) {
698 			error = EADDRNOTAVAIL;
699 			goto bad;
700 		}
701 		src = sc->gif_psrc;
702 		switch (cmd) {
703 #ifdef INET
704 		case SIOCGIFPSRCADDR:
705 			dst = &ifr->ifr_addr;
706 			size = sizeof(ifr->ifr_addr);
707 			break;
708 #endif /* INET */
709 #ifdef INET6
710 		case SIOCGIFPSRCADDR_IN6:
711 			dst = (struct sockaddr *)
712 				&(((struct in6_ifreq *)data)->ifr_addr);
713 			size = sizeof(((struct in6_ifreq *)data)->ifr_addr);
714 			break;
715 #endif /* INET6 */
716 		default:
717 			error = EADDRNOTAVAIL;
718 			goto bad;
719 		}
720 		if (src->sa_len > size)
721 			return EINVAL;
722 		bcopy((caddr_t)src, (caddr_t)dst, src->sa_len);
723 		break;
724 
725 	case SIOCGIFPDSTADDR:
726 #ifdef INET6
727 	case SIOCGIFPDSTADDR_IN6:
728 #endif /* INET6 */
729 		if (sc->gif_pdst == NULL) {
730 			error = EADDRNOTAVAIL;
731 			goto bad;
732 		}
733 		src = sc->gif_pdst;
734 		switch (cmd) {
735 #ifdef INET
736 		case SIOCGIFPDSTADDR:
737 			dst = &ifr->ifr_addr;
738 			size = sizeof(ifr->ifr_addr);
739 			break;
740 #endif /* INET */
741 #ifdef INET6
742 		case SIOCGIFPDSTADDR_IN6:
743 			dst = (struct sockaddr *)
744 				&(((struct in6_ifreq *)data)->ifr_addr);
745 			size = sizeof(((struct in6_ifreq *)data)->ifr_addr);
746 			break;
747 #endif /* INET6 */
748 		default:
749 			error = EADDRNOTAVAIL;
750 			goto bad;
751 		}
752 		if (src->sa_len > size)
753 			return EINVAL;
754 		bcopy((caddr_t)src, (caddr_t)dst, src->sa_len);
755 		break;
756 
757 	case SIOCGLIFPHYADDR:
758 		if (sc->gif_psrc == NULL || sc->gif_pdst == NULL) {
759 			error = EADDRNOTAVAIL;
760 			goto bad;
761 		}
762 
763 		/* copy src */
764 		src = sc->gif_psrc;
765 		dst = (struct sockaddr *)
766 			&(((struct if_laddrreq *)data)->addr);
767 		size = sizeof(((struct if_laddrreq *)data)->addr);
768 		if (src->sa_len > size)
769 			return EINVAL;
770 		bcopy((caddr_t)src, (caddr_t)dst, src->sa_len);
771 
772 		/* copy dst */
773 		src = sc->gif_pdst;
774 		dst = (struct sockaddr *)
775 			&(((struct if_laddrreq *)data)->dstaddr);
776 		size = sizeof(((struct if_laddrreq *)data)->dstaddr);
777 		if (src->sa_len > size)
778 			return EINVAL;
779 		bcopy((caddr_t)src, (caddr_t)dst, src->sa_len);
780 		break;
781 
782 	case SIOCSIFFLAGS:
783 		/* if_ioctl() takes care of it */
784 		break;
785 
786 	default:
787 		error = EINVAL;
788 		break;
789 	}
790  bad:
791 	return error;
792 }
793 
794 int
795 gif_set_tunnel(ifp, src, dst)
796 	struct ifnet *ifp;
797 	struct sockaddr *src;
798 	struct sockaddr *dst;
799 {
800 	struct gif_softc *sc = (struct gif_softc *)ifp;
801 	struct gif_softc *sc2;
802 	struct sockaddr *osrc, *odst, *sa;
803 	int s;
804 	int error;
805 
806 	s = splsoftnet();
807 
808 	for (sc2 = LIST_FIRST(&gif_softc_list); sc2 != NULL;
809 	     sc2 = LIST_NEXT(sc2, gif_list)) {
810 		if (sc2 == sc)
811 			continue;
812 		if (!sc2->gif_pdst || !sc2->gif_psrc)
813 			continue;
814 		if (sc2->gif_pdst->sa_family != dst->sa_family ||
815 		    sc2->gif_pdst->sa_len != dst->sa_len ||
816 		    sc2->gif_psrc->sa_family != src->sa_family ||
817 		    sc2->gif_psrc->sa_len != src->sa_len)
818 			continue;
819 		/* can't configure same pair of address onto two gifs */
820 		if (bcmp(sc2->gif_pdst, dst, dst->sa_len) == 0 &&
821 		    bcmp(sc2->gif_psrc, src, src->sa_len) == 0) {
822 			error = EADDRNOTAVAIL;
823 			goto bad;
824 		}
825 
826 		/* XXX both end must be valid? (I mean, not 0.0.0.0) */
827 	}
828 
829 	/* XXX we can detach from both, but be polite just in case */
830 	if (sc->gif_psrc)
831 		switch (sc->gif_psrc->sa_family) {
832 #ifdef INET
833 		case AF_INET:
834 			(void)in_gif_detach(sc);
835 			break;
836 #endif
837 #ifdef INET6
838 		case AF_INET6:
839 			(void)in6_gif_detach(sc);
840 			break;
841 #endif
842 		}
843 
844 #ifdef __HAVE_GENERIC_SOFT_INTERRUPTS
845 	sc->gif_si = softintr_establish(IPL_SOFTNET, gifintr, sc);
846 	if (sc->gif_si == NULL) {
847 		error = ENOMEM;
848 		goto bad;
849 	}
850 #endif
851 
852 	osrc = sc->gif_psrc;
853 	sa = (struct sockaddr *)malloc(src->sa_len, M_IFADDR, M_WAITOK);
854 	bcopy((caddr_t)src, (caddr_t)sa, src->sa_len);
855 	sc->gif_psrc = sa;
856 
857 	odst = sc->gif_pdst;
858 	sa = (struct sockaddr *)malloc(dst->sa_len, M_IFADDR, M_WAITOK);
859 	bcopy((caddr_t)dst, (caddr_t)sa, dst->sa_len);
860 	sc->gif_pdst = sa;
861 
862 	switch (sc->gif_psrc->sa_family) {
863 #ifdef INET
864 	case AF_INET:
865 		error = in_gif_attach(sc);
866 		break;
867 #endif
868 #ifdef INET6
869 	case AF_INET6:
870 		error = in6_gif_attach(sc);
871 		break;
872 #endif
873 	}
874 	if (error) {
875 		/* rollback */
876 		free((caddr_t)sc->gif_psrc, M_IFADDR);
877 		free((caddr_t)sc->gif_pdst, M_IFADDR);
878 		sc->gif_psrc = osrc;
879 		sc->gif_pdst = odst;
880 		goto bad;
881 	}
882 
883 	if (osrc)
884 		free((caddr_t)osrc, M_IFADDR);
885 	if (odst)
886 		free((caddr_t)odst, M_IFADDR);
887 
888 	if (sc->gif_psrc && sc->gif_pdst)
889 		ifp->if_flags |= IFF_RUNNING;
890 	else
891 		ifp->if_flags &= ~IFF_RUNNING;
892 	splx(s);
893 
894 	return 0;
895 
896  bad:
897 #ifdef __HAVE_GENERIC_SOFT_INTERRUPTS
898 	if (sc->gif_si) {
899 		softintr_disestablish(sc->gif_si);
900 		sc->gif_si = NULL;
901 	}
902 #endif
903 	if (sc->gif_psrc && sc->gif_pdst)
904 		ifp->if_flags |= IFF_RUNNING;
905 	else
906 		ifp->if_flags &= ~IFF_RUNNING;
907 	splx(s);
908 
909 	return error;
910 }
911 
912 void
913 gif_delete_tunnel(ifp)
914 	struct ifnet *ifp;
915 {
916 	struct gif_softc *sc = (struct gif_softc *)ifp;
917 	int s;
918 
919 	s = splsoftnet();
920 
921 #ifdef __HAVE_GENERIC_SOFT_INTERRUPTS
922 	if (sc->gif_si) {
923 		softintr_disestablish(sc->gif_si);
924 		sc->gif_si = NULL;
925 	}
926 #endif
927 	if (sc->gif_psrc) {
928 		free((caddr_t)sc->gif_psrc, M_IFADDR);
929 		sc->gif_psrc = NULL;
930 	}
931 	if (sc->gif_pdst) {
932 		free((caddr_t)sc->gif_pdst, M_IFADDR);
933 		sc->gif_pdst = NULL;
934 	}
935 	/* it is safe to detach from both */
936 #ifdef INET
937 	(void)in_gif_detach(sc);
938 #endif
939 #ifdef INET6
940 	(void)in6_gif_detach(sc);
941 #endif
942 
943 	if (sc->gif_psrc && sc->gif_pdst)
944 		ifp->if_flags |= IFF_RUNNING;
945 	else
946 		ifp->if_flags &= ~IFF_RUNNING;
947 	splx(s);
948 }
949 
950 #ifdef ISO
951 struct eonhdr {
952 	u_int8_t version;
953 	u_int8_t class;
954 	u_int16_t cksum;
955 };
956 
957 /*
958  * prepend EON header to ISO PDU
959  */
960 static struct mbuf *
961 gif_eon_encap(struct mbuf *m)
962 {
963 	struct eonhdr *ehdr;
964 
965 	M_PREPEND(m, sizeof(*ehdr), M_DONTWAIT);
966 	if (m && m->m_len < sizeof(*ehdr))
967 		m = m_pullup(m, sizeof(*ehdr));
968 	if (m == NULL)
969 		return NULL;
970 	ehdr = mtod(m, struct eonhdr *);
971 	ehdr->version = 1;
972 	ehdr->class = 0;		/* always unicast */
973 #if 0
974 	/* calculate the checksum of the eonhdr */
975 	{
976 		struct mbuf mhead;
977 		memset(&mhead, 0, sizeof(mhead));
978 		ehdr->cksum = 0;
979 		mhead.m_data = (caddr_t)ehdr;
980 		mhead.m_len = sizeof(*ehdr);
981 		mhead.m_next = 0;
982 		iso_gen_csum(&mhead, offsetof(struct eonhdr, cksum),
983 		    mhead.m_len);
984 	}
985 #else
986 	/* since the data is always constant we'll just plug the value in */
987 	ehdr->cksum = htons(0xfc02);
988 #endif
989 	return m;
990 }
991 
992 /*
993  * remove EON header and check checksum
994  */
995 static struct mbuf *
996 gif_eon_decap(struct ifnet *ifp, struct mbuf *m)
997 {
998 	struct eonhdr *ehdr;
999 
1000 	if (m->m_len < sizeof(*ehdr) &&
1001 	    (m = m_pullup(m, sizeof(*ehdr))) == NULL) {
1002 		ifp->if_ierrors++;
1003 		return NULL;
1004 	}
1005 	if (iso_check_csum(m, sizeof(struct eonhdr))) {
1006 		m_freem(m);
1007 		return NULL;
1008 	}
1009 	m_adj(m, sizeof(*ehdr));
1010 	return m;
1011 }
1012 #endif /*ISO*/
1013