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