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