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 * $DragonFly: src/sys/net/tun/if_tun.c,v 1.37 2008/06/05 18:06:32 swildner Exp $ 18 */ 19 20 #include "opt_atalk.h" 21 #include "opt_inet.h" 22 #include "opt_inet6.h" 23 #include "opt_ipx.h" 24 25 #include <sys/param.h> 26 #include <sys/proc.h> 27 #include <sys/priv.h> 28 #include <sys/systm.h> 29 #include <sys/mbuf.h> 30 #include <sys/socket.h> 31 #include <sys/conf.h> 32 #include <sys/device.h> 33 #include <sys/filio.h> 34 #include <sys/sockio.h> 35 #include <sys/thread2.h> 36 #include <sys/ttycom.h> 37 #include <sys/poll.h> 38 #include <sys/signalvar.h> 39 #include <sys/filedesc.h> 40 #include <sys/kernel.h> 41 #include <sys/sysctl.h> 42 #include <sys/uio.h> 43 #include <sys/vnode.h> 44 #include <sys/malloc.h> 45 46 #include <net/if.h> 47 #include <net/if_types.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 <net/bpf.h> 57 58 #include "if_tunvar.h" 59 #include "if_tun.h" 60 61 static MALLOC_DEFINE(M_TUN, "tun", "Tunnel Interface"); 62 63 static void tunattach (void *); 64 PSEUDO_SET(tunattach, if_tun); 65 66 static void tuncreate (cdev_t dev); 67 68 #define TUNDEBUG if (tundebug) if_printf 69 static int tundebug = 0; 70 SYSCTL_INT(_debug, OID_AUTO, if_tun_debug, CTLFLAG_RW, &tundebug, 0, ""); 71 72 static int tunoutput (struct ifnet *, struct mbuf *, struct sockaddr *, 73 struct rtentry *rt); 74 static int tunifioctl (struct ifnet *, u_long, caddr_t, struct ucred *); 75 static int tuninit (struct ifnet *); 76 static void tunstart(struct ifnet *); 77 78 static d_open_t tunopen; 79 static d_close_t tunclose; 80 static d_read_t tunread; 81 static d_write_t tunwrite; 82 static d_ioctl_t tunioctl; 83 static d_poll_t tunpoll; 84 85 #define CDEV_MAJOR 52 86 static struct dev_ops tun_ops = { 87 { "tun", CDEV_MAJOR, 0 }, 88 .d_open = tunopen, 89 .d_close = tunclose, 90 .d_read = tunread, 91 .d_write = tunwrite, 92 .d_ioctl = tunioctl, 93 .d_poll = tunpoll, 94 }; 95 96 static void 97 tunattach(void *dummy) 98 { 99 dev_ops_add(&tun_ops, 0, 0); 100 } 101 102 static void 103 tuncreate(cdev_t dev) 104 { 105 struct tun_softc *sc; 106 struct ifnet *ifp; 107 108 dev = make_dev(&tun_ops, minor(dev), 109 UID_UUCP, GID_DIALER, 0600, "tun%d", lminor(dev)); 110 111 MALLOC(sc, struct tun_softc *, sizeof(*sc), M_TUN, M_WAITOK | M_ZERO); 112 sc->tun_flags = TUN_INITED; 113 114 ifp = &sc->tun_if; 115 if_initname(ifp, "tun", lminor(dev)); 116 ifp->if_mtu = TUNMTU; 117 ifp->if_ioctl = tunifioctl; 118 ifp->if_output = tunoutput; 119 ifp->if_start = tunstart; 120 ifp->if_flags = IFF_POINTOPOINT | IFF_MULTICAST; 121 ifp->if_type = IFT_PPP; 122 ifq_set_maxlen(&ifp->if_snd, ifqmaxlen); 123 ifq_set_ready(&ifp->if_snd); 124 ifp->if_softc = sc; 125 if_attach(ifp, NULL); 126 bpfattach(ifp, DLT_NULL, sizeof(u_int)); 127 dev->si_drv1 = sc; 128 } 129 130 /* 131 * tunnel open - must be superuser & the device must be 132 * configured in 133 */ 134 static int 135 tunopen(struct dev_open_args *ap) 136 { 137 cdev_t dev = ap->a_head.a_dev; 138 struct ifnet *ifp; 139 struct tun_softc *tp; 140 int error; 141 142 if ((error = priv_check_cred(ap->a_cred, PRIV_ROOT, 0)) != 0) 143 return (error); 144 145 tp = dev->si_drv1; 146 if (!tp) { 147 tuncreate(dev); 148 tp = dev->si_drv1; 149 } 150 if (tp->tun_flags & TUN_OPEN) 151 return EBUSY; 152 tp->tun_pid = curproc->p_pid; 153 ifp = &tp->tun_if; 154 tp->tun_flags |= TUN_OPEN; 155 TUNDEBUG(ifp, "open\n"); 156 return (0); 157 } 158 159 /* 160 * tunclose - close the device - mark i/f down & delete 161 * routing info 162 */ 163 static int 164 tunclose(struct dev_close_args *ap) 165 { 166 cdev_t dev = ap->a_head.a_dev; 167 struct tun_softc *tp; 168 struct ifnet *ifp; 169 170 tp = dev->si_drv1; 171 ifp = &tp->tun_if; 172 173 tp->tun_flags &= ~TUN_OPEN; 174 tp->tun_pid = 0; 175 176 /* Junk all pending output. */ 177 ifq_purge(&ifp->if_snd); 178 179 if (ifp->if_flags & IFF_UP) 180 if_down(ifp); 181 ifp->if_flags &= ~IFF_RUNNING; 182 if_purgeaddrs_nolink(ifp); 183 184 funsetown(tp->tun_sigio); 185 selwakeup(&tp->tun_rsel); 186 187 TUNDEBUG(ifp, "closed\n"); 188 return (0); 189 } 190 191 static int 192 tuninit(struct ifnet *ifp) 193 { 194 struct tun_softc *tp = ifp->if_softc; 195 struct ifaddr_container *ifac; 196 int error = 0; 197 198 TUNDEBUG(ifp, "tuninit\n"); 199 200 ifp->if_flags |= IFF_UP | IFF_RUNNING; 201 getmicrotime(&ifp->if_lastchange); 202 203 TAILQ_FOREACH(ifac, &ifp->if_addrheads[mycpuid], ifa_link) { 204 struct ifaddr *ifa = ifac->ifa; 205 206 if (ifa->ifa_addr == NULL) { 207 error = EFAULT; 208 /* XXX: Should maybe return straight off? */ 209 } else { 210 #ifdef INET 211 if (ifa->ifa_addr->sa_family == AF_INET) { 212 struct sockaddr_in *si; 213 214 si = (struct sockaddr_in *)ifa->ifa_addr; 215 if (si->sin_addr.s_addr) 216 tp->tun_flags |= TUN_IASET; 217 } 218 #endif 219 } 220 } 221 return (error); 222 } 223 224 /* 225 * Process an ioctl request. 226 * 227 * MPSAFE 228 */ 229 int 230 tunifioctl(struct ifnet *ifp, u_long cmd, caddr_t data, struct ucred *cr) 231 { 232 struct ifreq *ifr = (struct ifreq *)data; 233 struct tun_softc *tp = ifp->if_softc; 234 struct ifstat *ifs; 235 int error = 0; 236 237 switch(cmd) { 238 case SIOCGIFSTATUS: 239 ifs = (struct ifstat *)data; 240 if (tp->tun_pid) 241 ksprintf(ifs->ascii + strlen(ifs->ascii), 242 "\tOpened by PID %d\n", tp->tun_pid); 243 break; 244 case SIOCSIFADDR: 245 error = tuninit(ifp); 246 TUNDEBUG(ifp, "address set, error=%d\n", error); 247 break; 248 case SIOCSIFDSTADDR: 249 error = tuninit(ifp); 250 TUNDEBUG(ifp, "destination address set, error=%d\n", error); 251 break; 252 case SIOCSIFMTU: 253 ifp->if_mtu = ifr->ifr_mtu; 254 TUNDEBUG(ifp, "mtu set\n"); 255 break; 256 case SIOCSIFFLAGS: 257 case SIOCADDMULTI: 258 case SIOCDELMULTI: 259 break; 260 default: 261 error = EINVAL; 262 } 263 return (error); 264 } 265 266 /* 267 * tunoutput - queue packets from higher level ready to put out. 268 * 269 * MPSAFE 270 */ 271 static int 272 tunoutput_serialized(struct ifnet *ifp, struct mbuf *m0, struct sockaddr *dst, 273 struct rtentry *rt) 274 { 275 struct tun_softc *tp = ifp->if_softc; 276 int error; 277 struct altq_pktattr pktattr; 278 279 TUNDEBUG(ifp, "tunoutput\n"); 280 281 if ((tp->tun_flags & TUN_READY) != TUN_READY) { 282 TUNDEBUG(ifp, "not ready 0%o\n", tp->tun_flags); 283 m_freem (m0); 284 return EHOSTDOWN; 285 } 286 287 /* 288 * if the queueing discipline needs packet classification, 289 * do it before prepending link headers. 290 */ 291 ifq_classify(&ifp->if_snd, m0, dst->sa_family, &pktattr); 292 293 /* BPF write needs to be handled specially */ 294 if (dst->sa_family == AF_UNSPEC) { 295 dst->sa_family = *(mtod(m0, int *)); 296 m0->m_len -= sizeof(int); 297 m0->m_pkthdr.len -= sizeof(int); 298 m0->m_data += sizeof(int); 299 } 300 301 if (ifp->if_bpf) { 302 /* 303 * We need to prepend the address family as 304 * a four byte field. 305 */ 306 uint32_t af = dst->sa_family; 307 308 bpf_ptap(ifp->if_bpf, m0, &af, sizeof(af)); 309 } 310 311 /* prepend sockaddr? this may abort if the mbuf allocation fails */ 312 if (tp->tun_flags & TUN_LMODE) { 313 /* allocate space for sockaddr */ 314 M_PREPEND(m0, dst->sa_len, MB_DONTWAIT); 315 316 /* if allocation failed drop packet */ 317 if (m0 == NULL){ 318 IF_DROP(&ifp->if_snd); 319 ifp->if_oerrors++; 320 return (ENOBUFS); 321 } else { 322 bcopy(dst, m0->m_data, dst->sa_len); 323 } 324 } 325 326 if (tp->tun_flags & TUN_IFHEAD) { 327 /* Prepend the address family */ 328 M_PREPEND(m0, 4, MB_DONTWAIT); 329 330 /* if allocation failed drop packet */ 331 if (m0 == NULL){ 332 IF_DROP(&ifp->if_snd); 333 ifp->if_oerrors++; 334 return ENOBUFS; 335 } else 336 *(u_int32_t *)m0->m_data = htonl(dst->sa_family); 337 } else { 338 #ifdef INET 339 if (dst->sa_family != AF_INET) 340 #endif 341 { 342 m_freem(m0); 343 return EAFNOSUPPORT; 344 } 345 } 346 347 error = ifq_handoff(ifp, m0, &pktattr); 348 if (error) { 349 ifp->if_collisions++; 350 } else { 351 ifp->if_opackets++; 352 if (tp->tun_flags & TUN_RWAIT) { 353 tp->tun_flags &= ~TUN_RWAIT; 354 wakeup((caddr_t)tp); 355 } 356 get_mplock(); 357 if (tp->tun_flags & TUN_ASYNC && tp->tun_sigio) 358 pgsigio(tp->tun_sigio, SIGIO, 0); 359 selwakeup(&tp->tun_rsel); 360 rel_mplock(); 361 } 362 return (error); 363 } 364 365 static int 366 tunoutput(struct ifnet *ifp, struct mbuf *m0, struct sockaddr *dst, 367 struct rtentry *rt) 368 { 369 int error; 370 371 ifnet_serialize_all(ifp); 372 error = tunoutput_serialized(ifp, m0, dst, rt); 373 ifnet_deserialize_all(ifp); 374 375 return error; 376 } 377 378 /* 379 * the ops interface is now pretty minimal. 380 */ 381 static int 382 tunioctl(struct dev_ioctl_args *ap) 383 { 384 cdev_t dev = ap->a_head.a_dev; 385 struct tun_softc *tp = dev->si_drv1; 386 struct tuninfo *tunp; 387 388 switch (ap->a_cmd) { 389 case TUNSIFINFO: 390 tunp = (struct tuninfo *)ap->a_data; 391 if (tunp->mtu < IF_MINMTU) 392 return (EINVAL); 393 tp->tun_if.if_mtu = tunp->mtu; 394 tp->tun_if.if_type = tunp->type; 395 tp->tun_if.if_baudrate = tunp->baudrate; 396 break; 397 case TUNGIFINFO: 398 tunp = (struct tuninfo *)ap->a_data; 399 tunp->mtu = tp->tun_if.if_mtu; 400 tunp->type = tp->tun_if.if_type; 401 tunp->baudrate = tp->tun_if.if_baudrate; 402 break; 403 case TUNSDEBUG: 404 tundebug = *(int *)ap->a_data; 405 break; 406 case TUNGDEBUG: 407 *(int *)ap->a_data = tundebug; 408 break; 409 case TUNSLMODE: 410 if (*(int *)ap->a_data) { 411 tp->tun_flags |= TUN_LMODE; 412 tp->tun_flags &= ~TUN_IFHEAD; 413 } else 414 tp->tun_flags &= ~TUN_LMODE; 415 break; 416 case TUNSIFHEAD: 417 if (*(int *)ap->a_data) { 418 tp->tun_flags |= TUN_IFHEAD; 419 tp->tun_flags &= ~TUN_LMODE; 420 } else 421 tp->tun_flags &= ~TUN_IFHEAD; 422 break; 423 case TUNGIFHEAD: 424 *(int *)ap->a_data = (tp->tun_flags & TUN_IFHEAD) ? 1 : 0; 425 break; 426 case TUNSIFMODE: 427 /* deny this if UP */ 428 if (tp->tun_if.if_flags & IFF_UP) 429 return(EBUSY); 430 431 switch (*(int *)ap->a_data & ~IFF_MULTICAST) { 432 case IFF_POINTOPOINT: 433 case IFF_BROADCAST: 434 tp->tun_if.if_flags &= ~(IFF_BROADCAST|IFF_POINTOPOINT); 435 tp->tun_if.if_flags |= *(int *)ap->a_data; 436 break; 437 default: 438 return(EINVAL); 439 } 440 break; 441 case TUNSIFPID: 442 tp->tun_pid = curproc->p_pid; 443 break; 444 case FIOASYNC: 445 if (*(int *)ap->a_data) 446 tp->tun_flags |= TUN_ASYNC; 447 else 448 tp->tun_flags &= ~TUN_ASYNC; 449 break; 450 case FIONREAD: 451 if (!ifq_is_empty(&tp->tun_if.if_snd)) { 452 struct mbuf *mb; 453 454 mb = ifq_poll(&tp->tun_if.if_snd); 455 for( *(int *)ap->a_data = 0; mb != 0; mb = mb->m_next) 456 *(int *)ap->a_data += mb->m_len; 457 } else { 458 *(int *)ap->a_data = 0; 459 } 460 break; 461 case FIOSETOWN: 462 return (fsetown(*(int *)ap->a_data, &tp->tun_sigio)); 463 464 case FIOGETOWN: 465 *(int *)ap->a_data = fgetown(tp->tun_sigio); 466 return (0); 467 468 /* This is deprecated, FIOSETOWN should be used instead. */ 469 case TIOCSPGRP: 470 return (fsetown(-(*(int *)ap->a_data), &tp->tun_sigio)); 471 472 /* This is deprecated, FIOGETOWN should be used instead. */ 473 case TIOCGPGRP: 474 *(int *)ap->a_data = -fgetown(tp->tun_sigio); 475 return (0); 476 477 default: 478 return (ENOTTY); 479 } 480 return (0); 481 } 482 483 /* 484 * The ops read interface - reads a packet at a time, or at 485 * least as much of a packet as can be read. 486 */ 487 static int 488 tunread(struct dev_read_args *ap) 489 { 490 cdev_t dev = ap->a_head.a_dev; 491 struct uio *uio = ap->a_uio; 492 struct tun_softc *tp = dev->si_drv1; 493 struct ifnet *ifp = &tp->tun_if; 494 struct mbuf *m0; 495 int error=0, len; 496 497 TUNDEBUG(ifp, "read\n"); 498 if ((tp->tun_flags & TUN_READY) != TUN_READY) { 499 TUNDEBUG(ifp, "not ready 0%o\n", tp->tun_flags); 500 return EHOSTDOWN; 501 } 502 503 tp->tun_flags &= ~TUN_RWAIT; 504 505 ifnet_serialize_all(ifp); 506 507 while ((m0 = ifq_dequeue(&ifp->if_snd, NULL)) == NULL) { 508 if (ap->a_ioflag & IO_NDELAY) { 509 ifnet_deserialize_all(ifp); 510 return EWOULDBLOCK; 511 } 512 tp->tun_flags |= TUN_RWAIT; 513 ifnet_deserialize_all(ifp); 514 if ((error = tsleep(tp, PCATCH, "tunread", 0)) != 0) 515 return error; 516 ifnet_serialize_all(ifp); 517 } 518 519 ifnet_deserialize_all(ifp); 520 521 while (m0 && uio->uio_resid > 0 && error == 0) { 522 len = min(uio->uio_resid, m0->m_len); 523 if (len != 0) 524 error = uiomove(mtod(m0, caddr_t), len, uio); 525 m0 = m_free(m0); 526 } 527 528 if (m0) { 529 TUNDEBUG(ifp, "Dropping mbuf\n"); 530 m_freem(m0); 531 } 532 return error; 533 } 534 535 /* 536 * the ops write interface - an atomic write is a packet - or else! 537 */ 538 static int 539 tunwrite(struct dev_write_args *ap) 540 { 541 cdev_t dev = ap->a_head.a_dev; 542 struct uio *uio = ap->a_uio; 543 struct tun_softc *tp = dev->si_drv1; 544 struct ifnet *ifp = &tp->tun_if; 545 struct mbuf *top, **mp, *m; 546 int error=0, tlen, mlen; 547 uint32_t family; 548 int isr; 549 550 TUNDEBUG(ifp, "tunwrite\n"); 551 552 if (uio->uio_resid == 0) 553 return 0; 554 555 if (uio->uio_resid < 0 || uio->uio_resid > TUNMRU) { 556 TUNDEBUG(ifp, "len=%d!\n", uio->uio_resid); 557 return EIO; 558 } 559 tlen = uio->uio_resid; 560 561 /* get a header mbuf */ 562 MGETHDR(m, MB_DONTWAIT, MT_DATA); 563 if (m == NULL) 564 return ENOBUFS; 565 mlen = MHLEN; 566 567 top = 0; 568 mp = ⊤ 569 while (error == 0 && uio->uio_resid > 0) { 570 m->m_len = min(mlen, uio->uio_resid); 571 error = uiomove(mtod (m, caddr_t), m->m_len, uio); 572 *mp = m; 573 mp = &m->m_next; 574 if (uio->uio_resid > 0) { 575 MGET (m, MB_DONTWAIT, MT_DATA); 576 if (m == 0) { 577 error = ENOBUFS; 578 break; 579 } 580 mlen = MLEN; 581 } 582 } 583 if (error) { 584 if (top) 585 m_freem (top); 586 ifp->if_ierrors++; 587 return error; 588 } 589 590 top->m_pkthdr.len = tlen; 591 top->m_pkthdr.rcvif = ifp; 592 593 if (ifp->if_bpf) { 594 if (tp->tun_flags & TUN_IFHEAD) { 595 /* 596 * Conveniently, we already have a 4-byte address 597 * family prepended to our packet ! 598 * Inconveniently, it's in the wrong byte order ! 599 */ 600 if ((top = m_pullup(top, sizeof(family))) == NULL) 601 return ENOBUFS; 602 *mtod(top, u_int32_t *) = 603 ntohl(*mtod(top, u_int32_t *)); 604 bpf_mtap(ifp->if_bpf, top); 605 *mtod(top, u_int32_t *) = 606 htonl(*mtod(top, u_int32_t *)); 607 } else { 608 /* 609 * We need to prepend the address family as 610 * a four byte field. 611 */ 612 static const uint32_t af = AF_INET; 613 614 bpf_ptap(ifp->if_bpf, top, &af, sizeof(af)); 615 } 616 } 617 618 if (tp->tun_flags & TUN_IFHEAD) { 619 if (top->m_len < sizeof(family) && 620 (top = m_pullup(top, sizeof(family))) == NULL) 621 return ENOBUFS; 622 family = ntohl(*mtod(top, u_int32_t *)); 623 m_adj(top, sizeof(family)); 624 } else 625 family = AF_INET; 626 627 ifp->if_ibytes += top->m_pkthdr.len; 628 ifp->if_ipackets++; 629 630 switch (family) { 631 #ifdef INET 632 case AF_INET: 633 isr = NETISR_IP; 634 break; 635 #endif 636 #ifdef INET6 637 case AF_INET6: 638 isr = NETISR_IPV6; 639 break; 640 #endif 641 #ifdef IPX 642 case AF_IPX: 643 isr = NETISR_IPX; 644 break; 645 #endif 646 #ifdef NETATALK 647 case AF_APPLETALK: 648 isr = NETISR_ATALK2; 649 break; 650 #endif 651 default: 652 m_freem(m); 653 return (EAFNOSUPPORT); 654 } 655 656 netisr_dispatch(isr, top); 657 return (0); 658 } 659 660 /* 661 * tunpoll - the poll interface, this is only useful on reads 662 * really. The write detect always returns true, write never blocks 663 * anyway, it either accepts the packet or drops it. 664 */ 665 static int 666 tunpoll(struct dev_poll_args *ap) 667 { 668 cdev_t dev = ap->a_head.a_dev; 669 struct tun_softc *tp = dev->si_drv1; 670 struct ifnet *ifp = &tp->tun_if; 671 int revents = 0; 672 673 TUNDEBUG(ifp, "tunpoll\n"); 674 675 ifnet_serialize_all(ifp); 676 677 if (ap->a_events & (POLLIN | POLLRDNORM)) { 678 if (!ifq_is_empty(&ifp->if_snd)) { 679 TUNDEBUG(ifp, "tunpoll q=%d\n", ifp->if_snd.ifq_len); 680 revents |= ap->a_events & (POLLIN | POLLRDNORM); 681 } else { 682 TUNDEBUG(ifp, "tunpoll waiting\n"); 683 selrecord(curthread, &tp->tun_rsel); 684 } 685 } 686 if (ap->a_events & (POLLOUT | POLLWRNORM)) 687 revents |= ap->a_events & (POLLOUT | POLLWRNORM); 688 689 ifnet_deserialize_all(ifp); 690 ap->a_events = revents; 691 return(0); 692 } 693 694 /* 695 * Start packet transmission on the interface. 696 * when the interface queue is rate-limited by ALTQ, 697 * if_start is needed to drain packets from the queue in order 698 * to notify readers when outgoing packets become ready. 699 */ 700 static void 701 tunstart(struct ifnet *ifp) 702 { 703 struct tun_softc *tp = ifp->if_softc; 704 struct mbuf *m; 705 706 if (!ifq_is_enabled(&ifp->if_snd)) 707 return; 708 709 m = ifq_poll(&ifp->if_snd); 710 if (m != NULL) { 711 if (tp->tun_flags & TUN_RWAIT) { 712 tp->tun_flags &= ~TUN_RWAIT; 713 wakeup((caddr_t)tp); 714 } 715 if (tp->tun_flags & TUN_ASYNC && tp->tun_sigio) 716 pgsigio(tp->tun_sigio, SIGIO, 0); 717 selwakeup(&tp->tun_rsel); 718 } 719 } 720