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