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 97static const char gifname[] = "gif"; 98 99/* 100 * gif_mtx protects a per-vnet gif_softc_list. 101 */ 102static VNET_DEFINE(struct mtx, gif_mtx); 103#define V_gif_mtx VNET(gif_mtx) 104static MALLOC_DEFINE(M_GIF, "gif", "Generic Tunnel Interface"); 105static VNET_DEFINE(LIST_HEAD(, gif_softc), gif_softc_list); 106#define V_gif_softc_list VNET(gif_softc_list) 107static struct sx gif_ioctl_sx; 108SX_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 116void (*ng_gif_input_p)(struct ifnet *ifp, struct mbuf **mp, int af); 117void (*ng_gif_input_orphan_p)(struct ifnet *ifp, struct mbuf *m, int af); 118void (*ng_gif_attach_p)(struct ifnet *ifp); 119void (*ng_gif_detach_p)(struct ifnet *ifp); 120 121static int gif_check_nesting(struct ifnet *, struct mbuf *); 122static int gif_set_tunnel(struct ifnet *, struct sockaddr *, 123 struct sockaddr *); 124static void gif_delete_tunnel(struct ifnet *); 125static int gif_ioctl(struct ifnet *, u_long, caddr_t); 126static int gif_transmit(struct ifnet *, struct mbuf *); 127static void gif_qflush(struct ifnet *); 128static int gif_clone_create(struct if_clone *, int, caddr_t); 129static void gif_clone_destroy(struct ifnet *); 130static VNET_DEFINE(struct if_clone *, gif_cloner); 131#define V_gif_cloner VNET(gif_cloner) 132 133static int gifmodevent(module_t, int, void *); 134 135SYSCTL_DECL(_net_link); 136static 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 149static VNET_DEFINE(int, max_gif_nesting) = MAX_GIF_NEST; 150#define V_max_gif_nesting VNET(max_gif_nesting) 151SYSCTL_VNET_INT(_net_link_gif, OID_AUTO, max_nesting, 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 160static VNET_DEFINE(int, parallel_tunnels) = 1; 161#else 162static VNET_DEFINE(int, parallel_tunnels) = 0; 163#endif 164#define V_parallel_tunnels VNET(parallel_tunnels) 165SYSCTL_VNET_INT(_net_link_gif, OID_AUTO, parallel_tunnels, CTLFLAG_RW, 166 &VNET_NAME(parallel_tunnels), 0, "Allow parallel tunnels?"); 167 168/* copy from src/sys/net/if_ethersubr.c */ 169static const u_char etherbroadcastaddr[ETHER_ADDR_LEN] = 170 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; 171#ifndef ETHER_IS_BROADCAST 172#define ETHER_IS_BROADCAST(addr) \ 173 (bcmp(etherbroadcastaddr, (addr), ETHER_ADDR_LEN) == 0) 174#endif 175 176static int 177gif_clone_create(struct if_clone *ifc, int unit, caddr_t params) 178{ 179 struct gif_softc *sc; 180 181 sc = malloc(sizeof(struct gif_softc), M_GIF, M_WAITOK | M_ZERO); 182 sc->gif_fibnum = curthread->td_proc->p_fibnum; 183 GIF2IFP(sc) = if_alloc(IFT_GIF); 184 GIF_LOCK_INIT(sc); 185 GIF2IFP(sc)->if_softc = sc; 186 if_initname(GIF2IFP(sc), gifname, unit); 187 188 GIF2IFP(sc)->if_addrlen = 0; 189 GIF2IFP(sc)->if_mtu = GIF_MTU; 190 GIF2IFP(sc)->if_flags = IFF_POINTOPOINT | IFF_MULTICAST; 191#if 0 192 /* turn off ingress filter */ 193 GIF2IFP(sc)->if_flags |= IFF_LINK2; 194#endif 195 GIF2IFP(sc)->if_ioctl = gif_ioctl; 196 GIF2IFP(sc)->if_transmit = gif_transmit; 197 GIF2IFP(sc)->if_qflush = gif_qflush; 198 GIF2IFP(sc)->if_output = gif_output; 199 GIF2IFP(sc)->if_capabilities |= IFCAP_LINKSTATE; 200 GIF2IFP(sc)->if_capenable |= IFCAP_LINKSTATE; 201 if_attach(GIF2IFP(sc)); 202 bpfattach(GIF2IFP(sc), DLT_NULL, sizeof(u_int32_t)); 203 if (ng_gif_attach_p != NULL) 204 (*ng_gif_attach_p)(GIF2IFP(sc)); 205 206 GIF_LIST_LOCK(); 207 LIST_INSERT_HEAD(&V_gif_softc_list, sc, gif_list); 208 GIF_LIST_UNLOCK(); 209 return (0); 210} 211 212static void 213gif_clone_destroy(struct ifnet *ifp) 214{ 215 struct gif_softc *sc; 216 217 sx_xlock(&gif_ioctl_sx); 218 sc = ifp->if_softc; 219 gif_delete_tunnel(ifp); 220 GIF_LIST_LOCK(); 221 LIST_REMOVE(sc, gif_list); 222 GIF_LIST_UNLOCK(); 223 if (ng_gif_detach_p != NULL) 224 (*ng_gif_detach_p)(ifp); 225 bpfdetach(ifp); 226 if_detach(ifp); 227 ifp->if_softc = NULL; 228 sx_xunlock(&gif_ioctl_sx); 229 230 if_free(ifp); 231 GIF_LOCK_DESTROY(sc); 232 free(sc, M_GIF); 233} 234 235static void 236vnet_gif_init(const void *unused __unused) 237{ 238 239 LIST_INIT(&V_gif_softc_list); 240 GIF_LIST_LOCK_INIT(); 241 V_gif_cloner = if_clone_simple(gifname, gif_clone_create, 242 gif_clone_destroy, 0); 243} 244VNET_SYSINIT(vnet_gif_init, SI_SUB_PROTO_IFATTACHDOMAIN, SI_ORDER_ANY, 245 vnet_gif_init, NULL); 246 247static void 248vnet_gif_uninit(const void *unused __unused) 249{ 250 251 if_clone_detach(V_gif_cloner); 252 GIF_LIST_LOCK_DESTROY(); 253} 254VNET_SYSUNINIT(vnet_gif_uninit, SI_SUB_PROTO_IFATTACHDOMAIN, SI_ORDER_ANY, 255 vnet_gif_uninit, NULL); 256 257static int 258gifmodevent(module_t mod, int type, void *data) 259{ 260 261 switch (type) { 262 case MOD_LOAD: 263 case MOD_UNLOAD: 264 break; 265 default: 266 return (EOPNOTSUPP); 267 } 268 return (0); 269} 270 271static moduledata_t gif_mod = { 272 "if_gif", 273 gifmodevent, 274 0 275}; 276 277DECLARE_MODULE(if_gif, gif_mod, SI_SUB_PSEUDO, SI_ORDER_ANY); 278MODULE_VERSION(if_gif, 1); 279 280int 281gif_encapcheck(const struct mbuf *m, int off, int proto, void *arg) 282{ 283 GIF_RLOCK_TRACKER; 284 struct gif_softc *sc; 285 int ret; 286 uint8_t ver; 287 288 sc = (struct gif_softc *)arg; 289 if (sc == NULL || (GIF2IFP(sc)->if_flags & IFF_UP) == 0) 290 return (0); 291 292 ret = 0; 293 GIF_RLOCK(sc); 294 295 /* no physical address */ 296 if (sc->gif_family == 0) 297 goto done; 298 299 switch (proto) { 300#ifdef INET 301 case IPPROTO_IPV4: 302#endif 303#ifdef INET6 304 case IPPROTO_IPV6: 305#endif 306 case IPPROTO_ETHERIP: 307 break; 308 default: 309 goto done; 310 } 311 312 /* Bail on short packets */ 313 if (m->m_pkthdr.len < sizeof(struct ip)) 314 goto done; 315 316 m_copydata(m, 0, 1, &ver); 317 switch (ver >> 4) { 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 } 335done: 336 GIF_RUNLOCK(sc); 337 return (ret); 338} 339 340static int 341gif_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 eth->eip_ver = ETHERIP_VERSION; 425 eth->eip_resvl = 0; 426 break; 427 default: 428 error = EAFNOSUPPORT; 429 m_freem(m); 430 goto err; 431 } 432 /* XXX should we check if our outer source is legal? */ 433 /* dispatch to output logic based on outer AF */ 434 switch (sc->gif_family) { 435#ifdef INET 436 case AF_INET: 437 error = in_gif_output(ifp, m, proto, ecn); 438 break; 439#endif 440#ifdef INET6 441 case AF_INET6: 442 error = in6_gif_output(ifp, m, proto, ecn); 443 break; 444#endif 445 default: 446 m_freem(m); 447 } 448err: 449 if (error) 450 if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); 451 return (error); 452} 453 454static void 455gif_qflush(struct ifnet *ifp __unused) 456{ 457 458} 459 460#define MTAG_GIF 1080679712 461static int 462gif_check_nesting(struct ifnet *ifp, struct mbuf *m) 463{ 464 struct m_tag *mtag; 465 int count; 466 467 /* 468 * gif may cause infinite recursion calls when misconfigured. 469 * We'll prevent this by detecting loops. 470 * 471 * High nesting level may cause stack exhaustion. 472 * We'll prevent this by introducing upper limit. 473 */ 474 count = 1; 475 mtag = NULL; 476 while ((mtag = m_tag_locate(m, MTAG_GIF, 0, mtag)) != NULL) { 477 if (*(struct ifnet **)(mtag + 1) == ifp) { 478 log(LOG_NOTICE, "%s: loop detected\n", ifp->if_xname); 479 return (EIO); 480 } 481 count++; 482 } 483 if (count > V_max_gif_nesting) { 484 log(LOG_NOTICE, 485 "%s: if_output recursively called too many times(%d)\n", 486 if_name(ifp), count); 487 return (EIO); 488 } 489 mtag = m_tag_alloc(MTAG_GIF, 0, sizeof(struct ifnet *), M_NOWAIT); 490 if (mtag == NULL) 491 return (ENOMEM); 492 *(struct ifnet **)(mtag + 1) = ifp; 493 m_tag_prepend(m, mtag); 494 return (0); 495} 496 497int 498gif_output(struct ifnet *ifp, struct mbuf *m, const struct sockaddr *dst, 499 struct route *ro) 500{ 501 uint32_t af; 502 503 if (dst->sa_family == AF_UNSPEC) 504 bcopy(dst->sa_data, &af, sizeof(af)); 505 else 506 af = dst->sa_family; 507 /* 508 * Now save the af in the inbound pkt csum data, this is a cheat since 509 * we are using the inbound csum_data field to carry the af over to 510 * the gif_transmit() routine, avoiding using yet another mtag. 511 */ 512 m->m_pkthdr.csum_data = af; 513 return (ifp->if_transmit(ifp, m)); 514} 515 516void 517gif_input(struct mbuf *m, struct ifnet *ifp, int proto, uint8_t ecn) 518{ 519 struct etherip_header *eip; 520#ifdef INET 521 struct ip *ip; 522#endif 523#ifdef INET6 524 struct ip6_hdr *ip6; 525 uint32_t t; 526#endif 527 struct gif_softc *sc; 528 struct ether_header *eh; 529 struct ifnet *oldifp; 530 int isr, n, af; 531 532 if (ifp == NULL) { 533 /* just in case */ 534 m_freem(m); 535 return; 536 } 537 sc = ifp->if_softc; 538 m->m_pkthdr.rcvif = ifp; 539 m_clrprotoflags(m); 540 switch (proto) { 541#ifdef INET 542 case IPPROTO_IPV4: 543 af = AF_INET; 544 if (m->m_len < sizeof(struct ip)) 545 m = m_pullup(m, sizeof(struct ip)); 546 if (m == NULL) 547 goto drop; 548 ip = mtod(m, struct ip *); 549 if (ip_ecn_egress((ifp->if_flags & IFF_LINK1) ? ECN_ALLOWED: 550 ECN_NOCARE, &ecn, &ip->ip_tos) == 0) { 551 m_freem(m); 552 goto drop; 553 } 554 break; 555#endif 556#ifdef INET6 557 case IPPROTO_IPV6: 558 af = AF_INET6; 559 if (m->m_len < sizeof(struct ip6_hdr)) 560 m = m_pullup(m, sizeof(struct ip6_hdr)); 561 if (m == NULL) 562 goto drop; 563 t = htonl((uint32_t)ecn << 20); 564 ip6 = mtod(m, struct ip6_hdr *); 565 if (ip6_ecn_egress((ifp->if_flags & IFF_LINK1) ? ECN_ALLOWED: 566 ECN_NOCARE, &t, &ip6->ip6_flow) == 0) { 567 m_freem(m); 568 goto drop; 569 } 570 break; 571#endif 572 case IPPROTO_ETHERIP: 573 af = AF_LINK; 574 break; 575 default: 576 m_freem(m); 577 goto drop; 578 } 579 580#ifdef MAC 581 mac_ifnet_create_mbuf(ifp, m); 582#endif 583 584 if (bpf_peers_present(ifp->if_bpf)) { 585 uint32_t af1 = af; 586 bpf_mtap2(ifp->if_bpf, &af1, sizeof(af1), m); 587 } 588 589 if ((ifp->if_flags & IFF_MONITOR) != 0) { 590 if_inc_counter(ifp, IFCOUNTER_IPACKETS, 1); 591 if_inc_counter(ifp, IFCOUNTER_IBYTES, m->m_pkthdr.len); 592 m_freem(m); 593 return; 594 } 595 596 if (ng_gif_input_p != NULL) { 597 (*ng_gif_input_p)(ifp, &m, af); 598 if (m == NULL) 599 goto drop; 600 } 601 602 /* 603 * Put the packet to the network layer input queue according to the 604 * specified address family. 605 * Note: older versions of gif_input directly called network layer 606 * input functions, e.g. ip6_input, here. We changed the policy to 607 * prevent too many recursive calls of such input functions, which 608 * might cause kernel panic. But the change may introduce another 609 * problem; if the input queue is full, packets are discarded. 610 * The kernel stack overflow really happened, and we believed 611 * queue-full rarely occurs, so we changed the policy. 612 */ 613 switch (af) { 614#ifdef INET 615 case AF_INET: 616 isr = NETISR_IP; 617 break; 618#endif 619#ifdef INET6 620 case AF_INET6: 621 isr = NETISR_IPV6; 622 break; 623#endif 624 case AF_LINK: 625 n = sizeof(struct etherip_header) + sizeof(struct ether_header); 626 if (n > m->m_len) 627 m = m_pullup(m, n); 628 if (m == NULL) 629 goto drop; 630 eip = mtod(m, struct etherip_header *); 631 if (eip->eip_ver != ETHERIP_VERSION) { 632 /* discard unknown versions */ 633 m_freem(m); 634 goto drop; 635 } 636 m_adj(m, sizeof(struct etherip_header)); 637 638 m->m_flags &= ~(M_BCAST|M_MCAST); 639 m->m_pkthdr.rcvif = ifp; 640 641 if (ifp->if_bridge) { 642 oldifp = ifp; 643 eh = mtod(m, struct ether_header *); 644 if (ETHER_IS_MULTICAST(eh->ether_dhost)) { 645 if (ETHER_IS_BROADCAST(eh->ether_dhost)) 646 m->m_flags |= M_BCAST; 647 else 648 m->m_flags |= M_MCAST; 649 if_inc_counter(ifp, IFCOUNTER_IMCASTS, 1); 650 } 651 BRIDGE_INPUT(ifp, m); 652 653 if (m != NULL && ifp != oldifp) { 654 /* 655 * The bridge gave us back itself or one of the 656 * members for which the frame is addressed. 657 */ 658 ether_demux(ifp, m); 659 return; 660 } 661 } 662 if (m != NULL) 663 m_freem(m); 664 return; 665 666 default: 667 if (ng_gif_input_orphan_p != NULL) 668 (*ng_gif_input_orphan_p)(ifp, m, af); 669 else 670 m_freem(m); 671 return; 672 } 673 674 if_inc_counter(ifp, IFCOUNTER_IPACKETS, 1); 675 if_inc_counter(ifp, IFCOUNTER_IBYTES, m->m_pkthdr.len); 676 M_SETFIB(m, ifp->if_fib); 677 netisr_dispatch(isr, m); 678 return; 679drop: 680 if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); 681} 682 683/* XXX how should we handle IPv6 scope on SIOC[GS]IFPHYADDR? */ 684int 685gif_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data) 686{ 687 GIF_RLOCK_TRACKER; 688 struct ifreq *ifr = (struct ifreq*)data; 689 struct sockaddr *dst, *src; 690 struct gif_softc *sc; 691#ifdef INET 692 struct sockaddr_in *sin = NULL; 693#endif 694#ifdef INET6 695 struct sockaddr_in6 *sin6 = NULL; 696#endif 697 u_int options; 698 int error; 699 700 switch (cmd) { 701 case SIOCSIFADDR: 702 ifp->if_flags |= IFF_UP; 703 case SIOCADDMULTI: 704 case SIOCDELMULTI: 705 case SIOCGIFMTU: 706 case SIOCSIFFLAGS: 707 return (0); 708 case SIOCSIFMTU: 709 if (ifr->ifr_mtu < GIF_MTU_MIN || 710 ifr->ifr_mtu > GIF_MTU_MAX) 711 return (EINVAL); 712 else 713 ifp->if_mtu = ifr->ifr_mtu; 714 return (0); 715 } 716 sx_xlock(&gif_ioctl_sx); 717 sc = ifp->if_softc; 718 if (sc == NULL) { 719 error = ENXIO; 720 goto bad; 721 } 722 error = 0; 723 switch (cmd) { 724 case SIOCSIFPHYADDR: 725#ifdef INET6 726 case SIOCSIFPHYADDR_IN6: 727#endif 728 error = EINVAL; 729 switch (cmd) { 730#ifdef INET 731 case SIOCSIFPHYADDR: 732 src = (struct sockaddr *) 733 &(((struct in_aliasreq *)data)->ifra_addr); 734 dst = (struct sockaddr *) 735 &(((struct in_aliasreq *)data)->ifra_dstaddr); 736 break; 737#endif 738#ifdef INET6 739 case SIOCSIFPHYADDR_IN6: 740 src = (struct sockaddr *) 741 &(((struct in6_aliasreq *)data)->ifra_addr); 742 dst = (struct sockaddr *) 743 &(((struct in6_aliasreq *)data)->ifra_dstaddr); 744 break; 745#endif 746 default: 747 goto bad; 748 } 749 /* sa_family must be equal */ 750 if (src->sa_family != dst->sa_family || 751 src->sa_len != dst->sa_len) 752 goto bad; 753 754 /* validate sa_len */ 755 /* check sa_family looks sane for the cmd */ 756 switch (src->sa_family) { 757#ifdef INET 758 case AF_INET: 759 if (src->sa_len != sizeof(struct sockaddr_in)) 760 goto bad; 761 if (cmd != SIOCSIFPHYADDR) { 762 error = EAFNOSUPPORT; 763 goto bad; 764 } 765 if (satosin(src)->sin_addr.s_addr == INADDR_ANY || 766 satosin(dst)->sin_addr.s_addr == INADDR_ANY) { 767 error = EADDRNOTAVAIL; 768 goto bad; 769 } 770 break; 771#endif 772#ifdef INET6 773 case AF_INET6: 774 if (src->sa_len != sizeof(struct sockaddr_in6)) 775 goto bad; 776 if (cmd != SIOCSIFPHYADDR_IN6) { 777 error = EAFNOSUPPORT; 778 goto bad; 779 } 780 error = EADDRNOTAVAIL; 781 if (IN6_IS_ADDR_UNSPECIFIED(&satosin6(src)->sin6_addr) 782 || 783 IN6_IS_ADDR_UNSPECIFIED(&satosin6(dst)->sin6_addr)) 784 goto bad; 785 /* 786 * Check validity of the scope zone ID of the 787 * addresses, and convert it into the kernel 788 * internal form if necessary. 789 */ 790 error = sa6_embedscope(satosin6(src), 0); 791 if (error != 0) 792 goto bad; 793 error = sa6_embedscope(satosin6(dst), 0); 794 if (error != 0) 795 goto bad; 796 break; 797#endif 798 default: 799 error = EAFNOSUPPORT; 800 goto bad; 801 } 802 error = gif_set_tunnel(ifp, src, dst); 803 break; 804 case SIOCDIFPHYADDR: 805 gif_delete_tunnel(ifp); 806 break; 807 case SIOCGIFPSRCADDR: 808 case SIOCGIFPDSTADDR: 809#ifdef INET6 810 case SIOCGIFPSRCADDR_IN6: 811 case SIOCGIFPDSTADDR_IN6: 812#endif 813 if (sc->gif_family == 0) { 814 error = EADDRNOTAVAIL; 815 break; 816 } 817 GIF_RLOCK(sc); 818 switch (cmd) { 819#ifdef INET 820 case SIOCGIFPSRCADDR: 821 case SIOCGIFPDSTADDR: 822 if (sc->gif_family != AF_INET) { 823 error = EADDRNOTAVAIL; 824 break; 825 } 826 sin = (struct sockaddr_in *)&ifr->ifr_addr; 827 memset(sin, 0, sizeof(*sin)); 828 sin->sin_family = AF_INET; 829 sin->sin_len = sizeof(*sin); 830 break; 831#endif 832#ifdef INET6 833 case SIOCGIFPSRCADDR_IN6: 834 case SIOCGIFPDSTADDR_IN6: 835 if (sc->gif_family != AF_INET6) { 836 error = EADDRNOTAVAIL; 837 break; 838 } 839 sin6 = (struct sockaddr_in6 *) 840 &(((struct in6_ifreq *)data)->ifr_addr); 841 memset(sin6, 0, sizeof(*sin6)); 842 sin6->sin6_family = AF_INET6; 843 sin6->sin6_len = sizeof(*sin6); 844 break; 845#endif 846 default: 847 error = EAFNOSUPPORT; 848 } 849 if (error == 0) { 850 switch (cmd) { 851#ifdef INET 852 case SIOCGIFPSRCADDR: 853 sin->sin_addr = sc->gif_iphdr->ip_src; 854 break; 855 case SIOCGIFPDSTADDR: 856 sin->sin_addr = sc->gif_iphdr->ip_dst; 857 break; 858#endif 859#ifdef INET6 860 case SIOCGIFPSRCADDR_IN6: 861 sin6->sin6_addr = sc->gif_ip6hdr->ip6_src; 862 break; 863 case SIOCGIFPDSTADDR_IN6: 864 sin6->sin6_addr = sc->gif_ip6hdr->ip6_dst; 865 break; 866#endif 867 } 868 } 869 GIF_RUNLOCK(sc); 870 if (error != 0) 871 break; 872 switch (cmd) { 873#ifdef INET 874 case SIOCGIFPSRCADDR: 875 case SIOCGIFPDSTADDR: 876 error = prison_if(curthread->td_ucred, 877 (struct sockaddr *)sin); 878 if (error != 0) 879 memset(sin, 0, sizeof(*sin)); 880 break; 881#endif 882#ifdef INET6 883 case SIOCGIFPSRCADDR_IN6: 884 case SIOCGIFPDSTADDR_IN6: 885 error = prison_if(curthread->td_ucred, 886 (struct sockaddr *)sin6); 887 if (error == 0) 888 error = sa6_recoverscope(sin6); 889 if (error != 0) 890 memset(sin6, 0, sizeof(*sin6)); 891#endif 892 } 893 break; 894 case SIOCGTUNFIB: 895 ifr->ifr_fib = sc->gif_fibnum; 896 break; 897 case SIOCSTUNFIB: 898 if ((error = priv_check(curthread, PRIV_NET_GIF)) != 0) 899 break; 900 if (ifr->ifr_fib >= rt_numfibs) 901 error = EINVAL; 902 else 903 sc->gif_fibnum = ifr->ifr_fib; 904 break; 905 case GIFGOPTS: 906 options = sc->gif_options; 907 error = copyout(&options, ifr->ifr_data, sizeof(options)); 908 break; 909 case GIFSOPTS: 910 if ((error = priv_check(curthread, PRIV_NET_GIF)) != 0) 911 break; 912 error = copyin(ifr->ifr_data, &options, sizeof(options)); 913 if (error) 914 break; 915 if (options & ~GIF_OPTMASK) 916 error = EINVAL; 917 else 918 sc->gif_options = options; 919 break; 920 default: 921 error = EINVAL; 922 break; 923 } 924bad: 925 sx_xunlock(&gif_ioctl_sx); 926 return (error); 927} 928 929static void 930gif_detach(struct gif_softc *sc) 931{ 932 933 sx_assert(&gif_ioctl_sx, SA_XLOCKED); 934 if (sc->gif_ecookie != NULL) 935 encap_detach(sc->gif_ecookie); 936 sc->gif_ecookie = NULL; 937} 938 939static int 940gif_attach(struct gif_softc *sc, int af) 941{ 942 943 sx_assert(&gif_ioctl_sx, SA_XLOCKED); 944 switch (af) { 945#ifdef INET 946 case AF_INET: 947 return (in_gif_attach(sc)); 948#endif 949#ifdef INET6 950 case AF_INET6: 951 return (in6_gif_attach(sc)); 952#endif 953 } 954 return (EAFNOSUPPORT); 955} 956 957static int 958gif_set_tunnel(struct ifnet *ifp, struct sockaddr *src, struct sockaddr *dst) 959{ 960 struct gif_softc *sc = ifp->if_softc; 961 struct gif_softc *tsc; 962#ifdef INET 963 struct ip *ip; 964#endif 965#ifdef INET6 966 struct ip6_hdr *ip6; 967#endif 968 void *hdr; 969 int error = 0; 970 971 if (sc == NULL) 972 return (ENXIO); 973 /* Disallow parallel tunnels unless instructed otherwise. */ 974 if (V_parallel_tunnels == 0) { 975 GIF_LIST_LOCK(); 976 LIST_FOREACH(tsc, &V_gif_softc_list, gif_list) { 977 if (tsc == sc || tsc->gif_family != src->sa_family) 978 continue; 979#ifdef INET 980 if (tsc->gif_family == AF_INET && 981 tsc->gif_iphdr->ip_src.s_addr == 982 satosin(src)->sin_addr.s_addr && 983 tsc->gif_iphdr->ip_dst.s_addr == 984 satosin(dst)->sin_addr.s_addr) { 985 error = EADDRNOTAVAIL; 986 GIF_LIST_UNLOCK(); 987 goto bad; 988 } 989#endif 990#ifdef INET6 991 if (tsc->gif_family == AF_INET6 && 992 IN6_ARE_ADDR_EQUAL(&tsc->gif_ip6hdr->ip6_src, 993 &satosin6(src)->sin6_addr) && 994 IN6_ARE_ADDR_EQUAL(&tsc->gif_ip6hdr->ip6_dst, 995 &satosin6(dst)->sin6_addr)) { 996 error = EADDRNOTAVAIL; 997 GIF_LIST_UNLOCK(); 998 goto bad; 999 } 1000#endif 1001 } 1002 GIF_LIST_UNLOCK(); 1003 } 1004 switch (src->sa_family) { 1005#ifdef INET 1006 case AF_INET: 1007 hdr = ip = malloc(sizeof(struct ip), M_GIF, 1008 M_WAITOK | M_ZERO); 1009 ip->ip_src.s_addr = satosin(src)->sin_addr.s_addr; 1010 ip->ip_dst.s_addr = satosin(dst)->sin_addr.s_addr; 1011 break; 1012#endif 1013#ifdef INET6 1014 case AF_INET6: 1015 hdr = ip6 = malloc(sizeof(struct ip6_hdr), M_GIF, 1016 M_WAITOK | M_ZERO); 1017 ip6->ip6_src = satosin6(src)->sin6_addr; 1018 ip6->ip6_dst = satosin6(dst)->sin6_addr; 1019 ip6->ip6_vfc = IPV6_VERSION; 1020 break; 1021#endif 1022 default: 1023 return (EAFNOSUPPORT); 1024 }; 1025 1026 if (sc->gif_family != src->sa_family) 1027 gif_detach(sc); 1028 if (sc->gif_family == 0 || 1029 sc->gif_family != src->sa_family) 1030 error = gif_attach(sc, src->sa_family); 1031 1032 GIF_WLOCK(sc); 1033 if (sc->gif_family != 0) 1034 free(sc->gif_hdr, M_GIF); 1035 sc->gif_family = src->sa_family; 1036 sc->gif_hdr = hdr; 1037 GIF_WUNLOCK(sc); 1038#if defined(INET) || defined(INET6) 1039bad: 1040#endif 1041 if (error == 0 && sc->gif_family != 0) { 1042 ifp->if_drv_flags |= IFF_DRV_RUNNING; 1043 if_link_state_change(ifp, LINK_STATE_UP); 1044 } else { 1045 ifp->if_drv_flags &= ~IFF_DRV_RUNNING; 1046 if_link_state_change(ifp, LINK_STATE_DOWN); 1047 } 1048 return (error); 1049} 1050 1051static void 1052gif_delete_tunnel(struct ifnet *ifp) 1053{ 1054 struct gif_softc *sc = ifp->if_softc; 1055 int family; 1056 1057 if (sc == NULL) 1058 return; 1059 1060 GIF_WLOCK(sc); 1061 family = sc->gif_family; 1062 sc->gif_family = 0; 1063 GIF_WUNLOCK(sc); 1064 if (family != 0) { 1065 gif_detach(sc); 1066 free(sc->gif_hdr, M_GIF); 1067 } 1068 ifp->if_drv_flags &= ~IFF_DRV_RUNNING; 1069 if_link_state_change(ifp, LINK_STATE_DOWN); 1070} 1071