For kmalloc(), MALLOC() and contigmalloc(), use M_ZERO instead of
[dragonfly.git] / sys / net / gif / if_gif.c
1 /*
2  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
3  * 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. Neither the name of the project nor the names of its contributors
14  *    may be used to endorse or promote products derived from this software
15  *    without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27  * SUCH DAMAGE.
28  *
29  * $FreeBSD: src/sys/net/if_gif.c,v 1.4.2.15 2002/11/08 16:57:13 ume Exp $
30  * $DragonFly: src/sys/net/gif/if_gif.c,v 1.19 2008/01/05 14:02:38 swildner Exp $
31  * $KAME: if_gif.c,v 1.87 2001/10/19 08:50:27 itojun Exp $
32  */
33
34 #include "opt_inet.h"
35 #include "opt_inet6.h"
36
37 #include <sys/param.h>
38 #include <sys/systm.h>
39 #include <sys/kernel.h>
40 #include <sys/bus.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 <sys/thread2.h>
52
53 #include <machine/cpu.h>
54
55 #include <net/if.h>
56 #include <net/if_types.h>
57 #include <net/netisr.h>
58 #include <net/route.h>
59 #include <net/bpf.h>
60
61 #include <netinet/in.h>
62 #include <netinet/in_systm.h>
63 #include <netinet/ip.h>
64 #ifdef  INET
65 #include <netinet/in_var.h>
66 #include <netinet/in_gif.h>
67 #include <netinet/ip_var.h>
68 #endif  /* INET */
69
70 #ifdef INET6
71 #ifndef INET
72 #include <netinet/in.h>
73 #endif
74 #include <netinet6/in6_var.h>
75 #include <netinet/ip6.h>
76 #include <netinet6/ip6_var.h>
77 #include <netinet6/in6_gif.h>
78 #include <netinet6/ip6protosw.h>
79 #endif /* INET6 */
80
81 #include <netinet/ip_encap.h>
82 #include "if_gif.h"
83
84 #include <net/net_osdep.h>
85
86 #define GIFNAME         "gif"
87
88 static MALLOC_DEFINE(M_GIF, "gif", "Generic Tunnel Interface");
89 LIST_HEAD(, gif_softc) gif_softc_list;
90
91 int     gif_clone_create (struct if_clone *, int);
92 void    gif_clone_destroy (struct ifnet *);
93
94 struct if_clone gif_cloner = IF_CLONE_INITIALIZER("gif", gif_clone_create,
95     gif_clone_destroy, 0, IF_MAXUNIT);
96
97 static int gifmodevent (module_t, int, void *);
98
99 SYSCTL_DECL(_net_link);
100 SYSCTL_NODE(_net_link, IFT_GIF, gif, CTLFLAG_RW, 0,
101     "Generic Tunnel Interface");
102 #ifndef MAX_GIF_NEST
103 /*
104  * This macro controls the default upper limitation on nesting of gif tunnels.
105  * Since, setting a large value to this macro with a careless configuration
106  * may introduce system crash, we don't allow any nestings by default.
107  * If you need to configure nested gif tunnels, you can define this macro
108  * in your kernel configuration file.  However, if you do so, please be
109  * careful to configure the tunnels so that it won't make a loop.
110  */
111 #define MAX_GIF_NEST 1
112 #endif
113 static int max_gif_nesting = MAX_GIF_NEST;
114 SYSCTL_INT(_net_link_gif, OID_AUTO, max_nesting, CTLFLAG_RW,
115     &max_gif_nesting, 0, "Max nested tunnels");
116
117 /*
118  * By default, we disallow creation of multiple tunnels between the same
119  * pair of addresses.  Some applications require this functionality so
120  * we allow control over this check here.
121  */
122 #ifdef XBONEHACK
123 static int parallel_tunnels = 1;
124 #else
125 static int parallel_tunnels = 0;
126 #endif
127 SYSCTL_INT(_net_link_gif, OID_AUTO, parallel_tunnels, CTLFLAG_RW,
128     &parallel_tunnels, 0, "Allow parallel tunnels?");
129
130 int
131 gif_clone_create(struct if_clone *ifc, int unit)
132 {
133         struct gif_softc *sc;
134         
135         sc = kmalloc (sizeof(struct gif_softc), M_GIF, M_WAITOK | M_ZERO);
136
137         sc->gif_if.if_softc = sc;
138         if_initname(&(sc->gif_if), GIFNAME, unit);
139
140         gifattach0(sc);
141
142         LIST_INSERT_HEAD(&gif_softc_list, sc, gif_list);
143         return (0);
144 }
145
146 void
147 gifattach0(struct gif_softc *sc)
148 {
149
150         sc->encap_cookie4 = sc->encap_cookie6 = NULL;
151
152         sc->gif_if.if_addrlen = 0;
153         sc->gif_if.if_mtu    = GIF_MTU;
154         sc->gif_if.if_flags  = IFF_POINTOPOINT | IFF_MULTICAST;
155 #if 0
156         /* turn off ingress filter */
157         sc->gif_if.if_flags  |= IFF_LINK2;
158 #endif
159         sc->gif_if.if_ioctl  = gif_ioctl;
160         sc->gif_if.if_output = gif_output;
161         sc->gif_if.if_type   = IFT_GIF;
162         sc->gif_if.if_snd.ifq_maxlen = IFQ_MAXLEN;
163         if_attach(&sc->gif_if, NULL);
164         bpfattach(&sc->gif_if, DLT_NULL, sizeof(u_int));
165 }
166
167 void
168 gif_clone_destroy(struct ifnet *ifp)
169 {
170         int err;
171         struct gif_softc *sc = ifp->if_softc;
172
173         gif_delete_tunnel(&sc->gif_if);
174         LIST_REMOVE(sc, gif_list);
175 #ifdef INET6
176         if (sc->encap_cookie6 != NULL) {
177                 err = encap_detach(sc->encap_cookie6);
178                 KASSERT(err == 0, ("Unexpected error detaching encap_cookie6"));
179         }
180 #endif
181 #ifdef INET
182         if (sc->encap_cookie4 != NULL) {
183                 err = encap_detach(sc->encap_cookie4);
184                 KASSERT(err == 0, ("Unexpected error detaching encap_cookie4"));
185         }
186 #endif
187
188         bpfdetach(ifp);
189         if_detach(ifp);
190
191         kfree(sc, M_GIF);
192 }
193
194 static int
195 gifmodevent(module_t mod, int type, void *data)
196 {
197
198         switch (type) {
199         case MOD_LOAD:
200                 LIST_INIT(&gif_softc_list);
201                 if_clone_attach(&gif_cloner);
202
203 #ifdef INET6
204                 ip6_gif_hlim = GIF_HLIM;
205 #endif
206
207                 break;
208         case MOD_UNLOAD:
209                 if_clone_detach(&gif_cloner);
210
211                 while (!LIST_EMPTY(&gif_softc_list))
212                         gif_clone_destroy(&LIST_FIRST(&gif_softc_list)->gif_if);
213
214 #ifdef INET6
215                 ip6_gif_hlim = 0;
216 #endif
217                 break;
218         }
219         return 0;
220 }
221
222 static moduledata_t gif_mod = {
223         "if_gif",
224         gifmodevent,
225         0
226 };
227
228 DECLARE_MODULE(if_gif, gif_mod, SI_SUB_PSEUDO, SI_ORDER_ANY);
229
230 int
231 gif_encapcheck(const struct mbuf *m, int off, int proto, void *arg)
232 {
233         struct ip ip;
234         struct gif_softc *sc;
235
236         sc = (struct gif_softc *)arg;
237         if (sc == NULL)
238                 return 0;
239
240         if ((sc->gif_if.if_flags & IFF_UP) == 0)
241                 return 0;
242
243         /* no physical address */
244         if (!sc->gif_psrc || !sc->gif_pdst)
245                 return 0;
246
247         switch (proto) {
248 #ifdef INET
249         case IPPROTO_IPV4:
250                 break;
251 #endif
252 #ifdef INET6
253         case IPPROTO_IPV6:
254                 break;
255 #endif
256         default:
257                 return 0;
258         }
259
260         /* Bail on short packets */
261         if (m->m_pkthdr.len < sizeof(ip))
262                 return 0;
263
264         m_copydata(m, 0, sizeof(ip), (caddr_t)&ip);
265
266         switch (ip.ip_v) {
267 #ifdef INET
268         case 4:
269                 if (sc->gif_psrc->sa_family != AF_INET ||
270                     sc->gif_pdst->sa_family != AF_INET)
271                         return 0;
272                 return gif_encapcheck4(m, off, proto, arg);
273 #endif
274 #ifdef INET6
275         case 6:
276                 if (m->m_pkthdr.len < sizeof(struct ip6_hdr))
277                         return 0;
278                 if (sc->gif_psrc->sa_family != AF_INET6 ||
279                     sc->gif_pdst->sa_family != AF_INET6)
280                         return 0;
281                 return gif_encapcheck6(m, off, proto, arg);
282 #endif
283         default:
284                 return 0;
285         }
286 }
287
288 /*
289  * Parameters:
290  *      rt:     added in net2
291  */
292 int
293 gif_output(struct ifnet *ifp, struct mbuf *m, struct sockaddr *dst,
294            struct rtentry *rt)
295 {
296         struct gif_softc *sc = (struct gif_softc*)ifp;
297         int error = 0;
298         static int called = 0;  /* XXX: MUTEX */
299
300         /*
301          * gif may cause infinite recursion calls when misconfigured.
302          * We'll prevent this by introducing upper limit.
303          * XXX: this mechanism may introduce another problem about
304          *      mutual exclusion of the variable CALLED, especially if we
305          *      use kernel thread.
306          */
307         if (++called > max_gif_nesting) {
308                 log(LOG_NOTICE,
309                     "gif_output: recursively called too many times(%d)\n",
310                     called);
311                 m_freem(m);
312                 error = EIO;    /* is there better errno? */
313                 goto end;
314         }
315
316         m->m_flags &= ~(M_BCAST|M_MCAST);
317         if (!(ifp->if_flags & IFF_UP) ||
318             sc->gif_psrc == NULL || sc->gif_pdst == NULL) {
319                 m_freem(m);
320                 error = ENETDOWN;
321                 goto end;
322         }
323
324         if (ifp->if_bpf) {
325                 /*
326                  * We need to prepend the address family as
327                  * a four byte field.
328                  */
329                 uint32_t af = dst->sa_family;
330
331                 bpf_ptap(ifp->if_bpf, m, &af, sizeof(4));
332         }
333         ifp->if_opackets++;     
334         ifp->if_obytes += m->m_pkthdr.len;
335
336         /* inner AF-specific encapsulation */
337
338         /* XXX should we check if our outer source is legal? */
339
340         /* dispatch to output logic based on outer AF */
341         switch (sc->gif_psrc->sa_family) {
342 #ifdef INET
343         case AF_INET:
344                 error = in_gif_output(ifp, dst->sa_family, m);
345                 break;
346 #endif
347 #ifdef INET6
348         case AF_INET6:
349                 error = in6_gif_output(ifp, dst->sa_family, m);
350                 break;
351 #endif
352         default:
353                 m_freem(m);             
354                 error = ENETDOWN;
355                 goto end;
356         }
357
358   end:
359         called = 0;             /* reset recursion counter */
360         if (error)
361                 ifp->if_oerrors++;
362         return error;
363 }
364
365 void
366 gif_input(struct mbuf *m, int af, struct ifnet *ifp)
367 {
368         int isr;
369
370         if (ifp == NULL) {
371                 /* just in case */
372                 m_freem(m);
373                 return;
374         }
375
376         m->m_pkthdr.rcvif = ifp;
377         
378         if (ifp->if_bpf) {
379                 /*
380                  * We need to prepend the address family as
381                  * a four byte field.
382                  */
383                 uint32_t af1 = af;
384
385                 bpf_ptap(ifp->if_bpf, m, &af1, sizeof(af1));
386         }
387
388         /*
389          * Put the packet to the network layer input queue according to the
390          * specified address family.
391          * Note: older versions of gif_input directly called network layer
392          * input functions, e.g. ip6_input, here.  We changed the policy to
393          * prevent too many recursive calls of such input functions, which
394          * might cause kernel panic.  But the change may introduce another
395          * problem; if the input queue is full, packets are discarded.
396          * The kernel stack overflow really happened, and we believed
397          * queue-full rarely occurs, so we changed the policy.
398          */
399         switch (af) {
400 #ifdef INET
401         case AF_INET:
402                 isr = NETISR_IP;
403                 break;
404 #endif
405 #ifdef INET6
406         case AF_INET6:
407                 isr = NETISR_IPV6;
408                 break;
409 #endif
410         default:
411                 m_freem(m);
412                 return;
413         }
414
415         ifp->if_ipackets++;
416         ifp->if_ibytes += m->m_pkthdr.len;
417         netisr_dispatch(isr, m);
418
419         return;
420 }
421
422 /* XXX how should we handle IPv6 scope on SIOC[GS]IFPHYADDR? */
423 int
424 gif_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data, struct ucred *cr)
425 {
426         struct gif_softc *sc  = (struct gif_softc*)ifp;
427         struct ifreq     *ifr = (struct ifreq*)data;
428         int error = 0, size;
429         struct sockaddr *dst, *src;
430 #ifdef  SIOCSIFMTU /* xxx */
431         u_long mtu;
432 #endif
433
434         switch (cmd) {
435         case SIOCSIFADDR:
436                 ifp->if_flags |= IFF_UP;
437                 break;
438                 
439         case SIOCSIFDSTADDR:
440                 break;
441
442         case SIOCADDMULTI:
443         case SIOCDELMULTI:
444                 break;
445
446 #ifdef  SIOCSIFMTU /* xxx */
447         case SIOCGIFMTU:
448                 break;
449
450         case SIOCSIFMTU:
451                 mtu = ifr->ifr_mtu;
452                 if (mtu < GIF_MTU_MIN || mtu > GIF_MTU_MAX)
453                         return (EINVAL);
454                 ifp->if_mtu = mtu;
455                 break;
456 #endif /* SIOCSIFMTU */
457
458 #ifdef INET
459         case SIOCSIFPHYADDR:
460 #endif
461 #ifdef INET6
462         case SIOCSIFPHYADDR_IN6:
463 #endif /* INET6 */
464         case SIOCSLIFPHYADDR:
465                 switch (cmd) {
466 #ifdef INET
467                 case SIOCSIFPHYADDR:
468                         src = (struct sockaddr *)
469                                 &(((struct in_aliasreq *)data)->ifra_addr);
470                         dst = (struct sockaddr *)
471                                 &(((struct in_aliasreq *)data)->ifra_dstaddr);
472                         break;
473 #endif
474 #ifdef INET6
475                 case SIOCSIFPHYADDR_IN6:
476                         src = (struct sockaddr *)
477                                 &(((struct in6_aliasreq *)data)->ifra_addr);
478                         dst = (struct sockaddr *)
479                                 &(((struct in6_aliasreq *)data)->ifra_dstaddr);
480                         break;
481 #endif
482                 case SIOCSLIFPHYADDR:
483                         src = (struct sockaddr *)
484                                 &(((struct if_laddrreq *)data)->addr);
485                         dst = (struct sockaddr *)
486                                 &(((struct if_laddrreq *)data)->dstaddr);
487                         break;
488                 default:
489                         return EINVAL;
490                 }
491
492                 /* sa_family must be equal */
493                 if (src->sa_family != dst->sa_family)
494                         return EINVAL;
495
496                 /* validate sa_len */
497                 switch (src->sa_family) {
498 #ifdef INET
499                 case AF_INET:
500                         if (src->sa_len != sizeof(struct sockaddr_in))
501                                 return EINVAL;
502                         break;
503 #endif
504 #ifdef INET6
505                 case AF_INET6:
506                         if (src->sa_len != sizeof(struct sockaddr_in6))
507                                 return EINVAL;
508                         break;
509 #endif
510                 default:
511                         return EAFNOSUPPORT;
512                 }
513                 switch (dst->sa_family) {
514 #ifdef INET
515                 case AF_INET:
516                         if (dst->sa_len != sizeof(struct sockaddr_in))
517                                 return EINVAL;
518                         break;
519 #endif
520 #ifdef INET6
521                 case AF_INET6:
522                         if (dst->sa_len != sizeof(struct sockaddr_in6))
523                                 return EINVAL;
524                         break;
525 #endif
526                 default:
527                         return EAFNOSUPPORT;
528                 }
529
530                 /* check sa_family looks sane for the cmd */
531                 switch (cmd) {
532                 case SIOCSIFPHYADDR:
533                         if (src->sa_family == AF_INET)
534                                 break;
535                         return EAFNOSUPPORT;
536 #ifdef INET6
537                 case SIOCSIFPHYADDR_IN6:
538                         if (src->sa_family == AF_INET6)
539                                 break;
540                         return EAFNOSUPPORT;
541 #endif /* INET6 */
542                 case SIOCSLIFPHYADDR:
543                         /* checks done in the above */
544                         break;
545                 }
546
547                 error = gif_set_tunnel(&sc->gif_if, src, dst);
548                 break;
549
550 #ifdef SIOCDIFPHYADDR
551         case SIOCDIFPHYADDR:
552                 gif_delete_tunnel(&sc->gif_if);
553                 break;
554 #endif
555                         
556         case SIOCGIFPSRCADDR:
557 #ifdef INET6
558         case SIOCGIFPSRCADDR_IN6:
559 #endif /* INET6 */
560                 if (sc->gif_psrc == NULL) {
561                         error = EADDRNOTAVAIL;
562                         goto bad;
563                 }
564                 src = sc->gif_psrc;
565                 switch (cmd) {
566 #ifdef INET
567                 case SIOCGIFPSRCADDR:
568                         dst = &ifr->ifr_addr;
569                         size = sizeof(ifr->ifr_addr);
570                         break;
571 #endif /* INET */
572 #ifdef INET6
573                 case SIOCGIFPSRCADDR_IN6:
574                         dst = (struct sockaddr *)
575                                 &(((struct in6_ifreq *)data)->ifr_addr);
576                         size = sizeof(((struct in6_ifreq *)data)->ifr_addr);
577                         break;
578 #endif /* INET6 */
579                 default:
580                         error = EADDRNOTAVAIL;
581                         goto bad;
582                 }
583                 if (src->sa_len > size)
584                         return EINVAL;
585                 bcopy((caddr_t)src, (caddr_t)dst, src->sa_len);
586                 break;
587                         
588         case SIOCGIFPDSTADDR:
589 #ifdef INET6
590         case SIOCGIFPDSTADDR_IN6:
591 #endif /* INET6 */
592                 if (sc->gif_pdst == NULL) {
593                         error = EADDRNOTAVAIL;
594                         goto bad;
595                 }
596                 src = sc->gif_pdst;
597                 switch (cmd) {
598 #ifdef INET
599                 case SIOCGIFPDSTADDR:
600                         dst = &ifr->ifr_addr;
601                         size = sizeof(ifr->ifr_addr);
602                         break;
603 #endif /* INET */
604 #ifdef INET6
605                 case SIOCGIFPDSTADDR_IN6:
606                         dst = (struct sockaddr *)
607                                 &(((struct in6_ifreq *)data)->ifr_addr);
608                         size = sizeof(((struct in6_ifreq *)data)->ifr_addr);
609                         break;
610 #endif /* INET6 */
611                 default:
612                         error = EADDRNOTAVAIL;
613                         goto bad;
614                 }
615                 if (src->sa_len > size)
616                         return EINVAL;
617                 bcopy((caddr_t)src, (caddr_t)dst, src->sa_len);
618                 break;
619
620         case SIOCGLIFPHYADDR:
621                 if (sc->gif_psrc == NULL || sc->gif_pdst == NULL) {
622                         error = EADDRNOTAVAIL;
623                         goto bad;
624                 }
625
626                 /* copy src */
627                 src = sc->gif_psrc;
628                 dst = (struct sockaddr *)
629                         &(((struct if_laddrreq *)data)->addr);
630                 size = sizeof(((struct if_laddrreq *)data)->addr);
631                 if (src->sa_len > size)
632                         return EINVAL;
633                 bcopy((caddr_t)src, (caddr_t)dst, src->sa_len);
634
635                 /* copy dst */
636                 src = sc->gif_pdst;
637                 dst = (struct sockaddr *)
638                         &(((struct if_laddrreq *)data)->dstaddr);
639                 size = sizeof(((struct if_laddrreq *)data)->dstaddr);
640                 if (src->sa_len > size)
641                         return EINVAL;
642                 bcopy((caddr_t)src, (caddr_t)dst, src->sa_len);
643                 break;
644
645         case SIOCSIFFLAGS:
646                 /* if_ioctl() takes care of it */
647                 break;
648
649         default:
650                 error = EINVAL;
651                 break;
652         }
653  bad:
654         return error;
655 }
656
657 int
658 gif_set_tunnel(struct ifnet *ifp, struct sockaddr *src, struct sockaddr *dst)
659 {
660         struct gif_softc *sc = (struct gif_softc *)ifp;
661         struct gif_softc *sc2;
662         struct sockaddr *osrc, *odst, *sa;
663         int error = 0; 
664
665         crit_enter();
666
667         LIST_FOREACH(sc2, &gif_softc_list, gif_list) {
668                 if (sc2 == sc)
669                         continue;
670                 if (!sc2->gif_pdst || !sc2->gif_psrc)
671                         continue;
672                 if (sc2->gif_pdst->sa_family != dst->sa_family ||
673                     sc2->gif_pdst->sa_len != dst->sa_len ||
674                     sc2->gif_psrc->sa_family != src->sa_family ||
675                     sc2->gif_psrc->sa_len != src->sa_len)
676                         continue;
677
678                 /*
679                  * Disallow parallel tunnels unless instructed
680                  * otherwise.
681                  */
682                 if (!parallel_tunnels &&
683                     bcmp(sc2->gif_pdst, dst, dst->sa_len) == 0 &&
684                     bcmp(sc2->gif_psrc, src, src->sa_len) == 0) {
685                         error = EADDRNOTAVAIL;
686                         goto bad;
687                 }
688
689                 /* XXX both end must be valid? (I mean, not 0.0.0.0) */
690         }
691
692         /* XXX we can detach from both, but be polite just in case */
693         if (sc->gif_psrc)
694                 switch (sc->gif_psrc->sa_family) {
695 #ifdef INET
696                 case AF_INET:
697                         in_gif_detach(sc);
698                         break;
699 #endif
700 #ifdef INET6
701                 case AF_INET6:
702                         in6_gif_detach(sc);
703                         break;
704 #endif
705                 }
706
707         osrc = sc->gif_psrc;
708         sa = (struct sockaddr *)kmalloc(src->sa_len, M_IFADDR, M_WAITOK);
709         bcopy((caddr_t)src, (caddr_t)sa, src->sa_len);
710         sc->gif_psrc = sa;
711
712         odst = sc->gif_pdst;
713         sa = (struct sockaddr *)kmalloc(dst->sa_len, M_IFADDR, M_WAITOK);
714         bcopy((caddr_t)dst, (caddr_t)sa, dst->sa_len);
715         sc->gif_pdst = sa;
716
717         switch (sc->gif_psrc->sa_family) {
718 #ifdef INET
719         case AF_INET:
720                 error = in_gif_attach(sc);
721                 break;
722 #endif
723 #ifdef INET6
724         case AF_INET6:
725                 error = in6_gif_attach(sc);
726                 break;
727 #endif
728         }
729         if (error) {
730                 /* rollback */
731                 kfree((caddr_t)sc->gif_psrc, M_IFADDR);
732                 kfree((caddr_t)sc->gif_pdst, M_IFADDR);
733                 sc->gif_psrc = osrc;
734                 sc->gif_pdst = odst;
735                 goto bad;
736         }
737
738         if (osrc)
739                 kfree((caddr_t)osrc, M_IFADDR);
740         if (odst)
741                 kfree((caddr_t)odst, M_IFADDR);
742
743         if (sc->gif_psrc && sc->gif_pdst)
744                 ifp->if_flags |= IFF_RUNNING;
745         else
746                 ifp->if_flags &= ~IFF_RUNNING;
747         crit_exit();
748
749         return 0;
750
751  bad:
752         if (sc->gif_psrc && sc->gif_pdst)
753                 ifp->if_flags |= IFF_RUNNING;
754         else
755                 ifp->if_flags &= ~IFF_RUNNING;
756         crit_exit();
757
758         return error;
759 }
760
761 void
762 gif_delete_tunnel(struct ifnet *ifp)
763 {
764         struct gif_softc *sc = (struct gif_softc *)ifp;
765
766         crit_enter();
767
768         if (sc->gif_psrc) {
769                 kfree((caddr_t)sc->gif_psrc, M_IFADDR);
770                 sc->gif_psrc = NULL;
771         }
772         if (sc->gif_pdst) {
773                 kfree((caddr_t)sc->gif_pdst, M_IFADDR);
774                 sc->gif_pdst = NULL;
775         }
776         /* it is safe to detach from both */
777 #ifdef INET
778         in_gif_detach(sc);
779 #endif
780 #ifdef INET6
781         in6_gif_detach(sc);
782 #endif
783
784         if (sc->gif_psrc && sc->gif_pdst)
785                 ifp->if_flags |= IFF_RUNNING;
786         else
787                 ifp->if_flags &= ~IFF_RUNNING;
788         crit_exit();
789 }