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