Annotation of sys/net/if_tun.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: if_tun.c,v 1.89 2007/06/06 10:04:36 henning Exp $ */
! 2: /* $NetBSD: if_tun.c,v 1.24 1996/05/07 02:40:48 thorpej Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 1988, Julian Onions <Julian.Onions@nexor.co.uk>
! 6: * Nottingham University 1987.
! 7: * All rights reserved.
! 8: *
! 9: * Redistribution and use in source and binary forms, with or without
! 10: * modification, are permitted provided that the following conditions
! 11: * are met:
! 12: * 1. Redistributions of source code must retain the above copyright
! 13: * notice, this list of conditions and the following disclaimer.
! 14: * 2. Redistributions in binary form must reproduce the above copyright
! 15: * notice, this list of conditions and the following disclaimer in the
! 16: * documentation and/or other materials provided with the distribution.
! 17: *
! 18: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
! 19: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
! 20: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
! 21: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
! 22: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
! 23: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
! 24: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
! 25: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
! 26: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
! 27: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
! 28: */
! 29:
! 30: /*
! 31: * This driver takes packets off the IP i/f and hands them up to a
! 32: * user process to have its wicked way with. This driver has its
! 33: * roots in a similar driver written by Phil Cockcroft (formerly) at
! 34: * UCL. This driver is based much more on read/write/select mode of
! 35: * operation though.
! 36: */
! 37:
! 38: /* #define TUN_DEBUG 9 */
! 39:
! 40: #include <sys/param.h>
! 41: #include <sys/kernel.h>
! 42: #include <sys/proc.h>
! 43: #include <sys/systm.h>
! 44: #include <sys/mbuf.h>
! 45: #include <sys/protosw.h>
! 46: #include <sys/socket.h>
! 47: #include <sys/ioctl.h>
! 48: #include <sys/errno.h>
! 49: #include <sys/syslog.h>
! 50: #include <sys/selinfo.h>
! 51: #include <sys/file.h>
! 52: #include <sys/time.h>
! 53: #include <sys/device.h>
! 54: #include <sys/vnode.h>
! 55: #include <sys/signalvar.h>
! 56: #include <sys/poll.h>
! 57: #include <sys/conf.h>
! 58:
! 59: #include <machine/cpu.h>
! 60:
! 61: #include <net/if.h>
! 62: #include <net/if_types.h>
! 63: #include <net/netisr.h>
! 64: #include <net/route.h>
! 65:
! 66: #ifdef INET
! 67: #include <netinet/in.h>
! 68: #include <netinet/in_systm.h>
! 69: #include <netinet/in_var.h>
! 70: #include <netinet/ip.h>
! 71: #include <netinet/if_ether.h>
! 72: #endif
! 73:
! 74: #ifdef NETATALK
! 75: #include <netatalk/at.h>
! 76: #include <netatalk/at_var.h>
! 77: #endif
! 78:
! 79: #include "bpfilter.h"
! 80: #if NBPFILTER > 0
! 81: #include <net/bpf.h>
! 82: #endif
! 83:
! 84: /* for arc4random() */
! 85: #include <dev/rndvar.h>
! 86:
! 87: #include <net/if_tun.h>
! 88:
! 89: struct tun_softc {
! 90: struct arpcom arpcom; /* ethernet common data */
! 91: u_short tun_flags; /* misc flags */
! 92: pid_t tun_pgid; /* the process group - if any */
! 93: uid_t tun_siguid; /* uid for process that set tun_pgid */
! 94: uid_t tun_sigeuid; /* euid for process that set tun_pgid */
! 95: struct selinfo tun_rsel; /* read select */
! 96: struct selinfo tun_wsel; /* write select (not used) */
! 97: int tun_unit;
! 98: LIST_ENTRY(tun_softc) tun_list; /* all tunnel interfaces */
! 99: #define tun_if arpcom.ac_if
! 100: };
! 101:
! 102: #ifdef TUN_DEBUG
! 103: int tundebug = TUN_DEBUG;
! 104: #define TUNDEBUG(a) (tundebug? printf a : 0)
! 105: #else
! 106: #define TUNDEBUG(a) /* (tundebug? printf a : 0) */
! 107: #endif
! 108:
! 109: /* Only these IFF flags are changeable by TUNSIFINFO */
! 110: #define TUN_IFF_FLAGS (IFF_UP|IFF_POINTOPOINT|IFF_MULTICAST|IFF_BROADCAST)
! 111:
! 112: void tunattach(int);
! 113: int tunopen(dev_t, int, int, struct proc *);
! 114: int tunclose(dev_t, int, int, struct proc *);
! 115: int tun_ioctl(struct ifnet *, u_long, caddr_t);
! 116: int tun_output(struct ifnet *, struct mbuf *, struct sockaddr *,
! 117: struct rtentry *);
! 118: int tunioctl(dev_t, u_long, caddr_t, int, struct proc *);
! 119: int tunread(dev_t, struct uio *, int);
! 120: int tunwrite(dev_t, struct uio *, int);
! 121: int tunpoll(dev_t, int, struct proc *);
! 122: int tunkqfilter(dev_t, struct knote *);
! 123: int tun_clone_create(struct if_clone *, int);
! 124: int tun_create(struct if_clone *, int, int);
! 125: int tun_clone_destroy(struct ifnet *);
! 126: struct tun_softc *tun_lookup(int);
! 127: void tun_wakeup(struct tun_softc *);
! 128: int tun_switch(struct tun_softc *, int);
! 129:
! 130: static int tuninit(struct tun_softc *);
! 131: static void tunstart(struct ifnet *);
! 132: int filt_tunread(struct knote *, long);
! 133: int filt_tunwrite(struct knote *, long);
! 134: void filt_tunrdetach(struct knote *);
! 135: void filt_tunwdetach(struct knote *);
! 136:
! 137: struct filterops tunread_filtops =
! 138: { 1, NULL, filt_tunrdetach, filt_tunread};
! 139:
! 140: struct filterops tunwrite_filtops =
! 141: { 1, NULL, filt_tunwdetach, filt_tunwrite};
! 142:
! 143: LIST_HEAD(, tun_softc) tun_softc_list;
! 144:
! 145: struct if_clone tun_cloner =
! 146: IF_CLONE_INITIALIZER("tun", tun_clone_create, tun_clone_destroy);
! 147:
! 148: void
! 149: tunattach(int n)
! 150: {
! 151: LIST_INIT(&tun_softc_list);
! 152: if_clone_attach(&tun_cloner);
! 153: }
! 154:
! 155: int
! 156: tun_clone_create(struct if_clone *ifc, int unit)
! 157: {
! 158: return (tun_create(ifc, unit, 0));
! 159: }
! 160:
! 161: int
! 162: tun_create(struct if_clone *ifc, int unit, int flags)
! 163: {
! 164: struct tun_softc *tp;
! 165: struct ifnet *ifp;
! 166: u_int32_t macaddr_rnd;
! 167: int s;
! 168:
! 169: tp = malloc(sizeof(*tp), M_DEVBUF, M_NOWAIT);
! 170: if (!tp)
! 171: return (ENOMEM);
! 172: bzero(tp, sizeof(*tp));
! 173:
! 174: tp->tun_unit = unit;
! 175: tp->tun_flags = TUN_INITED|TUN_STAYUP;
! 176:
! 177: /* generate fake MAC address: 00 bd xx xx xx unit_no */
! 178: tp->arpcom.ac_enaddr[0] = 0x00;
! 179: tp->arpcom.ac_enaddr[1] = 0xbd;
! 180: /*
! 181: * This no longer happens pre-scheduler so let's use the real
! 182: * random subsystem instead of random().
! 183: */
! 184: macaddr_rnd = arc4random();
! 185: bcopy(&macaddr_rnd, &tp->arpcom.ac_enaddr[2], sizeof(u_int32_t));
! 186: tp->arpcom.ac_enaddr[5] = (u_char)unit + 1;
! 187:
! 188: ifp = &tp->tun_if;
! 189: snprintf(ifp->if_xname, sizeof ifp->if_xname, "%s%d", ifc->ifc_name,
! 190: unit);
! 191: ifp->if_softc = tp;
! 192: ifp->if_ioctl = tun_ioctl;
! 193: ifp->if_output = tun_output;
! 194: ifp->if_start = tunstart;
! 195: IFQ_SET_MAXLEN(&ifp->if_snd, ifqmaxlen);
! 196: IFQ_SET_READY(&ifp->if_snd);
! 197: if ((flags & TUN_LAYER2) == 0) {
! 198: tp->tun_flags &= ~TUN_LAYER2;
! 199: ifp->if_mtu = ETHERMTU;
! 200: ifp->if_flags = IFF_POINTOPOINT;
! 201: ifp->if_type = IFT_TUNNEL;
! 202: ifp->if_hdrlen = sizeof(u_int32_t);
! 203: if_attach(ifp);
! 204: if_alloc_sadl(ifp);
! 205: #if NBPFILTER > 0
! 206: bpfattach(&ifp->if_bpf, ifp, DLT_LOOP, sizeof(u_int32_t));
! 207: #endif
! 208: } else {
! 209: tp->tun_flags |= TUN_LAYER2;
! 210: ifp->if_flags =
! 211: (IFF_BROADCAST|IFF_SIMPLEX|IFF_MULTICAST|IFF_LINK0);
! 212: if_attach(ifp);
! 213: ether_ifattach(ifp);
! 214: }
! 215: /* force output function to our function */
! 216: ifp->if_output = tun_output;
! 217:
! 218: s = splnet();
! 219: LIST_INSERT_HEAD(&tun_softc_list, tp, tun_list);
! 220: splx(s);
! 221:
! 222: return (0);
! 223: }
! 224:
! 225: int
! 226: tun_clone_destroy(struct ifnet *ifp)
! 227: {
! 228: struct tun_softc *tp = ifp->if_softc;
! 229: int s;
! 230:
! 231: tun_wakeup(tp);
! 232:
! 233: s = splhigh();
! 234: klist_invalidate(&tp->tun_rsel.si_note);
! 235: klist_invalidate(&tp->tun_wsel.si_note);
! 236: splx(s);
! 237:
! 238: s = splnet();
! 239: LIST_REMOVE(tp, tun_list);
! 240: splx(s);
! 241:
! 242: if (tp->tun_flags & TUN_LAYER2)
! 243: ether_ifdetach(ifp);
! 244:
! 245: if_detach(ifp);
! 246:
! 247: free(tp, M_DEVBUF);
! 248: return (0);
! 249: }
! 250:
! 251: struct tun_softc *
! 252: tun_lookup(int unit)
! 253: {
! 254: struct tun_softc *tp;
! 255:
! 256: LIST_FOREACH(tp, &tun_softc_list, tun_list)
! 257: if (tp->tun_unit == unit)
! 258: return (tp);
! 259: return (NULL);
! 260: }
! 261:
! 262: int
! 263: tun_switch(struct tun_softc *tp, int flags)
! 264: {
! 265: struct ifnet *ifp = &tp->tun_if;
! 266: int unit, open, r;
! 267:
! 268: if ((tp->tun_flags & TUN_LAYER2) == (flags & TUN_LAYER2))
! 269: return (0);
! 270:
! 271: /* tp will be removed so store unit number */
! 272: unit = tp->tun_unit;
! 273: open = tp->tun_flags & (TUN_OPEN|TUN_NBIO|TUN_ASYNC);
! 274: TUNDEBUG(("%s: switching to layer %d\n", ifp->if_xname,
! 275: flags & TUN_LAYER2 ? 2 : 3));
! 276:
! 277: /* remove old device and ... */
! 278: tun_clone_destroy(ifp);
! 279: /* attach new interface */
! 280: r = tun_create(&tun_cloner, unit, flags);
! 281:
! 282: if (open && r == 0) {
! 283: /* already opened before ifconfig tunX link0 */
! 284: if ((tp = tun_lookup(unit)) == NULL)
! 285: /* this should never fail */
! 286: return (ENXIO);
! 287: tp->tun_flags |= open;
! 288: TUNDEBUG(("%s: already open\n", tp->tun_if.if_xname));
! 289: }
! 290: return (r);
! 291: }
! 292:
! 293: /*
! 294: * tunnel open - must be superuser & the device must be
! 295: * configured in
! 296: */
! 297: int
! 298: tunopen(dev_t dev, int flag, int mode, struct proc *p)
! 299: {
! 300: struct tun_softc *tp;
! 301: struct ifnet *ifp;
! 302: int error, s;
! 303:
! 304: if ((error = suser(p, 0)) != 0)
! 305: return (error);
! 306:
! 307: if ((tp = tun_lookup(minor(dev))) == NULL) { /* create on demand */
! 308: char xname[IFNAMSIZ];
! 309:
! 310: snprintf(xname, sizeof(xname), "%s%d", "tun", minor(dev));
! 311: if ((error = if_clone_create(xname)) != 0)
! 312: return (error);
! 313:
! 314: if ((tp = tun_lookup(minor(dev))) == NULL)
! 315: return (ENXIO);
! 316: tp->tun_flags &= ~TUN_STAYUP;
! 317: }
! 318:
! 319: if (tp->tun_flags & TUN_OPEN)
! 320: return (EBUSY);
! 321:
! 322: ifp = &tp->tun_if;
! 323: tp->tun_flags |= TUN_OPEN;
! 324:
! 325: /* automatically UP the interface on open */
! 326: s = splnet();
! 327: if_up(ifp);
! 328: ifp->if_flags |= IFF_RUNNING;
! 329: splx(s);
! 330:
! 331: TUNDEBUG(("%s: open\n", ifp->if_xname));
! 332: return (0);
! 333: }
! 334:
! 335: /*
! 336: * tunclose - close the device; if closing the real device, flush pending
! 337: * output and unless STAYUP bring down and destroy the interface.
! 338: */
! 339: int
! 340: tunclose(dev_t dev, int flag, int mode, struct proc *p)
! 341: {
! 342: int s;
! 343: struct tun_softc *tp;
! 344: struct ifnet *ifp;
! 345:
! 346: if ((tp = tun_lookup(minor(dev))) == NULL)
! 347: return (ENXIO);
! 348:
! 349: ifp = &tp->tun_if;
! 350: tp->tun_flags &= ~(TUN_OPEN|TUN_NBIO|TUN_ASYNC);
! 351: ifp->if_flags &= ~IFF_RUNNING;
! 352:
! 353: /*
! 354: * junk all pending output
! 355: */
! 356: s = splnet();
! 357: IFQ_PURGE(&ifp->if_snd);
! 358: splx(s);
! 359:
! 360: TUNDEBUG(("%s: closed\n", ifp->if_xname));
! 361:
! 362: if (!(tp->tun_flags & TUN_STAYUP))
! 363: return (if_clone_destroy(ifp->if_xname));
! 364: else {
! 365: tp->tun_pgid = 0;
! 366: selwakeup(&tp->tun_rsel);
! 367: KNOTE(&tp->tun_rsel.si_note, 0);
! 368: }
! 369:
! 370: return (0);
! 371: }
! 372:
! 373: static int
! 374: tuninit(struct tun_softc *tp)
! 375: {
! 376: struct ifnet *ifp = &tp->tun_if;
! 377: struct ifaddr *ifa;
! 378:
! 379: TUNDEBUG(("%s: tuninit\n", ifp->if_xname));
! 380:
! 381: ifp->if_flags |= IFF_UP | IFF_RUNNING;
! 382: ifp->if_flags &= ~IFF_OACTIVE; /* we are never active */
! 383:
! 384: tp->tun_flags &= ~(TUN_IASET|TUN_DSTADDR|TUN_BRDADDR);
! 385: TAILQ_FOREACH(ifa, &ifp->if_addrlist, ifa_list) {
! 386: #ifdef INET
! 387: if (ifa->ifa_addr->sa_family == AF_INET) {
! 388: struct sockaddr_in *sin;
! 389:
! 390: sin = satosin(ifa->ifa_addr);
! 391: if (sin && sin->sin_addr.s_addr)
! 392: tp->tun_flags |= TUN_IASET;
! 393:
! 394: if (ifp->if_flags & IFF_POINTOPOINT) {
! 395: sin = satosin(ifa->ifa_dstaddr);
! 396: if (sin && sin->sin_addr.s_addr)
! 397: tp->tun_flags |= TUN_DSTADDR;
! 398: } else
! 399: tp->tun_flags &= ~TUN_DSTADDR;
! 400:
! 401: if (ifp->if_flags & IFF_BROADCAST) {
! 402: sin = satosin(ifa->ifa_broadaddr);
! 403: if (sin && sin->sin_addr.s_addr)
! 404: tp->tun_flags |= TUN_BRDADDR;
! 405: } else
! 406: tp->tun_flags &= ~TUN_BRDADDR;
! 407: }
! 408: #endif
! 409: #ifdef INET6
! 410: if (ifa->ifa_addr->sa_family == AF_INET6) {
! 411: struct sockaddr_in6 *sin;
! 412:
! 413: sin = (struct sockaddr_in6 *)ifa->ifa_addr;
! 414: if (!IN6_IS_ADDR_UNSPECIFIED(&sin->sin6_addr))
! 415: tp->tun_flags |= TUN_IASET;
! 416:
! 417: if (ifp->if_flags & IFF_POINTOPOINT) {
! 418: sin = (struct sockaddr_in6 *)ifa->ifa_dstaddr;
! 419: if (sin &&
! 420: !IN6_IS_ADDR_UNSPECIFIED(&sin->sin6_addr))
! 421: tp->tun_flags |= TUN_DSTADDR;
! 422: } else
! 423: tp->tun_flags &= ~TUN_DSTADDR;
! 424: }
! 425: #endif /* INET6 */
! 426: }
! 427:
! 428: return (0);
! 429: }
! 430:
! 431: /*
! 432: * Process an ioctl request.
! 433: */
! 434: int
! 435: tun_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
! 436: {
! 437: struct tun_softc *tp = (struct tun_softc *)(ifp->if_softc);
! 438: struct ifreq *ifr = (struct ifreq *)data;
! 439: int error = 0, s;
! 440:
! 441: s = splnet();
! 442: if (tp->tun_flags & TUN_LAYER2)
! 443: if ((error = ether_ioctl(ifp, &tp->arpcom, cmd, data)) > 0) {
! 444: splx(s);
! 445: return (error);
! 446: }
! 447: switch (cmd) {
! 448: case SIOCSIFADDR:
! 449: tuninit(tp);
! 450: TUNDEBUG(("%s: address set\n", ifp->if_xname));
! 451: if (tp->tun_flags & TUN_LAYER2)
! 452: switch (((struct ifaddr *)data)->ifa_addr->sa_family) {
! 453: #ifdef INET
! 454: case AF_INET:
! 455: arp_ifinit(&tp->arpcom, (struct ifaddr *)data);
! 456: break;
! 457: #endif
! 458: default:
! 459: break;
! 460: }
! 461: break;
! 462: case SIOCSIFDSTADDR:
! 463: tuninit(tp);
! 464: TUNDEBUG(("%s: destination address set\n", ifp->if_xname));
! 465: break;
! 466: case SIOCSIFBRDADDR:
! 467: tuninit(tp);
! 468: TUNDEBUG(("%s: broadcast address set\n", ifp->if_xname));
! 469: break;
! 470: case SIOCSIFMTU:
! 471: if (ifr->ifr_mtu < ETHERMIN || ifr->ifr_mtu > TUNMRU)
! 472: error = EINVAL;
! 473: else
! 474: ifp->if_mtu = ifr->ifr_mtu;
! 475: break;
! 476: case SIOCADDMULTI:
! 477: case SIOCDELMULTI: {
! 478: if (ifr == 0) {
! 479: error = EAFNOSUPPORT; /* XXX */
! 480: break;
! 481: }
! 482:
! 483: if (tp->tun_flags & TUN_LAYER2) {
! 484: error = (cmd == SIOCADDMULTI) ?
! 485: ether_addmulti(ifr, &tp->arpcom) :
! 486: ether_delmulti(ifr, &tp->arpcom);
! 487: if (error == ENETRESET) {
! 488: /*
! 489: * Multicast list has changed; set the hardware
! 490: * filter accordingly. The good thing is we do
! 491: * not have a hardware filter (:
! 492: */
! 493: error = 0;
! 494: }
! 495: break;
! 496: }
! 497:
! 498: switch (ifr->ifr_addr.sa_family) {
! 499: #ifdef INET
! 500: case AF_INET:
! 501: break;
! 502: #endif
! 503: #ifdef INET6
! 504: case AF_INET6:
! 505: break;
! 506: #endif
! 507: default:
! 508: error = EAFNOSUPPORT;
! 509: break;
! 510: }
! 511: break;
! 512: }
! 513:
! 514: case SIOCSIFFLAGS:
! 515: error = tun_switch(tp,
! 516: ifp->if_flags & IFF_LINK0 ? TUN_LAYER2 : 0);
! 517: break;
! 518: default:
! 519: error = EINVAL;
! 520: }
! 521: splx(s);
! 522: return (error);
! 523: }
! 524:
! 525: /*
! 526: * tun_output - queue packets from higher level ready to put out.
! 527: */
! 528: int
! 529: tun_output(struct ifnet *ifp, struct mbuf *m0, struct sockaddr *dst,
! 530: struct rtentry *rt)
! 531: {
! 532: struct tun_softc *tp = ifp->if_softc;
! 533: int s, len, error;
! 534: u_int32_t *af;
! 535:
! 536: if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING)) {
! 537: m_freem(m0);
! 538: return (EHOSTDOWN);
! 539: }
! 540:
! 541: TUNDEBUG(("%s: tun_output\n", ifp->if_xname));
! 542:
! 543: if ((tp->tun_flags & TUN_READY) != TUN_READY) {
! 544: TUNDEBUG(("%s: not ready %#x\n", ifp->if_xname,
! 545: tp->tun_flags));
! 546: m_freem(m0);
! 547: return (EHOSTDOWN);
! 548: }
! 549:
! 550: if (tp->tun_flags & TUN_LAYER2)
! 551: /* call ether_output and that will call tunstart at the end */
! 552: return (ether_output(ifp, m0, dst, rt));
! 553:
! 554: M_PREPEND(m0, sizeof(*af), M_DONTWAIT);
! 555: af = mtod(m0, u_int32_t *);
! 556: *af = htonl(dst->sa_family);
! 557:
! 558: #if NBPFILTER > 0
! 559: if (ifp->if_bpf)
! 560: bpf_mtap(ifp->if_bpf, m0, BPF_DIRECTION_OUT);
! 561: #endif
! 562:
! 563: len = m0->m_pkthdr.len + sizeof(*af);
! 564: s = splnet();
! 565: IFQ_ENQUEUE(&ifp->if_snd, m0, NULL, error);
! 566: if (error) {
! 567: splx(s);
! 568: ifp->if_collisions++;
! 569: return (error);
! 570: }
! 571: splx(s);
! 572: ifp->if_opackets++;
! 573: ifp->if_obytes += len;
! 574:
! 575: tun_wakeup(tp);
! 576: return (0);
! 577: }
! 578:
! 579: void
! 580: tun_wakeup(struct tun_softc *tp)
! 581: {
! 582: if (tp->tun_flags & TUN_RWAIT) {
! 583: tp->tun_flags &= ~TUN_RWAIT;
! 584: wakeup((caddr_t)tp);
! 585: }
! 586: if (tp->tun_flags & TUN_ASYNC && tp->tun_pgid)
! 587: csignal(tp->tun_pgid, SIGIO,
! 588: tp->tun_siguid, tp->tun_sigeuid);
! 589: selwakeup(&tp->tun_rsel);
! 590: KNOTE(&tp->tun_rsel.si_note, 0);
! 591: }
! 592:
! 593: /*
! 594: * the cdevsw interface is now pretty minimal.
! 595: */
! 596: int
! 597: tunioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p)
! 598: {
! 599: int s;
! 600: struct tun_softc *tp;
! 601: struct tuninfo *tunp;
! 602: struct mbuf *m;
! 603:
! 604: if ((tp = tun_lookup(minor(dev))) == NULL)
! 605: return (ENXIO);
! 606:
! 607: s = splnet();
! 608: switch (cmd) {
! 609: case TUNSIFINFO:
! 610: tunp = (struct tuninfo *)data;
! 611: if (tunp->mtu < ETHERMIN || tunp->mtu > TUNMRU) {
! 612: splx(s);
! 613: return (EINVAL);
! 614: }
! 615: tp->tun_if.if_mtu = tunp->mtu;
! 616: tp->tun_if.if_type = tunp->type;
! 617: tp->tun_if.if_flags =
! 618: (tunp->flags & TUN_IFF_FLAGS) |
! 619: (tp->tun_if.if_flags & ~TUN_IFF_FLAGS);
! 620: tp->tun_if.if_baudrate = tunp->baudrate;
! 621: break;
! 622: case TUNGIFINFO:
! 623: tunp = (struct tuninfo *)data;
! 624: tunp->mtu = tp->tun_if.if_mtu;
! 625: tunp->type = tp->tun_if.if_type;
! 626: tunp->flags = tp->tun_if.if_flags;
! 627: tunp->baudrate = tp->tun_if.if_baudrate;
! 628: break;
! 629: #ifdef TUN_DEBUG
! 630: case TUNSDEBUG:
! 631: tundebug = *(int *)data;
! 632: break;
! 633: case TUNGDEBUG:
! 634: *(int *)data = tundebug;
! 635: break;
! 636: #endif
! 637: case TUNSIFMODE:
! 638: switch (*(int *)data & (IFF_POINTOPOINT|IFF_BROADCAST)) {
! 639: case IFF_POINTOPOINT:
! 640: case IFF_BROADCAST:
! 641: tp->tun_if.if_flags &= ~TUN_IFF_FLAGS;
! 642: tp->tun_if.if_flags |= *(int *)data & TUN_IFF_FLAGS;
! 643: break;
! 644: default:
! 645: splx(s);
! 646: return (EINVAL);
! 647: }
! 648: break;
! 649:
! 650: case FIONBIO:
! 651: if (*(int *)data)
! 652: tp->tun_flags |= TUN_NBIO;
! 653: else
! 654: tp->tun_flags &= ~TUN_NBIO;
! 655: break;
! 656: case FIOASYNC:
! 657: if (*(int *)data)
! 658: tp->tun_flags |= TUN_ASYNC;
! 659: else
! 660: tp->tun_flags &= ~TUN_ASYNC;
! 661: break;
! 662: case FIONREAD:
! 663: IFQ_POLL(&tp->tun_if.if_snd, m);
! 664: if (m != NULL)
! 665: *(int *)data = m->m_pkthdr.len;
! 666: else
! 667: *(int *)data = 0;
! 668: break;
! 669: case TIOCSPGRP:
! 670: tp->tun_pgid = *(int *)data;
! 671: tp->tun_siguid = p->p_cred->p_ruid;
! 672: tp->tun_sigeuid = p->p_ucred->cr_uid;
! 673: break;
! 674: case TIOCGPGRP:
! 675: *(int *)data = tp->tun_pgid;
! 676: break;
! 677: case OSIOCGIFADDR:
! 678: case SIOCGIFADDR:
! 679: if (!(tp->tun_flags & TUN_LAYER2)) {
! 680: splx(s);
! 681: return (EINVAL);
! 682: }
! 683: bcopy(tp->arpcom.ac_enaddr, data,
! 684: sizeof(tp->arpcom.ac_enaddr));
! 685: break;
! 686:
! 687: case SIOCSIFADDR:
! 688: if (!(tp->tun_flags & TUN_LAYER2)) {
! 689: splx(s);
! 690: return (EINVAL);
! 691: }
! 692: bcopy(data, tp->arpcom.ac_enaddr,
! 693: sizeof(tp->arpcom.ac_enaddr));
! 694: break;
! 695: default:
! 696: splx(s);
! 697: return (ENOTTY);
! 698: }
! 699: splx(s);
! 700: return (0);
! 701: }
! 702:
! 703: /*
! 704: * The cdevsw read interface - reads a packet at a time, or at
! 705: * least as much of a packet as can be read.
! 706: */
! 707: int
! 708: tunread(dev_t dev, struct uio *uio, int ioflag)
! 709: {
! 710: struct tun_softc *tp;
! 711: struct ifnet *ifp;
! 712: struct mbuf *m, *m0;
! 713: int error = 0, len, s;
! 714:
! 715: if ((tp = tun_lookup(minor(dev))) == NULL)
! 716: return (ENXIO);
! 717:
! 718: ifp = &tp->tun_if;
! 719: TUNDEBUG(("%s: read\n", ifp->if_xname));
! 720: if ((tp->tun_flags & TUN_READY) != TUN_READY) {
! 721: TUNDEBUG(("%s: not ready %#x\n", ifp->if_xname, tp->tun_flags));
! 722: return (EHOSTDOWN);
! 723: }
! 724:
! 725: tp->tun_flags &= ~TUN_RWAIT;
! 726:
! 727: s = splnet();
! 728: do {
! 729: while ((tp->tun_flags & TUN_READY) != TUN_READY)
! 730: if ((error = tsleep((caddr_t)tp,
! 731: (PZERO + 1)|PCATCH, "tunread", 0)) != 0) {
! 732: splx(s);
! 733: return (error);
! 734: }
! 735: IFQ_DEQUEUE(&ifp->if_snd, m0);
! 736: if (m0 == NULL) {
! 737: if (tp->tun_flags & TUN_NBIO && ioflag & IO_NDELAY) {
! 738: splx(s);
! 739: return (EWOULDBLOCK);
! 740: }
! 741: tp->tun_flags |= TUN_RWAIT;
! 742: if ((error = tsleep((caddr_t)tp,
! 743: (PZERO + 1)|PCATCH, "tunread", 0)) != 0) {
! 744: splx(s);
! 745: return (error);
! 746: }
! 747: }
! 748: } while (m0 == NULL);
! 749: splx(s);
! 750:
! 751: while (m0 != NULL && uio->uio_resid > 0 && error == 0) {
! 752: len = min(uio->uio_resid, m0->m_len);
! 753: if (len != 0)
! 754: error = uiomove(mtod(m0, caddr_t), len, uio);
! 755: MFREE(m0, m);
! 756: m0 = m;
! 757: }
! 758:
! 759: if (m0 != NULL) {
! 760: TUNDEBUG(("Dropping mbuf\n"));
! 761: m_freem(m0);
! 762: }
! 763: if (error)
! 764: ifp->if_ierrors++;
! 765:
! 766: return (error);
! 767: }
! 768:
! 769: /*
! 770: * the cdevsw write interface - an atomic write is a packet - or else!
! 771: */
! 772: int
! 773: tunwrite(dev_t dev, struct uio *uio, int ioflag)
! 774: {
! 775: struct tun_softc *tp;
! 776: struct ifnet *ifp;
! 777: struct ifqueue *ifq;
! 778: u_int32_t *th;
! 779: struct mbuf *top, **mp, *m;
! 780: int isr;
! 781: int error=0, s, tlen, mlen;
! 782:
! 783: if ((tp = tun_lookup(minor(dev))) == NULL)
! 784: return (ENXIO);
! 785:
! 786: ifp = &tp->tun_if;
! 787: TUNDEBUG(("%s: tunwrite\n", ifp->if_xname));
! 788:
! 789: if (uio->uio_resid == 0 || uio->uio_resid > ifp->if_mtu +
! 790: (tp->tun_flags & TUN_LAYER2 ? ETHER_HDR_LEN : sizeof(*th))) {
! 791: TUNDEBUG(("%s: len=%d!\n", ifp->if_xname, uio->uio_resid));
! 792: return (EMSGSIZE);
! 793: }
! 794: tlen = uio->uio_resid;
! 795:
! 796: /* get a header mbuf */
! 797: MGETHDR(m, M_DONTWAIT, MT_DATA);
! 798: if (m == NULL)
! 799: return (ENOBUFS);
! 800: mlen = MHLEN;
! 801: if (uio->uio_resid >= MINCLSIZE) {
! 802: MCLGET(m, M_DONTWAIT);
! 803: if (!(m->m_flags & M_EXT)) {
! 804: m_free(m);
! 805: return (ENOBUFS);
! 806: }
! 807: mlen = MCLBYTES;
! 808: }
! 809:
! 810: top = NULL;
! 811: mp = ⊤
! 812: if (tp->tun_flags & TUN_LAYER2) {
! 813: /*
! 814: * Pad so that IP header is correctly aligned
! 815: * this is necessary for all strict aligned architectures.
! 816: */
! 817: mlen -= ETHER_ALIGN;
! 818: m->m_data += ETHER_ALIGN;
! 819: }
! 820: while (error == 0 && uio->uio_resid > 0) {
! 821: m->m_len = min(mlen, uio->uio_resid);
! 822: error = uiomove(mtod (m, caddr_t), m->m_len, uio);
! 823: *mp = m;
! 824: mp = &m->m_next;
! 825: if (error == 0 && uio->uio_resid > 0) {
! 826: MGET(m, M_DONTWAIT, MT_DATA);
! 827: if (m == NULL) {
! 828: error = ENOBUFS;
! 829: break;
! 830: }
! 831: mlen = MLEN;
! 832: if (uio->uio_resid >= MINCLSIZE) {
! 833: MCLGET(m, M_DONTWAIT);
! 834: if (!(m->m_flags & M_EXT)) {
! 835: error = ENOBUFS;
! 836: m_free(m);
! 837: break;
! 838: }
! 839: mlen = MCLBYTES;
! 840: }
! 841: }
! 842: }
! 843: if (error) {
! 844: if (top != NULL)
! 845: m_freem(top);
! 846: ifp->if_ierrors++;
! 847: return (error);
! 848: }
! 849:
! 850: top->m_pkthdr.len = tlen;
! 851: top->m_pkthdr.rcvif = ifp;
! 852:
! 853: #if NBPFILTER > 0
! 854: if (ifp->if_bpf)
! 855: bpf_mtap(ifp->if_bpf, top, BPF_DIRECTION_IN);
! 856: #endif
! 857:
! 858: if (tp->tun_flags & TUN_LAYER2) {
! 859: ether_input_mbuf(ifp, top);
! 860: ifp->if_ipackets++; /* ibytes are counted in ether_input */
! 861: return (0);
! 862: }
! 863:
! 864: th = mtod(top, u_int32_t *);
! 865: /* strip the tunnel header */
! 866: top->m_data += sizeof(*th);
! 867: top->m_len -= sizeof(*th);
! 868: top->m_pkthdr.len -= sizeof(*th);
! 869:
! 870: switch (ntohl(*th)) {
! 871: #ifdef INET
! 872: case AF_INET:
! 873: ifq = &ipintrq;
! 874: isr = NETISR_IP;
! 875: break;
! 876: #endif
! 877: #ifdef INET6
! 878: case AF_INET6:
! 879: ifq = &ip6intrq;
! 880: isr = NETISR_IPV6;
! 881: break;
! 882: #endif
! 883: #ifdef NETATALK
! 884: case AF_APPLETALK:
! 885: ifq = &atintrq2;
! 886: isr = NETISR_ATALK;
! 887: break;
! 888: #endif
! 889: default:
! 890: m_freem(top);
! 891: return (EAFNOSUPPORT);
! 892: }
! 893:
! 894: s = splnet();
! 895: if (IF_QFULL(ifq)) {
! 896: IF_DROP(ifq);
! 897: splx(s);
! 898: ifp->if_collisions++;
! 899: m_freem(top);
! 900: if (!ifq->ifq_congestion)
! 901: if_congestion(ifq);
! 902: return (ENOBUFS);
! 903: }
! 904: IF_ENQUEUE(ifq, top);
! 905: schednetisr(isr);
! 906: ifp->if_ipackets++;
! 907: ifp->if_ibytes += top->m_pkthdr.len;
! 908: splx(s);
! 909: return (error);
! 910: }
! 911:
! 912: /*
! 913: * tunpoll - the poll interface, this is only useful on reads
! 914: * really. The write detect always returns true, write never blocks
! 915: * anyway, it either accepts the packet or drops it.
! 916: */
! 917: int
! 918: tunpoll(dev_t dev, int events, struct proc *p)
! 919: {
! 920: int revents, s;
! 921: struct tun_softc *tp;
! 922: struct ifnet *ifp;
! 923: struct mbuf *m;
! 924:
! 925: if ((tp = tun_lookup(minor(dev))) == NULL)
! 926: return (POLLERR);
! 927:
! 928: ifp = &tp->tun_if;
! 929: revents = 0;
! 930: s = splnet();
! 931: TUNDEBUG(("%s: tunpoll\n", ifp->if_xname));
! 932:
! 933: if (events & (POLLIN | POLLRDNORM)) {
! 934: IFQ_POLL(&ifp->if_snd, m);
! 935: if (m != NULL) {
! 936: TUNDEBUG(("%s: tunselect q=%d\n", ifp->if_xname,
! 937: ifp->if_snd.ifq_len));
! 938: revents |= events & (POLLIN | POLLRDNORM);
! 939: } else {
! 940: TUNDEBUG(("%s: tunpoll waiting\n", ifp->if_xname));
! 941: selrecord(p, &tp->tun_rsel);
! 942: }
! 943: }
! 944: if (events & (POLLOUT | POLLWRNORM))
! 945: revents |= events & (POLLOUT | POLLWRNORM);
! 946: splx(s);
! 947: return (revents);
! 948: }
! 949:
! 950: /*
! 951: * kqueue(2) support.
! 952: *
! 953: * The tun driver uses an array of tun_softc's based on the minor number
! 954: * of the device. kn->kn_hook gets set to the specific tun_softc.
! 955: *
! 956: * filt_tunread() sets kn->kn_data to the iface qsize
! 957: * filt_tunwrite() sets kn->kn_data to the MTU size
! 958: */
! 959: int
! 960: tunkqfilter(dev_t dev, struct knote *kn)
! 961: {
! 962: int s;
! 963: struct klist *klist;
! 964: struct tun_softc *tp;
! 965: struct ifnet *ifp;
! 966:
! 967: if ((tp = tun_lookup(minor(dev))) == NULL)
! 968: return (ENXIO);
! 969:
! 970: ifp = &tp->tun_if;
! 971:
! 972: s = splnet();
! 973: TUNDEBUG(("%s: tunkqfilter\n", ifp->if_xname));
! 974: splx(s);
! 975:
! 976: switch (kn->kn_filter) {
! 977: case EVFILT_READ:
! 978: klist = &tp->tun_rsel.si_note;
! 979: kn->kn_fop = &tunread_filtops;
! 980: break;
! 981: case EVFILT_WRITE:
! 982: klist = &tp->tun_wsel.si_note;
! 983: kn->kn_fop = &tunwrite_filtops;
! 984: break;
! 985: default:
! 986: return (EPERM); /* 1 */
! 987: }
! 988:
! 989: kn->kn_hook = (caddr_t)tp;
! 990:
! 991: s = splhigh();
! 992: SLIST_INSERT_HEAD(klist, kn, kn_selnext);
! 993: splx(s);
! 994:
! 995: return (0);
! 996: }
! 997:
! 998: void
! 999: filt_tunrdetach(struct knote *kn)
! 1000: {
! 1001: int s;
! 1002: struct tun_softc *tp;
! 1003:
! 1004: tp = (struct tun_softc *)kn->kn_hook;
! 1005: s = splhigh();
! 1006: if (!(kn->kn_status & KN_DETACHED))
! 1007: SLIST_REMOVE(&tp->tun_rsel.si_note, kn, knote, kn_selnext);
! 1008: splx(s);
! 1009: }
! 1010:
! 1011: int
! 1012: filt_tunread(struct knote *kn, long hint)
! 1013: {
! 1014: int s;
! 1015: struct tun_softc *tp;
! 1016: struct ifnet *ifp;
! 1017: struct mbuf *m;
! 1018:
! 1019: if (kn->kn_status & KN_DETACHED) {
! 1020: kn->kn_data = 0;
! 1021: return (1);
! 1022: }
! 1023:
! 1024: tp = (struct tun_softc *)kn->kn_hook;
! 1025: ifp = &tp->tun_if;
! 1026:
! 1027: s = splnet();
! 1028: IFQ_POLL(&ifp->if_snd, m);
! 1029: if (m != NULL) {
! 1030: splx(s);
! 1031: kn->kn_data = ifp->if_snd.ifq_len;
! 1032:
! 1033: TUNDEBUG(("%s: tunkqread q=%d\n", ifp->if_xname,
! 1034: ifp->if_snd.ifq_len));
! 1035: return (1);
! 1036: }
! 1037: splx(s);
! 1038: TUNDEBUG(("%s: tunkqread waiting\n", ifp->if_xname));
! 1039: return (0);
! 1040: }
! 1041:
! 1042: void
! 1043: filt_tunwdetach(struct knote *kn)
! 1044: {
! 1045: int s;
! 1046: struct tun_softc *tp;
! 1047:
! 1048: tp = (struct tun_softc *)kn->kn_hook;
! 1049: s = splhigh();
! 1050: if (!(kn->kn_status & KN_DETACHED))
! 1051: SLIST_REMOVE(&tp->tun_wsel.si_note, kn, knote, kn_selnext);
! 1052: splx(s);
! 1053: }
! 1054:
! 1055: int
! 1056: filt_tunwrite(struct knote *kn, long hint)
! 1057: {
! 1058: struct tun_softc *tp;
! 1059: struct ifnet *ifp;
! 1060:
! 1061: if (kn->kn_status & KN_DETACHED) {
! 1062: kn->kn_data = 0;
! 1063: return (1);
! 1064: }
! 1065:
! 1066: tp = (struct tun_softc *)kn->kn_hook;
! 1067: ifp = &tp->tun_if;
! 1068:
! 1069: kn->kn_data = ifp->if_mtu;
! 1070:
! 1071: return (1);
! 1072: }
! 1073:
! 1074: /*
! 1075: * Start packet transmission on the interface.
! 1076: * when the interface queue is rate-limited by ALTQ or TBR,
! 1077: * if_start is needed to drain packets from the queue in order
! 1078: * to notify readers when outgoing packets become ready.
! 1079: * In layer 2 mode this function is called from ether_output.
! 1080: */
! 1081: static void
! 1082: tunstart(struct ifnet *ifp)
! 1083: {
! 1084: struct tun_softc *tp = ifp->if_softc;
! 1085: struct mbuf *m;
! 1086:
! 1087: if (!(tp->tun_flags & TUN_LAYER2) &&
! 1088: !ALTQ_IS_ENABLED(&ifp->if_snd) &&
! 1089: !TBR_IS_ENABLED(&ifp->if_snd))
! 1090: return;
! 1091:
! 1092: IFQ_POLL(&ifp->if_snd, m);
! 1093: if (m != NULL) {
! 1094: if (tp->tun_flags & TUN_LAYER2) {
! 1095: #if NBPFILTER > 0
! 1096: if (ifp->if_bpf)
! 1097: bpf_mtap(ifp->if_bpf, m, BPF_DIRECTION_OUT);
! 1098: #endif
! 1099: ifp->if_opackets++;
! 1100: }
! 1101: tun_wakeup(tp);
! 1102: }
! 1103: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to if_tun.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / net