sys/net/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  *      $KAME: if_gif.c,v 1.87 2001/10/19 08:50:27 itojun Exp $
  30  */
  31
  32 #include <sys/cdefs.h>
  33 __FBSDID("$FreeBSD$");
  34
  35 #include "opt_inet.h"
  36 #include "opt_inet6.h"
  37
  38 #include <sys/param.h>
  39 #include <sys/systm.h>
  40 #include <sys/jail.h>
  41 #include <sys/kernel.h>
  42 #include <sys/lock.h>
  43 #include <sys/malloc.h>
  44 #include <sys/mbuf.h>
  45 #include <sys/module.h>
  46 #include <sys/rmlock.h>
  47 #include <sys/socket.h>
  48 #include <sys/sockio.h>
  49 #include <sys/sx.h>
  50 #include <sys/errno.h>
  51 #include <sys/time.h>
  52 #include <sys/sysctl.h>
  53 #include <sys/syslog.h>
  54 #include <sys/priv.h>
  55 #include <sys/proc.h>
  56 #include <sys/protosw.h>
  57 #include <sys/conf.h>
  58 #include <machine/cpu.h>
  59
  60 #include <net/if.h>
  61 #include <net/if_var.h>
  62 #include <net/if_clone.h>
  63 #include <net/if_types.h>
  64 #include <net/netisr.h>
  65 #include <net/route.h>
  66 #include <net/bpf.h>
  67 #include <net/vnet.h>
  68
  69 #include <netinet/in.h>
  70 #include <netinet/in_systm.h>
  71 #include <netinet/ip.h>
  72 #include <netinet/ip_ecn.h>
  73 #ifdef  INET
  74 #include <netinet/in_var.h>
  75 #include <netinet/ip_var.h>
  76 #endif  /* INET */
  77
  78 #ifdef INET6
  79 #ifndef INET
  80 #include <netinet/in.h>
  81 #endif
  82 #include <netinet6/in6_var.h>
  83 #include <netinet/ip6.h>
  84 #include <netinet6/ip6_ecn.h>
  85 #include <netinet6/ip6_var.h>
  86 #include <netinet6/scope6_var.h>
  87 #include <netinet6/ip6protosw.h>
  88 #endif /* INET6 */
  89
  90 #include <netinet/ip_encap.h>
  91 #include <net/ethernet.h>
  92 #include <net/if_bridgevar.h>
  93 #include <net/if_gif.h>
  94
  95 #include <security/mac/mac_framework.h>
  96
  97 static const char gifname[] = "gif";
  98
  99 /*
 100  * gif_mtx protects a per-vnet gif_softc_list.
 101  */
 102 static VNET_DEFINE(struct mtx, gif_mtx);
 103 #define V_gif_mtx               VNET(gif_mtx)
 104 static MALLOC_DEFINE(M_GIF, "gif", "Generic Tunnel Interface");
 105 static VNET_DEFINE(LIST_HEAD(, gif_softc), gif_softc_list);
 106 #define V_gif_softc_list        VNET(gif_softc_list)
 107 static struct sx gif_ioctl_sx;
 108 SX_SYSINIT(gif_ioctl_sx, &gif_ioctl_sx, "gif_ioctl");
 109
 110 #define GIF_LIST_LOCK_INIT(x)           mtx_init(&V_gif_mtx, "gif_mtx", \
 111                                             NULL, MTX_DEF)
 112 #define GIF_LIST_LOCK_DESTROY(x)        mtx_destroy(&V_gif_mtx)
 113 #define GIF_LIST_LOCK(x)                mtx_lock(&V_gif_mtx)
 114 #define GIF_LIST_UNLOCK(x)              mtx_unlock(&V_gif_mtx)
 115
 116 void    (*ng_gif_input_p)(struct ifnet *ifp, struct mbuf **mp, int af);
 117 void    (*ng_gif_input_orphan_p)(struct ifnet *ifp, struct mbuf *m, int af);
 118 void    (*ng_gif_attach_p)(struct ifnet *ifp);
 119 void    (*ng_gif_detach_p)(struct ifnet *ifp);
 120
 121 static int      gif_check_nesting(struct ifnet *, struct mbuf *);
 122 static int      gif_set_tunnel(struct ifnet *, struct sockaddr *,
 123     struct sockaddr *);
 124 static void     gif_delete_tunnel(struct ifnet *);
 125 static int      gif_ioctl(struct ifnet *, u_long, caddr_t);
 126 static int      gif_transmit(struct ifnet *, struct mbuf *);
 127 static void     gif_qflush(struct ifnet *);
 128 static int      gif_clone_create(struct if_clone *, int, caddr_t);
 129 static void     gif_clone_destroy(struct ifnet *);
 130 static VNET_DEFINE(struct if_clone *, gif_cloner);
 131 #define V_gif_cloner    VNET(gif_cloner)
 132
 133 static int gifmodevent(module_t, int, void *);
 134
 135 SYSCTL_DECL(_net_link);
 136 static SYSCTL_NODE(_net_link, IFT_GIF, gif, CTLFLAG_RW, 0,
 137     "Generic Tunnel Interface");
 138 #ifndef MAX_GIF_NEST
 139 /*
 140  * This macro controls the default upper limitation on nesting of gif tunnels.
 141  * Since, setting a large value to this macro with a careless configuration
 142  * may introduce system crash, we don't allow any nestings by default.
 143  * If you need to configure nested gif tunnels, you can define this macro
 144  * in your kernel configuration file.  However, if you do so, please be
 145  * careful to configure the tunnels so that it won't make a loop.
 146  */
 147 #define MAX_GIF_NEST 1
 148 #endif
 149 static VNET_DEFINE(int, max_gif_nesting) = MAX_GIF_NEST;
 150 #define V_max_gif_nesting       VNET(max_gif_nesting)
 151 SYSCTL_INT(_net_link_gif, OID_AUTO, max_nesting, CTLFLAG_VNET | CTLFLAG_RW,
 152     &VNET_NAME(max_gif_nesting), 0, "Max nested tunnels");
 153
 154 /*
 155  * By default, we disallow creation of multiple tunnels between the same
 156  * pair of addresses.  Some applications require this functionality so
 157  * we allow control over this check here.
 158  */
 159 #ifdef XBONEHACK
 160 static VNET_DEFINE(int, parallel_tunnels) = 1;
 161 #else
 162 static VNET_DEFINE(int, parallel_tunnels) = 0;
 163 #endif
 164 #define V_parallel_tunnels      VNET(parallel_tunnels)
 165 SYSCTL_INT(_net_link_gif, OID_AUTO, parallel_tunnels,
 166     CTLFLAG_VNET | CTLFLAG_RW, &VNET_NAME(parallel_tunnels), 0,
 167     "Allow parallel tunnels?");
 168
 169 /* copy from src/sys/net/if_ethersubr.c */
 170 static const u_char etherbroadcastaddr[ETHER_ADDR_LEN] =
 171                         { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
 172 #ifndef ETHER_IS_BROADCAST
 173 #define ETHER_IS_BROADCAST(addr) \
 174         (bcmp(etherbroadcastaddr, (addr), ETHER_ADDR_LEN) == 0)
 175 #endif
 176
 177 static int
 178 gif_clone_create(struct if_clone *ifc, int unit, caddr_t params)
 179 {
 180         struct gif_softc *sc;
 181
 182         sc = malloc(sizeof(struct gif_softc), M_GIF, M_WAITOK | M_ZERO);
 183         sc->gif_fibnum = curthread->td_proc->p_fibnum;
 184         GIF2IFP(sc) = if_alloc(IFT_GIF);
 185         GIF_LOCK_INIT(sc);
 186         GIF2IFP(sc)->if_softc = sc;
 187         if_initname(GIF2IFP(sc), gifname, unit);
 188
 189         GIF2IFP(sc)->if_addrlen = 0;
 190         GIF2IFP(sc)->if_mtu    = GIF_MTU;
 191         GIF2IFP(sc)->if_flags  = IFF_POINTOPOINT | IFF_MULTICAST;
 192 #if 0
 193         /* turn off ingress filter */
 194         GIF2IFP(sc)->if_flags  |= IFF_LINK2;
 195 #endif
 196         GIF2IFP(sc)->if_ioctl  = gif_ioctl;
 197         GIF2IFP(sc)->if_transmit  = gif_transmit;
 198         GIF2IFP(sc)->if_qflush  = gif_qflush;
 199         GIF2IFP(sc)->if_output = gif_output;
 200         if_attach(GIF2IFP(sc));
 201         bpfattach(GIF2IFP(sc), DLT_NULL, sizeof(u_int32_t));
 202         if (ng_gif_attach_p != NULL)
 203                 (*ng_gif_attach_p)(GIF2IFP(sc));
 204
 205         GIF_LIST_LOCK();
 206         LIST_INSERT_HEAD(&V_gif_softc_list, sc, gif_list);
 207         GIF_LIST_UNLOCK();
 208         return (0);
 209 }
 210
 211 static void
 212 gif_clone_destroy(struct ifnet *ifp)
 213 {
 214         struct gif_softc *sc;
 215
 216         sx_xlock(&gif_ioctl_sx);
 217         sc = ifp->if_softc;
 218         gif_delete_tunnel(ifp);
 219         GIF_LIST_LOCK();
 220         LIST_REMOVE(sc, gif_list);
 221         GIF_LIST_UNLOCK();
 222         if (ng_gif_detach_p != NULL)
 223                 (*ng_gif_detach_p)(ifp);
 224         bpfdetach(ifp);
 225         if_detach(ifp);
 226         ifp->if_softc = NULL;
 227         sx_xunlock(&gif_ioctl_sx);
 228
 229         if_free(ifp);
 230         GIF_LOCK_DESTROY(sc);
 231         free(sc, M_GIF);
 232 }
 233
 234 static void
 235 vnet_gif_init(const void *unused __unused)
 236 {
 237
 238         LIST_INIT(&V_gif_softc_list);
 239         GIF_LIST_LOCK_INIT();
 240         V_gif_cloner = if_clone_simple(gifname, gif_clone_create,
 241             gif_clone_destroy, 0);
 242 }
 243 VNET_SYSINIT(vnet_gif_init, SI_SUB_PROTO_IFATTACHDOMAIN, SI_ORDER_ANY,
 244     vnet_gif_init, NULL);
 245
 246 static void
 247 vnet_gif_uninit(const void *unused __unused)
 248 {
 249
 250         if_clone_detach(V_gif_cloner);
 251         GIF_LIST_LOCK_DESTROY();
 252 }
 253 VNET_SYSUNINIT(vnet_gif_uninit, SI_SUB_PROTO_IFATTACHDOMAIN, SI_ORDER_ANY,
 254     vnet_gif_uninit, NULL);
 255
 256 static int
 257 gifmodevent(module_t mod, int type, void *data)
 258 {
 259
 260         switch (type) {
 261         case MOD_LOAD:
 262         case MOD_UNLOAD:
 263                 break;
 264         default:
 265                 return (EOPNOTSUPP);
 266         }
 267         return (0);
 268 }
 269
 270 static moduledata_t gif_mod = {
 271         "if_gif",
 272         gifmodevent,
 273         0
 274 };
 275
 276 DECLARE_MODULE(if_gif, gif_mod, SI_SUB_PSEUDO, SI_ORDER_ANY);
 277 MODULE_VERSION(if_gif, 1);
 278
 279 int
 280 gif_encapcheck(const struct mbuf *m, int off, int proto, void *arg)
 281 {
 282         GIF_RLOCK_TRACKER;
 283         const struct ip *ip;
 284         struct gif_softc *sc;
 285         int ret;
 286
 287         sc = (struct gif_softc *)arg;
 288         if (sc == NULL || (GIF2IFP(sc)->if_flags & IFF_UP) == 0)
 289                 return (0);
 290
 291         ret = 0;
 292         GIF_RLOCK(sc);
 293
 294         /* no physical address */
 295         if (sc->gif_family == 0)
 296                 goto done;
 297
 298         switch (proto) {
 299 #ifdef INET
 300         case IPPROTO_IPV4:
 301 #endif
 302 #ifdef INET6
 303         case IPPROTO_IPV6:
 304 #endif
 305         case IPPROTO_ETHERIP:
 306                 break;
 307         default:
 308                 goto done;
 309         }
 310
 311         /* Bail on short packets */
 312         M_ASSERTPKTHDR(m);
 313         if (m->m_pkthdr.len < sizeof(struct ip))
 314                 goto done;
 315
 316         ip = mtod(m, const struct ip *);
 317         switch (ip->ip_v) {
 318 #ifdef INET
 319         case 4:
 320                 if (sc->gif_family != AF_INET)
 321                         goto done;
 322                 ret = in_gif_encapcheck(m, off, proto, arg);
 323                 break;
 324 #endif
 325 #ifdef INET6
 326         case 6:
 327                 if (m->m_pkthdr.len < sizeof(struct ip6_hdr))
 328                         goto done;
 329                 if (sc->gif_family != AF_INET6)
 330                         goto done;
 331                 ret = in6_gif_encapcheck(m, off, proto, arg);
 332                 break;
 333 #endif
 334         }
 335 done:
 336         GIF_RUNLOCK(sc);
 337         return (ret);
 338 }
 339
 340 static int
 341 gif_transmit(struct ifnet *ifp, struct mbuf *m)
 342 {
 343         struct gif_softc *sc;
 344         struct etherip_header *eth;
 345 #ifdef INET
 346         struct ip *ip;
 347 #endif
 348 #ifdef INET6
 349         struct ip6_hdr *ip6;
 350         uint32_t t;
 351 #endif
 352         uint32_t af;
 353         uint8_t proto, ecn;
 354         int error;
 355
 356 #ifdef MAC
 357         error = mac_ifnet_check_transmit(ifp, m);
 358         if (error) {
 359                 m_freem(m);
 360                 goto err;
 361         }
 362 #endif
 363         error = ENETDOWN;
 364         sc = ifp->if_softc;
 365         if ((ifp->if_flags & IFF_MONITOR) != 0 ||
 366             (ifp->if_flags & IFF_UP) == 0 ||
 367             sc->gif_family == 0 ||
 368             (error = gif_check_nesting(ifp, m)) != 0) {
 369                 m_freem(m);
 370                 goto err;
 371         }
 372         /* Now pull back the af that we stashed in the csum_data. */
 373         if (ifp->if_bridge)
 374                 af = AF_LINK;
 375         else
 376                 af = m->m_pkthdr.csum_data;
 377         m->m_flags &= ~(M_BCAST|M_MCAST);
 378         M_SETFIB(m, sc->gif_fibnum);
 379         BPF_MTAP2(ifp, &af, sizeof(af), m);
 380         if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1);
 381         if_inc_counter(ifp, IFCOUNTER_OBYTES, m->m_pkthdr.len);
 382         /* inner AF-specific encapsulation */
 383         ecn = 0;
 384         switch (af) {
 385 #ifdef INET
 386         case AF_INET:
 387                 proto = IPPROTO_IPV4;
 388                 if (m->m_len < sizeof(struct ip))
 389                         m = m_pullup(m, sizeof(struct ip));
 390                 if (m == NULL) {
 391                         error = ENOBUFS;
 392                         goto err;
 393                 }
 394                 ip = mtod(m, struct ip *);
 395                 ip_ecn_ingress((ifp->if_flags & IFF_LINK1) ? ECN_ALLOWED:
 396                     ECN_NOCARE, &ecn, &ip->ip_tos);
 397                 break;
 398 #endif
 399 #ifdef INET6
 400         case AF_INET6:
 401                 proto = IPPROTO_IPV6;
 402                 if (m->m_len < sizeof(struct ip6_hdr))
 403                         m = m_pullup(m, sizeof(struct ip6_hdr));
 404                 if (m == NULL) {
 405                         error = ENOBUFS;
 406                         goto err;
 407                 }
 408                 t = 0;
 409                 ip6 = mtod(m, struct ip6_hdr *);
 410                 ip6_ecn_ingress((ifp->if_flags & IFF_LINK1) ? ECN_ALLOWED:
 411                     ECN_NOCARE, &t, &ip6->ip6_flow);
 412                 ecn = (ntohl(t) >> 20) & 0xff;
 413                 break;
 414 #endif
 415         case AF_LINK:
 416                 proto = IPPROTO_ETHERIP;
 417                 M_PREPEND(m, sizeof(struct etherip_header), M_NOWAIT);
 418                 if (m == NULL) {
 419                         error = ENOBUFS;
 420                         goto err;
 421                 }
 422                 eth = mtod(m, struct etherip_header *);
 423                 eth->eip_resvh = 0;
 424                 if ((sc->gif_options & GIF_SEND_REVETHIP) != 0) {
 425                         eth->eip_ver = 0;
 426                         eth->eip_resvl = ETHERIP_VERSION;
 427                 } else {
 428                         eth->eip_ver = ETHERIP_VERSION;
 429                         eth->eip_resvl = 0;
 430                 }
 431                 break;
 432         default:
 433                 error = EAFNOSUPPORT;
 434                 m_freem(m);
 435                 goto err;
 436         }
 437         /* XXX should we check if our outer source is legal? */
 438         /* dispatch to output logic based on outer AF */
 439         switch (sc->gif_family) {
 440 #ifdef INET
 441         case AF_INET:
 442                 error = in_gif_output(ifp, m, proto, ecn);
 443                 break;
 444 #endif
 445 #ifdef INET6
 446         case AF_INET6:
 447                 error = in6_gif_output(ifp, m, proto, ecn);
 448                 break;
 449 #endif
 450         default:
 451                 m_freem(m);
 452         }
 453 err:
 454         if (error)
 455                 if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
 456         return (error);
 457 }
 458
 459 static void
 460 gif_qflush(struct ifnet *ifp __unused)
 461 {
 462
 463 }
 464
 465 #define MTAG_GIF        1080679712
 466 static int
 467 gif_check_nesting(struct ifnet *ifp, struct mbuf *m)
 468 {
 469         struct m_tag *mtag;
 470         int count;
 471
 472         /*
 473          * gif may cause infinite recursion calls when misconfigured.
 474          * We'll prevent this by detecting loops.
 475          *
 476          * High nesting level may cause stack exhaustion.
 477          * We'll prevent this by introducing upper limit.
 478          */
 479         count = 1;
 480         mtag = NULL;
 481         while ((mtag = m_tag_locate(m, MTAG_GIF, 0, mtag)) != NULL) {
 482                 if (*(struct ifnet **)(mtag + 1) == ifp) {
 483                         log(LOG_NOTICE, "%s: loop detected\n", if_name(ifp));
 484                         return (EIO);
 485                 }
 486                 count++;
 487         }
 488         if (count > V_max_gif_nesting) {
 489                 log(LOG_NOTICE,
 490                     "%s: if_output recursively called too many times(%d)\n",
 491                     if_name(ifp), count);
 492                 return (EIO);
 493         }
 494         mtag = m_tag_alloc(MTAG_GIF, 0, sizeof(struct ifnet *), M_NOWAIT);
 495         if (mtag == NULL)
 496                 return (ENOMEM);
 497         *(struct ifnet **)(mtag + 1) = ifp;
 498         m_tag_prepend(m, mtag);
 499         return (0);
 500 }
 501
 502 int
 503 gif_output(struct ifnet *ifp, struct mbuf *m, const struct sockaddr *dst,
 504         struct route *ro)
 505 {
 506         uint32_t af;
 507
 508         if (dst->sa_family == AF_UNSPEC)
 509                 bcopy(dst->sa_data, &af, sizeof(af));
 510         else
 511                 af = dst->sa_family;
 512         /*
 513          * Now save the af in the inbound pkt csum data, this is a cheat since
 514          * we are using the inbound csum_data field to carry the af over to
 515          * the gif_transmit() routine, avoiding using yet another mtag.
 516          */
 517         m->m_pkthdr.csum_data = af;
 518         return (ifp->if_transmit(ifp, m));
 519 }
 520
 521 void
 522 gif_input(struct mbuf *m, struct ifnet *ifp, int proto, uint8_t ecn)
 523 {
 524         struct etherip_header *eip;
 525 #ifdef INET
 526         struct ip *ip;
 527 #endif
 528 #ifdef INET6
 529         struct ip6_hdr *ip6;
 530         uint32_t t;
 531 #endif
 532         struct gif_softc *sc;
 533         struct ether_header *eh;
 534         struct ifnet *oldifp;
 535         uint32_t gif_options;
 536         int isr, n, af;
 537
 538         if (ifp == NULL) {
 539                 /* just in case */
 540                 m_freem(m);
 541                 return;
 542         }
 543         sc = ifp->if_softc;
 544         gif_options = sc->gif_options;
 545         m->m_pkthdr.rcvif = ifp;
 546         m_clrprotoflags(m);
 547         switch (proto) {
 548 #ifdef INET
 549         case IPPROTO_IPV4:
 550                 af = AF_INET;
 551                 if (m->m_len < sizeof(struct ip))
 552                         m = m_pullup(m, sizeof(struct ip));
 553                 if (m == NULL)
 554                         goto drop;
 555                 ip = mtod(m, struct ip *);
 556                 if (ip_ecn_egress((ifp->if_flags & IFF_LINK1) ? ECN_ALLOWED:
 557                     ECN_NOCARE, &ecn, &ip->ip_tos) == 0) {
 558                         m_freem(m);
 559                         goto drop;
 560                 }
 561                 break;
 562 #endif
 563 #ifdef INET6
 564         case IPPROTO_IPV6:
 565                 af = AF_INET6;
 566                 if (m->m_len < sizeof(struct ip6_hdr))
 567                         m = m_pullup(m, sizeof(struct ip6_hdr));
 568                 if (m == NULL)
 569                         goto drop;
 570                 t = htonl((uint32_t)ecn << 20);
 571                 ip6 = mtod(m, struct ip6_hdr *);
 572                 if (ip6_ecn_egress((ifp->if_flags & IFF_LINK1) ? ECN_ALLOWED:
 573                     ECN_NOCARE, &t, &ip6->ip6_flow) == 0) {
 574                         m_freem(m);
 575                         goto drop;
 576                 }
 577                 break;
 578 #endif
 579         case IPPROTO_ETHERIP:
 580                 af = AF_LINK;
 581                 break;
 582         default:
 583                 m_freem(m);
 584                 goto drop;
 585         }
 586
 587 #ifdef MAC
 588         mac_ifnet_create_mbuf(ifp, m);
 589 #endif
 590
 591         if (bpf_peers_present(ifp->if_bpf)) {
 592                 uint32_t af1 = af;
 593                 bpf_mtap2(ifp->if_bpf, &af1, sizeof(af1), m);
 594         }
 595
 596         if ((ifp->if_flags & IFF_MONITOR) != 0) {
 597                 if_inc_counter(ifp, IFCOUNTER_IPACKETS, 1);
 598                 if_inc_counter(ifp, IFCOUNTER_IBYTES, m->m_pkthdr.len);
 599                 m_freem(m);
 600                 return;
 601         }
 602
 603         if (ng_gif_input_p != NULL) {
 604                 (*ng_gif_input_p)(ifp, &m, af);
 605                 if (m == NULL)
 606                         goto drop;
 607         }
 608
 609         /*
 610          * Put the packet to the network layer input queue according to the
 611          * specified address family.
 612          * Note: older versions of gif_input directly called network layer
 613          * input functions, e.g. ip6_input, here.  We changed the policy to
 614          * prevent too many recursive calls of such input functions, which
 615          * might cause kernel panic.  But the change may introduce another
 616          * problem; if the input queue is full, packets are discarded.
 617          * The kernel stack overflow really happened, and we believed
 618          * queue-full rarely occurs, so we changed the policy.
 619          */
 620         switch (af) {
 621 #ifdef INET
 622         case AF_INET:
 623                 isr = NETISR_IP;
 624                 break;
 625 #endif
 626 #ifdef INET6
 627         case AF_INET6:
 628                 isr = NETISR_IPV6;
 629                 break;
 630 #endif
 631         case AF_LINK:
 632                 n = sizeof(struct etherip_header) + sizeof(struct ether_header);
 633                 if (n > m->m_len)
 634                         m = m_pullup(m, n);
 635                 if (m == NULL)
 636                         goto drop;
 637                 eip = mtod(m, struct etherip_header *);
 638                 /*
 639                  * GIF_ACCEPT_REVETHIP (enabled by default) intentionally
 640                  * accepts an EtherIP packet with revered version field in
 641                  * the header.  This is a knob for backward compatibility
 642                  * with FreeBSD 7.2R or prior.
 643                  */
 644                 if (eip->eip_ver != ETHERIP_VERSION) {
 645                         if ((gif_options & GIF_ACCEPT_REVETHIP) == 0 ||
 646                             eip->eip_resvl != ETHERIP_VERSION) {
 647                                 /* discard unknown versions */
 648                                 m_freem(m);
 649                                 goto drop;
 650                         }
 651                 }
 652                 m_adj(m, sizeof(struct etherip_header));
 653
 654                 m->m_flags &= ~(M_BCAST|M_MCAST);
 655                 m->m_pkthdr.rcvif = ifp;
 656
 657                 if (ifp->if_bridge) {
 658                         oldifp = ifp;
 659                         eh = mtod(m, struct ether_header *);
 660                         if (ETHER_IS_MULTICAST(eh->ether_dhost)) {
 661                                 if (ETHER_IS_BROADCAST(eh->ether_dhost))
 662                                         m->m_flags |= M_BCAST;
 663                                 else
 664                                         m->m_flags |= M_MCAST;
 665                                 if_inc_counter(ifp, IFCOUNTER_IMCASTS, 1);
 666                         }
 667                         BRIDGE_INPUT(ifp, m);
 668
 669                         if (m != NULL && ifp != oldifp) {
 670                                 /*
 671                                  * The bridge gave us back itself or one of the
 672                                  * members for which the frame is addressed.
 673                                  */
 674                                 ether_demux(ifp, m);
 675                                 return;
 676                         }
 677                 }
 678                 if (m != NULL)
 679                         m_freem(m);
 680                 return;
 681
 682         default:
 683                 if (ng_gif_input_orphan_p != NULL)
 684                         (*ng_gif_input_orphan_p)(ifp, m, af);
 685                 else
 686                         m_freem(m);
 687                 return;
 688         }
 689
 690         if_inc_counter(ifp, IFCOUNTER_IPACKETS, 1);
 691         if_inc_counter(ifp, IFCOUNTER_IBYTES, m->m_pkthdr.len);
 692         M_SETFIB(m, ifp->if_fib);
 693         netisr_dispatch(isr, m);
 694         return;
 695 drop:
 696         if_inc_counter(ifp, IFCOUNTER_IERRORS, 1);
 697 }
 698
 699 /* XXX how should we handle IPv6 scope on SIOC[GS]IFPHYADDR? */
 700 int
 701 gif_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
 702 {
 703         GIF_RLOCK_TRACKER;
 704         struct ifreq *ifr = (struct ifreq*)data;
 705         struct sockaddr *dst, *src;
 706         struct gif_softc *sc;
 707 #ifdef INET
 708         struct sockaddr_in *sin = NULL;
 709 #endif
 710 #ifdef INET6
 711         struct sockaddr_in6 *sin6 = NULL;
 712 #endif
 713         u_int options;
 714         int error;
 715
 716         switch (cmd) {
 717         case SIOCSIFADDR:
 718                 ifp->if_flags |= IFF_UP;
 719         case SIOCADDMULTI:
 720         case SIOCDELMULTI:
 721         case SIOCGIFMTU:
 722         case SIOCSIFFLAGS:
 723                 return (0);
 724         case SIOCSIFMTU:
 725                 if (ifr->ifr_mtu < GIF_MTU_MIN ||
 726                     ifr->ifr_mtu > GIF_MTU_MAX)
 727                         return (EINVAL);
 728                 else
 729                         ifp->if_mtu = ifr->ifr_mtu;
 730                 return (0);
 731         }
 732         sx_xlock(&gif_ioctl_sx);
 733         sc = ifp->if_softc;
 734         if (sc == NULL) {
 735                 error = ENXIO;
 736                 goto bad;
 737         }
 738         error = 0;
 739         switch (cmd) {
 740         case SIOCSIFPHYADDR:
 741 #ifdef INET6
 742         case SIOCSIFPHYADDR_IN6:
 743 #endif
 744                 error = EINVAL;
 745                 switch (cmd) {
 746 #ifdef INET
 747                 case SIOCSIFPHYADDR:
 748                         src = (struct sockaddr *)
 749                                 &(((struct in_aliasreq *)data)->ifra_addr);
 750                         dst = (struct sockaddr *)
 751                                 &(((struct in_aliasreq *)data)->ifra_dstaddr);
 752                         break;
 753 #endif
 754 #ifdef INET6
 755                 case SIOCSIFPHYADDR_IN6:
 756                         src = (struct sockaddr *)
 757                                 &(((struct in6_aliasreq *)data)->ifra_addr);
 758                         dst = (struct sockaddr *)
 759                                 &(((struct in6_aliasreq *)data)->ifra_dstaddr);
 760                         break;
 761 #endif
 762                 default:
 763                         goto bad;
 764                 }
 765                 /* sa_family must be equal */
 766                 if (src->sa_family != dst->sa_family ||
 767                     src->sa_len != dst->sa_len)
 768                         goto bad;
 769
 770                 /* validate sa_len */
 771                 switch (src->sa_family) {
 772 #ifdef INET
 773                 case AF_INET:
 774                         if (src->sa_len != sizeof(struct sockaddr_in))
 775                                 goto bad;
 776                         break;
 777 #endif
 778 #ifdef INET6
 779                 case AF_INET6:
 780                         if (src->sa_len != sizeof(struct sockaddr_in6))
 781                                 goto bad;
 782                         break;
 783 #endif
 784                 default:
 785                         error = EAFNOSUPPORT;
 786                         goto bad;
 787                 }
 788                 /* check sa_family looks sane for the cmd */
 789                 error = EAFNOSUPPORT;
 790                 switch (cmd) {
 791 #ifdef INET
 792                 case SIOCSIFPHYADDR:
 793                         if (src->sa_family == AF_INET)
 794                                 break;
 795                         goto bad;
 796 #endif
 797 #ifdef INET6
 798                 case SIOCSIFPHYADDR_IN6:
 799                         if (src->sa_family == AF_INET6)
 800                                 break;
 801                         goto bad;
 802 #endif
 803                 }
 804                 error = EADDRNOTAVAIL;
 805                 switch (src->sa_family) {
 806 #ifdef INET
 807                 case AF_INET:
 808                         if (satosin(src)->sin_addr.s_addr == INADDR_ANY ||
 809                             satosin(dst)->sin_addr.s_addr == INADDR_ANY)
 810                                 goto bad;
 811                         break;
 812 #endif
 813 #ifdef INET6
 814                 case AF_INET6:
 815                         if (IN6_IS_ADDR_UNSPECIFIED(&satosin6(src)->sin6_addr)
 816                             ||
 817                             IN6_IS_ADDR_UNSPECIFIED(&satosin6(dst)->sin6_addr))
 818                                 goto bad;
 819                         /*
 820                          * Check validity of the scope zone ID of the
 821                          * addresses, and convert it into the kernel
 822                          * internal form if necessary.
 823                          */
 824                         error = sa6_embedscope(satosin6(src), 0);
 825                         if (error != 0)
 826                                 goto bad;
 827                         error = sa6_embedscope(satosin6(dst), 0);
 828                         if (error != 0)
 829                                 goto bad;
 830 #endif
 831                 };
 832                 error = gif_set_tunnel(ifp, src, dst);
 833                 break;
 834         case SIOCDIFPHYADDR:
 835                 gif_delete_tunnel(ifp);
 836                 break;
 837         case SIOCGIFPSRCADDR:
 838         case SIOCGIFPDSTADDR:
 839 #ifdef INET6
 840         case SIOCGIFPSRCADDR_IN6:
 841         case SIOCGIFPDSTADDR_IN6:
 842 #endif
 843                 if (sc->gif_family == 0) {
 844                         error = EADDRNOTAVAIL;
 845                         break;
 846                 }
 847                 GIF_RLOCK(sc);
 848                 switch (cmd) {
 849 #ifdef INET
 850                 case SIOCGIFPSRCADDR:
 851                 case SIOCGIFPDSTADDR:
 852                         if (sc->gif_family != AF_INET) {
 853                                 error = EADDRNOTAVAIL;
 854                                 break;
 855                         }
 856                         sin = (struct sockaddr_in *)&ifr->ifr_addr;
 857                         memset(sin, 0, sizeof(*sin));
 858                         sin->sin_family = AF_INET;
 859                         sin->sin_len = sizeof(*sin);
 860                         break;
 861 #endif
 862 #ifdef INET6
 863                 case SIOCGIFPSRCADDR_IN6:
 864                 case SIOCGIFPDSTADDR_IN6:
 865                         if (sc->gif_family != AF_INET6) {
 866                                 error = EADDRNOTAVAIL;
 867                                 break;
 868                         }
 869                         sin6 = (struct sockaddr_in6 *)
 870                                 &(((struct in6_ifreq *)data)->ifr_addr);
 871                         memset(sin6, 0, sizeof(*sin6));
 872                         sin6->sin6_family = AF_INET6;
 873                         sin6->sin6_len = sizeof(*sin6);
 874                         break;
 875 #endif
 876                 default:
 877                         error = EAFNOSUPPORT;
 878                 }
 879                 if (error == 0) {
 880                         switch (cmd) {
 881 #ifdef INET
 882                         case SIOCGIFPSRCADDR:
 883                                 sin->sin_addr = sc->gif_iphdr->ip_src;
 884                                 break;
 885                         case SIOCGIFPDSTADDR:
 886                                 sin->sin_addr = sc->gif_iphdr->ip_dst;
 887                                 break;
 888 #endif
 889 #ifdef INET6
 890                         case SIOCGIFPSRCADDR_IN6:
 891                                 sin6->sin6_addr = sc->gif_ip6hdr->ip6_src;
 892                                 break;
 893                         case SIOCGIFPDSTADDR_IN6:
 894                                 sin6->sin6_addr = sc->gif_ip6hdr->ip6_dst;
 895                                 break;
 896 #endif
 897                         }
 898                 }
 899                 GIF_RUNLOCK(sc);
 900                 if (error != 0)
 901                         break;
 902                 switch (cmd) {
 903 #ifdef INET
 904                 case SIOCGIFPSRCADDR:
 905                 case SIOCGIFPDSTADDR:
 906                         error = prison_if(curthread->td_ucred,
 907                             (struct sockaddr *)sin);
 908                         if (error != 0)
 909                                 memset(sin, 0, sizeof(*sin));
 910                         break;
 911 #endif
 912 #ifdef INET6
 913                 case SIOCGIFPSRCADDR_IN6:
 914                 case SIOCGIFPDSTADDR_IN6:
 915                         error = prison_if(curthread->td_ucred,
 916                             (struct sockaddr *)sin6);
 917                         if (error == 0)
 918                                 error = sa6_recoverscope(sin6);
 919                         if (error != 0)
 920                                 memset(sin6, 0, sizeof(*sin6));
 921 #endif
 922                 }
 923                 break;
 924         case SIOCGTUNFIB:
 925                 ifr->ifr_fib = sc->gif_fibnum;
 926                 break;
 927         case SIOCSTUNFIB:
 928                 if ((error = priv_check(curthread, PRIV_NET_GIF)) != 0)
 929                         break;
 930                 if (ifr->ifr_fib >= rt_numfibs)
 931                         error = EINVAL;
 932                 else
 933                         sc->gif_fibnum = ifr->ifr_fib;
 934                 break;
 935         case GIFGOPTS:
 936                 options = sc->gif_options;
 937                 error = copyout(&options, ifr->ifr_data, sizeof(options));
 938                 break;
 939         case GIFSOPTS:
 940                 if ((error = priv_check(curthread, PRIV_NET_GIF)) != 0)
 941                         break;
 942                 error = copyin(ifr->ifr_data, &options, sizeof(options));
 943                 if (error)
 944                         break;
 945                 if (options & ~GIF_OPTMASK)
 946                         error = EINVAL;
 947                 else
 948                         sc->gif_options = options;
 949                 break;
 950         default:
 951                 error = EINVAL;
 952                 break;
 953         }
 954 bad:
 955         sx_xunlock(&gif_ioctl_sx);
 956         return (error);
 957 }
 958
 959 static void
 960 gif_detach(struct gif_softc *sc)
 961 {
 962
 963         sx_assert(&gif_ioctl_sx, SA_XLOCKED);
 964         if (sc->gif_ecookie != NULL)
 965                 encap_detach(sc->gif_ecookie);
 966         sc->gif_ecookie = NULL;
 967 }
 968
 969 static int
 970 gif_attach(struct gif_softc *sc, int af)
 971 {
 972
 973         sx_assert(&gif_ioctl_sx, SA_XLOCKED);
 974         switch (af) {
 975 #ifdef INET
 976         case AF_INET:
 977                 return (in_gif_attach(sc));
 978 #endif
 979 #ifdef INET6
 980         case AF_INET6:
 981                 return (in6_gif_attach(sc));
 982 #endif
 983         }
 984         return (EAFNOSUPPORT);
 985 }
 986
 987 static int
 988 gif_set_tunnel(struct ifnet *ifp, struct sockaddr *src, struct sockaddr *dst)
 989 {
 990         struct gif_softc *sc = ifp->if_softc;
 991         struct gif_softc *tsc;
 992 #ifdef INET
 993         struct ip *ip;
 994 #endif
 995 #ifdef INET6
 996         struct ip6_hdr *ip6;
 997 #endif
 998         void *hdr;
 999         int error = 0;
1000
1001         if (sc == NULL)
1002                 return (ENXIO);
1003         /* Disallow parallel tunnels unless instructed otherwise. */
1004         if (V_parallel_tunnels == 0) {
1005                 GIF_LIST_LOCK();
1006                 LIST_FOREACH(tsc, &V_gif_softc_list, gif_list) {
1007                         if (tsc == sc || tsc->gif_family != src->sa_family)
1008                                 continue;
1009 #ifdef INET
1010                         if (tsc->gif_family == AF_INET &&
1011                             tsc->gif_iphdr->ip_src.s_addr ==
1012                             satosin(src)->sin_addr.s_addr &&
1013                             tsc->gif_iphdr->ip_dst.s_addr ==
1014                             satosin(dst)->sin_addr.s_addr) {
1015                                 error = EADDRNOTAVAIL;
1016                                 GIF_LIST_UNLOCK();
1017                                 goto bad;
1018                         }
1019 #endif
1020 #ifdef INET6
1021                         if (tsc->gif_family == AF_INET6 &&
1022                             IN6_ARE_ADDR_EQUAL(&tsc->gif_ip6hdr->ip6_src,
1023                             &satosin6(src)->sin6_addr) &&
1024                             IN6_ARE_ADDR_EQUAL(&tsc->gif_ip6hdr->ip6_dst,
1025                             &satosin6(dst)->sin6_addr)) {
1026                                 error = EADDRNOTAVAIL;
1027                                 GIF_LIST_UNLOCK();
1028                                 goto bad;
1029                         }
1030 #endif
1031                 }
1032                 GIF_LIST_UNLOCK();
1033         }
1034         switch (src->sa_family) {
1035 #ifdef INET
1036         case AF_INET:
1037                 hdr = ip = malloc(sizeof(struct ip), M_GIF,
1038                     M_WAITOK | M_ZERO);
1039                 ip->ip_src.s_addr = satosin(src)->sin_addr.s_addr;
1040                 ip->ip_dst.s_addr = satosin(dst)->sin_addr.s_addr;
1041                 break;
1042 #endif
1043 #ifdef INET6
1044         case AF_INET6:
1045                 hdr = ip6 = malloc(sizeof(struct ip6_hdr), M_GIF,
1046                     M_WAITOK | M_ZERO);
1047                 ip6->ip6_src = satosin6(src)->sin6_addr;
1048                 ip6->ip6_dst = satosin6(dst)->sin6_addr;
1049                 ip6->ip6_vfc = IPV6_VERSION;
1050                 break;
1051 #endif
1052         default:
1053                 return (EAFNOSUPPORT);
1054         };
1055
1056         if (sc->gif_family != src->sa_family)
1057                 gif_detach(sc);
1058         if (sc->gif_family == 0 ||
1059             sc->gif_family != src->sa_family)
1060                 error = gif_attach(sc, src->sa_family);
1061
1062         GIF_WLOCK(sc);
1063         if (sc->gif_family != 0)
1064                 free(sc->gif_hdr, M_GIF);
1065         sc->gif_family = src->sa_family;
1066         sc->gif_hdr = hdr;
1067         GIF_WUNLOCK(sc);
1068 #if defined(INET) || defined(INET6)
1069 bad:
1070 #endif
1071         if (error == 0 && sc->gif_family != 0)
1072                 ifp->if_drv_flags |= IFF_DRV_RUNNING;
1073         else
1074                 ifp->if_drv_flags &= ~IFF_DRV_RUNNING;
1075         return (error);
1076 }
1077
1078 static void
1079 gif_delete_tunnel(struct ifnet *ifp)
1080 {
1081         struct gif_softc *sc = ifp->if_softc;
1082         int family;
1083
1084         if (sc == NULL)
1085                 return;
1086
1087         GIF_WLOCK(sc);
1088         family = sc->gif_family;
1089         sc->gif_family = 0;
1090         GIF_WUNLOCK(sc);
1091         if (family != 0) {
1092                 gif_detach(sc);
1093                 free(sc->gif_hdr, M_GIF);
1094         }
1095         ifp->if_drv_flags &= ~IFF_DRV_RUNNING;
1096 }