/*
* Process an ioctl request.
*/
static int
tun_ioctl(struct ifnet *ifp, u_long cmd, void *data)
{
int error = 0, s;
struct tun_softc *tp = (struct tun_softc *)(ifp->if_softc);
struct ifreq *ifr = (struct ifreq *)data;
struct ifaddr *ifa = (struct ifaddr *)data;
s = splnet();
switch (cmd) {
case SIOCINITIFADDR:
tuninit(tp);
ifa->ifa_rtrequest = p2p_rtrequest;
TUNDEBUG("%s: address set\n", ifp->if_xname);
break;
case SIOCSIFBRDADDR:
TUNDEBUG("%s: broadcast address set\n", ifp->if_xname);
break;
case SIOCSIFMTU:
if (ifr->ifr_mtu > TUNMTU || ifr->ifr_mtu < 576) {
error = EINVAL;
break;
}
TUNDEBUG("%s: interface mtu set\n", ifp->if_xname);
if ((error = ifioctl_common(ifp, cmd, data)) == ENETRESET)
error = 0;
break;
case SIOCADDMULTI:
case SIOCDELMULTI:
if (ifr == NULL) {
error = EAFNOSUPPORT; /* XXX */
break;
}
switch (ifreq_getaddr(cmd, ifr)->sa_family) {
#ifdef INET
case AF_INET:
break;
#endif
#ifdef INET6
case AF_INET6:
break;
#endif
default:
error = EAFNOSUPPORT;
break;
}
break;
default:
error = ifioctl_common(ifp, cmd, data);
}
splx(s);
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)
{
int s;
struct tun_softc *tp;
struct ifnet *ifp;
s = splnet();
if ((tp = tun_find_zunit(minor(dev))) != NULL) {
/* interface was "destroyed" before the close */
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);
goto out_nolock;
}
if ((tp = tun_find_unit(dev)) == NULL)
goto out_nolock;
ifp = &tp->tun_if;
tp->tun_flags &= ~TUN_OPEN;
tp->tun_pgid = 0;
selnotify(&tp->tun_rsel, 0, 0);
TUNDEBUG ("%s: closed\n", ifp->if_xname);
mutex_exit(&tp->tun_lock);
/*
* junk all pending output
*/
IFQ_PURGE(&ifp->if_snd);
if (ifp->if_flags & IFF_UP) {
if_down(ifp);
if (ifp->if_flags & IFF_RUNNING) {
/* find internet addresses and delete routes */
struct ifaddr *ifa;
IFADDR_FOREACH(ifa, ifp) {
#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
}
}
}
/*
* tunoutput - queue packets from higher level ready to put out.
*/
static int
tunoutput(
struct ifnet *ifp,
struct mbuf *m0,
struct sockaddr *dst,
struct rtentry *rt)
{
struct tun_softc *tp = ifp->if_softc;
u_short cached_tun_flags;
int error;
TUNDEBUG (ifp, "tunoutput\n");
#ifdef MAC
error = mac_check_ifnet_transmit(ifp, m0);
if (error) {
m_freem(m0);
return (error);
}
#endif
/* Could be unlocked read? */
mtx_lock(&tp->tun_mtx);
cached_tun_flags = tp->tun_flags;
mtx_unlock(&tp->tun_mtx);
if ((cached_tun_flags & TUN_READY) != TUN_READY) {
TUNDEBUG (ifp, "not ready 0%o\n", tp->tun_flags);
m_freem (m0);
return (EHOSTDOWN);
}
if ((ifp->if_flags & IFF_UP) != IFF_UP) {
m_freem (m0);
return (EHOSTDOWN);
}
/* BPF write needs to be handled specially */
if (dst->sa_family == AF_UNSPEC) {
dst->sa_family = *(mtod(m0, int *));
m0->m_len -= sizeof(int);
m0->m_pkthdr.len -= sizeof(int);
m0->m_data += sizeof(int);
}
/*
* Process an ioctl request.
*/
static int
tunifioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
{
struct ifreq *ifr = (struct ifreq *)data;
struct tun_softc *tp = ifp->if_softc;
struct ifstat *ifs;
int error = 0, s;
s = splimp();
switch(cmd) {
case SIOCGIFSTATUS:
ifs = (struct ifstat *)data;
mtx_lock(&tp->tun_mtx);
if (tp->tun_pid)
sprintf(ifs->ascii + strlen(ifs->ascii),
"\tOpened by PID %d\n", tp->tun_pid);
mtx_unlock(&tp->tun_mtx);
break;
case SIOCSIFADDR:
error = tuninit(ifp);
TUNDEBUG(ifp, "address set, error=%d\n", error);
break;
case SIOCSIFDSTADDR:
error = tuninit(ifp);
TUNDEBUG(ifp, "destination address set, error=%d\n", error);
break;
case SIOCSIFMTU:
ifp->if_mtu = ifr->ifr_mtu;
TUNDEBUG(ifp, "mtu set\n");
break;
case SIOCSIFFLAGS:
case SIOCADDMULTI:
case SIOCDELMULTI:
break;
default:
error = EINVAL;
}
splx(s);
return (error);
}
/*
* Call at splnet().
*/
static void
tuninit(struct tun_softc *tp)
{
struct ifnet *ifp = &tp->tun_if;
struct ifaddr *ifa;
TUNDEBUG("%s: tuninit\n", ifp->if_xname);
mutex_enter(&tp->tun_lock);
ifp->if_flags |= IFF_UP | IFF_RUNNING;
tp->tun_flags &= ~(TUN_IASET|TUN_DSTADDR);
IFADDR_FOREACH(ifa, ifp) {
#ifdef INET
if (ifa->ifa_addr->sa_family == AF_INET) {
struct sockaddr_in *sin;
sin = satosin(ifa->ifa_addr);
if (sin && sin->sin_addr.s_addr)
tp->tun_flags |= TUN_IASET;
if (ifp->if_flags & IFF_POINTOPOINT) {
sin = satosin(ifa->ifa_dstaddr);
if (sin && sin->sin_addr.s_addr)
tp->tun_flags |= TUN_DSTADDR;
}
}
#endif
#ifdef INET6
if (ifa->ifa_addr->sa_family == AF_INET6) {
struct sockaddr_in6 *sin;
sin = (struct sockaddr_in6 *)ifa->ifa_addr;
if (!IN6_IS_ADDR_UNSPECIFIED(&sin->sin6_addr))
tp->tun_flags |= TUN_IASET;
if (ifp->if_flags & IFF_POINTOPOINT) {
sin = (struct sockaddr_in6 *)ifa->ifa_dstaddr;
if (sin &&
!IN6_IS_ADDR_UNSPECIFIED(&sin->sin6_addr))
tp->tun_flags |= TUN_DSTADDR;
} else
tp->tun_flags &= ~TUN_DSTADDR;
}
#endif /* INET6 */
}
mutex_exit(&tp->tun_lock);
}
/*
* tunclose - close the device - mark i/f down & delete
* routing info
*/
static int
tunclose(struct cdev *dev, int foo, int bar, struct thread *td)
{
struct tun_softc *tp;
struct ifnet *ifp;
int s;
tp = dev->si_drv1;
ifp = &tp->tun_if;
mtx_lock(&tp->tun_mtx);
tp->tun_flags &= ~TUN_OPEN;
tp->tun_pid = 0;
/*
* junk all pending output
*/
s = splimp();
IFQ_PURGE(&ifp->if_snd);
splx(s);
mtx_unlock(&tp->tun_mtx);
if (ifp->if_flags & IFF_UP) {
s = splimp();
if_down(ifp);
splx(s);
}
if (ifp->if_flags & IFF_RUNNING) {
struct ifaddr *ifa;
s = splimp();
/* find internet addresses and delete routes */
TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link)
if (ifa->ifa_addr->sa_family == AF_INET)
/* Unlocked read. */
rtinit(ifa, (int)RTM_DELETE,
tp->tun_flags & TUN_DSTADDR ? RTF_HOST : 0);
ifp->if_flags &= ~IFF_RUNNING;
splx(s);
}
funsetown(&tp->tun_sigio);
selwakeuppri(&tp->tun_rsel, PZERO + 1);
TUNDEBUG (ifp, "closed\n");
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 s, 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);
s = splnet();
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:
splx(s);
return (error);
}
static int
tuninit(struct ifnet *ifp)
{
struct tun_softc *tp = ifp->if_softc;
struct ifaddr *ifa;
int error = 0;
TUNDEBUG(ifp, "tuninit\n");
ifp->if_flags |= IFF_UP | IFF_RUNNING;
getmicrotime(&ifp->if_lastchange);
for (ifa = TAILQ_FIRST(&ifp->if_addrhead); ifa;
ifa = TAILQ_NEXT(ifa, ifa_link)) {
if (ifa->ifa_addr == NULL)
error = EFAULT;
/* XXX: Should maybe return straight off? */
else {
#ifdef INET
if (ifa->ifa_addr->sa_family == AF_INET) {
struct sockaddr_in *si;
si = (struct sockaddr_in *)ifa->ifa_addr;
mtx_lock(&tp->tun_mtx);
if (si->sin_addr.s_addr)
tp->tun_flags |= TUN_IASET;
si = (struct sockaddr_in *)ifa->ifa_dstaddr;
if (si && si->sin_addr.s_addr)
tp->tun_flags |= TUN_DSTADDR;
mtx_unlock(&tp->tun_mtx);
}
#endif
}
}
return (error);
}
static int
tunopen(struct cdev *dev, int flag, int mode, struct thread *td)
{
struct ifnet *ifp;
struct tun_softc *tp;
/*
* XXXRW: Non-atomic test and set of dev->si_drv1 requires
* synchronization.
*/
tp = dev->si_drv1;
if (!tp) {
tuncreate(dev);
tp = dev->si_drv1;
}
/*
* XXXRW: This use of tun_pid is subject to error due to the
* fact that a reference to the tunnel can live beyond the
* death of the process that created it. Can we replace this
* with a simple busy flag?
*/
mtx_lock(&tp->tun_mtx);
if (tp->tun_pid != 0 && tp->tun_pid != td->td_proc->p_pid) {
mtx_unlock(&tp->tun_mtx);
return (EBUSY);
}
tp->tun_pid = td->td_proc->p_pid;
tp->tun_flags |= TUN_OPEN;
mtx_unlock(&tp->tun_mtx);
ifp = &tp->tun_if;
TUNDEBUG(ifp, "open\n");
return (0);
}
/*
* 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,
struct rtentry *rt)
{
struct tun_softc *tp = ifp->if_softc;
int s;
int error;
#if defined(INET) || defined(INET6)
int mlen;
uint32_t *af;
#endif
s = splnet();
mutex_enter(&tp->tun_lock);
TUNDEBUG ("%s: tun_output\n", ifp->if_xname);
if ((tp->tun_flags & TUN_READY) != TUN_READY) {
TUNDEBUG ("%s: not ready 0%o\n", ifp->if_xname,
tp->tun_flags);
error = EHOSTDOWN;
goto out;
}
/*
* if the queueing discipline needs packet classification,
* do it before prepending link headers.
*/
IFQ_CLASSIFY(&ifp->if_snd, m0, dst->sa_family);
bpf_mtap_af(ifp, dst->sa_family, m0);
switch(dst->sa_family) {
#ifdef INET6
case AF_INET6:
#endif
#ifdef INET
case AF_INET:
#endif
#if defined(INET) || defined(INET6)
if (tp->tun_flags & TUN_PREPADDR) {
/* Simple link-layer header */
M_PREPEND(m0, dst->sa_len, M_DONTWAIT);
if (m0 == NULL) {
IF_DROP(&ifp->if_snd);
error = ENOBUFS;
goto out;
}
bcopy(dst, mtod(m0, char *), dst->sa_len);
}
if (tp->tun_flags & TUN_IFHEAD) {
/* Prepend the address family */
M_PREPEND(m0, sizeof(*af), M_DONTWAIT);
if (m0 == NULL) {
IF_DROP(&ifp->if_snd);
error = ENOBUFS;
goto out;
}
af = mtod(m0,uint32_t *);
*af = htonl(dst->sa_family);
} else {
