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