 @@ -1,74 +1,70 @@
-/*	$NetBSD: if_tun.c,v 1.134 2017/01/11 13:08:29 ozaki-r Exp $	*/
+/*	$NetBSD: if_tun.c,v 1.135 2017/01/23 15:32:04 skrll Exp $	*/
 /*
  * Copyright (c) 1988, Julian Onions <jpo@cs.nott.ac.uk>
  * Nottingham University 1987.
+ *
  * This source may be freely distributed, however I would be interested
  * in any changes that are made.
+ *
  * This driver takes packets off the IP i/f and hands them up to a
  * user process to have its wicked way with. This driver has its
  * roots in a similar driver written by Phil Cockcroft (formerly) at
  * UCL. This driver is based much more on read/write/poll mode of
  * operation though.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: if_tun.c,v 1.134 2017/01/11 13:08:29 ozaki-r Exp $");
+__KERNEL_RCSID(0, "$NetBSD: if_tun.c,v 1.135 2017/01/23 15:32:04 skrll Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_inet.h"
 #endif
 #include <sys/param.h>
 #include <sys/proc.h>
 #include <sys/systm.h>
 #include <sys/mbuf.h>
 #include <sys/buf.h>
 #include <sys/socket.h>
 #include <sys/ioctl.h>
 #include <sys/errno.h>
 #include <sys/syslog.h>
 #include <sys/select.h>
 #include <sys/poll.h>
 #include <sys/file.h>
 #include <sys/signalvar.h>
 #include <sys/conf.h>
 #include <sys/kauth.h>
 #include <sys/mutex.h>
 #include <sys/cpu.h>
 #include <sys/device.h>
 #include <sys/errno.h>
 #include <sys/file.h>
 #include <sys/ioctl.h>
 #include <sys/kauth.h>
 #include <sys/mbuf.h>
 #include <sys/module.h>
 #include <sys/mutex.h>
 #include <sys/poll.h>
 #include <sys/proc.h>
 #include <sys/select.h>
 #include <sys/signalvar.h>
 #include <sys/socket.h>
 #include <sys/syslog.h>
 #include <sys/systm.h>
 #include <sys/time.h>
 #include <net/bpf.h>
 #include <net/if.h>
 #include <net/if_types.h>
 #include <net/netisr.h>
 #include <net/route.h>
 #ifdef INET
 #include <netinet/in.h>
 #include <netinet/in_systm.h>
 #include <netinet/in_var.h>
 #include <netinet/ip.h>
 #include <netinet/if_inarp.h>
 #endif
 #include <sys/time.h>
 #include <net/bpf.h>
 #include <net/if_tun.h>
 #include "ioconf.h"
 #define TUNDEBUG	if (tundebug) printf
 int	tundebug = 0;
 extern int ifqmaxlen;
 static LIST_HEAD(, tun_softc) tun_softc_list;
 static LIST_HEAD(, tun_softc) tunz_softc_list;
 static kmutex_t tun_softc_lock;
 @@ -169,51 +165,51 @@ static struct tun_softc *
 tun_find_unit(dev_t dev)
+{
 	struct tun_softc *tp;
 	int unit = minor(dev);
 	mutex_enter(&tun_softc_lock);
 	LIST_FOREACH(tp, &tun_softc_list, tun_list)
 		if (unit == tp->tun_unit)
 			break;
 	if (tp)
 		mutex_enter(&tp->tun_lock);
 	mutex_exit(&tun_softc_lock);
-	return (tp);
+	return tp;
+}
 /*
  * Find zombie driver instance by unit number.
  * Remove tp from list and return it unlocked (if found).
  */
 static struct tun_softc *
 tun_find_zunit(int unit)
+{
 	struct tun_softc *tp;
 	mutex_enter(&tun_softc_lock);
 	LIST_FOREACH(tp, &tunz_softc_list, tun_list)
 		if (unit == tp->tun_unit)
 			break;
 	if (tp)
 		LIST_REMOVE(tp, tun_list);
 	mutex_exit(&tun_softc_lock);
 #ifdef DIAGNOSTIC
 	if (tp != NULL && (tp->tun_flags & (TUN_INITED|TUN_OPEN)) != TUN_OPEN)
 		printf("tun%d: inconsistent flags: %x\n", unit, tp->tun_flags);
 #endif
-	return (tp);
+	return tp;
+}
 static int
 tun_clone_create(struct if_clone *ifc, int unit)
