if_gif.c revision 1.137
1 /* $NetBSD: if_gif.c,v 1.137 2017/12/21 09:35:38 knakahara Exp $ */ 2 /* $KAME: if_gif.c,v 1.76 2001/08/20 02:01:02 kjc Exp $ */ 3 4 /* 5 * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project. 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 3. Neither the name of the project nor the names of its contributors 17 * may be used to endorse or promote products derived from this software 18 * without specific prior written permission. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND 21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 23 * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE 24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 30 * SUCH DAMAGE. 31 */ 32 33 #include <sys/cdefs.h> 34 __KERNEL_RCSID(0, "$NetBSD: if_gif.c,v 1.137 2017/12/21 09:35:38 knakahara Exp $"); 35 36 #ifdef _KERNEL_OPT 37 #include "opt_inet.h" 38 #include "opt_net_mpsafe.h" 39 #endif 40 41 #include <sys/param.h> 42 #include <sys/systm.h> 43 #include <sys/kernel.h> 44 #include <sys/mbuf.h> 45 #include <sys/socket.h> 46 #include <sys/sockio.h> 47 #include <sys/errno.h> 48 #include <sys/ioctl.h> 49 #include <sys/time.h> 50 #include <sys/socketvar.h> 51 #include <sys/syslog.h> 52 #include <sys/proc.h> 53 #include <sys/cpu.h> 54 #include <sys/intr.h> 55 #include <sys/kmem.h> 56 #include <sys/sysctl.h> 57 #include <sys/xcall.h> 58 #include <sys/device.h> 59 #include <sys/module.h> 60 #include <sys/mutex.h> 61 #include <sys/pserialize.h> 62 #include <sys/psref.h> 63 64 #include <net/if.h> 65 #include <net/if_types.h> 66 #include <net/netisr.h> 67 #include <net/route.h> 68 #include <net/bpf.h> 69 70 #include <netinet/in.h> 71 #include <netinet/in_systm.h> 72 #include <netinet/ip.h> 73 #ifdef INET 74 #include <netinet/in_var.h> 75 #endif /* INET */ 76 #include <netinet/in_gif.h> 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_var.h> 85 #include <netinet6/in6_gif.h> 86 #endif /* INET6 */ 87 88 #include <netinet/ip_encap.h> 89 #include <net/if_gif.h> 90 91 #include <net/net_osdep.h> 92 93 #include "ioconf.h" 94 95 #ifdef NET_MPSAFE 96 #define GIF_MPSAFE 1 97 #endif 98 99 /* 100 * gif global variable definitions 101 */ 102 LIST_HEAD(gif_sclist, gif_softc); 103 static struct { 104 struct gif_sclist list; 105 kmutex_t lock; 106 } gif_softcs __cacheline_aligned; 107 108 pserialize_t gif_psz __read_mostly; 109 struct psref_class *gv_psref_class __read_mostly; 110 111 static void gif_ro_init_pc(void *, void *, struct cpu_info *); 112 static void gif_ro_fini_pc(void *, void *, struct cpu_info *); 113 114 static int gifattach0(struct gif_softc *); 115 static int gif_output(struct ifnet *, struct mbuf *, 116 const struct sockaddr *, const struct rtentry *); 117 static void gif_start(struct ifnet *); 118 static int gif_transmit(struct ifnet *, struct mbuf *); 119 static int gif_transmit_direct(struct gif_variant *, struct mbuf *); 120 static int gif_ioctl(struct ifnet *, u_long, void *); 121 static int gif_set_tunnel(struct ifnet *, struct sockaddr *, 122 struct sockaddr *); 123 static void gif_delete_tunnel(struct ifnet *); 124 125 static int gif_clone_create(struct if_clone *, int); 126 static int gif_clone_destroy(struct ifnet *); 127 static int gif_check_nesting(struct ifnet *, struct mbuf *); 128 129 static int gif_encap_attach(struct gif_variant *); 130 static int gif_encap_detach(struct gif_variant *); 131 132 static void gif_update_variant(struct gif_softc *, struct gif_variant *); 133 134 static struct if_clone gif_cloner = 135 IF_CLONE_INITIALIZER("gif", gif_clone_create, gif_clone_destroy); 136 137 #ifndef MAX_GIF_NEST 138 /* 139 * This macro controls the upper limitation on nesting of gif tunnels. 140 * Since, setting a large value to this macro with a careless configuration 141 * may introduce system crash, we don't allow any nestings by default. 142 * If you need to configure nested gif tunnels, you can define this macro 143 * in your kernel configuration file. However, if you do so, please be 144 * careful to configure the tunnels so that it won't make a loop. 145 */ 146 #define MAX_GIF_NEST 1 147 #endif 148 static int max_gif_nesting = MAX_GIF_NEST; 149 150 static struct sysctllog *gif_sysctl; 151 152 static void 153 gif_sysctl_setup(void) 154 { 155 gif_sysctl = NULL; 156 157 #ifdef INET 158 /* 159 * Previously create "net.inet.ip" entry to avoid sysctl_createv error. 160 */ 161 sysctl_createv(NULL, 0, NULL, NULL, 162 CTLFLAG_PERMANENT, 163 CTLTYPE_NODE, "inet", 164 SYSCTL_DESCR("PF_INET related settings"), 165 NULL, 0, NULL, 0, 166 CTL_NET, PF_INET, CTL_EOL); 167 sysctl_createv(NULL, 0, NULL, NULL, 168 CTLFLAG_PERMANENT, 169 CTLTYPE_NODE, "ip", 170 SYSCTL_DESCR("IPv4 related settings"), 171 NULL, 0, NULL, 0, 172 CTL_NET, PF_INET, IPPROTO_IP, CTL_EOL); 173 174 sysctl_createv(&gif_sysctl, 0, NULL, NULL, 175 CTLFLAG_PERMANENT|CTLFLAG_READWRITE, 176 CTLTYPE_INT, "gifttl", 177 SYSCTL_DESCR("Default TTL for a gif tunnel datagram"), 178 NULL, 0, &ip_gif_ttl, 0, 179 CTL_NET, PF_INET, IPPROTO_IP, 180 IPCTL_GIF_TTL, CTL_EOL); 181 #endif 182 #ifdef INET6 183 /* 184 * Previously create "net.inet6.ip6" entry to avoid sysctl_createv error. 185 */ 186 sysctl_createv(NULL, 0, NULL, NULL, 187 CTLFLAG_PERMANENT, 188 CTLTYPE_NODE, "inet6", 189 SYSCTL_DESCR("PF_INET6 related settings"), 190 NULL, 0, NULL, 0, 191 CTL_NET, PF_INET6, CTL_EOL); 192 sysctl_createv(NULL, 0, NULL, NULL, 193 CTLFLAG_PERMANENT, 194 CTLTYPE_NODE, "ip6", 195 SYSCTL_DESCR("IPv6 related settings"), 196 NULL, 0, NULL, 0, 197 CTL_NET, PF_INET6, IPPROTO_IPV6, CTL_EOL); 198 199 sysctl_createv(&gif_sysctl, 0, NULL, NULL, 200 CTLFLAG_PERMANENT|CTLFLAG_READWRITE, 201 CTLTYPE_INT, "gifhlim", 202 SYSCTL_DESCR("Default hop limit for a gif tunnel datagram"), 203 NULL, 0, &ip6_gif_hlim, 0, 204 CTL_NET, PF_INET6, IPPROTO_IPV6, 205 IPV6CTL_GIF_HLIM, CTL_EOL); 206 #endif 207 } 208 209 /* ARGSUSED */ 210 void 211 gifattach(int count) 212 { 213 /* 214 * Nothing to do here, initialization is handled by the 215 * module initialization code in gifinit() below). 216 */ 217 } 218 219 static void 220 gifinit(void) 221 { 222 223 mutex_init(&gif_softcs.lock, MUTEX_DEFAULT, IPL_NONE); 224 LIST_INIT(&gif_softcs.list); 225 if_clone_attach(&gif_cloner); 226 227 gif_psz = pserialize_create(); 228 gv_psref_class = psref_class_create("gifvar", IPL_SOFTNET); 229 230 gif_sysctl_setup(); 231 } 232 233 static int 234 gifdetach(void) 235 { 236 int error = 0; 237 238 mutex_enter(&gif_softcs.lock); 239 if (!LIST_EMPTY(&gif_softcs.list)) { 240 mutex_exit(&gif_softcs.lock); 241 error = EBUSY; 242 } 243 244 if (error == 0) { 245 psref_class_destroy(gv_psref_class); 246 pserialize_destroy(gif_psz); 247 248 if_clone_detach(&gif_cloner); 249 sysctl_teardown(&gif_sysctl); 250 } 251 252 return error; 253 } 254 255 static int 256 gif_clone_create(struct if_clone *ifc, int unit) 257 { 258 struct gif_softc *sc; 259 struct gif_variant *var; 260 int rv; 261 262 sc = kmem_zalloc(sizeof(struct gif_softc), KM_SLEEP); 263 264 if_initname(&sc->gif_if, ifc->ifc_name, unit); 265 266 rv = gifattach0(sc); 267 if (rv != 0) { 268 kmem_free(sc, sizeof(struct gif_softc)); 269 return rv; 270 } 271 272 var = kmem_zalloc(sizeof(*var), KM_SLEEP); 273 var->gv_softc = sc; 274 psref_target_init(&var->gv_psref, gv_psref_class); 275 276 sc->gif_var = var; 277 mutex_init(&sc->gif_lock, MUTEX_DEFAULT, IPL_NONE); 278 sc->gif_ro_percpu = percpu_alloc(sizeof(struct gif_ro)); 279 percpu_foreach(sc->gif_ro_percpu, gif_ro_init_pc, NULL); 280 281 mutex_enter(&gif_softcs.lock); 282 LIST_INSERT_HEAD(&gif_softcs.list, sc, gif_list); 283 mutex_exit(&gif_softcs.lock); 284 return 0; 285 } 286 287 static int 288 gifattach0(struct gif_softc *sc) 289 { 290 int rv; 291 292 sc->gif_if.if_addrlen = 0; 293 sc->gif_if.if_mtu = GIF_MTU; 294 sc->gif_if.if_flags = IFF_POINTOPOINT | IFF_MULTICAST; 295 sc->gif_if.if_extflags = IFEF_NO_LINK_STATE_CHANGE; 296 #ifdef GIF_MPSAFE 297 sc->gif_if.if_extflags |= IFEF_MPSAFE; 298 #endif 299 sc->gif_if.if_ioctl = gif_ioctl; 300 sc->gif_if.if_output = gif_output; 301 sc->gif_if.if_start = gif_start; 302 sc->gif_if.if_transmit = gif_transmit; 303 sc->gif_if.if_type = IFT_GIF; 304 sc->gif_if.if_dlt = DLT_NULL; 305 sc->gif_if.if_softc = sc; 306 IFQ_SET_READY(&sc->gif_if.if_snd); 307 rv = if_initialize(&sc->gif_if); 308 if (rv != 0) 309 return rv; 310 311 if_register(&sc->gif_if); 312 if_alloc_sadl(&sc->gif_if); 313 bpf_attach(&sc->gif_if, DLT_NULL, sizeof(u_int)); 314 return 0; 315 } 316 317 static void 318 gif_ro_init_pc(void *p, void *arg __unused, struct cpu_info *ci __unused) 319 { 320 struct gif_ro *gro = p; 321 322 mutex_init(&gro->gr_lock, MUTEX_DEFAULT, IPL_NONE); 323 } 324 325 static void 326 gif_ro_fini_pc(void *p, void *arg __unused, struct cpu_info *ci __unused) 327 { 328 struct gif_ro *gro = p; 329 330 rtcache_free(&gro->gr_ro); 331 332 mutex_destroy(&gro->gr_lock); 333 } 334 335 void 336 gif_rtcache_free_pc(void *p, void *arg __unused, struct cpu_info *ci __unused) 337 { 338 struct gif_ro *gro = p; 339 340 rtcache_free(&gro->gr_ro); 341 } 342 343 static int 344 gif_clone_destroy(struct ifnet *ifp) 345 { 346 struct gif_softc *sc = (void *) ifp; 347 struct gif_variant *var; 348 349 LIST_REMOVE(sc, gif_list); 350 351 gif_delete_tunnel(&sc->gif_if); 352 bpf_detach(ifp); 353 if_detach(ifp); 354 355 percpu_foreach(sc->gif_ro_percpu, gif_ro_fini_pc, NULL); 356 percpu_free(sc->gif_ro_percpu, sizeof(struct gif_ro)); 357 358 mutex_destroy(&sc->gif_lock); 359 360 var = sc->gif_var; 361 kmem_free(var, sizeof(*var)); 362 kmem_free(sc, sizeof(struct gif_softc)); 363 364 return 0; 365 } 366 367 #ifdef GIF_ENCAPCHECK 368 int 369 gif_encapcheck(struct mbuf *m, int off, int proto, void *arg) 370 { 371 struct ip ip; 372 struct gif_softc *sc; 373 struct gif_variant *var; 374 struct psref psref; 375 int ret = 0; 376 377 sc = arg; 378 if (sc == NULL) 379 return 0; 380 381 if ((sc->gif_if.if_flags & IFF_UP) == 0) 382 return 0; 383 384 var = gif_getref_variant(sc, &psref); 385 /* no physical address */ 386 if (var->gv_psrc == NULL || var->gv_pdst == NULL) 387 goto out; 388 389 switch (proto) { 390 #ifdef INET 391 case IPPROTO_IPV4: 392 break; 393 #endif 394 #ifdef INET6 395 case IPPROTO_IPV6: 396 break; 397 #endif 398 default: 399 goto out; 400 } 401 402 /* Bail on short packets */ 403 KASSERT(m->m_flags & M_PKTHDR); 404 if (m->m_pkthdr.len < sizeof(ip)) 405 goto out; 406 407 m_copydata(m, 0, sizeof(ip), &ip); 408 409 switch (ip.ip_v) { 410 #ifdef INET 411 case 4: 412 if (var->gv_psrc->sa_family != AF_INET || 413 var->gv_pdst->sa_family != AF_INET) 414 goto out; 415 ret = gif_encapcheck4(m, off, proto, var); 416 break; 417 #endif 418 #ifdef INET6 419 case 6: 420 if (m->m_pkthdr.len < sizeof(struct ip6_hdr)) 421 goto out; 422 if (var->gv_psrc->sa_family != AF_INET6 || 423 var->gv_pdst->sa_family != AF_INET6) 424 goto out; 425 ret = gif_encapcheck6(m, off, proto, var); 426 break; 427 #endif 428 default: 429 goto out; 430 } 431 432 out: 433 gif_putref_variant(var, &psref); 434 return ret; 435 } 436 #endif 437 438 /* 439 * gif may cause infinite recursion calls when misconfigured. 440 * We'll prevent this by introducing upper limit. 441 */ 442 static int 443 gif_check_nesting(struct ifnet *ifp, struct mbuf *m) 444 { 445 446 return if_tunnel_check_nesting(ifp, m, max_gif_nesting); 447 } 448 449 static int 450 gif_output(struct ifnet *ifp, struct mbuf *m, const struct sockaddr *dst, 451 const struct rtentry *rt) 452 { 453 struct gif_softc *sc = ifp->if_softc; 454 struct gif_variant *var = NULL; 455 struct psref psref; 456 int error = 0; 457 458 IFQ_CLASSIFY(&ifp->if_snd, m, dst->sa_family); 459 460 if ((error = gif_check_nesting(ifp, m)) != 0) { 461 m_free(m); 462 goto end; 463 } 464 465 if ((ifp->if_flags & IFF_UP) == 0) { 466 m_freem(m); 467 error = ENETDOWN; 468 goto end; 469 } 470 471 var = gif_getref_variant(sc, &psref); 472 if (var->gv_psrc == NULL || var->gv_pdst == NULL) { 473 m_freem(m); 474 error = ENETDOWN; 475 goto end; 476 } 477 /* XXX should we check if our outer source is legal? */ 478 479 m->m_flags &= ~(M_BCAST|M_MCAST); 480 481 /* use DLT_NULL encapsulation here to pass inner af type */ 482 M_PREPEND(m, sizeof(int), M_DONTWAIT); 483 if (!m) { 484 error = ENOBUFS; 485 goto end; 486 } 487 *mtod(m, int *) = dst->sa_family; 488 489 /* Clear checksum-offload flags. */ 490 m->m_pkthdr.csum_flags = 0; 491 m->m_pkthdr.csum_data = 0; 492 493 error = gif_transmit_direct(var, m); 494 end: 495 if (var != NULL) 496 gif_putref_variant(var, &psref); 497 if (error) 498 ifp->if_oerrors++; 499 return error; 500 } 501 502 static void 503 gif_start(struct ifnet *ifp) 504 { 505 struct gif_softc *sc; 506 struct gif_variant *var; 507 struct mbuf *m; 508 struct psref psref; 509 int family; 510 int len; 511 int error; 512 513 sc = ifp->if_softc; 514 var = gif_getref_variant(sc, &psref); 515 516 KASSERT(var->gv_output != NULL); 517 518 /* output processing */ 519 while (1) { 520 IFQ_DEQUEUE(&sc->gif_if.if_snd, m); 521 if (m == NULL) 522 break; 523 524 /* grab and chop off inner af type */ 525 if (sizeof(int) > m->m_len) { 526 m = m_pullup(m, sizeof(int)); 527 if (!m) { 528 ifp->if_oerrors++; 529 continue; 530 } 531 } 532 family = *mtod(m, int *); 533 bpf_mtap(ifp, m); 534 m_adj(m, sizeof(int)); 535 536 len = m->m_pkthdr.len; 537 538 error = var->gv_output(var, family, m); 539 if (error) 540 ifp->if_oerrors++; 541 else { 542 ifp->if_opackets++; 543 ifp->if_obytes += len; 544 } 545 } 546 547 gif_putref_variant(var, &psref); 548 } 549 550 static int 551 gif_transmit(struct ifnet *ifp, struct mbuf *m) 552 { 553 struct gif_softc *sc; 554 struct gif_variant *var; 555 struct psref psref; 556 int error; 557 558 sc = ifp->if_softc; 559 560 /* output processing */ 561 if (m == NULL) 562 return EINVAL; 563 564 var = gif_getref_variant(sc, &psref); 565 error = gif_transmit_direct(var, m); 566 gif_putref_variant(var, &psref); 567 568 return error; 569 } 570 571 static int 572 gif_transmit_direct(struct gif_variant *var, struct mbuf *m) 573 { 574 struct ifnet *ifp = &var->gv_softc->gif_if; 575 int error; 576 int family; 577 int len; 578 579 KASSERT(gif_heldref_variant(var)); 580 KASSERT(var->gv_output != NULL); 581 582 /* grab and chop off inner af type */ 583 if (sizeof(int) > m->m_len) { 584 m = m_pullup(m, sizeof(int)); 585 if (!m) { 586 ifp->if_oerrors++; 587 return ENOBUFS; 588 } 589 } 590 family = *mtod(m, int *); 591 bpf_mtap(ifp, m); 592 m_adj(m, sizeof(int)); 593 594 len = m->m_pkthdr.len; 595 596 error = var->gv_output(var, family, m); 597 if (error) 598 ifp->if_oerrors++; 599 else { 600 ifp->if_opackets++; 601 ifp->if_obytes += len; 602 } 603 604 return error; 605 } 606 607 void 608 gif_input(struct mbuf *m, int af, struct ifnet *ifp) 609 { 610 pktqueue_t *pktq; 611 size_t pktlen; 612 613 if (ifp == NULL) { 614 /* just in case */ 615 m_freem(m); 616 return; 617 } 618 619 m_set_rcvif(m, ifp); 620 pktlen = m->m_pkthdr.len; 621 622 bpf_mtap_af(ifp, af, m); 623 624 /* 625 * Put the packet to the network layer input queue according to the 626 * specified address family. Note: we avoid direct call to the 627 * input function of the network layer in order to avoid recursion. 628 * This may be revisited in the future. 629 */ 630 switch (af) { 631 #ifdef INET 632 case AF_INET: 633 pktq = ip_pktq; 634 break; 635 #endif 636 #ifdef INET6 637 case AF_INET6: 638 pktq = ip6_pktq; 639 break; 640 #endif 641 default: 642 m_freem(m); 643 return; 644 } 645 646 #ifdef GIF_MPSAFE 647 const u_int h = curcpu()->ci_index; 648 #else 649 const uint32_t h = pktq_rps_hash(m); 650 #endif 651 if (__predict_true(pktq_enqueue(pktq, m, h))) { 652 ifp->if_ibytes += pktlen; 653 ifp->if_ipackets++; 654 } else { 655 m_freem(m); 656 } 657 } 658 659 /* XXX how should we handle IPv6 scope on SIOC[GS]IFPHYADDR? */ 660 static int 661 gif_ioctl(struct ifnet *ifp, u_long cmd, void *data) 662 { 663 struct gif_softc *sc = ifp->if_softc; 664 struct ifreq *ifr = (struct ifreq*)data; 665 struct ifaddr *ifa = (struct ifaddr*)data; 666 int error = 0, size, bound; 667 struct sockaddr *dst, *src; 668 struct gif_variant *var; 669 struct psref psref; 670 671 switch (cmd) { 672 case SIOCINITIFADDR: 673 ifp->if_flags |= IFF_UP; 674 ifa->ifa_rtrequest = p2p_rtrequest; 675 break; 676 677 case SIOCADDMULTI: 678 case SIOCDELMULTI: 679 switch (ifr->ifr_addr.sa_family) { 680 #ifdef INET 681 case AF_INET: /* IP supports Multicast */ 682 break; 683 #endif /* INET */ 684 #ifdef INET6 685 case AF_INET6: /* IP6 supports Multicast */ 686 break; 687 #endif /* INET6 */ 688 default: /* Other protocols doesn't support Multicast */ 689 error = EAFNOSUPPORT; 690 break; 691 } 692 break; 693 694 case SIOCSIFMTU: 695 if (ifr->ifr_mtu < GIF_MTU_MIN || ifr->ifr_mtu > GIF_MTU_MAX) 696 return EINVAL; 697 else if ((error = ifioctl_common(ifp, cmd, data)) == ENETRESET) 698 error = 0; 699 break; 700 701 #ifdef INET 702 case SIOCSIFPHYADDR: 703 #endif 704 #ifdef INET6 705 case SIOCSIFPHYADDR_IN6: 706 #endif /* INET6 */ 707 case SIOCSLIFPHYADDR: 708 switch (cmd) { 709 #ifdef INET 710 case SIOCSIFPHYADDR: 711 src = (struct sockaddr *) 712 &(((struct in_aliasreq *)data)->ifra_addr); 713 dst = (struct sockaddr *) 714 &(((struct in_aliasreq *)data)->ifra_dstaddr); 715 break; 716 #endif 717 #ifdef INET6 718 case SIOCSIFPHYADDR_IN6: 719 src = (struct sockaddr *) 720 &(((struct in6_aliasreq *)data)->ifra_addr); 721 dst = (struct sockaddr *) 722 &(((struct in6_aliasreq *)data)->ifra_dstaddr); 723 break; 724 #endif 725 case SIOCSLIFPHYADDR: 726 src = (struct sockaddr *) 727 &(((struct if_laddrreq *)data)->addr); 728 dst = (struct sockaddr *) 729 &(((struct if_laddrreq *)data)->dstaddr); 730 break; 731 default: 732 return EINVAL; 733 } 734 735 /* sa_family must be equal */ 736 if (src->sa_family != dst->sa_family) 737 return EINVAL; 738 739 /* validate sa_len */ 740 switch (src->sa_family) { 741 #ifdef INET 742 case AF_INET: 743 if (src->sa_len != sizeof(struct sockaddr_in)) 744 return EINVAL; 745 break; 746 #endif 747 #ifdef INET6 748 case AF_INET6: 749 if (src->sa_len != sizeof(struct sockaddr_in6)) 750 return EINVAL; 751 break; 752 #endif 753 default: 754 return EAFNOSUPPORT; 755 } 756 switch (dst->sa_family) { 757 #ifdef INET 758 case AF_INET: 759 if (dst->sa_len != sizeof(struct sockaddr_in)) 760 return EINVAL; 761 break; 762 #endif 763 #ifdef INET6 764 case AF_INET6: 765 if (dst->sa_len != sizeof(struct sockaddr_in6)) 766 return EINVAL; 767 break; 768 #endif 769 default: 770 return EAFNOSUPPORT; 771 } 772 773 /* check sa_family looks sane for the cmd */ 774 switch (cmd) { 775 case SIOCSIFPHYADDR: 776 if (src->sa_family == AF_INET) 777 break; 778 return EAFNOSUPPORT; 779 #ifdef INET6 780 case SIOCSIFPHYADDR_IN6: 781 if (src->sa_family == AF_INET6) 782 break; 783 return EAFNOSUPPORT; 784 #endif /* INET6 */ 785 case SIOCSLIFPHYADDR: 786 /* checks done in the above */ 787 break; 788 } 789 /* 790 * calls gif_getref_variant() for other softcs to check 791 * address pair duplicattion 792 */ 793 bound = curlwp_bind(); 794 error = gif_set_tunnel(&sc->gif_if, src, dst); 795 curlwp_bindx(bound); 796 break; 797 798 #ifdef SIOCDIFPHYADDR 799 case SIOCDIFPHYADDR: 800 bound = curlwp_bind(); 801 gif_delete_tunnel(&sc->gif_if); 802 curlwp_bindx(bound); 803 break; 804 #endif 805 806 case SIOCGIFPSRCADDR: 807 #ifdef INET6 808 case SIOCGIFPSRCADDR_IN6: 809 #endif /* INET6 */ 810 bound = curlwp_bind(); 811 var = gif_getref_variant(sc, &psref); 812 if (var->gv_psrc == NULL) { 813 gif_putref_variant(var, &psref); 814 curlwp_bindx(bound); 815 error = EADDRNOTAVAIL; 816 goto bad; 817 } 818 src = var->gv_psrc; 819 switch (cmd) { 820 #ifdef INET 821 case SIOCGIFPSRCADDR: 822 dst = &ifr->ifr_addr; 823 size = sizeof(ifr->ifr_addr); 824 break; 825 #endif /* INET */ 826 #ifdef INET6 827 case SIOCGIFPSRCADDR_IN6: 828 dst = (struct sockaddr *) 829 &(((struct in6_ifreq *)data)->ifr_addr); 830 size = sizeof(((struct in6_ifreq *)data)->ifr_addr); 831 break; 832 #endif /* INET6 */ 833 default: 834 gif_putref_variant(var, &psref); 835 curlwp_bindx(bound); 836 error = EADDRNOTAVAIL; 837 goto bad; 838 } 839 if (src->sa_len > size) { 840 gif_putref_variant(var, &psref); 841 curlwp_bindx(bound); 842 return EINVAL; 843 } 844 memcpy(dst, src, src->sa_len); 845 gif_putref_variant(var, &psref); 846 curlwp_bindx(bound); 847 break; 848 849 case SIOCGIFPDSTADDR: 850 #ifdef INET6 851 case SIOCGIFPDSTADDR_IN6: 852 #endif /* INET6 */ 853 bound = curlwp_bind(); 854 var = gif_getref_variant(sc, &psref); 855 if (var->gv_pdst == NULL) { 856 gif_putref_variant(var, &psref); 857 curlwp_bindx(bound); 858 error = EADDRNOTAVAIL; 859 goto bad; 860 } 861 src = var->gv_pdst; 862 switch (cmd) { 863 #ifdef INET 864 case SIOCGIFPDSTADDR: 865 dst = &ifr->ifr_addr; 866 size = sizeof(ifr->ifr_addr); 867 break; 868 #endif /* INET */ 869 #ifdef INET6 870 case SIOCGIFPDSTADDR_IN6: 871 dst = (struct sockaddr *) 872 &(((struct in6_ifreq *)data)->ifr_addr); 873 size = sizeof(((struct in6_ifreq *)data)->ifr_addr); 874 break; 875 #endif /* INET6 */ 876 default: 877 gif_putref_variant(var, &psref); 878 curlwp_bindx(bound); 879 error = EADDRNOTAVAIL; 880 goto bad; 881 } 882 if (src->sa_len > size) { 883 gif_putref_variant(var, &psref); 884 curlwp_bindx(bound); 885 return EINVAL; 886 } 887 memcpy(dst, src, src->sa_len); 888 gif_putref_variant(var, &psref); 889 curlwp_bindx(bound); 890 break; 891 892 case SIOCGLIFPHYADDR: 893 bound = curlwp_bind(); 894 var = gif_getref_variant(sc, &psref); 895 if (var->gv_psrc == NULL || var->gv_pdst == NULL) { 896 gif_putref_variant(var, &psref); 897 curlwp_bindx(bound); 898 error = EADDRNOTAVAIL; 899 goto bad; 900 } 901 902 /* copy src */ 903 src = var->gv_psrc; 904 dst = (struct sockaddr *) 905 &(((struct if_laddrreq *)data)->addr); 906 size = sizeof(((struct if_laddrreq *)data)->addr); 907 if (src->sa_len > size) { 908 gif_putref_variant(var, &psref); 909 curlwp_bindx(bound); 910 return EINVAL; 911 } 912 memcpy(dst, src, src->sa_len); 913 914 /* copy dst */ 915 src = var->gv_pdst; 916 dst = (struct sockaddr *) 917 &(((struct if_laddrreq *)data)->dstaddr); 918 size = sizeof(((struct if_laddrreq *)data)->dstaddr); 919 if (src->sa_len > size) { 920 gif_putref_variant(var, &psref); 921 curlwp_bindx(bound); 922 return EINVAL; 923 } 924 memcpy(dst, src, src->sa_len); 925 gif_putref_variant(var, &psref); 926 curlwp_bindx(bound); 927 break; 928 929 default: 930 return ifioctl_common(ifp, cmd, data); 931 } 932 bad: 933 return error; 934 } 935 936 static int 937 gif_encap_attach(struct gif_variant *var) 938 { 939 int error; 940 941 if (var == NULL || var->gv_psrc == NULL) 942 return EINVAL; 943 944 switch (var->gv_psrc->sa_family) { 945 #ifdef INET 946 case AF_INET: 947 error = in_gif_attach(var); 948 break; 949 #endif 950 #ifdef INET6 951 case AF_INET6: 952 error = in6_gif_attach(var); 953 break; 954 #endif 955 default: 956 error = EINVAL; 957 break; 958 } 959 960 return error; 961 } 962 963 static int 964 gif_encap_detach(struct gif_variant *var) 965 { 966 int error; 967 968 if (var == NULL || var->gv_psrc == NULL) 969 return EINVAL; 970 971 switch (var->gv_psrc->sa_family) { 972 #ifdef INET 973 case AF_INET: 974 error = in_gif_detach(var); 975 break; 976 #endif 977 #ifdef INET6 978 case AF_INET6: 979 error = in6_gif_detach(var); 980 break; 981 #endif 982 default: 983 error = EINVAL; 984 break; 985 } 986 987 return error; 988 } 989 990 static int 991 gif_set_tunnel(struct ifnet *ifp, struct sockaddr *src, struct sockaddr *dst) 992 { 993 struct gif_softc *sc = ifp->if_softc; 994 struct gif_softc *sc2; 995 struct gif_variant *ovar, *nvar; 996 struct sockaddr *osrc, *odst; 997 struct sockaddr *nsrc, *ndst; 998 int error; 999 #ifndef GIF_MPSAFE 1000 int s; 1001 1002 s = splsoftnet(); 1003 #endif 1004 error = encap_lock_enter(); 1005 if (error) { 1006 #ifndef GIF_MPSAFE 1007 splx(s); 1008 #endif 1009 return error; 1010 } 1011 1012 nsrc = sockaddr_dup(src, M_WAITOK); 1013 ndst = sockaddr_dup(dst, M_WAITOK); 1014 nvar = kmem_alloc(sizeof(*nvar), KM_SLEEP); 1015 1016 mutex_enter(&sc->gif_lock); 1017 1018 ovar = sc->gif_var; 1019 1020 if ((ovar->gv_pdst && sockaddr_cmp(ovar->gv_pdst, dst) == 0) && 1021 (ovar->gv_psrc && sockaddr_cmp(ovar->gv_psrc, src) == 0)) { 1022 /* address and port pair not changed. */ 1023 error = 0; 1024 goto out; 1025 } 1026 1027 mutex_enter(&gif_softcs.lock); 1028 LIST_FOREACH(sc2, &gif_softcs.list, gif_list) { 1029 struct gif_variant *var2; 1030 struct psref psref; 1031 1032 if (sc2 == sc) 1033 continue; 1034 var2 = gif_getref_variant(sc, &psref); 1035 if (!var2->gv_pdst || !var2->gv_psrc) { 1036 gif_putref_variant(var2, &psref); 1037 continue; 1038 } 1039 /* can't configure same pair of address onto two gifs */ 1040 if (sockaddr_cmp(var2->gv_pdst, dst) == 0 && 1041 sockaddr_cmp(var2->gv_psrc, src) == 0) { 1042 /* continue to use the old configureation. */ 1043 gif_putref_variant(var2, &psref); 1044 mutex_exit(&gif_softcs.lock); 1045 error = EADDRNOTAVAIL; 1046 goto out; 1047 } 1048 gif_putref_variant(var2, &psref); 1049 /* XXX both end must be valid? (I mean, not 0.0.0.0) */ 1050 } 1051 mutex_exit(&gif_softcs.lock); 1052 1053 osrc = ovar->gv_psrc; 1054 odst = ovar->gv_pdst; 1055 1056 *nvar = *ovar; 1057 nvar->gv_psrc = nsrc; 1058 nvar->gv_pdst = ndst; 1059 nvar->gv_encap_cookie4 = NULL; 1060 nvar->gv_encap_cookie6 = NULL; 1061 error = gif_encap_attach(nvar); 1062 if (error) 1063 goto out; 1064 psref_target_init(&nvar->gv_psref, gv_psref_class); 1065 membar_producer(); 1066 gif_update_variant(sc, nvar); 1067 1068 mutex_exit(&sc->gif_lock); 1069 1070 (void)gif_encap_detach(ovar); 1071 encap_lock_exit(); 1072 1073 if (osrc) 1074 sockaddr_free(osrc); 1075 if (odst) 1076 sockaddr_free(odst); 1077 kmem_free(ovar, sizeof(*ovar)); 1078 1079 #ifndef GIF_MPSAFE 1080 splx(s); 1081 #endif 1082 return 0; 1083 1084 out: 1085 sockaddr_free(nsrc); 1086 sockaddr_free(ndst); 1087 kmem_free(nvar, sizeof(*nvar)); 1088 1089 mutex_exit(&sc->gif_lock); 1090 encap_lock_exit(); 1091 #ifndef GIF_MPSAFE 1092 splx(s); 1093 #endif 1094 return error; 1095 } 1096 1097 static void 1098 gif_delete_tunnel(struct ifnet *ifp) 1099 { 1100 struct gif_softc *sc = ifp->if_softc; 1101 struct gif_variant *ovar, *nvar; 1102 struct sockaddr *osrc, *odst; 1103 int error; 1104 #ifndef GIF_MPSAFE 1105 int s; 1106 1107 s = splsoftnet(); 1108 #endif 1109 error = encap_lock_enter(); 1110 if (error) { 1111 #ifndef GIF_MPSAFE 1112 splx(s); 1113 #endif 1114 return; 1115 } 1116 1117 nvar = kmem_alloc(sizeof(*nvar), KM_SLEEP); 1118 1119 mutex_enter(&sc->gif_lock); 1120 1121 ovar = sc->gif_var; 1122 osrc = ovar->gv_psrc; 1123 odst = ovar->gv_pdst; 1124 if (osrc == NULL || odst == NULL) { 1125 /* address pair not changed. */ 1126 mutex_exit(&sc->gif_lock); 1127 encap_lock_exit(); 1128 kmem_free(nvar, sizeof(*nvar)); 1129 return; 1130 } 1131 1132 *nvar = *ovar; 1133 nvar->gv_psrc = NULL; 1134 nvar->gv_pdst = NULL; 1135 nvar->gv_encap_cookie4 = NULL; 1136 nvar->gv_encap_cookie6 = NULL; 1137 nvar->gv_output = NULL; 1138 psref_target_init(&nvar->gv_psref, gv_psref_class); 1139 membar_producer(); 1140 gif_update_variant(sc, nvar); 1141 1142 mutex_exit(&sc->gif_lock); 1143 1144 gif_encap_detach(ovar); 1145 encap_lock_exit(); 1146 1147 sockaddr_free(osrc); 1148 sockaddr_free(odst); 1149 kmem_free(ovar, sizeof(*ovar)); 1150 1151 #ifndef GIF_MPSAFE 1152 splx(s); 1153 #endif 1154 } 1155 1156 /* 1157 * gif_variant update API. 1158 * 1159 * Assumption: 1160 * reader side dereferences sc->gif_var in reader critical section only, 1161 * that is, all of reader sides do not reader the sc->gif_var after 1162 * pserialize_perform(). 1163 */ 1164 static void 1165 gif_update_variant(struct gif_softc *sc, struct gif_variant *nvar) 1166 { 1167 struct ifnet *ifp = &sc->gif_if; 1168 struct gif_variant *ovar = sc->gif_var; 1169 1170 KASSERT(mutex_owned(&sc->gif_lock)); 1171 1172 sc->gif_var = nvar; 1173 pserialize_perform(gif_psz); 1174 psref_target_destroy(&ovar->gv_psref, gv_psref_class); 1175 1176 if (nvar->gv_psrc != NULL && nvar->gv_pdst != NULL) 1177 ifp->if_flags |= IFF_RUNNING; 1178 else 1179 ifp->if_flags &= ~IFF_RUNNING; 1180 } 1181 1182 /* 1183 * Module infrastructure 1184 */ 1185 #include "if_module.h" 1186 1187 IF_MODULE(MODULE_CLASS_DRIVER, gif, "ip_ecn") 1188
Indexes created Wed Sep 24 14:09:57 GMT 2025