2/* $KAME: if_gif.c,v 1.87 2001/10/19 08:50:27 itojun 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 "opt_inet.h"
34#include "opt_inet6.h"
35#include "opt_mac.h"
36
37#include <sys/param.h>
38#include <sys/systm.h>
39#include <sys/kernel.h>
40#include <sys/mac.h>
41#include <sys/malloc.h>
42#include <sys/mbuf.h>
43#include <sys/socket.h>
44#include <sys/sockio.h>
45#include <sys/errno.h>
46#include <sys/time.h>
47#include <sys/sysctl.h>
48#include <sys/syslog.h>
49#include <sys/protosw.h>
50#include <sys/conf.h>
51#include <machine/cpu.h>
52
53#include <net/if.h>
54#include <net/if_types.h>
55#include <net/netisr.h>
56#include <net/route.h>
57#include <net/bpf.h>
58
59#include <netinet/in.h>
60#include <netinet/in_systm.h>
61#include <netinet/ip.h>
62#ifdef INET
63#include <netinet/in_var.h>
64#include <netinet/in_gif.h>
65#include <netinet/ip_var.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#include <netinet/ip_encap.h>
80#include <net/if_gif.h>
81
82#include <net/net_osdep.h>
83
84#define GIFNAME "gif"
85
86static MALLOC_DEFINE(M_GIF, "gif", "Generic Tunnel Interface");
87static LIST_HEAD(, gif_softc) gif_softc_list;
88
89void (*ng_gif_input_p)(struct ifnet *ifp, struct mbuf **mp, int af);
90void (*ng_gif_input_orphan_p)(struct ifnet *ifp, struct mbuf *m, int af);
91void (*ng_gif_attach_p)(struct ifnet *ifp);
92void (*ng_gif_detach_p)(struct ifnet *ifp);
93
94int gif_clone_create(struct if_clone *, int);
95void gif_clone_destroy(struct ifnet *);
96
97struct if_clone gif_cloner = IF_CLONE_INITIALIZER("gif",
98 gif_clone_create, gif_clone_destroy, 0, IF_MAXUNIT);
99
100static int gifmodevent(module_t, int, void *);
101
102SYSCTL_DECL(_net_link);
103SYSCTL_NODE(_net_link, IFT_GIF, gif, CTLFLAG_RW, 0,
104 "Generic Tunnel Interface");
105#ifndef MAX_GIF_NEST
106/*
107 * This macro controls the default upper limitation on nesting of gif tunnels.
108 * Since, setting a large value to this macro with a careless configuration
109 * may introduce system crash, we don't allow any nestings by default.
110 * If you need to configure nested gif tunnels, you can define this macro
111 * in your kernel configuration file. However, if you do so, please be
112 * careful to configure the tunnels so that it won't make a loop.
113 */
114#define MAX_GIF_NEST 1
115#endif
116static int max_gif_nesting = MAX_GIF_NEST;
117SYSCTL_INT(_net_link_gif, OID_AUTO, max_nesting, CTLFLAG_RW,
118 &max_gif_nesting, 0, "Max nested tunnels");
119
120/*
121 * By default, we disallow creation of multiple tunnels between the same
122 * pair of addresses. Some applications require this functionality so
123 * we allow control over this check here.
124 */
125#ifdef XBONEHACK
126static int parallel_tunnels = 1;
127#else
128static int parallel_tunnels = 0;
129#endif
130SYSCTL_INT(_net_link_gif, OID_AUTO, parallel_tunnels, CTLFLAG_RW,
131 ¶llel_tunnels, 0, "Allow parallel tunnels?");
132
133int
134gif_clone_create(ifc, unit)
135 struct if_clone *ifc;
136 int unit;
137{
138 struct gif_softc *sc;
139
140 sc = malloc (sizeof(struct gif_softc), M_GIF, M_WAITOK);
141 bzero(sc, sizeof(struct gif_softc));
142
143 sc->gif_if.if_softc = sc;
144 if_initname(&sc->gif_if, ifc->ifc_name, unit);
145
146 gifattach0(sc);
147
148 LIST_INSERT_HEAD(&gif_softc_list, sc, gif_list);
149 return (0);
150}
151
152void
153gifattach0(sc)
154 struct gif_softc *sc;
155{
156
157 sc->encap_cookie4 = sc->encap_cookie6 = NULL;
158
159 sc->gif_if.if_addrlen = 0;
160 sc->gif_if.if_mtu = GIF_MTU;
161 sc->gif_if.if_flags = IFF_POINTOPOINT | IFF_MULTICAST;
162#if 0
163 /* turn off ingress filter */
164 sc->gif_if.if_flags |= IFF_LINK2;
165#endif
166 sc->gif_if.if_ioctl = gif_ioctl;
167 sc->gif_if.if_output = gif_output;
168 sc->gif_if.if_type = IFT_GIF;
169 sc->gif_if.if_snd.ifq_maxlen = IFQ_MAXLEN;
170 if_attach(&sc->gif_if);
171 bpfattach(&sc->gif_if, DLT_NULL, sizeof(u_int));
172 if (ng_gif_attach_p != NULL)
173 (*ng_gif_attach_p)(&sc->gif_if);
174}
175
176void
177gif_clone_destroy(ifp)
178 struct ifnet *ifp;
179{
180 int err;
181 struct gif_softc *sc = ifp->if_softc;
182
183 gif_delete_tunnel(&sc->gif_if);
184 LIST_REMOVE(sc, gif_list);
185#ifdef INET6
186 if (sc->encap_cookie6 != NULL) {
187 err = encap_detach(sc->encap_cookie6);
188 KASSERT(err == 0, ("Unexpected error detaching encap_cookie6"));
189 }
190#endif
191#ifdef INET
192 if (sc->encap_cookie4 != NULL) {
193 err = encap_detach(sc->encap_cookie4);
194 KASSERT(err == 0, ("Unexpected error detaching encap_cookie4"));
195 }
196#endif
197
198 if (ng_gif_detach_p != NULL)
199 (*ng_gif_detach_p)(ifp);
200 bpfdetach(ifp);
201 if_detach(ifp);
202
203 free(sc, M_GIF);
204}
205
206static int
207gifmodevent(mod, type, data)
208 module_t mod;
209 int type;
210 void *data;
211{
212
213 switch (type) {
214 case MOD_LOAD:
215 LIST_INIT(&gif_softc_list);
216 if_clone_attach(&gif_cloner);
217
218#ifdef INET6
219 ip6_gif_hlim = GIF_HLIM;
220#endif
221
222 break;
223 case MOD_UNLOAD:
224 if_clone_detach(&gif_cloner);
225
226 while (!LIST_EMPTY(&gif_softc_list))
227 gif_clone_destroy(&LIST_FIRST(&gif_softc_list)->gif_if);
228
229#ifdef INET6
230 ip6_gif_hlim = 0;
231#endif
232 break;
233 }
234 return 0;
235}
236
237static moduledata_t gif_mod = {
238 "if_gif",
239 gifmodevent,
240 0
241};
242
243DECLARE_MODULE(if_gif, gif_mod, SI_SUB_PSEUDO, SI_ORDER_ANY);
244MODULE_VERSION(if_gif, 1);
245
246int
247gif_encapcheck(m, off, proto, arg)
248 const struct mbuf *m;
249 int off;
250 int proto;
251 void *arg;
252{
253 struct ip ip;
254 struct gif_softc *sc;
255
256 sc = (struct gif_softc *)arg;
257 if (sc == NULL)
258 return 0;
259
260 if ((sc->gif_if.if_flags & IFF_UP) == 0)
261 return 0;
262
263 /* no physical address */
264 if (!sc->gif_psrc || !sc->gif_pdst)
265 return 0;
266
267 switch (proto) {
268#ifdef INET
269 case IPPROTO_IPV4:
270 break;
271#endif
272#ifdef INET6
273 case IPPROTO_IPV6:
274 break;
275#endif
276 default:
277 return 0;
278 }
279
280 /* Bail on short packets */
281 if (m->m_pkthdr.len < sizeof(ip))
282 return 0;
283
284 m_copydata(m, 0, sizeof(ip), (caddr_t)&ip);
285
286 switch (ip.ip_v) {
287#ifdef INET
288 case 4:
289 if (sc->gif_psrc->sa_family != AF_INET ||
290 sc->gif_pdst->sa_family != AF_INET)
291 return 0;
292 return gif_encapcheck4(m, off, proto, arg);
293#endif
294#ifdef INET6
295 case 6:
296 if (m->m_pkthdr.len < sizeof(struct ip6_hdr))
297 return 0;
298 if (sc->gif_psrc->sa_family != AF_INET6 ||
299 sc->gif_pdst->sa_family != AF_INET6)
300 return 0;
301 return gif_encapcheck6(m, off, proto, arg);
302#endif
303 default:
304 return 0;
305 }
306}
307
308int
309gif_output(ifp, m, dst, rt)
310 struct ifnet *ifp;
311 struct mbuf *m;
312 struct sockaddr *dst;
313 struct rtentry *rt; /* added in net2 */
314{
315 struct gif_softc *sc = (struct gif_softc*)ifp;
316 int error = 0;
317 static int called = 0; /* XXX: MUTEX */
318
319#ifdef MAC
320 error = mac_check_ifnet_transmit(ifp, m);
321 if (error) {
322 m_freem(m);
323 goto end;
324 }
325#endif
326
327 /*
328 * gif may cause infinite recursion calls when misconfigured.
329 * We'll prevent this by introducing upper limit.
330 * XXX: this mechanism may introduce another problem about
331 * mutual exclusion of the variable CALLED, especially if we
332 * use kernel thread.
333 */
334 if (++called > max_gif_nesting) {
335 log(LOG_NOTICE,
336 "gif_output: recursively called too many times(%d)\n",
337 called);
338 m_freem(m);
339 error = EIO; /* is there better errno? */
340 goto end;
341 }
342
343 m->m_flags &= ~(M_BCAST|M_MCAST);
344 if (!(ifp->if_flags & IFF_UP) ||
345 sc->gif_psrc == NULL || sc->gif_pdst == NULL) {
346 m_freem(m);
347 error = ENETDOWN;
348 goto end;
349 }
350
351 if (ifp->if_bpf) {
|
410 }
411
412 if (ng_gif_input_p != NULL) {
413 (*ng_gif_input_p)(ifp, &m, af);
414 if (m == NULL)
415 return;
416 }
417
418 /*
419 * Put the packet to the network layer input queue according to the
420 * specified address family.
421 * Note: older versions of gif_input directly called network layer
422 * input functions, e.g. ip6_input, here. We changed the policy to
423 * prevent too many recursive calls of such input functions, which
424 * might cause kernel panic. But the change may introduce another
425 * problem; if the input queue is full, packets are discarded.
426 * The kernel stack overflow really happened, and we believed
427 * queue-full rarely occurs, so we changed the policy.
428 */
429 switch (af) {
430#ifdef INET
431 case AF_INET:
432 isr = NETISR_IP;
433 break;
434#endif
435#ifdef INET6
436 case AF_INET6:
437 isr = NETISR_IPV6;
438 break;
439#endif
440 default:
441 if (ng_gif_input_orphan_p != NULL)
442 (*ng_gif_input_orphan_p)(ifp, m, af);
443 else
444 m_freem(m);
445 return;
446 }
447
448 ifp->if_ipackets++;
449 ifp->if_ibytes += m->m_pkthdr.len;
450 netisr_dispatch(isr, m);
451}
452
453/* XXX how should we handle IPv6 scope on SIOC[GS]IFPHYADDR? */
454int
455gif_ioctl(ifp, cmd, data)
456 struct ifnet *ifp;
457 u_long cmd;
458 caddr_t data;
459{
460 struct gif_softc *sc = (struct gif_softc*)ifp;
461 struct ifreq *ifr = (struct ifreq*)data;
462 int error = 0, size;
463 struct sockaddr *dst, *src;
464#ifdef SIOCSIFMTU /* xxx */
465 u_long mtu;
466#endif
467
468 switch (cmd) {
469 case SIOCSIFADDR:
470 ifp->if_flags |= IFF_UP;
471 break;
472
473 case SIOCSIFDSTADDR:
474 break;
475
476 case SIOCADDMULTI:
477 case SIOCDELMULTI:
478 break;
479
480#ifdef SIOCSIFMTU /* xxx */
481 case SIOCGIFMTU:
482 break;
483
484 case SIOCSIFMTU:
485 mtu = ifr->ifr_mtu;
486 if (mtu < GIF_MTU_MIN || mtu > GIF_MTU_MAX)
487 return (EINVAL);
488 ifp->if_mtu = mtu;
489 break;
490#endif /* SIOCSIFMTU */
491
492#ifdef INET
493 case SIOCSIFPHYADDR:
494#endif
495#ifdef INET6
496 case SIOCSIFPHYADDR_IN6:
497#endif /* INET6 */
498 case SIOCSLIFPHYADDR:
499 switch (cmd) {
500#ifdef INET
501 case SIOCSIFPHYADDR:
502 src = (struct sockaddr *)
503 &(((struct in_aliasreq *)data)->ifra_addr);
504 dst = (struct sockaddr *)
505 &(((struct in_aliasreq *)data)->ifra_dstaddr);
506 break;
507#endif
508#ifdef INET6
509 case SIOCSIFPHYADDR_IN6:
510 src = (struct sockaddr *)
511 &(((struct in6_aliasreq *)data)->ifra_addr);
512 dst = (struct sockaddr *)
513 &(((struct in6_aliasreq *)data)->ifra_dstaddr);
514 break;
515#endif
516 case SIOCSLIFPHYADDR:
517 src = (struct sockaddr *)
518 &(((struct if_laddrreq *)data)->addr);
519 dst = (struct sockaddr *)
520 &(((struct if_laddrreq *)data)->dstaddr);
521 break;
522 default:
523 return EINVAL;
524 }
525
526 /* sa_family must be equal */
527 if (src->sa_family != dst->sa_family)
528 return EINVAL;
529
530 /* validate sa_len */
531 switch (src->sa_family) {
532#ifdef INET
533 case AF_INET:
534 if (src->sa_len != sizeof(struct sockaddr_in))
535 return EINVAL;
536 break;
537#endif
538#ifdef INET6
539 case AF_INET6:
540 if (src->sa_len != sizeof(struct sockaddr_in6))
541 return EINVAL;
542 break;
543#endif
544 default:
545 return EAFNOSUPPORT;
546 }
547 switch (dst->sa_family) {
548#ifdef INET
549 case AF_INET:
550 if (dst->sa_len != sizeof(struct sockaddr_in))
551 return EINVAL;
552 break;
553#endif
554#ifdef INET6
555 case AF_INET6:
556 if (dst->sa_len != sizeof(struct sockaddr_in6))
557 return EINVAL;
558 break;
559#endif
560 default:
561 return EAFNOSUPPORT;
562 }
563
564 /* check sa_family looks sane for the cmd */
565 switch (cmd) {
566 case SIOCSIFPHYADDR:
567 if (src->sa_family == AF_INET)
568 break;
569 return EAFNOSUPPORT;
570#ifdef INET6
571 case SIOCSIFPHYADDR_IN6:
572 if (src->sa_family == AF_INET6)
573 break;
574 return EAFNOSUPPORT;
575#endif /* INET6 */
576 case SIOCSLIFPHYADDR:
577 /* checks done in the above */
578 break;
579 }
580
581 error = gif_set_tunnel(&sc->gif_if, src, dst);
582 break;
583
584#ifdef SIOCDIFPHYADDR
585 case SIOCDIFPHYADDR:
586 gif_delete_tunnel(&sc->gif_if);
587 break;
588#endif
589
590 case SIOCGIFPSRCADDR:
591#ifdef INET6
592 case SIOCGIFPSRCADDR_IN6:
593#endif /* INET6 */
594 if (sc->gif_psrc == NULL) {
595 error = EADDRNOTAVAIL;
596 goto bad;
597 }
598 src = sc->gif_psrc;
599 switch (cmd) {
600#ifdef INET
601 case SIOCGIFPSRCADDR:
602 dst = &ifr->ifr_addr;
603 size = sizeof(ifr->ifr_addr);
604 break;
605#endif /* INET */
606#ifdef INET6
607 case SIOCGIFPSRCADDR_IN6:
608 dst = (struct sockaddr *)
609 &(((struct in6_ifreq *)data)->ifr_addr);
610 size = sizeof(((struct in6_ifreq *)data)->ifr_addr);
611 break;
612#endif /* INET6 */
613 default:
614 error = EADDRNOTAVAIL;
615 goto bad;
616 }
617 if (src->sa_len > size)
618 return EINVAL;
619 bcopy((caddr_t)src, (caddr_t)dst, src->sa_len);
620 break;
621
622 case SIOCGIFPDSTADDR:
623#ifdef INET6
624 case SIOCGIFPDSTADDR_IN6:
625#endif /* INET6 */
626 if (sc->gif_pdst == NULL) {
627 error = EADDRNOTAVAIL;
628 goto bad;
629 }
630 src = sc->gif_pdst;
631 switch (cmd) {
632#ifdef INET
633 case SIOCGIFPDSTADDR:
634 dst = &ifr->ifr_addr;
635 size = sizeof(ifr->ifr_addr);
636 break;
637#endif /* INET */
638#ifdef INET6
639 case SIOCGIFPDSTADDR_IN6:
640 dst = (struct sockaddr *)
641 &(((struct in6_ifreq *)data)->ifr_addr);
642 size = sizeof(((struct in6_ifreq *)data)->ifr_addr);
643 break;
644#endif /* INET6 */
645 default:
646 error = EADDRNOTAVAIL;
647 goto bad;
648 }
649 if (src->sa_len > size)
650 return EINVAL;
651 bcopy((caddr_t)src, (caddr_t)dst, src->sa_len);
652 break;
653
654 case SIOCGLIFPHYADDR:
655 if (sc->gif_psrc == NULL || sc->gif_pdst == NULL) {
656 error = EADDRNOTAVAIL;
657 goto bad;
658 }
659
660 /* copy src */
661 src = sc->gif_psrc;
662 dst = (struct sockaddr *)
663 &(((struct if_laddrreq *)data)->addr);
664 size = sizeof(((struct if_laddrreq *)data)->addr);
665 if (src->sa_len > size)
666 return EINVAL;
667 bcopy((caddr_t)src, (caddr_t)dst, src->sa_len);
668
669 /* copy dst */
670 src = sc->gif_pdst;
671 dst = (struct sockaddr *)
672 &(((struct if_laddrreq *)data)->dstaddr);
673 size = sizeof(((struct if_laddrreq *)data)->dstaddr);
674 if (src->sa_len > size)
675 return EINVAL;
676 bcopy((caddr_t)src, (caddr_t)dst, src->sa_len);
677 break;
678
679 case SIOCSIFFLAGS:
680 /* if_ioctl() takes care of it */
681 break;
682
683 default:
684 error = EINVAL;
685 break;
686 }
687 bad:
688 return error;
689}
690
691int
692gif_set_tunnel(ifp, src, dst)
693 struct ifnet *ifp;
694 struct sockaddr *src;
695 struct sockaddr *dst;
696{
697 struct gif_softc *sc = (struct gif_softc *)ifp;
698 struct gif_softc *sc2;
699 struct sockaddr *osrc, *odst, *sa;
700 int s;
701 int error = 0;
702
703 s = splnet();
704
705 LIST_FOREACH(sc2, &gif_softc_list, gif_list) {
706 if (sc2 == sc)
707 continue;
708 if (!sc2->gif_pdst || !sc2->gif_psrc)
709 continue;
710 if (sc2->gif_pdst->sa_family != dst->sa_family ||
711 sc2->gif_pdst->sa_len != dst->sa_len ||
712 sc2->gif_psrc->sa_family != src->sa_family ||
713 sc2->gif_psrc->sa_len != src->sa_len)
714 continue;
715
716 /*
717 * Disallow parallel tunnels unless instructed
718 * otherwise.
719 */
720 if (!parallel_tunnels &&
721 bcmp(sc2->gif_pdst, dst, dst->sa_len) == 0 &&
722 bcmp(sc2->gif_psrc, src, src->sa_len) == 0) {
723 error = EADDRNOTAVAIL;
724 goto bad;
725 }
726
727 /* XXX both end must be valid? (I mean, not 0.0.0.0) */
728 }
729
730 /* XXX we can detach from both, but be polite just in case */
731 if (sc->gif_psrc)
732 switch (sc->gif_psrc->sa_family) {
733#ifdef INET
734 case AF_INET:
735 (void)in_gif_detach(sc);
736 break;
737#endif
738#ifdef INET6
739 case AF_INET6:
740 (void)in6_gif_detach(sc);
741 break;
742#endif
743 }
744
745 osrc = sc->gif_psrc;
746 sa = (struct sockaddr *)malloc(src->sa_len, M_IFADDR, M_WAITOK);
747 bcopy((caddr_t)src, (caddr_t)sa, src->sa_len);
748 sc->gif_psrc = sa;
749
750 odst = sc->gif_pdst;
751 sa = (struct sockaddr *)malloc(dst->sa_len, M_IFADDR, M_WAITOK);
752 bcopy((caddr_t)dst, (caddr_t)sa, dst->sa_len);
753 sc->gif_pdst = sa;
754
755 switch (sc->gif_psrc->sa_family) {
756#ifdef INET
757 case AF_INET:
758 error = in_gif_attach(sc);
759 break;
760#endif
761#ifdef INET6
762 case AF_INET6:
763 error = in6_gif_attach(sc);
764 break;
765#endif
766 }
767 if (error) {
768 /* rollback */
769 free((caddr_t)sc->gif_psrc, M_IFADDR);
770 free((caddr_t)sc->gif_pdst, M_IFADDR);
771 sc->gif_psrc = osrc;
772 sc->gif_pdst = odst;
773 goto bad;
774 }
775
776 if (osrc)
777 free((caddr_t)osrc, M_IFADDR);
778 if (odst)
779 free((caddr_t)odst, M_IFADDR);
780
781 if (sc->gif_psrc && sc->gif_pdst)
782 ifp->if_flags |= IFF_RUNNING;
783 else
784 ifp->if_flags &= ~IFF_RUNNING;
785 splx(s);
786
787 return 0;
788
789 bad:
790 if (sc->gif_psrc && sc->gif_pdst)
791 ifp->if_flags |= IFF_RUNNING;
792 else
793 ifp->if_flags &= ~IFF_RUNNING;
794 splx(s);
795
796 return error;
797}
798
799void
800gif_delete_tunnel(ifp)
801 struct ifnet *ifp;
802{
803 struct gif_softc *sc = (struct gif_softc *)ifp;
804 int s;
805
806 s = splnet();
807
808 if (sc->gif_psrc) {
809 free((caddr_t)sc->gif_psrc, M_IFADDR);
810 sc->gif_psrc = NULL;
811 }
812 if (sc->gif_pdst) {
813 free((caddr_t)sc->gif_pdst, M_IFADDR);
814 sc->gif_pdst = NULL;
815 }
816 /* it is safe to detach from both */
817#ifdef INET
818 (void)in_gif_detach(sc);
819#endif
820#ifdef INET6
821 (void)in6_gif_detach(sc);
822#endif
823
824 if (sc->gif_psrc && sc->gif_pdst)
825 ifp->if_flags |= IFF_RUNNING;
826 else
827 ifp->if_flags &= ~IFF_RUNNING;
828 splx(s);
829}
|