xref: /dragonfly/sys/net/tun/if_tun.c (revision 5de36205) 
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 = &top;
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