+{
 	struct tun_softc *tp;
 	if ((tp = tun_find_zunit(unit)) == NULL) {
 		/* Allocate a new instance */
 		tp = malloc(sizeof(*tp), M_DEVBUF, M_WAITOK|M_ZERO);
 		tp->tun_unit = unit;
 		mutex_init(&tp->tun_lock, MUTEX_DEFAULT, IPL_NET);
 @@ -224,27 +220,27 @@ tun_clone_create(struct if_clone *ifc, i
 		(void)memset(&tp->tun_if, 0, sizeof(struct ifnet));
+	}
 	if_initname(&tp->tun_if, ifc->ifc_name, unit);
 	tunattach0(tp);
 	tp->tun_flags |= TUN_INITED;
 	tp->tun_osih = softint_establish(SOFTINT_CLOCK, tun_o_softintr, tp);
 	tp->tun_isih = softint_establish(SOFTINT_CLOCK, tun_i_softintr, tp);
 	mutex_enter(&tun_softc_lock);
 	LIST_INSERT_HEAD(&tun_softc_list, tp, tun_list);
 	mutex_exit(&tun_softc_lock);
-	return (0);
+	return 0;
+}
 static void
 tunattach0(struct tun_softc *tp)
+{
 	struct ifnet *ifp;
 	ifp = &tp->tun_if;
 	ifp->if_softc = tp;
 	ifp->if_mtu = TUNMTU;
 	ifp->if_ioctl = tun_ioctl;
 	ifp->if_output = tun_output;
 #ifdef ALTQ
 @@ -300,68 +296,68 @@ tun_clone_destroy(struct ifnet *ifp)
 	bpf_detach(ifp);
 	if_detach(ifp);
 	if (!zombie) {
 		seldestroy(&tp->tun_rsel);
 		seldestroy(&tp->tun_wsel);
 		softint_disestablish(tp->tun_osih);
 		softint_disestablish(tp->tun_isih);
 		mutex_destroy(&tp->tun_lock);
 		free(tp, M_DEVBUF);
+	}
-	return (0);
+	return 0;
+}
 /*
  * tunnel open - must be superuser & the device must be
  * configured in
  */
 static int
 tunopen(dev_t dev, int flag, int mode, struct lwp *l)
+{
 	struct ifnet	*ifp;
 	struct tun_softc *tp;
 	int	error;
 	error = kauth_authorize_network(l->l_cred, KAUTH_NETWORK_INTERFACE_TUN,
 	    KAUTH_REQ_NETWORK_INTERFACE_TUN_ADD, NULL, NULL, NULL);
 	if (error)
-		return (error);
+		return error;
 	tp = tun_find_unit(dev);
 	if (tp == NULL) {
 		(void)tun_clone_create(&tun_cloner, minor(dev));
 		tp = tun_find_unit(dev);
 		if (tp == NULL) {
 			error = ENXIO;
 			goto out_nolock;
+		}
+	}
 	if (tp->tun_flags & TUN_OPEN) {
 		error = EBUSY;
 		goto out;
+	}
 	ifp = &tp->tun_if;
 	tp->tun_flags |= TUN_OPEN;
 	TUNDEBUG("%s: open\n", ifp->if_xname);
 out:
 	mutex_exit(&tp->tun_lock);
 out_nolock:
-	return (error);
+	return error;
+}
 /*
  * tunclose - close the device - mark i/f down & delete
  * routing info
  */
 int
 tunclose(dev_t dev, int flag, int mode,
     struct lwp *l)
+{
 	struct tun_softc *tp;
 	struct ifnet	*ifp;
 @@ -403,27 +399,27 @@ tunclose(dev_t dev, int flag, int mode,
 #if defined(INET) || defined(INET6)
 				if (ifa->ifa_addr->sa_family == AF_INET ||
 				    ifa->ifa_addr->sa_family == AF_INET6) {
 					rtinit(ifa, (int)RTM_DELETE,
 					       tp->tun_flags & TUN_DSTADDR
 							? RTF_HOST
 							: 0);
+				}
 #endif
+			}
+		}
+	}
 out_nolock:
-	return (0);
+	return 0;
+}
 /*
  * Call at splnet().
  */
 static void
 tun_enable(struct tun_softc *tp, const struct ifaddr *ifa)
+{
 	struct ifnet	*ifp = &tp->tun_if;
 	TUNDEBUG("%s: %s\n", __func__, ifp->if_xname);
 	mutex_enter(&tp->tun_lock);
 @@ -517,27 +513,27 @@ tun_ioctl(struct ifnet *ifp, u_long cmd,
 		case AF_INET6:
 			break;
 #endif
 		default:
 			error = EAFNOSUPPORT;
 			break;
+		}
 		break;
 	default:
 		error = ifioctl_common(ifp, cmd, data);
+	}
 	splx(s);
-	return (error);
+	return error;
+}
 /*
  * tun_output - queue packets from higher level ready to put out.
  */
 static int
 tun_output(struct ifnet *ifp, struct mbuf *m0, const struct sockaddr *dst,
     const struct rtentry *rt)
