1 /* $NetBSD: if_tun.c,v 1.14 1994/06/29 06:36:25 cgd Exp $ */ 2 3 /* 4 * Copyright (c) 1988, Julian Onions <jpo@cs.nott.ac.uk> 5 * Nottingham University 1987. 6 * 7 * This source may be freely distributed, however I would be interested 8 * in any changes that are made. 9 * 10 * This driver takes packets off the IP i/f and hands them up to a 11 * user process to have its wicked way with. This driver has it's 12 * roots in a similar driver written by Phil Cockcroft (formerly) at 13 * UCL. This driver is based much more on read/write/poll mode of 14 * operation though. 15 * 16 * $FreeBSD: src/sys/net/if_tun.c,v 1.74.2.8 2002/02/13 00:43:11 dillon Exp $ 17 */ 18 19 #include "use_tun.h" 20 #include "opt_inet.h" 21 #include "opt_inet6.h" 22 23 #include <sys/param.h> 24 #include <sys/proc.h> 25 #include <sys/priv.h> 26 #include <sys/systm.h> 27 #include <sys/mbuf.h> 28 #include <sys/socket.h> 29 #include <sys/conf.h> 30 #include <sys/device.h> 31 #include <sys/filio.h> 32 #include <sys/sockio.h> 33 #include <sys/thread2.h> 34 #include <sys/ttycom.h> 35 #include <sys/signalvar.h> 36 #include <sys/filedesc.h> 37 #include <sys/kernel.h> 38 #include <sys/sysctl.h> 39 #include <sys/uio.h> 40 #include <sys/vnode.h> 41 #include <sys/malloc.h> 42 #include <sys/mplock2.h> 43 #include <sys/devfs.h> 44 #include <sys/queue.h> 45 46 #include <net/bpf.h> 47 #include <net/if.h> 48 #include <net/if_types.h> 49 #include <net/if_clone.h> 50 #include <net/ifq_var.h> 51 #include <net/netisr.h> 52 #include <net/route.h> 53 54 #ifdef INET 55 #include <netinet/in.h> 56 #endif 57 58 #include "if_tunvar.h" 59 #include "if_tun.h" 60 61 #if NTUN <= 1 62 #define TUN_PREALLOCATED_UNITS 4 63 #else 64 #define TUN_PREALLOCATED_UNITS NTUN 65 #endif 66 67 #define TUN "tun" 68 #define TUNDEBUG if (tundebug) if_printf 69 70 /* module */ 71 static int tunmodevent(module_t, int, void *); 72 73 /* device */ 74 static struct tun_softc *tuncreate(cdev_t, int); 75 static void tundestroy(struct tun_softc *sc); 76 77 /* clone */ 78 static int tun_clone_create(struct if_clone *, int, caddr_t); 79 static int tun_clone_destroy(struct ifnet *); 80 81 /* network interface */ 82 static int tunifinit(struct ifnet *); 83 static void tunifstart(struct ifnet *, struct ifaltq_subque *); 84 static int tunifoutput(struct ifnet *, struct mbuf *, 85 struct sockaddr *, struct rtentry *rt); 86 static int tunifioctl(struct ifnet *, u_long, 87 caddr_t, struct ucred *); 88 89 /* character device */ 90 static d_open_t tunopen; 91 static d_close_t tunclose; 92 static d_read_t tunread; 93 static d_write_t tunwrite; 94 static d_ioctl_t tunioctl; 95 static d_kqfilter_t tunkqfilter; 96 static d_clone_t tunclone; 97 98 static struct dev_ops tun_ops = { 99 { TUN, 0, 0 }, 100 .d_open = tunopen, 101 .d_close = tunclose, 102 .d_read = tunread, 103 .d_write = tunwrite, 104 .d_ioctl = tunioctl, 105 .d_kqfilter = tunkqfilter 106 }; 107 108 /* kqueue support */ 109 static void tun_filter_detach(struct knote *); 110 static int tun_filter_read(struct knote *, long); 111 static int tun_filter_write(struct knote *, long); 112 113 static struct filterops tun_read_filtops = { 114 FILTEROP_ISFD, 115 NULL, 116 tun_filter_detach, 117 tun_filter_read 118 }; 119 static struct filterops tun_write_filtops = { 120 FILTEROP_ISFD, 121 NULL, 122 tun_filter_detach, 123 tun_filter_write 124 }; 125 126 static int tundebug = 0; /* debug flag */ 127 static int tunrefcnt = 0; /* module reference counter */ 128 129 static MALLOC_DEFINE(M_TUN, TUN, "Tunnel Interface"); 130 131 static DEVFS_DEFINE_CLONE_BITMAP(tun); 132 133 struct if_clone tun_cloner = IF_CLONE_INITIALIZER( 134 TUN, tun_clone_create, tun_clone_destroy, 0, IF_MAXUNIT); 135 136 static SLIST_HEAD(,tun_softc) tun_listhead = 137 SLIST_HEAD_INITIALIZER(&tun_listhead); 138 139 SYSCTL_INT(_debug, OID_AUTO, if_tun_debug, CTLFLAG_RW, &tundebug, 0, 140 "Enable debug output"); 141 SYSCTL_DECL(_net_link); 142 SYSCTL_NODE(_net_link, OID_AUTO, tun, CTLFLAG_RW, 0, 143 "IP tunnel software network interface"); 144 SYSCTL_INT(_net_link_tun, OID_AUTO, debug, CTLFLAG_RW, &tundebug, 0, 145 "Enable debug output"); 146 SYSCTL_INT(_net_link_tun, OID_AUTO, refcnt, CTLFLAG_RD, &tunrefcnt, 0, 147 "Number of opened devices"); 148 149 DEV_MODULE(if_tun, tunmodevent, NULL); 150 151 /* 152 * tunmodevent - module event handler 153 */ 154 static int 155 tunmodevent(module_t mod, int type, void *data) 156 { 157 static cdev_t dev = NULL; 158 struct tun_softc *sc, *sc_tmp; 159 int i; 160 161 switch (type) { 162 case MOD_LOAD: 163 dev = make_autoclone_dev(&tun_ops, &DEVFS_CLONE_BITMAP(tun), 164 tunclone, UID_UUCP, GID_DIALER, 165 0600, TUN); 166 167 SLIST_INIT(&tun_listhead); 168 if_clone_attach(&tun_cloner); 169 170 for (i = 0; i < TUN_PREALLOCATED_UNITS; ++i) { 171 make_dev(&tun_ops, i, UID_UUCP, GID_DIALER, 172 0600, "%s%d", TUN, i); 173 devfs_clone_bitmap_set(&DEVFS_CLONE_BITMAP(tun), i); 174 } 175 break; 176 177 case MOD_UNLOAD: 178 if (tunrefcnt > 0) 179 return (EBUSY); 180 181 if_clone_detach(&tun_cloner); 182 183 SLIST_FOREACH_MUTABLE(sc, &tun_listhead, tun_link, sc_tmp) 184 tundestroy(sc); 185 186 dev_ops_remove_all(&tun_ops); 187 destroy_autoclone_dev(dev, &DEVFS_CLONE_BITMAP(tun)); 188 break; 189 190 default: 191 return (EOPNOTSUPP); 192 } 193 194 return (0); 195 } 196 197 static int 198 tunclone(struct dev_clone_args *ap) 199 { 200 int unit; 201 202 unit = devfs_clone_bitmap_get(&DEVFS_CLONE_BITMAP(tun), 0); 203 ap->a_dev = make_only_dev(&tun_ops, unit, UID_UUCP, GID_DIALER, 204 0600, "%s%d", TUN, unit); 205 206 if (tuncreate(ap->a_dev, 0) == NULL) 207 return (ENOMEM); 208 else 209 return (0); 210 } 211 212 static struct tun_softc * 213 tuncreate(cdev_t dev, int flags) 214 { 215 struct tun_softc *sc; 216 struct ifnet *ifp; 217 int unit = minor(dev); 218 219 sc = kmalloc(sizeof(*sc), M_TUN, M_WAITOK | M_ZERO); 220 dev->si_drv1 = sc; 221 sc->tun_dev = dev; 222 sc->tun_flags = TUN_INITED; 223 sc->tun_flags |= flags; 224 225 reference_dev(dev); /* device association */ 226 227 ifp = sc->tun_ifp = if_alloc(IFT_PPP); 228 if (ifp == NULL) { 229 kprintf("%s: failed to if_alloc() interface for %s%d", 230 __func__, TUN, unit); 231 return (NULL); 232 } 233 234 if_initname(ifp, TUN, unit); 235 ifp->if_mtu = TUNMTU; 236 ifp->if_ioctl = tunifioctl; 237 ifp->if_output = tunifoutput; 238 ifp->if_start = tunifstart; 239 ifp->if_flags = IFF_POINTOPOINT | IFF_MULTICAST; 240 ifp->if_type = IFT_PPP; 241 ifp->if_softc = sc; 242 ifq_set_maxlen(&ifp->if_snd, ifqmaxlen); 243 ifq_set_ready(&ifp->if_snd); 244 245 if_attach(ifp, NULL); 246 bpfattach(ifp, DLT_NULL, sizeof(u_int)); 247 248 SLIST_INSERT_HEAD(&tun_listhead, sc, tun_link); 249 TUNDEBUG(ifp, "created, minor = %#x, flags = 0x%x\n", 250 unit, sc->tun_flags); 251 return (sc); 252 } 253 254 static void 255 tundestroy(struct tun_softc *sc) 256 { 257 cdev_t dev = sc->tun_dev; 258 struct ifnet *ifp = sc->tun_ifp; 259 int unit = minor(dev); 260 261 TUNDEBUG(ifp, "destroyed, minor = %#x. Module refcnt = %d\n", 262 unit, tunrefcnt); 263 264 bpfdetach(ifp); 265 if_detach(ifp); 266 if_free(ifp); 267 268 sc->tun_dev = NULL; 269 dev->si_drv1 = NULL; 270 release_dev(dev); /* device disassociation */ 271 272 /* Also destroy the cloned device */ 273 if (unit >= TUN_PREALLOCATED_UNITS) { 274 destroy_dev(dev); 275 devfs_clone_bitmap_put(&DEVFS_CLONE_BITMAP(tun), unit); 276 } 277 278 SLIST_REMOVE(&tun_listhead, sc, tun_softc, tun_link); 279 kfree(sc, M_TUN); 280 } 281 282 /* 283 * tunnel open - must be superuser & the device must be configured in 284 */ 285 static int 286 tunopen(struct dev_open_args *ap) 287 { 288 cdev_t dev = ap->a_head.a_dev; 289 struct ifnet *ifp; 290 struct tun_softc *sc; 291 int error; 292 293 if ((error = priv_check_cred(ap->a_cred, PRIV_ROOT, 0)) != 0) 294 return (error); 295 296 sc = dev->si_drv1; 297 if (sc == NULL && (sc = tuncreate(dev, TUN_MANUALMAKE)) == NULL) 298 return (ENOMEM); 299 if (sc->tun_flags & TUN_OPEN) 300 return (EBUSY); 301 302 ifp = sc->tun_ifp; 303 if ((sc->tun_flags & TUN_CLONE) == 0) { 304 EVENTHANDLER_INVOKE(ifnet_attach_event, ifp); 305 306 /* Announce the return of the interface. */ 307 rt_ifannouncemsg(ifp, IFAN_ARRIVAL); 308 } 309 310 sc->tun_pid = curproc->p_pid; 311 sc->tun_flags |= TUN_OPEN; 312 tunrefcnt++; 313 314 TUNDEBUG(ifp, "opened, minor = %#x. Module refcnt = %d\n", 315 minor(dev), tunrefcnt); 316 return (0); 317 } 318 319 /* 320 * close the device - mark interface down & delete routing info 321 */ 322 static int 323 tunclose(struct dev_close_args *ap) 324 { 325 cdev_t dev = ap->a_head.a_dev; 326 struct tun_softc *sc = dev->si_drv1; 327 struct ifnet *ifp = sc->tun_ifp; 328 int unit = minor(dev); 329 330 sc->tun_flags &= ~TUN_OPEN; 331 sc->tun_pid = 0; 332 333 /* Junk all pending output. */ 334 ifq_purge_all(&ifp->if_snd); 335 336 if (ifp->if_flags & IFF_UP) 337 if_down(ifp); 338 ifp->if_flags &= ~IFF_RUNNING; 339 340 if ((sc->tun_flags & TUN_CLONE) == 0) { 341 if_purgeaddrs_nolink(ifp); 342 343 EVENTHANDLER_INVOKE(ifnet_detach_event, ifp); 344 345 /* Announce the departure of the interface. */ 346 rt_ifannouncemsg(ifp, IFAN_DEPARTURE); 347 } 348 349 funsetown(&sc->tun_sigio); 350 KNOTE(&sc->tun_rkq.ki_note, 0); 351 352 tunrefcnt--; 353 if (tunrefcnt < 0) { 354 tunrefcnt = 0; 355 if_printf(ifp, ". Module refcnt = %d is out of sync! " 356 "Force refcnt to be 0.\n", tunrefcnt); 357 } 358 359 TUNDEBUG(ifp, "closed, minor = %#x. Module refcnt = %d\n", 360 unit, tunrefcnt); 361 362 /* Only auto-destroy if the interface was not manually created. */ 363 if ((sc->tun_flags & TUN_MANUALMAKE) == 0 && 364 unit >= TUN_PREALLOCATED_UNITS) { 365 tundestroy(sc); 366 dev->si_drv1 = NULL; 367 } 368 369 return (0); 370 } 371 372 373 /* 374 * Interface clone support 375 * 376 * Create and destroy tun device/interface via ifconfig(8). 377 */ 378 379 static struct tun_softc * 380 tunfind(int unit) 381 { 382 struct tun_softc *sc; 383 384 SLIST_FOREACH(sc, &tun_listhead, tun_link) { 385 if (minor(sc->tun_dev) == unit) 386 return (sc); 387 } 388 return (NULL); 389 } 390 391 static int 392 tun_clone_create(struct if_clone *ifc __unused, int unit, 393 caddr_t param __unused) 394 { 395 struct tun_softc *sc; 396 cdev_t dev; 397 398 sc = tunfind(unit); 399 if (sc == NULL) { 400 if (!devfs_clone_bitmap_chk(&DEVFS_CLONE_BITMAP(tun), unit)) { 401 devfs_clone_bitmap_set(&DEVFS_CLONE_BITMAP(tun), unit); 402 dev = make_dev(&tun_ops, unit, UID_UUCP, GID_DIALER, 403 0600, "%s%d", TUN, unit); 404 } else { 405 dev = devfs_find_device_by_name("%s%d", TUN, unit); 406 } 407 408 if (dev == NULL) 409 return (ENODEV); 410 if ((sc = tuncreate(dev, TUN_MANUALMAKE)) == NULL) 411 return (ENOMEM); 412 } 413 414 sc->tun_flags |= TUN_CLONE; 415 TUNDEBUG(sc->tun_ifp, "clone created, minor = %#x, flags = 0x%x\n", 416 minor(sc->tun_dev), sc->tun_flags); 417 418 return (0); 419 } 420 421 static int 422 tun_clone_destroy(struct ifnet * ifp) 423 { 424 struct tun_softc *sc = ifp->if_softc; 425 426 if ((sc->tun_flags & TUN_CLONE) == 0) 427 return (ENXIO); 428 429 TUNDEBUG(ifp, "clone destroyed, minor = %#x, flags = 0x%x\n", 430 minor(sc->tun_dev), sc->tun_flags); 431 tundestroy(sc); 432 433 return (0); 434 } 435 436 437 /* 438 * Network interface functions 439 */ 440 441 static int 442 tunifinit(struct ifnet *ifp) 443 { 444 #ifdef INET 445 struct tun_softc *sc = ifp->if_softc; 446 #endif 447 struct ifaddr_container *ifac; 448 int error = 0; 449 450 TUNDEBUG(ifp, "initialize\n"); 451 452 ifp->if_flags |= IFF_UP | IFF_RUNNING; 453 getmicrotime(&ifp->if_lastchange); 454 455 TAILQ_FOREACH(ifac, &ifp->if_addrheads[mycpuid], ifa_link) { 456 struct ifaddr *ifa = ifac->ifa; 457 458 if (ifa->ifa_addr == NULL) { 459 error = EFAULT; 460 /* XXX: Should maybe return straight off? */ 461 } else { 462 #ifdef INET 463 if (ifa->ifa_addr->sa_family == AF_INET) { 464 struct sockaddr_in *si; 465 466 si = (struct sockaddr_in *)ifa->ifa_addr; 467 if (si->sin_addr.s_addr) 468 sc->tun_flags |= TUN_IASET; 469 } 470 #endif 471 } 472 } 473 return (error); 474 } 475 476 /* 477 * Process an ioctl request. 478 * 479 * MPSAFE 480 */ 481 static int 482 tunifioctl(struct ifnet *ifp, u_long cmd, caddr_t data, struct ucred *cr) 483 { 484 struct ifreq *ifr = (struct ifreq *)data; 485 struct tun_softc *sc = ifp->if_softc; 486 struct ifstat *ifs; 487 int error = 0; 488 489 switch (cmd) { 490 case SIOCGIFSTATUS: 491 ifs = (struct ifstat *)data; 492 if (sc->tun_pid) 493 ksprintf(ifs->ascii + strlen(ifs->ascii), 494 "\tOpened by PID %d\n", sc->tun_pid); 495 break; 496 case SIOCSIFADDR: 497 error = tunifinit(ifp); 498 TUNDEBUG(ifp, "address set, error=%d\n", error); 499 break; 500 case SIOCSIFDSTADDR: 501 error = tunifinit(ifp); 502 TUNDEBUG(ifp, "destination address set, error=%d\n", error); 503 break; 504 case SIOCSIFMTU: 505 ifp->if_mtu = ifr->ifr_mtu; 506 TUNDEBUG(ifp, "mtu set\n"); 507 break; 508 case SIOCSIFFLAGS: 509 case SIOCADDMULTI: 510 case SIOCDELMULTI: 511 break; 512 default: 513 error = EINVAL; 514 } 515 return (error); 516 } 517 518 /* 519 * Start packet transmission on the interface. 520 * when the interface queue is rate-limited by ALTQ, 521 * if_start is needed to drain packets from the queue in order 522 * to notify readers when outgoing packets become ready. 523 */ 524 static void 525 tunifstart(struct ifnet *ifp, struct ifaltq_subque *ifsq) 526 { 527 struct tun_softc *sc = ifp->if_softc; 528 struct mbuf *m; 529 530 ASSERT_ALTQ_SQ_DEFAULT(ifp, ifsq); 531 532 if (!ifq_is_enabled(&ifp->if_snd)) 533 return; 534 535 m = ifsq_poll(ifsq); 536 if (m != NULL) { 537 if (sc->tun_flags & TUN_RWAIT) { 538 sc->tun_flags &= ~TUN_RWAIT; 539 wakeup((caddr_t)sc); 540 } 541 if (sc->tun_flags & TUN_ASYNC && sc->tun_sigio) 542 pgsigio(sc->tun_sigio, SIGIO, 0); 543 ifsq_deserialize_hw(ifsq); 544 KNOTE(&sc->tun_rkq.ki_note, 0); 545 ifsq_serialize_hw(ifsq); 546 } 547 } 548 549 /* 550 * tunifoutput - queue packets from higher level ready to put out. 551 * 552 * MPSAFE 553 */ 554 static int 555 tunifoutput_serialized(struct ifnet *ifp, struct mbuf *m0, 556 struct sockaddr *dst, struct rtentry *rt) 557 { 558 struct tun_softc *sc = ifp->if_softc; 559 int error; 560 struct altq_pktattr pktattr; 561 562 TUNDEBUG(ifp, "output\n"); 563 564 if ((sc->tun_flags & TUN_READY) != TUN_READY) { 565 TUNDEBUG(ifp, "not ready, flags = 0x%x\n", sc->tun_flags); 566 m_freem (m0); 567 return (EHOSTDOWN); 568 } 569 570 /* 571 * if the queueing discipline needs packet classification, 572 * do it before prepending link headers. 573 */ 574 ifq_classify(&ifp->if_snd, m0, dst->sa_family, &pktattr); 575 576 /* BPF write needs to be handled specially */ 577 if (dst->sa_family == AF_UNSPEC) { 578 dst->sa_family = *(mtod(m0, int *)); 579 m0->m_len -= sizeof(int); 580 m0->m_pkthdr.len -= sizeof(int); 581 m0->m_data += sizeof(int); 582 } 583 584 if (ifp->if_bpf) { 585 bpf_gettoken(); 586 if (ifp->if_bpf) { 587 /* 588 * We need to prepend the address family as 589 * a four byte field. 590 */ 591 uint32_t af = dst->sa_family; 592 593 bpf_ptap(ifp->if_bpf, m0, &af, sizeof(af)); 594 } 595 bpf_reltoken(); 596 } 597 598 /* prepend sockaddr? this may abort if the mbuf allocation fails */ 599 if (sc->tun_flags & TUN_LMODE) { 600 /* allocate space for sockaddr */ 601 M_PREPEND(m0, dst->sa_len, M_NOWAIT); 602 603 /* if allocation failed drop packet */ 604 if (m0 == NULL){ 605 IFNET_STAT_INC(ifp, oerrors, 1); 606 return (ENOBUFS); 607 } else { 608 bcopy(dst, m0->m_data, dst->sa_len); 609 } 610 } 611 612 if (sc->tun_flags & TUN_IFHEAD) { 613 /* Prepend the address family */ 614 M_PREPEND(m0, 4, M_NOWAIT); 615 616 /* if allocation failed drop packet */ 617 if (m0 == NULL){ 618 IFNET_STAT_INC(ifp, oerrors, 1); 619 return (ENOBUFS); 620 } else { 621 *(u_int32_t *)m0->m_data = htonl(dst->sa_family); 622 } 623 } else { 624 #ifdef INET 625 if (dst->sa_family != AF_INET) 626 #endif 627 { 628 m_freem(m0); 629 return (EAFNOSUPPORT); 630 } 631 } 632 633 error = ifq_handoff(ifp, m0, &pktattr); 634 if (error) { 635 IFNET_STAT_INC(ifp, collisions, 1); 636 } else { 637 IFNET_STAT_INC(ifp, opackets, 1); 638 if (sc->tun_flags & TUN_RWAIT) { 639 sc->tun_flags &= ~TUN_RWAIT; 640 wakeup((caddr_t)sc); 641 } 642 get_mplock(); 643 if (sc->tun_flags & TUN_ASYNC && sc->tun_sigio) 644 pgsigio(sc->tun_sigio, SIGIO, 0); 645 rel_mplock(); 646 ifnet_deserialize_all(ifp); 647 KNOTE(&sc->tun_rkq.ki_note, 0); 648 ifnet_serialize_all(ifp); 649 } 650 return (error); 651 } 652 653 static int 654 tunifoutput(struct ifnet *ifp, struct mbuf *m0, struct sockaddr *dst, 655 struct rtentry *rt) 656 { 657 int error; 658 659 ifnet_serialize_all(ifp); 660 error = tunifoutput_serialized(ifp, m0, dst, rt); 661 ifnet_deserialize_all(ifp); 662 663 return (error); 664 } 665 666 667 /* 668 * the ops interface is now pretty minimal. 669 */ 670 static int 671 tunioctl(struct dev_ioctl_args *ap) 672 { 673 cdev_t dev = ap->a_head.a_dev; 674 caddr_t data = ap->a_data; 675 struct tun_softc *sc = dev->si_drv1; 676 struct ifnet *ifp = sc->tun_ifp; 677 struct ifreq *ifr; 678 struct tuninfo *tunp; 679 int error = 0; 680 681 switch (ap->a_cmd) { 682 case TUNSIFINFO: 683 tunp = (struct tuninfo *)data; 684 if (ifp->if_type != tunp->type) 685 return (EPROTOTYPE); 686 if (tunp->mtu < IF_MINMTU) 687 return (EINVAL); 688 ifp->if_mtu = tunp->mtu; 689 ifp->if_baudrate = tunp->baudrate; 690 break; 691 692 case TUNGIFINFO: 693 tunp = (struct tuninfo *)data; 694 tunp->mtu = ifp->if_mtu; 695 tunp->type = ifp->if_type; 696 tunp->baudrate = ifp->if_baudrate; 697 break; 698 699 case TUNGIFNAME: 700 ifr = (struct ifreq *)data; 701 strlcpy(ifr->ifr_name, ifp->if_xname, IFNAMSIZ); 702 break; 703 704 case TUNSDEBUG: 705 tundebug = *(int *)data; 706 break; 707 708 case TUNGDEBUG: 709 *(int *)data = tundebug; 710 break; 711 712 case TUNSLMODE: 713 if (*(int *)data) { 714 sc->tun_flags |= TUN_LMODE; 715 sc->tun_flags &= ~TUN_IFHEAD; 716 } else { 717 sc->tun_flags &= ~TUN_LMODE; 718 } 719 break; 720 721 case TUNSIFHEAD: 722 if (*(int *)data) { 723 sc->tun_flags |= TUN_IFHEAD; 724 sc->tun_flags &= ~TUN_LMODE; 725 } else { 726 sc->tun_flags &= ~TUN_IFHEAD; 727 } 728 break; 729 730 case TUNGIFHEAD: 731 *(int *)data = (sc->tun_flags & TUN_IFHEAD) ? 1 : 0; 732 break; 733 734 case TUNSIFMODE: 735 /* deny this if UP */ 736 if (ifp->if_flags & IFF_UP) 737 return (EBUSY); 738 739 switch (*(int *)data & ~IFF_MULTICAST) { 740 case IFF_POINTOPOINT: 741 case IFF_BROADCAST: 742 ifp->if_flags &= ~(IFF_BROADCAST | IFF_POINTOPOINT); 743 ifp->if_flags |= *(int *)data; 744 break; 745 default: 746 return (EINVAL); 747 } 748 break; 749 750 case TUNSIFPID: 751 sc->tun_pid = curproc->p_pid; 752 break; 753 754 case FIOASYNC: 755 if (*(int *)data) 756 sc->tun_flags |= TUN_ASYNC; 757 else 758 sc->tun_flags &= ~TUN_ASYNC; 759 break; 760 761 case FIONREAD: 762 *(int *)data = ifsq_poll_pktlen( 763 ifq_get_subq_default(&ifp->if_snd)); 764 break; 765 766 case FIOSETOWN: 767 error = fsetown(*(int *)data, &sc->tun_sigio); 768 break; 769 770 case FIOGETOWN: 771 *(int *)data = fgetown(&sc->tun_sigio); 772 break; 773 774 /* This is deprecated, FIOSETOWN should be used instead. */ 775 case TIOCSPGRP: 776 error = fsetown(-(*(int *)data), &sc->tun_sigio); 777 break; 778 779 /* This is deprecated, FIOGETOWN should be used instead. */ 780 case TIOCGPGRP: 781 *(int *)data = -fgetown(&sc->tun_sigio); 782 break; 783 784 default: 785 error = ENOTTY; 786 break; 787 } 788 789 return (error); 790 } 791 792 /* 793 * The ops read interface - reads a packet at a time, or at 794 * least as much of a packet as can be read. 795 */ 796 static int 797 tunread(struct dev_read_args *ap) 798 { 799 cdev_t dev = ap->a_head.a_dev; 800 struct uio *uio = ap->a_uio; 801 struct tun_softc *sc = dev->si_drv1; 802 struct ifnet *ifp = sc->tun_ifp; 803 struct ifaltq_subque *ifsq = ifq_get_subq_default(&ifp->if_snd); 804 struct mbuf *m0; 805 int error=0, len; 806 807 TUNDEBUG(ifp, "read\n"); 808 if ((sc->tun_flags & TUN_READY) != TUN_READY) { 809 TUNDEBUG(ifp, "not ready, flags = 0x%x\n", sc->tun_flags); 810 return (EHOSTDOWN); 811 } 812 813 sc->tun_flags &= ~TUN_RWAIT; 814 815 ifnet_serialize_all(ifp); 816 817 while ((m0 = ifsq_dequeue(ifsq)) == NULL) { 818 if (ap->a_ioflag & IO_NDELAY) { 819 ifnet_deserialize_all(ifp); 820 return (EWOULDBLOCK); 821 } 822 sc->tun_flags |= TUN_RWAIT; 823 ifnet_deserialize_all(ifp); 824 if ((error = tsleep(sc, PCATCH, "tunread", 0)) != 0) 825 return (error); 826 ifnet_serialize_all(ifp); 827 } 828 829 ifnet_deserialize_all(ifp); 830 831 while (m0 && uio->uio_resid > 0 && error == 0) { 832 len = (int)szmin(uio->uio_resid, m0->m_len); 833 if (len != 0) 834 error = uiomove(mtod(m0, caddr_t), (size_t)len, uio); 835 m0 = m_free(m0); 836 } 837 838 if (m0) { 839 TUNDEBUG(ifp, "dropping mbuf\n"); 840 m_freem(m0); 841 } 842 return (error); 843 } 844 845 /* 846 * the ops write interface - an atomic write is a packet - or else! 847 */ 848 static int 849 tunwrite(struct dev_write_args *ap) 850 { 851 cdev_t dev = ap->a_head.a_dev; 852 struct uio *uio = ap->a_uio; 853 struct tun_softc *sc = dev->si_drv1; 854 struct ifnet *ifp = sc->tun_ifp; 855 struct mbuf *top, **mp, *m; 856 size_t tlen; 857 uint32_t family, mru; 858 int error = 0; 859 int isr; 860 861 TUNDEBUG(ifp, "tunwrite\n"); 862 863 if (uio->uio_resid == 0) 864 return (0); 865 866 mru = TUNMRU; 867 if (sc->tun_flags & TUN_IFHEAD) 868 mru += sizeof(family); 869 if (uio->uio_resid > mru) { 870 TUNDEBUG(ifp, "len = %zd!\n", uio->uio_resid); 871 return (EIO); 872 } 873 874 /* get a header mbuf */ 875 MGETHDR(m, M_WAITOK, MT_DATA); 876 if (m == NULL) 877 return (ENOBUFS); 878 879 tlen = uio->uio_resid; 880 top = NULL; 881 mp = ⊤ 882 while (error == 0 && uio->uio_resid > 0) { 883 m->m_len = (int)szmin(MHLEN, uio->uio_resid); 884 error = uiomove(mtod(m, caddr_t), (size_t)m->m_len, uio); 885 *mp = m; 886 mp = &m->m_next; 887 if (uio->uio_resid > 0) { 888 MGET(m, M_WAITOK, MT_DATA); 889 if (m == NULL) { 890 error = ENOBUFS; 891 break; 892 } 893 } 894 } 895 if (error) { 896 if (top) 897 m_freem(top); 898 IFNET_STAT_INC(ifp, ierrors, 1); 899 return (error); 900 } 901 902 top->m_pkthdr.len = (int)tlen; 903 top->m_pkthdr.rcvif = ifp; 904 905 if (ifp->if_bpf) { 906 bpf_gettoken(); 907 908 if (ifp->if_bpf) { 909 if (sc->tun_flags & TUN_IFHEAD) { 910 /* 911 * Conveniently, we already have a 4-byte 912 * address family prepended to our packet ! 913 * Inconveniently, it's in the wrong byte 914 * order ! 915 */ 916 if ((top = m_pullup(top, sizeof(family))) 917 == NULL) { 918 bpf_reltoken(); 919 return (ENOBUFS); 920 } 921 *mtod(top, u_int32_t *) = 922 ntohl(*mtod(top, u_int32_t *)); 923 bpf_mtap(ifp->if_bpf, top); 924 *mtod(top, u_int32_t *) = 925 htonl(*mtod(top, u_int32_t *)); 926 } else { 927 /* 928 * We need to prepend the address family as 929 * a four byte field. 930 */ 931 static const uint32_t af = AF_INET; 932 933 bpf_ptap(ifp->if_bpf, top, &af, sizeof(af)); 934 } 935 } 936 937 bpf_reltoken(); 938 } 939 940 if (sc->tun_flags & TUN_IFHEAD) { 941 if (top->m_len < sizeof(family) && 942 (top = m_pullup(top, sizeof(family))) == NULL) 943 return (ENOBUFS); 944 family = ntohl(*mtod(top, u_int32_t *)); 945 m_adj(top, sizeof(family)); 946 } else { 947 family = AF_INET; 948 } 949 950 IFNET_STAT_INC(ifp, ibytes, top->m_pkthdr.len); 951 IFNET_STAT_INC(ifp, ipackets, 1); 952 953 switch (family) { 954 #ifdef INET 955 case AF_INET: 956 isr = NETISR_IP; 957 break; 958 #endif 959 #ifdef INET6 960 case AF_INET6: 961 isr = NETISR_IPV6; 962 break; 963 #endif 964 default: 965 m_freem(m); 966 return (EAFNOSUPPORT); 967 } 968 969 netisr_queue(isr, top); 970 return (0); 971 } 972 973 974 /* 975 * tunkqfilter - support for the kevent() system call. 976 */ 977 static int 978 tunkqfilter(struct dev_kqfilter_args *ap) 979 { 980 cdev_t dev = ap->a_head.a_dev; 981 struct tun_softc *sc = dev->si_drv1; 982 struct ifnet *ifp = sc->tun_ifp; 983 struct knote *kn = ap->a_kn; 984 struct klist *klist; 985 986 ap->a_result = 0; 987 ifnet_serialize_all(ifp); 988 989 switch (kn->kn_filter) { 990 case EVFILT_READ: 991 kn->kn_fop = &tun_read_filtops; 992 kn->kn_hook = (caddr_t)sc; 993 break; 994 case EVFILT_WRITE: 995 kn->kn_fop = &tun_write_filtops; 996 kn->kn_hook = (caddr_t)sc; 997 break; 998 default: 999 ifnet_deserialize_all(ifp); 1000 ap->a_result = EOPNOTSUPP; 1001 return (0); 1002 } 1003 1004 klist = &sc->tun_rkq.ki_note; 1005 knote_insert(klist, kn); 1006 ifnet_deserialize_all(ifp); 1007 1008 return (0); 1009 } 1010 1011 static void 1012 tun_filter_detach(struct knote *kn) 1013 { 1014 struct tun_softc *sc = (struct tun_softc *)kn->kn_hook; 1015 struct klist *klist = &sc->tun_rkq.ki_note; 1016 1017 knote_remove(klist, kn); 1018 } 1019 1020 static int 1021 tun_filter_write(struct knote *kn, long hint) 1022 { 1023 /* Always ready for a write */ 1024 return (1); 1025 } 1026 1027 static int 1028 tun_filter_read(struct knote *kn, long hint) 1029 { 1030 struct tun_softc *sc = (struct tun_softc *)kn->kn_hook; 1031 struct ifnet *ifp = sc->tun_ifp; 1032 int ready = 0; 1033 1034 ifnet_serialize_all(ifp); 1035 if (!ifsq_is_empty(ifq_get_subq_default(&ifp->if_snd))) 1036 ready = 1; 1037 ifnet_deserialize_all(ifp); 1038 1039 return (ready); 1040 } 1041