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