1 /* $NetBSD: if_gre.c,v 1.187 2025/07/16 19:14:14 kre Exp $ */ 2 3 /* 4 * Copyright (c) 1998, 2008 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Heiko W.Rupp <hwr (at) pilhuhn.de> 9 * 10 * IPv6-over-GRE contributed by Gert Doering <gert (at) greenie.muc.de> 11 * 12 * GRE over UDP/IPv4/IPv6 sockets contributed by David Young <dyoung (at) NetBSD.org> 13 * 14 * Redistribution and use in source and binary forms, with or without 15 * modification, are permitted provided that the following conditions 16 * are met: 17 * 1. Redistributions of source code must retain the above copyright 18 * notice, this list of conditions and the following disclaimer. 19 * 2. Redistributions in binary form must reproduce the above copyright 20 * notice, this list of conditions and the following disclaimer in the 21 * documentation and/or other materials provided with the distribution. 22 * 23 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 24 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 25 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 26 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 27 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 28 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 29 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 30 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 31 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 32 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 33 * POSSIBILITY OF SUCH DAMAGE. 34 * 35 * This material is based upon work partially supported by NSF 36 * under Contract No. NSF CNS-0626584. 37 */ 38 39 /* 40 * Encapsulate L3 protocols into IP 41 * See RFC 1701 and 1702 for more details. 42 * If_gre is compatible with Cisco GRE tunnels, so you can 43 * have a NetBSD box as the other end of a tunnel interface of a Cisco 44 * router. See gre(4) for more details. 45 */ 46 47 #include <sys/cdefs.h> 48 __KERNEL_RCSID(0, "$NetBSD: if_gre.c,v 1.187 2025/07/16 19:14:14 kre Exp $"); 49 50 #ifdef _KERNEL_OPT 51 #include "opt_atalk.h" 52 #include "opt_gre.h" 53 #include "opt_inet.h" 54 #include "opt_mpls.h" 55 #endif 56 57 #include <sys/param.h> 58 #include <sys/file.h> 59 #include <sys/filedesc.h> 60 #include <sys/malloc.h> 61 #include <sys/mallocvar.h> 62 #include <sys/mbuf.h> 63 #include <sys/proc.h> 64 #include <sys/domain.h> 65 #include <sys/protosw.h> 66 #include <sys/socket.h> 67 #include <sys/socketvar.h> 68 #include <sys/ioctl.h> 69 #include <sys/queue.h> 70 #include <sys/intr.h> 71 #include <sys/systm.h> 72 #include <sys/sysctl.h> 73 #include <sys/kauth.h> 74 #include <sys/device.h> 75 #include <sys/module.h> 76 77 #include <sys/kernel.h> 78 #include <sys/mutex.h> 79 #include <sys/condvar.h> 80 #include <sys/kthread.h> 81 82 #include <sys/cpu.h> 83 84 #include <net/ethertypes.h> 85 #include <net/if.h> 86 #include <net/if_types.h> 87 #include <net/route.h> 88 #include <sys/device.h> 89 #include <sys/module.h> 90 #include <sys/atomic.h> 91 92 #include <netinet/in_systm.h> 93 #include <netinet/in.h> 94 #include <netinet/ip.h> /* we always need this for sizeof(struct ip) */ 95 96 #ifdef INET 97 #include <netinet/in_var.h> 98 #include <netinet/ip_var.h> 99 #endif 100 101 #ifdef INET6 102 #include <netinet6/in6_var.h> 103 #endif 104 105 #ifdef MPLS 106 #include <netmpls/mpls.h> 107 #include <netmpls/mpls_var.h> 108 #endif 109 110 #ifdef NETATALK 111 #include <netatalk/at.h> 112 #include <netatalk/at_var.h> 113 #include <netatalk/at_extern.h> 114 #endif 115 116 #include <sys/time.h> 117 #include <net/bpf.h> 118 119 #include <net/if_gre.h> 120 121 #include "ioconf.h" 122 123 /* 124 * It is not easy to calculate the right value for a GRE MTU. 125 * We leave this task to the admin and use the same default that 126 * other vendors use. 127 */ 128 #define GREMTU 1476 129 130 #ifdef GRE_DEBUG 131 int gre_debug = 0; 132 #define GRE_DPRINTF(__sc, ...) \ 133 do { \ 134 if (__predict_false(gre_debug || \ 135 ((__sc)->sc_if.if_flags & IFF_DEBUG) != 0)) { \ 136 printf("%s.%d: ", __func__, __LINE__); \ 137 printf(__VA_ARGS__); \ 138 } \ 139 } while (/*CONSTCOND*/0) 140 #else 141 #define GRE_DPRINTF(__sc, __fmt, ...) do { } while (/*CONSTCOND*/0) 142 #endif /* GRE_DEBUG */ 143 144 CTASSERT(sizeof(struct gre_h) == 4); 145 146 int ip_gre_ttl = GRE_TTL; 147 148 static u_int gre_count; 149 150 static int gre_clone_create(struct if_clone *, int); 151 static int gre_clone_destroy(struct ifnet *); 152 153 static struct if_clone gre_cloner = 154 IF_CLONE_INITIALIZER("gre", gre_clone_create, gre_clone_destroy); 155 156 static int gre_input(struct gre_softc *, struct mbuf *, const struct gre_h *); 157 static bool gre_is_nullconf(const struct gre_soparm *); 158 static int gre_output(struct ifnet *, struct mbuf *, 159 const struct sockaddr *, const struct rtentry *); 160 static int gre_ioctl(struct ifnet *, u_long, void *); 161 static int gre_getsockname(struct socket *, struct sockaddr *); 162 static int gre_getpeername(struct socket *, struct sockaddr *); 163 static int gre_getnames(struct socket *, struct lwp *, 164 struct sockaddr_storage *, struct sockaddr_storage *); 165 static void gre_clearconf(struct gre_soparm *, bool); 166 static int gre_soreceive(struct socket *, struct mbuf **); 167 static int gre_sosend(struct socket *, struct mbuf *); 168 static struct socket *gre_reconf(struct gre_softc *, const struct gre_soparm *); 169 170 static bool gre_fp_send(struct gre_softc *, enum gre_msg, file_t *); 171 static bool gre_fp_recv(struct gre_softc *); 172 static void gre_fp_recvloop(void *); 173 174 static void 175 gre_bufq_init(struct gre_bufq *bq, size_t len0) 176 { 177 memset(bq, 0, sizeof(*bq)); 178 bq->bq_q = pcq_create(len0, KM_SLEEP); 179 KASSERT(bq->bq_q != NULL); 180 } 181 182 static struct mbuf * 183 gre_bufq_dequeue(struct gre_bufq *bq) 184 { 185 return pcq_get(bq->bq_q); 186 } 187 188 static void 189 gre_bufq_purge(struct gre_bufq *bq) 190 { 191 struct mbuf *m; 192 193 while ((m = gre_bufq_dequeue(bq)) != NULL) 194 m_freem(m); 195 } 196 197 static void 198 gre_bufq_destroy(struct gre_bufq *bq) 199 { 200 gre_bufq_purge(bq); 201 pcq_destroy(bq->bq_q); 202 } 203 204 static int 205 gre_bufq_enqueue(struct gre_bufq *bq, struct mbuf *m) 206 { 207 KASSERT(bq->bq_q != NULL); 208 209 if (!pcq_put(bq->bq_q, m)) { 210 bq->bq_drops++; 211 return ENOBUFS; 212 } 213 return 0; 214 } 215 216 static void 217 greintr(void *arg) 218 { 219 struct gre_softc *sc = (struct gre_softc *)arg; 220 struct socket *so = sc->sc_soparm.sp_so; 221 int rc; 222 struct mbuf *m; 223 224 KASSERT(so != NULL); 225 226 sc->sc_send_ev.ev_count++; 227 GRE_DPRINTF(sc, "enter\n"); 228 while ((m = gre_bufq_dequeue(&sc->sc_snd)) != NULL) { 229 /* XXX handle ENOBUFS? */ 230 if ((rc = gre_sosend(so, m)) != 0) 231 GRE_DPRINTF(sc, "gre_sosend failed %d\n", rc); 232 } 233 } 234 235 /* Caller must hold sc->sc_mtx. */ 236 static void 237 gre_fp_wait(struct gre_softc *sc) 238 { 239 sc->sc_fp_waiters++; 240 cv_wait(&sc->sc_fp_condvar, &sc->sc_mtx); 241 sc->sc_fp_waiters--; 242 } 243 244 static void 245 gre_evcnt_detach(struct gre_softc *sc) 246 { 247 evcnt_detach(&sc->sc_recv_ev); 248 evcnt_detach(&sc->sc_block_ev); 249 evcnt_detach(&sc->sc_error_ev); 250 evcnt_detach(&sc->sc_pullup_ev); 251 evcnt_detach(&sc->sc_unsupp_ev); 252 253 evcnt_detach(&sc->sc_send_ev); 254 evcnt_detach(&sc->sc_oflow_ev); 255 } 256 257 static void 258 gre_evcnt_attach(struct gre_softc *sc) 259 { 260 evcnt_attach_dynamic(&sc->sc_recv_ev, EVCNT_TYPE_MISC, 261 NULL, sc->sc_if.if_xname, "recv"); 262 evcnt_attach_dynamic(&sc->sc_block_ev, EVCNT_TYPE_MISC, 263 &sc->sc_recv_ev, sc->sc_if.if_xname, "would block"); 264 evcnt_attach_dynamic(&sc->sc_error_ev, EVCNT_TYPE_MISC, 265 &sc->sc_recv_ev, sc->sc_if.if_xname, "error"); 266 evcnt_attach_dynamic(&sc->sc_pullup_ev, EVCNT_TYPE_MISC, 267 &sc->sc_recv_ev, sc->sc_if.if_xname, "pullup failed"); 268 evcnt_attach_dynamic(&sc->sc_unsupp_ev, EVCNT_TYPE_MISC, 269 &sc->sc_recv_ev, sc->sc_if.if_xname, "unsupported"); 270 271 evcnt_attach_dynamic(&sc->sc_send_ev, EVCNT_TYPE_MISC, 272 NULL, sc->sc_if.if_xname, "send"); 273 evcnt_attach_dynamic(&sc->sc_oflow_ev, EVCNT_TYPE_MISC, 274 &sc->sc_send_ev, sc->sc_if.if_xname, "overflow"); 275 } 276 277 static int 278 gre_clone_create(struct if_clone *ifc, int unit) 279 { 280 int rc; 281 struct gre_softc *sc; 282 struct gre_soparm *sp; 283 const struct sockaddr *any; 284 285 if ((any = sockaddr_any_by_family(AF_INET)) == NULL && 286 (any = sockaddr_any_by_family(AF_INET6)) == NULL) 287 goto fail0; 288 289 sc = malloc(sizeof(*sc), M_DEVBUF, M_WAITOK|M_ZERO); 290 mutex_init(&sc->sc_mtx, MUTEX_DRIVER, IPL_SOFTNET); 291 cv_init(&sc->sc_condvar, "gre wait"); 292 cv_init(&sc->sc_fp_condvar, "gre fp"); 293 294 if_initname(&sc->sc_if, ifc->ifc_name, unit); 295 sc->sc_if.if_softc = sc; 296 sc->sc_if.if_type = IFT_TUNNEL; 297 sc->sc_if.if_addrlen = 0; 298 sc->sc_if.if_hdrlen = sizeof(struct ip) + sizeof(struct gre_h); 299 sc->sc_if.if_dlt = DLT_NULL; 300 sc->sc_if.if_mtu = GREMTU; 301 sc->sc_if.if_flags = IFF_POINTOPOINT|IFF_MULTICAST; 302 sc->sc_if.if_output = gre_output; 303 sc->sc_if.if_ioctl = gre_ioctl; 304 sp = &sc->sc_soparm; 305 sockaddr_copy(sstosa(&sp->sp_dst), sizeof(sp->sp_dst), any); 306 sockaddr_copy(sstosa(&sp->sp_src), sizeof(sp->sp_src), any); 307 sp->sp_proto = IPPROTO_GRE; 308 sp->sp_type = SOCK_RAW; 309 310 sc->sc_fd = -1; 311 312 rc = kthread_create(PRI_NONE, KTHREAD_MPSAFE, NULL, gre_fp_recvloop, sc, 313 NULL, "%s", sc->sc_if.if_xname); 314 if (rc) 315 goto fail1; 316 317 gre_evcnt_attach(sc); 318 319 gre_bufq_init(&sc->sc_snd, 17); 320 sc->sc_if.if_flags |= IFF_LINK0; 321 if_attach(&sc->sc_if); 322 if_alloc_sadl(&sc->sc_if); 323 bpf_attach(&sc->sc_if, DLT_NULL, sizeof(uint32_t)); 324 atomic_inc_uint(&gre_count); 325 return 0; 326 327 fail1: 328 cv_destroy(&sc->sc_fp_condvar); 329 cv_destroy(&sc->sc_condvar); 330 mutex_destroy(&sc->sc_mtx); 331 free(sc, M_DEVBUF); 332 333 fail0: 334 return -1; 335 } 336 337 static int 338 gre_clone_destroy(struct ifnet *ifp) 339 { 340 int s; 341 struct gre_softc *sc = ifp->if_softc; 342 343 GRE_DPRINTF(sc, "\n"); 344 345 bpf_detach(ifp); 346 s = splnet(); 347 if_detach(ifp); 348 349 GRE_DPRINTF(sc, "\n"); 350 /* Note that we must not hold the mutex while we call gre_reconf(). */ 351 gre_reconf(sc, NULL); 352 353 mutex_enter(&sc->sc_mtx); 354 sc->sc_msg = GRE_M_STOP; 355 cv_signal(&sc->sc_fp_condvar); 356 while (sc->sc_fp_waiters > 0) 357 cv_wait(&sc->sc_fp_condvar, &sc->sc_mtx); 358 mutex_exit(&sc->sc_mtx); 359 360 splx(s); 361 362 cv_destroy(&sc->sc_condvar); 363 cv_destroy(&sc->sc_fp_condvar); 364 mutex_destroy(&sc->sc_mtx); 365 gre_bufq_destroy(&sc->sc_snd); 366 gre_evcnt_detach(sc); 367 free(sc, M_DEVBUF); 368 369 atomic_dec_uint(&gre_count); 370 return 0; 371 } 372 373 static void 374 gre_receive(struct socket *so, void *arg, int events, int waitflag) 375 { 376 struct gre_softc *sc = (struct gre_softc *)arg; 377 int rc; 378 struct gre_h gh; 379 struct mbuf *m; 380 381 GRE_DPRINTF(sc, "enter\n"); 382 383 sc->sc_recv_ev.ev_count++; 384 385 rc = gre_soreceive(so, &m); 386 /* TBD Back off if ECONNREFUSED (indicates 387 * ICMP Port Unreachable)? 388 */ 389 if (rc == EWOULDBLOCK) { 390 GRE_DPRINTF(sc, "EWOULDBLOCK\n"); 391 sc->sc_block_ev.ev_count++; 392 return; 393 } else if (rc != 0 || m == NULL) { 394 GRE_DPRINTF(sc, "%s: rc %d m %p\n", 395 sc->sc_if.if_xname, rc, (void *)m); 396 sc->sc_error_ev.ev_count++; 397 return; 398 } 399 400 if (__predict_false(m->m_len < sizeof(gh))) { 401 if ((m = m_pullup(m, sizeof(gh))) == NULL) { 402 GRE_DPRINTF(sc, "m_pullup failed\n"); 403 sc->sc_pullup_ev.ev_count++; 404 return; 405 } 406 } 407 memcpy(&gh, mtod(m, void *), sizeof(gh)); 408 409 if (gre_input(sc, m, &gh) == 0) { 410 sc->sc_unsupp_ev.ev_count++; 411 GRE_DPRINTF(sc, "dropping unsupported\n"); 412 m_freem(m); 413 } 414 } 415 416 static void 417 gre_upcall_add(struct socket *so, void *arg) 418 { 419 /* XXX What if the kernel already set an upcall? */ 420 KASSERT((so->so_rcv.sb_flags & SB_UPCALL) == 0); 421 so->so_upcallarg = arg; 422 so->so_upcall = gre_receive; 423 so->so_rcv.sb_flags |= SB_UPCALL; 424 } 425 426 static void 427 gre_upcall_remove(struct socket *so) 428 { 429 so->so_rcv.sb_flags &= ~SB_UPCALL; 430 so->so_upcallarg = NULL; 431 so->so_upcall = NULL; 432 } 433 434 static int 435 gre_socreate(struct gre_softc *sc, const struct gre_soparm *sp, int *fdout) 436 { 437 int fd, rc; 438 file_t *fp; 439 struct socket *so; 440 struct sockaddr_big sbig; 441 sa_family_t af; 442 int val; 443 444 GRE_DPRINTF(sc, "enter\n"); 445 446 af = sp->sp_src.ss_family; 447 rc = fsocreate(af, &so, sp->sp_type, sp->sp_proto, &fd, &fp, NULL); 448 if (rc != 0) { 449 GRE_DPRINTF(sc, "fsocreate failed\n"); 450 return rc; 451 } 452 453 memcpy(&sbig, &sp->sp_src, sizeof(sp->sp_src)); 454 if ((rc = sobind(so, (struct sockaddr *)&sbig, curlwp)) != 0) { 455 GRE_DPRINTF(sc, "sobind failed\n"); 456 goto out; 457 } 458 459 memcpy(&sbig, &sp->sp_dst, sizeof(sp->sp_dst)); 460 solock(so); 461 if ((rc = soconnect(so, (struct sockaddr *)&sbig, curlwp)) != 0) { 462 GRE_DPRINTF(sc, "soconnect failed\n"); 463 sounlock(so); 464 goto out; 465 } 466 sounlock(so); 467 468 /* XXX convert to a (new) SOL_SOCKET call */ 469 KASSERT(so->so_proto != NULL); 470 rc = so_setsockopt(curlwp, so, IPPROTO_IP, IP_TTL, 471 &ip_gre_ttl, sizeof(ip_gre_ttl)); 472 if (rc != 0) { 473 GRE_DPRINTF(sc, "so_setsockopt ttl failed\n"); 474 rc = 0; 475 } 476 477 val = 1; 478 rc = so_setsockopt(curlwp, so, SOL_SOCKET, SO_NOHEADER, 479 &val, sizeof(val)); 480 if (rc != 0) { 481 GRE_DPRINTF(sc, "so_setsockopt SO_NOHEADER failed\n"); 482 rc = 0; 483 } 484 out: 485 if (rc != 0) { 486 soclose(so); 487 fd_abort(curproc, fp, fd); 488 } else { 489 fd_affix(curproc, fp, fd); 490 *fdout = fd; 491 } 492 493 return rc; 494 } 495 496 static int 497 gre_sosend(struct socket *so, struct mbuf *top) 498 { 499 struct proc *p; 500 long space, resid; 501 int error; 502 struct lwp * const l = curlwp; 503 504 p = l->l_proc; 505 506 resid = top->m_pkthdr.len; 507 if (p) 508 l->l_ru.ru_msgsnd++; 509 #define snderr(errno) { error = errno; goto release; } 510 511 solock(so); 512 if ((error = sblock(&so->so_snd, M_NOWAIT)) != 0) 513 goto out; 514 if (so->so_state & SS_CANTSENDMORE) 515 snderr(EPIPE); 516 if (so->so_error) { 517 error = so->so_error; 518 so->so_error = 0; 519 goto release; 520 } 521 if ((so->so_state & SS_ISCONNECTED) == 0) { 522 if (so->so_proto->pr_flags & PR_CONNREQUIRED) { 523 snderr(ENOTCONN); 524 } else { 525 snderr(EDESTADDRREQ); 526 } 527 } 528 space = sbspace(&so->so_snd); 529 if (resid > so->so_snd.sb_hiwat) 530 snderr(EMSGSIZE); 531 if (space < resid) 532 snderr(EWOULDBLOCK); 533 /* 534 * Data is prepackaged in "top". 535 */ 536 if (so->so_state & SS_CANTSENDMORE) 537 snderr(EPIPE); 538 error = (*so->so_proto->pr_usrreqs->pr_send)(so, 539 top, NULL, NULL, l); 540 top = NULL; 541 release: 542 sbunlock(&so->so_snd); 543 out: 544 sounlock(so); 545 m_freem(top); 546 return error; 547 } 548 549 /* This is a stripped-down version of soreceive() that will never 550 * block. It will support SOCK_DGRAM sockets. It may also support 551 * SOCK_SEQPACKET sockets. 552 */ 553 static int 554 gre_soreceive(struct socket *so, struct mbuf **mp0) 555 { 556 struct mbuf *m, **mp; 557 int flags, len, error, type; 558 const struct protosw *pr; 559 struct mbuf *nextrecord; 560 561 KASSERT(mp0 != NULL); 562 563 flags = MSG_DONTWAIT; 564 pr = so->so_proto; 565 mp = mp0; 566 type = 0; 567 568 *mp = NULL; 569 570 KASSERT(pr->pr_flags & PR_ATOMIC); 571 restart: 572 if ((error = sblock(&so->so_rcv, M_NOWAIT)) != 0) { 573 return error; 574 } 575 m = so->so_rcv.sb_mb; 576 /* 577 * If we have less data than requested, do not block awaiting more. 578 */ 579 if (m == NULL) { 580 #ifdef DIAGNOSTIC 581 if (so->so_rcv.sb_cc) 582 panic("receive 1"); 583 #endif 584 if (so->so_error) { 585 error = so->so_error; 586 so->so_error = 0; 587 } else if (so->so_state & SS_CANTRCVMORE) 588 ; 589 else if ((so->so_state & (SS_ISCONNECTED|SS_ISCONNECTING)) == 0 590 && (so->so_proto->pr_flags & PR_CONNREQUIRED)) 591 error = ENOTCONN; 592 else 593 error = EWOULDBLOCK; 594 goto release; 595 } 596 /* 597 * On entry here, m points to the first record of the socket buffer. 598 * While we process the initial mbufs containing address and control 599 * info, we save a copy of m->m_nextpkt into nextrecord. 600 */ 601 if (curlwp != NULL) 602 curlwp->l_ru.ru_msgrcv++; 603 KASSERT(m == so->so_rcv.sb_mb); 604 SBLASTRECORDCHK(&so->so_rcv, "soreceive 1"); 605 SBLASTMBUFCHK(&so->so_rcv, "soreceive 1"); 606 nextrecord = m->m_nextpkt; 607 if (pr->pr_flags & PR_ADDR) { 608 #ifdef DIAGNOSTIC 609 if (m->m_type != MT_SONAME) 610 panic("receive 1a"); 611 #endif 612 sbfree(&so->so_rcv, m); 613 m = so->so_rcv.sb_mb = m_free(m); 614 } 615 while (m != NULL && m->m_type == MT_CONTROL && error == 0) { 616 sbfree(&so->so_rcv, m); 617 /* 618 * Dispose of any SCM_RIGHTS message that went 619 * through the read path rather than recv. 620 */ 621 if (pr->pr_domain->dom_dispose && 622 mtod(m, struct cmsghdr *)->cmsg_type == SCM_RIGHTS) 623 (*pr->pr_domain->dom_dispose)(m); 624 m = so->so_rcv.sb_mb = m_free(m); 625 } 626 627 /* 628 * If m is non-NULL, we have some data to read. From now on, 629 * make sure to keep sb_lastrecord consistent when working on 630 * the last packet on the chain (nextrecord == NULL) and we 631 * change m->m_nextpkt. 632 */ 633 if (m != NULL) { 634 m->m_nextpkt = nextrecord; 635 /* 636 * If nextrecord == NULL (this is a single chain), 637 * then sb_lastrecord may not be valid here if m 638 * was changed earlier. 639 */ 640 if (nextrecord == NULL) { 641 KASSERT(so->so_rcv.sb_mb == m); 642 so->so_rcv.sb_lastrecord = m; 643 } 644 type = m->m_type; 645 if (type == MT_OOBDATA) 646 flags |= MSG_OOB; 647 } else { 648 KASSERT(so->so_rcv.sb_mb == m); 649 so->so_rcv.sb_mb = nextrecord; 650 SB_EMPTY_FIXUP(&so->so_rcv); 651 } 652 SBLASTRECORDCHK(&so->so_rcv, "soreceive 2"); 653 SBLASTMBUFCHK(&so->so_rcv, "soreceive 2"); 654 655 while (m != NULL) { 656 if (m->m_type == MT_OOBDATA) { 657 if (type != MT_OOBDATA) 658 break; 659 } else if (type == MT_OOBDATA) 660 break; 661 #ifdef DIAGNOSTIC 662 else if (m->m_type != MT_DATA && m->m_type != MT_HEADER) 663 panic("receive 3"); 664 #endif 665 so->so_state &= ~SS_RCVATMARK; 666 if (so->so_oobmark != 0 && so->so_oobmark < m->m_len) 667 break; 668 len = m->m_len; 669 /* 670 * mp is set, just pass back the mbufs. 671 * Sockbuf must be consistent here (points to current mbuf, 672 * it points to next record) when we drop priority; 673 * we must note any additions to the sockbuf when we 674 * block interrupts again. 675 */ 676 if (m->m_flags & M_EOR) 677 flags |= MSG_EOR; 678 nextrecord = m->m_nextpkt; 679 sbfree(&so->so_rcv, m); 680 *mp = m; 681 mp = &m->m_next; 682 so->so_rcv.sb_mb = m = m->m_next; 683 *mp = NULL; 684 /* 685 * If m != NULL, we also know that 686 * so->so_rcv.sb_mb != NULL. 687 */ 688 KASSERT(so->so_rcv.sb_mb == m); 689 if (m) { 690 m->m_nextpkt = nextrecord; 691 if (nextrecord == NULL) 692 so->so_rcv.sb_lastrecord = m; 693 } else { 694 so->so_rcv.sb_mb = nextrecord; 695 SB_EMPTY_FIXUP(&so->so_rcv); 696 } 697 SBLASTRECORDCHK(&so->so_rcv, "soreceive 3"); 698 SBLASTMBUFCHK(&so->so_rcv, "soreceive 3"); 699 if (so->so_oobmark) { 700 so->so_oobmark -= len; 701 if (so->so_oobmark == 0) { 702 so->so_state |= SS_RCVATMARK; 703 break; 704 } 705 } 706 if (flags & MSG_EOR) 707 break; 708 } 709 710 if (m != NULL) { 711 m_freem(*mp); 712 *mp = NULL; 713 error = ENOMEM; 714 (void) sbdroprecord(&so->so_rcv); 715 } else { 716 /* 717 * First part is an inline SB_EMPTY_FIXUP(). Second 718 * part makes sure sb_lastrecord is up-to-date if 719 * there is still data in the socket buffer. 720 */ 721 so->so_rcv.sb_mb = nextrecord; 722 if (so->so_rcv.sb_mb == NULL) { 723 so->so_rcv.sb_mbtail = NULL; 724 so->so_rcv.sb_lastrecord = NULL; 725 } else if (nextrecord->m_nextpkt == NULL) 726 so->so_rcv.sb_lastrecord = nextrecord; 727 } 728 SBLASTRECORDCHK(&so->so_rcv, "soreceive 4"); 729 SBLASTMBUFCHK(&so->so_rcv, "soreceive 4"); 730 if (pr->pr_flags & PR_WANTRCVD && so->so_pcb) 731 (*pr->pr_usrreqs->pr_rcvd)(so, flags, curlwp); 732 if (*mp0 == NULL && (flags & MSG_EOR) == 0 && 733 (so->so_state & SS_CANTRCVMORE) == 0) { 734 sbunlock(&so->so_rcv); 735 goto restart; 736 } 737 738 release: 739 sbunlock(&so->so_rcv); 740 return error; 741 } 742 743 static struct socket * 744 gre_reconf(struct gre_softc *sc, const struct gre_soparm *newsoparm) 745 { 746 struct ifnet *ifp = &sc->sc_if; 747 748 GRE_DPRINTF(sc, "enter\n"); 749 750 shutdown: 751 if (sc->sc_soparm.sp_so != NULL) { 752 GRE_DPRINTF(sc, "\n"); 753 gre_upcall_remove(sc->sc_soparm.sp_so); 754 softint_disestablish(sc->sc_si); 755 sc->sc_si = NULL; 756 gre_fp_send(sc, GRE_M_DELFP, NULL); 757 gre_clearconf(&sc->sc_soparm, false); 758 } 759 760 if (newsoparm != NULL) { 761 GRE_DPRINTF(sc, "\n"); 762 sc->sc_soparm = *newsoparm; 763 newsoparm = NULL; 764 } 765 766 if (sc->sc_soparm.sp_so != NULL) { 767 GRE_DPRINTF(sc, "\n"); 768 sc->sc_si = softint_establish(SOFTINT_NET, greintr, sc); 769 gre_upcall_add(sc->sc_soparm.sp_so, sc); 770 if ((ifp->if_flags & IFF_UP) == 0) { 771 GRE_DPRINTF(sc, "down\n"); 772 goto shutdown; 773 } 774 } 775 776 GRE_DPRINTF(sc, "\n"); 777 if (sc->sc_soparm.sp_so != NULL) 778 sc->sc_if.if_flags |= IFF_RUNNING; 779 else { 780 gre_bufq_purge(&sc->sc_snd); 781 sc->sc_if.if_flags &= ~IFF_RUNNING; 782 } 783 return sc->sc_soparm.sp_so; 784 } 785 786 static int 787 gre_input(struct gre_softc *sc, struct mbuf *m, const struct gre_h *gh) 788 { 789 pktqueue_t *pktq = NULL; 790 uint16_t flags; 791 uint32_t af; /* af passed to BPF tap */ 792 int hlen; 793 794 if_statadd2(&sc->sc_if, if_ipackets, 1, if_ibytes, m->m_pkthdr.len); 795 796 hlen = sizeof(struct gre_h); 797 798 /* process GRE flags as packet can be of variable len */ 799 flags = ntohs(gh->flags); 800 801 /* Checksum & Offset are present */ 802 if ((flags & GRE_CP) | (flags & GRE_RP)) 803 hlen += 4; 804 /* We don't support routing fields (variable length) */ 805 if (flags & GRE_RP) { 806 if_statinc(&sc->sc_if, if_ierrors); 807 return 0; 808 } 809 if (flags & GRE_KP) 810 hlen += 4; 811 if (flags & GRE_SP) 812 hlen += 4; 813 814 switch (ntohs(gh->ptype)) { /* ethertypes */ 815 #ifdef INET 816 case ETHERTYPE_IP: 817 pktq = ip_pktq; 818 af = AF_INET; 819 break; 820 #endif 821 #ifdef NETATALK 822 case ETHERTYPE_ATALK: 823 pktq = at_pktq1; 824 af = AF_APPLETALK; 825 break; 826 #endif 827 #ifdef INET6 828 case ETHERTYPE_IPV6: 829 pktq = ip6_pktq; 830 af = AF_INET6; 831 break; 832 #endif 833 #ifdef MPLS 834 case ETHERTYPE_MPLS: 835 pktq = mpls_pktq; 836 af = AF_MPLS; 837 break; 838 #endif 839 default: /* others not yet supported */ 840 GRE_DPRINTF(sc, "unhandled ethertype 0x%04x\n", 841 ntohs(gh->ptype)); 842 if_statinc(&sc->sc_if, if_noproto); 843 return 0; 844 } 845 846 if (hlen > m->m_pkthdr.len) { 847 m_freem(m); 848 if_statinc(&sc->sc_if, if_ierrors); 849 return 1; 850 } 851 m_adj(m, hlen); 852 853 bpf_mtap_af(&sc->sc_if, af, m, BPF_D_IN); 854 855 m_set_rcvif(m, &sc->sc_if); 856 857 KASSERT(pktq != NULL); 858 if (__predict_false(!pktq_enqueue(pktq, m, 0))) { 859 m_freem(m); 860 } 861 return 1; /* packet is done, no further processing needed */ 862 } 863 864 /* 865 * The output routine. Takes a packet and encapsulates it in the protocol 866 * given by sc->sc_soparm.sp_proto. See also RFC 1701 and RFC 2004 867 */ 868 static int 869 gre_output(struct ifnet *ifp, struct mbuf *m, const struct sockaddr *dst, 870 const struct rtentry *rt) 871 { 872 int error = 0; 873 struct gre_softc *sc = ifp->if_softc; 874 struct gre_h gh = { .flags = 0 }; 875 uint16_t etype = 0; 876 877 KASSERT((m->m_flags & M_PKTHDR) != 0); 878 879 if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING)) { 880 m_freem(m); 881 error = ENETDOWN; 882 goto end; 883 } 884 885 bpf_mtap_af(ifp, dst->sa_family, m, BPF_D_OUT); 886 887 m->m_flags &= ~(M_BCAST|M_MCAST); 888 889 GRE_DPRINTF(sc, "dst->sa_family=%d\n", dst->sa_family); 890 switch (dst->sa_family) { 891 #ifdef INET 892 case AF_INET: 893 /* 894 * TBD Extract the IP ToS field and set the 895 * encapsulating protocol's ToS to suit. 896 */ 897 etype = htons(ETHERTYPE_IP); 898 break; 899 #endif 900 #ifdef NETATALK 901 case AF_APPLETALK: 902 etype = htons(ETHERTYPE_ATALK); 903 break; 904 #endif 905 #ifdef INET6 906 case AF_INET6: 907 etype = htons(ETHERTYPE_IPV6); 908 break; 909 #endif 910 default: 911 IF_DROP(&ifp->if_snd); 912 m_freem(m); 913 error = EAFNOSUPPORT; 914 goto end; 915 } 916 917 #ifdef MPLS 918 if (rt != NULL && rt_gettag(rt) != NULL) { 919 union mpls_shim msh; 920 msh.s_addr = MPLS_GETSADDR(rt); 921 if (msh.shim.label != MPLS_LABEL_IMPLNULL) 922 etype = htons(ETHERTYPE_MPLS); 923 } 924 #endif 925 926 M_PREPEND(m, sizeof(gh), M_DONTWAIT); 927 if (m == NULL) { 928 IF_DROP(&ifp->if_snd); 929 error = ENOBUFS; 930 goto end; 931 } 932 933 gh.ptype = etype; 934 memcpy(mtod(m, void *), &gh, sizeof(gh)); 935 /* XXX Need to handle IP ToS. Look at how I handle IP TTL. */ 936 937 if_statadd2(ifp, if_opackets, 1, if_obytes, m->m_pkthdr.len); 938 939 /* Clear checksum-offload flags. */ 940 m->m_pkthdr.csum_flags = 0; 941 m->m_pkthdr.csum_data = 0; 942 943 /* send it off */ 944 if ((error = gre_bufq_enqueue(&sc->sc_snd, m)) != 0) { 945 sc->sc_oflow_ev.ev_count++; 946 m_freem(m); 947 } else { 948 kpreempt_disable(); 949 softint_schedule(sc->sc_si); 950 kpreempt_enable(); 951 } 952 953 end: 954 if (error) 955 if_statinc(ifp, if_oerrors); 956 return error; 957 } 958 959 static int 960 gre_getsockname(struct socket *so, struct sockaddr *nam) 961 { 962 return (*so->so_proto->pr_usrreqs->pr_sockaddr)(so, nam); 963 } 964 965 static int 966 gre_getpeername(struct socket *so, struct sockaddr *nam) 967 { 968 return (*so->so_proto->pr_usrreqs->pr_peeraddr)(so, nam); 969 } 970 971 static int 972 gre_getnames(struct socket *so, struct lwp *l, struct sockaddr_storage *src, 973 struct sockaddr_storage *dst) 974 { 975 struct sockaddr_storage ss; 976 int rc; 977 978 solock(so); 979 if ((rc = gre_getsockname(so, (struct sockaddr *)&ss)) != 0) 980 goto out; 981 *src = ss; 982 983 if ((rc = gre_getpeername(so, (struct sockaddr *)&ss)) != 0) 984 goto out; 985 *dst = ss; 986 out: 987 sounlock(so); 988 return rc; 989 } 990 991 static void 992 gre_fp_recvloop(void *arg) 993 { 994 struct gre_softc *sc = arg; 995 996 mutex_enter(&sc->sc_mtx); 997 while (gre_fp_recv(sc)) 998 ; 999 mutex_exit(&sc->sc_mtx); 1000 kthread_exit(0); 1001 } 1002 1003 static bool 1004 gre_fp_recv(struct gre_softc *sc) 1005 { 1006 int fd, ofd, rc; 1007 file_t *fp; 1008 1009 fp = sc->sc_fp; 1010 ofd = sc->sc_fd; 1011 fd = -1; 1012 1013 switch (sc->sc_msg) { 1014 case GRE_M_STOP: 1015 cv_signal(&sc->sc_fp_condvar); 1016 return false; 1017 case GRE_M_SETFP: 1018 mutex_exit(&sc->sc_mtx); 1019 rc = fd_dup(fp, 0, &fd, false, false); 1020 mutex_enter(&sc->sc_mtx); 1021 if (rc != 0) { 1022 sc->sc_msg = GRE_M_ERR; 1023 break; 1024 } 1025 /*FALLTHROUGH*/ 1026 case GRE_M_DELFP: 1027 mutex_exit(&sc->sc_mtx); 1028 if (ofd != -1 && fd_getfile(ofd) != NULL) 1029 fd_close(ofd); 1030 mutex_enter(&sc->sc_mtx); 1031 sc->sc_fd = fd; 1032 sc->sc_msg = GRE_M_OK; 1033 break; 1034 default: 1035 gre_fp_wait(sc); 1036 return true; 1037 } 1038 cv_signal(&sc->sc_fp_condvar); 1039 return true; 1040 } 1041 1042 static bool 1043 gre_fp_send(struct gre_softc *sc, enum gre_msg msg, file_t *fp) 1044 { 1045 bool rc; 1046 1047 mutex_enter(&sc->sc_mtx); 1048 while (sc->sc_msg != GRE_M_NONE) 1049 gre_fp_wait(sc); 1050 sc->sc_fp = fp; 1051 sc->sc_msg = msg; 1052 cv_signal(&sc->sc_fp_condvar); 1053 while (sc->sc_msg != GRE_M_STOP && sc->sc_msg != GRE_M_OK && 1054 sc->sc_msg != GRE_M_ERR) 1055 gre_fp_wait(sc); 1056 rc = (sc->sc_msg != GRE_M_ERR); 1057 sc->sc_msg = GRE_M_NONE; 1058 cv_signal(&sc->sc_fp_condvar); 1059 mutex_exit(&sc->sc_mtx); 1060 return rc; 1061 } 1062 1063 static int 1064 gre_ssock(struct ifnet *ifp, struct gre_soparm *sp, int fd) 1065 { 1066 int error = 0; 1067 const struct protosw *pr; 1068 file_t *fp; 1069 struct gre_softc *sc = ifp->if_softc; 1070 struct socket *so; 1071 struct sockaddr_storage dst, src; 1072 1073 if ((fp = fd_getfile(fd)) == NULL) 1074 return EBADF; 1075 if (fp->f_type != DTYPE_SOCKET) { 1076 fd_putfile(fd); 1077 return ENOTSOCK; 1078 } 1079 1080 GRE_DPRINTF(sc, "\n"); 1081 1082 so = fp->f_socket; 1083 pr = so->so_proto; 1084 1085 GRE_DPRINTF(sc, "type %d, proto %d\n", pr->pr_type, pr->pr_protocol); 1086 1087 if ((pr->pr_flags & PR_ATOMIC) == 0 || 1088 (sp->sp_type != 0 && pr->pr_type != sp->sp_type) || 1089 (sp->sp_proto != 0 && pr->pr_protocol != 0 && 1090 pr->pr_protocol != sp->sp_proto)) { 1091 error = EINVAL; 1092 goto err; 1093 } 1094 1095 GRE_DPRINTF(sc, "\n"); 1096 1097 /* check address */ 1098 if ((error = gre_getnames(so, curlwp, &src, &dst)) != 0) 1099 goto err; 1100 1101 GRE_DPRINTF(sc, "\n"); 1102 1103 if (!gre_fp_send(sc, GRE_M_SETFP, fp)) { 1104 error = EBUSY; 1105 goto err; 1106 } 1107 1108 GRE_DPRINTF(sc, "\n"); 1109 1110 sp->sp_src = src; 1111 sp->sp_dst = dst; 1112 1113 sp->sp_so = so; 1114 1115 err: 1116 fd_putfile(fd); 1117 return error; 1118 } 1119 1120 static bool 1121 sockaddr_is_anyaddr(const struct sockaddr *sa) 1122 { 1123 socklen_t anylen, salen; 1124 const void *anyaddr, *addr; 1125 1126 if ((anyaddr = sockaddr_anyaddr(sa, &anylen)) == NULL || 1127 (addr = sockaddr_const_addr(sa, &salen)) == NULL) 1128 return false; 1129 1130 if (salen > anylen) 1131 return false; 1132 1133 return memcmp(anyaddr, addr, MIN(anylen, salen)) == 0; 1134 } 1135 1136 static bool 1137 gre_is_nullconf(const struct gre_soparm *sp) 1138 { 1139 return sockaddr_is_anyaddr(sstocsa(&sp->sp_src)) || 1140 sockaddr_is_anyaddr(sstocsa(&sp->sp_dst)); 1141 } 1142 1143 static void 1144 gre_clearconf(struct gre_soparm *sp, bool force) 1145 { 1146 if (sp->sp_bysock || force) { 1147 sockaddr_copy(sstosa(&sp->sp_src), sizeof(sp->sp_src), 1148 sockaddr_any(sstosa(&sp->sp_src))); 1149 sockaddr_copy(sstosa(&sp->sp_dst), sizeof(sp->sp_dst), 1150 sockaddr_any(sstosa(&sp->sp_dst))); 1151 sp->sp_bysock = false; 1152 } 1153 sp->sp_so = NULL; /* XXX */ 1154 } 1155 1156 static int 1157 gre_ioctl(struct ifnet *ifp, const u_long cmd, void *data) 1158 { 1159 struct ifreq *ifr; 1160 struct ifaddr *ifa = (struct ifaddr *)data; 1161 struct if_laddrreq *lifr = (struct if_laddrreq *)data; 1162 struct gre_softc *sc = ifp->if_softc; 1163 struct gre_soparm *sp; 1164 int fd, error = 0, oproto, otype, s; 1165 struct gre_soparm sp0; 1166 1167 ifr = data; 1168 1169 GRE_DPRINTF(sc, "cmd %lu\n", cmd); 1170 1171 switch (cmd) { 1172 case GRESPROTO: 1173 case GRESADDRD: 1174 case GRESADDRS: 1175 case GRESSOCK: 1176 case GREDSOCK: 1177 if (kauth_authorize_network(kauth_cred_get(), 1178 KAUTH_NETWORK_INTERFACE, 1179 KAUTH_REQ_NETWORK_INTERFACE_SETPRIV, ifp, (void *)cmd, 1180 NULL) != 0) 1181 return EPERM; 1182 break; 1183 default: 1184 break; 1185 } 1186 1187 s = splnet(); 1188 1189 sp0 = sc->sc_soparm; 1190 sp0.sp_so = NULL; 1191 sp = &sp0; 1192 1193 GRE_DPRINTF(sc, "\n"); 1194 1195 switch (cmd) { 1196 case SIOCINITIFADDR: 1197 GRE_DPRINTF(sc, "\n"); 1198 if ((ifp->if_flags & IFF_UP) != 0) 1199 break; 1200 gre_clearconf(sp, false); 1201 ifp->if_flags |= IFF_UP; 1202 ifa->ifa_rtrequest = p2p_rtrequest; 1203 goto mksocket; 1204 case SIOCSIFFLAGS: 1205 if ((error = ifioctl_common(ifp, cmd, data)) != 0) 1206 break; 1207 oproto = sp->sp_proto; 1208 otype = sp->sp_type; 1209 switch (ifr->ifr_flags & (IFF_LINK0|IFF_LINK2)) { 1210 case IFF_LINK0|IFF_LINK2: 1211 sp->sp_proto = IPPROTO_UDP; 1212 sp->sp_type = SOCK_DGRAM; 1213 break; 1214 case IFF_LINK2: 1215 sp->sp_proto = 0; 1216 sp->sp_type = 0; 1217 break; 1218 case IFF_LINK0: 1219 sp->sp_proto = IPPROTO_GRE; 1220 sp->sp_type = SOCK_RAW; 1221 break; 1222 default: 1223 GRE_DPRINTF(sc, "\n"); 1224 error = EINVAL; 1225 goto out; 1226 } 1227 GRE_DPRINTF(sc, "\n"); 1228 gre_clearconf(sp, false); 1229 if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) == 1230 (IFF_UP|IFF_RUNNING) && 1231 (oproto == sp->sp_proto || sp->sp_proto == 0) && 1232 (otype == sp->sp_type || sp->sp_type == 0)) 1233 break; 1234 switch (sp->sp_proto) { 1235 case IPPROTO_UDP: 1236 case IPPROTO_GRE: 1237 goto mksocket; 1238 default: 1239 break; 1240 } 1241 break; 1242 case SIOCSIFMTU: 1243 /* XXX determine MTU automatically by probing w/ 1244 * XXX do-not-fragment packets? 1245 */ 1246 if (ifr->ifr_mtu < 576) { 1247 error = EINVAL; 1248 break; 1249 } 1250 /*FALLTHROUGH*/ 1251 case SIOCGIFMTU: 1252 if ((error = ifioctl_common(ifp, cmd, data)) == ENETRESET) 1253 error = 0; 1254 break; 1255 case SIOCADDMULTI: 1256 case SIOCDELMULTI: 1257 if (ifr == NULL) { 1258 error = EAFNOSUPPORT; 1259 break; 1260 } 1261 switch (ifreq_getaddr(cmd, ifr)->sa_family) { 1262 #ifdef INET 1263 case AF_INET: 1264 break; 1265 #endif 1266 #ifdef INET6 1267 case AF_INET6: 1268 break; 1269 #endif 1270 default: 1271 error = EAFNOSUPPORT; 1272 break; 1273 } 1274 break; 1275 case GRESPROTO: 1276 gre_clearconf(sp, false); 1277 oproto = sp->sp_proto; 1278 otype = sp->sp_type; 1279 sp->sp_proto = ifr->ifr_flags; 1280 switch (sp->sp_proto) { 1281 case IPPROTO_UDP: 1282 ifp->if_flags |= IFF_LINK0|IFF_LINK2; 1283 sp->sp_type = SOCK_DGRAM; 1284 break; 1285 case IPPROTO_GRE: 1286 ifp->if_flags |= IFF_LINK0; 1287 ifp->if_flags &= ~IFF_LINK2; 1288 sp->sp_type = SOCK_RAW; 1289 break; 1290 case 0: 1291 ifp->if_flags &= ~IFF_LINK0; 1292 ifp->if_flags |= IFF_LINK2; 1293 sp->sp_type = 0; 1294 break; 1295 default: 1296 error = EPROTONOSUPPORT; 1297 break; 1298 } 1299 if ((oproto == sp->sp_proto || sp->sp_proto == 0) && 1300 (otype == sp->sp_type || sp->sp_type == 0)) 1301 break; 1302 switch (sp->sp_proto) { 1303 case IPPROTO_UDP: 1304 case IPPROTO_GRE: 1305 goto mksocket; 1306 default: 1307 break; 1308 } 1309 break; 1310 case GREGPROTO: 1311 ifr->ifr_flags = sp->sp_proto; 1312 break; 1313 case GRESADDRS: 1314 case GRESADDRD: 1315 gre_clearconf(sp, false); 1316 /* set tunnel endpoints and mark interface as up */ 1317 switch (cmd) { 1318 case GRESADDRS: 1319 sockaddr_copy(sstosa(&sp->sp_src), 1320 sizeof(sp->sp_src), ifreq_getaddr(cmd, ifr)); 1321 break; 1322 case GRESADDRD: 1323 sockaddr_copy(sstosa(&sp->sp_dst), 1324 sizeof(sp->sp_dst), ifreq_getaddr(cmd, ifr)); 1325 break; 1326 } 1327 checkaddr: 1328 if (sockaddr_any(sstosa(&sp->sp_src)) == NULL || 1329 sockaddr_any(sstosa(&sp->sp_dst)) == NULL) { 1330 error = EINVAL; 1331 break; 1332 } 1333 /* let gre_socreate() check the rest */ 1334 mksocket: 1335 GRE_DPRINTF(sc, "\n"); 1336 /* If we're administratively down, or the configuration 1337 * is empty, there's no use creating a socket. 1338 */ 1339 if ((ifp->if_flags & IFF_UP) == 0 || gre_is_nullconf(sp)) 1340 goto sendconf; 1341 1342 GRE_DPRINTF(sc, "\n"); 1343 fd = 0; 1344 error = gre_socreate(sc, sp, &fd); 1345 if (error != 0) 1346 break; 1347 1348 setsock: 1349 GRE_DPRINTF(sc, "\n"); 1350 1351 error = gre_ssock(ifp, sp, fd); 1352 1353 if (cmd != GRESSOCK) { 1354 GRE_DPRINTF(sc, "\n"); 1355 /* XXX v. dodgy */ 1356 if (fd_getfile(fd) != NULL) 1357 fd_close(fd); 1358 } 1359 1360 if (error == 0) { 1361 sendconf: 1362 GRE_DPRINTF(sc, "\n"); 1363 ifp->if_flags &= ~IFF_RUNNING; 1364 gre_reconf(sc, sp); 1365 } 1366 1367 break; 1368 case GREGADDRS: 1369 ifreq_setaddr(cmd, ifr, sstosa(&sp->sp_src)); 1370 break; 1371 case GREGADDRD: 1372 ifreq_setaddr(cmd, ifr, sstosa(&sp->sp_dst)); 1373 break; 1374 case GREDSOCK: 1375 GRE_DPRINTF(sc, "\n"); 1376 if (sp->sp_bysock) 1377 ifp->if_flags &= ~IFF_UP; 1378 gre_clearconf(sp, false); 1379 goto mksocket; 1380 case GRESSOCK: 1381 GRE_DPRINTF(sc, "\n"); 1382 gre_clearconf(sp, true); 1383 fd = (int)ifr->ifr_value; 1384 sp->sp_bysock = true; 1385 ifp->if_flags |= IFF_UP; 1386 goto setsock; 1387 case SIOCSLIFPHYADDR: 1388 GRE_DPRINTF(sc, "\n"); 1389 if (lifr->addr.ss_family != lifr->dstaddr.ss_family) { 1390 error = EAFNOSUPPORT; 1391 break; 1392 } 1393 sockaddr_copy(sstosa(&sp->sp_src), sizeof(sp->sp_src), 1394 sstosa(&lifr->addr)); 1395 sockaddr_copy(sstosa(&sp->sp_dst), sizeof(sp->sp_dst), 1396 sstosa(&lifr->dstaddr)); 1397 GRE_DPRINTF(sc, "\n"); 1398 goto checkaddr; 1399 case SIOCDIFPHYADDR: 1400 GRE_DPRINTF(sc, "\n"); 1401 gre_clearconf(sp, true); 1402 ifp->if_flags &= ~IFF_UP; 1403 goto mksocket; 1404 case SIOCGLIFPHYADDR: 1405 GRE_DPRINTF(sc, "\n"); 1406 if (gre_is_nullconf(sp)) { 1407 error = EADDRNOTAVAIL; 1408 break; 1409 } 1410 sockaddr_copy(sstosa(&lifr->addr), sizeof(lifr->addr), 1411 sstosa(&sp->sp_src)); 1412 sockaddr_copy(sstosa(&lifr->dstaddr), sizeof(lifr->dstaddr), 1413 sstosa(&sp->sp_dst)); 1414 GRE_DPRINTF(sc, "\n"); 1415 break; 1416 default: 1417 error = ifioctl_common(ifp, cmd, data); 1418 break; 1419 } 1420 out: 1421 GRE_DPRINTF(sc, "\n"); 1422 splx(s); 1423 return error; 1424 } 1425 1426 /* ARGSUSED */ 1427 void 1428 greattach(int count) 1429 { 1430 1431 /* 1432 * Nothing to do here, initialization is handled by the 1433 * module initialization code in greinit() below. 1434 */ 1435 } 1436 1437 static void 1438 greinit(void) 1439 { 1440 if_clone_attach(&gre_cloner); 1441 } 1442 1443 static int 1444 gredetach(void) 1445 { 1446 int error = 0; 1447 1448 if (gre_count != 0) 1449 error = EBUSY; 1450 1451 if (error == 0) 1452 if_clone_detach(&gre_cloner); 1453 1454 return error; 1455 } 1456 1457 /* 1458 * Module infrastructure 1459 */ 1460 #include "if_module.h" 1461 1462 IF_MODULE(MODULE_CLASS_DRIVER, gre, NULL) 1463
Indexes created Thu Sep 25 08:09:54 GMT 2025