+{
 	struct tun_softc *tp = ifp->if_softc;
 	int		s;
 	int		error;
 #if defined(INET) || defined(INET6)
 @@ -753,27 +749,27 @@ tunioctl(dev_t dev, u_long cmd, void *da
 	case TIOCGPGRP:
 	case FIOGETOWN:
 		error = fgetown(tp->tun_pgid, cmd, data);
 		break;
 	default:
 		error = ENOTTY;
+	}
 out:
 	mutex_exit(&tp->tun_lock);
 out_nolock:
 	splx(s);
-	return (error);
+	return error;
+}
 /*
  * The cdevsw read interface - reads a packet at a time, or at
  * least as much of a packet as can be read.
  */
 int
 tunread(dev_t dev, struct uio *uio, int ioflag)
+{
 	struct tun_softc *tp;
 	struct ifnet	*ifp;
 	struct mbuf	*m, *m0;
 	int		error = 0, len, s, index;
 @@ -839,33 +835,33 @@ tunread(dev_t dev, struct uio *uio, int
 		len = min(uio->uio_resid, m0->m_len);
 		if (len != 0)
 			error = uiomove(mtod(m0, void *), len, uio);
 		m0 = m = m_free(m0);
+	}
 	if (m0) {
 		TUNDEBUG("Dropping mbuf\n");
 		m_freem(m0);
+	}
 	if (error)
 		ifp->if_ierrors++;
-	return (error);
+	return error;
 out:
 	mutex_exit(&tp->tun_lock);
 out_nolock:
 	splx(s);
-	return (error);
+	return error;
+}
 /*
  * the cdevsw write interface - an atomic write is a packet - or else!
  */
 int
 tunwrite(dev_t dev, struct uio *uio, int ioflag)
+{
 	struct tun_softc *tp;
 	struct ifnet	*ifp;
 	struct mbuf	*top, **mp, *m;
 	pktqueue_t	*pktq;
 	struct sockaddr	dst;
 @@ -989,27 +985,27 @@ tunwrite(dev_t dev, struct uio *uio, int
 		ifp->if_collisions++;
 		mutex_exit(&tp->tun_lock);
 		error = ENOBUFS;
 		m_freem(top);
 		goto out_nolock;
+	}
 	ifp->if_ipackets++;
 	ifp->if_ibytes += tlen;
 out:
 	mutex_exit(&tp->tun_lock);
 out_nolock:
 	splx(s);
 out0:
-	return (error);
+	return error;
+}
 #ifdef ALTQ
 /*
  * Start packet transmission on the interface.
  * when the interface queue is rate-limited by ALTQ or TBR,
  * if_start is needed to drain packets from the queue in order
  * to notify readers when outgoing packets become ready.
+ *
  * Should be called at splnet.
  */
 static void
 tunstart(struct ifnet *ifp)
 @@ -1063,60 +1059,60 @@ tunpoll(dev_t dev, int events, struct lw
 			revents |= events & (POLLIN | POLLRDNORM);
 		} else {
 			TUNDEBUG("%s: tunpoll waiting\n", ifp->if_xname);
 			selrecord(l, &tp->tun_rsel);
+		}
+	}
 	if (events & (POLLOUT | POLLWRNORM))
 		revents |= events & (POLLOUT | POLLWRNORM);
 	mutex_exit(&tp->tun_lock);
 out_nolock:
 	splx(s);
-	return (revents);
+	return revents;
+}
 static void
 filt_tunrdetach(struct knote *kn)
+{
 	struct tun_softc *tp = kn->kn_hook;
 	int s;
 	s = splnet();
 	SLIST_REMOVE(&tp->tun_rsel.sel_klist, kn, knote, kn_selnext);
 	splx(s);
+}
 static int
 filt_tunread(struct knote *kn, long hint)
+{
 	struct tun_softc *tp = kn->kn_hook;
 	struct ifnet *ifp = &tp->tun_if;
 	struct mbuf *m;
 	int s;
 	s = splnet();
 	IF_POLL(&ifp->if_snd, m);
 	if (m == NULL) {
 		splx(s);
-		return (0);
+		return 0;
+	}
 	for (kn->kn_data = 0; m != NULL; m = m->m_next)
 		kn->kn_data += m->m_len;
 	splx(s);
-	return (1);
+	return 1;
+}
 static const struct filterops tunread_filtops =
 	{ 1, NULL, filt_tunrdetach, filt_tunread };
 static const struct filterops tun_seltrue_filtops =
 	{ 1, NULL, filt_tunrdetach, filt_seltrue };
 int
 tunkqfilter(dev_t dev, struct knote *kn)
+{
 	struct tun_softc *tp;
 	struct klist *klist;
 @@ -1141,22 +1137,22 @@ tunkqfilter(dev_t dev, struct knote *kn)
 	default:
 		rv = EINVAL;
 		goto out;
+	}
 	kn->kn_hook = tp;
 	SLIST_INSERT_HEAD(klist, kn, kn_selnext);
 out:
 	mutex_exit(&tp->tun_lock);
 out_nolock:
 	splx(s);
-	return (rv);
+	return rv;
+}
 /*
  * Module infrastructure
  */
 #include "if_module.h"
 IF_MODULE(MODULE_CLASS_DRIVER, tun, "")