1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright (c) 1998 The NetBSD Foundation, Inc. 5 * Copyright (c) 2014 Andrey V. Elsukov <ae@FreeBSD.org> 6 * All rights reserved. 7 * 8 * This code is derived from software contributed to The NetBSD Foundation 9 * by Heiko W.Rupp <hwr@pilhuhn.de> 10 * 11 * IPv6-over-GRE contributed by Gert Doering <gert@greenie.muc.de> 12 * 13 * Redistribution and use in source and binary forms, with or without 14 * modification, are permitted provided that the following conditions 15 * are met: 16 * 1. Redistributions of source code must retain the above copyright 17 * notice, this list of conditions and the following disclaimer. 18 * 2. Redistributions in binary form must reproduce the above copyright 19 * notice, this list of conditions and the following disclaimer in the 20 * documentation and/or other materials provided with the distribution. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 23 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 24 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 25 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 26 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 27 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 28 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 29 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 30 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 31 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 32 * POSSIBILITY OF SUCH DAMAGE. 33 * 34 * $NetBSD: if_gre.c,v 1.49 2003/12/11 00:22:29 itojun Exp $ 35 */ 36 37 #include <sys/cdefs.h> 38 __FBSDID("$FreeBSD$"); 39 40 #include "opt_inet.h" 41 #include "opt_inet6.h" 42 43 #include <sys/param.h> 44 #include <sys/jail.h> 45 #include <sys/kernel.h> 46 #include <sys/lock.h> 47 #include <sys/libkern.h> 48 #include <sys/malloc.h> 49 #include <sys/module.h> 50 #include <sys/mbuf.h> 51 #include <sys/priv.h> 52 #include <sys/proc.h> 53 #include <sys/protosw.h> 54 #include <sys/rmlock.h> 55 #include <sys/socket.h> 56 #include <sys/sockio.h> 57 #include <sys/sx.h> 58 #include <sys/sysctl.h> 59 #include <sys/syslog.h> 60 #include <sys/systm.h> 61 62 #include <net/ethernet.h> 63 #include <net/if.h> 64 #include <net/if_var.h> 65 #include <net/if_clone.h> 66 #include <net/if_types.h> 67 #include <net/netisr.h> 68 #include <net/vnet.h> 69 #include <net/route.h> 70 71 #include <netinet/in.h> 72 #ifdef INET 73 #include <netinet/in_systm.h> 74 #include <netinet/in_var.h> 75 #include <netinet/ip.h> 76 #include <netinet/ip_var.h> 77 #endif 78 79 #ifdef INET6 80 #include <netinet/ip6.h> 81 #include <netinet6/in6_var.h> 82 #include <netinet6/ip6_var.h> 83 #include <netinet6/scope6_var.h> 84 #endif 85 86 #include <netinet/ip_encap.h> 87 #include <net/bpf.h> 88 #include <net/if_gre.h> 89 90 #include <machine/in_cksum.h> 91 #include <security/mac/mac_framework.h> 92 93 #define GREMTU 1476 94 static const char grename[] = "gre"; 95 static MALLOC_DEFINE(M_GRE, grename, "Generic Routing Encapsulation"); 96 static VNET_DEFINE(struct mtx, gre_mtx); 97 #define V_gre_mtx VNET(gre_mtx) 98 #define GRE_LIST_LOCK_INIT(x) mtx_init(&V_gre_mtx, "gre_mtx", NULL, \ 99 MTX_DEF) 100 #define GRE_LIST_LOCK_DESTROY(x) mtx_destroy(&V_gre_mtx) 101 #define GRE_LIST_LOCK(x) mtx_lock(&V_gre_mtx) 102 #define GRE_LIST_UNLOCK(x) mtx_unlock(&V_gre_mtx) 103 104 static VNET_DEFINE(LIST_HEAD(, gre_softc), gre_softc_list); 105 #define V_gre_softc_list VNET(gre_softc_list) 106 static struct sx gre_ioctl_sx; 107 SX_SYSINIT(gre_ioctl_sx, &gre_ioctl_sx, "gre_ioctl"); 108 109 static int gre_clone_create(struct if_clone *, int, caddr_t); 110 static void gre_clone_destroy(struct ifnet *); 111 static VNET_DEFINE(struct if_clone *, gre_cloner); 112 #define V_gre_cloner VNET(gre_cloner) 113 114 static void gre_qflush(struct ifnet *); 115 static int gre_transmit(struct ifnet *, struct mbuf *); 116 static int gre_ioctl(struct ifnet *, u_long, caddr_t); 117 static int gre_output(struct ifnet *, struct mbuf *, 118 const struct sockaddr *, struct route *); 119 120 static void gre_updatehdr(struct gre_softc *); 121 static int gre_set_tunnel(struct ifnet *, struct sockaddr *, 122 struct sockaddr *); 123 static void gre_delete_tunnel(struct ifnet *); 124 125 SYSCTL_DECL(_net_link); 126 static SYSCTL_NODE(_net_link, IFT_TUNNEL, gre, CTLFLAG_RW, 0, 127 "Generic Routing Encapsulation"); 128 #ifndef MAX_GRE_NEST 129 /* 130 * This macro controls the default upper limitation on nesting of gre tunnels. 131 * Since, setting a large value to this macro with a careless configuration 132 * may introduce system crash, we don't allow any nestings by default. 133 * If you need to configure nested gre tunnels, you can define this macro 134 * in your kernel configuration file. However, if you do so, please be 135 * careful to configure the tunnels so that it won't make a loop. 136 */ 137 #define MAX_GRE_NEST 1 138 #endif 139 140 static VNET_DEFINE(int, max_gre_nesting) = MAX_GRE_NEST; 141 #define V_max_gre_nesting VNET(max_gre_nesting) 142 SYSCTL_INT(_net_link_gre, OID_AUTO, max_nesting, CTLFLAG_RW | CTLFLAG_VNET, 143 &VNET_NAME(max_gre_nesting), 0, "Max nested tunnels"); 144 145 static void 146 vnet_gre_init(const void *unused __unused) 147 { 148 LIST_INIT(&V_gre_softc_list); 149 GRE_LIST_LOCK_INIT(); 150 V_gre_cloner = if_clone_simple(grename, gre_clone_create, 151 gre_clone_destroy, 0); 152 } 153 VNET_SYSINIT(vnet_gre_init, SI_SUB_PROTO_IFATTACHDOMAIN, SI_ORDER_ANY, 154 vnet_gre_init, NULL); 155 156 static void 157 vnet_gre_uninit(const void *unused __unused) 158 { 159 160 if_clone_detach(V_gre_cloner); 161 GRE_LIST_LOCK_DESTROY(); 162 } 163 VNET_SYSUNINIT(vnet_gre_uninit, SI_SUB_PROTO_IFATTACHDOMAIN, SI_ORDER_ANY, 164 vnet_gre_uninit, NULL); 165 166 static int 167 gre_clone_create(struct if_clone *ifc, int unit, caddr_t params) 168 { 169 struct gre_softc *sc; 170 171 sc = malloc(sizeof(struct gre_softc), M_GRE, M_WAITOK | M_ZERO); 172 sc->gre_fibnum = curthread->td_proc->p_fibnum; 173 GRE2IFP(sc) = if_alloc(IFT_TUNNEL); 174 GRE_LOCK_INIT(sc); 175 GRE2IFP(sc)->if_softc = sc; 176 if_initname(GRE2IFP(sc), grename, unit); 177 178 GRE2IFP(sc)->if_mtu = GREMTU; 179 GRE2IFP(sc)->if_flags = IFF_POINTOPOINT|IFF_MULTICAST; 180 GRE2IFP(sc)->if_output = gre_output; 181 GRE2IFP(sc)->if_ioctl = gre_ioctl; 182 GRE2IFP(sc)->if_transmit = gre_transmit; 183 GRE2IFP(sc)->if_qflush = gre_qflush; 184 GRE2IFP(sc)->if_capabilities |= IFCAP_LINKSTATE; 185 GRE2IFP(sc)->if_capenable |= IFCAP_LINKSTATE; 186 if_attach(GRE2IFP(sc)); 187 bpfattach(GRE2IFP(sc), DLT_NULL, sizeof(u_int32_t)); 188 GRE_LIST_LOCK(); 189 LIST_INSERT_HEAD(&V_gre_softc_list, sc, gre_list); 190 GRE_LIST_UNLOCK(); 191 return (0); 192 } 193 194 static void 195 gre_clone_destroy(struct ifnet *ifp) 196 { 197 struct gre_softc *sc; 198 199 sx_xlock(&gre_ioctl_sx); 200 sc = ifp->if_softc; 201 gre_delete_tunnel(ifp); 202 GRE_LIST_LOCK(); 203 LIST_REMOVE(sc, gre_list); 204 GRE_LIST_UNLOCK(); 205 bpfdetach(ifp); 206 if_detach(ifp); 207 ifp->if_softc = NULL; 208 sx_xunlock(&gre_ioctl_sx); 209 210 if_free(ifp); 211 GRE_LOCK_DESTROY(sc); 212 free(sc, M_GRE); 213 } 214 215 static int 216 gre_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data) 217 { 218 GRE_RLOCK_TRACKER; 219 struct ifreq *ifr = (struct ifreq *)data; 220 struct sockaddr *src, *dst; 221 struct gre_softc *sc; 222 #ifdef INET 223 struct sockaddr_in *sin = NULL; 224 #endif 225 #ifdef INET6 226 struct sockaddr_in6 *sin6 = NULL; 227 #endif 228 uint32_t opt; 229 int error; 230 231 switch (cmd) { 232 case SIOCSIFMTU: 233 /* XXX: */ 234 if (ifr->ifr_mtu < 576) 235 return (EINVAL); 236 ifp->if_mtu = ifr->ifr_mtu; 237 return (0); 238 case SIOCSIFADDR: 239 ifp->if_flags |= IFF_UP; 240 case SIOCSIFFLAGS: 241 case SIOCADDMULTI: 242 case SIOCDELMULTI: 243 return (0); 244 case GRESADDRS: 245 case GRESADDRD: 246 case GREGADDRS: 247 case GREGADDRD: 248 case GRESPROTO: 249 case GREGPROTO: 250 return (EOPNOTSUPP); 251 } 252 src = dst = NULL; 253 sx_xlock(&gre_ioctl_sx); 254 sc = ifp->if_softc; 255 if (sc == NULL) { 256 error = ENXIO; 257 goto end; 258 } 259 error = 0; 260 switch (cmd) { 261 case SIOCSIFPHYADDR: 262 #ifdef INET6 263 case SIOCSIFPHYADDR_IN6: 264 #endif 265 error = EINVAL; 266 switch (cmd) { 267 #ifdef INET 268 case SIOCSIFPHYADDR: 269 src = (struct sockaddr *) 270 &(((struct in_aliasreq *)data)->ifra_addr); 271 dst = (struct sockaddr *) 272 &(((struct in_aliasreq *)data)->ifra_dstaddr); 273 break; 274 #endif 275 #ifdef INET6 276 case SIOCSIFPHYADDR_IN6: 277 src = (struct sockaddr *) 278 &(((struct in6_aliasreq *)data)->ifra_addr); 279 dst = (struct sockaddr *) 280 &(((struct in6_aliasreq *)data)->ifra_dstaddr); 281 break; 282 #endif 283 default: 284 error = EAFNOSUPPORT; 285 goto end; 286 } 287 /* sa_family must be equal */ 288 if (src->sa_family != dst->sa_family || 289 src->sa_len != dst->sa_len) 290 goto end; 291 292 /* validate sa_len */ 293 switch (src->sa_family) { 294 #ifdef INET 295 case AF_INET: 296 if (src->sa_len != sizeof(struct sockaddr_in)) 297 goto end; 298 break; 299 #endif 300 #ifdef INET6 301 case AF_INET6: 302 if (src->sa_len != sizeof(struct sockaddr_in6)) 303 goto end; 304 break; 305 #endif 306 default: 307 error = EAFNOSUPPORT; 308 goto end; 309 } 310 /* check sa_family looks sane for the cmd */ 311 error = EAFNOSUPPORT; 312 switch (cmd) { 313 #ifdef INET 314 case SIOCSIFPHYADDR: 315 if (src->sa_family == AF_INET) 316 break; 317 goto end; 318 #endif 319 #ifdef INET6 320 case SIOCSIFPHYADDR_IN6: 321 if (src->sa_family == AF_INET6) 322 break; 323 goto end; 324 #endif 325 } 326 error = EADDRNOTAVAIL; 327 switch (src->sa_family) { 328 #ifdef INET 329 case AF_INET: 330 if (satosin(src)->sin_addr.s_addr == INADDR_ANY || 331 satosin(dst)->sin_addr.s_addr == INADDR_ANY) 332 goto end; 333 break; 334 #endif 335 #ifdef INET6 336 case AF_INET6: 337 if (IN6_IS_ADDR_UNSPECIFIED(&satosin6(src)->sin6_addr) 338 || 339 IN6_IS_ADDR_UNSPECIFIED(&satosin6(dst)->sin6_addr)) 340 goto end; 341 /* 342 * Check validity of the scope zone ID of the 343 * addresses, and convert it into the kernel 344 * internal form if necessary. 345 */ 346 error = sa6_embedscope(satosin6(src), 0); 347 if (error != 0) 348 goto end; 349 error = sa6_embedscope(satosin6(dst), 0); 350 if (error != 0) 351 goto end; 352 #endif 353 } 354 error = gre_set_tunnel(ifp, src, dst); 355 break; 356 case SIOCDIFPHYADDR: 357 gre_delete_tunnel(ifp); 358 break; 359 case SIOCGIFPSRCADDR: 360 case SIOCGIFPDSTADDR: 361 #ifdef INET6 362 case SIOCGIFPSRCADDR_IN6: 363 case SIOCGIFPDSTADDR_IN6: 364 #endif 365 if (sc->gre_family == 0) { 366 error = EADDRNOTAVAIL; 367 break; 368 } 369 GRE_RLOCK(sc); 370 switch (cmd) { 371 #ifdef INET 372 case SIOCGIFPSRCADDR: 373 case SIOCGIFPDSTADDR: 374 if (sc->gre_family != AF_INET) { 375 error = EADDRNOTAVAIL; 376 break; 377 } 378 sin = (struct sockaddr_in *)&ifr->ifr_addr; 379 memset(sin, 0, sizeof(*sin)); 380 sin->sin_family = AF_INET; 381 sin->sin_len = sizeof(*sin); 382 break; 383 #endif 384 #ifdef INET6 385 case SIOCGIFPSRCADDR_IN6: 386 case SIOCGIFPDSTADDR_IN6: 387 if (sc->gre_family != AF_INET6) { 388 error = EADDRNOTAVAIL; 389 break; 390 } 391 sin6 = (struct sockaddr_in6 *) 392 &(((struct in6_ifreq *)data)->ifr_addr); 393 memset(sin6, 0, sizeof(*sin6)); 394 sin6->sin6_family = AF_INET6; 395 sin6->sin6_len = sizeof(*sin6); 396 break; 397 #endif 398 } 399 if (error == 0) { 400 switch (cmd) { 401 #ifdef INET 402 case SIOCGIFPSRCADDR: 403 sin->sin_addr = sc->gre_oip.ip_src; 404 break; 405 case SIOCGIFPDSTADDR: 406 sin->sin_addr = sc->gre_oip.ip_dst; 407 break; 408 #endif 409 #ifdef INET6 410 case SIOCGIFPSRCADDR_IN6: 411 sin6->sin6_addr = sc->gre_oip6.ip6_src; 412 break; 413 case SIOCGIFPDSTADDR_IN6: 414 sin6->sin6_addr = sc->gre_oip6.ip6_dst; 415 break; 416 #endif 417 } 418 } 419 GRE_RUNLOCK(sc); 420 if (error != 0) 421 break; 422 switch (cmd) { 423 #ifdef INET 424 case SIOCGIFPSRCADDR: 425 case SIOCGIFPDSTADDR: 426 error = prison_if(curthread->td_ucred, 427 (struct sockaddr *)sin); 428 if (error != 0) 429 memset(sin, 0, sizeof(*sin)); 430 break; 431 #endif 432 #ifdef INET6 433 case SIOCGIFPSRCADDR_IN6: 434 case SIOCGIFPDSTADDR_IN6: 435 error = prison_if(curthread->td_ucred, 436 (struct sockaddr *)sin6); 437 if (error == 0) 438 error = sa6_recoverscope(sin6); 439 if (error != 0) 440 memset(sin6, 0, sizeof(*sin6)); 441 #endif 442 } 443 break; 444 case SIOCGTUNFIB: 445 ifr->ifr_fib = sc->gre_fibnum; 446 break; 447 case SIOCSTUNFIB: 448 if ((error = priv_check(curthread, PRIV_NET_GRE)) != 0) 449 break; 450 if (ifr->ifr_fib >= rt_numfibs) 451 error = EINVAL; 452 else 453 sc->gre_fibnum = ifr->ifr_fib; 454 break; 455 case GRESKEY: 456 if ((error = priv_check(curthread, PRIV_NET_GRE)) != 0) 457 break; 458 if ((error = copyin(ifr_data_get_ptr(ifr), &opt, 459 sizeof(opt))) != 0) 460 break; 461 if (sc->gre_key != opt) { 462 GRE_WLOCK(sc); 463 sc->gre_key = opt; 464 gre_updatehdr(sc); 465 GRE_WUNLOCK(sc); 466 } 467 break; 468 case GREGKEY: 469 error = copyout(&sc->gre_key, ifr_data_get_ptr(ifr), 470 sizeof(sc->gre_key)); 471 break; 472 case GRESOPTS: 473 if ((error = priv_check(curthread, PRIV_NET_GRE)) != 0) 474 break; 475 if ((error = copyin(ifr_data_get_ptr(ifr), &opt, 476 sizeof(opt))) != 0) 477 break; 478 if (opt & ~GRE_OPTMASK) 479 error = EINVAL; 480 else { 481 if (sc->gre_options != opt) { 482 GRE_WLOCK(sc); 483 sc->gre_options = opt; 484 gre_updatehdr(sc); 485 GRE_WUNLOCK(sc); 486 } 487 } 488 break; 489 490 case GREGOPTS: 491 error = copyout(&sc->gre_options, ifr_data_get_ptr(ifr), 492 sizeof(sc->gre_options)); 493 break; 494 default: 495 error = EINVAL; 496 break; 497 } 498 end: 499 sx_xunlock(&gre_ioctl_sx); 500 return (error); 501 } 502 503 static void 504 gre_updatehdr(struct gre_softc *sc) 505 { 506 struct grehdr *gh = NULL; 507 uint32_t *opts; 508 uint16_t flags; 509 510 GRE_WLOCK_ASSERT(sc); 511 switch (sc->gre_family) { 512 #ifdef INET 513 case AF_INET: 514 sc->gre_hlen = sizeof(struct greip); 515 sc->gre_oip.ip_v = IPPROTO_IPV4; 516 sc->gre_oip.ip_hl = sizeof(struct ip) >> 2; 517 sc->gre_oip.ip_p = IPPROTO_GRE; 518 gh = &sc->gre_gihdr->gi_gre; 519 break; 520 #endif 521 #ifdef INET6 522 case AF_INET6: 523 sc->gre_hlen = sizeof(struct greip6); 524 sc->gre_oip6.ip6_vfc = IPV6_VERSION; 525 sc->gre_oip6.ip6_nxt = IPPROTO_GRE; 526 gh = &sc->gre_gi6hdr->gi6_gre; 527 break; 528 #endif 529 default: 530 return; 531 } 532 flags = 0; 533 opts = gh->gre_opts; 534 if (sc->gre_options & GRE_ENABLE_CSUM) { 535 flags |= GRE_FLAGS_CP; 536 sc->gre_hlen += 2 * sizeof(uint16_t); 537 *opts++ = 0; 538 } 539 if (sc->gre_key != 0) { 540 flags |= GRE_FLAGS_KP; 541 sc->gre_hlen += sizeof(uint32_t); 542 *opts++ = htonl(sc->gre_key); 543 } 544 if (sc->gre_options & GRE_ENABLE_SEQ) { 545 flags |= GRE_FLAGS_SP; 546 sc->gre_hlen += sizeof(uint32_t); 547 *opts++ = 0; 548 } else 549 sc->gre_oseq = 0; 550 gh->gre_flags = htons(flags); 551 } 552 553 static void 554 gre_detach(struct gre_softc *sc, int family) 555 { 556 557 sx_assert(&gre_ioctl_sx, SA_XLOCKED); 558 if (sc->gre_ecookie != NULL) { 559 switch (family) { 560 #ifdef INET 561 case AF_INET: 562 ip_encap_detach(sc->gre_ecookie); 563 break; 564 #endif 565 #ifdef INET6 566 case AF_INET6: 567 ip6_encap_detach(sc->gre_ecookie); 568 break; 569 #endif 570 } 571 } 572 sc->gre_ecookie = NULL; 573 } 574 575 static int 576 gre_set_tunnel(struct ifnet *ifp, struct sockaddr *src, 577 struct sockaddr *dst) 578 { 579 struct gre_softc *sc, *tsc; 580 #ifdef INET6 581 struct ip6_hdr *ip6; 582 #endif 583 #ifdef INET 584 struct ip *ip; 585 #endif 586 void *hdr; 587 int error; 588 589 sx_assert(&gre_ioctl_sx, SA_XLOCKED); 590 GRE_LIST_LOCK(); 591 sc = ifp->if_softc; 592 LIST_FOREACH(tsc, &V_gre_softc_list, gre_list) { 593 if (tsc == sc || tsc->gre_family != src->sa_family) 594 continue; 595 #ifdef INET 596 if (tsc->gre_family == AF_INET && 597 tsc->gre_oip.ip_src.s_addr == 598 satosin(src)->sin_addr.s_addr && 599 tsc->gre_oip.ip_dst.s_addr == 600 satosin(dst)->sin_addr.s_addr) { 601 GRE_LIST_UNLOCK(); 602 return (EADDRNOTAVAIL); 603 } 604 #endif 605 #ifdef INET6 606 if (tsc->gre_family == AF_INET6 && 607 IN6_ARE_ADDR_EQUAL(&tsc->gre_oip6.ip6_src, 608 &satosin6(src)->sin6_addr) && 609 IN6_ARE_ADDR_EQUAL(&tsc->gre_oip6.ip6_dst, 610 &satosin6(dst)->sin6_addr)) { 611 GRE_LIST_UNLOCK(); 612 return (EADDRNOTAVAIL); 613 } 614 #endif 615 } 616 GRE_LIST_UNLOCK(); 617 618 switch (src->sa_family) { 619 #ifdef INET 620 case AF_INET: 621 hdr = ip = malloc(sizeof(struct greip) + 622 3 * sizeof(uint32_t), M_GRE, M_WAITOK | M_ZERO); 623 ip->ip_src = satosin(src)->sin_addr; 624 ip->ip_dst = satosin(dst)->sin_addr; 625 break; 626 #endif 627 #ifdef INET6 628 case AF_INET6: 629 hdr = ip6 = malloc(sizeof(struct greip6) + 630 3 * sizeof(uint32_t), M_GRE, M_WAITOK | M_ZERO); 631 ip6->ip6_src = satosin6(src)->sin6_addr; 632 ip6->ip6_dst = satosin6(dst)->sin6_addr; 633 break; 634 #endif 635 default: 636 return (EAFNOSUPPORT); 637 } 638 if (sc->gre_family != 0) 639 gre_detach(sc, sc->gre_family); 640 GRE_WLOCK(sc); 641 if (sc->gre_family != 0) 642 free(sc->gre_hdr, M_GRE); 643 sc->gre_family = src->sa_family; 644 sc->gre_hdr = hdr; 645 sc->gre_oseq = 0; 646 sc->gre_iseq = UINT32_MAX; 647 gre_updatehdr(sc); 648 GRE_WUNLOCK(sc); 649 650 error = 0; 651 switch (src->sa_family) { 652 #ifdef INET 653 case AF_INET: 654 error = in_gre_attach(sc); 655 break; 656 #endif 657 #ifdef INET6 658 case AF_INET6: 659 error = in6_gre_attach(sc); 660 break; 661 #endif 662 } 663 if (error == 0) { 664 ifp->if_drv_flags |= IFF_DRV_RUNNING; 665 if_link_state_change(ifp, LINK_STATE_UP); 666 } 667 return (error); 668 } 669 670 static void 671 gre_delete_tunnel(struct ifnet *ifp) 672 { 673 struct gre_softc *sc = ifp->if_softc; 674 int family; 675 676 GRE_WLOCK(sc); 677 family = sc->gre_family; 678 sc->gre_family = 0; 679 GRE_WUNLOCK(sc); 680 if (family != 0) { 681 gre_detach(sc, family); 682 free(sc->gre_hdr, M_GRE); 683 } 684 ifp->if_drv_flags &= ~IFF_DRV_RUNNING; 685 if_link_state_change(ifp, LINK_STATE_DOWN); 686 } 687 688 int 689 gre_input(struct mbuf *m, int off, int proto, void *arg) 690 { 691 struct gre_softc *sc = arg; 692 struct grehdr *gh; 693 struct ifnet *ifp; 694 uint32_t *opts; 695 #ifdef notyet 696 uint32_t key; 697 #endif 698 uint16_t flags; 699 int hlen, isr, af; 700 701 ifp = GRE2IFP(sc); 702 hlen = off + sizeof(struct grehdr) + 4 * sizeof(uint32_t); 703 if (m->m_pkthdr.len < hlen) 704 goto drop; 705 if (m->m_len < hlen) { 706 m = m_pullup(m, hlen); 707 if (m == NULL) 708 goto drop; 709 } 710 gh = (struct grehdr *)mtodo(m, off); 711 flags = ntohs(gh->gre_flags); 712 if (flags & ~GRE_FLAGS_MASK) 713 goto drop; 714 opts = gh->gre_opts; 715 hlen = 2 * sizeof(uint16_t); 716 if (flags & GRE_FLAGS_CP) { 717 /* reserved1 field must be zero */ 718 if (((uint16_t *)opts)[1] != 0) 719 goto drop; 720 if (in_cksum_skip(m, m->m_pkthdr.len, off) != 0) 721 goto drop; 722 hlen += 2 * sizeof(uint16_t); 723 opts++; 724 } 725 if (flags & GRE_FLAGS_KP) { 726 #ifdef notyet 727 /* 728 * XXX: The current implementation uses the key only for outgoing 729 * packets. But we can check the key value here, or even in the 730 * encapcheck function. 731 */ 732 key = ntohl(*opts); 733 #endif 734 hlen += sizeof(uint32_t); 735 opts++; 736 } 737 #ifdef notyet 738 } else 739 key = 0; 740 741 if (sc->gre_key != 0 && (key != sc->gre_key || key != 0)) 742 goto drop; 743 #endif 744 if (flags & GRE_FLAGS_SP) { 745 #ifdef notyet 746 seq = ntohl(*opts); 747 #endif 748 hlen += sizeof(uint32_t); 749 } 750 switch (ntohs(gh->gre_proto)) { 751 case ETHERTYPE_WCCP: 752 /* 753 * For WCCP skip an additional 4 bytes if after GRE header 754 * doesn't follow an IP header. 755 */ 756 if (flags == 0 && (*(uint8_t *)gh->gre_opts & 0xF0) != 0x40) 757 hlen += sizeof(uint32_t); 758 /* FALLTHROUGH */ 759 case ETHERTYPE_IP: 760 isr = NETISR_IP; 761 af = AF_INET; 762 break; 763 case ETHERTYPE_IPV6: 764 isr = NETISR_IPV6; 765 af = AF_INET6; 766 break; 767 default: 768 goto drop; 769 } 770 m_adj(m, off + hlen); 771 m_clrprotoflags(m); 772 m->m_pkthdr.rcvif = ifp; 773 M_SETFIB(m, ifp->if_fib); 774 #ifdef MAC 775 mac_ifnet_create_mbuf(ifp, m); 776 #endif 777 BPF_MTAP2(ifp, &af, sizeof(af), m); 778 if_inc_counter(ifp, IFCOUNTER_IPACKETS, 1); 779 if_inc_counter(ifp, IFCOUNTER_IBYTES, m->m_pkthdr.len); 780 if ((ifp->if_flags & IFF_MONITOR) != 0) 781 m_freem(m); 782 else 783 netisr_dispatch(isr, m); 784 return (IPPROTO_DONE); 785 drop: 786 if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); 787 m_freem(m); 788 return (IPPROTO_DONE); 789 } 790 791 #define MTAG_GRE 1307983903 792 static int 793 gre_check_nesting(struct ifnet *ifp, struct mbuf *m) 794 { 795 struct m_tag *mtag; 796 int count; 797 798 count = 1; 799 mtag = NULL; 800 while ((mtag = m_tag_locate(m, MTAG_GRE, 0, mtag)) != NULL) { 801 if (*(struct ifnet **)(mtag + 1) == ifp) { 802 log(LOG_NOTICE, "%s: loop detected\n", ifp->if_xname); 803 return (EIO); 804 } 805 count++; 806 } 807 if (count > V_max_gre_nesting) { 808 log(LOG_NOTICE, 809 "%s: if_output recursively called too many times(%d)\n", 810 ifp->if_xname, count); 811 return (EIO); 812 } 813 mtag = m_tag_alloc(MTAG_GRE, 0, sizeof(struct ifnet *), M_NOWAIT); 814 if (mtag == NULL) 815 return (ENOMEM); 816 *(struct ifnet **)(mtag + 1) = ifp; 817 m_tag_prepend(m, mtag); 818 return (0); 819 } 820 821 static int 822 gre_output(struct ifnet *ifp, struct mbuf *m, const struct sockaddr *dst, 823 struct route *ro) 824 { 825 uint32_t af; 826 int error; 827 828 #ifdef MAC 829 error = mac_ifnet_check_transmit(ifp, m); 830 if (error != 0) 831 goto drop; 832 #endif 833 if ((ifp->if_flags & IFF_MONITOR) != 0 || 834 (ifp->if_flags & IFF_UP) == 0) { 835 error = ENETDOWN; 836 goto drop; 837 } 838 839 error = gre_check_nesting(ifp, m); 840 if (error != 0) 841 goto drop; 842 843 m->m_flags &= ~(M_BCAST|M_MCAST); 844 if (dst->sa_family == AF_UNSPEC) 845 bcopy(dst->sa_data, &af, sizeof(af)); 846 else 847 af = dst->sa_family; 848 BPF_MTAP2(ifp, &af, sizeof(af), m); 849 m->m_pkthdr.csum_data = af; /* save af for if_transmit */ 850 return (ifp->if_transmit(ifp, m)); 851 drop: 852 m_freem(m); 853 if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); 854 return (error); 855 } 856 857 static void 858 gre_setseqn(struct grehdr *gh, uint32_t seq) 859 { 860 uint32_t *opts; 861 uint16_t flags; 862 863 opts = gh->gre_opts; 864 flags = ntohs(gh->gre_flags); 865 KASSERT((flags & GRE_FLAGS_SP) != 0, 866 ("gre_setseqn called, but GRE_FLAGS_SP isn't set ")); 867 if (flags & GRE_FLAGS_CP) 868 opts++; 869 if (flags & GRE_FLAGS_KP) 870 opts++; 871 *opts = htonl(seq); 872 } 873 874 static int 875 gre_transmit(struct ifnet *ifp, struct mbuf *m) 876 { 877 GRE_RLOCK_TRACKER; 878 struct gre_softc *sc; 879 struct grehdr *gh; 880 uint32_t iaf, oaf, oseq; 881 int error, hlen, olen, plen; 882 int want_seq, want_csum; 883 884 plen = 0; 885 sc = ifp->if_softc; 886 if (sc == NULL) { 887 error = ENETDOWN; 888 m_freem(m); 889 goto drop; 890 } 891 GRE_RLOCK(sc); 892 if (sc->gre_family == 0) { 893 GRE_RUNLOCK(sc); 894 error = ENETDOWN; 895 m_freem(m); 896 goto drop; 897 } 898 iaf = m->m_pkthdr.csum_data; 899 oaf = sc->gre_family; 900 hlen = sc->gre_hlen; 901 want_seq = (sc->gre_options & GRE_ENABLE_SEQ) != 0; 902 if (want_seq) 903 oseq = sc->gre_oseq++; /* XXX */ 904 else 905 oseq = 0; /* Make compiler happy. */ 906 want_csum = (sc->gre_options & GRE_ENABLE_CSUM) != 0; 907 M_SETFIB(m, sc->gre_fibnum); 908 M_PREPEND(m, hlen, M_NOWAIT); 909 if (m == NULL) { 910 GRE_RUNLOCK(sc); 911 error = ENOBUFS; 912 goto drop; 913 } 914 bcopy(sc->gre_hdr, mtod(m, void *), hlen); 915 GRE_RUNLOCK(sc); 916 switch (oaf) { 917 #ifdef INET 918 case AF_INET: 919 olen = sizeof(struct ip); 920 break; 921 #endif 922 #ifdef INET6 923 case AF_INET6: 924 olen = sizeof(struct ip6_hdr); 925 break; 926 #endif 927 default: 928 error = ENETDOWN; 929 goto drop; 930 } 931 gh = (struct grehdr *)mtodo(m, olen); 932 switch (iaf) { 933 #ifdef INET 934 case AF_INET: 935 gh->gre_proto = htons(ETHERTYPE_IP); 936 break; 937 #endif 938 #ifdef INET6 939 case AF_INET6: 940 gh->gre_proto = htons(ETHERTYPE_IPV6); 941 break; 942 #endif 943 default: 944 error = ENETDOWN; 945 goto drop; 946 } 947 if (want_seq) 948 gre_setseqn(gh, oseq); 949 if (want_csum) { 950 *(uint16_t *)gh->gre_opts = in_cksum_skip(m, 951 m->m_pkthdr.len, olen); 952 } 953 plen = m->m_pkthdr.len - hlen; 954 switch (oaf) { 955 #ifdef INET 956 case AF_INET: 957 error = in_gre_output(m, iaf, hlen); 958 break; 959 #endif 960 #ifdef INET6 961 case AF_INET6: 962 error = in6_gre_output(m, iaf, hlen); 963 break; 964 #endif 965 default: 966 m_freem(m); 967 error = ENETDOWN; 968 } 969 drop: 970 if (error) 971 if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); 972 else { 973 if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1); 974 if_inc_counter(ifp, IFCOUNTER_OBYTES, plen); 975 } 976 return (error); 977 } 978 979 static void 980 gre_qflush(struct ifnet *ifp __unused) 981 { 982 983 } 984 985 static int 986 gremodevent(module_t mod, int type, void *data) 987 { 988 989 switch (type) { 990 case MOD_LOAD: 991 case MOD_UNLOAD: 992 break; 993 default: 994 return (EOPNOTSUPP); 995 } 996 return (0); 997 } 998 999 static moduledata_t gre_mod = { 1000 "if_gre", 1001 gremodevent, 1002 0 1003 }; 1004 1005 DECLARE_MODULE(if_gre, gre_mod, SI_SUB_PSEUDO, SI_ORDER_ANY); 1006 MODULE_VERSION(if_gre, 1); 1007